@bctrl/sdk/playwright

import { ... } from '@bctrl/sdk/playwright';

class PlaywrightSession extends BaseSession<RemotePlaywrightPage, PlaywrightScriptPage>

new (sessionId: string, hostId: string, baseUrl: string, options?: { apiKey?: string; defaultContextId?: string; defaultPageId?: string; storage?: string })

getDefaultContext(): Promise<RemotePlaywrightBrowserContext>

getPages(): Promise<RemotePlaywrightPage[]>

class RemotePlaywrightAPIRequestContext extends RemoteComponentBase

new (sendRpc: SimpleRpcSender)

delete(url: string, options?: PlaywrightAPIRequestOptions): Promise<PlaywrightAPIResponse>

dispose(options?: { reason?: string }): Promise<void>

fetch(urlOrRequest: string, options?: PlaywrightAPIRequestOptions): Promise<PlaywrightAPIResponse>

get(url: string, options?: PlaywrightAPIRequestOptions): Promise<PlaywrightAPIResponse>

head(url: string, options?: PlaywrightAPIRequestOptions): Promise<PlaywrightAPIResponse>

patch(url: string, options?: PlaywrightAPIRequestOptions): Promise<PlaywrightAPIResponse>

post(url: string, options?: PlaywrightAPIRequestOptions): Promise<PlaywrightAPIResponse>

put(url: string, options?: PlaywrightAPIRequestOptions): Promise<PlaywrightAPIResponse>

storageState(options?: PlaywrightStorageStateOptions): Promise<PlaywrightStorageState>

class RemotePlaywrightAPIResponse extends RemoteBase

new (sendRpc: SimpleRpcSender, data: SerializedAPIResponse)

body(): Promise<Buffer>

dispose(): Promise<void>

headers(): Record<string, string>

headersArray(): Array<{ name: string; value: string }>

json(): Promise<unknown>

ok(): boolean

status(): number

statusText(): string

text(): Promise<string>

url(): string

class RemotePlaywrightBrowser extends RemoteBase

new (id: string, sendRpc: SimpleRpcSender, createBrowserContext: (id: string) => RemotePlaywrightBrowserContext, createPage: (id: string) => RemotePlaywrightPage)

browserType(): Promise<'chromium' | 'firefox' | 'webkit'>

close(options?: { reason?: string }): Promise<void>

contexts(): Promise<RemotePlaywrightBrowserContext[]>

isConnected(): Promise<boolean>

newBrowserCDPSession(): Promise<{ sessionId: string }>

newContext(options?: PlaywrightNewContextOptions): Promise<RemotePlaywrightBrowserContext>

newPage(options?: PlaywrightNewPageOptions): Promise<RemotePlaywrightPage>

removeAllListeners(event?: string): this

startTracing(page?: HasHandleId, options?: PlaywrightStartTracingOptions): Promise<void>

stopTracing(): Promise<Buffer>

version(): Promise<string>

class RemotePlaywrightBrowserContext extends RemoteBase

new (id: string, sendRpc: SimpleRpcSender, createPage: (id: string) => RemotePlaywrightPage, browserRef: RemotePlaywrightBrowser | null)

addCookies(cookies: PlaywrightCookie[]): Promise<void>

addInitScript(script: Function | string | { path?: string; content?: string }, arg?: unknown): Promise<void>

addListener(event: string, handler: (event: unknown) => void): this

backgroundPages(): Promise<RemotePlaywrightPage[]>

browser(): RemotePlaywrightBrowser | null

clearCookies(options?: PlaywrightClearCookiesOptions): Promise<void>

clearPermissions(): Promise<void>

close(options?: { reason?: string }): Promise<void>

cookies(urls?: string | string[]): Promise<PlaywrightCookie[]>

emit(event: string, payload: unknown): boolean

exposeBinding(name: string, callback: Function, options?: { handle?: boolean }): Promise<void>

grantPermissions(permissions: PlaywrightPermission[], options?: PlaywrightGrantPermissionsOptions): Promise<void>

listenerCount(event: string): number

newCDPSession(page: HasHandleId): Promise<{ sessionId: string }>

newPage(): Promise<RemotePlaywrightPage>

off(event: string, handler?: (event: unknown) => void): this

on(event: string, handler: (event: unknown) => void): this

once(event: string, handler: (event: unknown) => void): this

pages(): Promise<RemotePlaywrightPage[]>

removeAllListeners(event?: string): this

removeListener(event: string, handler: (event: unknown) => void): this

route(url: string | RegExp | ((url: URL) => boolean), handler: Function, options?: PlaywrightRouteOptions): Promise<void>

routeFromHAR(har: string, options?: PlaywrightRouteFromHAROptions): Promise<void>

routeWebSocket(url: string | RegExp | ((url: URL) => boolean), handler: Function): Promise<void>

serviceWorkers(): Promise<Array<{ url: string; workerId: string }>>

setDefaultNavigationTimeout(timeout: number): Promise<void>

setDefaultTimeout(timeout: number): Promise<void>

setExtraHTTPHeaders(headers: Record<string, string>): Promise<void>

setGeolocation(geolocation: PlaywrightGeolocation | null): Promise<void>

setHTTPCredentials(httpCredentials: PlaywrightHttpCredentials | null): Promise<void>

setOffline(offline: boolean): Promise<void>

storageState(options?: { path?: string }): Promise<PlaywrightStorageState>

unroute(url: string | RegExp | ((url: URL) => boolean), handler?: Function): Promise<void>

unrouteAll(options?: PlaywrightUnrouteAllOptions): Promise<void>

waitForEvent<T = unknown>(event: string, optionsOrPredicate?: PlaywrightWaitForEventOptions | ((event: unknown) => boolean)): Promise<T>

class RemotePlaywrightClock extends RemoteComponentBase

new (sendRpc: SimpleRpcSender, contextId: string)

fastForward(ticks: number | string): Promise<void>

install(options?: { time?: number | string | Date }): Promise<void>

pauseAt(time: number | string | Date): Promise<void>

resume(): Promise<void>

runFor(ticks: number | string): Promise<void>

setFixedTime(time: number | string | Date): Promise<void>

setSystemTime(time: number | string | Date): Promise<void>

class RemotePlaywrightConsoleMessage

new (sendRpc: SimpleRpcSender, data: SerializedConsoleMessage, createJSHandle: (id: string) => RemotePlaywrightJSHandle, createPage: (id: string) => RemotePlaywrightPage, createWorker: (id: string) => RemotePlaywrightWorker)

args(): RemotePlaywrightJSHandle[]

location(): PlaywrightConsoleMessageLocation

page(): RemotePlaywrightPage | null

text(): string

type(): PlaywrightConsoleMessageType

worker(): RemotePlaywrightWorker | null

class RemotePlaywrightCoverage extends RemoteComponentBase

new (sendRpc: SimpleRpcSender, pageId: string)

startCSSCoverage(options?: PlaywrightStartCSSCoverageOptions): Promise<void>

startJSCoverage(options?: PlaywrightStartJSCoverageOptions): Promise<void>

stopCSSCoverage(): Promise<PlaywrightCSSCoverageEntry[]>

stopJSCoverage(): Promise<PlaywrightJSCoverageEntry[]>

class RemotePlaywrightDialog

new (sendRpc: SimpleRpcSender, data: SerializedDialog, createPage: (id: string) => RemotePlaywrightPage)

accept(promptText?: string): Promise<void>

defaultValue(): string

dismiss(): Promise<void>

message(): string

page(): RemotePlaywrightPage | null

type(): PlaywrightDialogType

class RemotePlaywrightElementHandle extends RemoteBase

new (id: string, sendRpc: SimpleRpcSender, createElementHandle: (handleId: string) => RemotePlaywrightElementHandle, createFrame: (frameId: string) => RemotePlaywrightFrame, createJSHandle: (handleId: string) => RemotePlaywrightJSHandle)

$(selector: string): Promise<RemotePlaywrightElementHandle | null>

$$(selector: string): Promise<RemotePlaywrightElementHandle[]>

$$eval<R = unknown, Arg = unknown>(selector: string, pageFunction: string | ((elements: Element[], arg: Arg) => R | Promise<R>), arg?: unknown): Promise<R>

$eval<R = unknown, Arg = unknown>(selector: string, pageFunction: string | ((element: Element, arg: Arg) => R | Promise<R>), arg?: unknown): Promise<R>

asElement(): RemotePlaywrightElementHandle | null

boundingBox(): Promise<PlaywrightBoundingBox | null>

check(options?: PlaywrightCheckOptions): Promise<void>

click(options?: PlaywrightClickOptions): Promise<void>

contentFrame(): Promise<RemotePlaywrightFrame | null>

dblclick(options?: PlaywrightClickOptions): Promise<void>

dispatchEvent(type: string, eventInit?: PlaywrightEventInit): Promise<void>

dispose(): Promise<void>

evaluate<R = unknown, Arg = unknown>(pageFunction: string | ((element: Element, arg: Arg) => R | Promise<R>), arg?: unknown): Promise<R>

evaluateHandle<R = unknown, Arg = unknown>(pageFunction: string | ((element: Element, arg: Arg) => R | Promise<R>), arg?: unknown): Promise<unknown>

fill(value: string, options?: PlaywrightFillOptions): Promise<void>

focus(): Promise<void>

getAttribute(name: string): Promise<string | null>

getProperty(propertyName: string): Promise<unknown>

hover(options?: PlaywrightHoverOptions): Promise<void>

innerHTML(): Promise<string>

innerText(): Promise<string>

inputValue(options?: PlaywrightTimeoutOptions): Promise<string>

isChecked(): Promise<boolean>

isDisabled(): Promise<boolean>

isEditable(): Promise<boolean>

isEnabled(): Promise<boolean>

isHidden(): Promise<boolean>

isVisible(): Promise<boolean>

jsonValue<T = unknown>(): Promise<T>

ownerFrame(): Promise<RemotePlaywrightFrame | null>

press(key: string, options?: PlaywrightPressOptions): Promise<void>

scrollIntoViewIfNeeded(options?: PlaywrightTimeoutOptions): Promise<void>

selectOption(values: string | string[] | PlaywrightSelectOption | PlaywrightSelectOption[], options?: PlaywrightSelectOptionOptions): Promise<string[]>

setChecked(checked: boolean, options?: PlaywrightCheckOptions): Promise<void>

setInputFiles(files: string | string[] | PlaywrightFilePayload | PlaywrightFilePayload[], options?: PlaywrightSetInputFilesOptions): Promise<void>

tap(options?: PlaywrightTapOptions): Promise<void>

textContent(): Promise<string | null>

type(text: string, options?: PlaywrightTypeOptions): Promise<void>

uncheck(options?: PlaywrightCheckOptions): Promise<void>

waitForElementState(state: PlaywrightElementState, options?: PlaywrightTimeoutOptions): Promise<void>

waitForSelector(selector: string, options?: PlaywrightWaitForSelectorOptions): Promise<RemotePlaywrightElementHandle | null>

class RemotePlaywrightFrame extends RemoteBase

new (id: string, sendRpc: SimpleRpcSender, createElementHandle: (handleId: string) => RemotePlaywrightElementHandle, createFrame: (frameId: string) => RemotePlaywrightFrame, createLocator: (selector: string) => RemotePlaywrightLocator, createFrameLocator: (selector: string) => RemotePlaywrightFrameLocator, createJSHandle: (handleId: string) => RemotePlaywrightJSHandle, getPage: () => RemotePlaywrightPage)

$(selector: string): Promise<RemotePlaywrightElementHandle | null>

$$(selector: string): Promise<RemotePlaywrightElementHandle[]>

$$eval<R = unknown>(selector: string, pageFunction: string | ((elements: Element[], ...args: unknown[]) => R | Promise<R>), arg?: unknown): Promise<R>

$eval<R = unknown>(selector: string, pageFunction: string | ((element: Element, ...args: unknown[]) => R | Promise<R>), arg?: unknown): Promise<R>

addScriptTag(options?: { content?: string; path?: string; type?: string; url?: string }): Promise<RemotePlaywrightElementHandle>

addStyleTag(options?: { content?: string; path?: string; url?: string }): Promise<RemotePlaywrightElementHandle>

check(selector: string, options?: PlaywrightCheckOptions): Promise<void>

childFrames(): Promise<RemotePlaywrightFrame[]>

click(selector: string, options?: PlaywrightClickOptions): Promise<void>

content(): Promise<string>

dblclick(selector: string, options?: PlaywrightClickOptions): Promise<void>

dispatchEvent(selector: string, type: string, eventInit?: unknown, options?: { strict?: boolean; timeout?: number }): Promise<void>

dragAndDrop(source: string, target: string, options?: { force?: boolean; noWaitAfter?: boolean; sourcePosition?: { x: number; y: number }; strict?: boolean; targetPosition?: { x: number; y: number }; timeout?: number; trial?: boolean }): Promise<void>

evaluate<R = unknown>(pageFunction: string | ((...args: unknown[]) => R | Promise<R>), arg?: unknown): Promise<R>

evaluateHandle<R = unknown>(pageFunction: string | ((...args: unknown[]) => R | Promise<R>), arg?: unknown): Promise<RemotePlaywrightJSHandle>

fill(selector: string, value: string, options?: PlaywrightFillOptions): Promise<void>

focus(selector: string, options?: PlaywrightFocusOptions): Promise<void>

frameElement(): Promise<RemotePlaywrightElementHandle>

frameLocator(selector: string): RemotePlaywrightFrameLocator

getAttribute(selector: string, name: string, options?: PlaywrightGetAttributeOptions): Promise<string | null>

getByAltText(text: string | RegExp, options?: PlaywrightGetByAltTextOptions): RemotePlaywrightLocator

getByLabel(text: string | RegExp, options?: PlaywrightGetByLabelOptions): RemotePlaywrightLocator

getByPlaceholder(text: string | RegExp, options?: PlaywrightGetByPlaceholderOptions): RemotePlaywrightLocator

getByRole(role: "alert" | "alertdialog" | "application" | "article" | "banner" | "blockquote" | "button" | "caption" | "cell" | "checkbox" | "code" | "columnheader" | "combobox" | "complementary" | "contentinfo" | "definition" | "deletion" | "dialog" | "directory" | "document" | "emphasis" | "feed" | "figure" | "form" | "generic" | "grid" | "gridcell" | "group" | "heading" | "img" | "insertion" | "link" | "list" | "listbox" | "listitem" | "log" | "main" | "marquee" | "math" | "meter" | "menu" | "menubar" | "menuitem" | "menuitemcheckbox" | "menuitemradio" | "navigation" | "none" | "note" | "option" | "paragraph" | "presentation" | "progressbar" | "radio" | "radiogroup" | "region" | "row" | "rowgroup" | "rowheader" | "scrollbar" | "search" | "searchbox" | "separator" | "slider" | "spinbutton" | "status" | "strong" | "subscript" | "superscript" | "switch" | "tab" | "table" | "tablist" | "tabpanel" | "term" | "textbox" | "time" | "timer" | "toolbar" | "tooltip" | "tree" | "treegrid" | "treeitem", options?: PlaywrightGetByRoleOptions): RemotePlaywrightLocator

getByTestId(testId: string | RegExp): RemotePlaywrightLocator

getByText(text: string | RegExp, options?: PlaywrightGetByTextOptions): RemotePlaywrightLocator

getByTitle(text: string | RegExp, options?: PlaywrightGetByTitleOptions): RemotePlaywrightLocator

goto(url: string, options?: PlaywrightGotoOptions): Promise<SerializedHandle | null>

hover(selector: string, options?: PlaywrightHoverOptions): Promise<void>

innerHTML(selector: string, options?: PlaywrightInnerHTMLOptions): Promise<string>

innerText(selector: string, options?: PlaywrightInnerTextOptions): Promise<string>

inputValue(selector: string, options?: PlaywrightInputValueOptions): Promise<string>

isChecked(selector: string, options?: PlaywrightIsOptions): Promise<boolean>

isDetached(): boolean

isDisabled(selector: string, options?: PlaywrightIsOptions): Promise<boolean>

isEditable(selector: string, options?: PlaywrightIsOptions): Promise<boolean>

isEnabled(selector: string, options?: PlaywrightIsOptions): Promise<boolean>

isHidden(selector: string, options?: PlaywrightIsOptions): Promise<boolean>

isVisible(selector: string, options?: PlaywrightIsOptions): Promise<boolean>

locator(selector: string, options?: { has?: RemotePlaywrightLocator; hasNot?: RemotePlaywrightLocator; hasText?: string | RegExp; hasNotText?: string | RegExp }): RemotePlaywrightLocator

name(): Promise<string>

page(): RemotePlaywrightPage

parentFrame(): Promise<RemotePlaywrightFrame | null>

press(selector: string, key: string, options?: PlaywrightPressOptions): Promise<void>

selectOption(selector: string, values: string | string[] | { value?: string; label?: string; index?: number } | { value?: string; label?: string; index?: number }[] | null, options?: PlaywrightSelectOptionOptions): Promise<string[]>

setChecked(selector: string, checked: boolean, options?: PlaywrightCheckOptions): Promise<void>

setContent(html: string, options?: { timeout?: number; waitUntil?: "load" | "domcontentloaded" | "networkidle" | "commit" }): Promise<void>

setInputFiles(selector: string, files: string | string[] | { name: string; mimeType: string; buffer: Buffer } | { name: string; mimeType: string; buffer: Buffer }[], options?: { noWaitAfter?: boolean; strict?: boolean; timeout?: number }): Promise<void>

tap(selector: string, options?: { force?: boolean; modifiers?: ("Alt" | "Control" | "Meta" | "Shift")[]; noWaitAfter?: boolean; position?: { x: number; y: number }; strict?: boolean; timeout?: number; trial?: boolean }): Promise<void>

textContent(selector: string, options?: PlaywrightTextContentOptions): Promise<string | null>

title(): Promise<string>

type(selector: string, text: string, options?: PlaywrightTypeOptions): Promise<void>

uncheck(selector: string, options?: PlaywrightCheckOptions): Promise<void>

url(): Promise<string>

waitForFunction<R = unknown>(pageFunction: string | ((...args: unknown[]) => R | Promise<R>), arg?: unknown, options?: { timeout?: number; polling?: number | 'raf' }): Promise<RemotePlaywrightJSHandle>

waitForLoadState(state?: "load" | "domcontentloaded" | "networkidle", options?: { timeout?: number }): Promise<void>

waitForSelector(selector: string, options?: PlaywrightWaitForSelectorOptions): Promise<RemotePlaywrightElementHandle | null>

waitForTimeout(timeout: number): Promise<void>

waitForURL(url: string | RegExp | ((url: URL) => boolean), options?: PlaywrightWaitForURLOptions): Promise<void>

class RemotePlaywrightJSHandle extends RemoteBase

new (id: string, sendRpc: SimpleRpcSender, jsHandleFactory: (id: string) => RemotePlaywrightJSHandle)

dispose(): Promise<void>

evaluate<R = unknown>(pageFunction: Function | string, arg?: unknown): Promise<R>

evaluateHandle<R = unknown>(pageFunction: Function | string, arg?: unknown): Promise<unknown>

getProperties(): Promise<Map<string, unknown>>

getProperty(propertyName: string): Promise<unknown>

jsonValue<T = unknown>(): Promise<T>

class RemotePlaywrightKeyboard extends RemoteComponentBase

new (sendRpc: SimpleRpcSender)

down(key: string): Promise<void>

insertText(text: string): Promise<void>

press(key: string, options?: PlaywrightKeyboardPressOptions): Promise<void>

type(text: string, options?: PlaywrightKeyboardTypeOptions): Promise<void>

up(key: string): Promise<void>

class RemotePlaywrightLocator

new (selector: string, sendRpc: SimpleRpcSender, createElementHandle: ElementHandleFactory, createLocator: LocatorFactory, createFrameLocator: FrameLocatorFactory, _page: RemotePlaywrightPage, state?: Partial<RemotePlaywrightLocatorState>)