Page

async create(client: CDPSession | CRIConnection | Chrome | Object, optionals: PageInitOptions): Promise<Page>

constructor(client: Chrome | CRIConnection | CDPSession | Object, frameTree: Object, initOpts: PageInitOptions)

accessibility: Accessibility: *

animationManager: AnimationManager

coverage: Coverage: *

databaseManager: DatabaseManager: *

frameManager: FrameManager: *

javascriptEnabled: boolean: *

keyboard: Keyboard: *

mouse: Mouse: *

networkManager: NetworkManager: *

touchscreen: Touchscreen: *

tracing: Tracing: *

workerManager: WorkerManager: *

_accessibility: Accessibility

_additionalDomains: EnabledExtras

_animationManager: AnimationManager

_client: Chrome | CRIConnection | CDPSession | Object

_closed: boolean

_coverage: Coverage

_databaseManager: DatabaseManager

_emulationManager: EmulationManager

_frameManager: FrameManager

_ignoreHTTPSErrors: boolean

_javascriptEnabled: boolean

_keyboard: Keyboard

_mouse: Mouse

_networkManager: NetworkManager

_pageBindings: Map<string, Function>

_screenshotTaskQueue: TaskQueue

_target: Target

_targetId: string

_timeoutSettings: TimeoutSettings

_touchscreen: Touchscreen

_tracing: Tracing

_viewport: Viewport

_workerManager: WorkerManager

$(selector: string): Promise<ElementHandle|undefined>

$$(selector: string): Promise<Array<ElementHandle>>

$$eval(selector: string, pageFunction: Function | string, args: ...*): Promise<Object|undefined>

$eval(selector: string, pageFunction: Function | string, args: ...*): Promise<Object|undefined>

$x(expression: string): Promise<Array<ElementHandle>>

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

async addScriptToEvaluateOnNewDocument(source: string, worldName: string): Promise<string>

addStyleTag(options: {url?: string, path?: string, content?: string}): Promise<ElementHandle>

animationsDomainEnabled(): boolean

authenticate(credentials: {username: string, password: string}): *

async bringToFront()

browser(): Browser

browserContext(): BrowserContext

async clearBrowserCache(): Promise<void>

clearBrowserCookies(): Promise<void>

click(selector: string, options: {delay?: number, button?: "left"|"right"|"middle", clickCount?: number}): *

async close(options: {runBeforeUnload: (boolean|undefined)}=)

content(): Promise<string>

cookies(urls: Array<string>): Promise<Array<Cookie>>

databaseDomainEnabled(): boolean

async deleteCookie(cookie: CDPCookie | CookieToBeDeleted | string | Cookie): Promise<void>

async deleteCookies(cookies: Array<CDPCookie|CookieToBeDeleted|string|Cookie>): Promise<void>

async disableAnimationsDomain(): Promise<void>

async disableDatabaseDomain(): Promise<void>

async disableLogDomain(): Promise<void>

async disableNetworkCache(): Promise<void>

async disablePerformanceDomain(): Promise<void>

async disableSecurityDomain(): Promise<void>

async disableServiceWorkersDomain(): Promise<void>

async disableWorkerMonitoring(): Promise<void>

async emulate(options: {viewport: !Viewport, userAgent: string})

async emulateMedia(mediaType: string)

async enableAnimationsDomain(): Promise<void>

async enableDatabaseDomain(): Promise<void>

async enableLogDomain(): Promise<void>

async enableNetworkCache(): Promise<void>

async enablePerformanceDomain(): Promise<void>

async enableSecurityDomain(): Promise<void>

async enableServiceWorkersDomain(): Promise<void>

async enableWorkerMonitoring(): Promise<void>

evaluate(pageFunction: Function | string, args: ...*): Promise<*>

async evaluateHandle(pageFunction: Function | string, args: ...*): Promise<JSHandle>

async evaluateOnNewDocument(pageFunction: Function | string, args: ...*)

async exposeDevToolsProtocol(bindingName: string): Promise<void>

async exposeFunction(name: string, puppeteerFunction: Function)

focus(selector: string): *

frames(): Array<Frame>

getAllCookies(): Promise<Array<Cookie>>

getAnimationPlaybackRate(): Promise<number>

getAppManifest(): Promise{url: string, errors: Array<Object>, data: ?string}>

getDEREncodedCertificateForOrigin(origin: string): Promise<Array<string>>

getElementById(elemId: string): Promise<ElementHandle|undefined>

getLayoutMetrics(): Promise<{layoutviewport: Object, visualViewport: Object, contentSize: Object}>

getNavigationHistory(): PromiseCDPNavigationEntry>

getResourceContent(frameId: string, url: string): Promise<Buffer>

getResourceTree(): Promise<FrameResourceTree>

goBack(options: {timeout?: number, waitUntil?: string|Array<string>}=): Promise<Response|undefined>

goForward(options: {timeout?: number, waitUntil?: string|Array<string>}=): Promise<Response|undefined>

goto(url: string, options: {referer?: string, timeout?: number, waitUntil?: string|Array<string>, transitionType?: string}=): Promise<Response|undefined>

hover(selector: string): *

async httpRequestsBypassServiceWorker(bypass: boolean): Promise<void>

isClosed(): boolean

logDomainEnabled(): boolean

mainFrame(): Frame

async metrics(): Promise<Metrics>

async navigateToHistoryEntry(entryId: number): Promise<void>

networkIdlePromise(options: NetIdleOptions): Promise<void>

async pdf(options: PDFOptions=): Promise<Buffer>

performanceDomainEnabled(): boolean

async queryObjects(prototypeHandle: JSHandle): Promise<JSHandle>

querySelector(selector: string): Promise<ElementHandle|undefined>

querySelectorAll(selector: string): Promise<Array<ElementHandle>>

querySelectorAllEval(selector: string, pageFunction: Function | String, args: ...*): Promise<Object|undefined>

querySelectorEval(selector: string, pageFunction: Function | String, args: ...*): Promise<Object|undefined>

async reload(options: {timeout?: number, waitUntil?: string|Array<string>, ignoreCache?: boolean, scriptToEvaluateOnLoad?: string}=): Promise<Response|undefined>

async removeScriptToEvaluateOnNewDocument(identifier: string): Promise<void>

async resetNavigationHistory()

async screenshot(options: ScreenshotOptions=): Promise<Buffer|!String>

securityDomainEnabled(): boolean

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

serviceWorkers(): Array<ServiceWorker>

serviceWorkersEnabled(): boolean

async setAcceptLanguage(acceptLanguage: string)

setAnimationPlaybackRate(playbackRate: number): Promise<void>

setBlockedURLs(urls: ...string): Promise<void>

async setBypassCSP(enabled: boolean)

async setCacheEnabled(enabled: boolean)

async setContent(html: string, options: {timeout?: number, waitUntil?: string|Array<string>}=)

async setCookie(cookie: CDPCookie | Cookie | string): Promise<boolean>

async setCookies(cookies: Array<CDPCookie|Cookie|string>): Promise<void>

setDefaultNavigationTimeout(timeout: number)

setDefaultTimeout(timeout: number)

async setDownloadBehavior(behavior: string, downloadPath: string): Promise<void>

setExtraHTTPHeaders(headers: Object<string, string>): *

async setGeolocation(options: {longitude: number, latitude: number, accuracy: number|undefined})

async setJavaScriptEnabled(enabled: boolean)

async setNavigatorPlatform(platform: string)

setOfflineMode(enabled: boolean): *

async setRequestInterception(value: boolean)

setUserAgent(userAgent: string): *

async setViewport(viewport: Viewport)

async stopLoading(): Promise<void>

tap(selector: string): *

target(): Target

title(): Promise<string>

toJSON(): {frames: !FrameManager, javascriptEnabled: boolean, additionalDomains: EnabledExtras, workers: IterableIterator<Worker>, url: string, target: ?Target, network: !NetworkManager}

type(selector: string, text: string, options: {delay: (number|undefined)}=): *

url(): string

async userAgent(): Promise<string>

viewport(): Viewport

waitFor(selectorOrFunctionOrTimeout: string | number | Function, options: Object=, args: ...*): Promise<JSHandle>

waitForFunction(pageFunction: Function, options: {polling?: string|number, timeout?: number}=, args: ...*): Promise<JSHandle>

waitForNavigation(options: {timeout?: number, waitUntil?: string|Array<string>}=): PromiseResponse>

waitForRequest(urlOrPredicate: string | Function, options: {timeout?: number}): Promise<Request>

waitForResponse(urlOrPredicate: string | Function, options: {timeout?: number}): Promise<Response>

waitForSelector(selector: string, options: {visible?: boolean, hidden?: boolean, timeout?: number}): Promise<ElementHandle|undefined>

waitForXPath(xpath: string, options: {visible?: boolean, hidden?: boolean, timeout?: number}=): Promise<ElementHandle|undefined>

workerMonitoringEnabled(): boolean

workers(): Array<Worker>

xpathQuery(expression: string): Promise<Array<ElementHandle>>

__onClose()

_buildMetricsObject(metrics: Array<Object>): Metrics

_emitMetrics(event: Object)

async _go(delta: *, options: {timeout?: number, waitUntil?: string|Array<string>}=): Promise<Response|undefined>

_handleException(exception: Object)

async _onBindingCalled(event: Object)

_onCertificateError(event: Object)

async _onConsoleAPI(event: Object)

_onDialog(event: *)

_onLogEntryAdded(event: Object): *

_onTargetCrashed()

async _screenshotTask(format: "png" | "jpeg", options: ScreenshotOptions=): Promise<Buffer|!String>