checkly 0.0.0-canary.7166ed8

package/dist/constructs/ref.js

@@ -0,0 +1,54 @@
+/**
+ * Represents a reference to a construct that can be used to link constructs together.
+ * Used for establishing relationships between constructs without direct dependencies.
+ *
+ * @example
+ * ```typescript
+ * // Reference an existing check group by ID (recommended)
+ * const existingGroup = CheckGroupV2.fromId(123)
+ *
+ * // Use the group property, not groupId
+ * const check = new ApiCheck('my-check', {
+ *   name: 'API Check',
+ *   request: { url: 'https://api.example.com', method: 'GET' },
+ *   group: existingGroup  // Use group property with CheckGroupV2
+ * })
+ *
+ * // Or create a new group
+ * const newGroup = new CheckGroupV2('my-group', {
+ *   name: 'My Check Group',
+ *   activated: true
+ * })
+ *
+ * const check2 = new ApiCheck('my-check-2', {
+ *   name: 'Another API Check',
+ *   request: { url: 'https://api.example.com/v2', method: 'GET' },
+ *   group: newGroup
+ * })
+ * ```
+ *
+ * @internal The Ref class itself is primarily for internal use. Users should not create Ref instances directly.
+ */
+export class Ref {
+    /** The reference string that identifies the target construct */
+    ref;
+    /**
+     * Creates a new reference instance.
+     * Use the static `from` method instead of creating instances directly.
+     *
+     * @param ref The reference string
+     */
+    constructor(ref) {
+        this.ref = ref;
+    }
+    /**
+     * Creates a reference from a logical ID string.
+     *
+     * @param ref The logical ID of the construct to reference
+     * @returns A new Ref instance that can be used to link constructs
+     */
+    static from(ref) {
+        return new Ref(ref);
+    }
+}
+//# sourceMappingURL=ref.js.map

package/dist/constructs/ref.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ref.js","sourceRoot":"","sources":["../../src/constructs/ref.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,MAAM,OAAO,GAAG;IACd,gEAAgE;IAChE,GAAG,CAAQ;IAEX;;;;;OAKG;IACH,YAAqB,GAAW;QAC9B,IAAI,CAAC,GAAG,GAAG,GAAG,CAAA;IAChB,CAAC;IAED;;;;;OAKG;IACH,MAAM,CAAC,IAAI,CAAE,GAAW;QACtB,OAAO,IAAI,GAAG,CAAC,GAAG,CAAC,CAAA;IACrB,CAAC;CACF"}

package/dist/constructs/retry-strategy-codegen.d.ts

@@ -0,0 +1,4 @@
+import { Value, GeneratedFile } from '../sourcegen/index.js';
+import { RetryStrategy } from './retry-strategy.js';
+export type RetryStrategyResource = RetryStrategy;
+export declare function valueForRetryStrategy(genfile: GeneratedFile, strategy?: RetryStrategyResource | null): Value;

package/dist/constructs/retry-strategy-codegen.js

@@ -0,0 +1,104 @@
+import { expr, ident } from '../sourcegen/index.js';
+export function valueForRetryStrategy(genfile, strategy) {
+    genfile.namedImport('RetryStrategyBuilder', 'checkly/constructs');
+    function buildBaseBackoffSecondsOption(options, builder) {
+        if (options.baseBackoffSeconds) {
+            builder.number('baseBackoffSeconds', options.baseBackoffSeconds);
+        }
+    }
+    function buildMaxRetriesOption(options, builder) {
+        if (options.maxRetries) {
+            builder.number('maxRetries', options.maxRetries);
+        }
+    }
+    function buildMaxDurationSecondsOption(options, builder) {
+        if (options.maxDurationSeconds) {
+            builder.number('maxDurationSeconds', options.maxDurationSeconds);
+        }
+    }
+    function buildSameRegionOption(options, builder) {
+        if (options.sameRegion !== undefined) {
+            builder.boolean('sameRegion', options.sameRegion);
+        }
+    }
+    function buildOnlyOnOption(options, builder) {
+        if (options.onlyOn !== undefined) {
+            const onlyOn = Array.isArray(options.onlyOn) ? options.onlyOn : [options.onlyOn];
+            if (onlyOn.length === 1) {
+                builder.string('onlyOn', onlyOn[0]);
+            }
+            else {
+                builder.array('onlyOn', builder => {
+                    for (const condition of onlyOn) {
+                        builder.string(condition);
+                    }
+                });
+            }
+        }
+    }
+    function buildCommonOptions(options, builder) {
+        buildBaseBackoffSecondsOption(options, builder);
+        buildMaxRetriesOption(options, builder);
+        buildMaxDurationSecondsOption(options, builder);
+        buildSameRegionOption(options, builder);
+        buildOnlyOnOption(options, builder);
+    }
+    if (strategy === null || strategy === undefined) {
+        return expr(ident('RetryStrategyBuilder'), builder => {
+            builder.member(ident('noRetries'));
+            builder.call(builder => {
+                builder.empty();
+            });
+        });
+    }
+    switch (strategy.type) {
+        case 'FIXED':
+            return expr(ident('RetryStrategyBuilder'), builder => {
+                builder.member(ident('fixedStrategy'));
+                builder.call(builder => {
+                    builder.object(builder => {
+                        buildCommonOptions(strategy, builder);
+                    });
+                });
+            });
+        case 'LINEAR':
+            return expr(ident('RetryStrategyBuilder'), builder => {
+                builder.member(ident('linearStrategy'));
+                builder.call(builder => {
+                    builder.object(builder => {
+                        buildCommonOptions(strategy, builder);
+                    });
+                });
+            });
+        case 'EXPONENTIAL':
+            return expr(ident('RetryStrategyBuilder'), builder => {
+                builder.member(ident('exponentialStrategy'));
+                builder.call(builder => {
+                    builder.object(builder => {
+                        buildCommonOptions(strategy, builder);
+                    });
+                });
+            });
+        case 'SINGLE_RETRY':
+            return expr(ident('RetryStrategyBuilder'), builder => {
+                builder.member(ident('singleRetry'));
+                builder.call(builder => {
+                    builder.object(builder => {
+                        buildBaseBackoffSecondsOption(strategy, builder);
+                        buildSameRegionOption(strategy, builder);
+                        buildOnlyOnOption(strategy, builder);
+                    });
+                });
+            });
+        case 'NO_RETRIES':
+            return expr(ident('RetryStrategyBuilder'), builder => {
+                builder.member(ident('noRetries'));
+                builder.call(builder => {
+                    builder.empty();
+                });
+            });
+        default:
+            throw new Error(`Unsupported retry strategy type ${strategy.type}`);
+    }
+}
+//# sourceMappingURL=retry-strategy-codegen.js.map

package/dist/constructs/retry-strategy-codegen.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"retry-strategy-codegen.js","sourceRoot":"","sources":["../../src/constructs/retry-strategy-codegen.ts"],"names":[],"mappings":"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"}

package/dist/constructs/retry-strategy.d.ts

@@ -0,0 +1,196 @@
+/** Available retry strategy types */
+export type RetryStrategyType = 'LINEAR' | 'EXPONENTIAL' | 'FIXED' | 'SINGLE_RETRY' | 'NO_RETRIES';
+/**
+ * Conditions can be used to limit when a retry strategy applies.
+ */
+export type RetryStrategyCondition = 'NETWORK_ERROR';
+/**
+ * Configuration for check and monitor retry behavior.
+ * Defines how and when to retry failed checks or monitors before marking
+ * them as permanently failed.
+ */
+export interface RetryStrategy {
+    /** The retry strategy type */
+    type: RetryStrategyType;
+    /**
+     * The number of seconds to wait before the first retry attempt.
+     * This value is used differently based on the retry strategy type:
+     * - FIXED: Same delay for all retries
+     * - LINEAR: Base value that increases linearly (baseBackoffSeconds * attempt)
+     * - EXPONENTIAL: Base value that increases exponentially (baseBackoffSeconds ^ attempt)
+     * - SINGLE_RETRY: The delay for the first and only retry
+     *
+     * @defaultValue 60
+     * @example
+     * ```typescript
+     * // Fixed: 30s, 30s, 30s
+     * baseBackoffSeconds: 30
+     *
+     * // Linear: 10s, 20s, 30s
+     * baseBackoffSeconds: 10
+     *
+     * // Exponential: 5s, 25s, 125s
+     * baseBackoffSeconds: 5
+     *
+     * // Single retry: 10s
+     * baseBackoffSeconds: 10
+     * ```
+     */
+    baseBackoffSeconds?: number;
+    /**
+     * The maximum number of attempts to retry the check.
+     * Value must be between 1 and 10.
+     *
+     * @defaultValue 2
+     */
+    maxRetries?: number;
+    /**
+     * The total amount of time to continue retrying the check.
+     * Maximum value is 600 seconds (10 minutes).
+     * If retries would exceed this duration, they are stopped early.
+     *
+     * @defaultValue 600
+     */
+    maxDurationSeconds?: number;
+    /**
+     * Whether retries should be run in the same region as the initial check run.
+     * If false, retries use a randomly selected region for better fault tolerance.
+     *
+     * @defaultValue true
+     */
+    sameRegion?: boolean;
+    /**
+     * Apply the retry strategy only if the cause of the failure matches the
+     * given condition. Otherwise, do not retry.
+     *
+     * The following conditions are supported:
+     * - NETWORK_ERROR: Retry only if the failure was caused by a network error.
+     *   Available with the {@link ApiCheck} and {@link UrlMonitor} constructs.
+     */
+    onlyOn?: RetryStrategyCondition;
+}
+/**
+ * Options for configuring retry strategy behavior.
+ * These options can be used with any retry strategy type.
+ */
+export type RetryStrategyOptions = Omit<RetryStrategy, 'type'>;
+/**
+ * Configuration for linear retry strategies.
+ */
+export interface LinearRetryStrategy extends RetryStrategy {
+    type: 'LINEAR';
+}
+/**
+ * Options for configuring linear retry strategy behavior.
+ */
+export type LinearRetryStrategyOptions = RetryStrategyOptions;
+/**
+ * Configuration for exponential retry strategies.
+ */
+export interface ExponentialRetryStrategy extends RetryStrategy {
+    type: 'EXPONENTIAL';
+}
+/**
+ * Options for configuring exponential retry strategy behavior.
+ */
+export type ExponentialRetryStrategyOptions = RetryStrategyOptions;
+/**
+ * Configuration for fixed retry strategies.
+ */
+export interface FixedRetryStrategy extends RetryStrategy {
+    type: 'FIXED';
+}
+/**
+ * Options for configuring fixed retry strategy behavior.
+ */
+export type FixedRetryStrategyOptions = RetryStrategyOptions;
+/**
+ * Configuration for single retry retry strategies.
+ */
+export interface SingleRetryRetryStrategy extends Pick<RetryStrategy, 'type' | 'baseBackoffSeconds' | 'sameRegion' | 'onlyOn'> {
+    type: 'SINGLE_RETRY';
+}
+/**
+ * Options for configuring single retry retry strategy behavior.
+ */
+export type SingleRetryRetryStrategyOptions = Pick<RetryStrategyOptions, 'baseBackoffSeconds' | 'sameRegion' | 'onlyOn'>;
+/**
+ * Configuration for no retry retry strategies.
+ */
+export interface NoRetriesRetryStrategy extends Pick<RetryStrategy, 'type'> {
+    type: 'NO_RETRIES';
+}
+/**
+ * Builder class for creating retry strategies.
+ * Provides convenient methods to create different types of retry strategies.
+ * Retry strategies control how and when to retry failed checks before marking them as failed.
+ *
+ * @example
+ * ```typescript
+ * // Fixed retry strategy - same delay between retries (60s, 60s, 60s)
+ * const fixedRetry = RetryStrategyBuilder.fixedStrategy({
+ *   maxRetries: 3,
+ *   baseBackoffSeconds: 60,
+ *   sameRegion: false
+ * })
+ *
+ * // Linear retry strategy - increasing delay (10s, 20s, 30s)
+ * const linearRetry = RetryStrategyBuilder.linearStrategy({
+ *   maxRetries: 3,
+ *   baseBackoffSeconds: 10,
+ *   maxDurationSeconds: 600
+ * })
+ *
+ * // Exponential retry strategy - exponential backoff (10s, 100s, 1000s)
+ * const exponentialRetry = RetryStrategyBuilder.exponentialStrategy({
+ *   maxRetries: 3,
+ *   baseBackoffSeconds: 10
+ * })
+ *
+ * // No retries - fail immediately
+ * const noRetries = RetryStrategyBuilder.noRetries()
+ *
+ * // Retry on network errors only
+ * const retryOnNetworkError = RetryStrategyBuilder.fixedStrategy({
+ *   maxRetries: 1,
+ *   baseBackoffSeconds: 30,
+ *   sameRegion: false,
+ *   onlyOn: 'NETWORK_ERROR'
+ * })
+ * ```
+ *
+ * @see {@link https://www.checklyhq.com/docs/alerting-and-retries/retries/ | Retry Strategies Documentation}
+ */
+export declare class RetryStrategyBuilder {
+    private static readonly DEFAULT_BASE_BACKOFF_SECONDS;
+    private static readonly DEFAULT_MAX_RETRIES;
+    private static readonly DEFAULT_MAX_DURATION_SECONDS;
+    private static readonly DEFAULT_SAME_REGION;
+    /**
+     * Each retry is run with the same backoff between attempts.
+     */
+    static fixedStrategy(options?: FixedRetryStrategyOptions): FixedRetryStrategy;
+    /**
+     * The delay between retries increases linearly
+     *
+     * The delay between retries is calculated using `baseBackoffSeconds * attempt`.
+     * For example, retries will be run with a backoff of 10s, 20s, 30s, and so on.
+     */
+    static linearStrategy(options?: LinearRetryStrategyOptions): LinearRetryStrategy;
+    /**
+     * The delay between retries increases exponentially
+     *
+     * The delay between retries is calculated using `baseBackoffSeconds ^ attempt`.
+     * For example, retries will be run with a backoff of 10s, 100s, 1000s, and so on.
+     */
+    static exponentialStrategy(options?: ExponentialRetryStrategyOptions): ExponentialRetryStrategy;
+    /**
+     * A single retry will be performed.
+     */
+    static singleRetry(options?: SingleRetryRetryStrategyOptions): SingleRetryRetryStrategy;
+    /**
+     * No retries are performed.
+     */
+    static noRetries(): NoRetriesRetryStrategy;
+    private static defaults;
+}

package/dist/constructs/retry-strategy.js

@@ -0,0 +1,110 @@
+/**
+ * Builder class for creating retry strategies.
+ * Provides convenient methods to create different types of retry strategies.
+ * Retry strategies control how and when to retry failed checks before marking them as failed.
+ *
+ * @example
+ * ```typescript
+ * // Fixed retry strategy - same delay between retries (60s, 60s, 60s)
+ * const fixedRetry = RetryStrategyBuilder.fixedStrategy({
+ *   maxRetries: 3,
+ *   baseBackoffSeconds: 60,
+ *   sameRegion: false
+ * })
+ *
+ * // Linear retry strategy - increasing delay (10s, 20s, 30s)
+ * const linearRetry = RetryStrategyBuilder.linearStrategy({
+ *   maxRetries: 3,
+ *   baseBackoffSeconds: 10,
+ *   maxDurationSeconds: 600
+ * })
+ *
+ * // Exponential retry strategy - exponential backoff (10s, 100s, 1000s)
+ * const exponentialRetry = RetryStrategyBuilder.exponentialStrategy({
+ *   maxRetries: 3,
+ *   baseBackoffSeconds: 10
+ * })
+ *
+ * // No retries - fail immediately
+ * const noRetries = RetryStrategyBuilder.noRetries()
+ *
+ * // Retry on network errors only
+ * const retryOnNetworkError = RetryStrategyBuilder.fixedStrategy({
+ *   maxRetries: 1,
+ *   baseBackoffSeconds: 30,
+ *   sameRegion: false,
+ *   onlyOn: 'NETWORK_ERROR'
+ * })
+ * ```
+ *
+ * @see {@link https://www.checklyhq.com/docs/alerting-and-retries/retries/ | Retry Strategies Documentation}
+ */
+export class RetryStrategyBuilder {
+    static DEFAULT_BASE_BACKOFF_SECONDS = 60;
+    static DEFAULT_MAX_RETRIES = 2;
+    static DEFAULT_MAX_DURATION_SECONDS = 60 * 10;
+    static DEFAULT_SAME_REGION = true;
+    /**
+     * Each retry is run with the same backoff between attempts.
+     */
+    static fixedStrategy(options) {
+        return {
+            type: 'FIXED',
+            ...RetryStrategyBuilder.defaults(options),
+        };
+    }
+    /**
+     * The delay between retries increases linearly
+     *
+     * The delay between retries is calculated using `baseBackoffSeconds * attempt`.
+     * For example, retries will be run with a backoff of 10s, 20s, 30s, and so on.
+     */
+    static linearStrategy(options) {
+        return {
+            type: 'LINEAR',
+            ...RetryStrategyBuilder.defaults(options),
+        };
+    }
+    /**
+     * The delay between retries increases exponentially
+     *
+     * The delay between retries is calculated using `baseBackoffSeconds ^ attempt`.
+     * For example, retries will be run with a backoff of 10s, 100s, 1000s, and so on.
+     */
+    static exponentialStrategy(options) {
+        return {
+            type: 'EXPONENTIAL',
+            ...RetryStrategyBuilder.defaults(options),
+        };
+    }
+    /**
+     * A single retry will be performed.
+     */
+    static singleRetry(options) {
+        const { baseBackoffSeconds, sameRegion, onlyOn } = RetryStrategyBuilder.defaults(options);
+        return {
+            type: 'SINGLE_RETRY',
+            baseBackoffSeconds,
+            sameRegion,
+            onlyOn,
+        };
+    }
+    /**
+     * No retries are performed.
+     */
+    static noRetries() {
+        return {
+            type: 'NO_RETRIES',
+        };
+    }
+    static defaults(options) {
+        return {
+            baseBackoffSeconds: options?.baseBackoffSeconds ?? RetryStrategyBuilder.DEFAULT_BASE_BACKOFF_SECONDS,
+            maxRetries: options?.maxRetries ?? RetryStrategyBuilder.DEFAULT_MAX_RETRIES,
+            maxDurationSeconds: options?.maxDurationSeconds ?? RetryStrategyBuilder.DEFAULT_MAX_DURATION_SECONDS,
+            sameRegion: options?.sameRegion ?? RetryStrategyBuilder.DEFAULT_SAME_REGION,
+            onlyOn: options?.onlyOn,
+        };
+    }
+}
+//# sourceMappingURL=retry-strategy.js.map

package/dist/constructs/retry-strategy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"retry-strategy.js","sourceRoot":"","sources":["../../src/constructs/retry-strategy.ts"],"names":[],"mappings":"AAiJA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,MAAM,OAAO,oBAAoB;IACvB,MAAM,CAAU,4BAA4B,GAAG,EAAE,CAAA;IACjD,MAAM,CAAU,mBAAmB,GAAG,CAAC,CAAA;IACvC,MAAM,CAAU,4BAA4B,GAAG,EAAE,GAAG,EAAE,CAAA;IACtD,MAAM,CAAU,mBAAmB,GAAG,IAAI,CAAA;IAElD;;OAEG;IACH,MAAM,CAAC,aAAa,CAAE,OAAmC;QACvD,OAAO;YACL,IAAI,EAAE,OAAO;YACb,GAAG,oBAAoB,CAAC,QAAQ,CAAC,OAAO,CAAC;SAC1C,CAAA;IACH,CAAC;IAED;;;;;OAKG;IACH,MAAM,CAAC,cAAc,CAAE,OAAoC;QACzD,OAAO;YACL,IAAI,EAAE,QAAQ;YACd,GAAG,oBAAoB,CAAC,QAAQ,CAAC,OAAO,CAAC;SAC1C,CAAA;IACH,CAAC;IAED;;;;;OAKG;IACH,MAAM,CAAC,mBAAmB,CAAE,OAAyC;QACnE,OAAO;YACL,IAAI,EAAE,aAAa;YACnB,GAAG,oBAAoB,CAAC,QAAQ,CAAC,OAAO,CAAC;SAC1C,CAAA;IACH,CAAC;IAED;;OAEG;IACH,MAAM,CAAC,WAAW,CAAE,OAAyC;QAC3D,MAAM,EAAE,kBAAkB,EAAE,UAAU,EAAE,MAAM,EAAE,GAAG,oBAAoB,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAA;QACzF,OAAO;YACL,IAAI,EAAE,cAAc;YACpB,kBAAkB;YAClB,UAAU;YACV,MAAM;SACP,CAAA;IACH,CAAC;IAED;;OAEG;IACH,MAAM,CAAC,SAAS;QACd,OAAO;YACL,IAAI,EAAE,YAAY;SACnB,CAAA;IACH,CAAC;IAEO,MAAM,CAAC,QAAQ,CAAE,OAA8B;QACrD,OAAO;YACL,kBAAkB,EAAE,OAAO,EAAE,kBAAkB,IAAI,oBAAoB,CAAC,4BAA4B;YACpG,UAAU,EAAE,OAAO,EAAE,UAAU,IAAI,oBAAoB,CAAC,mBAAmB;YAC3E,kBAAkB,EAAE,OAAO,EAAE,kBAAkB,IAAI,oBAAoB,CAAC,4BAA4B;YACpG,UAAU,EAAE,OAAO,EAAE,UAAU,IAAI,oBAAoB,CAAC,mBAAmB;YAC3E,MAAM,EAAE,OAAO,EAAE,MAAM;SACxB,CAAA;IACH,CAAC"}

package/dist/constructs/session.d.ts

@@ -0,0 +1,67 @@
+import { CheckConfigDefaults } from '../services/checkly-config-loader.js';
+import { type EngineDetectionResult } from '../services/engine-detector.js';
+import { Parser } from '../services/check-parser/parser.js';
+import { Construct } from './construct.js';
+import { PrivateLocationApi } from '../rest/private-locations.js';
+import { FileLoader } from '../loader/index.js';
+import { Workspace } from '../services/check-parser/package-files/workspace.js';
+import { PackageManager } from '../services/check-parser/package-files/package-manager.js';
+import { Result } from '../services/check-parser/package-files/result.js';
+import { Runtime } from '../runtimes/index.js';
+import { PlaywrightProjectBundler } from '../services/playwright-project-bundler.js';
+import type { Project } from './project.js';
+import type { Check } from './check.js';
+export interface ConstructExport {
+    type: string;
+    logicalId: string;
+    filePath: string;
+    exportName: string;
+}
+export type CheckFilter = (check: Check) => boolean;
+export interface SharedFile {
+    path: string;
+    content: string;
+}
+export type SharedFileRef = number;
+export declare class Session {
+    #private;
+    static loader: FileLoader;
+    static project?: Project;
+    static basePath?: string;
+    static contextPath?: string;
+    static checkDefaults?: CheckConfigDefaults;
+    static checkFilter?: CheckFilter;
+    static browserCheckDefaults?: CheckConfigDefaults;
+    static multiStepCheckDefaults?: CheckConfigDefaults;
+    static checkFilePath?: string;
+    static checkFileAbsolutePath?: string;
+    static availableRuntimes: Record<string, Runtime>;
+    static defaultRuntimeId?: string;
+    static verifyRuntimeDependencies: boolean;
+    static loadingChecklyConfigFile: boolean;
+    static checklyConfigFileConstructs?: Construct[];
+    static privateLocations: PrivateLocationApi[];
+    static parsers: Map<string, Parser>;
+    static playwrightProjectBundler?: PlaywrightProjectBundler;
+    static constructExports: ConstructExport[];
+    static ignoreDirectoriesMatch: string[];
+    static warnOnWebServerConfig?: boolean;
+    static packageManager: PackageManager;
+    static workspace: Result<Workspace, Error>;
+    static detectedEnginePromise?: Promise<EngineDetectionResult | null>;
+    static reset(): void;
+    static loadFile<T = unknown>(filePath: string): Promise<T>;
+    static registerConstruct(construct: Construct): void;
+    static validateCreateConstruct(construct: Construct): void;
+    static getPrivateLocations(): Promise<PrivateLocationApi[]>;
+    static getRuntime(runtimeId?: string): Runtime | undefined;
+    static getParser(runtime: Runtime): Parser;
+    static getPlaywrightParser(): Parser;
+    static getPlaywrightProjectBundler(): PlaywrightProjectBundler;
+    static relativePosixPath(filePath: string): string;
+    static contextRelativePosixPath(filePath: string): string;
+    static sharedFileRefs: Map<string, number>;
+    static sharedFiles: SharedFile[];
+    static registerSharedFile(file: SharedFile): SharedFileRef;
+    static resetSharedFiles(): void;
+}