// Copyright (c) 2019 Uber Technologies, Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

// flow-typed signature: 5424f3038583c263ad173d9a0e94e5f6
// flow-typed version: 6175de7811/puppeteer_v1.2.x/flow_>=v0.58.x

// @flow

/**
 * Based on typescript definitions found at the url below
 * https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/puppeteer
 */

declare module 'puppeteer' {
  import type {ChildProcess} from 'child_process';

  declare class OverridableEventEmitter extends events$EventEmitter {
    /* eslint-disable flowtype/no-weak-types */
    +on: Function;
    +once: Function;
    /* eslint-enable flowtype/no-weak-types */
  }

  /** Keyboard provides an api for managing a virtual keyboard. */
  declare type Keyboard = {
    /**
     * Dispatches a keydown event.
     * @param key Name of key to press, such as ArrowLeft.
     * @param options Specifies a input text event.
     */
    down(key: string, options?: {text?: string}): Promise<void>,

    /** Shortcut for `keyboard.down` and `keyboard.up`. */
    press(
      key: string,
      options?: {delay?: number, text?: string}
    ): Promise<void>,

    /** Dispatches a `keypress` and `input` event. This does not send a `keydown` or keyup `event`. */
    sendCharacter(char: string): Promise<void>,

    /**
     * Sends a keydown, keypress/input, and keyup event for each character in the text.
     * @param text A text to type into a focused element.
     * @param options Specifies the typing options.
     */
    type(text: string, options?: {delay?: number}): Promise<void>,

    /**
     * Dispatches a keyup event.
     * @param key Name of key to release, such as ArrowLeft.
     */
    up(key: string): Promise<void>,
  };

  declare type MousePressOptions = {
    /**
     * left, right, or middle.
     * @default left
     */
    button?: MouseButtons,

    /**
     * The number of clicks.
     * @default 1
     */
    clickCount?: number,
  };

  declare type Mouse = {
    /**
     * Shortcut for `mouse.move`, `mouse.down` and `mouse.up`.
     * @param x The x position.
     * @param y The y position.
     * @param options The click options.
     */
    click(x: number, y: number, options?: ClickOptions): Promise<void>,

    /**
     * Dispatches a `mousedown` event.
     * @param options The mouse press options.
     */
    down(options?: MousePressOptions): Promise<void>,

    /**
     * Dispatches a `mousemove` event.
     * @param x The x position.
     * @param y The y position.
     * @param options The mouse move options.
     */
    move(x: number, y: number, options?: {steps: number}): Promise<void>,
    /**
     * Dispatches a `mouseup` event.
     * @param options The mouse press options.
     */
    up(options?: MousePressOptions): Promise<void>,
  };

  declare type Touchscreen = {
    /**
     * Dispatches a touchstart and touchend event.
     * @param x The x position.
     * @param y The y position.
     */
    tap(x: number, y: number): Promise<void>,
  };

  /**
   * You can use `tracing.start` and `tracing.stop` to create a trace file which can be opened in Chrome DevTools or timeline viewer.
   */
  declare type Tracing = {
    start(options: TracingStartOptions): Promise<void>,

    stop(): Promise<void>,
  };

  declare type TracingStartOptions = {
    categories?: Array<string>,
    path: string,
    screenshots?: boolean,
  };

  /** Dialog objects are dispatched by page via the 'dialog' event. */
  declare type Dialog = {
    /**
     * Accepts the dialog.
     * @param promptText A text to enter in prompt. Does not cause any effects if the dialog's type is not prompt.
     */
    accept(promptText?: string): Promise<void>,

    /** If dialog is prompt, returns default prompt value. Otherwise, returns empty string. */
    defaultValue(): string,

    /** Dismiss the dialog */
    dismiss(): Promise<void>,

    /** Returns the message displayed in the dialog. */
    message(): string,

    /** The dialog type. Dialog's type, can be one of `alert`, `beforeunload`, `confirm` or `prompt`. */
    type(): 'alert' | 'beforeunload' | 'confirm' | 'prompt',
  };

  /** ConsoleMessage objects are dispatched by page via the 'console' event. */
  declare type ConsoleMessage = {
    /** The message arguments. */
    args(): Array<JSHandle>,

    /** The message text. */
    text(): string,

    type():
      | 'log'
      | 'debug'
      | 'info'
      | 'error'
      | 'warning'
      | 'dir'
      | 'dirxml'
      | 'table'
      | 'trace'
      | 'clear'
      | 'startGroup'
      | 'startGroupCollapsed'
      | 'endGroup'
      | 'assert'
      | 'profile'
      | 'profileEnd'
      | 'count'
      | 'timeEnd',
  };

  declare type PageEvents =
    | 'console'
    | 'dialog'
    | 'error'
    | 'frameattached'
    | 'framedetached'
    | 'framenavigated'
    | 'load'
    | 'pageerror'
    | 'request'
    | 'requestfailed'
    | 'requestfinished'
    | 'response';

  declare type BrowserEvents =
    | 'disconnected'
    | 'targetchanged'
    | 'targetcreated'
    | 'targetdestroyed';

  declare type AuthOptions = {
    password: string,
    username: string,
  };

  declare type MouseButtons = 'left' | 'right' | 'middle';

  declare type ClickOptions = {
    /** defaults to left */
    button?: MouseButtons,

    /** defaults to 1 */
    clickCount?: number,

    /**
     * Time to wait between mousedown and mouseup in milliseconds.
     * Defaults to 0.
     */
    delay?: number,
  };

  /** Represents a browser cookie. */
  declare type Cookie = {
    /** The cookie domain. */
    domain: string,

    /** The cookie Unix expiration time in seconds. */
    expires: number,

    /** The cookie http only flag. */
    httpOnly: boolean,

    /** The cookie name. */
    name: string,

    /** The cookie path. */
    path: string,

    /** The cookie same site definition. */
    sameSite: 'Strict' | 'Lax',

    /** The cookie secure flag. */
    secure: boolean,

    /** The cookie value. */
    value: string,
  };

  declare type DeleteCookie = {
    domain?: string,
    /** The cookie name. */
    name: string,
    path?: string,
    secure?: boolean,
    url?: string,
  };

  declare type SetCookie = {
    /** The cookie domain. */
    domain?: string,

    /** The cookie Unix expiration time in seconds. */
    expires?: number,

    /** The cookie http only flag. */
    httpOnly?: boolean,

    /** The cookie name. */
    name: string,

    /** The cookie path. */
    path?: string,

    /** The cookie same site definition. */
    sameSite?: 'Strict' | 'Lax',

    /** The cookie secure flag. */
    secure?: boolean,

    /** The request-URI to associate with the setting of the cookie. This value can affect the default domain and path values of the created cookie. */
    url?: string,

    /** The cookie value. */
    value: string,
  };

  declare type Viewport = {
    /**
     * Specify device scale factor (can be thought of as dpr).
     * @default 1
     */
    deviceScaleFactor?: number,

    /**
     * Specifies if viewport supports touch events.
     * @default false
     */
    hasTouch?: boolean,

    /** The page height in pixels. */
    height: number,

    /**
     * Specifies if viewport is in landscape mode.
     * @default false
     */
    isLandscape?: boolean,

    /**
     * Whether the `meta viewport` tag is taken into account.
     * @default false
     */
    isMobile?: boolean,

    /** The page width in pixels. */
    width: number,
  };

  /** Page emulation options. */
  declare type EmulateOptions = {
    /** The emulated user-agent. */
    userAgent?: string,

    /** The viewport emulation options. */
    viewport?: Viewport,
  };

  declare type EvaluateFn = string | ((...args: Array<mixed>) => mixed);

  declare type LoadEvent =
    | 'load'
    | 'domcontentloaded'
    | 'networkidle0'
    | 'networkidle2';

  /** The navigation options. */
  declare type NavigationOptions = {
    /**
     * Maximum navigation time in milliseconds, pass 0 to disable timeout.
     * @default 30000
     */
    timeout?: number,
    /**
     * When to consider navigation succeeded.
     * @default load Navigation is consider when the `load` event is fired.
     */
    waitUntil?: LoadEvent | Array<LoadEvent>,
  };

  declare type PDFFormat =
    | 'Letter'
    | 'Legal'
    | 'Tabload'
    | 'Ledger'
    | 'A0'
    | 'A1'
    | 'A2'
    | 'A3'
    | 'A4'
    | 'A5';

  declare type PDFOptions = {
    /**
     * Display header and footer.
     * @default false
     */
    displayHeaderFooter?: boolean,

    /**
     * HTML template for the print footer. Should be valid HTML markup with following classes used to inject printing values into them:
     * - `date` formatted print date
     * - `title` document title
     * - `url` document location
     * - `pageNumber` current page number
     * - `totalPages` total pages in the document
     */
    footerTemplate?: string,

    /** Paper format. If set, takes priority over width or height options. Defaults to 'Letter'. */
    format?: PDFFormat,

    /**
     * HTML template for the print header. Should be valid HTML markup with following classes used to inject printing values into them:
     * - `date` formatted print date
     * - `title` document title
     * - `url` document location
     * - `pageNumber` current page number
     * - `totalPages` total pages in the document
     */
    headerTemplate?: string,

    /** Paper height, accepts values labeled with units. */
    height?: string,

    /**
     * Paper orientation.
     * @default false
     */
    landscape?: boolean,

    /** Paper margins, defaults to none.  */
    margin?: {
      /** Bottom margin, accepts values labeled with units. */
      bottom?: string,

      /** Left margin, accepts values labeled with units. */
      left?: string,

      /** Right margin, accepts values labeled with units. */
      right?: string,

      /** Top margin, accepts values labeled with units. */
      top?: string,
    },

    /**
     * Paper ranges to print, e.g., '1-5, 8, 11-13'. Defaults to the empty
     * string, which means print all pages.
     */
    pageRanges?: string,

    /**
     * The file path to save the PDF to.
     * If `path` is a relative path, then it is resolved relative to current working directory.
     * If no path is provided, the PDF won't be saved to the disk.
     */
    path?: string,

    /**
     * Print background graphics.
     * @default false
     */
    printBackground?: boolean,

    /**
     * Scale of the webpage rendering.
     * @default 1
     */
    scale?: number,

    /** Paper width, accepts values labeled with units. */
    width?: string,
  };

  /** Defines the screenshot options. */
  declare type ScreenshotOptions = {
    /**
     * An object which specifies clipping region of the page.
     */
    clip?: BoundingBox,

    /**
     * When true, takes a screenshot of the full scrollable page.
     * @default false
     */
    fullPage?: boolean,

    /**
     * Hides default white background and allows capturing screenshots with transparency.
     * @default false
     */
    omitBackground?: boolean,

    /**
     * The file path to save the image to. The screenshot type will be inferred from file extension.
     * If `path` is a relative path, then it is resolved relative to current working directory.
     * If no path is provided, the image won't be saved to the disk.
     */
    path?: string,

    /** The quality of the image, between 0-100. Not applicable to png images. */
    quality?: number,

    /**
     * The screenshot type.
     * @default png
     */
    type?: 'jpeg' | 'png',
  };

  /** Options for `addStyleTag` */
  declare type StyleTagOptions = {
    /** Raw CSS content to be injected into frame. */
    content?: string,

    /** Path to the CSS file to be injected into frame. If `path` is a relative path, then it is resolved relative to current working directory. */
    path?: string,

    /** Url of the <link> tag. */
    url?: string,
  };
  /** Options for `addScriptTag` */
  declare type ScriptTagOptions = {
    /** Raw JavaScript content to be injected into frame. */
    content?: string,

    /** Path to the JavaScript file to be injected into frame. If `path` is a relative path, then it is resolved relative to current working directory. */
    path?: string,

    /** Script type. Use 'module' in order to load a Javascript ES6 module. */
    type?: string,

    /** Url of a script to be added. */
    url?: string,
  };

  declare type PageFnOptions = {
    polling?: 'raf' | 'mutation' | number,
    timeout?: number,
  };

  declare type BoundingBox = {
    /** The height. */
    height: number,

    /** The width. */
    width: number,

    /** The x-coordinate of top-left corner. */
    x: number,

    /** The y-coordinate of top-left corner. */
    y: number,
  };

  /**
   * Represents an in-page DOM element. ElementHandles can be created with the page.$ method.
   */
  declare type ElementHandle = JSHandle & {
    /**
     * The method runs element.querySelector within the page. If no element matches the selector, the return value resolve to null.
     * @param selector A selector to query element for
     * @since 0.13.0
     */
    $(selector: string): Promise<ElementHandle | null>,

    /**
     * The method runs element.querySelectorAll within the page. If no elements match the selector, the return value resolve to [].
     * @param selector A selector to query element for
     * @since 0.13.0
     */
    $$(selector: string): Promise<Array<ElementHandle>>,

    /**
     * @param selector XPath expression to evaluate.
     */
    $x(expression: string): Promise<Array<ElementHandle>>,

    /**
     * This method returns the value resolve to the bounding box of the element (relative to the main frame), or null if the element is not visible.
     */
    boundingBox(): Promise<BoundingBox | null>,

    /**
     * This method scrolls element into view if needed, and then uses page.mouse to click in the center of the element.
     * If the element is detached from DOM, the method throws an error.
     * @param options Specifies the options.
     * @since 0.9.0
     */
    click(options?: ClickOptions): Promise<void>,

    /**
     * @returns Resolves to the content frame for element handles referencing iframe nodes, or null otherwise.
     * @since 1.2.0
     */
    contentFrame(): Promise<?Frame>,

    /**
     * Calls focus on the element.
     */
    focus(): Promise<void>,

    /**
     * This method scrolls element into view if needed, and then uses page.mouse to hover over the center of the element.
     * If the element is detached from DOM, the method throws an error.
     */
    hover(): Promise<void>,

    /**
     * Focuses the element, and then uses keyboard.down and keyboard.up.
     * @param key Name of key to press, such as ArrowLeft. See USKeyboardLayout for a list of all key names.
     * @param options The text and delay options.
     */
    press(
      key: string,
      options?: {delay?: number, text?: string}
    ): Promise<void>,

    /**
     * This method scrolls element into view if needed, and then uses page.screenshot to take a screenshot of the element.
     * If the element is detached from DOM, the method throws an error.
     * @param options Same options as in page.screenshot.
     */
    screenshot(options?: ScreenshotOptions): Promise<Buffer>,

    /**
     * This method scrolls element into view if needed, and then uses touchscreen.tap to tap in the center of the element.
     * If the element is detached from DOM, the method throws an error.
     */
    tap(): Promise<void>,

    toString(): string,

    /**
     * Focuses the element, and then sends a keydown, keypress/input, and keyup event for each character in the text.
     * @param text A text to type into a focused element.
     * @param options The typing options.
     */
    type(text: string, options?: {delay: number}): Promise<void>,

    /**
     * This method expects elementHandle to point to an input element.
     * @param filePaths Sets the value of the file input these paths. If some of the filePaths are relative paths, then they are resolved relative to current working directory.
     */
    uploadFile(...filePaths: Array<string>): Promise<void>,
  };

  /** The class represents a context for JavaScript execution. */
  declare type ExecutionContext = {
    evaluate(fn: EvaluateFn, ...args: Array<mixed>): Promise<mixed>,
    evaluateHandle(fn: EvaluateFn, ...args: Array<mixed>): Promise<JSHandle>,
    queryObjects(prototypeHandle: JSHandle): JSHandle,
  };

  /** JSHandle represents an in-page JavaScript object. */
  declare type JSHandle = {
    /**
     * Returns a ElementHandle
     */
    asElement(): ElementHandle | null,

    /**
     * Stops referencing the element handle.
     */
    dispose(): Promise<void>,

    /**
     * Gets the execution context.
     */
    executionContext(): ExecutionContext,

    /**
     * Returns a map with property names as keys and JSHandle instances for the property values.
     */
    getProperties(): Promise<Map<string, JSHandle>>,

    /**
     * Fetches a single property from the objectHandle.
     * @param propertyName The property to get.
     */
    getProperty(propertyName: string): Promise<JSHandle>,

    /**
     * Returns a JSON representation of the object.
     * The JSON is generated by running JSON.stringify on the object in page and consequent JSON.parse in puppeteer.
     * @throws The method will throw if the referenced object is not stringifiable.
     */
    jsonValue(): Promise<mixed>,
  };

  declare type Metrics = {
    /** Number of documents in the page. */
    Documents: number,

    /** Number of frames in the page. */
    Frames: number,

    /** Number of events in the page. */
    JSEventListeners: number,

    /** Total JavaScript heap size. */
    JSHeapTotalSize: number,

    /** Used JavaScript heap size. */
    JSHeapUsedSize: number,
    /** Total number of full or partial page layout. */
    LayoutCount: number,

    /** Combined durations of all page layouts. */
    LayoutDuration: number,

    /** Number of DOM nodes in the page. */
    Nodes: number,

    /** Total number of page style recalculations. */
    RecalcStyleCount: number,

    /** Combined duration of all page style recalculations. */
    RecalcStyleDuration: number,

    /** Combined duration of JavaScript execution. */
    ScriptDuration: number,

    /** Combined duration of all tasks performed by the browser. */
    TaskDuration: number,

    /** The timestamp when the metrics sample was taken. */
    Timestamp: number,
  };

  declare type Headers = {[key: string]: string};
  declare type HttpMethod =
    | 'GET'
    | 'POST'
    | 'PATCH'
    | 'PUT'
    | 'DELETE'
    | 'OPTIONS';

  declare type ResourceType =
    | 'document'
    | 'stylesheet'
    | 'image'
    | 'media'
    | 'font'
    | 'script'
    | 'texttrack'
    | 'xhr'
    | 'fetch'
    | 'eventsource'
    | 'websocket'
    | 'manifest'
    | 'other';

  declare type Overrides = {
    headers?: Headers,
    method?: HttpMethod,
    postData?: string,
    url?: string,
  };

  /** Represents a page request. */
  declare type Request = {
    /**
     * Aborts request.
     * To use this, request interception should be enabled with `page.setRequestInterception`.
     * @throws An exception is immediately thrown if the request interception is not enabled.
     */
    abort(): Promise<void>,

    /**
     * Continues request with optional request overrides.
     * To use this, request interception should be enabled with `page.setRequestInterception`.
     * @throws An exception is immediately thrown if the request interception is not enabled.
     */
    continue(overrides?: Overrides): Promise<void>,

    /**
     * @returns The `Frame` object that initiated the request, or `null` if navigating to error pages
     */
    frame(): Promise<?Frame>,

    /**
     * An object with HTTP headers associated with the request.
     * All header names are lower-case.
     */
    headers(): Headers,
    /** Returns the request's method (GET, POST, etc.) */

    method(): HttpMethod,

    /** Contains the request's post body, if any. */
    postData(): ?string,

    /**
     * A `redirectChain` is a chain of requests initiated to fetch a resource.
     *
     * - If there are no redirects and the request was successful, the chain will be empty.
     * - If a server responds with at least a single redirect, then the chain will contain all the requests that were redirected.
     *
     * `redirectChain` is shared between all the requests of the same chain.
     *
     * @since 1.2.0
     */
    redirectChain(): Array<Request>,

    /** Contains the request's resource type as it was perceived by the rendering engine.  */
    resourceType(): ResourceType,

    /**
     * Fulfills request with given response.
     * To use this, request interception should be enabled with `page.setRequestInterception`.
     * @throws An exception is immediately thrown if the request interception is not enabled.
     * @param response The response options that will fulfill this request.
     */
    respond(response: RespondOptions): Promise<void>,

    /** A matching `Response` object, or `null` if the response has not been received yet. */
    response(): ?Response,

    /** Contains the URL of the request. */
    url(): string,
  };

  /** Options for `Request.respond` method */
  declare type RespondOptions = {
    /** Specifies the response body. */
    body?: Buffer | string,

    /** Specifies the Content-Type response header. */
    contentType?: string,

    /** Specifies the response headers. */
    headers?: Headers,

    /**
     * Specifies the response status code.
     * @default 200
     */
    status?: number,
  };

  /** Response class represents responses which are received by page. */
  declare type Response = {
    /** Promise which resolves to a buffer with response body. */
    buffer(): Promise<Buffer>,

    /** True if the response was served from either the browser's disk cache or memory cache. */
    fromCache(): boolean,

    /** True if the response was served by a service worker. */
    fromServiceWorker(): boolean,

    /** An object with HTTP headers associated with the response. All header names are lower-case. */
    headers(): Headers,

    /**
     * Promise which resolves to a JSON representation of response body.
     * @throws This method will throw if the response body is not parsable via `JSON.parse`.
     */
    json(): Promise<mixed>,

    /** Contains a boolean stating whether the response was successful (status in the range 200-299) or not. */
    ok(): boolean,

    /** A matching Request object. */
    request(): Request,

    /** Contains the status code of the response (e.g., 200 for a success). */
    status(): number,

    /** Promise which resolves to a text representation of response body. */
    text(): Promise<string>,

    /** Contains the URL of the response. */
    url(): string,
  };

  declare type FrameBase = {
    /**
     * The method runs document.querySelector within the page.
     * If no element matches the selector, the return value resolve to null.
     */
    $(selector: string): Promise<?ElementHandle>,

    /**
     * The method runs document.querySelectorAll within the page. If no elements match the selector, the return value resolve to [].
     */
    $$(selector: string): Promise<Array<ElementHandle>>,

    /**
     * This method runs document.querySelectorAll within the page and passes it as the first argument to `fn`.
     * If `fn` returns a Promise, then $$eval would wait for the promise to resolve and return its value.
     * @param selector A selector to query frame for
     * @param fn Function to be evaluated in browser context
     * @param args Arguments to pass to pageFunction
     * @returns Promise which resolves to the return value of pageFunction
     */
    $$eval(
      selector: string,
      pageFunction: (
        elements: NodeList<Element>,
        ...args: Array<mixed>
      ) => mixed,
      ...args: Array<mixed>
    ): Promise<mixed>,

    /**
     * This method runs document.querySelector within the page and passes it as the first argument to `fn`.
     * If there's no element matching selector, the method throws an error.
     * If `fn` returns a Promise, then $eval would wait for the promise to resolve and return its value.
     */
    $eval(
      selector: string,
      pageFunction: (element: Element, ...args: Array<mixed>) => mixed,
      ...args: Array<mixed>
    ): Promise<mixed>,

    /**
     * @param expression XPath expression to evaluate.
     */
    $x(expression: string): Promise<Array<ElementHandle>>,

    /** Adds a `<script>` tag into the page with the desired url or content. */
    addScriptTag(options: ScriptTagOptions): Promise<void>,

    /** Adds a `<link rel="stylesheet">` tag into the page with the desired url or a `<style type="text/css">` tag with the content. */
    addStyleTag(options: StyleTagOptions): Promise<void>,

    /** Gets the full HTML contents of the page, including the doctype. */
    content(): Promise<string>,

    /**
     * Evaluates a function in the browser context.
     * If the function, passed to the frame.evaluate, returns a Promise, then frame.evaluate would wait for the promise to resolve and return its value.
     * If the function passed into frame.evaluate returns a non-Serializable value, then frame.evaluate resolves to undefined.
     * @param fn Function to be evaluated in browser context
     * @param args Arguments to pass to `fn`
     */
    evaluate(fn: EvaluateFn, ...args: Array<mixed>): Promise<mixed>,

    /**
     * Sets the page content.
     * @param html HTML markup to assign to the page.
     */
    setContent(html: string): Promise<void>,

    /** Returns page's title. */
    title(): Promise<string>,

    /** Returns frame's url. */
    url(): string,

    waitFor(
      // fn can be an abritary function
      // eslint-disable-next-line flowtype/no-weak-types
      selectorOrFunctionOrTimeout: string | number | Function,
      options?: mixed,
      ...args: Array<mixed>
    ): Promise<mixed>,

    waitForFunction(
      // fn can be an abritary function
      // eslint-disable-next-line flowtype/no-weak-types
      fn: string | Function,
      options?: PageFnOptions,
      ...args: Array<mixed>
    ): Promise<mixed>,

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

  declare type Frame = FrameBase & {
    childFrames(): Array<Frame>,

    /** Execution context associated with this frame. */
    executionContext(): ExecutionContext,

    /** Returns `true` if the frame has been detached, or `false` otherwise. */
    isDetached(): boolean,

    /** Returns frame's name attribute as specified in the tag. */
    name(): string,

    /** Returns parent frame, if any. Detached frames and main frames return null. */
    parentFrame(): ?Frame,
  };

  declare type PageEventObj = {
    /**
     * Emitted when JavaScript within the page calls one of console API methods, e.g. console.log or console.dir.
     * Also emitted if the page throws an error or a warning.
     */
    console: ConsoleMessage,

    /**
     * Emitted when a JavaScript dialog appears, such as alert, prompt, confirm or beforeunload.
     * Puppeteer can respond to the dialog via Dialog's accept or dismiss methods.
     */
    dialog: Dialog,

    /** Emitted when the page crashes. */
    error: Error,

    /** Emitted when a frame is attached. */
    frameattached: Frame,

    /** Emitted when a frame is detached. */
    framedetached: Frame,

    /** Emitted when a frame is navigated to a new url. */
    framenavigated: Frame,

    /** Emitted when the JavaScript load event is dispatched. */
    load: void,

    /**
     * Emitted when the JavaScript code makes a call to `console.timeStamp`.
     * For the list of metrics see `page.metrics`.
     */
    metrics: {metrics: mixed, title: string},

    /** Emitted when an uncaught exception happens within the page. */
    pageerror: string,

    /**
     * Emitted when a page issues a request. The request object is read-only.
     * In order to intercept and mutate requests, see page.setRequestInterceptionEnabled.
     */
    request: Request,

    /** Emitted when a request fails, for example by timing out. */
    requestfailed: Request,

    /** Emitted when a request finishes successfully. */
    requestfinished: Request,

    /** Emitted when a response is received. */
    response: Response,
  };

  /** Page provides methods to interact with a single tab in Chromium. One Browser instance might have multiple Page instances. */
  declare interface Page extends OverridableEventEmitter, FrameBase {
    /**
     * Provide credentials for http authentication.
     * To disable authentication, pass `null`.
     */
    authenticate(credentials: AuthOptions | null): Promise<void>;

    /** Brings page to front (activates tab). */
    bringToFront(): Promise<void>;

    /**
     * This method fetches an element with selector, scrolls it into view if needed, and
     * then uses `page.mouse` to click in the center of the element. If there's no element
     * matching selector, the method throws an error.
     * @param selector A selector to search for element to click. If there are multiple elements satisfying the selector, the first will be clicked.
     * @param options Specifies the click options.
     */
    click(selector: string, options?: ClickOptions): Promise<void>;

    /** Closes the current page. */
    close(): Promise<void>;

    /**
     * Gets the cookies.
     * If no URLs are specified, this method returns cookies for the current page URL.
     * If URLs are specified, only cookies for those URLs are returned.
     */
    cookies(...urls: Array<string>): Promise<Array<Cookie>>;

    coverage: Coverage;

    /**
     * Deletes the specified cookies.
     */
    deleteCookie(...cookies: Array<DeleteCookie>): Promise<void>;

    /** Emulates given device metrics and user agent. This method is a shortcut for `setUserAgent` and `setViewport`.  */
    emulate(options: $Shape<EmulateOptions>): Promise<void>;

    /** Emulates the media. */
    emulateMedia(mediaType: 'screen' | 'print' | null): Promise<void>;

    /**
     * Evaluates a function in the page context.
     * If the function, passed to the page.evaluateHandle, returns a Promise, then page.evaluateHandle
     * would wait for the promise to resolve and return its value.
     * @param fn The function to be evaluated in the page context.
     * @param args The arguments to pass to the `fn`.
     * @returns A promise which resolves to return value of `fn`.
     */
    evaluateHandle(fn: EvaluateFn, ...args: Array<mixed>): Promise<JSHandle>;

    /**
     * Adds a function which would be invoked in one of the following scenarios: whenever the page is navigated; whenever the child frame is attached or navigated.
     * The function is invoked after the document was created but before any of its scripts were run. This is useful to amend JavaScript environment, e.g. to seed Math.random.
     * @param fn The function to be evaluated in browser context.
     * @param args The arguments to pass to the `fn`.
     */
    evaluateOnNewDocument(fn: EvaluateFn, ...args: Array<mixed>): Promise<void>;

    /**
     * The method adds a function called name on the page's `window` object.
     * When called, the function executes `puppeteerFunction` in node.js and returns a
     * Promise which resolves to the return value of `puppeteerFunction`.
     * @param name The name of the function on the window object.
     * @param fn Callback function which will be called in Puppeteer's context.
     */
    exposeFunction(
      name: string,
      puppeteerFunction: (...args: Array<mixed>) => mixed
    ): Promise<void>;

    /** This method fetches an element with selector and focuses it. */
    focus(selector: string): Promise<void>;

    /** An array of all frames attached to the page. */
    frames(): Array<Frame>;

    /**
     * Navigate to the previous page in history.
     * @param options The navigation parameters.
     */
    goBack(options?: $Shape<NavigationOptions>): Promise<Response | null>;

    /**
     * Navigate to the next page in history.
     * @param options The navigation parameters.
     */
    goForward(options?: $Shape<NavigationOptions>): Promise<Response | null>;

    /**
     * Navigates to a URL.
     * @param url URL to navigate page to. The url should include scheme, e.g. `https://`
     * @param options The navigation parameters.
     */
    goto(
      url: string,
      options?: $Shape<NavigationOptions>
    ): Promise<Response | null>;

    /**
     * This method fetches an element with `selector`, scrolls it into view if needed,
     * and then uses page.mouse to hover over the center of the element. If there's no
     * element matching `selector`, the method throws an error.
     * @param selector A selector to search for element to hover. If there are multiple elements satisfying the selector, the first will be hovered.
     */
    hover(selector: string): Promise<void>;

    /** Returns the virtual keyboard. */
    keyboard: Keyboard;

    /** Page is guaranteed to have a main frame which persists during navigation's. */
    mainFrame(): Frame;

    /** Gets the page metrics. */
    metrics(): Promise<Metrics>;

    /** Gets the virtual mouse. */
    mouse: Mouse;

    /**
     * Adds the listener function to the end of the listeners array for the event named `eventName`.
     * No checks are made to see if the listener has already been added. Multiple calls passing the same combination of
     * `eventName` and listener will result in the listener being added, and called, multiple times.
     * @param event The name of the event.
     * @param handler The callback function.
     */
    on<K: PageEvents>(
      eventName: K,
      handler: (e: $ElementType<PageEventObj, K>, ...args: Array<mixed>) => void
    ): Page;

    /**
     * Adds a one time listener function for the event named `eventName`.
     * The next time `eventName` is triggered, this listener is removed and then invoked.
     * @param event The name of the event.
     * @param handler The callback function.
     */
    once<K: PageEvents>(
      eventName: K,
      handler: (e: $ElementType<PageEventObj, K>, ...args: Array<mixed>) => void
    ): Page;

    /**
     * Generates a PDF of the page with `print` css media.
     * To generate a pdf with `screen` media, call `page.emulateMedia('screen')` before calling `page.pdf()`:
     * @param options The PDF parameters.
     */
    pdf(options?: $Shape<PDFOptions>): Promise<Buffer>;

    /**
     * The method iterates JavaScript heap and finds all the objects with the given prototype.
     * @param prototypeHandle A handle to the object prototype.
     */
    queryObjects(prototypeHandle: JSHandle): Promise<JSHandle>;

    /**
     * Reloads the current page.
     * @param options The navigation parameters.
     */
    reload(options?: NavigationOptions): Promise<Response>;

    /**
     * Captures a screenshot of the page.
     * @param options The screenshot options.
     */
    screenshot(options?: ScreenshotOptions): Promise<Buffer>;

    /**
     * Triggers a `change` and `input` event once all the provided options have been selected.
     * If there's no `<select>` element matching selector, the method throws an error.
     * @param selector A selector to query page for.
     * @param values Values of options to select. If the `<select>` has the `multiple` attribute,
     * all values are considered, otherwise only the first one is taken into account.
     */
    select(selector: string, ...values: Array<string>): Promise<Array<string>>;

    /**
     * Determines whether cache is enabled on the page.
     * @param enabled Whether or not to enable cache on the page.
     */
    setCacheEnabled(enabled: boolean): Promise<void>;

    /**
     * Sets the cookies on the page.
     * @param cookies The cookies to set.
     */
    setCookie(...cookies: Array<SetCookie>): Promise<void>;

    /**
     * This setting will change the default maximum navigation time of 30 seconds for the following methods:
     * - `page.goto`
     * - `page.goBack`
     * - `page.goForward`
     * - `page.reload`
     * - `page.waitForNavigation`
     */
    setDefaultNavigationTimeout(timeout: number): void;

    /**
     * The extra HTTP headers will be sent with every request the page initiates.
     * @param headers An object containing additional http headers to be sent with every request. All header values must be strings.
     */
    setExtraHTTPHeaders(headers: Headers): Promise<void>;

    /**
     * Determines whether JavaScript is enabled on the page.
     * @param enable Whether or not to enable JavaScript on the page.
     */
    setJavaScriptEnabled(enabled: boolean): Promise<void>;

    /**
     * Determines whether the offline mode is enabled.
     * @param enabled When `true`, enables the offline mode for the page.
     */
    setOfflineMode(enabled: boolean): Promise<void>;

    /**
     * Determines whether the request interception is enabled.
     * @param enabled When `true` the methods `request.abort`, `request.continue` and `request.respond` must be used.
     */
    setRequestInterception(enabled: boolean): Promise<void>;

    /**
     * Specifies the User-Agent used in this page.
     * @param userAgent The user-agent to be used in the page.
     */
    setUserAgent(userAgent: string): Promise<void>;

    /**
     * Sets the viewport of the page.
     * @param viewport The viewport parameters.
     */
    setViewport(viewport: Viewport): Promise<void>;

    /**
     * This method fetches an element with `selector`, scrolls it into view if needed,
     * and then uses page.touchscreen to tap in the center of the element.
     * @param selector A `selector` to search for element to tap. If there are multiple elements
     * satisfying the selector, the first will be tapped.
     */
    tap(selector: string): Promise<void>;

    /** @returns The target this page was created from */
    target(): Target;

    /** Returns the page's title. */
    title(): Promise<string>;

    /** Returns the virtual touchscreen object. */
    touchscreen: Touchscreen;

    /** Returns the tracing object. */
    tracing: Tracing;

    /**
     * Sends a `keydown`, `keypress/input`, and `keyup` event for each character in the text.
     * @param selector A selector of an element to type into. If there are multiple elements satisfying the selector, the first will be used.
     * @param text: A text to type into a focused element.
     * @param options: The typing parameters.
     */
    type(
      selector: string,
      text: string,
      options?: {delay: number}
    ): Promise<void>;

    /**
     * The page's URL. This is a shortcut for `page.mainFrame().url()`
     */
    url(): string;

    /** Gets the page viewport. */
    viewport(): Viewport;

    /**
     * Wait for the page navigation occur.
     * @param options The navigation parameters.
     */
    waitForNavigation(options?: NavigationOptions): Promise<Response>;
  }

  /** A Browser is created when Puppeteer connects to a Chromium instance, either through puppeteer.launch or puppeteer.connect. */
  declare interface Browser extends OverridableEventEmitter {
    /**
     * Closes browser with all the pages (if any were opened).
     * The browser object itself is considered to be disposed and can not be used anymore.
     */
    close(): Promise<void>;

    /**
     * Disconnects Puppeteer from the browser, but leaves the Chromium process running.
     * After calling `disconnect`, the browser object is considered disposed and cannot be used anymore.
     */
    disconnect(): void;

    /** Promise which resolves to a new Page object. */
    newPage(): Promise<Page>;

    /**
     * Adds the listener function to the end of the listeners array for the event named `eventName`.
     * No checks are made to see if the listener has already been added. Multiple calls passing the same combination of
     * `eventName` and listener will result in the listener being added, and called, multiple times.
     * @param event The name of the event.
     * @param handler The callback function.
     */
    on<K: BrowserEvents>(
      eventName: K,
      handler: (
        e: $ElementType<BrowserEventObj, K>,
        ...args: Array<mixed>
      ) => void
    ): Browser;

    /**
     * Adds a one time listener function for the event named `eventName`.
     * The next time `eventName` is triggered, this listener is removed and then invoked.
     * @param event The name of the event.
     * @param handler The callback function.
     */
    once<K: BrowserEvents>(
      eventName: K,
      handler: (
        e: $ElementType<BrowserEventObj, K>,
        ...args: Array<mixed>
      ) => void
    ): Browser;

    /** Promise which resolves to an array of all open pages. */
    pages(): Promise<Array<Page>>;

    /** Spawned browser process. Returns `null` if the browser instance was created with `puppeteer.connect` method */
    process(): ChildProcess;

    /** Promise which resolves to an array of all active targets. */
    targets(): Promise<Array<Target>>;

    /**
     * Promise which resolves to the browser's original user agent.
     * **NOTE** Pages can override browser user agent with `page.setUserAgent`.
     */
    userAgent(): Promise<string>;

    /** For headless Chromium, this is similar to HeadlessChrome/61.0.3153.0. For non-headless, this is similar to Chrome/61.0.3153.0. */
    version(): Promise<string>;

    /** Browser websocket endpoint which can be used as an argument to puppeteer.connect. The format is ws://${host}:${port}/devtools/browser/<id> */
    wsEndpoint(): string;
  }

  declare type BrowserEventObj = {
    /** Emitted when puppeteer gets disconnected from the browser instance. */
    disconnected: void,

    /** Emitted when the url of a target changes. */
    targetchanged: Target,

    /** Emitted when a target is created, for example when a new page is opened by `window.open` or `browser.newPage`. */
    targetcreated: Target,

    /** Emitted when a target is destroyed, for example when a page is closed. */
    targetdestroyed: Target,
  };

  declare type Target = {
    /** Creates a Chrome Devtools Protocol session attached to the target. */
    createCDPSession(): Promise<CDPSession>,

    /** Returns the target `Page` or a `null` if the type of the page is not "page". */
    page(): Promise<Page>,

    /** Identifies what kind of target this is.  */
    type(): 'page' | 'service_worker' | 'other',

    /** Returns the target URL. */
    url(): string,
  };

  declare type LaunchOptions = {
    /** Whether to open chrome in appMode. Defaults to false. */
    appMode?: boolean,

    /**
     * Additional arguments to pass to the Chromium instance. List of Chromium
     * flags can be found here.
     */
    args?: Array<string>,

    /** Whether to auto-open DevTools panel for each tab. If this option is true, the headless option will be set false. */
    devtools?: boolean,

    /**
     * Whether to pipe browser process stdout and stderr into process.stdout and
     * process.stderr. Defaults to false.
     */
    dumpio?: boolean,

    /** Specify environment variables that will be visible to Chromium. Defaults to process.env. */
    env?: mixed,

    /**
     * Path to a Chromium executable to run instead of bundled Chromium. If
     * executablePath is a relative path, then it is resolved relative to current
     * working directory.
     */
    executablePath?: string,

    /** Close chrome process on SIGHUP. Defaults to true. */
    handleSIGHUP?: boolean,

    /** Close chrome process on Ctrl-C. Defaults to true. */
    handleSIGINT?: boolean,

    /** Close chrome process on SIGTERM. Defaults to true. */
    handleSIGTERM?: boolean,

    /** Whether to run Chromium in headless mode. Defaults to true. */
    headless?: boolean,

    /** Do not use `puppeteer.defaultArgs()` for launching Chromium. Defaults to false. */
    ignoreDefaultArgs?: boolean,

    /** Whether to ignore HTTPS errors during navigation. Defaults to false. */
    ignoreHTTPSErrors?: boolean,

    /**
     * Slows down Puppeteer operations by the specified amount of milliseconds.
     * Useful so that you can see what is going on.
     */
    slowMo?: number,

    /**
     * Maximum time in milliseconds to wait for the Chrome instance to start.
     * Defaults to 30000 (30 seconds). Pass 0 to disable timeout.
     */
    timeout?: number,

    /** Path to a User Data Directory. */
    userDataDir?: string,
  };

  declare type ConnectOptions = {
    /** A browser websocket endpoint to connect to. */
    browserWSEndpoint?: string,

    /**
     * Whether to ignore HTTPS errors during navigation.
     * @default false
     */
    ignoreHTTPSErrors?: boolean,
  };

  declare interface CDPSession extends events$EventEmitter {
    /**
     * Detaches session from target. Once detached, session won't emit any events and can't be used
     * to send messages.
     */
    detach(): Promise<void>;

    /**
     * @param method Protocol method name
     */
    // eslint-disable-next-line flowtype/no-weak-types
    send(method: string, params?: Object): Promise<mixed>;
  }

  declare type Coverage = {
    startCSSCoverage(options?: StartCoverageOptions): Promise<void>,
    startJSCoverage(options?: StartCoverageOptions): Promise<void>,
    stopCSSCoverage(): Promise<Array<CoverageEntry>>,
    stopJSCoverage(): Promise<Array<CoverageEntry>>,
  };

  declare type StartCoverageOptions = {
    /** Whether to reset coverage on every navigation. Defaults to `true`. */
    resetOnNavigation?: boolean,
  };

  declare type CoverageEntry = {
    ranges: Array<{end: number, start: number}>,
    text: string,
    url: string,
  };

  /** Attaches Puppeteer to an existing Chromium instance */
  declare function connect(options?: ConnectOptions): Promise<Browser>;
  /** The default flags that Chromium will be launched with */
  declare function defaultArgs(): Array<string>;
  /** Path where Puppeteer expects to find bundled Chromium */
  declare function executablePath(): string;
  /** The method launches a browser instance with given arguments. The browser will be closed when the parent node.js process is closed. */
  declare function launch(options?: LaunchOptions): Promise<Browser>;
}
