import type { CaptchaType, CountryCode, LiveURLStreamType, MediaType, Method, OperatorType, PDFPageFormat, ProxyNetwork, ResourceType, ScreenshotType, WaitForFunctionPolling, WaitUntilGoto, WaitUntilHistory } from './enums.js';
import type { CleanInput, CookieInput, HTMLRewriteInput, HeaderInput, ScreenshotClip } from './inputs.js';
import type { TransportFactory } from '../transport.js';
export interface AuthenticateOptions {
    /**
     * The origin of the requests needing authentication, specified as a full
     * HTTP origin in `protocol://host(:port)` format (e.g.
     * `https://example.com`). If not provided, every request needing
     * authentication will use the provided credentials.
     */
    origin?: string;
}
export interface NavigationOptions {
    /** The maximum amount of time, in milliseconds, to wait for the page to load, overriding any defaults. Default timeout is 30 seconds, or 30000. */
    timeout?: number;
    /**
     * When to consider the page fully-loaded and proceed with further execution
     *
     * @default load
     */
    waitUntil?: WaitUntilHistory;
}
export interface CheckboxOptions {
    /**
     * Whether or not to scroll to the element prior to clicking, defaults to true
     *
     * @default true
     */
    scroll?: boolean;
    /** How long to wait for the element to appear before timing out on the handler, overriding any defaults. Default timeout is 30 seconds, or 30000. */
    timeout?: number;
    /**
     * Whether or not to check/uncheck the element only if it's visible
     *
     * @default false
     */
    visible?: boolean;
    /**
     * Whether or not to wait for the element to present in the DOM
     *
     * @default true
     */
    wait?: boolean;
}
export interface ClickOptions {
    /**
     * Whether or not to scroll to the element prior to clicking, defaults to true
     *
     * @default true
     */
    scroll?: boolean;
    /** How long to wait for the element to appear before timing out on the click handler, overriding any defaults. Default timeout is 30 seconds, or 30000. */
    timeout?: number;
    /**
     * Whether or not to click the element only if it's visible
     *
     * @default false
     */
    visible?: boolean;
    /**
     * Whether or not to wait for the element to present in the DOM
     *
     * @default true
     */
    wait?: boolean;
}
export interface SetContentOptions {
    /** The maximum amount of time, in milliseconds, to wait for the content to load, overriding any defaults. Default timeout is 30 seconds, or 30000. */
    timeout?: number;
    /** When to consider the page fully-loaded and proceed with further execution, used in conjunction with the value parameter */
    waitUntil?: WaitUntilHistory;
    /** Wait for every listed lifecycle event. Use this instead of waitUntil when preserving an ordered REST array contract. */
    waitUntilAll?: WaitUntilHistory[];
}
export interface SetCookieOptions {
    /** The cookies to set on the page */
    cookies?: CookieInput[];
}
export interface EvaluateOptions {
    /** A timeout to wait for the script to finish evaluating, overriding any defaults. Useful for async scripts that may be longer running. Default timeout is 30 seconds, or 30000. */
    timeout?: number;
    /**
     * The URL of the script you'd like to evaluate. This code gets wrapped in an async function so you can use `return` at the end as well as `await` and other async
     * concepts. You can return any stringified value from this function
     */
    url?: string;
}
export interface GotoOptions {
    /** The maximum amount of time, in milliseconds, to wait for the page to load, overriding any defaults. Default timeout is 30 seconds, or 30000. */
    timeout?: number;
    /**
     * When to consider the page fully-loaded and proceed with further execution
     *
     * @default load
     */
    waitUntil?: WaitUntilGoto;
    /** Wait for every listed lifecycle event. This preserves Puppeteer waitUntil array semantics. */
    waitUntilAll?: WaitUntilGoto[];
    /** The Referer header to send with the navigation request */
    referer?: string;
    /** The referrer policy to use for the navigation request */
    referrerPolicy?: string;
    /** Request remote IP/port fields. Enable only when the target BQL schema supports them. */
    remoteResponseMetadata?: boolean;
}
export interface HTMLOptions {
    /** The DOM selector of the given element you want to return the HTML of */
    selector?: string;
    /** The maximum amount of time, in milliseconds, to wait for the selector to appear, overriding any defaults. Default timeout is 30 seconds, or 30000. */
    timeout?: number;
    /**
     * Whether or not to return the HTML content of the element only if it's visible
     *
     * @default false
     */
    visible?: boolean;
    /** Specifies conditions for "cleaning" HTML, useful for minimizing the amount of markup returned for cases like LLMs and more. See nested options for parameters. */
    clean?: CleanInput;
    /** Rewrites captured resource URLs to archive-relative paths before returning HTML. */
    rewrite?: HTMLRewriteInput;
}
export interface SetExtraHTTPHeadersOptions {
    /** The HTTP headers to set on the page */
    headers?: HeaderInput[];
}
export interface HoverOptions {
    /**
     * Whether or not to scroll to the element, defaults to true
     *
     * @default true
     */
    scroll?: boolean;
    /** How long to wait for the element to appear before timing out, overriding any defaults. Default timeout is 30 seconds, or 30000. */
    timeout?: number;
    /**
     * Whether or not to hover on the element only if it's visible
     *
     * @default false
     */
    visible?: boolean;
    /**
     * Whether or not to wait for the element to present in the DOM
     *
     * @default true
     */
    wait?: boolean;
    /** The X coordinate, in pixels, to hover on the page */
    x?: number;
    /** The Y coordinate, in pixels, to hover on the page */
    y?: number;
}
export interface JavaScriptEnabledOptions {
    /** Whether or not to enable JavaScript on the page */
    enabled?: boolean;
}
export interface LiveURLOptions {
    /** The maximum time allowed for the browser to remain alive. Once the time is reached, the end-user will receive a prompt that the session has closed */
    timeout?: number;
    /**
     * Whether the session is interactable or not. Set to "false" to not allow click and mouse events to be forwarded through to the end-user
     *
     * @default true
     */
    interactable?: boolean;
    /**
     * The binary-type of the streamed imaged. "jpeg" will consumer lower bandwidth and useful low bandwidth networks and devices. "png" is a much higher quality but will consume considerably more bandwidth.
     *
     * Use "jpeg" when setting a custom quality
     *
     * @default jpeg
     */
    type?: LiveURLStreamType;
    /**
     * The quality of the stream, represented as number from 1 - 100. Only used when "type" is "jpeg". Default is 70.
     *
     * @default 70
     */
    quality?: number;
    /**
     * Whether or not to resize the underlying browser to match the end-user's screen size. When `false` the underlying browser will retain it's current viewport, and the end users's screen wil maintain the appropriate aspect ratio.
     *
     * @default true
     */
    resizable?: boolean;
    /**
     * Whether to show the browser interface and tabs in the live URL. When `false` (default), only the browser content is shown. When `true`, navigation bar and tabs are displayed.
     *
     * @default false
     */
    showBrowserInterface?: boolean;
    /**
     * Whether to compress each frame of the streamed image data. When `true` (default), frames are compressed to reduce bandwidth usage. Set to `false` to disable compression for lower latency at the cost of increased bandwidth usage.
     *
     * @default true
     */
    compressed?: boolean;
    /**
     * Whether to emulate HTML components such as `<select>` dropdowns and the virtual keyboard. Setting this to `false` will force the virtual keyboard to not appear on the end-user's screen when interacting with input fields. Defaults to `true`.
     *
     * @default true
     */
    emulateComponents?: boolean;
}
export interface MapSelectorOptions {
    /** How long to wait for the element to appear before timing out, overriding any defaults. Default timeout is 30 seconds, or 30000. */
    timeout?: number;
    /**
     * Whether or not to wait for the selectors to present in the DOM
     *
     * @default true
     */
    wait?: boolean;
}
export interface PDFOptions {
    /** Display header and footer. Defaults to false */
    displayHeaderFooter?: boolean;
    /** The page format to use for the PDF */
    format?: PDFPageFormat;
    /** HTML template for the print footer. Should use the same format as the `headerTemplate`. */
    footerTemplate?: string;
    /** Whether or not to embed the document outline into the PDF */
    generateDocumentOutline?: boolean;
    /** Whether or not to generate tagged (accessible) PDF. Defaults to embedded choice */
    generateTaggedPDF?: boolean;
    /** Paper orientation. Defaults to false */
    landscape?: boolean;
    /** Print background graphics. Defaults to false */
    printBackground?: boolean;
    /** Hides the default white background and allows the PDF to preserve transparency. Defaults to false. */
    omitBackground?: boolean;
    /** Scale of the webpage rendering. Defaults to 1 */
    scale?: number;
    /** The maximum amount of time, in milliseconds, to wait for the PDF to be generated. Default timeout is 30 seconds, or 30000. */
    timeout?: number;
    /**
     * When true, waits for all images on the page to load before generating the PDF.
     * Default: False
     */
    waitForImages?: boolean;
    /**
     * When true, waits for document fonts to finish loading before generating the PDF.
     * Default: False
     */
    waitForFonts?: boolean;
    /**
     * When true, sizes the PDF page height to the full scroll height of the
     * document so the entire page renders on a single page. Mutually exclusive
     * with "format" and "height". Default: False
     */
    fullPage?: boolean;
    /** Width in inches or CSS unit. Defaults to 8.5 inches */
    width?: number | string;
    /**
     * 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
     *
     * For example, `<span class=title></span>` would generate span containing the title
     */
    headerTemplate?: string;
    /** Height in inches or CSS unit. Defaults to 11 inches */
    height?: number | string;
    /** Bottom margin in inches or CSS unit. Defaults to 1cm (~0.4 inches). */
    marginBottom?: number | string;
    /** Left margin in inches or CSS unit. Defaults to 1cm (~0.4 inches). */
    marginLeft?: number | string;
    /** Right margin in inches or CSS unit. Defaults to 1cm (~0.4 inches). */
    marginRight?: number | string;
    /** Top margin in inches or CSS unit. Defaults to 1cm (~0.4 inches). */
    marginTop?: number | string;
    /**
     * Paper ranges to print, one based, e.g., '1-5, 8, 11-13'. Pages are
     * printed in the document order, not in the order specified, and no
     * more than once. Defaults to empty string, which implies the entire document is printed.
     * The page numbers are quietly capped to actual page count of the
     * document, and ranges beyond the end of the document are ignored.
     * If this results in no pages to print, an error is reported.
     * It is an error to specify a range with start greater than end
     */
    pageRanges?: string;
    /**
     * Whether or not to prefer page size as defined by css. Defaults to false,
     * in which case the content will be scaled to fit the paper size
     */
    preferCSSPageSize?: boolean;
    /** Return as stream (PrintToPDFRequestTransferMode enum) */
    transferMode?: string;
    path?: string;
}
export interface PreferencesOptions {
    /**
     * Sets a default timeout for all methods, including 'goto', 'type', 'wait', etc. Default timeout is 30 seconds, or 30000.
     *
     * @default 30000
     */
    timeout?: number;
}
export interface ProxyOptions {
    /**
     * The Browserless proxy network to route matching requests through: `residential` (default) or `datacenter`. Only valid for the browserless.io proxy network (not with `server`).
     *
     * @default residential
     */
    network?: ProxyNetwork;
    /** The country you wish to proxy through. Only allowed when using the browserless.io proxy and no `server` argument. */
    country?: CountryCode;
    /** The city you wish to proxy through. Any spaces should be removed and all casing lowercase. For instance, "New York City" should be "newyorkcity" */
    city?: string;
    /** The state or provence you wish to proxy through. Any spaces should be removed and all casing lowercase. For instance, "Rhode Island" would be "rhodeisland" and "New Brunswick" would be "newbrunswick" */
    state?: string;
    /** Whether or not you want the same IP to be used for subsequent requests matching the pattern */
    sticky?: boolean;
    /** A preset code for website-specific proxy configurations. Use this with known presets like "px_gov01" for government websites. Only applies to the `residential` network; the `datacenter` pool ignores it */
    preset?: string;
    /** An external proxy to use for these requests matching the specified patterns set in the other arguments. When this is set then `country`, `city`, `state` and `sticky` options will throw errors as these are only valid for the browserless.io proxy network */
    server?: string;
    /** The Method(s) of the request you'd like to proxy */
    method?: Method[];
    /**
     * Whether to "or" conditions together, meaning any condition that matches will be proxied, or "and" them together meaning every condition must match to proxy the request.
     *
     * @default or
     */
    operator?: OperatorType;
    /** The content-type of the request you'd like to proxy requests to */
    type?: ResourceType[];
    /** A glob-style URL pattern to match requests, and if matched, are proxied through */
    url?: string[];
}
export interface QuerySelectorOptions {
    timeout?: number;
    /**
     * @default false
     */
    visible?: boolean;
}
export interface ReconnectOptions {
    /**
     * The amount of time, in milliseconds, to leave the browser open without a connection before it is manually terminated. Defaults to 30 seconds
     *
     * @default 30000
     */
    timeout?: number;
}
export interface RejectOptions {
    /**
     * Whether or not to enable request rejections
     *
     * @default true
     */
    enabled?: boolean;
    /** The Method of the request you'd like to reject */
    method?: Method[];
    /**
     * Whether to "or" conditions together, meaning any condition that matches will be rejected, or "and" them together meaning every condition must match to reject the request.
     *
     * @default or
     */
    operator?: OperatorType;
    /** The type of resource you'd like to reject request to */
    type?: ResourceType[];
    /** The glob-style URL pattern you'd like to reject requests to */
    url?: string[];
    /** The JavaScript regular-expression pattern(s) you'd like to reject requests by URL */
    regex?: string[];
}
export interface RequestFilterOptions {
    /** The type content-type of the request to match against */
    type?: ResourceType[];
    /** The method of the request to return results for */
    method?: Method[];
    /** How long to wait for the request(s) to be made before timing out, overriding any defaults. Default timeout is 30 seconds, or 30000. "wait" parameter must also be "true". */
    timeout?: number;
    /** The pattern of the request URL to wait for, using glob-style pattern-matching */
    url?: string[];
    /**
     * Whether or not to wait for the request to be made. When set to `true`, generally only one request is returned since this API will wait for the first request that matches any patterns to be returned
     *
     * @default true
     */
    wait?: boolean;
    /**
     * When applying arguments like URL or method, this operator will either "and" them together, or "or" them together. Default is "or"
     *
     * @default or
     */
    operator?: OperatorType;
}
export interface ResponseFilterOptions {
    /** The status codes response to return results for */
    status?: number[];
    /** The method of the response to return results for */
    method?: Method[];
    /**
     * When applying arguments like URL or method, this operator will either "and" them together, or "or" them together. Default is "or"
     *
     * @default or
     */
    operator?: OperatorType;
    /** How long to wait for the response(s) to be made before timing out, overriding any defaults. Default timeout is 30 seconds, or 30000. "wait" parameter must also be "true". */
    timeout?: number;
    /** The type content-type of the response to match against */
    type?: ResourceType[];
    /** The pattern of the response URL to wait for, using glob-style pattern-matching */
    url?: string[];
    /**
     * Whether or not to wait for the response to be received. When set to `true`, generally only one response is returned since this API will wait for the first response that matches any patterns to be returned
     *
     * @default true
     */
    wait?: boolean;
    /** Request the `base64Encoded` body flag. Enable only when the target BQL schema supports it. */
    bodyEncoding?: boolean;
}
export interface ScreenshotOptions {
    /**
     * Capture the screenshot beyond the viewport.
     * Default: False if there is no clip. True otherwise
     */
    captureBeyondViewport?: boolean;
    /** Specifies the region of the page/element to clip */
    clip?: ScreenshotClip;
    /**
     * Capture the screenshot from the surface, rather than the view.
     * Default: True
     */
    fromSurface?: boolean;
    /**
     * When True, takes a screenshot of the full page.
     * Default: False
     */
    fullPage?: boolean;
    /**
     * Hides default white background and allows capturing screenshots with transparency.
     * Default: False
     */
    omitBackground?: boolean;
    /**
     * Optimize image encoding for speed, not for resulting size.
     * Default: False
     */
    optimizeForSpeed?: boolean;
    /** Quality of the image, between 0-100. Not applicable to png images. */
    quality?: number;
    /** The CSS selector of the element on the page you want to screenshot */
    selector?: string;
    /** The final format of the screenshot */
    type?: ScreenshotType;
    /** The maximum amount of time, in milliseconds, to wait for the screenshot to be taken. Default timeout is 30 seconds, or 30000. */
    timeout?: number;
    /**
     * When true, waits for all images on the page to load before taking the screenshot.
     * Default: False
     */
    waitForImages?: boolean;
    path?: string;
}
export interface ScrollOptions {
    /** The DOM selector of the element on the page you want to scroll to */
    selector?: string;
    /**
     * Scrolls through the entire document in viewport-sized steps to trigger
     * lazy-loaded content, then returns to the top. Cannot be combined with
     * selector, x, or y.
     *
     * @default false
     */
    throughPage?: boolean;
    /** How long to wait for the element to appear before timing out, overriding any defaults. Default timeout is 30 seconds, or 30000. */
    timeout?: number;
    /**
     * Whether or not to scroll to the element only if it's visible
     *
     * @default false
     */
    visible?: boolean;
    /**
     * Whether or not to wait for the element, then scroll to it
     *
     * @default true
     */
    wait?: boolean;
    /** The X coordinate, in pixels, to scroll to */
    x?: number;
    /** The Y coordinate, in pixels, to scroll to */
    y?: number;
}
export interface SelectOptions {
    /** How long to wait for the element to appear before timing out on the handler, overriding any defaults. Default timeout is 30 seconds, or 30000. */
    timeout?: number;
    /**
     * Whether or not to scroll to the select element prior to selecting, defaults to true
     *
     * @default true
     */
    scroll?: boolean;
    /**
     * Whether or not to select the element only if it's visible
     *
     * @default false
     */
    visible?: boolean;
    /**
     * Whether or not to wait for the select to present in the DOM
     *
     * @default true
     */
    wait?: boolean;
}
export interface SolveOptions {
    /** An enum of the type of captcha to look for and solve. If not provided, auto-detection will be used. */
    type?: CaptchaType;
    /**
     * A time, in milliseconds, to wait for a captcha to appear. Only valid when wait = true.
     * If a captcha is found then this timer doesn't have an effect on timing-out the solve
     * Default timeout is 30 seconds, or 30000.
     */
    timeout?: number;
    /**
     * Whether or not to wait for the Captcha to be present on the page
     *
     * @default true
     */
    wait?: boolean;
}
export interface SolveImageCaptchaOptions {
    /** The CSS selector for the captcha image element on the page */
    captchaSelector: string;
    /** The CSS selector for the input field where the solved captcha value should be filled */
    inputSelector: string;
    /** A time, in milliseconds, to wait for the captcha to appear and be solved. Default timeout is 30 seconds, or 30000. */
    timeout?: number;
}
export interface TextOptions {
    /** The maximum amount of time, in milliseconds, to wait for the selector to appear, overriding any defaults. Default timeout is 30 seconds, or 30000. */
    timeout?: number;
    /**
     * The DOM selector of the given element you want to return the text of
     *
     * @default "html"
     */
    selector?: string;
    /**
     * Whether or not to return the text content of the element only if it's visible
     *
     * @default false
     */
    visible?: boolean;
    /** Specifies conditions for "cleaning" the returned text, useful for minimizing the amount of markup returned for cases like LLMs and more. See nested options for parameters. */
    clean?: CleanInput;
}
export interface TypeOptions {
    /**
     * The amount of delay between keystrokes in milliseconds. Values are used as a range and chosen at random
     *
     * @default [50, 200]
     */
    delay?: number[];
    /**
     * Whether or not to check if element can be interacted with by hovering over it and seeing if the element
     * is available at that x and y position
     *
     * @default true
     */
    interactable?: boolean;
    /**
     * Whether or not to scroll to the element prior to typing, defaults to true
     *
     * @default true
     */
    scroll?: boolean;
    /** How long to wait for the element to appear before timing out, overriding any defaults. Default timeout is 30 seconds, or 30000. */
    timeout?: number;
    /**
     * Whether or not to type into the element only if it's visible
     *
     * @default false
     */
    visible?: boolean;
    /**
     * Whether or not to wait for the element to present in the DOM
     *
     * @default true
     */
    wait?: boolean;
}
export interface LoadSecretOptions {
    /**
     * The CSS selector of the input to fill. If omitted, the currently focused
     * element is used.
     */
    selector?: string;
}
export interface WaitForNavigationOptions {
    /** The maximum amount of time, in milliseconds, to wait for the page to load, overriding any defaults. Default timeout is 30 seconds, or 30000. */
    timeout?: number;
    /**
     * When to consider the page fully-loaded and proceed with further execution
     *
     * @default load
     */
    waitUntil?: WaitUntilGoto;
}
export interface WaitForRequestOptions {
    /** The method of the request to wait for */
    method?: Method;
    /**
     * When applying arguments like URL or method, this operator will either "and" them together, or "or" them together. Default is "or"
     *
     * @default or
     */
    operator?: OperatorType;
    /** How long to wait for the request to be made before timing out, overriding any defaults. Default timeout is 30 seconds, or 30000. */
    timeout?: number;
    /** The pattern of the request URL to wait for, using glob-style pattern-matching */
    url?: string;
}
export interface WaitForResponseOptions {
    /**
     * The HTTP Response code(s) of the URL to wait for. Can be a single HTTP code or a list of desired codes
     *
     * @deprecated Use `statuses` field instead as it is more consistent in BrowserQL.
     */
    codes?: number[];
    /**
     * When applying arguments like URL or statuses, this operator will either "and" them together, or "or" them together. Default is "or"
     *
     * @default or
     */
    operator?: OperatorType;
    /** The HTTP Response code(s) of the URL to wait for. Can be a single HTTP code or a list of desired codes */
    statuses?: number[];
    /** The pattern of the response URL to wait for, using glob-style pattern-matching */
    url?: string;
    timeout?: number;
}
export interface WaitForNetworkIdleOptions {
    /**
     * The number of milliseconds the network must remain idle.
     *
     * @default 500
     */
    idleTime?: number;
    /**
     * The maximum number of in-flight requests allowed while considering the network idle.
     *
     * @default 0
     */
    concurrency?: number;
    /** The maximum amount of time, in milliseconds, to wait for network idle. */
    timeout?: number;
}
export interface WaitForSelectorOptions {
    /** When waiting for a selector applies a timeout to wait for in milliseconds, overriding any defaults. Default timeout is 30 seconds, or 30000. */
    timeout?: number;
    /**
     * Whether or not to consider the element as present only if it's visible
     *
     * @default false
     */
    visible?: boolean;
    /**
     * Wait for the selector to become hidden, i.e. removed from the DOM or with
     * no visible bounding box. Mutually exclusive with "visible".
     *
     * @default false
     */
    hidden?: boolean;
}
export interface WaitForFunctionOptions {
    /** The interval, in milliseconds, at which the predicate is re-evaluated. Defaults to 100ms */
    polling?: number;
    /** A browser-driven polling mode. Use this instead of polling for raf or mutation behavior. */
    pollingType?: WaitForFunctionPolling;
    /** The maximum amount of time, in milliseconds, to wait for the predicate to become truthy, overriding any defaults. Default timeout is 30 seconds, or 30000. */
    timeout?: number;
    /** Resolve after an async predicate promise settles, regardless of its return value. */
    completeOnPromiseResolution?: boolean;
}
export interface WaitForEventOptions {
    /** The maximum amount of time, in milliseconds, to wait for the event to fire, overriding any defaults. Default timeout is 30 seconds, or 30000. */
    timeout?: number;
}
export interface ViewportOptions {
    /** The width of the viewport in pixels */
    width: number;
    /** The height of the viewport in pixels */
    height: number;
    /**
     * The device scale factor, defaults to 1
     *
     * @default 1
     */
    deviceScaleFactor?: number;
    /**
     * Whether to simulate a mobile device, defaults to false
     *
     * @default false
     */
    mobile?: boolean;
    /**
     * Whether the viewport supports touch events, defaults to false
     *
     * @default false
     */
    hasTouch?: boolean;
    /**
     * Whether the viewport is in landscape orientation, defaults to false
     *
     * @default false
     */
    landscape?: boolean;
}
export interface SwitchToWindowOptions {
    /** URL pattern to match against window URLs (supports wildcards) */
    url?: string;
    /** Window title pattern to match */
    title?: string;
    /**
     * Whether to target most recently opened window
     *
     * @default false
     */
    newest?: boolean;
    /**
     * Maximum time to wait for matching window (in milliseconds)
     *
     * @default 5000
     */
    timeout?: number;
    /** When to consider the page fully-loaded and proceed with further execution */
    waitUntil?: WaitUntilGoto;
}
export interface EmulateMediaTypeOptions {
    /** The CSS media type to emulate */
    type: MediaType;
}
export interface AddScriptTagOptions {
    /** The URL of the script to add. One of "url" or "content" is required. */
    url?: string;
    /** The raw JavaScript content of the script to add. One of "url" or "content" is required. */
    content?: string;
    /** The id attribute to set on the injected script element */
    id?: string;
    /** The type attribute to set on the injected script element, eg: "module" */
    type?: string;
    /** Read JavaScript from this local file before sending the mutation. Node.js only. */
    path?: string;
}
export interface AddStyleTagOptions {
    /** The URL of the stylesheet to add. One of "url" or "content" is required. */
    url?: string;
    /** The raw CSS content of the stylesheet to add. One of "url" or "content" is required. */
    content?: string;
    /** Read CSS from this local file before sending the mutation. Node.js only. */
    path?: string;
}
export interface FulfillOptions {
    /** The glob-style URL pattern(s) to fulfill requests for */
    url?: string[];
    /** JavaScript regular-expression pattern(s) to match request URLs */
    regex?: string[];
    /** The HTTP Method(s) of the requests to fulfill */
    method?: Method[];
    /** The resource type(s) of the requests to fulfill */
    type?: ResourceType[];
    /**
     * Whether to "or" the conditions together (any match fulfills) or "and" them (all must match)
     *
     * @default or
     */
    operator?: OperatorType;
    /**
     * The HTTP status code to respond with. Defaults to 200
     *
     * @default 200
     */
    status?: number;
    /** The Content-Type header to respond with */
    contentType?: string;
    /** The response body to respond with */
    body?: string;
    /** A base64-encoded response body. Use this instead of body for binary data. */
    base64Body?: string;
    /** Additional response headers to respond with */
    headers?: HeaderInput[];
}
export interface MarkdownOptions {
    /** The DOM selector to scope the Markdown conversion to. Defaults to the whole document. */
    selector?: string;
    /** The maximum amount of time, in milliseconds, to wait for the selector to appear, overriding any defaults. Default timeout is 30 seconds, or 30000. */
    timeout?: number;
    /**
     * Whether or not to convert the element only if it's visible
     *
     * @default false
     */
    visible?: boolean;
}
export interface SendOptions {
    variables?: Record<string, unknown>;
    timeout?: number;
}
export interface ConnectOptions {
    /**
     * The BrowserQL WebSocket endpoint to connect to. Optional when a custom
     * `transport` is supplied, since the transport owns the connection.
     */
    browserWSEndpoint?: string;
    token?: string;
    timeout?: number;
    /**
     * Override the built-in WebSocket with your own transport (puppeteer-style).
     * Called once per Browser.newPage with the endpoint URL; must resolve a
     * ConnectionTransport that is already open. See {@link TransportFactory}.
     */
    transport?: TransportFactory;
}
//# sourceMappingURL=options.d.ts.map