@bctrl/sdk/puppeteer

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

class ProtocolError extends PuppeteerError

new (message?: string, code?: number, originalMessage?: string)

class PuppeteerError extends Error

new (message?: string)

class PuppeteerEventEmitter

emit<Key extends keyof Events>(type: Key, event: Events[Key]): boolean

listenerCount<Key extends keyof Events>(type: Key): number

off<Key extends keyof Events>(type: Key, handler?: Handler<Events[Key]>): this

on<Key extends keyof Events>(type: Key, handler: Handler<Events[Key]>): this

once<Key extends keyof Events>(type: Key, handler: Handler<Events[Key]>): this

removeAllListeners<Key extends keyof Events>(type?: Key): this

class PuppeteerSession extends BaseSession<RemotePuppeteerPage, PuppeteerScriptPage>

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

class RemoteBase

new (id: string, sendRpc: SimpleRpcSender)

class RemoteComponentBase

new (sendRpc: SimpleRpcSender)

class RemotePuppeteerAccessibility extends RemoteComponentBase

new (sendRpc: SimpleRpcSender)

snapshot(options?: SnapshotOptions): Promise<PuppeteerSerializedAXNode | null>

class RemotePuppeteerBrowser extends PuppeteerEventEmitter<BrowserEvents>

new (sendRpc: SimpleRpcSender, createPage: (pageId: string) => RemotePuppeteerPage, createContext: (contextId: string, isDefault: boolean) => RemotePuppeteerBrowserContext)

browserContexts(): RemotePuppeteerBrowserContext[]

close(): Promise<void>

cookies(...urls: string[]): Promise<PuppeteerCookie[]>

createBrowserContext(options?: PuppeteerBrowserContextOptions): Promise<RemotePuppeteerBrowserContext>

defaultBrowserContext(): RemotePuppeteerBrowserContext

deleteCookie(...cookies: PuppeteerCookie[]): Promise<void>

deleteMatchingCookies(...filters: PuppeteerDeleteCookiesRequest[]): Promise<void>

disconnect(): void

getWindowBounds(windowId: number): Promise<PuppeteerWindowBounds>

installExtension(path: string): Promise<string>

newPage(options?: { timeout?: number }): Promise<RemotePuppeteerPage>

pages(includeAll?: boolean): Promise<RemotePuppeteerPage[]>

process(): Promise<{ pid: number } | null>

setCookie(...cookies: PuppeteerCookieData[]): Promise<void>

setWindowBounds(windowId: number, bounds: PuppeteerWindowBounds): Promise<void>

target(): Promise<PuppeteerTarget>

targets(): Promise<PuppeteerTarget[]>

uninstallExtension(id: string): Promise<void>

userAgent(): Promise<string>

version(): Promise<string>

waitForTarget(filter: PuppeteerTargetFilter, options?: PuppeteerWaitForTargetOptions): Promise<PuppeteerTarget>

wsEndpoint(): Promise<string>

class RemotePuppeteerBrowserContext extends PuppeteerEventEmitter<BrowserContextEvents>

new (sendRpc: SimpleRpcSender, options: { contextId: string; isDefault?: boolean }, createPage: (pageId: string) => RemotePuppeteerPage)

clearPermissionOverrides(): Promise<void>

close(): Promise<void>

cookies(...urls: string[]): Promise<PuppeteerCookie[]>

deleteCookie(...cookies: PuppeteerCookie[]): Promise<void>

deleteMatchingCookies(...filters: PuppeteerDeleteCookiesRequest[]): Promise<void>

markClosed(): void

newPage(options?: { timeout?: number }): Promise<RemotePuppeteerPage>

overridePermissions(origin: string, permissions: PuppeteerPermission[]): Promise<void>

pages(includeAll?: boolean): Promise<RemotePuppeteerPage[]>

setCookie(...cookies: PuppeteerCookieData[]): Promise<void>

targets(): Promise<PuppeteerTarget[]>

class RemotePuppeteerConsoleMessage

new (messageData: PuppeteerConsoleMessage)

args(): unknown[]

location(): PuppeteerConsoleMessageLocation

stackTrace(): PuppeteerConsoleMessageLocation[]

text(): string

type(): PuppeteerConsoleMessageType

class RemotePuppeteerCoverage

new (sendRpc: SimpleRpcSender)

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

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

stopCSSCoverage(): Promise<PuppeteerCoverageEntry[]>

stopJSCoverage(): Promise<PuppeteerJSCoverageEntry[]>

class RemotePuppeteerDialog

new (sendRpc: SimpleRpcSender, dialogData: PuppeteerDialog)

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

defaultValue(): string

dismiss(): Promise<void>

message(): string

type(): PuppeteerDialogType

class RemotePuppeteerElementHandle extends RemoteBase

new (id: string, sendRpc: SimpleRpcSender, createElementHandle: (handleId: string) => RemotePuppeteerElementHandle, createFrame: (frameId: string) => RemotePuppeteerFrame, createLocator: (handleId: string) => RemotePuppeteerLocator, createTouchHandle: (touchId: string) => TouchHandle)

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

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

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

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

autofill(data: PuppeteerAutofillData): Promise<void>

boundingBox(): Promise<PuppeteerBoundingBox | null>

boxModel(): Promise<PuppeteerBoxModel | null>

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

clickablePoint(offset?: PuppeteerOffset): Promise<PuppeteerPoint>

contentFrame(): Promise<RemotePuppeteerFrame | null>

drag(target: PuppeteerPoint | RemotePuppeteerElementHandle): Promise<PuppeteerDragData | void>

dragAndDrop(target: RemotePuppeteerElementHandle | PuppeteerPoint, options?: { delay?: number }): Promise<void>

dragEnter(data?: PuppeteerDragData): Promise<void>

dragOver(data?: PuppeteerDragData): Promise<void>

drop(element: RemotePuppeteerElementHandle): Promise<void>

evaluate<T = unknown>(pageFunction: string | ((element: Element, ...args: unknown[]) => T | Promise<T>), ...args: unknown[]): Promise<T>

focus(): Promise<void>

getProperty<T = unknown>(propertyName: string): Promise<T>

hover(): Promise<void>

isHidden(): Promise<boolean>

isIntersectingViewport(options?: { threshold?: number }): Promise<boolean>

isVisible(): Promise<boolean>

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

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

scrollIntoView(): Promise<void>

select(...values: string[]): Promise<string[]>

tap(): Promise<void>

toElement<K extends keyof HTMLElementTagNameMap>(tagName: K): Promise<RemotePuppeteerElementHandle>

touchEnd(): Promise<void>

touchMove(touch?: { touchId?: string }): Promise<void>

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

uploadFile(...filePaths: string[]): Promise<void>

waitForSelector(selector: string, options?: PuppeteerWaitForSelectorOptions): Promise<RemotePuppeteerElementHandle | null>

class RemotePuppeteerFileChooser

new (id: string, sendRpc: SimpleRpcSender, isMultiple: boolean)

accept(paths: string[]): Promise<void>

cancel(): Promise<void>

isMultiple(): boolean

class RemotePuppeteerFrame extends RemoteBase

new (id: string, sendRpc: SimpleRpcSender, createElementHandle: (handleId: string) => RemotePuppeteerElementHandle, createFrame: (frameId: string) => RemotePuppeteerFrame, createLocator: (selector: string) => RemotePuppeteerLocator, createJSHandle: (handleId: string) => RemotePuppeteerJSHandle, getPage: () => RemotePuppeteerPage)

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

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

$$eval<T = unknown>(selector: string, pageFunction: string | ((els: Element[], ...args: unknown[]) => T | Promise<T>), ...args: unknown[]): Promise<T>

$eval<T = unknown>(selector: string, pageFunction: string | ((el: Element, ...args: unknown[]) => T | Promise<T>), ...args: unknown[]): Promise<T>

addScriptTag(options: PuppeteerFrameAddScriptTagOptions): Promise<RemotePuppeteerElementHandle>

addStyleTag(options: PuppeteerFrameAddStyleTagOptions): Promise<RemotePuppeteerElementHandle>

childFrames(): Promise<RemotePuppeteerFrame[]>

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

content(): Promise<string>

detached(): boolean

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

evaluateHandle<Params extends unknown[] = unknown[], Func extends (...args: Params) => unknown = (...args: Params) => unknown>(pageFunction: Func | string, ...args: Params): Promise<RemotePuppeteerJSHandle<Awaited<ReturnType<Func>>>>

focus(selector: string): Promise<void>

frameElement(): Promise<RemotePuppeteerElementHandle | null>

goto(url: string, options?: PuppeteerGotoOptions): Promise<PuppeteerHTTPResponse | null>

hover(selector: string): Promise<void>

isDetached(): boolean

isMainFrame(): Promise<boolean>

locator(selector: string): RemotePuppeteerLocator

name(): Promise<string>

page(): RemotePuppeteerPage

parentFrame(): Promise<RemotePuppeteerFrame | null>

select(selector: string, ...values: string[]): Promise<string[]>

setContent(html: string, options?: { timeout?: number; waitUntil?: string }): Promise<void>

tap(selector: string): Promise<void>

title(): Promise<string>

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

url(): Promise<string>

waitForFunction<Params extends unknown[] = unknown[], Func extends (...args: Params) => unknown = (...args: Params) => unknown>(pageFunction: Func | string, options?: { timeout?: number; polling?: number | 'raf' | 'mutation' }, ...args: Params): Promise<RemotePuppeteerJSHandle<Awaited<ReturnType<Func>>>>

waitForNavigation(options?: PuppeteerWaitForNavigationOptions): Promise<PuppeteerHTTPResponse | null>

waitForSelector(selector: string, options?: PuppeteerWaitForSelectorOptions): Promise<RemotePuppeteerElementHandle | null>

class RemotePuppeteerHTTPRequest

new (sendRpc: SimpleRpcSender, data: SerializedHTTPRequest, factories: { createRequest?: HTTPRequestFactory; createResponse?: HTTPResponseFactory; createFrame?: FrameFactory })

abort(errorCode?: PuppeteerErrorCode, priority?: number): Promise<void>

abortErrorReason(): PuppeteerErrorCode | undefined

continue(overrides?: PuppeteerContinueRequestOverrides, priority?: number): Promise<void>

continueRequestOverrides(): PuppeteerContinueRequestOverrides

enqueueInterceptAction(pendingHandler: () => void | PromiseLike<unknown>): Promise<void>

failure(): { errorText: string } | null

fetchPostData(): Promise<string | undefined>

finalizeInterceptions(): Promise<void>

frame(): unknown | null

hasPostData(): boolean

headers(): Record<string, string>

initiator(): PuppeteerInitiator | undefined

interceptResolutionState(): PuppeteerInterceptResolutionState

isInterceptResolutionHandled(): boolean

isNavigationRequest(): boolean

method(): string

postData(): string | undefined

redirectChain(): RemotePuppeteerHTTPRequest[]

resourceType(): PuppeteerResourceType

respond(response: PuppeteerResponseForRequest, priority?: number): Promise<void>

response(): RemotePuppeteerHTTPResponse | null

responseForRequest(): PuppeteerResponseForRequest | undefined

setFailure(errorText: string): void

url(): string

class RemotePuppeteerHTTPResponse

new (sendRpc: SimpleRpcSender, data: PuppeteerHTTPResponse, factories: { createRequest?: HTTPRequestFactory; createFrame?: FrameFactory })

buffer(): Promise<Buffer>

content(): Promise<string>

frame(): unknown | null

fromCache(): boolean

fromServiceWorker(): boolean

headers(): Record<string, string>

json(): Promise<unknown>

ok(): boolean

remoteAddress(): PuppeteerRemoteAddress

request(): RemotePuppeteerHTTPRequest | null

securityDetails(): PuppeteerSecurityDetails | null

status(): number

statusText(): string

text(): Promise<string>

timing(): PuppeteerResourceTiming | null

url(): string

class RemotePuppeteerJSHandle

new (handleId: string, sendRpc: JSHandleRpcSender, createJSHandle: JSHandleFactory, elementHandleFactory?: ElementHandleFactoryForJSHandle)

evaluate<Params extends unknown[] = unknown[], Func extends (value: T, ...args: Params) => unknown = (value: T, ...args: Params) => unknown>(pageFunction: Func | string, ...args: unknown[]): Promise<Awaited<ReturnType<Func>>>

evaluateHandle<Params extends unknown[] = unknown[], Func extends (value: T, ...args: Params) => unknown = (value: T, ...args: Params) => unknown>(pageFunction: Func | string, ...args: unknown[]): Promise<RemotePuppeteerJSHandle<Awaited<ReturnType<Func>>>>

getProperty<K extends keyof T>(propertyName: K | string): Promise<RemotePuppeteerJSHandle<T[K]>>

jsonValue(): Promise<T>

class RemotePuppeteerKeyboard extends RemoteComponentBase

new (sendRpc: SimpleRpcSender)

down(key: PuppeteerKeyInput, options?: PuppeteerKeyDownOptions): Promise<void>

press(key: PuppeteerKeyInput, options?: PuppeteerKeyPressOptions): Promise<void>

sendCharacter(char: string): Promise<void>

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

up(key: PuppeteerKeyInput): Promise<void>

class RemotePuppeteerLocator

new (selector: string, sendRpc: SimpleRpcSender, createElementHandle: ElementHandleFactoryLocal, createLocator: LocatorFactory, state?: Partial<RemotePuppeteerLocatorState>)

click(options?: Readonly<PuppeteerLocatorClickOptions>): Promise<void>

clone(): RemotePuppeteerLocator<T>