chromedeveloperprotocol-client 0.1.0__py3-none-any.whl

cdp/protocol/overlay/events/service.py

@@ -0,0 +1,53 @@
+"""CDP Overlay 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 OverlayEvents:
+    """
+    Events for the Overlay domain.
+    """
+    def __init__(self, client: "Client"):
+        """
+        Initialize the Overlay events.
+        
+        Args:
+            client ("Client"): The parent CDP client instance.
+        """
+        self.client = client
+
+    def on_inspect_node_requested(self, callback: Callable[[inspectNodeRequestedEvent,Optional[str]], None]=None) -> None:
+        """
+    Fired when the node should be inspected. This happens after call to `setInspectMode` or when user manually inspects an element.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: inspectNodeRequestedEvent, session_id: Optional[str]).
+        """
+        self.client.on('Overlay.inspectNodeRequested', callback)
+    def on_node_highlight_requested(self, callback: Callable[[nodeHighlightRequestedEvent,Optional[str]], None]=None) -> None:
+        """
+    Fired when the node should be highlighted. This happens after call to `setInspectMode`.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: nodeHighlightRequestedEvent, session_id: Optional[str]).
+        """
+        self.client.on('Overlay.nodeHighlightRequested', callback)
+    def on_screenshot_requested(self, callback: Callable[[screenshotRequestedEvent,Optional[str]], None]=None) -> None:
+        """
+    Fired when user asks to capture screenshot of some area on the page.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: screenshotRequestedEvent, session_id: Optional[str]).
+        """
+        self.client.on('Overlay.screenshotRequested', callback)
+    def on_inspect_mode_canceled(self, callback: Callable[[inspectModeCanceledEvent,Optional[str]], None]=None) -> None:
+        """
+    Fired when user cancels the inspect mode.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: inspectModeCanceledEvent, session_id: Optional[str]).
+        """
+        self.client.on('Overlay.inspectModeCanceled', callback)

cdp/protocol/overlay/events/types.py

@@ -0,0 +1,20 @@
+"""CDP Overlay 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.dom.types import NodeId
+    from cdp.protocol.page.types import Viewport
+
+class inspectNodeRequestedEvent(TypedDict, total=True):
+    backendNodeId: 'BackendNodeId'
+    """Id of the node to inspect."""
+class nodeHighlightRequestedEvent(TypedDict, total=True):
+    nodeId: 'NodeId'
+class screenshotRequestedEvent(TypedDict, total=True):
+    viewport: 'Viewport'
+    """Viewport to capture, in device independent pixels (dip)."""
+class inspectModeCanceledEvent(TypedDict, total=True):
+    pass

cdp/protocol/overlay/methods/service.py

@@ -0,0 +1,307 @@
+"""CDP Overlay Domain Methods"""
+from ..types import *
+from .types import *
+from typing import Optional, Dict, Any, Callable, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ....service import Client
+
+class OverlayMethods:
+    """
+    Methods for the Overlay domain.
+    """
+    def __init__(self, client: "Client"):
+        """
+        Initialize the Overlay methods.
+        
+        Args:
+            client ("Client"): The parent CDP client instance.
+        """
+        self.client = client
+
+    async def disable(self, params: None=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Disables domain notifications.    
+        Args:
+            params (None, optional): Parameters for the disable method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the disable call.
+        """
+        return await self.client.send(method="Overlay.disable", params=params,session_id=session_id)
+    async def enable(self, params: None=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Enables domain notifications.    
+        Args:
+            params (None, optional): Parameters for the enable method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the enable call.
+        """
+        return await self.client.send(method="Overlay.enable", params=params,session_id=session_id)
+    async def get_highlight_object_for_test(self, params: Optional[getHighlightObjectForTestParameters]=None,session_id: Optional[str] = None) -> getHighlightObjectForTestReturns:
+        """
+    For testing.    
+        Args:
+            params (getHighlightObjectForTestParameters, optional): Parameters for the getHighlightObjectForTest method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    getHighlightObjectForTestReturns: The result of the getHighlightObjectForTest call.
+        """
+        return await self.client.send(method="Overlay.getHighlightObjectForTest", params=params,session_id=session_id)
+    async def get_grid_highlight_objects_for_test(self, params: Optional[getGridHighlightObjectsForTestParameters]=None,session_id: Optional[str] = None) -> getGridHighlightObjectsForTestReturns:
+        """
+    For Persistent Grid testing.    
+        Args:
+            params (getGridHighlightObjectsForTestParameters, optional): Parameters for the getGridHighlightObjectsForTest method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    getGridHighlightObjectsForTestReturns: The result of the getGridHighlightObjectsForTest call.
+        """
+        return await self.client.send(method="Overlay.getGridHighlightObjectsForTest", params=params,session_id=session_id)
+    async def get_source_order_highlight_object_for_test(self, params: Optional[getSourceOrderHighlightObjectForTestParameters]=None,session_id: Optional[str] = None) -> getSourceOrderHighlightObjectForTestReturns:
+        """
+    For Source Order Viewer testing.    
+        Args:
+            params (getSourceOrderHighlightObjectForTestParameters, optional): Parameters for the getSourceOrderHighlightObjectForTest method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    getSourceOrderHighlightObjectForTestReturns: The result of the getSourceOrderHighlightObjectForTest call.
+        """
+        return await self.client.send(method="Overlay.getSourceOrderHighlightObjectForTest", params=params,session_id=session_id)
+    async def hide_highlight(self, params: None=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Hides any highlight.    
+        Args:
+            params (None, optional): Parameters for the hideHighlight method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the hideHighlight call.
+        """
+        return await self.client.send(method="Overlay.hideHighlight", params=params,session_id=session_id)
+    async def highlight_node(self, params: Optional[highlightNodeParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Highlights DOM node with given id or with the given JavaScript object wrapper. Either nodeId or objectId must be specified.    
+        Args:
+            params (highlightNodeParameters, optional): Parameters for the highlightNode method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the highlightNode call.
+        """
+        return await self.client.send(method="Overlay.highlightNode", params=params,session_id=session_id)
+    async def highlight_quad(self, params: Optional[highlightQuadParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Highlights given quad. Coordinates are absolute with respect to the main frame viewport.    
+        Args:
+            params (highlightQuadParameters, optional): Parameters for the highlightQuad method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the highlightQuad call.
+        """
+        return await self.client.send(method="Overlay.highlightQuad", params=params,session_id=session_id)
+    async def highlight_rect(self, params: Optional[highlightRectParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Highlights given rectangle. Coordinates are absolute with respect to the main frame viewport. Issue: the method does not handle device pixel ratio (DPR) correctly. The coordinates currently have to be adjusted by the client if DPR is not 1 (see crbug.com/437807128).    
+        Args:
+            params (highlightRectParameters, optional): Parameters for the highlightRect method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the highlightRect call.
+        """
+        return await self.client.send(method="Overlay.highlightRect", params=params,session_id=session_id)
+    async def highlight_source_order(self, params: Optional[highlightSourceOrderParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Highlights the source order of the children of the DOM node with given id or with the given JavaScript object wrapper. Either nodeId or objectId must be specified.    
+        Args:
+            params (highlightSourceOrderParameters, optional): Parameters for the highlightSourceOrder method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the highlightSourceOrder call.
+        """
+        return await self.client.send(method="Overlay.highlightSourceOrder", params=params,session_id=session_id)
+    async def set_inspect_mode(self, params: Optional[setInspectModeParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Enters the 'inspect' mode. In this mode, elements that user is hovering over are highlighted. Backend then generates 'inspectNodeRequested' event upon element selection.    
+        Args:
+            params (setInspectModeParameters, optional): Parameters for the setInspectMode method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the setInspectMode call.
+        """
+        return await self.client.send(method="Overlay.setInspectMode", params=params,session_id=session_id)
+    async def set_show_ad_highlights(self, params: Optional[setShowAdHighlightsParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Highlights owner element of all frames detected to be ads.    
+        Args:
+            params (setShowAdHighlightsParameters, optional): Parameters for the setShowAdHighlights method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the setShowAdHighlights call.
+        """
+        return await self.client.send(method="Overlay.setShowAdHighlights", params=params,session_id=session_id)
+    async def set_paused_in_debugger_message(self, params: Optional[setPausedInDebuggerMessageParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    No description available for setPausedInDebuggerMessage.    
+        Args:
+            params (setPausedInDebuggerMessageParameters, optional): Parameters for the setPausedInDebuggerMessage method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the setPausedInDebuggerMessage call.
+        """
+        return await self.client.send(method="Overlay.setPausedInDebuggerMessage", params=params,session_id=session_id)
+    async def set_show_debug_borders(self, params: Optional[setShowDebugBordersParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Requests that backend shows debug borders on layers    
+        Args:
+            params (setShowDebugBordersParameters, optional): Parameters for the setShowDebugBorders method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the setShowDebugBorders call.
+        """
+        return await self.client.send(method="Overlay.setShowDebugBorders", params=params,session_id=session_id)
+    async def set_show_fps_counter(self, params: Optional[setShowFPSCounterParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Requests that backend shows the FPS counter    
+        Args:
+            params (setShowFPSCounterParameters, optional): Parameters for the setShowFPSCounter method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the setShowFPSCounter call.
+        """
+        return await self.client.send(method="Overlay.setShowFPSCounter", params=params,session_id=session_id)
+    async def set_show_grid_overlays(self, params: Optional[setShowGridOverlaysParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Highlight multiple elements with the CSS Grid overlay.    
+        Args:
+            params (setShowGridOverlaysParameters, optional): Parameters for the setShowGridOverlays method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the setShowGridOverlays call.
+        """
+        return await self.client.send(method="Overlay.setShowGridOverlays", params=params,session_id=session_id)
+    async def set_show_flex_overlays(self, params: Optional[setShowFlexOverlaysParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    No description available for setShowFlexOverlays.    
+        Args:
+            params (setShowFlexOverlaysParameters, optional): Parameters for the setShowFlexOverlays method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the setShowFlexOverlays call.
+        """
+        return await self.client.send(method="Overlay.setShowFlexOverlays", params=params,session_id=session_id)
+    async def set_show_scroll_snap_overlays(self, params: Optional[setShowScrollSnapOverlaysParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    No description available for setShowScrollSnapOverlays.    
+        Args:
+            params (setShowScrollSnapOverlaysParameters, optional): Parameters for the setShowScrollSnapOverlays method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the setShowScrollSnapOverlays call.
+        """
+        return await self.client.send(method="Overlay.setShowScrollSnapOverlays", params=params,session_id=session_id)
+    async def set_show_container_query_overlays(self, params: Optional[setShowContainerQueryOverlaysParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    No description available for setShowContainerQueryOverlays.    
+        Args:
+            params (setShowContainerQueryOverlaysParameters, optional): Parameters for the setShowContainerQueryOverlays method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the setShowContainerQueryOverlays call.
+        """
+        return await self.client.send(method="Overlay.setShowContainerQueryOverlays", params=params,session_id=session_id)
+    async def set_show_paint_rects(self, params: Optional[setShowPaintRectsParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Requests that backend shows paint rectangles    
+        Args:
+            params (setShowPaintRectsParameters, optional): Parameters for the setShowPaintRects method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the setShowPaintRects call.
+        """
+        return await self.client.send(method="Overlay.setShowPaintRects", params=params,session_id=session_id)
+    async def set_show_layout_shift_regions(self, params: Optional[setShowLayoutShiftRegionsParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Requests that backend shows layout shift regions    
+        Args:
+            params (setShowLayoutShiftRegionsParameters, optional): Parameters for the setShowLayoutShiftRegions method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the setShowLayoutShiftRegions call.
+        """
+        return await self.client.send(method="Overlay.setShowLayoutShiftRegions", params=params,session_id=session_id)
+    async def set_show_scroll_bottleneck_rects(self, params: Optional[setShowScrollBottleneckRectsParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Requests that backend shows scroll bottleneck rects    
+        Args:
+            params (setShowScrollBottleneckRectsParameters, optional): Parameters for the setShowScrollBottleneckRects method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the setShowScrollBottleneckRects call.
+        """
+        return await self.client.send(method="Overlay.setShowScrollBottleneckRects", params=params,session_id=session_id)
+    async def set_show_viewport_size_on_resize(self, params: Optional[setShowViewportSizeOnResizeParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Paints viewport size upon main frame resize.    
+        Args:
+            params (setShowViewportSizeOnResizeParameters, optional): Parameters for the setShowViewportSizeOnResize method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the setShowViewportSizeOnResize call.
+        """
+        return await self.client.send(method="Overlay.setShowViewportSizeOnResize", params=params,session_id=session_id)
+    async def set_show_hinge(self, params: Optional[setShowHingeParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Add a dual screen device hinge    
+        Args:
+            params (setShowHingeParameters, optional): Parameters for the setShowHinge method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the setShowHinge call.
+        """
+        return await self.client.send(method="Overlay.setShowHinge", params=params,session_id=session_id)
+    async def set_show_isolated_elements(self, params: Optional[setShowIsolatedElementsParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Show elements in isolation mode with overlays.    
+        Args:
+            params (setShowIsolatedElementsParameters, optional): Parameters for the setShowIsolatedElements method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the setShowIsolatedElements call.
+        """
+        return await self.client.send(method="Overlay.setShowIsolatedElements", params=params,session_id=session_id)
+    async def set_show_window_controls_overlay(self, params: Optional[setShowWindowControlsOverlayParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Show Window Controls Overlay for PWA    
+        Args:
+            params (setShowWindowControlsOverlayParameters, optional): Parameters for the setShowWindowControlsOverlay method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the setShowWindowControlsOverlay call.
+        """
+        return await self.client.send(method="Overlay.setShowWindowControlsOverlay", params=params,session_id=session_id)

cdp/protocol/overlay/methods/types.py

@@ -0,0 +1,144 @@
+"""CDP Overlay Methods 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 BackendNodeId
+    from cdp.protocol.dom.types import NodeId
+    from cdp.protocol.dom.types import Quad
+    from cdp.protocol.dom.types import RGBA
+    from cdp.protocol.overlay.types import ColorFormat
+    from cdp.protocol.overlay.types import ContainerQueryHighlightConfig
+    from cdp.protocol.overlay.types import FlexNodeHighlightConfig
+    from cdp.protocol.overlay.types import GridNodeHighlightConfig
+    from cdp.protocol.overlay.types import HighlightConfig
+    from cdp.protocol.overlay.types import HingeConfig
+    from cdp.protocol.overlay.types import InspectMode
+    from cdp.protocol.overlay.types import IsolatedElementHighlightConfig
+    from cdp.protocol.overlay.types import ScrollSnapHighlightConfig
+    from cdp.protocol.overlay.types import SourceOrderConfig
+    from cdp.protocol.overlay.types import WindowControlsOverlayConfig
+    from cdp.protocol.runtime.types import RemoteObjectId
+
+
+
+class getHighlightObjectForTestParameters(TypedDict, total=True):
+    nodeId: 'NodeId'
+    """Id of the node to get highlight object for."""
+    includeDistance: NotRequired['bool']
+    """Whether to include distance info."""
+    includeStyle: NotRequired['bool']
+    """Whether to include style info."""
+    colorFormat: NotRequired['ColorFormat']
+    """The color format to get config with (default: hex)."""
+    showAccessibilityInfo: NotRequired['bool']
+    """Whether to show accessibility info (default: true)."""
+class getGridHighlightObjectsForTestParameters(TypedDict, total=True):
+    nodeIds: 'List[NodeId]'
+    """Ids of the node to get highlight object for."""
+class getSourceOrderHighlightObjectForTestParameters(TypedDict, total=True):
+    nodeId: 'NodeId'
+    """Id of the node to highlight."""
+
+class highlightNodeParameters(TypedDict, total=True):
+    highlightConfig: 'HighlightConfig'
+    """A descriptor for the highlight appearance."""
+    nodeId: NotRequired['NodeId']
+    """Identifier of the node to highlight."""
+    backendNodeId: NotRequired['BackendNodeId']
+    """Identifier of the backend node to highlight."""
+    objectId: NotRequired['RemoteObjectId']
+    """JavaScript object id of the node to be highlighted."""
+    selector: NotRequired['str']
+    """Selectors to highlight relevant nodes."""
+class highlightQuadParameters(TypedDict, total=True):
+    quad: 'Quad'
+    """Quad to highlight"""
+    color: NotRequired['RGBA']
+    """The highlight fill color (default: transparent)."""
+    outlineColor: NotRequired['RGBA']
+    """The highlight outline color (default: transparent)."""
+class highlightRectParameters(TypedDict, total=True):
+    x: 'int'
+    """X coordinate"""
+    y: 'int'
+    """Y coordinate"""
+    width: 'int'
+    """Rectangle width"""
+    height: 'int'
+    """Rectangle height"""
+    color: NotRequired['RGBA']
+    """The highlight fill color (default: transparent)."""
+    outlineColor: NotRequired['RGBA']
+    """The highlight outline color (default: transparent)."""
+class highlightSourceOrderParameters(TypedDict, total=True):
+    sourceOrderConfig: 'SourceOrderConfig'
+    """A descriptor for the appearance of the overlay drawing."""
+    nodeId: NotRequired['NodeId']
+    """Identifier of the node to highlight."""
+    backendNodeId: NotRequired['BackendNodeId']
+    """Identifier of the backend node to highlight."""
+    objectId: NotRequired['RemoteObjectId']
+    """JavaScript object id of the node to be highlighted."""
+class setInspectModeParameters(TypedDict, total=True):
+    mode: 'InspectMode'
+    """Set an inspection mode."""
+    highlightConfig: NotRequired['HighlightConfig']
+    """A descriptor for the highlight appearance of hovered-over nodes. May be omitted if enabled == false."""
+class setShowAdHighlightsParameters(TypedDict, total=True):
+    show: 'bool'
+    """True for showing ad highlights"""
+class setPausedInDebuggerMessageParameters(TypedDict, total=False):
+    message: NotRequired['str']
+    """The message to display, also triggers resume and step over controls."""
+class setShowDebugBordersParameters(TypedDict, total=True):
+    show: 'bool'
+    """True for showing debug borders"""
+class setShowFPSCounterParameters(TypedDict, total=True):
+    show: 'bool'
+    """True for showing the FPS counter"""
+class setShowGridOverlaysParameters(TypedDict, total=True):
+    gridNodeHighlightConfigs: 'List[GridNodeHighlightConfig]'
+    """An array of node identifiers and descriptors for the highlight appearance."""
+class setShowFlexOverlaysParameters(TypedDict, total=True):
+    flexNodeHighlightConfigs: 'List[FlexNodeHighlightConfig]'
+    """An array of node identifiers and descriptors for the highlight appearance."""
+class setShowScrollSnapOverlaysParameters(TypedDict, total=True):
+    scrollSnapHighlightConfigs: 'List[ScrollSnapHighlightConfig]'
+    """An array of node identifiers and descriptors for the highlight appearance."""
+class setShowContainerQueryOverlaysParameters(TypedDict, total=True):
+    containerQueryHighlightConfigs: 'List[ContainerQueryHighlightConfig]'
+    """An array of node identifiers and descriptors for the highlight appearance."""
+class setShowPaintRectsParameters(TypedDict, total=True):
+    result: 'bool'
+    """True for showing paint rectangles"""
+class setShowLayoutShiftRegionsParameters(TypedDict, total=True):
+    result: 'bool'
+    """True for showing layout shift regions"""
+class setShowScrollBottleneckRectsParameters(TypedDict, total=True):
+    show: 'bool'
+    """True for showing scroll bottleneck rects"""
+class setShowViewportSizeOnResizeParameters(TypedDict, total=True):
+    show: 'bool'
+    """Whether to paint size or not."""
+class setShowHingeParameters(TypedDict, total=False):
+    hingeConfig: NotRequired['HingeConfig']
+    """hinge data, null means hideHinge"""
+class setShowIsolatedElementsParameters(TypedDict, total=True):
+    isolatedElementHighlightConfigs: 'List[IsolatedElementHighlightConfig]'
+    """An array of node identifiers and descriptors for the highlight appearance."""
+class setShowWindowControlsOverlayParameters(TypedDict, total=False):
+    windowControlsOverlayConfig: NotRequired['WindowControlsOverlayConfig']
+    """Window Controls Overlay data, null means hide Window Controls Overlay"""
+
+
+class getHighlightObjectForTestReturns(TypedDict):
+    highlight: 'Dict[str, Any]'
+    """Highlight data for the node."""
+class getGridHighlightObjectsForTestReturns(TypedDict):
+    highlights: 'Dict[str, Any]'
+    """Grid Highlight data for the node ids provided."""
+class getSourceOrderHighlightObjectForTestReturns(TypedDict):
+    highlight: 'Dict[str, Any]'
+    """Source order highlight data for the node id provided."""

cdp/protocol/overlay/service.py

@@ -0,0 +1,21 @@
+"""CDP Overlay Domain"""
+from typing import TYPE_CHECKING
+from .methods.service import OverlayMethods
+from .events.service import OverlayEvents
+
+if TYPE_CHECKING:
+    from ...service import Client
+
+class Overlay(OverlayMethods, OverlayEvents):
+    """
+    This domain provides various functionality related to drawing atop the inspected page.
+    """
+    def __init__(self, client: "Client"):
+        """
+        Initialize the Overlay domain.
+        
+        Args:
+            client ("Client"): The parent CDP client instance.
+        """
+        OverlayMethods.__init__(self, client)
+        OverlayEvents.__init__(self, client)