@grafana/plugin-e2e 0.12.0 → 0.12.2

package/dist/fixtures/annotationEditPage.d.ts

@@ -0,0 +1,7 @@
+import { TestFixture } from '@playwright/test';
+import { PluginFixture, PluginOptions } from '../api';
+import { AnnotationEditPage } from '../models';
+import { PlaywrightCombinedArgs } from './types';
+type AnnotationEditPageFixture = TestFixture<AnnotationEditPage, PluginFixture & PluginOptions & PlaywrightCombinedArgs>;
+declare const annotationEditPage: AnnotationEditPageFixture;
+export default annotationEditPage;

package/dist/fixtures/commands/createDataSource.d.ts

@@ -0,0 +1,8 @@
+import { APIRequestContext, TestFixture } from '@playwright/test';
+import { PluginFixture, PluginOptions } from '../../api';
+import { CreateDataSourceArgs, DataSource } from '../../types';
+import { PlaywrightCombinedArgs } from '../types';
+type CreateDataSourceViaAPIFixture = TestFixture<(args: CreateDataSourceArgs) => Promise<DataSource>, PluginFixture & PluginOptions & PlaywrightCombinedArgs>;
+export declare const createDataSourceViaAPI: (request: APIRequestContext, datasource: CreateDataSourceArgs) => Promise<DataSource>;
+declare const createDataSource: CreateDataSourceViaAPIFixture;
+export default createDataSource;

package/dist/fixtures/commands/createDataSourceConfigPage.d.ts

@@ -0,0 +1,8 @@
+import { TestFixture } from '@playwright/test';
+import { PluginFixture, PluginOptions } from '../../api';
+import { CreateDataSourcePageArgs } from '../../types';
+import { PlaywrightCombinedArgs } from '../types';
+import { DataSourceConfigPage } from '../../models';
+type CreateDataSourceConfigPageFixture = TestFixture<(args: CreateDataSourcePageArgs) => Promise<DataSourceConfigPage>, PluginFixture & PluginOptions & PlaywrightCombinedArgs>;
+declare const createDataSourceConfigPage: CreateDataSourceConfigPageFixture;
+export default createDataSourceConfigPage;

package/dist/fixtures/commands/login.d.ts

@@ -0,0 +1,6 @@
+import { TestFixture } from '@playwright/test';
+import { PluginFixture, PluginOptions } from '../../api';
+import { PlaywrightCombinedArgs } from '../types';
+type LoginFixture = TestFixture<() => Promise<void>, PluginFixture & PluginOptions & PlaywrightCombinedArgs>;
+declare const login: LoginFixture;
+export default login;

package/dist/fixtures/commands/readProvision.d.ts

@@ -0,0 +1,7 @@
+import { TestFixture } from '@playwright/test';
+import { PluginFixture, PluginOptions } from '../../api';
+import { ReadProvisionArgs } from '../../types';
+import { PlaywrightCombinedArgs } from '../types';
+type ReadProvisionFixture = TestFixture<(<T = any>(args: ReadProvisionArgs) => Promise<T>), PluginFixture & PluginOptions & PlaywrightCombinedArgs>;
+declare const readProvision: ReadProvisionFixture;
+export default readProvision;

package/dist/fixtures/explorePage.d.ts

@@ -0,0 +1,7 @@
+import { TestFixture } from '@playwright/test';
+import { PluginFixture, PluginOptions } from '../api';
+import { ExplorePage } from '../models/ExplorePage';
+import { PlaywrightCombinedArgs } from './types';
+type ExplorePageFixture = TestFixture<ExplorePage, PluginFixture & PluginOptions & PlaywrightCombinedArgs>;
+declare const explorePage: ExplorePageFixture;
+export default explorePage;

package/dist/fixtures/grafanaVersion.d.ts

@@ -0,0 +1,4 @@
+import { PlaywrightTestArgs, TestFixture } from '@playwright/test';
+type GrafanaVersion = TestFixture<string, PlaywrightTestArgs>;
+declare const grafanaVersion: GrafanaVersion;
+export default grafanaVersion;

package/dist/fixtures/index.d.ts

@@ -0,0 +1,16 @@
+declare const fixtures: {
+    selectors: (args: import("..").PluginFixture & import("..").PluginOptions & import("playwright/test").PlaywrightTestArgs & import("playwright/test").PlaywrightTestOptions & import("playwright/test").PlaywrightWorkerArgs & import("playwright/test").PlaywrightWorkerOptions, use: (r: import("..").E2ESelectors) => Promise<void>, testInfo: import("playwright/test").TestInfo) => any;
+    grafanaVersion: (args: import("playwright/test").PlaywrightTestArgs, use: (r: string) => Promise<void>, testInfo: import("playwright/test").TestInfo) => any;
+    login: (args: import("..").PluginFixture & import("..").PluginOptions & import("playwright/test").PlaywrightTestArgs & import("playwright/test").PlaywrightTestOptions & import("playwright/test").PlaywrightWorkerArgs & import("playwright/test").PlaywrightWorkerOptions, use: (r: () => Promise<void>) => Promise<void>, testInfo: import("playwright/test").TestInfo) => any;
+    createDataSourceConfigPage: (args: import("..").PluginFixture & import("..").PluginOptions & import("playwright/test").PlaywrightTestArgs & import("playwright/test").PlaywrightTestOptions & import("playwright/test").PlaywrightWorkerArgs & import("playwright/test").PlaywrightWorkerOptions, use: (r: (args: import("../types").CreateDataSourcePageArgs) => Promise<import("..").DataSourceConfigPage>) => Promise<void>, testInfo: import("playwright/test").TestInfo) => any;
+    page: (args: import("..").PluginFixture & import("..").PluginOptions & import("playwright/test").PlaywrightTestArgs & import("playwright/test").PlaywrightTestOptions & import("playwright/test").PlaywrightWorkerArgs & import("playwright/test").PlaywrightWorkerOptions, use: (r: import("playwright-core").Page) => Promise<void>, testInfo: import("playwright/test").TestInfo) => any;
+    newDashboardPage: (args: import("..").PluginFixture & import("..").PluginOptions & import("playwright/test").PlaywrightTestArgs & import("playwright/test").PlaywrightTestOptions & import("playwright/test").PlaywrightWorkerArgs & import("playwright/test").PlaywrightWorkerOptions, use: (r: import("..").DashboardPage) => Promise<void>, testInfo: import("playwright/test").TestInfo) => any;
+    panelEditPage: (args: import("..").PluginFixture & import("..").PluginOptions & import("playwright/test").PlaywrightTestArgs & import("playwright/test").PlaywrightTestOptions & import("playwright/test").PlaywrightWorkerArgs & import("playwright/test").PlaywrightWorkerOptions, use: (r: import("..").PanelEditPage) => Promise<void>, testInfo: import("playwright/test").TestInfo) => any;
+    variableEditPage: (args: import("..").PluginFixture & import("..").PluginOptions & import("playwright/test").PlaywrightTestArgs & import("playwright/test").PlaywrightTestOptions & import("playwright/test").PlaywrightWorkerArgs & import("playwright/test").PlaywrightWorkerOptions, use: (r: import("..").VariableEditPage) => Promise<void>, testInfo: import("playwright/test").TestInfo) => any;
+    annotationEditPage: (args: import("..").PluginFixture & import("..").PluginOptions & import("playwright/test").PlaywrightTestArgs & import("playwright/test").PlaywrightTestOptions & import("playwright/test").PlaywrightWorkerArgs & import("playwright/test").PlaywrightWorkerOptions, use: (r: import("..").AnnotationEditPage) => Promise<void>, testInfo: import("playwright/test").TestInfo) => any;
+    explorePage: (args: import("..").PluginFixture & import("..").PluginOptions & import("playwright/test").PlaywrightTestArgs & import("playwright/test").PlaywrightTestOptions & import("playwright/test").PlaywrightWorkerArgs & import("playwright/test").PlaywrightWorkerOptions, use: (r: import("../models/ExplorePage").ExplorePage) => Promise<void>, testInfo: import("playwright/test").TestInfo) => any;
+    createDataSource: (args: import("..").PluginFixture & import("..").PluginOptions & import("playwright/test").PlaywrightTestArgs & import("playwright/test").PlaywrightTestOptions & import("playwright/test").PlaywrightWorkerArgs & import("playwright/test").PlaywrightWorkerOptions, use: (r: (args: import("../types").CreateDataSourceArgs) => Promise<import("../types").DataSource<any>>) => Promise<void>, testInfo: import("playwright/test").TestInfo) => any;
+    readProvision: (args: import("..").PluginFixture & import("..").PluginOptions & import("playwright/test").PlaywrightTestArgs & import("playwright/test").PlaywrightTestOptions & import("playwright/test").PlaywrightWorkerArgs & import("playwright/test").PlaywrightWorkerOptions, use: (r: <T = any>(args: import("../types").ReadProvisionArgs) => Promise<T>) => Promise<void>, testInfo: import("playwright/test").TestInfo) => any;
+    isFeatureToggleEnabled: (args: import("..").PluginFixture & import("..").PluginOptions & import("playwright/test").PlaywrightTestArgs & import("playwright/test").PlaywrightTestOptions & import("playwright/test").PlaywrightWorkerArgs & import("playwright/test").PlaywrightWorkerOptions, use: (r: <T_1 = object>(featureToggle: keyof T_1) => Promise<boolean>) => Promise<void>, testInfo: import("playwright/test").TestInfo) => any;
+};
+export default fixtures;

package/dist/fixtures/isFeatureToggleEnabled.d.ts

@@ -0,0 +1,6 @@
+import { TestFixture } from '@playwright/test';
+import { PluginFixture, PluginOptions } from '../api';
+import { PlaywrightCombinedArgs } from './types';
+type FeatureToggleFixture = TestFixture<(<T = object>(featureToggle: keyof T) => Promise<boolean>), PluginFixture & PluginOptions & PlaywrightCombinedArgs>;
+declare const isFeatureToggleEnabled: FeatureToggleFixture;
+export default isFeatureToggleEnabled;

package/dist/fixtures/newDashboardPage.d.ts

@@ -0,0 +1,7 @@
+import { TestFixture } from '@playwright/test';
+import { PluginFixture, PluginOptions } from '../api';
+import { DashboardPage } from '../models';
+import { PlaywrightCombinedArgs } from './types';
+type NewDashboardPageFixture = TestFixture<DashboardPage, PluginFixture & PluginOptions & PlaywrightCombinedArgs>;
+declare const newDashboardPage: NewDashboardPageFixture;
+export default newDashboardPage;

package/dist/fixtures/page.d.ts

@@ -0,0 +1,17 @@
+import { TestFixture, Page } from '@playwright/test';
+import { PluginFixture, PluginOptions } from '../api';
+import { PlaywrightCombinedArgs } from './types';
+type PageFixture = TestFixture<Page, PluginFixture & PluginOptions & PlaywrightCombinedArgs>;
+/**
+ * This fixture ensures the feature toggles defined in the Playwright config are being used in Grafana frontend.
+ * If Grafana version >= 10.1.0, feature toggles are read from to the 'grafana.featureToggles' key in the browser's localStorage.
+ * Otherwise, feature toggles are added directly to the window.grafanaBootData.settings.featureToggles object.
+ *
+ * page.addInitScript adds a script which would be evaluated in one of the following scenarios:
+ * - Whenever the page is navigated.
+ * - Whenever the child frame is attached or navigated. In this case, the script is evaluated in the context of the
+ *   newly attached frame.
+ * The script is evaluated after the document was created but before any of its scripts were run.
+ */
+declare const page: PageFixture;
+export default page;

package/dist/fixtures/panelEditPage.d.ts

@@ -0,0 +1,7 @@
+import { TestFixture } from '@playwright/test';
+import { PluginFixture, PluginOptions } from '../api';
+import { PanelEditPage } from '../models';
+import { PlaywrightCombinedArgs } from './types';
+type PanelEditPageFixture = TestFixture<PanelEditPage, PluginFixture & PluginOptions & PlaywrightCombinedArgs>;
+declare const panelEditPage: PanelEditPageFixture;
+export default panelEditPage;

package/dist/fixtures/scripts/overrideFeatureToggles.d.ts

@@ -0,0 +1 @@
+export function overrideFeatureToggles(featureToggles: any): void;

package/dist/fixtures/scripts/overrideFeatureToggles.js

@@ -3,9 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.overrideFeatureToggles = void 0;
 // this script is evaluated in the browser context, so we cannot use typescript
 const overrideFeatureToggles = (featureToggles) => {
-    const timeout = 5;
+    const timeout = 1;
     const waitForGrafanaBootData = (cb) => {
-        if (window.grafanaBootData) {
+        if (window?.grafanaBootData?.settings?.featureToggles) {
             cb();
         }
         else {
@@ -14,7 +14,7 @@ const overrideFeatureToggles = (featureToggles) => {
     };
     // wait for Grafana boot data to be added to the window object
     waitForGrafanaBootData(() => {
-        const version = window?.grafanaBootData?.settings?.buildInfo?.version;
+        console.log('@grafana/plugin-e2e: setting the following feature toggles', featureToggles);
         // override feature toggles with the ones provided by the test
         window.grafanaBootData.settings.featureToggles = {
             ...window.grafanaBootData.settings.featureToggles,

package/dist/fixtures/selectors.d.ts

@@ -0,0 +1,7 @@
+import { TestFixture } from '@playwright/test';
+import { PluginFixture, PluginOptions } from '../api';
+import { E2ESelectors } from '../e2e-selectors';
+import { PlaywrightCombinedArgs } from './types';
+type SelectorFixture = TestFixture<E2ESelectors, PluginFixture & PluginOptions & PlaywrightCombinedArgs>;
+declare const selectors: SelectorFixture;
+export default selectors;

package/dist/fixtures/types.d.ts

@@ -0,0 +1,2 @@
+import { PlaywrightTestArgs, PlaywrightTestOptions, PlaywrightWorkerArgs, PlaywrightWorkerOptions } from '@playwright/test';
+export type PlaywrightCombinedArgs = PlaywrightTestArgs & PlaywrightTestOptions & PlaywrightWorkerArgs & PlaywrightWorkerOptions;

package/dist/fixtures/variableEditPage.d.ts

@@ -0,0 +1,7 @@
+import { TestFixture } from '@playwright/test';
+import { PluginFixture, PluginOptions } from '../api';
+import { VariableEditPage } from '../models';
+import { PlaywrightCombinedArgs } from './types';
+type VariableEditPageFixture = TestFixture<VariableEditPage, PluginFixture & PluginOptions & PlaywrightCombinedArgs>;
+declare const variableEditPage: VariableEditPageFixture;
+export default variableEditPage;

package/dist/index.d.ts

@@ -0,0 +1,35 @@
+import { GrafanaPage, VariableEditPage } from './models';
+import { AlertPageOptions, AlertVariant, ContainTextOptions } from './types';
+export { expect, test, type PluginFixture, type PluginOptions } from './api';
+export * from './e2e-selectors';
+export * from './fixtures';
+export * from './models';
+declare global {
+    interface Window {
+        grafanaBootData: {
+            settings: {
+                featureToggles: Record<string, boolean>;
+            };
+        };
+    }
+    namespace PlaywrightTest {
+        const r: unique symbol;
+        const t: unique symbol;
+        interface Matchers<R, T> {
+            [r]: R;
+            [t]: T;
+            /**
+             * Await the response of a Playwright request and asserts the response was successful (status in the range 200-299).
+             */
+            toBeOK(this: Matchers<unknown, Promise<Response>>): R;
+            /**
+             * Asserts that preview text elements are displayed on the Variable Edit Page. You should make sure any variable queries are completed before calling this matcher.
+             */
+            toDisplayPreviews(this: Matchers<unknown, VariableEditPage>, previewTexts: Array<string | RegExp>, options: ContainTextOptions): R;
+            /**
+             * Asserts that a GrafanaPage contains an alert with the specified severity. Use the options to specify the timeout and to filter the alerts.
+             */
+            toHaveAlert(this: Matchers<unknown, GrafanaPage>, severity: AlertVariant, options?: AlertPageOptions): R;
+        }
+    }
+}

package/dist/matchers/index.d.ts

@@ -0,0 +1,25 @@
+declare const _default: {
+    toBeOK: (request: Promise<import("playwright-core").Response>) => Promise<{
+        message: () => string;
+        pass: boolean;
+        actual: number;
+    } | {
+        message: () => string;
+        pass: boolean;
+        actual: undefined;
+    }>;
+    toDisplayPreviews: (variableEditPage: import("..").VariableEditPage, previewTexts: (string | RegExp)[], options?: import("../types").ContainTextOptions | undefined) => Promise<{
+        pass: boolean;
+        actual: boolean;
+        message: () => string;
+    } | {
+        message: () => string;
+        pass: boolean;
+        actual: undefined;
+    }>;
+    toHaveAlert: (grafanaPage: import("..").GrafanaPage, severity: import("./toHaveAlert").AlertVariant, options?: import("../types").AlertPageOptions | undefined) => Promise<{
+        message: () => any;
+        pass: boolean;
+    }>;
+};
+export default _default;

package/dist/matchers/toBeOK.d.ts

@@ -0,0 +1,11 @@
+import { Response } from '@playwright/test';
+declare const toBeOK: (request: Promise<Response>) => Promise<{
+    message: () => string;
+    pass: boolean;
+    actual: number;
+} | {
+    message: () => string;
+    pass: boolean;
+    actual: undefined;
+}>;
+export default toBeOK;

package/dist/matchers/toDisplayPreviews.d.ts

@@ -0,0 +1,12 @@
+import { VariableEditPage } from '../models';
+import { ContainTextOptions } from '../types';
+declare const toDisplayPreviews: (variableEditPage: VariableEditPage, previewTexts: Array<string | RegExp>, options?: ContainTextOptions) => Promise<{
+    pass: boolean;
+    actual: boolean;
+    message: () => string;
+} | {
+    message: () => string;
+    pass: boolean;
+    actual: undefined;
+}>;
+export default toDisplayPreviews;

package/dist/matchers/toHaveAlert.d.ts

@@ -0,0 +1,8 @@
+import { GrafanaPage } from '../models';
+import { AlertPageOptions } from '../types';
+export type AlertVariant = 'success' | 'warning' | 'error' | 'info';
+declare const toHaveAlert: (grafanaPage: GrafanaPage, severity: AlertVariant, options?: AlertPageOptions) => Promise<{
+    message: () => any;
+    pass: boolean;
+}>;
+export default toHaveAlert;

package/dist/matchers/utils.d.ts

@@ -0,0 +1 @@
+export declare const getMessage: (expected: string, received: string) => string;

package/dist/models/AnnotationEditPage.d.ts

@@ -0,0 +1,18 @@
+import { DataSourcePicker } from './DataSourcePicker';
+import { DashboardEditViewArgs, NavigateOptions, PluginTestCtx, RequestOptions } from '../types';
+import { GrafanaPage } from './GrafanaPage';
+export declare class AnnotationEditPage extends GrafanaPage {
+    readonly ctx: PluginTestCtx;
+    readonly args: DashboardEditViewArgs<string>;
+    datasource: DataSourcePicker;
+    constructor(ctx: PluginTestCtx, args: DashboardEditViewArgs<string>);
+    /**
+     * Navigates to the annotation edit page. If a dashboard uid was not provided, it's assumed that it's a new dashboard.
+     */
+    goto(options?: NavigateOptions): Promise<void>;
+    /**
+     * Executes the annotation query defined in the annotation page and returns the response promise
+     * @param options - Optional. RequestOptions to pass to waitForResponse
+     */
+    runQuery(options?: RequestOptions): Promise<import("playwright-core").Response>;
+}

package/dist/models/AnnotationPage.d.ts

@@ -0,0 +1,16 @@
+import { DashboardPageArgs, NavigateOptions, PluginTestCtx } from '../types';
+import { AnnotationEditPage } from './AnnotationEditPage';
+import { GrafanaPage } from './GrafanaPage';
+export declare class AnnotationPage extends GrafanaPage {
+    readonly ctx: PluginTestCtx;
+    readonly dashboard?: DashboardPageArgs | undefined;
+    constructor(ctx: PluginTestCtx, dashboard?: DashboardPageArgs | undefined);
+    /**
+     * Navigates to the annotation list page. If a dashboard uid was not provided, it's assumed that it's a new dashboard.
+     */
+    goto(options?: NavigateOptions): Promise<void>;
+    /**
+     * Clicks the add new annotation button and returns the annotation edit page
+     */
+    clickAddNew(): Promise<AnnotationEditPage>;
+}

package/dist/models/DashboardPage.d.ts

@@ -0,0 +1,33 @@
+import { DashboardPageArgs, NavigateOptions, PluginTestCtx } from '../types';
+import { GrafanaPage } from './GrafanaPage';
+import { PanelEditPage } from './PanelEditPage';
+import { TimeRange } from './TimeRange';
+export declare class DashboardPage extends GrafanaPage {
+    readonly ctx: PluginTestCtx;
+    readonly dashboard?: DashboardPageArgs | undefined;
+    dataSourcePicker: any;
+    timeRange: TimeRange;
+    constructor(ctx: PluginTestCtx, dashboard?: DashboardPageArgs | undefined);
+    /**
+     * Navigates to the dashboard page. If a dashboard uid was not provided, it's assumed that it's a new dashboard.
+     */
+    goto(options?: NavigateOptions): Promise<void>;
+    /**
+     * Navigates to the panel edit page for the given panel id
+     *
+     * If the panel id does not exist in the dashboard, Grafana will redirect to the dashboard page
+     */
+    gotoPanelEditPage(panelId: string): Promise<PanelEditPage>;
+    /**
+     * Clicks the buttons to add a new panel and returns the panel edit page for the new panel
+     */
+    addPanel(): Promise<PanelEditPage>;
+    /**
+     * Deletes the dashboard
+     */
+    deleteDashboard(): Promise<void>;
+    /**
+     * Clicks the run button in the refresh picker to refresh the dashboard
+     */
+    refreshDashboard(): Promise<void>;
+}

package/dist/models/DataSourceConfigPage.d.ts

@@ -0,0 +1,23 @@
+import { DataSource, NavigateOptions, PluginTestCtx, TriggerQueryOptions } from '../types';
+import { GrafanaPage } from './GrafanaPage';
+export declare class DataSourceConfigPage extends GrafanaPage {
+    private datasource;
+    constructor(ctx: PluginTestCtx, datasource: DataSource);
+    deleteDataSource(): Promise<void>;
+    /**
+     * Navigates to the datasource edit page for an existing datasource
+     */
+    goto(options?: NavigateOptions): Promise<void>;
+    /**
+     * Mocks the response of the datasource health check call
+     * @param json the json response to return
+     * @param status the HTTP status code to return. Defaults to 200
+     */
+    mockHealthCheckResponse<T = any>(json: T, status?: number): Promise<void>;
+    /**
+     * Clicks the save and test button and waits for the response
+     *
+     * Optionally, you can skip waiting for the response by passing in { skipWaitForResponse: true } as the options parameter
+     */
+    saveAndTest(options?: TriggerQueryOptions): Promise<void | import("playwright-core").Response>;
+}

package/dist/models/DataSourcePicker.d.ts

@@ -0,0 +1,9 @@
+import { PluginTestCtx } from '../types';
+import { GrafanaPage } from './GrafanaPage';
+export declare class DataSourcePicker extends GrafanaPage {
+    constructor(ctx: PluginTestCtx);
+    /**
+     * Sets the data source picker to the provided name
+     */
+    set(name: string): Promise<void>;
+}

package/dist/models/ExplorePage.d.ts

@@ -0,0 +1,26 @@
+import { Locator } from '@playwright/test';
+import { NavigateOptions, PluginTestCtx, RequestOptions } from '../types';
+import { DataSourcePicker } from './DataSourcePicker';
+import { GrafanaPage } from './GrafanaPage';
+import { Panel } from './Panel';
+export declare class ExplorePage extends GrafanaPage {
+    datasource: DataSourcePicker;
+    timeRange: any;
+    timeSeriesPanel: Panel;
+    logsPanel: Panel;
+    tablePanel: Panel;
+    constructor(ctx: PluginTestCtx);
+    private getPanelLocators;
+    /**
+     * Navigates to the explore page.
+     */
+    goto(options?: NavigateOptions): Promise<void>;
+    /**
+     * Returns the locator for the query editor row with the given refId
+     */
+    getQueryEditorRow(refId: string): Locator;
+    /**
+     * Clicks the "Run Query" button in the refresh picker to run the query. Returns the response promise for the data query
+     */
+    runQuery(options?: RequestOptions): Promise<import("@playwright/test").Response>;
+}

package/dist/models/GrafanaPage.d.ts

@@ -0,0 +1,43 @@
+import { Locator, Request, Response } from '@playwright/test';
+import { GetByTestIdOrAriaLabelOptions, NavigateOptions, PluginTestCtx } from '../types';
+/**
+ * Base class for all Grafana pages.
+ *
+ * Exposes methods for locating Grafana specific elements on the page
+ */
+export declare abstract class GrafanaPage {
+    readonly ctx: PluginTestCtx;
+    constructor(ctx: PluginTestCtx);
+    protected navigate(url: string, options?: NavigateOptions): Promise<void>;
+    /**
+     * Get a locator for a Grafana element by data-testid or aria-label
+     * @param selector the data-testid or aria-label of the element
+     * @param root optional root locator to search within. If no locator is provided, the page will be used
+     */
+    getByTestIdOrAriaLabel(selector: string, options?: GetByTestIdOrAriaLabelOptions): Locator;
+    /**
+     * Mocks the response of the datasource query call
+     * @param json the json response to return
+     * @param status the HTTP status code to return. Defaults to 200
+     */
+    mockQueryDataResponse<T = any>(json: T, status?: number): Promise<void>;
+    /**
+     * Mocks the response of the datasource resource request
+     * @param path the path of the resource to mock
+     * @param json the json response to return
+     * @param status the HTTP status code to return. Defaults to 200
+     */
+    mockResourceResponse<T = any>(path: string, json: T, status?: number): Promise<void>;
+    /**
+     * Waits for a data source query data request to be made.
+     *
+     * @param cb optional callback to filter the request. Use this to filter by request body or other request properties
+     */
+    waitForQueryDataRequest(cb?: (request: Request) => boolean | Promise<boolean>): Promise<Request>;
+    /**
+     * Waits for a data source query data response
+     *
+     * @param cb optional callback to filter the response. Use this to filter by response body or other response properties
+     */
+    waitForQueryDataResponse(cb?: (request: Response) => boolean | Promise<boolean>): Promise<Response>;
+}

package/dist/models/Panel.d.ts

@@ -0,0 +1,12 @@
+import { Locator } from '@playwright/test';
+import { PluginTestCtx } from '../types';
+import { GrafanaPage } from './GrafanaPage';
+export declare class Panel extends GrafanaPage {
+    readonly ctx: PluginTestCtx;
+    readonly locator: () => Locator;
+    constructor(ctx: PluginTestCtx, locator: () => Locator);
+    /**
+     * Returns the locator for the panel error (if any)
+     */
+    getErrorIcon(): Locator;
+}

package/dist/models/PanelEditPage.d.ts

@@ -0,0 +1,55 @@
+import { Locator, Response } from '@playwright/test';
+import { DashboardEditViewArgs, NavigateOptions, PluginTestCtx, RequestOptions, Visualization } from '../types';
+import { DataSourcePicker } from './DataSourcePicker';
+import { GrafanaPage } from './GrafanaPage';
+import { TimeRange } from './TimeRange';
+import { Panel } from './Panel';
+export declare class PanelEditPage extends GrafanaPage {
+    readonly ctx: PluginTestCtx;
+    readonly args: DashboardEditViewArgs<string>;
+    datasource: DataSourcePicker;
+    timeRange: TimeRange;
+    panel: Panel;
+    constructor(ctx: PluginTestCtx, args: DashboardEditViewArgs<string>);
+    /**
+     * Navigates to the panel edit page. If a dashboard uid was not provided, it's assumed that it's a new dashboard.
+     */
+    goto(options?: NavigateOptions): Promise<void>;
+    /**
+     * Sets the title of the panel. This method will open the panel options, set the title and close the panel options.
+     */
+    setPanelTitle(title: string): Promise<void>;
+    /**
+     * Sets the visualization for the panel. This method will open the visualization picker, select the given visualization
+     */
+    setVisualization(visualization: Visualization): Promise<void>;
+    /**
+     * Expands the section for the given category name. If the section is already expanded, this method does nothing.
+     */
+    collapseSection(categoryName: string): Promise<void>;
+    /**
+     * Returns the name of the visualization currently selected in the panel editor
+     */
+    getVisualizationName(): Locator;
+    /**
+     * Clicks the "Apply" button in the panel editor
+     */
+    apply(): Promise<void>;
+    /**
+     * Returns the locator for the query editor row with the given refId
+     */
+    getQueryEditorRow(refId: string): Locator;
+    /**
+     * Clicks the "Refresh" button in the panel editor. Returns the response promise for the data query
+     *
+     * By default, this method will wait for any response that has the url '/api/ds/query'.
+     * If you need to wait for a specific response, you can pass a callback to the `waitForResponsePredicateCallback` option.
+     * e.g
+     * panelEditPage.refreshPanel({
+        waitForResponsePredicateCallback: (r) =>
+          r.url().includes(selectors.apis.DataSource.query) &&
+          r.body().then((body) => body.includes(`"status":"finished"`)),
+      })
+     */
+    refreshPanel(options?: RequestOptions): Promise<Response>;
+}

package/dist/models/TimeRange.d.ts

@@ -0,0 +1,9 @@
+import { PluginTestCtx, TimeRangeArgs } from '../types';
+import { GrafanaPage } from './GrafanaPage';
+export declare class TimeRange extends GrafanaPage {
+    constructor(ctx: PluginTestCtx);
+    /**
+     * Opens the time picker and sets the time range to the provided values
+     */
+    set({ from, to, zone }: TimeRangeArgs): Promise<void>;
+}

package/dist/models/VariableEditPage.d.ts

@@ -0,0 +1,26 @@
+import { DashboardEditViewArgs, NavigateOptions, PluginTestCtx } from '../types';
+import { DataSourcePicker } from './DataSourcePicker';
+import { GrafanaPage } from './GrafanaPage';
+export type VariableType = 'Query' | 'Constant' | 'Custom';
+export declare class VariableEditPage extends GrafanaPage {
+    readonly ctx: PluginTestCtx;
+    readonly args: DashboardEditViewArgs<string>;
+    datasource: DataSourcePicker;
+    constructor(ctx: PluginTestCtx, args: DashboardEditViewArgs<string>);
+    /**
+     * Navigates to the variable edit page. If a dashboard uid was not provided, it's assumed that it's a new dashboard.
+     */
+    goto(options?: NavigateOptions): Promise<void>;
+    /**
+     * Sets the type of variable in the 'Variable type' dropdown to the given type
+     */
+    setVariableType(type: VariableType): Promise<void>;
+    /**
+     * Triggers the variable query to run. Note that unlike {@link PanelEditPage.refreshPanel}, this method doesn't
+     * return a request promise. This is because there's no canonical way of querying variables - data sources may
+     * call any endpoint or resolve variables in the frontend. If you need to wait for a specific request, you can
+     * do that in your test.
+     * @example await this.ctx.page.waitForResponse((resp) => resp.url().includes('<url>')
+     */
+    runQuery(): Promise<void>;
+}

package/dist/models/VariablePage.d.ts

@@ -0,0 +1,16 @@
+import { DashboardPageArgs, NavigateOptions, PluginTestCtx } from '../types';
+import { GrafanaPage } from './GrafanaPage';
+import { VariableEditPage } from './VariableEditPage';
+export declare class VariablePage extends GrafanaPage {
+    readonly ctx: PluginTestCtx;
+    readonly dashboard?: DashboardPageArgs | undefined;
+    constructor(ctx: PluginTestCtx, dashboard?: DashboardPageArgs | undefined);
+    /**
+     * Navigates to the variable list page. If a dashboard uid was not provided, it's assumed that it's a new dashboard.
+     */
+    goto(options?: NavigateOptions): Promise<void>;
+    /**
+     * Clicks the add new variable button and returns the variable edit page
+     */
+    clickAddNew(): Promise<VariableEditPage>;
+}

package/dist/models/index.d.ts

@@ -0,0 +1,8 @@
+export { AnnotationEditPage } from './AnnotationEditPage';
+export { AnnotationPage } from './AnnotationPage';
+export { DashboardPage } from './DashboardPage';
+export { DataSourceConfigPage } from './DataSourceConfigPage';
+export { GrafanaPage } from './GrafanaPage';
+export { PanelEditPage } from './PanelEditPage';
+export { VariableEditPage } from './VariableEditPage';
+export { VariablePage } from './VariablePage';

package/dist/options/index.d.ts

@@ -0,0 +1,4 @@
+import { Fixtures } from '@playwright/test';
+import { PluginOptions } from '../api';
+declare const options: Fixtures<{}, PluginOptions>;
+export default options;

package/dist/selectorEngine.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Returns a selector engine that resolves selectors by data-testid or aria-label
+ */
+export declare const grafanaE2ESelectorEngine: () => {
+    query(root: Element, selector: string): Element | null;
+    queryAll(root: Element, selector: string): NodeListOf<Element>;
+};