webdriver-bidi-protocol/out/gen/main.d.ts

This repository contains TypeScript types conforming to the [WebDriver BiDi](https://w3c.github.io/webdriver-bidi/) specification. It also supports WebDriver BiDi extension modules defined in other specifications:

export type Command = {
  id: JsUint;
} & CommandData &
  Extensible;
export type CommandData =
  | BrowserCommand
  | BrowsingContextCommand
  | EmulationCommand
  | InputCommand
  | NetworkCommand
  | ScriptCommand
  | SessionCommand
  | StorageCommand
  | WebExtensionCommand;
export type EmptyParams = Extensible;
export type Message = CommandResponse | ErrorResponse | Event;
export type CommandResponse = {
  type: 'success';
  id: JsUint;
  result: ResultData;
} & Extensible;
export type ErrorResponse = {
  type: 'error';
  id: JsUint | null;
  error: ErrorCode;
  message: string;
  stacktrace?: string;
} & Extensible;
export type ResultData =
  | BrowserResult
  | BrowsingContextResult
  | EmulationResult
  | InputResult
  | NetworkResult
  | ScriptResult
  | SessionResult
  | StorageResult
  | WebExtensionResult;
export type EmptyResult = Extensible;
export type Event = {
  type: 'event';
} & EventData &
  Extensible;
export type EventData =
  | BrowsingContextEvent
  | InputEvent
  | LogEvent
  | NetworkEvent
  | ScriptEvent;
export type Extensible = {
  [key: string]: any;
};
/**
 * Must be between `-9007199254740991` and `9007199254740991`, inclusive.
 */
export type JsInt = number;
/**
 * Must be between `0` and `9007199254740991`, inclusive.
 */
export type JsUint = number;
export declare const enum ErrorCode {
  InvalidArgument = 'invalid argument',
  InvalidSelector = 'invalid selector',
  InvalidSessionId = 'invalid session id',
  InvalidWebExtension = 'invalid web extension',
  MoveTargetOutOfBounds = 'move target out of bounds',
  NoSuchAlert = 'no such alert',
  NoSuchNetworkCollector = 'no such network collector',
  NoSuchElement = 'no such element',
  NoSuchFrame = 'no such frame',
  NoSuchHandle = 'no such handle',
  NoSuchHistoryEntry = 'no such history entry',
  NoSuchIntercept = 'no such intercept',
  NoSuchNetworkData = 'no such network data',
  NoSuchNode = 'no such node',
  NoSuchRequest = 'no such request',
  NoSuchScript = 'no such script',
  NoSuchStoragePartition = 'no such storage partition',
  NoSuchUserContext = 'no such user context',
  NoSuchWebExtension = 'no such web extension',
  SessionNotCreated = 'session not created',
  UnableToCaptureScreen = 'unable to capture screen',
  UnableToCloseBrowser = 'unable to close browser',
  UnableToSetCookie = 'unable to set cookie',
  UnableToSetFileInput = 'unable to set file input',
  UnavailableNetworkData = 'unavailable network data',
  UnderspecifiedStoragePartition = 'underspecified storage partition',
  UnknownCommand = 'unknown command',
  UnknownError = 'unknown error',
  UnsupportedOperation = 'unsupported operation',
}
export type SessionCommand =
  | Session.End
  | Session.New
  | Session.Status
  | Session.Subscribe
  | Session.Unsubscribe;
export type SessionResult =
  | Session.EndResult
  | Session.NewResult
  | Session.StatusResult
  | Session.SubscribeResult
  | Session.UnsubscribeResult;
export declare namespace Session {
  type CapabilitiesRequest = {
    alwaysMatch?: Session.CapabilityRequest;
    firstMatch?: [...Session.CapabilityRequest[]];
  };
}
export declare namespace Session {
  type CapabilityRequest = {
    acceptInsecureCerts?: boolean;
    browserName?: string;
    browserVersion?: string;
    platformName?: string;
    proxy?: Session.ProxyConfiguration;
    unhandledPromptBehavior?: Session.UserPromptHandler;
  } & Extensible;
}
export declare namespace Session {
  type ProxyConfiguration =
    | Session.AutodetectProxyConfiguration
    | Session.DirectProxyConfiguration
    | Session.ManualProxyConfiguration
    | Session.PacProxyConfiguration
    | Session.SystemProxyConfiguration;
}
export declare namespace Session {
  type AutodetectProxyConfiguration = {
    proxyType: 'autodetect';
  } & Extensible;
}
export declare namespace Session {
  type DirectProxyConfiguration = {
    proxyType: 'direct';
  } & Extensible;
}
export declare namespace Session {
  type ManualProxyConfiguration = {
    proxyType: 'manual';
    httpProxy?: string;
    sslProxy?: string;
  } & ({} | Session.SocksProxyConfiguration) & {
      noProxy?: [...string[]];
    } & Extensible;
}
export declare namespace Session {
  type SocksProxyConfiguration = {
    socksProxy: string;
    /**
     * Must be between `0` and `255`, inclusive.
     */
    socksVersion: number;
  };
}
export declare namespace Session {
  type PacProxyConfiguration = {
    proxyType: 'pac';
    proxyAutoconfigUrl: string;
  } & Extensible;
}
export declare namespace Session {
  type SystemProxyConfiguration = {
    proxyType: 'system';
  } & Extensible;
}
export declare namespace Session {
  type UserPromptHandler = {
    alert?: Session.UserPromptHandlerType;
    beforeUnload?: Session.UserPromptHandlerType;
    confirm?: Session.UserPromptHandlerType;
    default?: Session.UserPromptHandlerType;
    file?: Session.UserPromptHandlerType;
    prompt?: Session.UserPromptHandlerType;
  };
}
export declare namespace Session {
  const enum UserPromptHandlerType {
    Accept = 'accept',
    Dismiss = 'dismiss',
    Ignore = 'ignore',
  }
}
export declare namespace Session {
  type Subscription = string;
}
export declare namespace Session {
  type SubscriptionRequest = {
    events: [string, ...string[]];
    contexts?: [
      BrowsingContext.BrowsingContext,
      ...BrowsingContext.BrowsingContext[],
    ];
    userContexts?: [Browser.UserContext, ...Browser.UserContext[]];
  };
}
export declare namespace Session {
  type UnsubscribeByIdRequest = {
    subscriptions: [Session.Subscription, ...Session.Subscription[]];
  };
}
export declare namespace Session {
  type UnsubscribeByAttributesRequest = {
    events: [string, ...string[]];
  };
}
export declare namespace Session {
  type Status = {
    method: 'session.status';
    params: EmptyParams;
  };
}
export declare namespace Session {
  type StatusResult = {
    ready: boolean;
    message: string;
  };
}
export declare namespace Session {
  type New = {
    method: 'session.new';
    params: Session.NewParameters;
  };
}
export declare namespace Session {
  type NewParameters = {
    capabilities: Session.CapabilitiesRequest;
  };
}
export declare namespace Session {
  type NewResult = {
    sessionId: string;
    capabilities: {
      acceptInsecureCerts: boolean;
      browserName: string;
      browserVersion: string;
      platformName: string;
      setWindowRect: boolean;
      userAgent: string;
      proxy?: Session.ProxyConfiguration;
      unhandledPromptBehavior?: Session.UserPromptHandler;
      webSocketUrl?: string;
    } & Extensible;
  };
}
export declare namespace Session {
  type End = {
    method: 'session.end';
    params: EmptyParams;
  };
}
export declare namespace Session {
  type EndResult = EmptyResult;
}
export declare namespace Session {
  type Subscribe = {
    method: 'session.subscribe';
    params: Session.SubscriptionRequest;
  };
}
export declare namespace Session {
  type SubscribeResult = {
    subscription: Session.Subscription;
  };
}
export declare namespace Session {
  type Unsubscribe = {
    method: 'session.unsubscribe';
    params: Session.UnsubscribeParameters;
  };
}
export declare namespace Session {
  type UnsubscribeParameters =
    | Session.UnsubscribeByAttributesRequest
    | Session.UnsubscribeByIdRequest;
}
export declare namespace Session {
  type UnsubscribeResult = EmptyResult;
}
export type BrowserCommand =
  | Browser.Close
  | Browser.CreateUserContext
  | Browser.GetClientWindows
  | Browser.GetUserContexts
  | Browser.RemoveUserContext
  | Browser.SetClientWindowState
  | Browser.SetDownloadBehavior;
export type BrowserResult =
  | Browser.CloseResult
  | Browser.CreateUserContextResult
  | Browser.GetClientWindowsResult
  | Browser.GetUserContextsResult
  | Browser.RemoveUserContextResult
  | Browser.SetClientWindowStateResult
  | Browser.SetDownloadBehaviorResult;
export declare namespace Browser {
  type ClientWindow = string;
}
export declare namespace Browser {
  type ClientWindowInfo = {
    active: boolean;
    clientWindow: Browser.ClientWindow;
    height: JsUint;
    state: 'fullscreen' | 'maximized' | 'minimized' | 'normal';
    width: JsUint;
    x: JsInt;
    y: JsInt;
  };
}
export declare namespace Browser {
  type UserContext = string;
}
export declare namespace Browser {
  type UserContextInfo = {
    userContext: Browser.UserContext;
  };
}
export declare namespace Browser {
  type Close = {
    method: 'browser.close';
    params: EmptyParams;
  };
}
export declare namespace Browser {
  type CloseResult = EmptyResult;
}
export declare namespace Browser {
  type CreateUserContext = {
    method: 'browser.createUserContext';
    params: Browser.CreateUserContextParameters;
  };
}
export declare namespace Browser {
  type CreateUserContextParameters = {
    acceptInsecureCerts?: boolean;
    proxy?: Session.ProxyConfiguration;
    unhandledPromptBehavior?: Session.UserPromptHandler;
  };
}
export declare namespace Browser {
  type CreateUserContextResult = Browser.UserContextInfo;
}
export declare namespace Browser {
  type GetClientWindows = {
    method: 'browser.getClientWindows';
    params: EmptyParams;
  };
}
export declare namespace Browser {
  type GetClientWindowsResult = {
    clientWindows: [...Browser.ClientWindowInfo[]];
  };
}
export declare namespace Browser {
  type GetUserContexts = {
    method: 'browser.getUserContexts';
    params: EmptyParams;
  };
}
export declare namespace Browser {
  type GetUserContextsResult = {
    userContexts: [Browser.UserContextInfo, ...Browser.UserContextInfo[]];
  };
}
export declare namespace Browser {
  type RemoveUserContext = {
    method: 'browser.removeUserContext';
    params: Browser.RemoveUserContextParameters;
  };
}
export declare namespace Browser {
  type RemoveUserContextParameters = {
    userContext: Browser.UserContext;
  };
}
export declare namespace Browser {
  type RemoveUserContextResult = EmptyResult;
}
export declare namespace Browser {
  type SetClientWindowState = {
    method: 'browser.setClientWindowState';
    params: Browser.SetClientWindowStateParameters;
  };
}
export declare namespace Browser {
  type SetClientWindowStateParameters = {
    clientWindow: Browser.ClientWindow;
  } & (Browser.ClientWindowNamedState | Browser.ClientWindowRectState);
}
export declare namespace Browser {
  type ClientWindowNamedState = {
    state: 'fullscreen' | 'maximized' | 'minimized';
  };
}
export declare namespace Browser {
  type ClientWindowRectState = {
    state: 'normal';
    width?: JsUint;
    height?: JsUint;
    x?: JsInt;
    y?: JsInt;
  };
}
export declare namespace Browser {
  type SetClientWindowStateResult = Browser.ClientWindowInfo;
}
export declare namespace Browser {
  type SetDownloadBehavior = {
    method: 'browser.setDownloadBehavior';
    params: Browser.SetDownloadBehaviorParameters;
  };
}
export declare namespace Browser {
  type SetDownloadBehaviorParameters = {
    downloadBehavior: Browser.DownloadBehavior | null;
    userContexts?: [Browser.UserContext, ...Browser.UserContext[]];
  };
}
export declare namespace Browser {
  type DownloadBehavior =
    | Browser.DownloadBehaviorAllowed
    | Browser.DownloadBehaviorDenied;
}
export declare namespace Browser {
  type DownloadBehaviorAllowed = {
    type: 'allowed';
    destinationFolder: string;
  };
}
export declare namespace Browser {
  type DownloadBehaviorDenied = {
    type: 'denied';
  };
}
export declare namespace Browser {
  type SetDownloadBehaviorResult = EmptyResult;
}
export type BrowsingContextCommand =
  | BrowsingContext.Activate
  | BrowsingContext.CaptureScreenshot
  | BrowsingContext.Close
  | BrowsingContext.Create
  | BrowsingContext.GetTree
  | BrowsingContext.HandleUserPrompt
  | BrowsingContext.LocateNodes
  | BrowsingContext.Navigate
  | BrowsingContext.Print
  | BrowsingContext.Reload
  | BrowsingContext.SetViewport
  | BrowsingContext.TraverseHistory;
export type BrowsingContextResult =
  | BrowsingContext.ActivateResult
  | BrowsingContext.CaptureScreenshotResult
  | BrowsingContext.CloseResult
  | BrowsingContext.CreateResult
  | BrowsingContext.GetTreeResult
  | BrowsingContext.HandleUserPromptResult
  | BrowsingContext.LocateNodesResult
  | BrowsingContext.NavigateResult
  | BrowsingContext.PrintResult
  | BrowsingContext.ReloadResult
  | BrowsingContext.SetViewportResult
  | BrowsingContext.TraverseHistoryResult;
export type BrowsingContextEvent =
  | BrowsingContext.ContextCreated
  | BrowsingContext.ContextDestroyed
  | BrowsingContext.DomContentLoaded
  | BrowsingContext.DownloadEnd
  | BrowsingContext.DownloadWillBegin
  | BrowsingContext.FragmentNavigated
  | BrowsingContext.HistoryUpdated
  | BrowsingContext.Load
  | BrowsingContext.NavigationAborted
  | BrowsingContext.NavigationCommitted
  | BrowsingContext.NavigationFailed
  | BrowsingContext.NavigationStarted
  | BrowsingContext.UserPromptClosed
  | BrowsingContext.UserPromptOpened;
export declare namespace BrowsingContext {
  type BrowsingContext = string;
}
export declare namespace BrowsingContext {
  type InfoList = [...BrowsingContext.Info[]];
}
export declare namespace BrowsingContext {
  type Info = {
    children: BrowsingContext.InfoList | null;
    clientWindow: Browser.ClientWindow;
    context: BrowsingContext.BrowsingContext;
    originalOpener: BrowsingContext.BrowsingContext | null;
    url: string;
    userContext: Browser.UserContext;
    parent?: BrowsingContext.BrowsingContext | null;
  };
}
export declare namespace BrowsingContext {
  type Locator =
    | BrowsingContext.AccessibilityLocator
    | BrowsingContext.CssLocator
    | BrowsingContext.ContextLocator
    | BrowsingContext.InnerTextLocator
    | BrowsingContext.XPathLocator;
}
export declare namespace BrowsingContext {
  type AccessibilityLocator = {
    type: 'accessibility';
    value: {
      name?: string;
      role?: string;
    };
  };
}
export declare namespace BrowsingContext {
  type CssLocator = {
    type: 'css';
    value: string;
  };
}
export declare namespace BrowsingContext {
  type ContextLocator = {
    type: 'context';
    value: {
      context: BrowsingContext.BrowsingContext;
    };
  };
}
export declare namespace BrowsingContext {
  type InnerTextLocator = {
    type: 'innerText';
    value: string;
    ignoreCase?: boolean;
    matchType?: 'full' | 'partial';
    maxDepth?: JsUint;
  };
}
export declare namespace BrowsingContext {
  type XPathLocator = {
    type: 'xpath';
    value: string;
  };
}
export declare namespace BrowsingContext {
  type Navigation = string;
}
export declare namespace BrowsingContext {
  type BaseNavigationInfo = {
    context: BrowsingContext.BrowsingContext;
    navigation: BrowsingContext.Navigation | null;
    timestamp: JsUint;
    url: string;
  };
}
export declare namespace BrowsingContext {
  type NavigationInfo = BrowsingContext.BaseNavigationInfo;
}
export declare namespace BrowsingContext {
  const enum ReadinessState {
    None = 'none',
    Interactive = 'interactive',
    Complete = 'complete',
  }
}
export declare namespace BrowsingContext {
  const enum UserPromptType {
    Alert = 'alert',
    Beforeunload = 'beforeunload',
    Confirm = 'confirm',
    Prompt = 'prompt',
  }
}
export declare namespace BrowsingContext {
  type Activate = {
    method: 'browsingContext.activate';
    params: BrowsingContext.ActivateParameters;
  };
}
export declare namespace BrowsingContext {
  type ActivateParameters = {
    context: BrowsingContext.BrowsingContext;
  };
}
export declare namespace BrowsingContext {
  type ActivateResult = EmptyResult;
}
export declare namespace BrowsingContext {
  type CaptureScreenshot = {
    method: 'browsingContext.captureScreenshot';
    params: BrowsingContext.CaptureScreenshotParameters;
  };
}
export declare namespace BrowsingContext {
  type CaptureScreenshotParameters = {
    context: BrowsingContext.BrowsingContext;
    /**
     * @defaultValue `"viewport"`
     */
    origin?: 'viewport' | 'document';
    format?: BrowsingContext.ImageFormat;
    clip?: BrowsingContext.ClipRectangle;
  };
}
export declare namespace BrowsingContext {
  type ImageFormat = {
    type: string;
    /**
     * Must be between `0` and `1`, inclusive.
     */
    quality?: number;
  };
}
export declare namespace BrowsingContext {
  type ClipRectangle =
    | BrowsingContext.BoxClipRectangle
    | BrowsingContext.ElementClipRectangle;
}
export declare namespace BrowsingContext {
  type ElementClipRectangle = {
    type: 'element';
    element: Script.SharedReference;
  };
}
export declare namespace BrowsingContext {
  type BoxClipRectangle = {
    type: 'box';
    x: number;
    y: number;
    width: number;
    height: number;
  };
}
export declare namespace BrowsingContext {
  type CaptureScreenshotResult = {
    data: string;
  };
}
export declare namespace BrowsingContext {
  type Close = {
    method: 'browsingContext.close';
    params: BrowsingContext.CloseParameters;
  };
}
export declare namespace BrowsingContext {
  type CloseParameters = {
    context: BrowsingContext.BrowsingContext;
    /**
     * @defaultValue `false`
     */
    promptUnload?: boolean;
  };
}
export declare namespace BrowsingContext {
  type CloseResult = EmptyResult;
}
export declare namespace BrowsingContext {
  type Create = {
    method: 'browsingContext.create';
    params: BrowsingContext.CreateParameters;
  };
}
export declare namespace BrowsingContext {
  const enum CreateType {
    Tab = 'tab',
    Window = 'window',
  }
}
export declare namespace BrowsingContext {
  type CreateParameters = {
    type: BrowsingContext.CreateType;
    referenceContext?: BrowsingContext.BrowsingContext;
    /**
     * @defaultValue `false`
     */
    background?: boolean;
    userContext?: Browser.UserContext;
  };
}
export declare namespace BrowsingContext {
  type CreateResult = {
    context: BrowsingContext.BrowsingContext;
  };
}
export declare namespace BrowsingContext {
  type GetTree = {
    method: 'browsingContext.getTree';
    params: BrowsingContext.GetTreeParameters;
  };
}
export declare namespace BrowsingContext {
  type GetTreeParameters = {
    maxDepth?: JsUint;
    root?: BrowsingContext.BrowsingContext;
  };
}
export declare namespace BrowsingContext {
  type GetTreeResult = {
    contexts: BrowsingContext.InfoList;
  };
}
export declare namespace BrowsingContext {
  type HandleUserPrompt = {
    method: 'browsingContext.handleUserPrompt';
    params: BrowsingContext.HandleUserPromptParameters;
  };
}
export declare namespace BrowsingContext {
  type HandleUserPromptParameters = {
    context: BrowsingContext.BrowsingContext;
    accept?: boolean;
    userText?: string;
  };
}
export declare namespace BrowsingContext {
  type HandleUserPromptResult = EmptyResult;
}
export declare namespace BrowsingContext {
  type LocateNodes = {
    method: 'browsingContext.locateNodes';
    params: BrowsingContext.LocateNodesParameters;
  };
}
export declare namespace BrowsingContext {
  type LocateNodesParameters = {
    context: BrowsingContext.BrowsingContext;
    locator: BrowsingContext.Locator;
    /**
     * Must be greater than or equal to `1`.
     */
    maxNodeCount?: JsUint;
    serializationOptions?: Script.SerializationOptions;
    startNodes?: [Script.SharedReference, ...Script.SharedReference[]];
  };
}
export declare namespace BrowsingContext {
  type LocateNodesResult = {
    nodes: [...Script.NodeRemoteValue[]];
  };
}
export declare namespace BrowsingContext {
  type Navigate = {
    method: 'browsingContext.navigate';
    params: BrowsingContext.NavigateParameters;
  };
}
export declare namespace BrowsingContext {
  type NavigateParameters = {
    context: BrowsingContext.BrowsingContext;
    url: string;
    wait?: BrowsingContext.ReadinessState;
  };
}
export declare namespace BrowsingContext {
  type NavigateResult = {
    navigation: BrowsingContext.Navigation | null;
    url: string;
  };
}
export declare namespace BrowsingContext {
  type Print = {
    method: 'browsingContext.print';
    params: BrowsingContext.PrintParameters;
  };
}
export declare namespace BrowsingContext {
  type PrintParameters = {
    context: BrowsingContext.BrowsingContext;
    /**
     * @defaultValue `false`
     */
    background?: boolean;
    margin?: BrowsingContext.PrintMarginParameters;
    /**
     * @defaultValue `"portrait"`
     */
    orientation?: 'portrait' | 'landscape';
    page?: BrowsingContext.PrintPageParameters;
    pageRanges?: [...(JsUint | string)[]];
    /**
     * Must be between `0.1` and `2`, inclusive.
     *
     * @defaultValue `1`
     */
    scale?: number;
    /**
     * @defaultValue `true`
     */
    shrinkToFit?: boolean;
  };
}
export declare namespace BrowsingContext {
  type PrintMarginParameters = {
    /**
     * Must be greater than or equal to `0`.
     *
     * @defaultValue `1`
     */
    bottom?: number;
    /**
     * Must be greater than or equal to `0`.
     *
     * @defaultValue `1`
     */
    left?: number;
    /**
     * Must be greater than or equal to `0`.
     *
     * @defaultValue `1`
     */
    right?: number;
    /**
     * Must be greater than or equal to `0`.
     *
     * @defaultValue `1`
     */
    top?: number;
  };
}
export declare namespace BrowsingContext {
  type PrintPageParameters = {
    /**
     * Must be greater than or equal to `0.0352`.
     *
     * @defaultValue `27.94`
     */
    height?: number;
    /**
     * Must be greater than or equal to `0.0352`.
     *
     * @defaultValue `21.59`
     */
    width?: number;
  };
}
export declare namespace BrowsingContext {
  type PrintResult = {
    data: string;
  };
}
export declare namespace BrowsingContext {
  type Reload = {
    method: 'browsingContext.reload';
    params: BrowsingContext.ReloadParameters;
  };
}
export declare namespace BrowsingContext {
  type ReloadParameters = {
    context: BrowsingContext.BrowsingContext;
    ignoreCache?: boolean;
    wait?: BrowsingContext.ReadinessState;
  };
}
export declare namespace BrowsingContext {
  type ReloadResult = BrowsingContext.NavigateResult;
}
export declare namespace BrowsingContext {
  type SetViewport = {
    method: 'browsingContext.setViewport';
    params: BrowsingContext.SetViewportParameters;
  };
}
export declare namespace BrowsingContext {
  type SetViewportParameters = {
    context?: BrowsingContext.BrowsingContext;
    viewport?: BrowsingContext.Viewport | null;
    /**
     * Must be greater than `0`.
     */
    devicePixelRatio?: number | null;
    userContexts?: [Browser.UserContext, ...Browser.UserContext[]];
  };
}
export declare namespace BrowsingContext {
  type Viewport = {
    width: JsUint;
    height: JsUint;
  };
}
export declare namespace BrowsingContext {
  type SetViewportResult = EmptyResult;
}
export declare namespace BrowsingContext {
  type TraverseHistory = {
    method: 'browsingContext.traverseHistory';
    params: BrowsingContext.TraverseHistoryParameters;
  };
}
export declare namespace BrowsingContext {
  type TraverseHistoryParameters = {
    context: BrowsingContext.BrowsingContext;
    delta: JsInt;
  };
}
export declare namespace BrowsingContext {
  type TraverseHistoryResult = EmptyResult;
}
export declare namespace BrowsingContext {
  type ContextCreated = {
    method: 'browsingContext.contextCreated';
    params: BrowsingContext.Info;
  };
}
export declare namespace BrowsingContext {
  type ContextDestroyed = {
    method: 'browsingContext.contextDestroyed';
    params: BrowsingContext.Info;
  };
}
export declare namespace BrowsingContext {
  type NavigationStarted = {
    method: 'browsingContext.navigationStarted';
    params: BrowsingContext.NavigationInfo;
  };
}
export declare namespace BrowsingContext {
  type FragmentNavigated = {
    method: 'browsingContext.fragmentNavigated';
    params: BrowsingContext.NavigationInfo;
  };
}
export declare namespace BrowsingContext {
  type HistoryUpdated = {
    method: 'browsingContext.historyUpdated';
    params: BrowsingContext.HistoryUpdatedParameters;
  };
}
export declare namespace BrowsingContext {
  type HistoryUpdatedParameters = {
    context: BrowsingContext.BrowsingContext;
    timestamp: JsUint;
    url: string;
  };
}
export declare namespace BrowsingContext {
  type DomContentLoaded = {
    method: 'browsingContext.domContentLoaded';
    params: BrowsingContext.NavigationInfo;
  };
}
export declare namespace BrowsingContext {
  type Load = {
    method: 'browsingContext.load';
    params: BrowsingContext.NavigationInfo;
  };
}
export declare namespace BrowsingContext {
  type DownloadWillBegin = {
    method: 'browsingContext.downloadWillBegin';
    params: BrowsingContext.DownloadWillBeginParams;
  };
}
export declare namespace BrowsingContext {
  type DownloadWillBeginParams = {
    suggestedFilename: string;
  } & BrowsingContext.BaseNavigationInfo;
}
export declare namespace BrowsingContext {
  type DownloadEnd = {
    method: 'browsingContext.downloadEnd';
    params: BrowsingContext.DownloadEndParams;
  };
}
export declare namespace BrowsingContext {
  type DownloadEndParams =
    | BrowsingContext.DownloadCanceledParams
    | BrowsingContext.DownloadCompleteParams;
}
export declare namespace BrowsingContext {
  type DownloadCanceledParams = {
    status: 'canceled';
  } & BrowsingContext.BaseNavigationInfo;
}
export declare namespace BrowsingContext {
  type DownloadCompleteParams = {
    status: 'complete';
    filepath: string | null;
  } & BrowsingContext.BaseNavigationInfo;
}
export declare namespace BrowsingContext {
  type NavigationAborted = {
    method: 'browsingContext.navigationAborted';
    params: BrowsingContext.NavigationInfo;
  };
}
export declare namespace BrowsingContext {
  type NavigationCommitted = {
    method: 'browsingContext.navigationCommitted';
    params: BrowsingContext.NavigationInfo;
  };
}
export declare namespace BrowsingContext {
  type NavigationFailed = {
    method: 'browsingContext.navigationFailed';
    params: BrowsingContext.NavigationInfo;
  };
}
export declare namespace BrowsingContext {
  type UserPromptClosed = {
    method: 'browsingContext.userPromptClosed';
    params: BrowsingContext.UserPromptClosedParameters;
  };
}
export declare namespace BrowsingContext {
  type UserPromptClosedParameters = {
    context: BrowsingContext.BrowsingContext;
    accepted: boolean;
    type: BrowsingContext.UserPromptType;
    userText?: string;
  };
}
export declare namespace BrowsingContext {
  type UserPromptOpened = {
    method: 'browsingContext.userPromptOpened';
    params: BrowsingContext.UserPromptOpenedParameters;
  };
}
export declare namespace BrowsingContext {
  type UserPromptOpenedParameters = {
    context: BrowsingContext.BrowsingContext;
    handler: Session.UserPromptHandlerType;
    message: string;
    type: BrowsingContext.UserPromptType;
    defaultValue?: string;
  };
}
export type EmulationCommand =
  | Emulation.SetForcedColorsModeThemeOverride
  | Emulation.SetGeolocationOverride
  | Emulation.SetLocaleOverride
  | Emulation.SetNetworkConditions
  | Emulation.SetScreenOrientationOverride
  | Emulation.SetScriptingEnabled
  | Emulation.SetTimezoneOverride
  | Emulation.SetUserAgentOverride;
export type EmulationResult =
  | Emulation.SetForcedColorsModeThemeOverrideResult
  | Emulation.SetGeolocationOverrideResult
  | Emulation.SetLocaleOverrideResult
  | Emulation.SetScreenOrientationOverrideResult
  | Emulation.SetScriptingEnabledResult
  | Emulation.SetTimezoneOverrideResult
  | Emulation.SetUserAgentOverrideResult;
export declare namespace Emulation {
  type SetForcedColorsModeThemeOverride = {
    method: 'emulation.setForcedColorsModeThemeOverride';
    params: Emulation.SetForcedColorsModeThemeOverrideParameters;
  };
}
export declare namespace Emulation {
  type SetForcedColorsModeThemeOverrideParameters = {
    theme: Emulation.ForcedColorsModeTheme | null;
    contexts?: [
      BrowsingContext.BrowsingContext,
      ...BrowsingContext.BrowsingContext[],
    ];
    userContexts?: [Browser.UserContext, ...Browser.UserContext[]];
  };
}
export declare namespace Emulation {
  const enum ForcedColorsModeTheme {
    Light = 'light',
    Dark = 'dark',
  }
}
export declare namespace Emulation {
  type SetForcedColorsModeThemeOverrideResult = EmptyResult;
}
export declare namespace Emulation {
  type SetGeolocationOverride = {
    method: 'emulation.setGeolocationOverride';
    params: Emulation.SetGeolocationOverrideParameters;
  };
}
export declare namespace Emulation {
  type SetGeolocationOverrideParameters = (
    | {
        coordinates: Emulation.GeolocationCoordinates | null;
      }
    | {
        error: Emulation.GeolocationPositionError;
      }
  ) & {
    contexts?: [
      BrowsingContext.BrowsingContext,
      ...BrowsingContext.BrowsingContext[],
    ];
    userContexts?: [Browser.UserContext, ...Browser.UserContext[]];
  };
}
export declare namespace Emulation {
  type GeolocationCoordinates = {
    /**
     * Must be between `-90` and `90`, inclusive.
     */
    latitude: number;
    /**
     * Must be between `-180` and `180`, inclusive.
     */
    longitude: number;
    /**
     * Must be greater than or equal to `0`.
     *
     * @defaultValue `1`
     */
    accuracy?: number;
    /**
     * @defaultValue `null`
     */
    altitude?: number | null;
    /**
     * Must be greater than or equal to `0`.
     *
     * @defaultValue `null`
     */
    altitudeAccuracy?: number | null;
    /**
     * Must be between `0` and `360`.
     *
     * @defaultValue `null`
     */
    heading?: number | null;
    /**
     * Must be greater than or equal to `0`.
     *
     * @defaultValue `null`
     */
    speed?: number | null;
  };
}
export declare namespace Emulation {
  type GeolocationPositionError = {
    type: 'positionUnavailable';
  };
}
export declare namespace Emulation {
  type SetGeolocationOverrideResult = EmptyResult;
}
export declare namespace Emulation {
  type SetLocaleOverride = {
    method: 'emulation.setLocaleOverride';
    params: Emulation.SetLocaleOverrideParameters;
  };
}
export declare namespace Emulation {
  type SetLocaleOverrideParameters = {
    locale: string | null;
    contexts?: [
      BrowsingContext.BrowsingContext,
      ...BrowsingContext.BrowsingContext[],
    ];
    userContexts?: [Browser.UserContext, ...Browser.UserContext[]];
  };
}
export declare namespace Emulation {
  type SetLocaleOverrideResult = EmptyResult;
}
export declare namespace Emulation {
  type SetNetworkConditions = {
    method: 'emulation.setNetworkConditions';
    params: Emulation.SetNetworkConditionsParameters;
  };
}
export declare namespace Emulation {
  type SetNetworkConditionsParameters = {
    networkConditions: Emulation.NetworkConditions | null;
    contexts?: [
      BrowsingContext.BrowsingContext,
      ...BrowsingContext.BrowsingContext[],
    ];
    userContexts?: [Browser.UserContext, ...Browser.UserContext[]];
  };
}
export declare namespace Emulation {
  type NetworkConditions = Emulation.NetworkConditionsOffline;
}
export declare namespace Emulation {
  type NetworkConditionsOffline = {
    type: 'offline';
  };
}
export declare namespace Emulation {
  type SetScreenOrientationOverride = {
    method: 'emulation.setScreenOrientationOverride';
    params: Emulation.SetScreenOrientationOverrideParameters;
  };
}
export declare namespace Emulation {
  const enum ScreenOrientationNatural {
    Portrait = 'portrait',
    Landscape = 'landscape',
  }
}
export declare namespace Emulation {
  type ScreenOrientationType =
    | 'portrait-primary'
    | 'portrait-secondary'
    | 'landscape-primary'
    | 'landscape-secondary';
}
export declare namespace Emulation {
  type ScreenOrientation = {
    natural: Emulation.ScreenOrientationNatural;
    type: Emulation.ScreenOrientationType;
  };
}
export declare namespace Emulation {
  type SetScreenOrientationOverrideParameters = {
    screenOrientation: Emulation.ScreenOrientation | null;
    contexts?: [
      BrowsingContext.BrowsingContext,
      ...BrowsingContext.BrowsingContext[],
    ];
    userContexts?: [Browser.UserContext, ...Browser.UserContext[]];
  };
}
export declare namespace Emulation {
  type SetScreenOrientationOverrideResult = EmptyResult;
}
export declare namespace Emulation {
  type SetUserAgentOverride = {
    method: 'emulation.setUserAgentOverride';
    params: Emulation.SetUserAgentOverrideParameters;
  };
}
export declare namespace Emulation {
  type SetUserAgentOverrideParameters = {
    userAgent: string | null;
    contexts?: [
      BrowsingContext.BrowsingContext,
      ...BrowsingContext.BrowsingContext[],
    ];
    userContexts?: [Browser.UserContext, ...Browser.UserContext[]];
  };
}
export declare namespace Emulation {
  type SetUserAgentOverrideResult = EmptyResult;
}
export declare namespace Emulation {
  type SetScriptingEnabled = {
    method: 'emulation.setScriptingEnabled';
    params: Emulation.SetScriptingEnabledParameters;
  };
}
export declare namespace Emulation {
  type SetScriptingEnabledParameters = {
    enabled: false | null;
    contexts?: [
      BrowsingContext.BrowsingContext,
      ...BrowsingContext.BrowsingContext[],
    ];
    userContexts?: [Browser.UserContext, ...Browser.UserContext[]];
  };
}
export declare namespace Emulation {
  type SetScriptingEnabledResult = EmptyResult;
}
export declare namespace Emulation {
  type SetTimezoneOverride = {
    method: 'emulation.setTimezoneOverride';
    params: Emulation.SetTimezoneOverrideParameters;
  };
}
export declare namespace Emulation {
  type SetTimezoneOverrideParameters = {
    timezone: string | null;
    contexts?: [
      BrowsingContext.BrowsingContext,
      ...BrowsingContext.BrowsingContext[],
    ];
    userContexts?: [Browser.UserContext, ...Browser.UserContext[]];
  };
}
export declare namespace Emulation {
  type SetTimezoneOverrideResult = EmptyResult;
}
export type NetworkCommand =
  | Network.AddDataCollector
  | Network.AddIntercept
  | Network.ContinueRequest
  | Network.ContinueResponse
  | Network.ContinueWithAuth
  | Network.DisownData
  | Network.FailRequest
  | Network.GetData
  | Network.ProvideResponse
  | Network.RemoveDataCollector
  | Network.RemoveIntercept
  | Network.SetCacheBehavior
  | Network.SetExtraHeaders;
export type NetworkResult =
  | Network.AddDataCollectorResult
  | Network.AddInterceptResult
  | Network.ContinueRequestResult
  | Network.ContinueResponseResult
  | Network.ContinueWithAuthResult
  | Network.DisownDataResult
  | Network.FailRequestResult
  | Network.GetDataResult
  | Network.ProvideResponseResult
  | Network.RemoveDataCollectorResult
  | Network.RemoveInterceptResult
  | Network.SetCacheBehaviorResult
  | Network.SetExtraHeadersResult;
export type NetworkEvent =
  | Network.AuthRequired
  | Network.BeforeRequestSent
  | Network.FetchError
  | Network.ResponseCompleted
  | Network.ResponseStarted;
export declare namespace Network {
  type AuthChallenge = {
    scheme: string;
    realm: string;
  };
}
export declare namespace Network {
  type AuthCredentials = {
    type: 'password';
    username: string;
    password: string;
  };
}
export declare namespace Network {
  type BaseParameters = {
    context: BrowsingContext.BrowsingContext | null;
    isBlocked: boolean;
    navigation: BrowsingContext.Navigation | null;
    redirectCount: JsUint;
    request: Network.RequestData;
    timestamp: JsUint;
    intercepts?: [Network.Intercept, ...Network.Intercept[]];
  };
}
export declare namespace Network {
  type BytesValue = Network.StringValue | Network.Base64Value;
}
export declare namespace Network {
  type StringValue = {
    type: 'string';
    value: string;
  };
}
export declare namespace Network {
  type Base64Value = {
    type: 'base64';
    value: string;
  };
}
export declare namespace Network {
  type Collector = string;
}
export declare namespace Network {
  const enum CollectorType {
    Blob = 'blob',
  }
}
export declare namespace Network {
  const enum SameSite {
    Strict = 'strict',
    Lax = 'lax',
    None = 'none',
    Default = 'default',
  }
}
export declare namespace Network {
  type Cookie = {
    name: string;
    value: Network.BytesValue;
    domain: string;
    path: string;
    size: JsUint;
    httpOnly: boolean;
    secure: boolean;
    sameSite: Network.SameSite;
    expiry?: JsUint;
  } & Extensible;
}
export declare namespace Network {
  type CookieHeader = {
    name: string;
    value: Network.BytesValue;
  };
}
export declare namespace Network {
  const enum DataType {
    Request = 'request',
    Response = 'response',
  }
}
export declare namespace Network {
  type FetchTimingInfo = {
    timeOrigin: number;
    requestTime: number;
    redirectStart: number;
    redirectEnd: number;
    fetchStart: number;
    dnsStart: number;
    dnsEnd: number;
    connectStart: number;
    connectEnd: number;
    tlsStart: number;
    requestStart: number;
    responseStart: number;
    responseEnd: number;
  };
}
export declare namespace Network {
  type Header = {
    name: string;
    value: Network.BytesValue;
  };
}
export declare namespace Network {
  type Initiator = {
    columnNumber?: JsUint;
    lineNumber?: JsUint;
    request?: Network.Request;
    stackTrace?: Script.StackTrace;
    type?: 'parser' | 'script' | 'preflight' | 'other';
  };
}
export declare namespace Network {
  type Intercept = string;
}
export declare namespace Network {
  type Request = string;
}
export declare namespace Network {
  type RequestData = {
    request: Network.Request;
    url: string;
    method: string;
    headers: [...Network.Header[]];
    cookies: [...Network.Cookie[]];
    headersSize: JsUint;
    bodySize: JsUint | null;
    destination: string;
    initiatorType: string | null;
    timings: Network.FetchTimingInfo;
  };
}
export declare namespace Network {
  type ResponseContent = {
    size: JsUint;
  };
}
export declare namespace Network {
  type ResponseData = {
    url: string;
    protocol: string;
    status: JsUint;
    statusText: string;
    fromCache: boolean;
    headers: [...Network.Header[]];
    mimeType: string;
    bytesReceived: JsUint;
    headersSize: JsUint | null;
    bodySize: JsUint | null;
    content: Network.ResponseContent;
    authChallenges?: [...Network.AuthChallenge[]];
  };
}
export declare namespace Network {
  type SetCookieHeader = {
    name: string;
    value: Network.BytesValue;
    domain?: string;
    httpOnly?: boolean;
    expiry?: string;
    maxAge?: JsInt;
    path?: string;
    sameSite?: Network.SameSite;
    secure?: boolean;
  };
}
export declare namespace Network {
  type UrlPattern = Network.UrlPatternPattern | Network.UrlPatternString;
}
export declare namespace Network {
  type UrlPatternPattern = {
    type: 'pattern';
    protocol?: string;
    hostname?: string;
    port?: string;
    pathname?: string;
    search?: string;
  };
}
export declare namespace Network {
  type UrlPatternString = {
    type: 'string';
    pattern: string;
  };
}
export declare namespace Network {
  type AddDataCollector = {
    method: 'network.addDataCollector';
    params: Network.AddDataCollectorParameters;
  };
}
export declare namespace Network {
  type AddDataCollectorParameters = {
    dataTypes: [Network.DataType, ...Network.DataType[]];
    maxEncodedDataSize: JsUint;
    /**
     * @defaultValue `"blob"`
     */
    collectorType?: Network.CollectorType;
    contexts?: [
      BrowsingContext.BrowsingContext,
      ...BrowsingContext.BrowsingContext[],
    ];
    userContexts?: [Browser.UserContext, ...Browser.UserContext[]];
  };
}
export declare namespace Network {
  type AddDataCollectorResult = {
    collector: Network.Collector;
  };
}
export declare namespace Network {
  type AddIntercept = {
    method: 'network.addIntercept';
    params: Network.AddInterceptParameters;
  };
}
export declare namespace Network {
  type AddInterceptParameters = {
    phases: [Network.InterceptPhase, ...Network.InterceptPhase[]];
    contexts?: [
      BrowsingContext.BrowsingContext,
      ...BrowsingContext.BrowsingContext[],
    ];
    urlPatterns?: [...Network.UrlPattern[]];
  };
}
export declare namespace Network {
  const enum InterceptPhase {
    BeforeRequestSent = 'beforeRequestSent',
    ResponseStarted = 'responseStarted',
    AuthRequired = 'authRequired',
  }
}
export declare namespace Network {
  type AddInterceptResult = {
    intercept: Network.Intercept;
  };
}
export declare namespace Network {
  type ContinueRequest = {
    method: 'network.continueRequest';
    params: Network.ContinueRequestParameters;
  };
}
export declare namespace Network {
  type ContinueRequestParameters = {
    request: Network.Request;
    body?: Network.BytesValue;
    cookies?: [...Network.CookieHeader[]];
    headers?: [...Network.Header[]];
    method?: string;
    url?: string;
  };
}
export declare namespace Network {
  type ContinueRequestResult = EmptyResult;
}
export declare namespace Network {
  type ContinueResponse = {
    method: 'network.continueResponse';
    params: Network.ContinueResponseParameters;
  };
}
export declare namespace Network {
  type ContinueResponseParameters = {
    request: Network.Request;
    cookies?: [...Network.SetCookieHeader[]];
    credentials?: Network.AuthCredentials;
    headers?: [...Network.Header[]];
    reasonPhrase?: string;
    statusCode?: JsUint;
  };
}
export declare namespace Network {
  type ContinueResponseResult = EmptyResult;
}
export declare namespace Network {
  type ContinueWithAuth = {
    method: 'network.continueWithAuth';
    params: Network.ContinueWithAuthParameters;
  };
}
export declare namespace Network {
  type ContinueWithAuthParameters = {
    request: Network.Request;
  } & (
    | Network.ContinueWithAuthCredentials
    | Network.ContinueWithAuthNoCredentials
  );
}
export declare namespace Network {
  type ContinueWithAuthCredentials = {
    action: 'provideCredentials';
    credentials: Network.AuthCredentials;
  };
}
export declare namespace Network {
  type ContinueWithAuthNoCredentials = {
    action: 'default' | 'cancel';
  };
}
export declare namespace Network {
  type ContinueWithAuthResult = EmptyResult;
}
export declare namespace Network {
  type DisownData = {
    method: 'network.disownData';
    params: Network.DisownDataParameters;
  };
}
export declare namespace Network {
  type DisownDataParameters = {
    dataType: Network.DataType;
    collector: Network.Collector;
    request: Network.Request;
  };
}
export declare namespace Network {
  type DisownDataResult = EmptyResult;
}
export declare namespace Network {
  type FailRequest = {
    method: 'network.failRequest';
    params: Network.FailRequestParameters;
  };
}
export declare namespace Network {
  type FailRequestParameters = {
    request: Network.Request;
  };
}
export declare namespace Network {
  type FailRequestResult = EmptyResult;
}
export declare namespace Network {
  type GetData = {
    method: 'network.getData';
    params: Network.GetDataParameters;
  };
}
export declare namespace Network {
  type GetDataParameters = {
    dataType: Network.DataType;
    collector?: Network.Collector;
    /**
     * @defaultValue `false`
     */
    disown?: boolean;
    request: Network.Request;
  };
}
export declare namespace Network {
  type GetDataResult = {
    bytes: Network.BytesValue;
  };
}
export declare namespace Network {
  type ProvideResponse = {
    method: 'network.provideResponse';
    params: Network.ProvideResponseParameters;
  };
}
export declare namespace Network {
  type ProvideResponseParameters = {
    request: Network.Request;
    body?: Network.BytesValue;
    cookies?: [...Network.SetCookieHeader[]];
    headers?: [...Network.Header[]];
    reasonPhrase?: string;
    statusCode?: JsUint;
  };
}
export declare namespace Network {
  type ProvideResponseResult = EmptyResult;
}
export declare namespace Network {
  type RemoveDataCollector = {
    method: 'network.removeDataCollector';
    params: Network.RemoveDataCollectorParameters;
  };
}
export declare namespace Network {
  type RemoveDataCollectorParameters = {
    collector: Network.Collector;
  };
}
export declare namespace Network {
  type RemoveDataCollectorResult = EmptyResult;
}
export declare namespace Network {
  type RemoveIntercept = {
    method: 'network.removeIntercept';
    params: Network.RemoveInterceptParameters;
  };
}
export declare namespace Network {
  type RemoveInterceptParameters = {
    intercept: Network.Intercept;
  };
}
export declare namespace Network {
  type RemoveInterceptResult = EmptyResult;
}
export declare namespace Network {
  type SetCacheBehavior = {
    method: 'network.setCacheBehavior';
    params: Network.SetCacheBehaviorParameters;
  };
}
export declare namespace Network {
  type SetCacheBehaviorParameters = {
    cacheBehavior: 'default' | 'bypass';
    contexts?: [
      BrowsingContext.BrowsingContext,
      ...BrowsingContext.BrowsingContext[],
    ];
  };
}
export declare namespace Network {
  type SetCacheBehaviorResult = EmptyResult;
}
export declare namespace Network {
  type SetExtraHeaders = {
    method: 'network.setExtraHeaders';
    params: Network.SetExtraHeadersParameters;
  };
}
export declare namespace Network {
  type SetExtraHeadersParameters = {
    headers: [...Network.Header[]];
    contexts?: [
      BrowsingContext.BrowsingContext,
      ...BrowsingContext.BrowsingContext[],
    ];
    userContexts?: [Browser.UserContext, ...Browser.UserContext[]];
  };
}
export declare namespace Network {
  type SetExtraHeadersResult = EmptyResult;
}
export declare namespace Network {
  type AuthRequired = {
    method: 'network.authRequired';
    params: Network.AuthRequiredParameters;
  };
}
export declare namespace Network {
  type AuthRequiredParameters = Network.BaseParameters & {
    response: Network.ResponseData;
  };
}
export declare namespace Network {
  type BeforeRequestSent = {
    method: 'network.beforeRequestSent';
    params: Network.BeforeRequestSentParameters;
  };
}
export declare namespace Network {
  type BeforeRequestSentParameters = Network.BaseParameters & {
    initiator?: Network.Initiator;
  };
}
export declare namespace Network {
  type FetchError = {
    method: 'network.fetchError';
    params: Network.FetchErrorParameters;
  };
}
export declare namespace Network {
  type FetchErrorParameters = Network.BaseParameters & {
    errorText: string;
  };
}
export declare namespace Network {
  type ResponseCompleted = {
    method: 'network.responseCompleted';
    params: Network.ResponseCompletedParameters;
  };
}
export declare namespace Network {
  type ResponseCompletedParameters = Network.BaseParameters & {
    response: Network.ResponseData;
  };
}
export declare namespace Network {
  type ResponseStarted = {
    method: 'network.responseStarted';
    params: Network.ResponseStartedParameters;
  };
}
export declare namespace Network {
  type ResponseStartedParameters = Network.BaseParameters & {
    response: Network.ResponseData;
  };
}
export type ScriptCommand =
  | Script.AddPreloadScript
  | Script.CallFunction
  | Script.Disown
  | Script.Evaluate
  | Script.GetRealms
  | Script.RemovePreloadScript;
export type ScriptResult =
  | Script.AddPreloadScriptResult
  | Script.CallFunctionResult
  | Script.DisownResult
  | Script.EvaluateResult
  | Script.GetRealmsResult
  | Script.RemovePreloadScriptResult;
export type ScriptEvent =
  | Script.Message
  | Script.RealmCreated
  | Script.RealmDestroyed;
export declare namespace Script {
  type Channel = string;
}
export declare namespace Script {
  type ChannelValue = {
    type: 'channel';
    value: Script.ChannelProperties;
  };
}
export declare namespace Script {
  type ChannelProperties = {
    channel: Script.Channel;
    serializationOptions?: Script.SerializationOptions;
    ownership?: Script.ResultOwnership;
  };
}
export declare namespace Script {
  type EvaluateResult =
    | Script.EvaluateResultSuccess
    | Script.EvaluateResultException;
}
export declare namespace Script {
  type EvaluateResultSuccess = {
    type: 'success';
    result: Script.RemoteValue;
    realm: Script.Realm;
  };
}
export declare namespace Script {
  type EvaluateResultException = {
    type: 'exception';
    exceptionDetails: Script.ExceptionDetails;
    realm: Script.Realm;
  };
}
export declare namespace Script {
  type ExceptionDetails = {
    columnNumber: JsUint;
    exception: Script.RemoteValue;
    lineNumber: JsUint;
    stackTrace: Script.StackTrace;
    text: string;
  };
}
export declare namespace Script {
  type Handle = string;
}
export declare namespace Script {
  type InternalId = string;
}
export declare namespace Script {
  type LocalValue =
    | Script.RemoteReference
    | Script.PrimitiveProtocolValue
    | Script.ChannelValue
    | Script.ArrayLocalValue
    | Script.DateLocalValue
    | Script.MapLocalValue
    | Script.ObjectLocalValue
    | Script.RegExpLocalValue
    | Script.SetLocalValue;
}
export declare namespace Script {
  type ListLocalValue = [...Script.LocalValue[]];
}
export declare namespace Script {
  type ArrayLocalValue = {
    type: 'array';
    value: Script.ListLocalValue;
  };
}
export declare namespace Script {
  type DateLocalValue = {
    type: 'date';
    value: string;
  };
}
export declare namespace Script {
  type MappingLocalValue = [
    ...[Script.LocalValue | string, Script.LocalValue][],
  ];
}
export declare namespace Script {
  type MapLocalValue = {
    type: 'map';
    value: Script.MappingLocalValue;
  };
}
export declare namespace Script {
  type ObjectLocalValue = {
    type: 'object';
    value: Script.MappingLocalValue;
  };
}
export declare namespace Script {
  type RegExpValue = {
    pattern: string;
    flags?: string;
  };
}
export declare namespace Script {
  type RegExpLocalValue = {
    type: 'regexp';
    value: Script.RegExpValue;
  };
}
export declare namespace Script {
  type SetLocalValue = {