pw-core 1.1.0 → 1.2.1

package/dist/page/actions/locator-actions.js

@@ -5,6 +5,7 @@ exports.defineActionMethods = defineActionMethods;
 const test_1 = require("@playwright/test");
 const config_1 = require("../config");
 const formatter_1 = require("../utils/formatter");
+const caller_location_1 = require("../utils/caller-location");
 function executeAction(prop, resolveLocatorFn, timeout, args) {
     const [locatorKey, ...methodArgs] = args;
     let optNth = undefined;
@@ -22,7 +23,13 @@ function executeAction(prop, resolveLocatorFn, timeout, args) {
         }
     }
     const isCount = prop === 'count';
-    const locator = resolveLocatorFn(locatorKey, { nth: optNth, hasText: optHasText, raw: isCount });
+    const userOptions = optionsIndex !== -1 && methodArgs.length > optionsIndex ? methodArgs[optionsIndex] : undefined;
+    const locator = resolveLocatorFn(locatorKey, {
+        nth: optNth,
+        hasText: optHasText,
+        raw: isCount,
+        ...userOptions
+    });
     const method = locator[prop];
     if (typeof method !== 'function') {
         throw new Error(`Property '${prop}' does not exist on Locator.`);
@@ -30,6 +37,13 @@ function executeAction(prop, resolveLocatorFn, timeout, args) {
     if (prop === 'dragTo' && methodArgs.length > 0) {
         methodArgs[0] = resolveLocatorFn(methodArgs[0]);
     }
+    if (optionsIndex !== -1 && methodArgs.length > optionsIndex) {
+        const opts = methodArgs[optionsIndex];
+        if (opts && typeof opts === 'object') {
+            const { exact, checked, disabled, expanded, includeHidden, level, pressed, selected, ...rest } = opts;
+            methodArgs[optionsIndex] = rest;
+        }
+    }
     if (timeout !== undefined) {
         if (optionsIndex !== -1) {
             while (methodArgs.length < optionsIndex) {
@@ -47,9 +61,39 @@ function executeAction(prop, resolveLocatorFn, timeout, args) {
             methodArgs[1] = playwrightOpts;
         }
     }
+    let shouldMask = false;
+    if (prop === 'fill' && methodArgs.length > 0) {
+        const opts = methodArgs[1];
+        if (opts && typeof opts === 'object' && opts.mask !== undefined) {
+            shouldMask = opts.mask === true;
+        }
+        else {
+            const targetStr = (0, formatter_1.formatTarget)(locatorKey);
+            const targetStrLower = targetStr.toLowerCase();
+            shouldMask = targetStrLower.includes('pass') || targetStrLower.includes('pw');
+        }
+    }
+    if (prop === 'fill' && shouldMask) {
+        return test_1.test.step(stepName, async () => {
+            await locator.focus();
+            await locator.evaluate((el, val) => {
+                const inputEl = el;
+                const prototype = el.tagName === 'TEXTAREA' ? window.HTMLTextAreaElement.prototype : window.HTMLInputElement.prototype;
+                const descriptor = Object.getOwnPropertyDescriptor(prototype, 'value');
+                if (descriptor && descriptor.set) {
+                    descriptor.set.call(inputEl, val);
+                }
+                else {
+                    inputEl.value = val;
+                }
+                inputEl.dispatchEvent(new Event('input', { bubbles: true }));
+                inputEl.dispatchEvent(new Event('change', { bubbles: true }));
+            }, methodArgs[0]);
+        }, { box: true, location: (0, caller_location_1.getCallerLocation)() });
+    }
     return test_1.test.step(stepName, () => {
         return method.apply(locator, methodArgs);
-    });
+    }, { box: true, location: (0, caller_location_1.getCallerLocation)() });
 }
 function defineActionMethods(instance, resolveLocatorFn, timeout) {
     const locatorMethods = [...config_1.zeroArgMethodsList, ...config_1.oneArgMethodsList];

package/dist/page/actions/page-actions.d.ts

@@ -6,34 +6,39 @@ type GotoOptions = {
 };
 type ToHaveURLOptions = Parameters<ReturnType<typeof playwrightExpect<Page>>['toHaveURL']>[1];
 type ToHaveTitleOptions = Parameters<ReturnType<typeof playwrightExpect<Page>>['toHaveTitle']>[1];
+type StepLocation = {
+    file: string;
+    line: number;
+    column: number;
+};
 /**
  * Navigate to the page URL defined in the page config.
  * Wraps {@link https://playwright.dev/docs/api/class-page#page-goto Page.goto} in a test step.
  */
-export declare function goto(page: Page, url: string | undefined, constructorName: string, options?: GotoOptions): Promise<void>;
+export declare function goto(page: Page, url: string | undefined, constructorName: string, options?: GotoOptions, location?: StepLocation): Promise<void>;
 /**
  * Assert the current URL matches the page config URL or a custom pattern.
  * Uses {@link https://playwright.dev/docs/api/class-pageassertions#page-assertions-to-have-url expect(page).toHaveURL}.
  */
-export declare function verifyURL(page: Page, url: string | undefined, constructorName: string, urlOrOptions?: string | RegExp | ToHaveURLOptions, options?: ToHaveURLOptions): Promise<void>;
+export declare function verifyURL(page: Page, url: string | undefined, constructorName: string, urlOrOptions?: string | RegExp | ToHaveURLOptions, options?: ToHaveURLOptions, location?: StepLocation): Promise<void>;
 /**
  * Assert the page title matches the expected value.
  * Uses {@link https://playwright.dev/docs/api/class-pageassertions#page-assertions-to-have-title expect(page).toHaveTitle}.
  */
-export declare function verifyTitle(page: Page, title: string | RegExp, options?: ToHaveTitleOptions): Promise<void>;
+export declare function verifyTitle(page: Page, title: string | RegExp, options?: ToHaveTitleOptions, location?: StepLocation): Promise<void>;
 /**
  * Reload the page.
  * Wraps {@link https://playwright.dev/docs/api/class-page#page-reload Page.reload} in a test step.
  */
-export declare function reload(page: Page, options?: Parameters<Page['reload']>[0]): Promise<void>;
+export declare function reload(page: Page, options?: Parameters<Page['reload']>[0], location?: StepLocation): Promise<void>;
 /**
  * Wait for the page to reach a load state.
  * Wraps {@link https://playwright.dev/docs/api/class-page#page-wait-for-load-state Page.waitForLoadState} in a test step.
  */
-export declare function waitForLoadState(page: Page, state?: Parameters<Page['waitForLoadState']>[0], options?: Parameters<Page['waitForLoadState']>[1]): Promise<void>;
+export declare function waitForLoadState(page: Page, state?: Parameters<Page['waitForLoadState']>[0], options?: Parameters<Page['waitForLoadState']>[1], location?: StepLocation): Promise<void>;
 /**
  * Wait for navigation to a URL. Defaults to the page config URL when no pattern is given.
  * Wraps {@link https://playwright.dev/docs/api/class-page#page-wait-for-url Page.waitForURL} in a test step.
  */
-export declare function waitForURL(page: Page, url: string | undefined, constructorName: string, urlOrOptions?: string | RegExp | Parameters<Page['waitForURL']>[1], options?: Parameters<Page['waitForURL']>[1]): Promise<void>;
+export declare function waitForURL(page: Page, url: string | undefined, constructorName: string, urlOrOptions?: string | RegExp | Parameters<Page['waitForURL']>[1], options?: Parameters<Page['waitForURL']>[1], location?: StepLocation): Promise<void>;
 export {};

package/dist/page/actions/page-actions.js

@@ -33,59 +33,59 @@ function resolveUrlPattern(url, constructorName, urlOrOptions, options) {
  * Navigate to the page URL defined in the page config.
  * Wraps {@link https://playwright.dev/docs/api/class-page#page-goto Page.goto} in a test step.
  */
-async function goto(page, url, constructorName, options) {
+async function goto(page, url, constructorName, options, location) {
     await test_1.test.step(`Goto "${url || ''}"`, async () => {
         if (!url) {
             throw new Error(`URL is not defined on ${constructorName}`);
         }
         await page.goto(url, options);
-    });
+    }, { box: true, location });
 }
 /**
  * Assert the current URL matches the page config URL or a custom pattern.
  * Uses {@link https://playwright.dev/docs/api/class-pageassertions#page-assertions-to-have-url expect(page).toHaveURL}.
  */
-async function verifyURL(page, url, constructorName, urlOrOptions, options) {
+async function verifyURL(page, url, constructorName, urlOrOptions, options, location) {
     const { targetUrl, actualOptions } = resolveUrlPattern(url, constructorName, urlOrOptions, options);
     const stepName = `Verify URL matches "${targetUrl.toString()}"`;
     await test_1.test.step(stepName, async () => {
         await (0, test_1.expect)(page).toHaveURL(targetUrl, actualOptions);
-    });
+    }, { box: true, location });
 }
 /**
  * Assert the page title matches the expected value.
  * Uses {@link https://playwright.dev/docs/api/class-pageassertions#page-assertions-to-have-title expect(page).toHaveTitle}.
  */
-async function verifyTitle(page, title, options) {
+async function verifyTitle(page, title, options, location) {
     const stepName = `Verify title matches "${title}"`;
     await test_1.test.step(stepName, async () => {
         await (0, test_1.expect)(page).toHaveTitle(title, options);
-    });
+    }, { box: true, location });
 }
 /**
  * Reload the page.
  * Wraps {@link https://playwright.dev/docs/api/class-page#page-reload Page.reload} in a test step.
  */
-async function reload(page, options) {
+async function reload(page, options, location) {
     await test_1.test.step('Reload page', async () => {
         await page.reload(options);
-    });
+    }, { box: true, location });
 }
 /**
  * Wait for the page to reach a load state.
  * Wraps {@link https://playwright.dev/docs/api/class-page#page-wait-for-load-state Page.waitForLoadState} in a test step.
  */
-async function waitForLoadState(page, state, options) {
+async function waitForLoadState(page, state, options, location) {
     const stepName = `Wait for load state "${state ?? 'load'}"`;
     await test_1.test.step(stepName, async () => {
         await page.waitForLoadState(state, options);
-    });
+    }, { box: true, location });
 }
 /**
  * Wait for navigation to a URL. Defaults to the page config URL when no pattern is given.
  * Wraps {@link https://playwright.dev/docs/api/class-page#page-wait-for-url Page.waitForURL} in a test step.
  */
-async function waitForURL(page, url, constructorName, urlOrOptions, options) {
+async function waitForURL(page, url, constructorName, urlOrOptions, options, location) {
     let targetUrl;
     let actualOptions = options;
     if (urlOrOptions !== undefined && (typeof urlOrOptions === 'string' || urlOrOptions instanceof RegExp)) {
@@ -103,5 +103,5 @@ async function waitForURL(page, url, constructorName, urlOrOptions, options) {
     const stepName = `Wait for URL "${targetUrl.toString()}"`;
     await test_1.test.step(stepName, async () => {
         await page.waitForURL(targetUrl, actualOptions);
-    });
+    }, { box: true, location });
 }

package/dist/page/assertions/verify-chain.d.ts

@@ -1,5 +1,5 @@
 import { Locator, expect as playwrightExpect } from '@playwright/test';
-import { ChainedKeys, PageKeys } from '../config';
+import { PageKeys, GetStrategyOfKey } from '../config';
 export type VerifyOptions = {
     timeout?: number;
     nth?: number;
@@ -11,64 +11,71 @@ type ModifyMatcherArgs<Args extends any[]> = Args extends [] ? [options?: {
     nth?: number;
     hasText?: string | RegExp;
     message?: string;
-}] : Args extends [any, any?] ? [Args[0], (Exclude<Args[1], undefined> & {
-    nth?: number;
-    hasText?: string | RegExp;
-    message?: string;
-})?] : Args extends [any?] ? Exclude<Args[0], undefined> extends object ? [(Exclude<Args[0], undefined> & {
-    nth?: number;
-    hasText?: string | RegExp;
-    message?: string;
-})?] : [Exclude<Args[0], undefined>, options?: {
-    nth?: number;
-    hasText?: string | RegExp;
-    message?: string;
-}] : [options?: {
-    nth?: number;
-    hasText?: string | RegExp;
-    message?: string;
-}];
-type DynamicallyModifiedMatchers<T> = {
-    [K in keyof PlaywrightLocatorMatchers]: K extends 'not' ? Omit<VerifyMatchers<T>, 'not'> : PlaywrightLocatorMatchers[K] extends (...args: infer Args) => any ? (...args: ModifyMatcherArgs<Args>) => Promise<void> : PlaywrightLocatorMatchers[K];
+}] : Args extends [any, any?] ? [
+    Args[0],
+    (Exclude<Args[1], undefined> & {
+        nth?: number;
+        hasText?: string | RegExp;
+        message?: string;
+    })?
+] : Args extends [any?] ? Exclude<Args[0], undefined> extends object ? [
+    (Exclude<Args[0], undefined> & {
+        nth?: number;
+        hasText?: string | RegExp;
+        message?: string;
+    })?
+] : [
+    Exclude<Args[0], undefined>,
+    options?: {
+        nth?: number;
+        hasText?: string | RegExp;
+        message?: string;
+    }
+] : [
+    options?: {
+        nth?: number;
+        hasText?: string | RegExp;
+        message?: string;
+    }
+];
+type DynamicallyModifiedMatchers<T, Target> = {
+    [K in keyof PlaywrightLocatorMatchers]: K extends 'not' ? Omit<VerifyMatchers<T, Target>, 'not'> : K extends 'toBeChecked' ? Target extends Locator ? (...args: ModifyMatcherArgs<Parameters<PlaywrightLocatorMatchers[K]>>) => Promise<void> : Target extends string ? GetStrategyOfKey<T, Target> extends 'checkbox' | 'radio' ? (...args: ModifyMatcherArgs<Parameters<PlaywrightLocatorMatchers[K]>>) => Promise<void> : never : never : PlaywrightLocatorMatchers[K] extends (...args: infer Args) => any ? (...args: ModifyMatcherArgs<Args>) => Promise<void> : PlaywrightLocatorMatchers[K];
 };
-export type VerifyMatchers<T> = DynamicallyModifiedMatchers<T> & PromiseLike<void> & {
+export type VerifyMatchers<T, Target> = DynamicallyModifiedMatchers<T, Target> & PromiseLike<void> & {
     (options?: Parameters<PlaywrightLocatorMatchers['toBeVisible']>[0] & {
         nth?: number;
         hasText?: string | RegExp;
         message?: string;
     }): Promise<void>;
 };
-export type VerifyFn<T> = (target: PageKeys<T> | ChainedKeys<T> | Locator, options?: VerifyOptions) => VerifyMatchers<T>;
+export type VerifyFn<T> = <Target extends PageKeys<T> | Locator>(target: Target, options?: VerifyOptions) => VerifyMatchers<T, Target>;
 export type AssertionsMethod<T> = {
     verify: VerifyFn<T> & {
         soft: VerifyFn<T>;
     };
-    verifyHidden(target: PageKeys<T> | ChainedKeys<T> | Locator, options?: Parameters<ReturnType<typeof playwrightExpect<Locator>>['toBeHidden']>[0] & {
+    verifyHidden(target: PageKeys<T> | Locator, options?: Parameters<ReturnType<typeof playwrightExpect<Locator>>['toBeHidden']>[0] & {
         nth?: number;
         hasText?: string | RegExp;
         message?: string;
     }): Promise<void>;
-    verifyEnabled(target: PageKeys<T> | ChainedKeys<T> | Locator, options?: Parameters<ReturnType<typeof playwrightExpect<Locator>>['toBeEnabled']>[0] & {
+    verifyEnabled(target: PageKeys<T> | Locator, options?: Parameters<ReturnType<typeof playwrightExpect<Locator>>['toBeEnabled']>[0] & {
         nth?: number;
         hasText?: string | RegExp;
         message?: string;
     }): Promise<void>;
-    verifyDisabled(target: PageKeys<T> | ChainedKeys<T> | Locator, options?: Parameters<ReturnType<typeof playwrightExpect<Locator>>['toBeDisabled']>[0] & {
+    verifyDisabled(target: PageKeys<T> | Locator, options?: Parameters<ReturnType<typeof playwrightExpect<Locator>>['toBeDisabled']>[0] & {
         nth?: number;
         hasText?: string | RegExp;
         message?: string;
     }): Promise<void>;
-    expect(target: PageKeys<T> | ChainedKeys<T> | Locator, message?: string): ReturnType<typeof playwrightExpect<Locator>>;
-    locator(target: PageKeys<T> | ChainedKeys<T> | Locator, options?: Parameters<Locator['filter']>[0] & {
+    expect(target: PageKeys<T> | Locator, message?: string): ReturnType<typeof playwrightExpect<Locator>>;
+    locator(target: PageKeys<T> | Locator, options?: Parameters<Locator['filter']>[0] & {
         nth?: number;
     }): Locator;
 };
-export declare function createVerifyChain<T extends {
-    testIds?: Record<string, string>;
-    selectors?: Record<string, string>;
-}>(resolveLocator: (target: any, options?: {
+export declare function createVerifyChain<T>(resolveLocator: (target: any, options?: {
     nth?: number;
     hasText?: string | RegExp;
     raw?: boolean;
-}) => Locator, target: PageKeys<T> | ChainedKeys<T> | Locator, verifyOptions: VerifyOptions | undefined, isSoft: boolean): VerifyMatchers<T>;
+}) => Locator, target: PageKeys<T> | Locator, verifyOptions: VerifyOptions | undefined, isSoft: boolean): VerifyMatchers<T, any>;
 export {};

package/dist/page/assertions/verify-chain.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createVerifyChain = createVerifyChain;
 const test_1 = require("@playwright/test");
 const formatter_1 = require("../utils/formatter");
+const caller_location_1 = require("../utils/caller-location");
 function createVerifyChain(resolveLocator, target, verifyOptions, isSoft) {
     const defaultNth = verifyOptions?.nth;
     const defaultHasText = verifyOptions?.hasText;
@@ -18,7 +19,7 @@ function createVerifyChain(resolveLocator, target, verifyOptions, isSoft) {
                 const expectation = expectFn(locator, stepName);
                 const match = isNegated ? expectation.not : expectation;
                 await match.toBeVisible(options);
-            });
+            }, { box: true, location: (0, caller_location_1.getCallerLocation)() });
         };
         return new Proxy(baseFn, {
             get(targetObj, prop) {
@@ -35,7 +36,17 @@ function createVerifyChain(resolveLocator, target, verifyOptions, isSoft) {
                         return baseFn().then(onfulfilled, onrejected);
                     };
                 }
-                const skippedProps = new Set(['then', 'catch', 'finally', 'bind', 'call', 'apply', 'toString', 'valueOf', 'toLocaleString']);
+                const skippedProps = new Set([
+                    'then',
+                    'catch',
+                    'finally',
+                    'bind',
+                    'call',
+                    'apply',
+                    'toString',
+                    'valueOf',
+                    'toLocaleString'
+                ]);
                 if (skippedProps.has(prop)) {
                     return targetObj[prop];
                 }
@@ -44,16 +55,20 @@ function createVerifyChain(resolveLocator, target, verifyOptions, isSoft) {
                     const lastIsOptions = lastArg !== null && typeof lastArg === 'object' && !(lastArg instanceof RegExp) && !Array.isArray(lastArg);
                     const valueArgs = lastIsOptions ? args.slice(0, args.length - 1) : args;
                     const options = lastIsOptions ? lastArg : undefined;
-                    const nth = (options && 'nth' in options) ? options.nth : defaultNth;
-                    const hasText = (options && 'hasText' in options) ? options.hasText : defaultHasText;
+                    const nth = options && 'nth' in options ? options.nth : defaultNth;
+                    const hasText = options && 'hasText' in options ? options.hasText : defaultHasText;
                     const isHaveCount = prop === 'toHaveCount';
                     const stepName = options?.message ?? defaultMessage ?? (0, formatter_1.formatAssertionDescription)(target, String(prop), isNegated, valueArgs);
                     await test_1.test.step(stepName, async () => {
-                        const locator = resolveLocator(target, { nth, hasText, raw: isHaveCount });
+                        const locator = resolveLocator(target, {
+                            nth,
+                            hasText,
+                            raw: isHaveCount
+                        });
                         const expectation = expectFn(locator, stepName);
                         const match = isNegated ? expectation.not : expectation;
                         await match[prop](...args);
-                    });
+                    }, { box: true, location: (0, caller_location_1.getCallerLocation)() });
                 };
             }
         });

package/dist/page/assertions/verify-helpers.d.ts

@@ -1,4 +1,9 @@
 import { Locator, expect as playwrightExpect } from '@playwright/test';
+type StepLocation = {
+    file: string;
+    line: number;
+    column: number;
+};
 export declare function verifyHidden(resolveLocator: (target: any, options?: {
     nth?: number;
     hasText?: string | RegExp;
@@ -7,7 +12,7 @@ export declare function verifyHidden(resolveLocator: (target: any, options?: {
     nth?: number;
     hasText?: string | RegExp;
     message?: string;
-}): Promise<void>;
+}, location?: StepLocation): Promise<void>;
 export declare function verifyEnabled(resolveLocator: (target: any, options?: {
     nth?: number;
     hasText?: string | RegExp;
@@ -16,7 +21,7 @@ export declare function verifyEnabled(resolveLocator: (target: any, options?: {
     nth?: number;
     hasText?: string | RegExp;
     message?: string;
-}): Promise<void>;
+}, location?: StepLocation): Promise<void>;
 export declare function verifyDisabled(resolveLocator: (target: any, options?: {
     nth?: number;
     hasText?: string | RegExp;
@@ -25,4 +30,5 @@ export declare function verifyDisabled(resolveLocator: (target: any, options?: {
     nth?: number;
     hasText?: string | RegExp;
     message?: string;
-}): Promise<void>;
+}, location?: StepLocation): Promise<void>;
+export {};

package/dist/page/assertions/verify-helpers.js

@@ -5,24 +5,33 @@ exports.verifyEnabled = verifyEnabled;
 exports.verifyDisabled = verifyDisabled;
 const test_1 = require("@playwright/test");
 const formatter_1 = require("../utils/formatter");
-async function verifyHidden(resolveLocator, target, options) {
+async function verifyHidden(resolveLocator, target, options, location) {
     const stepName = options?.message ?? (0, formatter_1.formatAssertionDescription)(target, 'toBeHidden', false, [options]);
     await test_1.test.step(stepName, async () => {
-        const locator = resolveLocator(target, { nth: options?.nth, hasText: options?.hasText });
+        const locator = resolveLocator(target, {
+            nth: options?.nth,
+            hasText: options?.hasText
+        });
         await (0, test_1.expect)(locator, stepName).toBeHidden(options);
-    });
+    }, { box: true, location });
 }
-async function verifyEnabled(resolveLocator, target, options) {
+async function verifyEnabled(resolveLocator, target, options, location) {
     const stepName = options?.message ?? (0, formatter_1.formatAssertionDescription)(target, 'toBeEnabled', false, [options]);
     await test_1.test.step(stepName, async () => {
-        const locator = resolveLocator(target, { nth: options?.nth, hasText: options?.hasText });
+        const locator = resolveLocator(target, {
+            nth: options?.nth,
+            hasText: options?.hasText
+        });
         await (0, test_1.expect)(locator, stepName).toBeEnabled(options);
-    });
+    }, { box: true, location });
 }
-async function verifyDisabled(resolveLocator, target, options) {
+async function verifyDisabled(resolveLocator, target, options, location) {
     const stepName = options?.message ?? (0, formatter_1.formatAssertionDescription)(target, 'toBeDisabled', false, [options]);
     await test_1.test.step(stepName, async () => {
-        const locator = resolveLocator(target, { nth: options?.nth, hasText: options?.hasText });
+        const locator = resolveLocator(target, {
+            nth: options?.nth,
+            hasText: options?.hasText
+        });
         await (0, test_1.expect)(locator, stepName).toBeDisabled(options);
-    });
+    }, { box: true, location });
 }

package/dist/page/config.d.ts

@@ -1,51 +1,139 @@
-import { Locator, Page } from '@playwright/test';
-export { ProxyLocatorMethods } from './types/proxy-methods';
-export declare const zeroArgMethodsList: readonly ["click", "dblclick", "hover", "focus", "blur", "check", "uncheck", "clear", "waitFor", "isChecked", "isDisabled", "isVisible", "textContent", "innerText", "allInnerTexts", "allTextContents", "count", "scrollIntoViewIfNeeded", "boundingBox"];
-export declare const oneArgMethodsList: readonly ["fill", "press", "pressSequentially", "selectOption", "setInputFiles", "getAttribute", "dragTo"];
-export type AllowedZeroArgMethods = typeof zeroArgMethodsList[number];
-export type AllowedOneArgMethods = typeof oneArgMethodsList[number];
-export type AllowedMethodKeys = AllowedZeroArgMethods | AllowedOneArgMethods;
+import { Locator } from '@playwright/test';
+import type { DynamicTestIdEntry, DynamicSelectorEntry } from './locators/dynamic-locator-resolver.js';
+export { ProxyLocatorMethods } from './types/proxy-methods.js';
+export type { DynamicLocatorEntry, DynamicTestIdEntry, DynamicSelectorEntry } from './locators/dynamic-locator-resolver.js';
+import { AllowedMethodKeys } from '../types/methods';
+import { StrategyType, LocatorStrategyOptions } from '../types/strategies';
+import { ResolvedTestIdKeys, ValidateTestIds } from './types/validation.js';
+export { zeroArgMethodsList, oneArgMethodsList } from '../constants/methods';
+export { rolesList, strategyList } from '../constants/strategies';
+export { AllowedZeroArgMethods, AllowedOneArgMethods, AllowedMethodKeys } from '../types/methods';
+export { RoleType, StrategyType, PlaywrightRoleOptions, PlaywrightTextOptions, LocatorStrategyOptions } from '../types/strategies';
+export type GetStrategyOfKey<T, K extends string> = K extends (T extends {
+    testId: infer I;
+} ? ResolvedTestIdKeys<I> : never) ? 'testId' : K extends (T extends {
+    testIds: infer I;
+} ? ResolvedTestIdKeys<I> : never) ? 'testId' : K extends (T extends {
+    selector: infer S;
+} ? ResolvedTestIdKeys<S> : never) ? 'selector' : K extends (T extends {
+    selectors: infer S;
+} ? ResolvedTestIdKeys<S> : never) ? 'selector' : {
+    [S in Exclude<StrategyType, 'testId' | 'selector'>]: K extends (T extends Record<S, readonly string[]> ? T[S][number] : never) ? S : never;
+}[Exclude<StrategyType, 'testId' | 'selector'>];
+export type ModifyOptionsForTarget<T, Target, Options> = Options & {
+    nth?: number;
+    hasText?: string | RegExp;
+} & (Target extends string ? LocatorStrategyOptions<GetStrategyOfKey<T, Target>> : {});
 export type PageKeys<T> = (T extends {
-    testIds?: infer I;
-} ? keyof I & string : never) | (T extends {
-    selectors?: infer S;
-} ? keyof S & string : never);
+    testId: infer I;
+} ? (I extends Record<string, any> ? ResolvedTestIdKeys<I> : never) : never) | (T extends {
+    testIds: infer I;
+} ? (I extends Record<string, any> ? ResolvedTestIdKeys<I> : never) : never) | (T extends {
+    selector: infer S;
+} ? (S extends Record<string, any> ? ResolvedTestIdKeys<S> : never) : never) | (T extends {
+    selectors: infer S;
+} ? (S extends Record<string, any> ? ResolvedTestIdKeys<S> : never) : never) | {
+    [S in Exclude<StrategyType, 'testId' | 'selector'>]: T extends Record<S, readonly string[]> ? T[S][number] : never;
+}[Exclude<StrategyType, 'testId' | 'selector'>];
+export type CheckableLocatorKeys<T> = {
+    [S in 'checkbox' | 'radio']: T extends Record<S, readonly string[]> ? T[S][number] : never;
+}['checkbox' | 'radio'];
+export type CheckboxLocatorKeys<T> = T extends Record<'checkbox', readonly string[]> ? T['checkbox'][number] : never;
+export type EditableLocatorKeys<T> = {
+    [S in 'label' | 'placeholder' | 'textbox' | 'searchbox']: T extends Record<S, readonly string[]> ? T[S][number] : never;
+}['label' | 'placeholder' | 'textbox' | 'searchbox'];
+export type SelectableLocatorKeys<T> = {
+    [S in 'combobox' | 'listbox' | 'option']: T extends Record<S, readonly string[]> ? T[S][number] : never;
+}['combobox' | 'listbox' | 'option'];
 export type TypedLocators<T> = {
     [K in PageKeys<T>]: Locator;
 };
-export type ChainedKeys<T> = `${PageKeys<T>}.${PageKeys<T>}`;
+export type UniversalKeys<T> = (T extends {
+    testId: infer I;
+} ? ResolvedTestIdKeys<I> : never) | (T extends {
+    testIds: infer I;
+} ? ResolvedTestIdKeys<I> : never) | (T extends {
+    selector: infer S;
+} ? ResolvedTestIdKeys<S> : never) | (T extends {
+    selectors: infer S;
+} ? ResolvedTestIdKeys<S> : never);
+export type SemanticKeys<T> = Exclude<PageKeys<T>, UniversalKeys<T>>;
+export type ChainedKeys<T> = `${UniversalKeys<T>}.${PageKeys<T>}` | `${UniversalKeys<T>}.${SemanticKeys<T>}.${UniversalKeys<T>}` | `${UniversalKeys<T>}.${UniversalKeys<T>}.${PageKeys<T>}`;
 export type TargetKey<T> = PageKeys<T> | ChainedKeys<T> | Locator;
-export type ValidateTarget<K, T> = K extends Locator ? Locator : K extends (PageKeys<T> | ChainedKeys<T>) ? K : never;
+export type ValidateTarget<K, T> = K extends Locator ? Locator : K extends PageKeys<T> | ChainedKeys<T> ? K : never;
 export declare function getOptionsArgumentIndex(methodName: AllowedMethodKeys): number;
-export type PageConfig<T = any> = {
+/** Map type accepted by the `testId` property in a page config. */
+export type TestIdMap = Record<string, string | DynamicTestIdEntry>;
+export type SelectorMap = Record<string, string | DynamicSelectorEntry>;
+export type PageConfig = {
     url?: string;
-    testIds?: Record<string, string>;
-    selectors?: T extends {
+    testId?: TestIdMap;
+    selector?: SelectorMap;
+    testIds?: TestIdMap;
+    selectors?: SelectorMap;
+} & {
+    [S in Exclude<StrategyType, 'testId' | 'selector'>]?: readonly string[];
+};
+export type KeysOfStrategy<T, S extends StrategyType> = S extends 'testId' ? T extends {
+    testId: infer I;
+} ? ResolvedTestIdKeys<I> : T extends {
+    testIds: infer I;
+} ? ResolvedTestIdKeys<I> : never : S extends 'selector' ? T extends {
+    selector: infer I;
+} ? ResolvedTestIdKeys<I> : T extends {
+    selectors: infer S2;
+} ? ResolvedTestIdKeys<S2> : never : T extends Record<S, infer A> ? A extends readonly string[] ? A[number] : never : never;
+export type KeysOfOtherStrategies<T, S extends StrategyType> = {
+    [O in Exclude<StrategyType, S>]: KeysOfStrategy<T, O>;
+}[Exclude<StrategyType, S>];
+type GetTestIds<T> = T extends {
+    testId: infer I;
+} ? (I extends Record<string, any> ? I : {}) : T extends {
+    testIds: infer I;
+} ? (I extends Record<string, any> ? I : {}) : {};
+type GetSelectors<T> = T extends {
+    selector: infer S;
+} ? (S extends Record<string, any> ? S : {}) : T extends {
+    selectors: infer S;
+} ? (S extends Record<string, any> ? S : {}) : {};
+export type ValidatePageConfig<T> = {
+    url?: string;
+    testId?: T extends {
+        testId: infer I;
+    } ? I extends Record<string, any> ? ValidateTestIds<I, 'testId', GetSelectors<T>> & {
+        [K in keyof I]: K extends KeysOfOtherStrategies<T, 'testId'> ? {
+            [P in `Error: Duplicate key "${K & string}" is defined in multiple strategies`]: never;
+        } : any;
+    } : TestIdMap : TestIdMap;
+    testIds?: T extends {
         testIds: infer I;
+    } ? I extends Record<string, any> ? ValidateTestIds<I, 'testId', GetSelectors<T>> & {
+        [K in keyof I]: K extends KeysOfOtherStrategies<T, 'testId'> ? {
+            [P in `Error: Duplicate key "${K & string}" is defined in multiple strategies`]: never;
+        } : any;
+    } : TestIdMap : TestIdMap;
+    selector?: T extends {
+        selector: infer S;
+    } ? S extends Record<string, any> ? ValidateTestIds<S, 'selector', GetTestIds<T>> & {
+        [K in keyof S]: K extends KeysOfOtherStrategies<T, 'selector'> ? {
+            [P in `Error: Duplicate key "${K & string}" is defined in multiple strategies`]: never;
+        } : any;
+    } : SelectorMap : SelectorMap;
+    selectors?: T extends {
         selectors: infer S;
-    } ? {
-        [K in keyof S]: K extends keyof I ? `Duplicate key: ${K & string} already exists in testIds` : S[K];
-    } : Record<string, string>;
-    Class?: new (page: Page, config?: any) => any;
+    } ? S extends Record<string, any> ? ValidateTestIds<S, 'selector', GetTestIds<T>> & {
+        [K in keyof S]: K extends KeysOfOtherStrategies<T, 'selector'> ? {
+            [P in `Error: Duplicate key "${K & string}" is defined in multiple strategies`]: never;
+        } : any;
+    } : SelectorMap : SelectorMap;
+} & {
+    [S in Exclude<StrategyType, 'testId' | 'selector'>]?: T extends Record<S, infer A> ? A extends readonly string[] ? {
+        [I in keyof A]: A[I] extends string ? A[I] extends KeysOfOtherStrategies<T, S> ? `Error: Duplicate key "${A[I]}" is defined in multiple strategies` : A[I] : A[I];
+    } : readonly string[] : readonly string[];
+} & {
+    [K in Exclude<keyof T, keyof PageConfig>]: never;
 };
 /**
  * Creates a strongly-typed page configuration object containing URLs, testIds, and CSS selectors.
- *
- * @example
- * ```ts
- * import { createPageConfig } from 'pw-core/page';
- *
- * const config = createPageConfig({
- *   url: '/login',
- *   testIds: {
- *     username: 'username-input',
- *     password: 'password-input',
- *     submitBtn: 'login-button',
- *   },
- *   selectors: {
- *     errorAlert: '.alert-danger',
- *   }
- * });
- * ```
  */
-export declare function createPageConfig<T extends PageConfig<T>>(config: T): T;
+export declare function createPageConfig<const T extends PageConfig>(config: [T] extends [ValidatePageConfig<T>] ? T : ValidatePageConfig<T>): T;