kayle/build/config.d.ts

Extremely fast and accurate accessibility engine built for any headless tool like playwright or puppeteer.

/// <reference types="node" />
import { Watcher } from "./watcher";
import type { Runner } from "./runner-js";
type Permission = "geolocation" | "midi" | "notifications" | "camera" | "microphone" | "background-sync" | "ambient-light-sensor" | "accelerometer" | "gyroscope" | "magnetometer" | "accessibility-events" | "clipboard-read" | "clipboard-write" | "payment-handler" | "persistent-storage" | "idle-detection" | "midi-sysex";
type Awaitable<T> = T | PromiseLike<T>;
type FlattenHandle<T> = T;
type InnerParams<T extends unknown[]> = {
    [K in keyof T]: FlattenHandle<T[K]>;
};
type EvaluateFunc<T extends unknown[]> = (...params: InnerParams<T>) => Awaitable<unknown>;
type Frame = {
    [x: string]: any;
};
type BrowserContext = {
    browser?(): Browser | null;
    close(): Promise<void>;
    pages?(): Partial<Page>[];
    targets?(): Target[];
    newCDPSession?(page: Partial<Page> | Frame): Partial<CDPSession>;
    overridePermissions?(origin: string, permissions: Permission[]): Promise<void>;
};
type Browser = {
    newPage(): Promise<any>;
    wsEndpoint?(): string;
    createIncognitoBrowserContext?(): Promise<BrowserContext | any>;
};
declare abstract class JSHandle<T = unknown> {
}
declare abstract class ElementHandle<ElementType extends Node = Element> extends JSHandle<ElementType> {
}
type Target = {
    createCDPSession?(): Promise<CDPSession>;
};
export type LifeCycleEvent = "load" | "domcontentloaded" | "commit" | "networkidle" | "networkidle0" | "networkidle2";
export type WaitForOptions = {
    timeout?: number;
    waitUntil?: LifeCycleEvent | LifeCycleEvent[] | string;
};
declare interface WaitTimeoutOptions {
    timeout?: number;
}
declare interface WaitForNetworkIdleOptions extends WaitTimeoutOptions {
    idleTime?: number;
    concurrency?: number;
}
type DefaultMouseActions = {
    delay?: number;
    clickCount?: number;
    button?: "left" | "right" | "middle";
} | number;
type Point = {
    x?: number;
    y?: number;
};
type MouseActions = {
    dragAndDrop?(source: Point, target: Point, options?: {
        delay?: number;
    }): Promise<void>;
    up?(source: number | Readonly<DefaultMouseActions> | unknown, target?: number): Promise<void>;
    down?(source: number | Readonly<DefaultMouseActions> | unknown, target?: number): Promise<void>;
    move?(source: number, target: number): Promise<void>;
    wheel?(deltaX: number | Readonly<{
        x: number;
        y: number;
    }> | unknown, deltaY?: number): Promise<void>;
    reset?(): Promise<void>;
    click?(source: number, target: number, options?: {
        delay?: number;
        clickCount?: number;
        button?: "left" | "right" | "middle";
    }): Promise<void>;
    dblclick?(source: number, target: number, options?: {
        delay?: number;
        clickCount?: number;
        button?: "left" | "right" | "middle";
    }): Promise<void>;
};
type Page = {
    goto(url: string, options?: WaitForOptions): Promise<any | null>;
    setContent(html: string, options?: WaitForOptions): Promise<void>;
    close(o?: {
        runBeforeUnload?: boolean;
    }): Promise<void>;
    browser?(): Browser;
    context?(): BrowserContext | null;
    target(): Target;
    _client?(): Partial<CDPSession>;
    _route?: string;
    _routes?: {
        url: string;
    }[];
    route(path: string, intercept: (config: any, next: any) => Promise<void> | Promise<boolean>): Promise<void>;
    setRequestInterception?(enable?: boolean): Promise<void>;
    listenerCount?(name: string): number;
    exposeFunction?(name: string, pptrFunction: Function | {
        default: Function;
    }): Promise<void>;
    addInitScript?(script: {
        content?: string;
    }): Promise<void>;
    evaluateOnNewDocument?<Params extends unknown[], Func extends (...args: Params) => unknown = (...args: Params) => unknown>(pageFunction: Func | string, ...args: Params): Promise<{
        identifier: string;
    }>;
    evaluate<Params extends unknown[], Func extends EvaluateFunc<Params> = EvaluateFunc<Params>>(pageFunction: Func | string, ...args: Params): Promise<Awaited<ReturnType<Func>>>;
    on(eventName: any, handler: (event: any, next?: any) => any): void;
    once(eventName: any, handler: (event: any, _?: any) => void): void;
    off(eventName: any, handler: (event: any, _?: any) => void): void;
    unroute?(eventName: any, handler: (event: any, _?: any) => void): void;
    url(): string;
    title(): Promise<string>;
    content(): Promise<string>;
    addStyleTag(options: {
        content?: string;
        path?: string;
        url?: string;
    }): Promise<ElementHandle>;
    dragAndDrop?(source: string, target: string, options?: {
        force?: boolean;
        noWaitAfter?: boolean;
        strict?: boolean;
        trial?: boolean;
        timeout?: number;
        sourcePosition?: {
            x: number;
            y: number;
        };
        targetPosition?: {
            x: number;
            y: number;
        };
    }): Promise<void>;
    mouse?: Partial<MouseActions>;
    emulateCPUThrottling(factor: number | null): Promise<void>;
    screenshot(s: {
        path?: string;
        clip?: Pick<DOMRect, "x" | "y" | "width" | "height">;
    }): Promise<string | Buffer>;
    pdf(s: {
        path?: string;
        displayHeaderFooter?: boolean;
        footerTemplate?: string;
        headerTemplate?: string;
        height?: string | number;
        width?: string | number;
        omitBackground?: boolean;
        outline?: boolean;
        preferCSSPageSize?: boolean;
        scale?: number;
        tagged?: boolean;
        timeout?: number;
        landscape?: boolean;
    }): Promise<string | Buffer>;
    getByRole?(role: string, o?: Record<string, string>): {
        click?(): Promise<void>;
    };
    waitForSelector?(role: string, o?: Record<string, string>): Partial<unknown | {
        click(): Promise<void>;
        dispose(): Promise<void>;
        hover(): Promise<void>;
    }>;
    waitForLoadState?(s: string): Promise<void>;
    waitForNetworkIdle?(options?: WaitForNetworkIdleOptions): Promise<void>;
    waitForNavigation?(options?: WaitForOptions): Promise<any>;
    waitForResponse?(urlOrPredicate: string | any, options?: WaitTimeoutOptions): Promise<any>;
};
export interface CDPSession {
    [x: string]: any;
}
export type RunnerConfig = {
    browser: Partial<Browser>;
    page: Partial<Page>;
    cdpSession?: Partial<CDPSession>;
    waitUntil?: LifeCycleEvent;
    actions?: string[];
    hideElements?: string;
    ignore?: string[];
    includeNotices?: boolean;
    includeWarnings?: boolean;
    rootElement?: string;
    rules?: string[];
    runners?: Runner[];
    standard?: keyof typeof Standard | Standard;
    timeout?: number;
    clip?: boolean;
    clipDir?: string;
    clip2Base64?: boolean;
    clipMax?: number;
    allowImages?: boolean;
    origin?: string;
    language?: string;
    noIntercept?: boolean;
    browserExtension?: boolean;
    dialogHandle?: {
        action?: "dismiss" | "accept";
        promptText?: string;
    };
    smart_check?: boolean;
    _watcher?: Watcher;
    _initRequest?: boolean;
    _kayleRunner?: boolean;
};
export declare const _log: {
    enabled: boolean;
};
export declare function setLogging(enabled?: boolean): void;
export declare enum Standard {
    WCAG2A = "WCAG2A",
    WCAG2AA = "WCAG2AA",
    WCAG2AAA = "WCAG2AAA",
    SECTION508 = "SECTION508"
}
export { Runner };
export declare const enum MainRunner {
    htmlcs = "htmlcs",
    axe = "axe"
}