chromedeveloperprotocol-client 0.1.0__py3-none-any.whl

cdp/protocol/dom_debugger/methods/service.py

@@ -0,0 +1,109 @@
+"""CDP DOMDebugger 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 DOMDebuggerMethods:
+    """
+    Methods for the DOMDebugger domain.
+    """
+    def __init__(self, client: "Client"):
+        """
+        Initialize the DOMDebugger methods.
+        
+        Args:
+            client ("Client"): The parent CDP client instance.
+        """
+        self.client = client
+
+    async def get_event_listeners(self, params: Optional[getEventListenersParameters]=None,session_id: Optional[str] = None) -> getEventListenersReturns:
+        """
+    Returns event listeners of the given object.    
+        Args:
+            params (getEventListenersParameters, optional): Parameters for the getEventListeners method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    getEventListenersReturns: The result of the getEventListeners call.
+        """
+        return await self.client.send(method="DOMDebugger.getEventListeners", params=params,session_id=session_id)
+    async def remove_dom_breakpoint(self, params: Optional[removeDOMBreakpointParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Removes DOM breakpoint that was set using `setDOMBreakpoint`.    
+        Args:
+            params (removeDOMBreakpointParameters, optional): Parameters for the removeDOMBreakpoint method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the removeDOMBreakpoint call.
+        """
+        return await self.client.send(method="DOMDebugger.removeDOMBreakpoint", params=params,session_id=session_id)
+    async def remove_event_listener_breakpoint(self, params: Optional[removeEventListenerBreakpointParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Removes breakpoint on particular DOM event.    
+        Args:
+            params (removeEventListenerBreakpointParameters, optional): Parameters for the removeEventListenerBreakpoint method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the removeEventListenerBreakpoint call.
+        """
+        return await self.client.send(method="DOMDebugger.removeEventListenerBreakpoint", params=params,session_id=session_id)
+    async def remove_xhr_breakpoint(self, params: Optional[removeXHRBreakpointParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Removes breakpoint from XMLHttpRequest.    
+        Args:
+            params (removeXHRBreakpointParameters, optional): Parameters for the removeXHRBreakpoint method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the removeXHRBreakpoint call.
+        """
+        return await self.client.send(method="DOMDebugger.removeXHRBreakpoint", params=params,session_id=session_id)
+    async def set_break_on_csp_violation(self, params: Optional[setBreakOnCSPViolationParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Sets breakpoint on particular CSP violations.    
+        Args:
+            params (setBreakOnCSPViolationParameters, optional): Parameters for the setBreakOnCSPViolation method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the setBreakOnCSPViolation call.
+        """
+        return await self.client.send(method="DOMDebugger.setBreakOnCSPViolation", params=params,session_id=session_id)
+    async def set_dom_breakpoint(self, params: Optional[setDOMBreakpointParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Sets breakpoint on particular operation with DOM.    
+        Args:
+            params (setDOMBreakpointParameters, optional): Parameters for the setDOMBreakpoint method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the setDOMBreakpoint call.
+        """
+        return await self.client.send(method="DOMDebugger.setDOMBreakpoint", params=params,session_id=session_id)
+    async def set_event_listener_breakpoint(self, params: Optional[setEventListenerBreakpointParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Sets breakpoint on particular DOM event.    
+        Args:
+            params (setEventListenerBreakpointParameters, optional): Parameters for the setEventListenerBreakpoint method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the setEventListenerBreakpoint call.
+        """
+        return await self.client.send(method="DOMDebugger.setEventListenerBreakpoint", params=params,session_id=session_id)
+    async def set_xhr_breakpoint(self, params: Optional[setXHRBreakpointParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Sets breakpoint on XMLHttpRequest.    
+        Args:
+            params (setXHRBreakpointParameters, optional): Parameters for the setXHRBreakpoint method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the setXHRBreakpoint call.
+        """
+        return await self.client.send(method="DOMDebugger.setXHRBreakpoint", params=params,session_id=session_id)

cdp/protocol/dom_debugger/methods/types.py

@@ -0,0 +1,51 @@
+"""CDP DOMDebugger 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 NodeId
+    from cdp.protocol.dom_debugger.types import CSPViolationType
+    from cdp.protocol.dom_debugger.types import DOMBreakpointType
+    from cdp.protocol.dom_debugger.types import EventListener
+    from cdp.protocol.runtime.types import RemoteObjectId
+
+class getEventListenersParameters(TypedDict, total=True):
+    objectId: 'RemoteObjectId'
+    """Identifier of the object to return listeners for."""
+    depth: NotRequired['int']
+    """The maximum depth at which Node children should be retrieved, defaults to 1. Use -1 for the entire subtree or provide an integer larger than 0."""
+    pierce: NotRequired['bool']
+    """Whether or not iframes and shadow roots should be traversed when returning the subtree (default is false). Reports listeners for all contexts if pierce is enabled."""
+class removeDOMBreakpointParameters(TypedDict, total=True):
+    nodeId: 'NodeId'
+    """Identifier of the node to remove breakpoint from."""
+    type: 'DOMBreakpointType'
+    """Type of the breakpoint to remove."""
+class removeEventListenerBreakpointParameters(TypedDict, total=True):
+    eventName: 'str'
+    """Event name."""
+    targetName: NotRequired['str']
+    """EventTarget interface name."""
+class removeXHRBreakpointParameters(TypedDict, total=True):
+    url: 'str'
+    """Resource URL substring."""
+class setBreakOnCSPViolationParameters(TypedDict, total=True):
+    violationTypes: 'List[CSPViolationType]'
+    """CSP Violations to stop upon."""
+class setDOMBreakpointParameters(TypedDict, total=True):
+    nodeId: 'NodeId'
+    """Identifier of the node to set breakpoint on."""
+    type: 'DOMBreakpointType'
+    """Type of the operation to stop upon."""
+class setEventListenerBreakpointParameters(TypedDict, total=True):
+    eventName: 'str'
+    """DOM Event name to stop on (any DOM event will do)."""
+    targetName: NotRequired['str']
+    """EventTarget interface name to stop on. If equal to "*" or not provided, will stop on any EventTarget."""
+class setXHRBreakpointParameters(TypedDict, total=True):
+    url: 'str'
+    """Resource URL substring. All XHRs having this substring in the URL will get stopped upon."""
+class getEventListenersReturns(TypedDict):
+    listeners: 'List[EventListener]'
+    """Array of relevant listeners."""

cdp/protocol/dom_debugger/service.py

@@ -0,0 +1,21 @@
+"""CDP DOMDebugger Domain"""
+from typing import TYPE_CHECKING
+from .methods.service import DOMDebuggerMethods
+from .events.service import DOMDebuggerEvents
+
+if TYPE_CHECKING:
+    from ...service import Client
+
+class DOMDebugger(DOMDebuggerMethods, DOMDebuggerEvents):
+    """
+    DOM debugging allows setting breakpoints on particular DOM operations and events. JavaScript execution will stop on these operations as if there was a regular breakpoint set.
+    """
+    def __init__(self, client: "Client"):
+        """
+        Initialize the DOMDebugger domain.
+        
+        Args:
+            client ("Client"): The parent CDP client instance.
+        """
+        DOMDebuggerMethods.__init__(self, client)
+        DOMDebuggerEvents.__init__(self, client)

cdp/protocol/dom_debugger/types.py

@@ -0,0 +1,36 @@
+"""CDP DOMDebugger 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.runtime.types import RemoteObject
+    from cdp.protocol.runtime.types import ScriptId
+
+DOMBreakpointType = Literal['subtree-modified','attribute-modified','node-removed']
+"""DOM breakpoint type."""
+CSPViolationType = Literal['trustedtype-sink-violation','trustedtype-policy-violation']
+"""CSP Violation type."""
+class EventListener(TypedDict, total=True):
+    """Object event listener."""
+    type: 'str'
+    """EventListener's type."""
+    useCapture: 'bool'
+    """EventListener's useCapture."""
+    passive: 'bool'
+    """EventListener's passive flag."""
+    once: 'bool'
+    """EventListener's once flag."""
+    scriptId: 'ScriptId'
+    """Script id of the handler code."""
+    lineNumber: 'int'
+    """Line number in the script (0-based)."""
+    columnNumber: 'int'
+    """Column number in the script (0-based)."""
+    handler: NotRequired['RemoteObject']
+    """Event handler function value."""
+    originalHandler: NotRequired['RemoteObject']
+    """Event original handler function value."""
+    backendNodeId: NotRequired['BackendNodeId']
+    """Node the listener is added to (if any)."""

cdp/protocol/dom_snapshot/events/service.py

@@ -0,0 +1,20 @@
+"""CDP DOMSnapshot 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 DOMSnapshotEvents:
+    """
+    Events for the DOMSnapshot domain.
+    """
+    def __init__(self, client: "Client"):
+        """
+        Initialize the DOMSnapshot events.
+        
+        Args:
+            client ("Client"): The parent CDP client instance.
+        """
+        self.client = client

cdp/protocol/dom_snapshot/events/types.py

@@ -0,0 +1,3 @@
+"""CDP DOMSnapshot Events"""
+
+from typing import TypedDict, NotRequired, Required, Literal, Any, Dict, Union, Optional, List, Set, Tuple

cdp/protocol/dom_snapshot/methods/service.py

@@ -0,0 +1,54 @@
+"""CDP DOMSnapshot 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 DOMSnapshotMethods:
+    """
+    Methods for the DOMSnapshot domain.
+    """
+    def __init__(self, client: "Client"):
+        """
+        Initialize the DOMSnapshot 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 DOM snapshot agent for the given page.    
+        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="DOMSnapshot.disable", params=params,session_id=session_id)
+    async def enable(self, params: None=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Enables DOM snapshot agent for the given page.    
+        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="DOMSnapshot.enable", params=params,session_id=session_id)
+    async def capture_snapshot(self, params: Optional[captureSnapshotParameters]=None,session_id: Optional[str] = None) -> captureSnapshotReturns:
+        """
+    Returns a document snapshot, including the full DOM tree of the root node (including iframes, template contents, and imported documents) in a flattened array, as well as layout and white-listed computed style information for the nodes. Shadow DOM in the returned DOM tree is flattened.    
+        Args:
+            params (captureSnapshotParameters, optional): Parameters for the captureSnapshot method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    captureSnapshotReturns: The result of the captureSnapshot call.
+        """
+        return await self.client.send(method="DOMSnapshot.captureSnapshot", params=params,session_id=session_id)

cdp/protocol/dom_snapshot/methods/types.py

@@ -0,0 +1,28 @@
+"""CDP DOMSnapshot 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_snapshot.types import DocumentSnapshot
+
+
+
+class captureSnapshotParameters(TypedDict, total=True):
+    computedStyles: 'List[str]'
+    """Whitelist of computed styles to return."""
+    includePaintOrder: NotRequired['bool']
+    """Whether to include layout object paint orders into the snapshot."""
+    includeDOMRects: NotRequired['bool']
+    """Whether to include DOM rectangles (offsetRects, clientRects, scrollRects) into the snapshot"""
+    includeBlendedBackgroundColors: NotRequired['bool']
+    """Whether to include blended background colors in the snapshot (default: false). Blended background color is achieved by blending background colors of all elements that overlap with the current element."""
+    includeTextColorOpacities: NotRequired['bool']
+    """Whether to include text color opacity in the snapshot (default: false). An element might have the opacity property set that affects the text color of the element. The final text color opacity is computed based on the opacity of all overlapping elements."""
+
+
+class captureSnapshotReturns(TypedDict):
+    documents: 'List[DocumentSnapshot]'
+    """The nodes in the DOM tree. The DOMNode at index 0 corresponds to the root document."""
+    strings: 'List[str]'
+    """Shared string table that all string properties refer to with indexes."""

cdp/protocol/dom_snapshot/service.py

@@ -0,0 +1,21 @@
+"""CDP DOMSnapshot Domain"""
+from typing import TYPE_CHECKING
+from .methods.service import DOMSnapshotMethods
+from .events.service import DOMSnapshotEvents
+
+if TYPE_CHECKING:
+    from ...service import Client
+
+class DOMSnapshot(DOMSnapshotMethods, DOMSnapshotEvents):
+    """
+    This domain facilitates obtaining document snapshots with DOM, layout, and style information.
+    """
+    def __init__(self, client: "Client"):
+        """
+        Initialize the DOMSnapshot domain.
+        
+        Args:
+            client ("Client"): The parent CDP client instance.
+        """
+        DOMSnapshotMethods.__init__(self, client)
+        DOMSnapshotEvents.__init__(self, client)

cdp/protocol/dom_snapshot/types.py

@@ -0,0 +1,220 @@
+"""CDP DOMSnapshot 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 PseudoType
+    from cdp.protocol.dom.types import Rect
+    from cdp.protocol.dom.types import ShadowRootType
+    from cdp.protocol.domdebugger.types import EventListener
+    from cdp.protocol.page.types import FrameId
+
+class DOMNode(TypedDict, total=True):
+    """A Node in the DOM tree."""
+    nodeType: 'int'
+    """Node's nodeType."""
+    nodeName: 'str'
+    """Node's nodeName."""
+    nodeValue: 'str'
+    """Node's nodeValue."""
+    backendNodeId: 'BackendNodeId'
+    """Node's id, corresponds to DOM.Node.backendNodeId."""
+    textValue: NotRequired['str']
+    """Only set for textarea elements, contains the text value."""
+    inputValue: NotRequired['str']
+    """Only set for input elements, contains the input's associated text value."""
+    inputChecked: NotRequired['bool']
+    """Only set for radio and checkbox input elements, indicates if the element has been checked"""
+    optionSelected: NotRequired['bool']
+    """Only set for option elements, indicates if the element has been selected"""
+    childNodeIndexes: NotRequired['List[int]']
+    """The indexes of the node's child nodes in the domNodes array returned by getSnapshot, if any."""
+    attributes: NotRequired['List[NameValue]']
+    """Attributes of an Element node."""
+    pseudoElementIndexes: NotRequired['List[int]']
+    """Indexes of pseudo elements associated with this node in the domNodes array returned by getSnapshot, if any."""
+    layoutNodeIndex: NotRequired['int']
+    """The index of the node's related layout tree node in the layoutTreeNodes array returned by getSnapshot, if any."""
+    documentURL: NotRequired['str']
+    """Document URL that Document or FrameOwner node points to."""
+    baseURL: NotRequired['str']
+    """Base URL that Document or FrameOwner node uses for URL completion."""
+    contentLanguage: NotRequired['str']
+    """Only set for documents, contains the document's content language."""
+    documentEncoding: NotRequired['str']
+    """Only set for documents, contains the document's character set encoding."""
+    publicId: NotRequired['str']
+    """DocumentType node's publicId."""
+    systemId: NotRequired['str']
+    """DocumentType node's systemId."""
+    frameId: NotRequired['FrameId']
+    """Frame ID for frame owner elements and also for the document node."""
+    contentDocumentIndex: NotRequired['int']
+    """The index of a frame owner element's content document in the domNodes array returned by getSnapshot, if any."""
+    pseudoType: NotRequired['PseudoType']
+    """Type of a pseudo element node."""
+    shadowRootType: NotRequired['ShadowRootType']
+    """Shadow root type."""
+    isClickable: NotRequired['bool']
+    """Whether this DOM node responds to mouse clicks. This includes nodes that have had click event listeners attached via JavaScript as well as anchor tags that naturally navigate when clicked."""
+    eventListeners: NotRequired['List[EventListener]']
+    """Details of the node's event listeners, if any."""
+    currentSourceURL: NotRequired['str']
+    """The selected url for nodes with a srcset attribute."""
+    originURL: NotRequired['str']
+    """The url of the script (if any) that generates this node."""
+    scrollOffsetX: NotRequired['float']
+    """Scroll offsets, set when this node is a Document."""
+    scrollOffsetY: NotRequired['float']
+class InlineTextBox(TypedDict, total=True):
+    """Details of post layout rendered text positions. The exact layout should not be regarded as stable and may change between versions."""
+    boundingBox: 'Rect'
+    """The bounding box in document coordinates. Note that scroll offset of the document is ignored."""
+    startCharacterIndex: 'int'
+    """The starting index in characters, for this post layout textbox substring. Characters that would be represented as a surrogate pair in UTF-16 have length 2."""
+    numCharacters: 'int'
+    """The number of characters in this post layout textbox substring. Characters that would be represented as a surrogate pair in UTF-16 have length 2."""
+class LayoutTreeNode(TypedDict, total=True):
+    """Details of an element in the DOM tree with a LayoutObject."""
+    domNodeIndex: 'int'
+    """The index of the related DOM node in the domNodes array returned by getSnapshot."""
+    boundingBox: 'Rect'
+    """The bounding box in document coordinates. Note that scroll offset of the document is ignored."""
+    layoutText: NotRequired['str']
+    """Contents of the LayoutText, if any."""
+    inlineTextNodes: NotRequired['List[InlineTextBox]']
+    """The post-layout inline text nodes, if any."""
+    styleIndex: NotRequired['int']
+    """Index into the computedStyles array returned by getSnapshot."""
+    paintOrder: NotRequired['int']
+    """Global paint order index, which is determined by the stacking order of the nodes. Nodes that are painted together will have the same index. Only provided if includePaintOrder in getSnapshot was true."""
+    isStackingContext: NotRequired['bool']
+    """Set to true to indicate the element begins a new stacking context."""
+class ComputedStyle(TypedDict, total=True):
+    """A subset of the full ComputedStyle as defined by the request whitelist."""
+    properties: 'List[NameValue]'
+    """Name/value pairs of computed style properties."""
+class NameValue(TypedDict, total=True):
+    """A name/value pair."""
+    name: 'str'
+    """Attribute/property name."""
+    value: 'str'
+    """Attribute/property value."""
+StringIndex = int
+"""Index of the string in the strings table."""
+ArrayOfStrings = List['StringIndex']
+"""Index of the string in the strings table."""
+class RareStringData(TypedDict, total=True):
+    """Data that is only present on rare nodes."""
+    index: 'List[int]'
+    value: 'List[StringIndex]'
+class RareBooleanData(TypedDict, total=True):
+    index: 'List[int]'
+class RareIntegerData(TypedDict, total=True):
+    index: 'List[int]'
+    value: 'List[int]'
+Rectangle = List['float']
+class DocumentSnapshot(TypedDict, total=True):
+    """Document snapshot."""
+    documentURL: 'StringIndex'
+    """Document URL that Document or FrameOwner node points to."""
+    title: 'StringIndex'
+    """Document title."""
+    baseURL: 'StringIndex'
+    """Base URL that Document or FrameOwner node uses for URL completion."""
+    contentLanguage: 'StringIndex'
+    """Contains the document's content language."""
+    encodingName: 'StringIndex'
+    """Contains the document's character set encoding."""
+    publicId: 'StringIndex'
+    """DocumentType node's publicId."""
+    systemId: 'StringIndex'
+    """DocumentType node's systemId."""
+    frameId: 'StringIndex'
+    """Frame ID for frame owner elements and also for the document node."""
+    nodes: 'NodeTreeSnapshot'
+    """A table with dom nodes."""
+    layout: 'LayoutTreeSnapshot'
+    """The nodes in the layout tree."""
+    textBoxes: 'TextBoxSnapshot'
+    """The post-layout inline text nodes."""
+    scrollOffsetX: NotRequired['float']
+    """Horizontal scroll offset."""
+    scrollOffsetY: NotRequired['float']
+    """Vertical scroll offset."""
+    contentWidth: NotRequired['float']
+    """Document content width."""
+    contentHeight: NotRequired['float']
+    """Document content height."""
+class NodeTreeSnapshot(TypedDict, total=False):
+    """Table containing nodes."""
+    parentIndex: NotRequired['List[int]']
+    """Parent node index."""
+    nodeType: NotRequired['List[int]']
+    """Node's nodeType."""
+    shadowRootType: NotRequired['RareStringData']
+    """Type of the shadow root the Node is in. String values are equal to the ShadowRootType enum."""
+    nodeName: NotRequired['List[StringIndex]']
+    """Node's nodeName."""
+    nodeValue: NotRequired['List[StringIndex]']
+    """Node's nodeValue."""
+    backendNodeId: NotRequired['List[BackendNodeId]']
+    """Node's id, corresponds to DOM.Node.backendNodeId."""
+    attributes: NotRequired['List[ArrayOfStrings]']
+    """Attributes of an Element node. Flatten name, value pairs."""
+    textValue: NotRequired['RareStringData']
+    """Only set for textarea elements, contains the text value."""
+    inputValue: NotRequired['RareStringData']
+    """Only set for input elements, contains the input's associated text value."""
+    inputChecked: NotRequired['RareBooleanData']
+    """Only set for radio and checkbox input elements, indicates if the element has been checked"""
+    optionSelected: NotRequired['RareBooleanData']
+    """Only set for option elements, indicates if the element has been selected"""
+    contentDocumentIndex: NotRequired['RareIntegerData']
+    """The index of the document in the list of the snapshot documents."""
+    pseudoType: NotRequired['RareStringData']
+    """Type of a pseudo element node."""
+    pseudoIdentifier: NotRequired['RareStringData']
+    """Pseudo element identifier for this node. Only present if there is a valid pseudoType."""
+    isClickable: NotRequired['RareBooleanData']
+    """Whether this DOM node responds to mouse clicks. This includes nodes that have had click event listeners attached via JavaScript as well as anchor tags that naturally navigate when clicked."""
+    currentSourceURL: NotRequired['RareStringData']
+    """The selected url for nodes with a srcset attribute."""
+    originURL: NotRequired['RareStringData']
+    """The url of the script (if any) that generates this node."""
+class LayoutTreeSnapshot(TypedDict, total=True):
+    """Table of details of an element in the DOM tree with a LayoutObject."""
+    nodeIndex: 'List[int]'
+    """Index of the corresponding node in the NodeTreeSnapshot array returned by captureSnapshot."""
+    styles: 'List[ArrayOfStrings]'
+    """Array of indexes specifying computed style strings, filtered according to the computedStyles parameter passed to captureSnapshot."""
+    bounds: 'List[Rectangle]'
+    """The absolute position bounding box."""
+    text: 'List[StringIndex]'
+    """Contents of the LayoutText, if any."""
+    stackingContexts: 'RareBooleanData'
+    """Stacking context information."""
+    paintOrders: NotRequired['List[int]']
+    """Global paint order index, which is determined by the stacking order of the nodes. Nodes that are painted together will have the same index. Only provided if includePaintOrder in captureSnapshot was true."""
+    offsetRects: NotRequired['List[Rectangle]']
+    """The offset rect of nodes. Only available when includeDOMRects is set to true"""
+    scrollRects: NotRequired['List[Rectangle]']
+    """The scroll rect of nodes. Only available when includeDOMRects is set to true"""
+    clientRects: NotRequired['List[Rectangle]']
+    """The client rect of nodes. Only available when includeDOMRects is set to true"""
+    blendedBackgroundColors: NotRequired['List[StringIndex]']
+    """The list of background colors that are blended with colors of overlapping elements."""
+    textColorOpacities: NotRequired['List[float]']
+    """The list of computed text opacities."""
+class TextBoxSnapshot(TypedDict, total=True):
+    """Table of details of the post layout rendered text positions. The exact layout should not be regarded as stable and may change between versions."""
+    layoutIndex: 'List[int]'
+    """Index of the layout tree node that owns this box collection."""
+    bounds: 'List[Rectangle]'
+    """The absolute position bounding box."""
+    start: 'List[int]'
+    """The starting index in characters, for this post layout textbox substring. Characters that would be represented as a surrogate pair in UTF-16 have length 2."""
+    length: 'List[int]'
+    """The number of characters in this post layout textbox substring. Characters that would be represented as a surrogate pair in UTF-16 have length 2."""

cdp/protocol/dom_storage/events/service.py

@@ -0,0 +1,53 @@
+"""CDP DOMStorage 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 DOMStorageEvents:
+    """
+    Events for the DOMStorage domain.
+    """
+    def __init__(self, client: "Client"):
+        """
+        Initialize the DOMStorage events.
+        
+        Args:
+            client ("Client"): The parent CDP client instance.
+        """
+        self.client = client
+
+    def on_dom_storage_item_added(self, callback: Callable[[domStorageItemAddedEvent,Optional[str]], None]=None) -> None:
+        """
+    No description available for domStorageItemAdded.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: domStorageItemAddedEvent, session_id: Optional[str]).
+        """
+        self.client.on('DOMStorage.domStorageItemAdded', callback)
+    def on_dom_storage_item_removed(self, callback: Callable[[domStorageItemRemovedEvent,Optional[str]], None]=None) -> None:
+        """
+    No description available for domStorageItemRemoved.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: domStorageItemRemovedEvent, session_id: Optional[str]).
+        """
+        self.client.on('DOMStorage.domStorageItemRemoved', callback)
+    def on_dom_storage_item_updated(self, callback: Callable[[domStorageItemUpdatedEvent,Optional[str]], None]=None) -> None:
+        """
+    No description available for domStorageItemUpdated.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: domStorageItemUpdatedEvent, session_id: Optional[str]).
+        """
+        self.client.on('DOMStorage.domStorageItemUpdated', callback)
+    def on_dom_storage_items_cleared(self, callback: Callable[[domStorageItemsClearedEvent,Optional[str]], None]=None) -> None:
+        """
+    No description available for domStorageItemsCleared.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: domStorageItemsClearedEvent, session_id: Optional[str]).
+        """
+        self.client.on('DOMStorage.domStorageItemsCleared', callback)