chromedeveloperprotocol-client 0.1.0__py3-none-any.whl

cdp/protocol/overlay/types.py

@@ -0,0 +1,198 @@
+"""CDP Overlay Types"""
+
+from typing import TypedDict, NotRequired, Required, Literal, Any, Dict, Union, Optional, List, Set, Tuple
+
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+    from cdp.protocol.dom.types import NodeId
+    from cdp.protocol.dom.types import RGBA
+    from cdp.protocol.dom.types import Rect
+
+class SourceOrderConfig(TypedDict, total=True):
+    """Configuration data for drawing the source order of an elements children."""
+    parentOutlineColor: 'RGBA'
+    """the color to outline the given element in."""
+    childOutlineColor: 'RGBA'
+    """the color to outline the child elements in."""
+class GridHighlightConfig(TypedDict, total=False):
+    """Configuration data for the highlighting of Grid elements."""
+    showGridExtensionLines: NotRequired['bool']
+    """Whether the extension lines from grid cells to the rulers should be shown (default: false)."""
+    showPositiveLineNumbers: NotRequired['bool']
+    """Show Positive line number labels (default: false)."""
+    showNegativeLineNumbers: NotRequired['bool']
+    """Show Negative line number labels (default: false)."""
+    showAreaNames: NotRequired['bool']
+    """Show area name labels (default: false)."""
+    showLineNames: NotRequired['bool']
+    """Show line name labels (default: false)."""
+    showTrackSizes: NotRequired['bool']
+    """Show track size labels (default: false)."""
+    gridBorderColor: NotRequired['RGBA']
+    """The grid container border highlight color (default: transparent)."""
+    rowLineColor: NotRequired['RGBA']
+    """The row line color (default: transparent)."""
+    columnLineColor: NotRequired['RGBA']
+    """The column line color (default: transparent)."""
+    gridBorderDash: NotRequired['bool']
+    """Whether the grid border is dashed (default: false)."""
+    rowLineDash: NotRequired['bool']
+    """Whether row lines are dashed (default: false)."""
+    columnLineDash: NotRequired['bool']
+    """Whether column lines are dashed (default: false)."""
+    rowGapColor: NotRequired['RGBA']
+    """The row gap highlight fill color (default: transparent)."""
+    rowHatchColor: NotRequired['RGBA']
+    """The row gap hatching fill color (default: transparent)."""
+    columnGapColor: NotRequired['RGBA']
+    """The column gap highlight fill color (default: transparent)."""
+    columnHatchColor: NotRequired['RGBA']
+    """The column gap hatching fill color (default: transparent)."""
+    areaBorderColor: NotRequired['RGBA']
+    """The named grid areas border color (Default: transparent)."""
+    gridBackgroundColor: NotRequired['RGBA']
+    """The grid container background color (Default: transparent)."""
+class FlexContainerHighlightConfig(TypedDict, total=False):
+    """Configuration data for the highlighting of Flex container elements."""
+    containerBorder: NotRequired['LineStyle']
+    """The style of the container border"""
+    lineSeparator: NotRequired['LineStyle']
+    """The style of the separator between lines"""
+    itemSeparator: NotRequired['LineStyle']
+    """The style of the separator between items"""
+    mainDistributedSpace: NotRequired['BoxStyle']
+    """Style of content-distribution space on the main axis (justify-content)."""
+    crossDistributedSpace: NotRequired['BoxStyle']
+    """Style of content-distribution space on the cross axis (align-content)."""
+    rowGapSpace: NotRequired['BoxStyle']
+    """Style of empty space caused by row gaps (gap/row-gap)."""
+    columnGapSpace: NotRequired['BoxStyle']
+    """Style of empty space caused by columns gaps (gap/column-gap)."""
+    crossAlignment: NotRequired['LineStyle']
+    """Style of the self-alignment line (align-items)."""
+class FlexItemHighlightConfig(TypedDict, total=False):
+    """Configuration data for the highlighting of Flex item elements."""
+    baseSizeBox: NotRequired['BoxStyle']
+    """Style of the box representing the item's base size"""
+    baseSizeBorder: NotRequired['LineStyle']
+    """Style of the border around the box representing the item's base size"""
+    flexibilityArrow: NotRequired['LineStyle']
+    """Style of the arrow representing if the item grew or shrank"""
+class LineStyle(TypedDict, total=False):
+    """Style information for drawing a line."""
+    color: NotRequired['RGBA']
+    """The color of the line (default: transparent)"""
+    pattern: NotRequired['Literal["dashed", "dotted"]']
+    """The line pattern (default: solid)"""
+class BoxStyle(TypedDict, total=False):
+    """Style information for drawing a box."""
+    fillColor: NotRequired['RGBA']
+    """The background color for the box (default: transparent)"""
+    hatchColor: NotRequired['RGBA']
+    """The hatching color for the box (default: transparent)"""
+ContrastAlgorithm = Literal['aa','aaa','apca']
+class HighlightConfig(TypedDict, total=False):
+    """Configuration data for the highlighting of page elements."""
+    showInfo: NotRequired['bool']
+    """Whether the node info tooltip should be shown (default: false)."""
+    showStyles: NotRequired['bool']
+    """Whether the node styles in the tooltip (default: false)."""
+    showRulers: NotRequired['bool']
+    """Whether the rulers should be shown (default: false)."""
+    showAccessibilityInfo: NotRequired['bool']
+    """Whether the a11y info should be shown (default: true)."""
+    showExtensionLines: NotRequired['bool']
+    """Whether the extension lines from node to the rulers should be shown (default: false)."""
+    contentColor: NotRequired['RGBA']
+    """The content box highlight fill color (default: transparent)."""
+    paddingColor: NotRequired['RGBA']
+    """The padding highlight fill color (default: transparent)."""
+    borderColor: NotRequired['RGBA']
+    """The border highlight fill color (default: transparent)."""
+    marginColor: NotRequired['RGBA']
+    """The margin highlight fill color (default: transparent)."""
+    eventTargetColor: NotRequired['RGBA']
+    """The event target element highlight fill color (default: transparent)."""
+    shapeColor: NotRequired['RGBA']
+    """The shape outside fill color (default: transparent)."""
+    shapeMarginColor: NotRequired['RGBA']
+    """The shape margin fill color (default: transparent)."""
+    cssGridColor: NotRequired['RGBA']
+    """The grid layout color (default: transparent)."""
+    colorFormat: NotRequired['ColorFormat']
+    """The color format used to format color styles (default: hex)."""
+    gridHighlightConfig: NotRequired['GridHighlightConfig']
+    """The grid layout highlight configuration (default: all transparent)."""
+    flexContainerHighlightConfig: NotRequired['FlexContainerHighlightConfig']
+    """The flex container highlight configuration (default: all transparent)."""
+    flexItemHighlightConfig: NotRequired['FlexItemHighlightConfig']
+    """The flex item highlight configuration (default: all transparent)."""
+    contrastAlgorithm: NotRequired['ContrastAlgorithm']
+    """The contrast algorithm to use for the contrast ratio (default: aa)."""
+    containerQueryContainerHighlightConfig: NotRequired['ContainerQueryContainerHighlightConfig']
+    """The container query container highlight configuration (default: all transparent)."""
+ColorFormat = Literal['rgb','hsl','hwb','hex']
+class GridNodeHighlightConfig(TypedDict, total=True):
+    """Configurations for Persistent Grid Highlight"""
+    gridHighlightConfig: 'GridHighlightConfig'
+    """A descriptor for the highlight appearance."""
+    nodeId: 'NodeId'
+    """Identifier of the node to highlight."""
+class FlexNodeHighlightConfig(TypedDict, total=True):
+    flexContainerHighlightConfig: 'FlexContainerHighlightConfig'
+    """A descriptor for the highlight appearance of flex containers."""
+    nodeId: 'NodeId'
+    """Identifier of the node to highlight."""
+class ScrollSnapContainerHighlightConfig(TypedDict, total=False):
+    snapportBorder: NotRequired['LineStyle']
+    """The style of the snapport border (default: transparent)"""
+    snapAreaBorder: NotRequired['LineStyle']
+    """The style of the snap area border (default: transparent)"""
+    scrollMarginColor: NotRequired['RGBA']
+    """The margin highlight fill color (default: transparent)."""
+    scrollPaddingColor: NotRequired['RGBA']
+    """The padding highlight fill color (default: transparent)."""
+class ScrollSnapHighlightConfig(TypedDict, total=True):
+    scrollSnapContainerHighlightConfig: 'ScrollSnapContainerHighlightConfig'
+    """A descriptor for the highlight appearance of scroll snap containers."""
+    nodeId: 'NodeId'
+    """Identifier of the node to highlight."""
+class HingeConfig(TypedDict, total=True):
+    """Configuration for dual screen hinge"""
+    rect: 'Rect'
+    """A rectangle represent hinge"""
+    contentColor: NotRequired['RGBA']
+    """The content box highlight fill color (default: a dark color)."""
+    outlineColor: NotRequired['RGBA']
+    """The content box highlight outline color (default: transparent)."""
+class WindowControlsOverlayConfig(TypedDict, total=True):
+    """Configuration for Window Controls Overlay"""
+    showCSS: 'bool'
+    """Whether the title bar CSS should be shown when emulating the Window Controls Overlay."""
+    selectedPlatform: 'str'
+    """Selected platforms to show the overlay."""
+    themeColor: 'str'
+    """The theme color defined in app manifest."""
+class ContainerQueryHighlightConfig(TypedDict, total=True):
+    containerQueryContainerHighlightConfig: 'ContainerQueryContainerHighlightConfig'
+    """A descriptor for the highlight appearance of container query containers."""
+    nodeId: 'NodeId'
+    """Identifier of the container node to highlight."""
+class ContainerQueryContainerHighlightConfig(TypedDict, total=False):
+    containerBorder: NotRequired['LineStyle']
+    """The style of the container border."""
+    descendantBorder: NotRequired['LineStyle']
+    """The style of the descendants' borders."""
+class IsolatedElementHighlightConfig(TypedDict, total=True):
+    isolationModeHighlightConfig: 'IsolationModeHighlightConfig'
+    """A descriptor for the highlight appearance of an element in isolation mode."""
+    nodeId: 'NodeId'
+    """Identifier of the isolated element to highlight."""
+class IsolationModeHighlightConfig(TypedDict, total=False):
+    resizerColor: NotRequired['RGBA']
+    """The fill color of the resizers (default: transparent)."""
+    resizerHandleColor: NotRequired['RGBA']
+    """The fill color for resizer handles (default: transparent)."""
+    maskColor: NotRequired['RGBA']
+    """The fill color for the mask covering non-isolated elements (default: transparent)."""
+InspectMode = Literal['searchForNode','searchForUAShadowDOM','captureAreaScreenshot','none']

cdp/protocol/page/events/service.py

@@ -0,0 +1,213 @@
+"""CDP Page Domain Events"""
+from ..types import *
+from .types import *
+from typing import Optional, Dict, Any, Callable, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ....service import Client
+
+class PageEvents:
+    """
+    Events for the Page domain.
+    """
+    def __init__(self, client: "Client"):
+        """
+        Initialize the Page events.
+        
+        Args:
+            client ("Client"): The parent CDP client instance.
+        """
+        self.client = client
+
+    def on_dom_content_event_fired(self, callback: Callable[[domContentEventFiredEvent,Optional[str]], None]=None) -> None:
+        """
+    No description available for domContentEventFired.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: domContentEventFiredEvent, session_id: Optional[str]).
+        """
+        self.client.on('Page.domContentEventFired', callback)
+    def on_file_chooser_opened(self, callback: Callable[[fileChooserOpenedEvent,Optional[str]], None]=None) -> None:
+        """
+    Emitted only when `page.interceptFileChooser` is enabled.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: fileChooserOpenedEvent, session_id: Optional[str]).
+        """
+        self.client.on('Page.fileChooserOpened', callback)
+    def on_frame_attached(self, callback: Callable[[frameAttachedEvent,Optional[str]], None]=None) -> None:
+        """
+    Fired when frame has been attached to its parent.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: frameAttachedEvent, session_id: Optional[str]).
+        """
+        self.client.on('Page.frameAttached', callback)
+    def on_frame_detached(self, callback: Callable[[frameDetachedEvent,Optional[str]], None]=None) -> None:
+        """
+    Fired when frame has been detached from its parent.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: frameDetachedEvent, session_id: Optional[str]).
+        """
+        self.client.on('Page.frameDetached', callback)
+    def on_frame_subtree_will_be_detached(self, callback: Callable[[frameSubtreeWillBeDetachedEvent,Optional[str]], None]=None) -> None:
+        """
+    Fired before frame subtree is detached. Emitted before any frame of the subtree is actually detached.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: frameSubtreeWillBeDetachedEvent, session_id: Optional[str]).
+        """
+        self.client.on('Page.frameSubtreeWillBeDetached', callback)
+    def on_frame_navigated(self, callback: Callable[[frameNavigatedEvent,Optional[str]], None]=None) -> None:
+        """
+    Fired once navigation of the frame has completed. Frame is now associated with the new loader.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: frameNavigatedEvent, session_id: Optional[str]).
+        """
+        self.client.on('Page.frameNavigated', callback)
+    def on_document_opened(self, callback: Callable[[documentOpenedEvent,Optional[str]], None]=None) -> None:
+        """
+    Fired when opening document to write to.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: documentOpenedEvent, session_id: Optional[str]).
+        """
+        self.client.on('Page.documentOpened', callback)
+    def on_frame_resized(self, callback: Callable[[frameResizedEvent,Optional[str]], None]=None) -> None:
+        """
+    No description available for frameResized.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: frameResizedEvent, session_id: Optional[str]).
+        """
+        self.client.on('Page.frameResized', callback)
+    def on_frame_started_navigating(self, callback: Callable[[frameStartedNavigatingEvent,Optional[str]], None]=None) -> None:
+        """
+    Fired when a navigation starts. This event is fired for both renderer-initiated and browser-initiated navigations. For renderer-initiated navigations, the event is fired after `frameRequestedNavigation`. Navigation may still be cancelled after the event is issued. Multiple events can be fired for a single navigation, for example, when a same-document navigation becomes a cross-document navigation (such as in the case of a frameset).    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: frameStartedNavigatingEvent, session_id: Optional[str]).
+        """
+        self.client.on('Page.frameStartedNavigating', callback)
+    def on_frame_requested_navigation(self, callback: Callable[[frameRequestedNavigationEvent,Optional[str]], None]=None) -> None:
+        """
+    Fired when a renderer-initiated navigation is requested. Navigation may still be cancelled after the event is issued.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: frameRequestedNavigationEvent, session_id: Optional[str]).
+        """
+        self.client.on('Page.frameRequestedNavigation', callback)
+    def on_frame_started_loading(self, callback: Callable[[frameStartedLoadingEvent,Optional[str]], None]=None) -> None:
+        """
+    Fired when frame has started loading.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: frameStartedLoadingEvent, session_id: Optional[str]).
+        """
+        self.client.on('Page.frameStartedLoading', callback)
+    def on_frame_stopped_loading(self, callback: Callable[[frameStoppedLoadingEvent,Optional[str]], None]=None) -> None:
+        """
+    Fired when frame has stopped loading.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: frameStoppedLoadingEvent, session_id: Optional[str]).
+        """
+        self.client.on('Page.frameStoppedLoading', callback)
+    def on_interstitial_hidden(self, callback: Callable[[interstitialHiddenEvent,Optional[str]], None]=None) -> None:
+        """
+    Fired when interstitial page was hidden    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: interstitialHiddenEvent, session_id: Optional[str]).
+        """
+        self.client.on('Page.interstitialHidden', callback)
+    def on_interstitial_shown(self, callback: Callable[[interstitialShownEvent,Optional[str]], None]=None) -> None:
+        """
+    Fired when interstitial page was shown    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: interstitialShownEvent, session_id: Optional[str]).
+        """
+        self.client.on('Page.interstitialShown', callback)
+    def on_javascript_dialog_closed(self, callback: Callable[[javascriptDialogClosedEvent,Optional[str]], None]=None) -> None:
+        """
+    Fired when a JavaScript initiated dialog (alert, confirm, prompt, or onbeforeunload) has been closed.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: javascriptDialogClosedEvent, session_id: Optional[str]).
+        """
+        self.client.on('Page.javascriptDialogClosed', callback)
+    def on_javascript_dialog_opening(self, callback: Callable[[javascriptDialogOpeningEvent,Optional[str]], None]=None) -> None:
+        """
+    Fired when a JavaScript initiated dialog (alert, confirm, prompt, or onbeforeunload) is about to open.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: javascriptDialogOpeningEvent, session_id: Optional[str]).
+        """
+        self.client.on('Page.javascriptDialogOpening', callback)
+    def on_lifecycle_event(self, callback: Callable[[lifecycleEventEvent,Optional[str]], None]=None) -> None:
+        """
+    Fired for lifecycle events (navigation, load, paint, etc) in the current target (including local frames).    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: lifecycleEventEvent, session_id: Optional[str]).
+        """
+        self.client.on('Page.lifecycleEvent', callback)
+    def on_back_forward_cache_not_used(self, callback: Callable[[backForwardCacheNotUsedEvent,Optional[str]], None]=None) -> None:
+        """
+    Fired for failed bfcache history navigations if BackForwardCache feature is enabled. Do not assume any ordering with the Page.frameNavigated event. This event is fired only for main-frame history navigation where the document changes (non-same-document navigations), when bfcache navigation fails.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: backForwardCacheNotUsedEvent, session_id: Optional[str]).
+        """
+        self.client.on('Page.backForwardCacheNotUsed', callback)
+    def on_load_event_fired(self, callback: Callable[[loadEventFiredEvent,Optional[str]], None]=None) -> None:
+        """
+    No description available for loadEventFired.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: loadEventFiredEvent, session_id: Optional[str]).
+        """
+        self.client.on('Page.loadEventFired', callback)
+    def on_navigated_within_document(self, callback: Callable[[navigatedWithinDocumentEvent,Optional[str]], None]=None) -> None:
+        """
+    Fired when same-document navigation happens, e.g. due to history API usage or anchor navigation.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: navigatedWithinDocumentEvent, session_id: Optional[str]).
+        """
+        self.client.on('Page.navigatedWithinDocument', callback)
+    def on_screencast_frame(self, callback: Callable[[screencastFrameEvent,Optional[str]], None]=None) -> None:
+        """
+    Compressed image data requested by the `startScreencast`.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: screencastFrameEvent, session_id: Optional[str]).
+        """
+        self.client.on('Page.screencastFrame', callback)
+    def on_screencast_visibility_changed(self, callback: Callable[[screencastVisibilityChangedEvent,Optional[str]], None]=None) -> None:
+        """
+    Fired when the page with currently enabled screencast was shown or hidden `.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: screencastVisibilityChangedEvent, session_id: Optional[str]).
+        """
+        self.client.on('Page.screencastVisibilityChanged', callback)
+    def on_window_open(self, callback: Callable[[windowOpenEvent,Optional[str]], None]=None) -> None:
+        """
+    Fired when a new window is going to be opened, via window.open(), link click, form submission, etc.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: windowOpenEvent, session_id: Optional[str]).
+        """
+        self.client.on('Page.windowOpen', callback)
+    def on_compilation_cache_produced(self, callback: Callable[[compilationCacheProducedEvent,Optional[str]], None]=None) -> None:
+        """
+    Issued for every compilation cache generated.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: compilationCacheProducedEvent, session_id: Optional[str]).
+        """
+        self.client.on('Page.compilationCacheProduced', callback)

cdp/protocol/page/events/types.py

@@ -0,0 +1,147 @@
+"""CDP Page Events"""
+
+from typing import TypedDict, NotRequired, Required, Literal, Any, Dict, Union, Optional, List, Set, Tuple
+
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+    from cdp.protocol.dom.types import BackendNodeId
+    from cdp.protocol.network.types import LoaderId
+    from cdp.protocol.network.types import MonotonicTime
+    from cdp.protocol.page.types import BackForwardCacheNotRestoredExplanation
+    from cdp.protocol.page.types import BackForwardCacheNotRestoredExplanationTree
+    from cdp.protocol.page.types import ClientNavigationDisposition
+    from cdp.protocol.page.types import ClientNavigationReason
+    from cdp.protocol.page.types import DialogType
+    from cdp.protocol.page.types import Frame
+    from cdp.protocol.page.types import FrameId
+    from cdp.protocol.page.types import NavigationType
+    from cdp.protocol.page.types import ScreencastFrameMetadata
+    from cdp.protocol.runtime.types import StackTrace
+
+class domContentEventFiredEvent(TypedDict, total=True):
+    timestamp: 'MonotonicTime'
+class fileChooserOpenedEvent(TypedDict, total=True):
+    frameId: 'FrameId'
+    """Id of the frame containing input node."""
+    mode: 'Literal["selectSingle", "selectMultiple"]'
+    """Input mode."""
+    backendNodeId: NotRequired['BackendNodeId']
+    """Input node id. Only present for file choosers opened via an <input type="file"> element."""
+class frameAttachedEvent(TypedDict, total=True):
+    frameId: 'FrameId'
+    """Id of the frame that has been attached."""
+    parentFrameId: 'FrameId'
+    """Parent frame identifier."""
+    stack: NotRequired['StackTrace']
+    """JavaScript stack trace of when frame was attached, only set if frame initiated from script."""
+class frameDetachedEvent(TypedDict, total=True):
+    frameId: 'FrameId'
+    """Id of the frame that has been detached."""
+    reason: 'Literal["remove", "swap"]'
+class frameSubtreeWillBeDetachedEvent(TypedDict, total=True):
+    frameId: 'FrameId'
+    """Id of the frame that is the root of the subtree that will be detached."""
+class frameNavigatedEvent(TypedDict, total=True):
+    frame: 'Frame'
+    """Frame object."""
+    type: 'NavigationType'
+class documentOpenedEvent(TypedDict, total=True):
+    frame: 'Frame'
+    """Frame object."""
+class frameResizedEvent(TypedDict, total=True):
+    pass
+class frameStartedNavigatingEvent(TypedDict, total=True):
+    frameId: 'FrameId'
+    """ID of the frame that is being navigated."""
+    url: 'str'
+    """The URL the navigation started with. The final URL can be different."""
+    loaderId: 'LoaderId'
+    """Loader identifier. Even though it is present in case of same-document navigation, the previously committed loaderId would not change unless the navigation changes from a same-document to a cross-document navigation."""
+    navigationType: 'Literal["reload", "reloadBypassingCache", "restore", "restoreWithPost", "historySameDocument", "historyDifferentDocument", "sameDocument", "differentDocument"]'
+class frameRequestedNavigationEvent(TypedDict, total=True):
+    frameId: 'FrameId'
+    """Id of the frame that is being navigated."""
+    reason: 'ClientNavigationReason'
+    """The reason for the navigation."""
+    url: 'str'
+    """The destination URL for the requested navigation."""
+    disposition: 'ClientNavigationDisposition'
+    """The disposition for the navigation."""
+class frameStartedLoadingEvent(TypedDict, total=True):
+    frameId: 'FrameId'
+    """Id of the frame that has started loading."""
+class frameStoppedLoadingEvent(TypedDict, total=True):
+    frameId: 'FrameId'
+    """Id of the frame that has stopped loading."""
+class interstitialHiddenEvent(TypedDict, total=True):
+    pass
+class interstitialShownEvent(TypedDict, total=True):
+    pass
+class javascriptDialogClosedEvent(TypedDict, total=True):
+    frameId: 'FrameId'
+    """Frame id."""
+    result: 'bool'
+    """Whether dialog was confirmed."""
+    userInput: 'str'
+    """User input in case of prompt."""
+class javascriptDialogOpeningEvent(TypedDict, total=True):
+    url: 'str'
+    """Frame url."""
+    frameId: 'FrameId'
+    """Frame id."""
+    message: 'str'
+    """Message that will be displayed by the dialog."""
+    type: 'DialogType'
+    """Dialog type."""
+    hasBrowserHandler: 'bool'
+    """True iff browser is capable showing or acting on the given dialog. When browser has no dialog handler for given target, calling alert while Page domain is engaged will stall the page execution. Execution can be resumed via calling Page.handleJavaScriptDialog."""
+    defaultPrompt: NotRequired['str']
+    """Default dialog prompt."""
+class lifecycleEventEvent(TypedDict, total=True):
+    frameId: 'FrameId'
+    """Id of the frame."""
+    loaderId: 'LoaderId'
+    """Loader identifier. Empty string if the request is fetched from worker."""
+    name: 'str'
+    timestamp: 'MonotonicTime'
+class backForwardCacheNotUsedEvent(TypedDict, total=True):
+    loaderId: 'LoaderId'
+    """The loader id for the associated navigation."""
+    frameId: 'FrameId'
+    """The frame id of the associated frame."""
+    notRestoredExplanations: 'List[BackForwardCacheNotRestoredExplanation]'
+    """Array of reasons why the page could not be cached. This must not be empty."""
+    notRestoredExplanationsTree: NotRequired['BackForwardCacheNotRestoredExplanationTree']
+    """Tree structure of reasons why the page could not be cached for each frame."""
+class loadEventFiredEvent(TypedDict, total=True):
+    timestamp: 'MonotonicTime'
+class navigatedWithinDocumentEvent(TypedDict, total=True):
+    frameId: 'FrameId'
+    """Id of the frame."""
+    url: 'str'
+    """Frame's new url."""
+    navigationType: 'Literal["fragment", "historyApi", "other"]'
+    """Navigation type"""
+class screencastFrameEvent(TypedDict, total=True):
+    data: 'str'
+    """Base64-encoded compressed image. (Encoded as a base64 string when passed over JSON)"""
+    metadata: 'ScreencastFrameMetadata'
+    """Screencast frame metadata."""
+    sessionId: 'int'
+    """Frame number."""
+class screencastVisibilityChangedEvent(TypedDict, total=True):
+    visible: 'bool'
+    """True if the page is visible."""
+class windowOpenEvent(TypedDict, total=True):
+    url: 'str'
+    """The URL for the new window."""
+    windowName: 'str'
+    """Window name."""
+    windowFeatures: 'List[str]'
+    """An array of enabled window features."""
+    userGesture: 'bool'
+    """Whether or not it was triggered by user gesture."""
+class compilationCacheProducedEvent(TypedDict, total=True):
+    url: 'str'
+    data: 'str'
+    """Base64-encoded data (Encoded as a base64 string when passed over JSON)"""