pomwright 1.4.0 → 1.5.0

package/dist/index.d.ts

@@ -1,8 +1,15 @@
 import * as _playwright_test from '@playwright/test';
-import { Page, Locator, TestInfo, Selectors, APIRequestContext } from '@playwright/test';
+import { Page, Locator, TestInfo, APIRequestContext, Selectors, test as test$1 } from '@playwright/test';
 
+/**
+ * @deprecated AriaRoleType will be removed in v2, see docs/v1-to-v2-migration
+ *
+ * Type representing the ARIA role of an element, used in the "role" property of the "LocatorSchema" interface. This type is derived from the parameters of Playwright's "page.getByRole" method, ensuring compatibility with Playwright's locator strategies.
+ */
 type AriaRoleType = Parameters<Page["getByRole"]>[0];
 /**
+ * @deprecated GetByMethod will be removed in v2, see docs/v1-to-v2-migration
+ *
  * ENUM representing methods from the "GetBy" helper class, used by the "GetLocatorBase" class when building nested locators
  */
 declare enum GetByMethod {
@@ -19,6 +26,8 @@ declare enum GetByMethod {
     id = "id"
 }
 /**
+ * @deprecated LocatorSchema will be removed in v2, see docs/v1-to-v2-migration
+ *
  * An interface representing a locator object, which can be used with Playwright or other automation tools to create a reusable and maintainable "library" of Locator objects.
  *
  * To make tests resilient, prioritize user-facing attributes and explicit contracts such as role locators (ARIA).
@@ -125,7 +134,7 @@ type LogEntry = {
  * PlaywrightReportLogger is a logger implementation designed for Playwright tests.
  * It records log messages and attaches them to the Playwright HTML report.
  *
- * The logger enables all fixtures implementing it to share the same log level
+ * The logger enables all fixtures implementing a child logger to share the same log level
  * within the scope of a single test, independant of other tests run in parallell.
  * In the same way each fixture will share a single logEntry for recording all log
  * statements produced throughout the tests execution, when the test is done, all log
@@ -134,8 +143,8 @@ type LogEntry = {
  * Log messages can be recorded with various log levels (debug, info, warn, error).
  *
  * The getNewChildLogger method allows you to create a new 'child' logger instance
- * with a new contextual name (e.g. the class it's used), while sharing the logLevel
- * and LogEntry with the 'parent'.
+ * with a new contextual name (e.g. the class it's used in), while sharing the logLevel
+ * and LogEntry with the 'parent' fixture.
  *
  * @example
  * 20:49:50 05.05.2023 - DEBUG : [TestCase]
@@ -210,6 +219,18 @@ declare class PlaywrightReportLogger {
     attachLogsToTest(testInfo: TestInfo): void;
 }
 
+/**
+ * @deprecated BaseApi will be removed in v2, see docs/v1-to-v2-migration
+ * Please use your own API base class implementation and do not rely on this class.
+ */
+declare class BaseApi {
+    protected baseUrl: string;
+    apiName: string;
+    protected log: PlaywrightReportLogger;
+    protected request: APIRequestContext;
+    constructor(baseUrl: string, apiName: string, context: APIRequestContext, pwrl: PlaywrightReportLogger);
+}
+
 /**
  * The GetBy class encapsulates methods for generating and obtaining Playwright Locators using LocatorSchema.
  * It maps locator methods to corresponding Playwright page functions and provides a convenient interface to interact
@@ -285,7 +306,7 @@ type FilterEntry = {
  * For example: ExtractSubPaths<"body.section@playground.button@reset"> produces:
  * "body" | "body.section@playground" | "body.section@playground.button@reset"
  */
-type ExtractSubPaths<Path extends string> = Path extends `${infer Head}.${infer Tail}` ? Head | `${Head}.${ExtractSubPaths<Tail>}` : Path;
+type ExtractSubPaths$1<Path extends string> = Path extends `${infer Head}.${infer Tail}` ? Head | `${Head}.${ExtractSubPaths$1<Tail>}` : Path;
 /**
  * SubPaths computes valid sub-paths for a given chosen substring (LocatorSubstring).
  * If LocatorSubstring is a string:
@@ -294,8 +315,10 @@ type ExtractSubPaths<Path extends string> = Path extends `${infer Head}.${infer
  * SubPaths returns only "body", "body.section@playground", and "body.section@playground.button@reset"
  * from the entire union of LocatorSchemaPathType, if they exist.
  */
-type SubPaths<LocatorSchemaPathType extends string, LocatorSubstring extends LocatorSchemaPathType | undefined> = LocatorSubstring extends string ? Extract<LocatorSchemaPathType, LocatorSubstring | ExtractSubPaths<LocatorSubstring>> : never;
+type SubPaths<LocatorSchemaPathType extends string, LocatorSubstring extends LocatorSchemaPathType | undefined> = LocatorSubstring extends string ? Extract<LocatorSchemaPathType, LocatorSubstring | ExtractSubPaths$1<LocatorSubstring>> : never;
 /**
+ * @deprecated LocatorSchemaWithMethods will be replaced by LocatorRegistry.createReusable in v2, see docs/v1-to-v2-migration
+ *
  * UpdatableLocatorSchemaProperties represent the properties of LocatorSchema that can be changed by update,
  * excluding the locatorSchemaPath itself, which remains immutable.
  */
@@ -308,7 +331,7 @@ type PathIndexPairs = {
 /**
  * Ensures LocatorSchemaPath strings are non-empty, do not start/end with dots, and avoid consecutive dots.
  */
-type LocatorSchemaPathValid<Path extends string> = Path extends "" ? never : Path extends `.${string}` | `${string}.` ? never : Path extends `${string}..${string}` ? never : Path;
+type LocatorSchemaPathValid$1<Path extends string> = Path extends "" ? never : Path extends `.${string}` | `${string}.` ? never : Path extends `${string}..${string}` ? never : Path;
 /**
  * LocatorSchemaWithMethods is the type returned by getLocatorSchema. It merges LocatorSchema with chainable methods:
  * - update: Modify any properties of any LocatorSchema in the chain that make up the LocatorSchemaPath. Can be chained multiple times, applies updates in the order chained.
@@ -454,6 +477,8 @@ type LocatorSchemaWithMethods<LocatorSchemaPathType extends string, LocatorSubst
     getLocator(): Promise<Locator>;
 };
 /**
+ * @deprecated GetLocatorBase will be replaced by LocatorRegistry in v2, see docs/v1-to-v2-migration
+ *
  * GetLocatorBase:
  * The foundational class for managing and constructing nested locators based on LocatorSchemas.
  *
@@ -476,12 +501,12 @@ type LocatorSchemaWithMethods<LocatorSchemaPathType extends string, LocatorSubst
  *   Assembles nested Playwright locators step-by-step according to the path.
  */
 declare class GetLocatorBase<LocatorSchemaPathType extends string, LocatorSubstring extends LocatorSchemaPathType | undefined = undefined> {
-    protected pageObjectClass: BasePage<LocatorSchemaPathType, BasePageOptions, LocatorSubstring>;
+    protected pageObjectClass: BasePage<LocatorSchemaPathType, BasePageOptions$1, LocatorSubstring>;
     protected log: PlaywrightReportLogger;
     protected locatorSubstring?: LocatorSubstring | undefined;
     getBy: GetBy;
     private locatorSchemas;
-    constructor(pageObjectClass: BasePage<LocatorSchemaPathType, BasePageOptions, LocatorSubstring>, log: PlaywrightReportLogger, locatorSubstring?: LocatorSubstring | undefined);
+    constructor(pageObjectClass: BasePage<LocatorSchemaPathType, BasePageOptions$1, LocatorSubstring>, log: PlaywrightReportLogger, locatorSubstring?: LocatorSubstring | undefined);
     /**
      * getLocatorSchema:
      * Given a path P, we:
@@ -513,7 +538,7 @@ declare class GetLocatorBase<LocatorSchemaPathType extends string, LocatorSubstr
      * Registers a new LocatorSchema under the given locatorSchemaPath.
      * Throws an error if a schema already exists at that path.
      */
-    addSchema(locatorSchemaPath: LocatorSchemaPathType & LocatorSchemaPathValid<LocatorSchemaPathType>, schemaDetails: LocatorSchemaWithoutPath): void;
+    addSchema(locatorSchemaPath: LocatorSchemaPathType & LocatorSchemaPathValid$1<LocatorSchemaPathType>, schemaDetails: LocatorSchemaWithoutPath): void;
     /**
      * safeGetLocatorSchema:
      * Safely retrieves a schema function if available for the given path.
@@ -554,7 +579,7 @@ declare class GetLocatorBase<LocatorSchemaPathType extends string, LocatorSubstr
  * Defines the SessionStorage class to manage session storage in Playwright.
  * It provides methods to set, get, and clear session storage data, and to handle data before page navigation.
  */
-declare class SessionStorage {
+declare class SessionStorage$1 {
     private page;
     private pocName;
     private queuedStates;
@@ -609,27 +634,40 @@ declare class SessionStorage {
 }
 
 /**
+ * @deprecated BasePageOptions will be removed in v2, see docs/v1-to-v2-migration
+ *
  * BasePageOptions can define optional patterns for baseUrl and urlPath.
  * Defaults assume they are strings if not specified.
  */
-type BasePageOptions = {
+type BasePageOptions$1 = {
     urlOptions?: {
         baseUrlType?: string | RegExp;
         urlPathType?: string | RegExp;
     };
 };
-type ExtractBaseUrlType<T extends BasePageOptions> = T["urlOptions"] extends {
+/**
+ * @deprecated ExtractBaseUrlType will be replaced by BaseUrlTypeFromOptions in v2, see docs/v1-to-v2-migration
+ */
+type ExtractBaseUrlType$1<T extends BasePageOptions$1> = T["urlOptions"] extends {
     baseUrlType: RegExp;
 } ? RegExp : string;
-type ExtractUrlPathType<T extends BasePageOptions> = T["urlOptions"] extends {
+/**
+ * @deprecated ExtractUrlPathType will be replaced by UrlPathTypeFromOptions in v2, see docs/v1-to-v2-migration
+ */
+type ExtractUrlPathType$1<T extends BasePageOptions$1> = T["urlOptions"] extends {
     urlPathType: RegExp;
 } ? RegExp : string;
-type ExtractFullUrlType<T extends BasePageOptions> = T["urlOptions"] extends {
+/**
+ * @deprecated ExtractFullUrlType will be replaced by FullUrlTypeFromOptions in v2, see docs/v1-to-v2-migration
+ */
+type ExtractFullUrlType$1<T extends BasePageOptions$1> = T["urlOptions"] extends {
     baseUrlType: RegExp;
 } | {
     urlPathType: RegExp;
 } ? RegExp : string;
 /**
+ * @deprecated BasePage will be replaced by PageObject in v2, see docs/v1-to-v2-migration.
+ *
  * BasePage:
  * The foundational class for all Page Object Classes.
  *
@@ -646,7 +684,7 @@ type ExtractFullUrlType<T extends BasePageOptions> = T["urlOptions"] extends {
  * - getNestedLocator & getLocator methods that delegate to getLocatorSchema.
  * - Abstract initLocatorSchemas method to be implemented by concrete POCs.
  */
-declare abstract class BasePage<LocatorSchemaPathType extends string, Options extends BasePageOptions = {
+declare abstract class BasePage<LocatorSchemaPathType extends string, Options extends BasePageOptions$1 = {
     urlOptions: {
         baseUrlType: string;
         urlPathType: string;
@@ -659,17 +697,17 @@ declare abstract class BasePage<LocatorSchemaPathType extends string, Options ex
     /** Selectors can be used to install custom selector engines.*/
     selector: Selectors;
     /** The base URL of the Page Object Class */
-    baseUrl: ExtractBaseUrlType<Options>;
+    baseUrl: ExtractBaseUrlType$1<Options>;
     /** The URL path of the Page Object Class */
-    urlPath: ExtractUrlPathType<Options>;
+    urlPath: ExtractUrlPathType$1<Options>;
     /** The full URL of the Page Object Class */
-    fullUrl: ExtractFullUrlType<Options>;
+    fullUrl: ExtractFullUrlType$1<Options>;
     /** The name of the Page Object Class */
     pocName: string;
     /** The Page Object Class' PlaywrightReportLogger instance, prefixed with its name. Log levels: debug, info, warn, and error.  */
     protected log: PlaywrightReportLogger;
     /** The SessionStorage class provides methods for setting and getting session storage data in Playwright.*/
-    sessionStorage: SessionStorage;
+    sessionStorage: SessionStorage$1;
     /**
      * locators:
      * An instance of GetLocatorBase that handles schema management and provides getLocatorSchema calls.
@@ -677,7 +715,7 @@ declare abstract class BasePage<LocatorSchemaPathType extends string, Options ex
      * we get a chainable object typed with LocatorSubstring = P.
      */
     protected locators: GetLocatorBase<LocatorSchemaPathType, LocatorSubstring>;
-    constructor(page: Page, testInfo: TestInfo, baseUrl: ExtractBaseUrlType<Options>, urlPath: ExtractUrlPathType<Options>, pocName: string, pwrl: PlaywrightReportLogger, locatorSubstring?: LocatorSubstring);
+    constructor(page: Page, testInfo: TestInfo, baseUrl: ExtractBaseUrlType$1<Options>, urlPath: ExtractUrlPathType$1<Options>, pocName: string, pwrl: PlaywrightReportLogger, locatorSubstring?: LocatorSubstring);
     /**
      * constructFullUrl:
      * Combines baseUrl and urlPath, handling both strings and RegExps.
@@ -862,17 +900,1001 @@ declare abstract class BasePage<LocatorSchemaPathType extends string, Options ex
     protected abstract initLocatorSchemas(): void;
 }
 
-type baseFixtures = {
-    log: PlaywrightReportLogger;
+type UnicodeWhitespaceChar = "\u0009" | "\u000A" | "\u000B" | "\u000C" | "\u000D" | "\u0020" | "\u0085" | "\u00A0" | "\u1680" | "\u2000" | "\u2001" | "\u2002" | "\u2003" | "\u2004" | "\u2005" | "\u2006" | "\u2007" | "\u2008" | "\u2009" | "\u200A" | "\u2028" | "\u2029" | "\u202F" | "\u205F" | "\u3000";
+type LocatorSchemaPathError<S extends string, Reason extends string> = [
+    "Invalid locator schema path",
+    Reason,
+    S
+];
+type LocatorSchemaPathFormat<S extends string> = string extends S ? S : S extends "" ? LocatorSchemaPathError<S, "String can't be empty"> : _LocatorSchemaPathFormat<S, S, true, false>;
+type _LocatorSchemaPathFormat<Original extends string, Rest extends string, AtStart extends boolean, PrevDot extends boolean> = Rest extends "" ? PrevDot extends true ? LocatorSchemaPathError<Original, "String can't end with '.'"> : Original : Rest extends `${infer C}${infer Tail}` ? C extends UnicodeWhitespaceChar ? LocatorSchemaPathError<Original, "String can't contain whitespace chars"> : C extends "." ? AtStart extends true ? LocatorSchemaPathError<Original, "String can't start with '.'"> : PrevDot extends true ? LocatorSchemaPathError<Original, "String can't contain consecutive '.'"> : _LocatorSchemaPathFormat<Original, Tail, false, true> : _LocatorSchemaPathFormat<Original, Tail, false, false> : never;
+type LocatorSchemaPathValid<Path extends string> = Path extends unknown ? LocatorSchemaPathFormat<Path> extends Path ? Path : never : never;
+type RegistryPath<LocatorSchemaPathType extends string> = LocatorSchemaPathType & LocatorSchemaPathValid<LocatorSchemaPathType>;
+type ExtractSubPaths<Path extends string> = Path extends `${infer Head}.${infer Tail}` ? Head | `${Head}.${ExtractSubPaths<Tail>}` : Path;
+type LocatorChainPaths<LocatorSchemaPathType extends string, LocatorSubstring extends LocatorSchemaPathType | undefined> = LocatorSubstring extends string ? Extract<LocatorSchemaPathType, LocatorSubstring | ExtractSubPaths<LocatorSubstring>> : never;
+type LocatorSchemaPathAlias<LocatorSchemaPathType extends string> = LocatorSchemaPathType & LocatorSchemaPathValid<LocatorSchemaPathType>;
+type RoleDefinition = {
+    type: "role";
+    role: Parameters<Page["getByRole"]>[0];
+    options?: Parameters<Page["getByRole"]>[1];
+};
+type TextDefinition = {
+    type: "text";
+    text: Parameters<Page["getByText"]>[0];
+    options?: Parameters<Page["getByText"]>[1];
+};
+type LabelDefinition = {
+    type: "label";
+    text: Parameters<Page["getByLabel"]>[0];
+    options?: Parameters<Page["getByLabel"]>[1];
+};
+type PlaceholderDefinition = {
+    type: "placeholder";
+    text: Parameters<Page["getByPlaceholder"]>[0];
+    options?: Parameters<Page["getByPlaceholder"]>[1];
+};
+type AltTextDefinition = {
+    type: "altText";
+    text: Parameters<Page["getByAltText"]>[0];
+    options?: Parameters<Page["getByAltText"]>[1];
+};
+type TitleDefinition = {
+    type: "title";
+    text: Parameters<Page["getByTitle"]>[0];
+    options?: Parameters<Page["getByTitle"]>[1];
+};
+type LocatorDefinition = {
+    type: "locator";
+    selector: Parameters<Page["locator"]>[0];
+    options?: Parameters<Page["locator"]>[1];
+};
+type FrameLocatorDefinition = {
+    type: "frameLocator";
+    selector: Parameters<Page["frameLocator"]>[0];
+};
+type TestIdDefinition = {
+    type: "testId";
+    testId: Parameters<Page["getByTestId"]>[0];
+};
+type IdDefinition = {
+    type: "id";
+    id: string | RegExp;
 };
-declare const test: _playwright_test.TestType<_playwright_test.PlaywrightTestArgs & _playwright_test.PlaywrightTestOptions & baseFixtures, _playwright_test.PlaywrightWorkerArgs & _playwright_test.PlaywrightWorkerOptions>;
+type LocatorStrategyDefinition = RoleDefinition | TextDefinition | LabelDefinition | PlaceholderDefinition | AltTextDefinition | TitleDefinition | LocatorDefinition | FrameLocatorDefinition | TestIdDefinition | IdDefinition;
+type PlaywrightFilterDefinition = NonNullable<Parameters<Locator["filter"]>[0]>;
+type ResolvedFilterDefinition = PlaywrightFilterDefinition;
+type LocatorDescription = Parameters<Locator["describe"]>[0];
+type LocatorStep<LocatorSchemaPathType extends string = string, AllowedPaths extends string = LocatorSchemaPathAlias<LocatorSchemaPathType>> = {
+    kind: "filter";
+    filter: FilterDefinition<LocatorSchemaPathType, AllowedPaths>;
+} | {
+    kind: "index";
+    index: IndexSelector | null;
+};
+type ReusableLocator<LocatorSchemaPathType extends string = string, AllowedPaths extends string = LocatorSchemaPathAlias<LocatorSchemaPathType>, Type extends LocatorStrategyDefinition["type"] = LocatorStrategyDefinition["type"]> = {
+    type: Type;
+    definition: Extract<LocatorStrategyDefinition, {
+        type: Type;
+    }>;
+    steps: LocatorStep<LocatorSchemaPathType, AllowedPaths>[];
+    description?: LocatorDescription;
+};
+type FilterLocatorReference<LocatorSchemaPathType extends string, AllowedPaths extends string = LocatorSchemaPathAlias<LocatorSchemaPathType>> = Locator | AllowedPaths;
+type FilterDefinition<LocatorSchemaPathType extends string, AllowedPaths extends string = LocatorSchemaPathAlias<LocatorSchemaPathType>> = PlaywrightFilterDefinition | (Omit<PlaywrightFilterDefinition, "has" | "hasNot"> & {
+    has?: PlaywrightFilterDefinition["has"] | FilterLocatorReference<LocatorSchemaPathType, AllowedPaths>;
+    hasNot?: PlaywrightFilterDefinition["hasNot"] | FilterLocatorReference<LocatorSchemaPathType, AllowedPaths>;
+});
+type LocatorSchemaRecord<LocatorSchemaPathType extends string = string, AllowedPaths extends string = LocatorSchemaPathAlias<LocatorSchemaPathType>> = {
+    locatorSchemaPath: LocatorSchemaPathAlias<LocatorSchemaPathType>;
+    definition: LocatorStrategyDefinition;
+    steps?: LocatorStep<LocatorSchemaPathType, AllowedPaths>[];
+    description?: LocatorDescription;
+};
+type LocatorUpdateFor<Definition extends LocatorStrategyDefinition> = {
+    type: Definition["type"];
+} & Partial<Omit<Definition, "type">>;
+type LocatorUpdate = LocatorUpdateFor<RoleDefinition> | LocatorUpdateFor<TextDefinition> | LocatorUpdateFor<LabelDefinition> | LocatorUpdateFor<PlaceholderDefinition> | LocatorUpdateFor<AltTextDefinition> | LocatorUpdateFor<TitleDefinition> | LocatorUpdateFor<LocatorDefinition> | LocatorUpdateFor<FrameLocatorDefinition> | LocatorUpdateFor<TestIdDefinition> | LocatorUpdateFor<IdDefinition>;
+type IndexSelector = number | "first" | "last";
 
-declare class BaseApi {
-    protected baseUrl: string;
-    apiName: string;
+type LocatorRegistrationPostDefinitionBuilder<LocatorSchemaPathType extends string, Path extends RegistryPath<LocatorSchemaPathType>> = {
+    filter: (filter: FilterDefinition<RegistryPath<LocatorSchemaPathType>, RegistryPath<LocatorSchemaPathType>>) => LocatorRegistrationPostDefinitionBuilder<LocatorSchemaPathType, Path>;
+    nth: (index: IndexSelector) => LocatorRegistrationPostDefinitionBuilder<LocatorSchemaPathType, Path>;
+    describe: (description: LocatorDescription) => LocatorRegistrationPostDefinitionBuilder<LocatorSchemaPathType, Path>;
+};
+declare class LocatorRegistrationBuilder<LocatorSchemaPathType extends string, Path extends RegistryPath<LocatorSchemaPathType>, Seeded extends boolean = false> {
+    private readonly registry;
+    private readonly path;
+    private steps;
+    private definition?;
+    private description?;
+    private registered;
+    private readonly reuseType?;
+    private readonly seededDefinition;
+    private overrideApplied;
+    private postDefinitionView?;
+    constructor(registry: LocatorRegistryInternal<LocatorSchemaPathType>, path: Path, seed?: {
+        initialDefinition?: LocatorStrategyDefinition;
+        initialSteps?: LocatorStep<LocatorSchemaPathType, RegistryPath<LocatorSchemaPathType>>[];
+        reuseType?: LocatorStrategyDefinition["type"];
+        initialDescription?: LocatorDescription;
+    });
+    persistSeededDefinition(): this;
+    /**
+     * Records a Playwright-style filter on the locator being registered. Filters are applied in the
+     * order they are chained and can include `has`/`hasNot` locator references. Requires that a
+     * locator strategy has already been set for this registration.
+     *
+     * @example
+     * ```ts
+     * registry.add("list.item").locator("li").filter({ hasText: /Row/ });
+     * ```
+     */
+    filter(filter: FilterDefinition<RegistryPath<LocatorSchemaPathType>, RegistryPath<LocatorSchemaPathType>>): LocatorRegistrationPostDefinitionBuilder<LocatorSchemaPathType, Path>;
+    /**
+     * Adds an index selector for the locator being registered. Indices are applied in the order they
+     * are chained and require a locator definition to have been set first.
+     *
+     * @example
+     * ```ts
+     * registry.add("table.rows").locator("tr").nth(0);
+     * ```
+     */
+    nth(index: IndexSelector): LocatorRegistrationPostDefinitionBuilder<LocatorSchemaPathType, Path>;
+    describe(description: LocatorDescription): LocatorRegistrationPostDefinitionBuilder<LocatorSchemaPathType, Path>;
+    /**
+     * Uses Playwright `getByRole` semantics to define the locator strategy. Accepts a role and
+     * optional options; when seeded via `{ reuse }`, an options-only call patches the seeded role.
+     *
+     * @example
+     * ```ts
+     * registry.add("nav.home").getByRole("link", { name: "Home" });
+     * ```
+     */
+    getByRole(role: RoleDefinition["role"], options: RoleDefinition["options"]): LocatorRegistrationPostDefinitionBuilder<LocatorSchemaPathType, Path>;
+    getByRole(role: RoleDefinition["role"]): LocatorRegistrationPostDefinitionBuilder<LocatorSchemaPathType, Path>;
+    getByRole(options: Seeded extends true ? RoleDefinition["options"] : never): LocatorRegistrationPostDefinitionBuilder<LocatorSchemaPathType, Path>;
+    /**
+     * Uses Playwright `getByText` semantics to define the locator strategy. Accepts string/RegExp
+     * text and optional options; when seeded, an options-only call patches the seeded text.
+     *
+     * @example
+     * ```ts
+     * registry.add("alert.error").getByText(/failed/i);
+     * ```
+     */
+    getByText(text: Parameters<Page["getByText"]>[0], options: Parameters<Page["getByText"]>[1]): LocatorRegistrationPostDefinitionBuilder<LocatorSchemaPathType, Path>;
+    getByText(text: Parameters<Page["getByText"]>[0]): LocatorRegistrationPostDefinitionBuilder<LocatorSchemaPathType, Path>;
+    getByText(options: Seeded extends true ? Parameters<Page["getByText"]>[1] : never): LocatorRegistrationPostDefinitionBuilder<LocatorSchemaPathType, Path>;
+    /**
+     * Uses Playwright `getByLabel` semantics to define the locator strategy. Accepts label text and
+     * optional options; when seeded, an options-only call patches the seeded text.
+     *
+     * @example
+     * ```ts
+     * registry.add("form.email").getByLabel("Email", { exact: true });
+     * ```
+     */
+    getByLabel(text: Parameters<Page["getByLabel"]>[0], options: Parameters<Page["getByLabel"]>[1]): LocatorRegistrationPostDefinitionBuilder<LocatorSchemaPathType, Path>;
+    getByLabel(text: Parameters<Page["getByLabel"]>[0]): LocatorRegistrationPostDefinitionBuilder<LocatorSchemaPathType, Path>;
+    getByLabel(options: Seeded extends true ? Parameters<Page["getByLabel"]>[1] : never): LocatorRegistrationPostDefinitionBuilder<LocatorSchemaPathType, Path>;
+    /**
+     * Uses Playwright `getByPlaceholder` semantics to define the locator strategy. Accepts placeholder
+     * text and optional options; when seeded, an options-only call patches the seeded text.
+     *
+     * @example
+     * ```ts
+     * registry.add("form.search").getByPlaceholder("Search", { exact: true });
+     * ```
+     */
+    getByPlaceholder(text: Parameters<Page["getByPlaceholder"]>[0], options: Parameters<Page["getByPlaceholder"]>[1]): LocatorRegistrationPostDefinitionBuilder<LocatorSchemaPathType, Path>;
+    getByPlaceholder(text: Parameters<Page["getByPlaceholder"]>[0]): LocatorRegistrationPostDefinitionBuilder<LocatorSchemaPathType, Path>;
+    getByPlaceholder(options: Seeded extends true ? Parameters<Page["getByPlaceholder"]>[1] : never): LocatorRegistrationPostDefinitionBuilder<LocatorSchemaPathType, Path>;
+    /**
+     * Uses Playwright `getByAltText` semantics to define the locator strategy. Accepts alt text and
+     * optional options; when seeded, an options-only call patches the seeded text.
+     *
+     * @example
+     * ```ts
+     * registry.add("image.logo").getByAltText(/brand/);
+     * ```
+     */
+    getByAltText(text: Parameters<Page["getByAltText"]>[0], options: Parameters<Page["getByAltText"]>[1]): LocatorRegistrationPostDefinitionBuilder<LocatorSchemaPathType, Path>;
+    getByAltText(text: Parameters<Page["getByAltText"]>[0]): LocatorRegistrationPostDefinitionBuilder<LocatorSchemaPathType, Path>;
+    getByAltText(options: Seeded extends true ? Parameters<Page["getByAltText"]>[1] : never): LocatorRegistrationPostDefinitionBuilder<LocatorSchemaPathType, Path>;
+    /**
+     * Uses Playwright `getByTitle` semantics to define the locator strategy. Accepts title text and
+     * optional options; when seeded, an options-only call patches the seeded text.
+     *
+     * @example
+     * ```ts
+     * registry.add("icon.info").getByTitle("Info");
+     * ```
+     */
+    getByTitle(text: Parameters<Page["getByTitle"]>[0], options: Parameters<Page["getByTitle"]>[1]): LocatorRegistrationPostDefinitionBuilder<LocatorSchemaPathType, Path>;
+    getByTitle(text: Parameters<Page["getByTitle"]>[0]): LocatorRegistrationPostDefinitionBuilder<LocatorSchemaPathType, Path>;
+    getByTitle(options: Seeded extends true ? Parameters<Page["getByTitle"]>[1] : never): LocatorRegistrationPostDefinitionBuilder<LocatorSchemaPathType, Path>;
+    /**
+     * Uses Playwright `locator` semantics to define the locator strategy. Accepts a selector and
+     * optional options; when seeded, an options-only call patches the seeded selector by merging
+     * options while inheriting the selector.
+     *
+     * @example
+     * ```ts
+     * registry.add("list.items").locator("ul > li");
+     * ```
+     */
+    locator(selector: Parameters<Page["locator"]>[0], options: Parameters<Page["locator"]>[1]): LocatorRegistrationPostDefinitionBuilder<LocatorSchemaPathType, Path>;
+    locator(selector: Parameters<Page["locator"]>[0]): LocatorRegistrationPostDefinitionBuilder<LocatorSchemaPathType, Path>;
+    locator(options: Seeded extends true ? Parameters<Page["locator"]>[1] : never): LocatorRegistrationPostDefinitionBuilder<LocatorSchemaPathType, Path>;
+    /**
+     * Uses Playwright `frameLocator` semantics to define the locator strategy, entering the targeted
+     * frame for subsequent chained locators. When seeded, `selector` may be omitted to retain the
+     * existing selector while overriding options elsewhere.
+     *
+     * @example
+     * ```ts
+     * registry.add("frame.login").frameLocator("iframe.auth");
+     * ```
+     */
+    frameLocator(selector: Seeded extends true ? Parameters<Page["frameLocator"]>[0] | undefined : Parameters<Page["frameLocator"]>[0]): LocatorRegistrationPostDefinitionBuilder<LocatorSchemaPathType, Path>;
+    /**
+     * Uses Playwright `getByTestId` semantics to define the locator strategy. When seeded, omitting
+     * the argument inherits the seeded `testId` while allowing options from other overrides.
+     *
+     * @example
+     * ```ts
+     * registry.add("card.title").getByTestId("card-title");
+     * ```
+     */
+    getByTestId(testId: Seeded extends true ? Parameters<Page["getByTestId"]>[0] | undefined : Parameters<Page["getByTestId"]>[0]): LocatorRegistrationPostDefinitionBuilder<LocatorSchemaPathType, Path>;
+    /**
+     * Targets elements by `id`, normalizing string or RegExp input. When seeded, the argument can be
+     * omitted to inherit the seeded id.
+     *
+     * @example
+     * ```ts
+     * registry.add("modal.close").getById("close-modal");
+     * ```
+     */
+    getById(id: Seeded extends true ? string | RegExp | undefined : string | RegExp): LocatorRegistrationPostDefinitionBuilder<LocatorSchemaPathType, Path>;
+    private commit;
+    private applyFilter;
+    private applyIndex;
+    private ensureDefinitionAllowedWithRollback;
+    private ensureDefinition;
+    private persist;
+    private rollbackSeededRegistration;
+    private getPostDefinitionView;
+}
+type LocatorRegistrationPreDefinitionBuilder<LocatorSchemaPathType extends string, Path extends RegistryPath<LocatorSchemaPathType>, Seeded extends boolean = false> = LocatorRegistrationPostDefinitionBuilder<LocatorSchemaPathType, Path> & Pick<LocatorRegistrationBuilder<LocatorSchemaPathType, Path, Seeded>, "getByRole" | "getByText" | "getByLabel" | "getByPlaceholder" | "getByAltText" | "getByTitle" | "locator" | "frameLocator" | "getByTestId" | "getById">;
+type LocatorMethodForType<Type extends LocatorStrategyDefinition["type"]> = Type extends "role" ? "getByRole" : Type extends "text" ? "getByText" : Type extends "label" ? "getByLabel" : Type extends "placeholder" ? "getByPlaceholder" : Type extends "altText" ? "getByAltText" : Type extends "title" ? "getByTitle" : Type extends "locator" ? "locator" : Type extends "frameLocator" ? "frameLocator" : Type extends "testId" ? "getByTestId" : Type extends "id" ? "getById" : never;
+type LocatorRegistrationSeededBuilderForType<LocatorSchemaPathType extends string, Path extends RegistryPath<LocatorSchemaPathType>, SeededType extends LocatorStrategyDefinition["type"]> = LocatorRegistrationPostDefinitionBuilder<LocatorSchemaPathType, Path> & Pick<LocatorRegistrationBuilder<LocatorSchemaPathType, Path, true>, LocatorMethodForType<SeededType>>;
+
+declare class ReusableLocatorBuilder<LocatorSchemaPathType extends string, AllowedPaths extends string = RegistryPath<LocatorSchemaPathType>, Type extends LocatorStrategyDefinition["type"] = LocatorStrategyDefinition["type"]> implements ReusableLocator<LocatorSchemaPathType, AllowedPaths, Type> {
+    private readonly stepsList;
+    private readonly definitionValue;
+    private descriptionValue?;
+    readonly type: Type;
+    constructor(definition: Extract<LocatorStrategyDefinition, {
+        type: Type;
+    }>, steps?: LocatorStep<LocatorSchemaPathType, AllowedPaths>[]);
+    filter(filter: FilterDefinition<RegistryPath<LocatorSchemaPathType>, AllowedPaths>): this;
+    nth(index: IndexSelector): this;
+    describe(description: LocatorDescription): this;
+    get definition(): Extract<RoleDefinition, {
+        type: Type;
+    }> | Extract<TextDefinition, {
+        type: Type;
+    }> | Extract<LabelDefinition, {
+        type: Type;
+    }> | Extract<PlaceholderDefinition, {
+        type: Type;
+    }> | Extract<AltTextDefinition, {
+        type: Type;
+    }> | Extract<TitleDefinition, {
+        type: Type;
+    }> | Extract<LocatorDefinition, {
+        type: Type;
+    }> | Extract<FrameLocatorDefinition, {
+        type: Type;
+    }> | Extract<TestIdDefinition, {
+        type: Type;
+    }> | Extract<IdDefinition, {
+        type: Type;
+    }>;
+    get steps(): ({
+        kind: "index";
+        index: IndexSelector | null;
+    } | {
+        kind: "filter";
+        filter: FilterDefinition<LocatorSchemaPathType, AllowedPaths>;
+    })[];
+    get description(): string | undefined;
+}
+declare class ReusableLocatorFactory<LocatorSchemaPathType extends string> {
+    getByRole(role: RoleDefinition["role"], options: RoleDefinition["options"]): ReusableLocatorBuilder<LocatorSchemaPathType, RegistryPath<LocatorSchemaPathType>, "role">;
+    getByRole(role: RoleDefinition["role"]): ReusableLocatorBuilder<LocatorSchemaPathType, RegistryPath<LocatorSchemaPathType>, "role">;
+    getByText(text: Parameters<Page["getByText"]>[0], options: Parameters<Page["getByText"]>[1]): ReusableLocatorBuilder<LocatorSchemaPathType, RegistryPath<LocatorSchemaPathType>, "text">;
+    getByText(text: Parameters<Page["getByText"]>[0]): ReusableLocatorBuilder<LocatorSchemaPathType, RegistryPath<LocatorSchemaPathType>, "text">;
+    getByLabel(text: Parameters<Page["getByLabel"]>[0], options: Parameters<Page["getByLabel"]>[1]): ReusableLocatorBuilder<LocatorSchemaPathType, RegistryPath<LocatorSchemaPathType>, "label">;
+    getByLabel(text: Parameters<Page["getByLabel"]>[0]): ReusableLocatorBuilder<LocatorSchemaPathType, RegistryPath<LocatorSchemaPathType>, "label">;
+    getByPlaceholder(text: Parameters<Page["getByPlaceholder"]>[0], options: Parameters<Page["getByPlaceholder"]>[1]): ReusableLocatorBuilder<LocatorSchemaPathType, RegistryPath<LocatorSchemaPathType>, "placeholder">;
+    getByPlaceholder(text: Parameters<Page["getByPlaceholder"]>[0]): ReusableLocatorBuilder<LocatorSchemaPathType, RegistryPath<LocatorSchemaPathType>, "placeholder">;
+    getByAltText(text: Parameters<Page["getByAltText"]>[0], options: Parameters<Page["getByAltText"]>[1]): ReusableLocatorBuilder<LocatorSchemaPathType, RegistryPath<LocatorSchemaPathType>, "altText">;
+    getByAltText(text: Parameters<Page["getByAltText"]>[0]): ReusableLocatorBuilder<LocatorSchemaPathType, RegistryPath<LocatorSchemaPathType>, "altText">;
+    getByTitle(text: Parameters<Page["getByTitle"]>[0], options: Parameters<Page["getByTitle"]>[1]): ReusableLocatorBuilder<LocatorSchemaPathType, RegistryPath<LocatorSchemaPathType>, "title">;
+    getByTitle(text: Parameters<Page["getByTitle"]>[0]): ReusableLocatorBuilder<LocatorSchemaPathType, RegistryPath<LocatorSchemaPathType>, "title">;
+    locator(selector: Parameters<Page["locator"]>[0], options: Parameters<Page["locator"]>[1]): ReusableLocatorBuilder<LocatorSchemaPathType, RegistryPath<LocatorSchemaPathType>, "locator">;
+    locator(selector: Parameters<Page["locator"]>[0]): ReusableLocatorBuilder<LocatorSchemaPathType, RegistryPath<LocatorSchemaPathType>, "locator">;
+    frameLocator(selector: Parameters<Page["frameLocator"]>[0]): ReusableLocatorBuilder<LocatorSchemaPathType, RegistryPath<LocatorSchemaPathType>, "frameLocator">;
+    getByTestId(testId: Parameters<Page["getByTestId"]>[0]): ReusableLocatorBuilder<LocatorSchemaPathType, RegistryPath<LocatorSchemaPathType>, "testId">;
+    getById(id: string | RegExp): ReusableLocatorBuilder<LocatorSchemaPathType, RegistryPath<LocatorSchemaPathType>, "id">;
+    private create;
+}
+
+declare class LocatorRegistryInternal<LocatorSchemaPathType extends string> {
+    private readonly page;
+    private readonly schemas;
+    /**
+     * Factory for reusable locator seeds that capture a locator strategy plus any chained
+     * `filter`/`nth` steps without registering them. Pass the resulting seed to
+     * {@link LocatorRegistryInternal.add} via `{ reuse }` to register a path that inherits the
+     * stored definition and steps.
+     *
+     * @example
+     * ```ts
+     * const seed = registry.createReusable.getByRole("heading", { level: 2 }).filter({ hasText: /Summary/ });
+     * registry.add("hero.title", { reuse: seed }).getByRole({ name: "Summary" });
+     * ```
+     */
+    readonly createReusable: ReusableLocatorFactory<LocatorSchemaPathType>;
+    constructor(page: Page);
+    private normalizeRecord;
+    private cloneRecordForReuse;
+    /**
+     * Registers a locator schema at the provided dot-delimited path.
+     * Accepts exactly one locator strategy (`getByRole`, `locator`, etc.) and any number of
+     * `filter`/`nth` steps chained in call order. When `{ reuse }` is supplied, the seeded
+     * definition is applied first and one matching override is allowed as a PATCH of the seed;
+     * otherwise, calling multiple locator strategies will throw.
+     *
+     * @example
+     * ```ts
+     * registry
+     *   .add("list.item")
+     *   .getByRole("listitem", { name: /Row/ })
+     *   .filter({ hasText: "Row" })
+     *   .nth("last");
+     * ```
+     */
+    add(path: RegistryPath<LocatorSchemaPathType>): LocatorRegistrationPreDefinitionBuilder<LocatorSchemaPathType, RegistryPath<LocatorSchemaPathType>, false>;
+    add(path: RegistryPath<LocatorSchemaPathType>, options: {
+        reuse: RegistryPath<LocatorSchemaPathType>;
+    }): void;
+    add<Reuse extends ReusableLocator<LocatorSchemaPathType, RegistryPath<LocatorSchemaPathType>, LocatorStrategyDefinition["type"]>>(path: RegistryPath<LocatorSchemaPathType>, options: {
+        reuse: Reuse;
+    }): LocatorRegistrationSeededBuilderForType<LocatorSchemaPathType, RegistryPath<LocatorSchemaPathType>, Reuse["type"]>;
+    register(path: RegistryPath<LocatorSchemaPathType>, record: LocatorSchemaRecord<LocatorSchemaPathType, RegistryPath<LocatorSchemaPathType>>): void;
+    replace(path: RegistryPath<LocatorSchemaPathType>, record: LocatorSchemaRecord<LocatorSchemaPathType, RegistryPath<LocatorSchemaPathType>>): void;
+    get(path: RegistryPath<LocatorSchemaPathType>): LocatorSchemaRecord<LocatorSchemaPathType, RegistryPath<LocatorSchemaPathType>>;
+    unregister(path: RegistryPath<LocatorSchemaPathType>): void;
+    getIfExists(path: RegistryPath<LocatorSchemaPathType>): LocatorSchemaRecord<LocatorSchemaPathType, RegistryPath<LocatorSchemaPathType>> | undefined;
+    private resolveFilterLocator;
+    private createResolutionContext;
+    private getLocatorWithContext;
+    private resolveFiltersForTarget;
+    /**
+     * Returns a mutable query builder clone for the provided path. Use the builder to add or clear
+     * `filter`/`nth` steps, or to `update`/`replace` locator definitions before resolving locators.
+     * Changes affect only the builder clone; the registry’s stored schema remains untouched.
+     *
+     * @example
+     * ```ts
+     * const builder = registry
+     *   .getLocatorSchema("section.button")
+     *   .filter("section.button", { hasText: /Save/ })
+     *   .nth("section", 0);
+     * const locator = builder.getNestedLocator();
+     * ```
+     */
+    getLocatorSchema<Path extends RegistryPath<LocatorSchemaPathType>>(path: Path): LocatorQueryBuilderPublic<LocatorSchemaPathType, Path>;
+    /**
+     * Resolves the Playwright {@link Locator} for the provided path, applying only the terminal
+     * definition and its recorded steps (no ancestor chaining). Throws if the path is not registered.
+     *
+     * @example
+     * ```ts
+     * const button = registry.getLocator("form.submit");
+     * await button.click();
+     * ```
+     */
+    getLocator<Path extends RegistryPath<LocatorSchemaPathType>>(path: Path): Locator;
+    /**
+     * Resolves a chained Playwright {@link Locator} for a nested path, traversing each registered
+     * segment and applying their steps in order. Throws if any segment in the chain is missing.
+     *
+     * @example
+     * ```ts
+     * const nested = registry.getNestedLocator("list.item");
+     * await expect(nested).toBeVisible();
+     * ```
+     */
+    getNestedLocator<Path extends RegistryPath<LocatorSchemaPathType>>(path: Path): Locator;
+    buildLocatorChain(path: RegistryPath<LocatorSchemaPathType>, definitions: Map<string, LocatorStrategyDefinition>, steps: Map<string, LocatorStep<RegistryPath<LocatorSchemaPathType>, RegistryPath<LocatorSchemaPathType>>[]>, tombstones?: Set<string>, terminalDescription?: LocatorDescription, context?: {
+        rootPath: RegistryPath<LocatorSchemaPathType>;
+        resolvingPaths: Set<string>;
+    }): {
+        locator: Locator | null;
+        steps: {
+            path: string;
+            definition: LocatorStrategyDefinition;
+            appliedFilters: ResolvedFilterDefinition[];
+            index?: IndexSelector | null | undefined;
+            recordedSteps: LocatorStep<RegistryPath<LocatorSchemaPathType>, RegistryPath<LocatorSchemaPathType>>[];
+        }[];
+    };
+}
+type GetLocatorAccessor<LocatorSchemaPathType extends string> = <Path extends RegistryPath<LocatorSchemaPathType>>(path: Path) => Locator;
+type AddAccessor<LocatorSchemaPathType extends string> = LocatorRegistryInternal<LocatorSchemaPathType>["add"];
+type GetLocatorSchemaAccessor<LocatorSchemaPathType extends string> = <Path extends RegistryPath<LocatorSchemaPathType>>(path: Path) => LocatorQueryBuilderPublic<LocatorSchemaPathType, Path>;
+type GetNestedLocatorAccessor<LocatorSchemaPathType extends string> = <Path extends RegistryPath<LocatorSchemaPathType>>(path: Path) => Locator;
+type LocatorRegistry<LocatorSchemaPathType extends string> = Pick<LocatorRegistryInternal<LocatorSchemaPathType>, "add" | "createReusable" | "getLocator" | "getLocatorSchema" | "getNestedLocator">;
+/**
+ * Creates a v2 locator registry bound to a Playwright {@link Page} and returns the registry plus
+ * pre-bound helpers for ergonomic use in page objects and tests. Path unions are validated at
+ * compile time and runtime. The returned `add`/`getLocator`/`getNestedLocator`/`getLocatorSchema`
+ * accessors are pre-bound to the registry instance for dependency injection.
+ *
+ * @example
+ * ```ts
+ * const { registry, add, getNestedLocator, getLocatorSchema } =
+ *   createRegistryWithAccessors<"root" | "root.child">(page);
+ *
+ * registry.add("root").locator("section");
+ * registry.add("root.child").getByRole("heading", { level: 2 });
+ *
+ * const nested = getNestedLocator("root.child");
+ * const patched = getLocatorSchema("root.child").filter("root.child", { hasText: /Docs/ }).getNestedLocator();
+ * ```
+ */
+declare const createRegistryWithAccessors: <Paths extends string>(page: Page) => {
+    readonly registry: LocatorRegistry<Paths>;
+    readonly add: {
+        (path: RegistryPath<Paths>): LocatorRegistrationPreDefinitionBuilder<Paths, RegistryPath<Paths>, false>;
+        (path: RegistryPath<Paths>, options: {
+            reuse: RegistryPath<Paths>;
+        }): void;
+        <Reuse extends ReusableLocator<Paths, RegistryPath<Paths>, "role" | "text" | "label" | "placeholder" | "altText" | "title" | "locator" | "frameLocator" | "testId" | "id">>(path: RegistryPath<Paths>, options: {
+            reuse: Reuse;
+        }): LocatorRegistrationSeededBuilderForType<Paths, RegistryPath<Paths>, Reuse["type"]>;
+    };
+    readonly getLocator: GetLocatorAccessor<Paths>;
+    readonly getNestedLocator: GetNestedLocatorAccessor<Paths>;
+    readonly getLocatorSchema: GetLocatorSchemaAccessor<Paths>;
+};
+
+type UpdateArgsWithOptions<Primary, Options> = [] | [Primary] | [Options] | [Primary, Options];
+type UpdateArgsWithoutOptions<Primary> = [] | [Primary];
+declare class LocatorUpdateBuilder<LocatorSchemaPathType extends string, LocatorSubstring extends RegistryPath<LocatorSchemaPathType>, SubPath extends LocatorChainPaths<RegistryPath<LocatorSchemaPathType>, LocatorSubstring>> {
+    private readonly parent;
+    private readonly subPath;
+    private readonly mode;
+    constructor(parent: LocatorQueryBuilder<LocatorSchemaPathType, LocatorSubstring>, subPath: SubPath, mode?: "update" | "replace");
+    /**
+     * Defines or patches a `getByRole` locator strategy for the target subpath. In `update` mode the
+     * `role` and `options` arguments are optional (PATCH semantics); in `replace` mode they follow
+     * Playwright requirements (POST semantics) and `role` is required.
+     *
+     * @example
+     * ```ts
+     * getLocatorSchema("form.button")
+     *   .update("form.button")
+     *   .getByRole({ name: "Save" })
+     *   .getNestedLocator();
+     * ```
+     */
+    getByRole(...args: UpdateArgsWithOptions<RoleDefinition["role"], RoleDefinition["options"]>): LocatorQueryBuilder<LocatorSchemaPathType, LocatorSubstring>;
+    /**
+     * Defines or patches a `getByText` locator strategy for the target subpath. In `update` mode,
+     * text/options are optional; in `replace` mode text is required.
+     *
+     * @example
+     * ```ts
+     * getLocatorSchema("banner.message")
+     *   .replace("banner.message")
+     *   .getByText(/Updated/, { exact: false })
+     *   .getNestedLocator();
+     * ```
+     */
+    getByText(...args: UpdateArgsWithOptions<Parameters<Page["getByText"]>[0], Parameters<Page["getByText"]>[1]>): LocatorQueryBuilder<LocatorSchemaPathType, LocatorSubstring>;
+    /**
+     * Defines or patches a `getByLabel` locator strategy for the target subpath. In `update` mode the
+     * label text/options are optional; in `replace` mode text is required.
+     *
+     * @example
+     * ```ts
+     * getLocatorSchema("form.email").update("form.email").getByLabel({ exact: true }).getNestedLocator();
+     * ```
+     */
+    getByLabel(...args: UpdateArgsWithOptions<Parameters<Page["getByLabel"]>[0], Parameters<Page["getByLabel"]>[1]>): LocatorQueryBuilder<LocatorSchemaPathType, LocatorSubstring>;
+    /**
+     * Defines or patches a `getByPlaceholder` locator strategy for the target subpath. In `update`
+     * mode text/options are optional; in `replace` mode text is required.
+     *
+     * @example
+     * ```ts
+     * getLocatorSchema("form.search").update("form.search").getByPlaceholder({ exact: true }).getNestedLocator();
+     * ```
+     */
+    getByPlaceholder(...args: UpdateArgsWithOptions<Parameters<Page["getByPlaceholder"]>[0], Parameters<Page["getByPlaceholder"]>[1]>): LocatorQueryBuilder<LocatorSchemaPathType, LocatorSubstring>;
+    /**
+     * Defines or patches a `getByAltText` locator strategy for the target subpath. In `update` mode
+     * text/options are optional; in `replace` mode text is required.
+     *
+     * @example
+     * ```ts
+     * getLocatorSchema("image.logo").replace("image.logo").getByAltText("Logo").getNestedLocator();
+     * ```
+     */
+    getByAltText(...args: UpdateArgsWithOptions<Parameters<Page["getByAltText"]>[0], Parameters<Page["getByAltText"]>[1]>): LocatorQueryBuilder<LocatorSchemaPathType, LocatorSubstring>;
+    /**
+     * Defines or patches a `getByTitle` locator strategy for the target subpath. In `update` mode
+     * text/options are optional; in `replace` mode text is required.
+     *
+     * @example
+     * ```ts
+     * getLocatorSchema("icon.info").update("icon.info").getByTitle({ exact: true }).getNestedLocator();
+     * ```
+     */
+    getByTitle(...args: UpdateArgsWithOptions<Parameters<Page["getByTitle"]>[0], Parameters<Page["getByTitle"]>[1]>): LocatorQueryBuilder<LocatorSchemaPathType, LocatorSubstring>;
+    /**
+     * Defines or patches a `locator` strategy for the target subpath. In `update` mode selector and
+     * options are optional and merge with the existing definition; in `replace` mode selector is
+     * required.
+     *
+     * @example
+     * ```ts
+     * getLocatorSchema("list.items")
+     *   .replace("list.items")
+     *   .locator("ul > li", { hasText: /Row/ })
+     *   .getNestedLocator();
+     * ```
+     */
+    locator(...args: UpdateArgsWithOptions<Parameters<Page["locator"]>[0], Parameters<Page["locator"]>[1]>): LocatorQueryBuilder<LocatorSchemaPathType, LocatorSubstring>;
+    /**
+     * Defines or patches a `frameLocator` strategy for the target subpath. In `update` mode the
+     * selector is optional and, when omitted, inherits the existing selector; in `replace` mode the
+     * selector is required.
+     *
+     * @example
+     * ```ts
+     * getLocatorSchema("frame.login").replace("frame.login").frameLocator("iframe.auth").getNestedLocator();
+     * ```
+     */
+    frameLocator(...args: UpdateArgsWithoutOptions<Parameters<Page["frameLocator"]>[0]>): LocatorQueryBuilder<LocatorSchemaPathType, LocatorSubstring>;
+    /**
+     * Defines or patches a `getByTestId` locator strategy for the target subpath. In `update` mode
+     * `testId` is optional and merges with existing options; in `replace` mode it is required.
+     *
+     * @example
+     * ```ts
+     * getLocatorSchema("card.title").update("card.title").getByTestId().getNestedLocator();
+     * ```
+     */
+    getByTestId(...args: UpdateArgsWithoutOptions<Parameters<Page["getByTestId"]>[0]>): LocatorQueryBuilder<LocatorSchemaPathType, LocatorSubstring>;
+    /**
+     * Defines or patches an `id` locator strategy for the target subpath. In `update` mode the id is
+     * optional and will be normalized if provided; in `replace` mode the id is required.
+     *
+     * @example
+     * ```ts
+     * getLocatorSchema("modal.close").update("modal.close").getById().getNestedLocator();
+     * ```
+     */
+    getById(...args: UpdateArgsWithoutOptions<string | RegExp>): LocatorQueryBuilder<LocatorSchemaPathType, LocatorSubstring>;
+    private commit;
+}
+
+type LocatorQueryBuilderPublic<LocatorSchemaPathType extends string, LocatorSubstring extends RegistryPath<LocatorSchemaPathType>> = Pick<LocatorQueryBuilder<LocatorSchemaPathType, LocatorSubstring>, "filter" | "clearSteps" | "nth" | "describe" | "update" | "replace" | "remove" | "getLocator" | "getNestedLocator">;
+declare class LocatorQueryBuilder<LocatorSchemaPathType extends string, LocatorSubstring extends RegistryPath<LocatorSchemaPathType>> {
+    private readonly registry;
+    private readonly path;
+    private readonly definitions;
+    private readonly perPathTypeCache;
+    private readonly steps;
+    private readonly descriptions;
+    private readonly tombstones;
+    constructor(registry: LocatorRegistryInternal<LocatorSchemaPathType>, path: LocatorSubstring);
+    /**
+     * Starts a PATCH-style update for the locator definition at the given `subPath` within this
+     * builder. Returns a builder exposing the same locator-type methods as `registry.add`, with all
+     * arguments optional to merge with the existing definition. The registry remains unchanged until
+     * you resolve with `getLocator`/`getNestedLocator`.
+     *
+     * If `subPath` is omitted, the terminal path for this builder (`path` passed to
+     * `getLocatorSchema`) is used.
+     *
+     * @example
+     * ```ts
+     * getLocatorSchema("form.button")
+     *   .update("form.button")
+     *   .getByRole({ name: "Submit" })
+     *   .getNestedLocator();
+     * ```
+     */
+    update(): LocatorUpdateBuilder<LocatorSchemaPathType, LocatorSubstring, LocatorChainPaths<RegistryPath<LocatorSchemaPathType>, LocatorSubstring>>;
+    update<SubPath extends LocatorChainPaths<RegistryPath<LocatorSchemaPathType>, LocatorSubstring>>(subPath: SubPath): LocatorUpdateBuilder<LocatorSchemaPathType, LocatorSubstring, SubPath>;
+    /**
+     * Records a Playwright-style filter for the specified `subPath` within this builder. Unlike
+     * `registry.add`, `subPath` is optional here: when omitted, the terminal path for this builder is
+     * used. Provide an explicit `subPath` when targeting an ancestor segment.
+     *
+     * @example
+     * ```ts
+     * getLocatorSchema("list.item")
+     *   .filter("list", { hasText: "List" })
+     *   .filter("list.item", { hasText: "Row" });
+     * ```
+     */
+    filter(filter: FilterDefinition<RegistryPath<LocatorSchemaPathType>, RegistryPath<LocatorSchemaPathType>>): this;
+    filter<SubPath extends LocatorChainPaths<RegistryPath<LocatorSchemaPathType>, LocatorSubstring>>(subPath: SubPath, filter: FilterDefinition<RegistryPath<LocatorSchemaPathType>, RegistryPath<LocatorSchemaPathType>>): this;
+    /**
+     * Clears all recorded `filter`/`nth` steps for the specified `subPath` in this builder, leaving
+     * the locator definition intact. If `subPath` is omitted, the terminal path for this builder is
+     * used; provide an explicit `subPath` to clear ancestor steps.
+     *
+     * @example
+     * ```ts
+     * getLocatorSchema("list.item").clearSteps("list.item").getNestedLocator();
+     * ```
+     */
+    clearSteps(): this;
+    clearSteps<SubPath extends LocatorChainPaths<RegistryPath<LocatorSchemaPathType>, LocatorSubstring>>(subPath: SubPath): this;
+    /**
+     * Records an index selector for the specified `subPath` in this builder. Indices are applied in
+     * the order they are chained and require that the subPath already exists on the builder. If
+     * `subPath` is omitted, the terminal path for this builder is used; provide an explicit `subPath`
+     * to target ancestor segments.
+     *
+     * @example
+     * ```ts
+     * getLocatorSchema("list.item").nth("list.item", 2).getNestedLocator();
+     * ```
+     */
+    nth(index: IndexSelector): this;
+    nth<SubPath extends LocatorChainPaths<RegistryPath<LocatorSchemaPathType>, LocatorSubstring>>(subPath: SubPath, index: IndexSelector): this;
+    /**
+     * Adds or overrides the description for the terminal path of this builder. The description is
+     * applied only to the resolved terminal locator and does not mutate registry state.
+     *
+     * @example
+     * ```ts
+     * getLocatorSchema("section.button")
+     *   .describe("Save button")
+     *   .getNestedLocator();
+     * ```
+     */
+    describe(description: LocatorDescription): this;
+    /** @internal */
+    applyUpdate<SubPath extends LocatorChainPaths<RegistryPath<LocatorSchemaPathType>, LocatorSubstring>>(subPath: SubPath, updates: LocatorUpdate): this;
+    /**
+     * Starts a POST-style replacement for the locator definition at the given `subPath` within this
+     * builder. Returns a builder exposing the same locator-type methods as `registry.add`, requiring
+     * primary arguments where Playwright does. Registry state is unchanged; the replacement applies
+     * to the builder clone when resolved. If `subPath` is omitted, the terminal path for this
+     * builder is used.
+     *
+     * @example
+     * ```ts
+     * getLocatorSchema("section.button")
+     *   .replace("section.button")
+     *   .getByRole("button", { name: "Save" })
+     *   .getNestedLocator();
+     * ```
+     */
+    replace(): LocatorUpdateBuilder<LocatorSchemaPathType, LocatorSubstring, LocatorChainPaths<RegistryPath<LocatorSchemaPathType>, LocatorSubstring>>;
+    replace<SubPath extends LocatorChainPaths<RegistryPath<LocatorSchemaPathType>, LocatorSubstring>>(subPath: SubPath): LocatorUpdateBuilder<LocatorSchemaPathType, LocatorSubstring, SubPath>;
+    /** @internal */
+    applyReplacement<SubPath extends LocatorChainPaths<RegistryPath<LocatorSchemaPathType>, LocatorSubstring>>(subPath: SubPath, updates: LocatorUpdate): this;
+    /**
+     * Soft-deletes the definition and steps for the given `subPath` on this builder clone, adding a
+     * tombstone. Non-terminal removals are skipped during resolution; terminal removals throw unless
+     * repopulated with `update`/`replace` before resolving. If `subPath` is omitted, the terminal
+     * path for this builder is used.
+     *
+     * @example
+     * ```ts
+     * const builder = getLocatorSchema("section.button");
+     * builder.remove("section.button");
+     * expect(() => builder.getNestedLocator()).toThrow();
+     * ```
+     */
+    remove(): this;
+    remove<SubPath extends LocatorChainPaths<RegistryPath<LocatorSchemaPathType>, LocatorSubstring>>(subPath: SubPath): this;
+    /**
+     * Resolves and returns the Playwright {@link Locator} for the terminal path of this builder,
+     * applying only the terminal definition and its steps. Throws if the terminal path has been
+     * removed or is otherwise missing.
+     *
+     * @example
+     * ```ts
+     * const locator = getLocatorSchema("form.submit").getLocator();
+     * ```
+     */
+    getLocator(): Locator;
+    /**
+     * Resolves the chained Playwright {@link Locator} for this builder’s root path, traversing each
+     * registered segment and applying recorded steps. Throws if any required segment is missing.
+     *
+     * @example
+     * ```ts
+     * const nested = getLocatorSchema("list.item")
+     *   .filter("list", { hasText: "List" })
+     *   .getNestedLocator();
+     * ```
+     */
+    getNestedLocator(): Locator;
+    private ensureSubPath;
+    private resolve;
+    private ensureTypeCache;
+}
+
+/**
+ * BasePageOptions can define optional patterns for baseUrl and urlPath.
+ * Defaults assume they are strings if not specified.
+ */
+type BasePageOptions = {
+    urlOptions?: {
+        baseUrlType?: string | RegExp;
+        urlPathType?: string | RegExp;
+    };
+};
+type ExtractBaseUrlType<T extends BasePageOptions> = T["urlOptions"] extends {
+    baseUrlType: RegExp;
+} ? RegExp : string;
+type ExtractUrlPathType<T extends BasePageOptions> = T["urlOptions"] extends {
+    urlPathType: RegExp;
+} ? RegExp : string;
+type ExtractFullUrlType<T extends BasePageOptions> = T["urlOptions"] extends {
+    baseUrlType: RegExp;
+} | {
+    urlPathType: RegExp;
+} ? RegExp : string;
+/**
+ * @deprecated Transitional bridge for migrating from v1 to v2. This class will be removed in v2.
+ * Switch to PageObject and the v2 registry DSL, see docs/v1-to-v2-migration
+ *
+ * BasePageV1toV2:
+ * Migration-friendly BasePage that maintains v1 schema ingestion while exposing v2 registries.
+ *
+ * Generics:
+ * - LocatorSchemaPathType: A union of valid locator paths.
+ * - Options: Configuration type for URLs.
+ * - LocatorSubstring: The chosen substring locator.
+ */
+declare abstract class BasePageV1toV2<LocatorSchemaPathType extends string, Options extends BasePageOptions = {
+    urlOptions: {
+        baseUrlType: string;
+        urlPathType: string;
+    };
+}, LocatorSubstring extends LocatorSchemaPathType | undefined = undefined> {
+    /** Provides Playwright page methods */
+    page: Page;
+    /** Playwright TestInfo contains information about currently running test, available to any test function */
+    testInfo: TestInfo;
+    /** Selectors can be used to install custom selector engines.*/
+    selector: Selectors;
+    /** The base URL of the Page Object Class */
+    baseUrl: ExtractBaseUrlType<Options>;
+    /** The URL path of the Page Object Class */
+    urlPath: ExtractUrlPathType<Options>;
+    /** The full URL of the Page Object Class */
+    fullUrl: ExtractFullUrlType<Options>;
+    /** The name of the Page Object Class */
+    pocName: string;
+    /** The Page Object Class' PlaywrightReportLogger instance, prefixed with its name. Log levels: debug, info, warn, and error.  */
     protected log: PlaywrightReportLogger;
-    protected request: APIRequestContext;
-    constructor(baseUrl: string, apiName: string, context: APIRequestContext, pwrl: PlaywrightReportLogger);
+    /** The SessionStorage class provides methods for setting and getting session storage data in Playwright.*/
+    sessionStorage: SessionStorage$1;
+    /**
+     * locators:
+     * An instance of GetLocatorBase that handles schema management and provides getLocatorSchema calls.
+     * Initially, LocatorSubstring is undefined. Once getLocatorSchema(path) is called,
+     * we get a chainable object typed with LocatorSubstring = P.
+     */
+    protected locators: GetLocatorBase<LocatorSchemaPathType, LocatorSubstring>;
+    /**
+     * v2 locator registry and accessors, used for migration to the fluent registry DSL.
+     */
+    protected readonly locatorRegistry: LocatorRegistry<LocatorSchemaPathType>;
+    readonly add: AddAccessor<LocatorSchemaPathType>;
+    readonly getLocator: GetLocatorAccessor<LocatorSchemaPathType>;
+    readonly getLocatorSchema: GetLocatorSchemaAccessor<LocatorSchemaPathType>;
+    readonly getNestedLocator: GetNestedLocatorAccessor<LocatorSchemaPathType>;
+    constructor(page: Page, testInfo: TestInfo, baseUrl: ExtractBaseUrlType<Options>, urlPath: ExtractUrlPathType<Options>, pocName: string, pwrl: PlaywrightReportLogger, locatorSubstring?: LocatorSubstring);
+    /**
+     * constructFullUrl:
+     * Combines baseUrl and urlPath, handling both strings and RegExps.
+     * Ensures a flexible approach to URL matching (string or regex-based).
+     */
+    private constructFullUrl;
+    /**
+     * defineLocators:
+     * Abstract method to be implemented by each POC for v2 registry definitions.
+     */
+    protected abstract defineLocators(): void;
+    /**
+     * @deprecated V1 schema ingestion will be removed in 2.0.0. Migrate definitions to defineLocators.
+     * initLocatorSchemas:
+     * Abstract method to be implemented by each POC for v1 locator schema definitions.
+     */
+    protected abstract initLocatorSchemas(): void;
+}
+
+type WaitUntil = NonNullable<Parameters<Page["goto"]>[1]>["waitUntil"];
+type State = NonNullable<Parameters<Page["waitForLoadState"]>[0]>;
+type NavigationOptions = {
+    waitUntil?: WaitUntil;
+    waitForLoadState?: State;
+};
+interface NavigationString {
+    goto(urlPathOrUrl: string, options?: NavigationOptions): Promise<void>;
+    gotoThisPage(options?: NavigationOptions): Promise<void>;
+    expectThisPage(options?: NavigationOptions): Promise<void>;
+    expectAnotherPage(options?: NavigationOptions): Promise<void>;
+}
+interface NavigationRegExp {
+    expectThisPage(options?: NavigationOptions): Promise<void>;
+    expectAnotherPage(options?: NavigationOptions): Promise<void>;
 }
+type ExtractNavigationType<FullUrlType> = FullUrlType extends RegExp ? NavigationRegExp : NavigationString;
+
+/**
+ * Defines the SessionStorage class to manage session storage in Playwright.
+ * It provides methods to set, get, and clear session storage data, and to handle data before page navigation.
+ */
+type SessionStorageState<T = unknown> = Record<string, T>;
+type SetOptions = {
+    reload?: boolean;
+    waitForContext?: boolean;
+};
+type WaitForContextOptions = {
+    waitForContext?: boolean;
+};
+type SessionStorageOptions = {
+    label?: string;
+};
+declare class SessionStorage {
+    private page;
+    private options;
+    private queuedStates;
+    private isInitiated;
+    constructor(page: Page, options?: SessionStorageOptions);
+    private getStepLabel;
+    private hasContext;
+    private waitForContextAvailability;
+    private ensureContext;
+    /** Writes states to session storage. Accepts an object with key-value pairs representing the states. */
+    private writeToSessionStorage;
+    /** Reads all states from session storage and returns them as an object. */
+    private readFromSessionStorage;
+    /**
+     * Sets the specified states in session storage.
+     * Optionally waits for the next main-frame navigation to establish a valid context before writing,
+     * and reloads the page after setting the data.
+     *
+     * Parameters:
+     * states: Object representing the states to set in session storage.
+     * reload: Boolean indicating whether to reload the page after setting the session storage data.
+     * waitForContext: Boolean indicating whether to wait for a main-frame navigation and a valid context.
+     */
+    set<T = unknown>(states: SessionStorageState<T>, options?: SetOptions): Promise<void>;
+    /**
+     * Queues states to be set in the sessionStorage before the next navigation occurs.
+     * Handles different scenarios based on multiple calls made before the navigation occurs.
+     *
+     * 1. No Context, Single Call: Queues and sets states upon the next navigation.
+     * 2. No Context, Multiple Calls: Merges states from multiple calls and sets them upon the next navigation.
+     * 3. With Context: Still queues until the next navigation.
+     *
+     * Parameters:
+     * states: Object representing the states to queue for setting in session storage.
+     */
+    setOnNextNavigation<T = unknown>(states: SessionStorageState<T>): Promise<void>;
+    /**
+     * Fetches states from session storage.
+     * If specific keys are provided, fetches only those states; otherwise, fetches all states.
+     *
+     * Parameters:
+     * keys: Optional array of keys to specify which states to fetch from session storage.
+     * waitForContext: Boolean indicating whether to wait for a main-frame navigation and a valid context.
+     *
+     * Returns:
+     * Object containing the fetched states.
+     */
+    get<T = unknown>(keys?: string[]): Promise<SessionStorageState<T>>;
+    get<T = unknown>(keys: string[] | undefined, options: WaitForContextOptions): Promise<SessionStorageState<T>>;
+    /**
+     * Clears states in sessionStorage. When keys are provided, clears only those entries.
+     * Pass `waitForContext` to wait for the next main-frame navigation and validate that a usable context exists.
+     */
+    clear(): Promise<void>;
+    clear(options: WaitForContextOptions): Promise<void>;
+    clear(key: string | string[]): Promise<void>;
+    clear(key: string | string[], options: WaitForContextOptions): Promise<void>;
+}
+
+/**
+ * UrlTypeOptions define types for baseUrl and urlPath.
+ * string is the default type; The types can be overridden to RegExp, using the Extract...Type utility types. If either
+ * baseUrlType or urlPathType is set to RegExp, then fullUrlType will also be RegExp and can't be used for navigation,
+ * only validation through URL matching.
+ */
+type UrlTypeOptions = {
+    baseUrlType?: string | RegExp;
+    urlPathType?: string | RegExp;
+};
+type BaseUrlTypeFromOptions<T extends UrlTypeOptions> = T extends {
+    baseUrlType: RegExp;
+} ? RegExp : string;
+type UrlPathTypeFromOptions<T extends UrlTypeOptions> = T extends {
+    urlPathType: RegExp;
+} ? RegExp : "" | string;
+type FullUrlTypeFromOptions<T extends UrlTypeOptions> = T extends {
+    baseUrlType: RegExp;
+} | {
+    urlPathType: RegExp;
+} ? RegExp : string;
+declare abstract class PageObject<LocatorSchemaPathType extends string, Options extends UrlTypeOptions = {
+    baseUrlType: string;
+    urlPathType: string;
+}> {
+    readonly page: Page;
+    readonly baseUrl: BaseUrlTypeFromOptions<Options>;
+    readonly urlPath: UrlPathTypeFromOptions<Options>;
+    readonly fullUrl: FullUrlTypeFromOptions<Options>;
+    readonly label: string;
+    readonly sessionStorage: SessionStorage;
+    readonly navigation: ExtractNavigationType<FullUrlTypeFromOptions<Options>>;
+    protected readonly locatorRegistry: LocatorRegistry<LocatorSchemaPathType>;
+    readonly add: AddAccessor<LocatorSchemaPathType>;
+    readonly getLocator: GetLocatorAccessor<LocatorSchemaPathType>;
+    readonly getLocatorSchema: GetLocatorSchemaAccessor<LocatorSchemaPathType>;
+    readonly getNestedLocator: GetNestedLocatorAccessor<LocatorSchemaPathType>;
+    protected constructor(page: Page, baseUrl: BaseUrlTypeFromOptions<Options>, urlPath: UrlPathTypeFromOptions<Options>, options?: {
+        label?: string;
+        navOptions?: NavigationOptions;
+    });
+    protected abstract defineLocators(): void;
+    protected abstract pageActionsToPerformAfterNavigation(): (() => Promise<void>)[] | null;
+    private composeFullUrl;
+}
+
+type BaseFixtures = {
+    log: PlaywrightReportLogger;
+};
+declare const test: _playwright_test.TestType<_playwright_test.PlaywrightTestArgs & _playwright_test.PlaywrightTestOptions & BaseFixtures, _playwright_test.PlaywrightWorkerArgs & _playwright_test.PlaywrightWorkerOptions>;
+
+type AnyMethod<This = unknown, Args extends unknown[] = unknown[], Return = unknown> = (this: This, ...args: Args) => Return;
+type StepTitle = Parameters<typeof test$1.step>[0];
+type StepOptions = Parameters<typeof test$1.step>[2];
+interface StepDecoratorFactory {
+    <This, Args extends unknown[], Return>(value: AnyMethod<This, Args, Return>, context: ClassMethodDecoratorContext<This, AnyMethod<This, Args, Return>>): AnyMethod<This, Args, Return> | undefined;
+    <This, Args extends unknown[], Return>(target: object, propertyKey: string | symbol, descriptor: TypedPropertyDescriptor<AnyMethod<This, Args, Return>>): TypedPropertyDescriptor<AnyMethod<This, Args, Return>> | undefined;
+}
+/**
+ * Wraps a method in Playwright `test.step`, defaulting the title to `ClassName.methodName`.
+ *
+ * Examples:
+ * - `@step`
+ * - `@step("title")`
+ * - `@step({ box: true })`
+ * - `@step("title", { timeout: 5000 })`
+ */
+declare function step(): StepDecoratorFactory;
+declare function step(title: StepTitle): StepDecoratorFactory;
+declare function step(options: StepOptions): StepDecoratorFactory;
+declare function step(title: StepTitle, options: StepOptions): StepDecoratorFactory;
+declare function step<This, Args extends unknown[], Return>(value: AnyMethod<This, Args, Return>, context: ClassMethodDecoratorContext<This, AnyMethod<This, Args, Return>>): AnyMethod<This, Args, Return> | undefined;
 
-export { type AriaRoleType, BaseApi, BasePage, type BasePageOptions, type ExtractBaseUrlType, type ExtractFullUrlType, type ExtractUrlPathType, GetByMethod, GetLocatorBase, type LocatorSchema, type LocatorSchemaWithoutPath, PlaywrightReportLogger, test };
+export { type AddAccessor, type AriaRoleType, BaseApi, BasePage, type BasePageOptions$1 as BasePageOptions, BasePageV1toV2, type BaseUrlTypeFromOptions, type ExtractBaseUrlType$1 as ExtractBaseUrlType, type ExtractFullUrlType$1 as ExtractFullUrlType, type ExtractUrlPathType$1 as ExtractUrlPathType, type FullUrlTypeFromOptions, GetByMethod, type GetLocatorAccessor, GetLocatorBase, type GetLocatorSchemaAccessor, type GetNestedLocatorAccessor, type LocatorRegistry, type LocatorSchema, type LocatorSchemaWithoutPath, type LogEntry, type LogLevel, type NavigationOptions, PageObject, PlaywrightReportLogger, SessionStorage, type UrlPathTypeFromOptions, type UrlTypeOptions, createRegistryWithAccessors, step, test };