chromedeveloperprotocol-client 0.1.0__py3-none-any.whl

cdp/protocol/debugger/types.py

@@ -0,0 +1,91 @@
+"""CDP Debugger 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.runtime.types import RemoteObject
+    from cdp.protocol.runtime.types import ScriptId
+
+BreakpointId = str
+"""Breakpoint identifier."""
+CallFrameId = str
+"""Call frame identifier."""
+class Location(TypedDict, total=True):
+    """Location in the source code."""
+    scriptId: 'ScriptId'
+    """Script identifier as reported in the Debugger.scriptParsed."""
+    lineNumber: 'int'
+    """Line number in the script (0-based)."""
+    columnNumber: NotRequired['int']
+    """Column number in the script (0-based)."""
+class ScriptPosition(TypedDict, total=True):
+    """Location in the source code."""
+    lineNumber: 'int'
+    columnNumber: 'int'
+class LocationRange(TypedDict, total=True):
+    """Location range within one script."""
+    scriptId: 'ScriptId'
+    start: 'ScriptPosition'
+    end: 'ScriptPosition'
+class CallFrame(TypedDict, total=True):
+    """JavaScript call frame. Array of call frames form the call stack."""
+    callFrameId: 'CallFrameId'
+    """Call frame identifier. This identifier is only valid while the virtual machine is paused."""
+    functionName: 'str'
+    """Name of the JavaScript function called on this call frame."""
+    location: 'Location'
+    """Location in the source code."""
+    scopeChain: 'List[Scope]'
+    """Scope chain for this call frame."""
+    this: 'RemoteObject'
+    """this object for this call frame."""
+    functionLocation: NotRequired['Location']
+    """Location in the source code."""
+    returnValue: NotRequired['RemoteObject']
+    """The value being returned, if the function is at return point."""
+    canBeRestarted: NotRequired['bool']
+    """Valid only while the VM is paused and indicates whether this frame can be restarted or not. Note that a true value here does not guarantee that Debugger#restartFrame with this CallFrameId will be successful, but it is very likely."""
+class Scope(TypedDict, total=True):
+    """Scope description."""
+    type: 'Literal["global", "local", "with", "closure", "catch", "block", "script", "eval", "module", "wasm-expression-stack"]'
+    """Scope type."""
+    object: 'RemoteObject'
+    """Object representing the scope. For global and with scopes it represents the actual object; for the rest of the scopes, it is artificial transient object enumerating scope variables as its properties."""
+    name: NotRequired['str']
+    startLocation: NotRequired['Location']
+    """Location in the source code where scope starts"""
+    endLocation: NotRequired['Location']
+    """Location in the source code where scope ends"""
+class SearchMatch(TypedDict, total=True):
+    """Search match for resource."""
+    lineNumber: 'float'
+    """Line number in resource content."""
+    lineContent: 'str'
+    """Line with match content."""
+class BreakLocation(TypedDict, total=True):
+    scriptId: 'ScriptId'
+    """Script identifier as reported in the Debugger.scriptParsed."""
+    lineNumber: 'int'
+    """Line number in the script (0-based)."""
+    columnNumber: NotRequired['int']
+    """Column number in the script (0-based)."""
+    type: NotRequired['Literal["debuggerStatement", "call", "return"]']
+class WasmDisassemblyChunk(TypedDict, total=True):
+    lines: 'List[str]'
+    """The next chunk of disassembled lines."""
+    bytecodeOffsets: 'List[int]'
+    """The bytecode offsets describing the start of each line."""
+ScriptLanguage = Literal['JavaScript','WebAssembly']
+"""Enum of possible script languages."""
+class DebugSymbols(TypedDict, total=True):
+    """Debug symbols available for a wasm script."""
+    type: 'Literal["SourceMap", "EmbeddedDWARF", "ExternalDWARF"]'
+    """Type of the debug symbols."""
+    externalURL: NotRequired['str']
+    """URL of the external symbol source."""
+class ResolvedBreakpoint(TypedDict, total=True):
+    breakpointId: 'BreakpointId'
+    """Breakpoint unique identifier."""
+    location: 'Location'
+    """Actual breakpoint location."""

cdp/protocol/device_access/events/service.py

@@ -0,0 +1,29 @@
+"""CDP DeviceAccess 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 DeviceAccessEvents:
+    """
+    Events for the DeviceAccess domain.
+    """
+    def __init__(self, client: "Client"):
+        """
+        Initialize the DeviceAccess events.
+        
+        Args:
+            client ("Client"): The parent CDP client instance.
+        """
+        self.client = client
+
+    def on_device_request_prompted(self, callback: Callable[[deviceRequestPromptedEvent,Optional[str]], None]=None) -> None:
+        """
+    A device request opened a user prompt to select a device. Respond with the selectPrompt or cancelPrompt command.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: deviceRequestPromptedEvent, session_id: Optional[str]).
+        """
+        self.client.on('DeviceAccess.deviceRequestPrompted', callback)

cdp/protocol/device_access/events/types.py

@@ -0,0 +1,12 @@
+"""CDP DeviceAccess 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.device_access.types import PromptDevice
+    from cdp.protocol.device_access.types import RequestId
+
+class deviceRequestPromptedEvent(TypedDict, total=True):
+    id: 'RequestId'
+    devices: 'List[PromptDevice]'

cdp/protocol/device_access/methods/service.py

@@ -0,0 +1,65 @@
+"""CDP DeviceAccess 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 DeviceAccessMethods:
+    """
+    Methods for the DeviceAccess domain.
+    """
+    def __init__(self, client: "Client"):
+        """
+        Initialize the DeviceAccess methods.
+        
+        Args:
+            client ("Client"): The parent CDP client instance.
+        """
+        self.client = client
+
+    async def enable(self, params: None=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Enable events in this domain.    
+        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="DeviceAccess.enable", params=params,session_id=session_id)
+    async def disable(self, params: None=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Disable events in this domain.    
+        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="DeviceAccess.disable", params=params,session_id=session_id)
+    async def select_prompt(self, params: Optional[selectPromptParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Select a device in response to a DeviceAccess.deviceRequestPrompted event.    
+        Args:
+            params (selectPromptParameters, optional): Parameters for the selectPrompt method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the selectPrompt call.
+        """
+        return await self.client.send(method="DeviceAccess.selectPrompt", params=params,session_id=session_id)
+    async def cancel_prompt(self, params: Optional[cancelPromptParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Cancel a prompt in response to a DeviceAccess.deviceRequestPrompted event.    
+        Args:
+            params (cancelPromptParameters, optional): Parameters for the cancelPrompt method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the cancelPrompt call.
+        """
+        return await self.client.send(method="DeviceAccess.cancelPrompt", params=params,session_id=session_id)

cdp/protocol/device_access/methods/types.py

@@ -0,0 +1,16 @@
+"""CDP DeviceAccess 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.device_access.types import DeviceId
+    from cdp.protocol.device_access.types import RequestId
+
+
+
+class selectPromptParameters(TypedDict, total=True):
+    id: 'RequestId'
+    deviceId: 'DeviceId'
+class cancelPromptParameters(TypedDict, total=True):
+    id: 'RequestId'

cdp/protocol/device_access/service.py

@@ -0,0 +1,21 @@
+"""CDP DeviceAccess Domain"""
+from typing import TYPE_CHECKING
+from .methods.service import DeviceAccessMethods
+from .events.service import DeviceAccessEvents
+
+if TYPE_CHECKING:
+    from ...service import Client
+
+class DeviceAccess(DeviceAccessMethods, DeviceAccessEvents):
+    """
+    Access the DeviceAccess domain.
+    """
+    def __init__(self, client: "Client"):
+        """
+        Initialize the DeviceAccess domain.
+        
+        Args:
+            client ("Client"): The parent CDP client instance.
+        """
+        DeviceAccessMethods.__init__(self, client)
+        DeviceAccessEvents.__init__(self, client)

cdp/protocol/device_access/types.py

@@ -0,0 +1,13 @@
+"""CDP DeviceAccess Types"""
+
+from typing import TypedDict, NotRequired, Required, Literal, Any, Dict, Union, Optional, List, Set, Tuple
+
+RequestId = str
+"""Device request id."""
+DeviceId = str
+"""A device id."""
+class PromptDevice(TypedDict, total=True):
+    """Device information displayed in a user prompt to select a device."""
+    id: 'DeviceId'
+    name: 'str'
+    """Display name as it appears in a device request user prompt."""

cdp/protocol/device_orientation/events/service.py

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

cdp/protocol/device_orientation/events/types.py

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

cdp/protocol/device_orientation/methods/service.py

@@ -0,0 +1,43 @@
+"""CDP DeviceOrientation 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 DeviceOrientationMethods:
+    """
+    Methods for the DeviceOrientation domain.
+    """
+    def __init__(self, client: "Client"):
+        """
+        Initialize the DeviceOrientation methods.
+        
+        Args:
+            client ("Client"): The parent CDP client instance.
+        """
+        self.client = client
+
+    async def clear_device_orientation_override(self, params: None=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Clears the overridden Device Orientation.    
+        Args:
+            params (None, optional): Parameters for the clearDeviceOrientationOverride method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the clearDeviceOrientationOverride call.
+        """
+        return await self.client.send(method="DeviceOrientation.clearDeviceOrientationOverride", params=params,session_id=session_id)
+    async def set_device_orientation_override(self, params: Optional[setDeviceOrientationOverrideParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Overrides the Device Orientation.    
+        Args:
+            params (setDeviceOrientationOverrideParameters, optional): Parameters for the setDeviceOrientationOverride method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the setDeviceOrientationOverride call.
+        """
+        return await self.client.send(method="DeviceOrientation.setDeviceOrientationOverride", params=params,session_id=session_id)

cdp/protocol/device_orientation/methods/types.py

@@ -0,0 +1,12 @@
+"""CDP DeviceOrientation Methods Types"""
+
+from typing import TypedDict, NotRequired, Required, Literal, Any, Dict, Union, Optional, List, Set, Tuple
+
+
+class setDeviceOrientationOverrideParameters(TypedDict, total=True):
+    alpha: 'float'
+    """Mock alpha"""
+    beta: 'float'
+    """Mock beta"""
+    gamma: 'float'
+    """Mock gamma"""

cdp/protocol/device_orientation/service.py

@@ -0,0 +1,21 @@
+"""CDP DeviceOrientation Domain"""
+from typing import TYPE_CHECKING
+from .methods.service import DeviceOrientationMethods
+from .events.service import DeviceOrientationEvents
+
+if TYPE_CHECKING:
+    from ...service import Client
+
+class DeviceOrientation(DeviceOrientationMethods, DeviceOrientationEvents):
+    """
+    Access the DeviceOrientation domain.
+    """
+    def __init__(self, client: "Client"):
+        """
+        Initialize the DeviceOrientation domain.
+        
+        Args:
+            client ("Client"): The parent CDP client instance.
+        """
+        DeviceOrientationMethods.__init__(self, client)
+        DeviceOrientationEvents.__init__(self, client)

cdp/protocol/device_orientation/types.py

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

cdp/protocol/dom/events/service.py

@@ -0,0 +1,165 @@
+"""CDP DOM 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 DOMEvents:
+    """
+    Events for the DOM domain.
+    """
+    def __init__(self, client: "Client"):
+        """
+        Initialize the DOM events.
+        
+        Args:
+            client ("Client"): The parent CDP client instance.
+        """
+        self.client = client
+
+    def on_attribute_modified(self, callback: Callable[[attributeModifiedEvent,Optional[str]], None]=None) -> None:
+        """
+    Fired when `Element`'s attribute is modified.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: attributeModifiedEvent, session_id: Optional[str]).
+        """
+        self.client.on('DOM.attributeModified', callback)
+    def on_adopted_style_sheets_modified(self, callback: Callable[[adoptedStyleSheetsModifiedEvent,Optional[str]], None]=None) -> None:
+        """
+    Fired when `Element`'s adoptedStyleSheets are modified.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: adoptedStyleSheetsModifiedEvent, session_id: Optional[str]).
+        """
+        self.client.on('DOM.adoptedStyleSheetsModified', callback)
+    def on_attribute_removed(self, callback: Callable[[attributeRemovedEvent,Optional[str]], None]=None) -> None:
+        """
+    Fired when `Element`'s attribute is removed.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: attributeRemovedEvent, session_id: Optional[str]).
+        """
+        self.client.on('DOM.attributeRemoved', callback)
+    def on_character_data_modified(self, callback: Callable[[characterDataModifiedEvent,Optional[str]], None]=None) -> None:
+        """
+    Mirrors `DOMCharacterDataModified` event.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: characterDataModifiedEvent, session_id: Optional[str]).
+        """
+        self.client.on('DOM.characterDataModified', callback)
+    def on_child_node_count_updated(self, callback: Callable[[childNodeCountUpdatedEvent,Optional[str]], None]=None) -> None:
+        """
+    Fired when `Container`'s child node count has changed.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: childNodeCountUpdatedEvent, session_id: Optional[str]).
+        """
+        self.client.on('DOM.childNodeCountUpdated', callback)
+    def on_child_node_inserted(self, callback: Callable[[childNodeInsertedEvent,Optional[str]], None]=None) -> None:
+        """
+    Mirrors `DOMNodeInserted` event.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: childNodeInsertedEvent, session_id: Optional[str]).
+        """
+        self.client.on('DOM.childNodeInserted', callback)
+    def on_child_node_removed(self, callback: Callable[[childNodeRemovedEvent,Optional[str]], None]=None) -> None:
+        """
+    Mirrors `DOMNodeRemoved` event.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: childNodeRemovedEvent, session_id: Optional[str]).
+        """
+        self.client.on('DOM.childNodeRemoved', callback)
+    def on_distributed_nodes_updated(self, callback: Callable[[distributedNodesUpdatedEvent,Optional[str]], None]=None) -> None:
+        """
+    Called when distribution is changed.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: distributedNodesUpdatedEvent, session_id: Optional[str]).
+        """
+        self.client.on('DOM.distributedNodesUpdated', callback)
+    def on_document_updated(self, callback: Callable[[documentUpdatedEvent,Optional[str]], None]=None) -> None:
+        """
+    Fired when `Document` has been totally updated. Node ids are no longer valid.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: documentUpdatedEvent, session_id: Optional[str]).
+        """
+        self.client.on('DOM.documentUpdated', callback)
+    def on_inline_style_invalidated(self, callback: Callable[[inlineStyleInvalidatedEvent,Optional[str]], None]=None) -> None:
+        """
+    Fired when `Element`'s inline style is modified via a CSS property modification.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: inlineStyleInvalidatedEvent, session_id: Optional[str]).
+        """
+        self.client.on('DOM.inlineStyleInvalidated', callback)
+    def on_pseudo_element_added(self, callback: Callable[[pseudoElementAddedEvent,Optional[str]], None]=None) -> None:
+        """
+    Called when a pseudo element is added to an element.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: pseudoElementAddedEvent, session_id: Optional[str]).
+        """
+        self.client.on('DOM.pseudoElementAdded', callback)
+    def on_top_layer_elements_updated(self, callback: Callable[[topLayerElementsUpdatedEvent,Optional[str]], None]=None) -> None:
+        """
+    Called when top layer elements are changed.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: topLayerElementsUpdatedEvent, session_id: Optional[str]).
+        """
+        self.client.on('DOM.topLayerElementsUpdated', callback)
+    def on_scrollable_flag_updated(self, callback: Callable[[scrollableFlagUpdatedEvent,Optional[str]], None]=None) -> None:
+        """
+    Fired when a node's scrollability state changes.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: scrollableFlagUpdatedEvent, session_id: Optional[str]).
+        """
+        self.client.on('DOM.scrollableFlagUpdated', callback)
+    def on_affected_by_starting_styles_flag_updated(self, callback: Callable[[affectedByStartingStylesFlagUpdatedEvent,Optional[str]], None]=None) -> None:
+        """
+    Fired when a node's starting styles changes.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: affectedByStartingStylesFlagUpdatedEvent, session_id: Optional[str]).
+        """
+        self.client.on('DOM.affectedByStartingStylesFlagUpdated', callback)
+    def on_pseudo_element_removed(self, callback: Callable[[pseudoElementRemovedEvent,Optional[str]], None]=None) -> None:
+        """
+    Called when a pseudo element is removed from an element.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: pseudoElementRemovedEvent, session_id: Optional[str]).
+        """
+        self.client.on('DOM.pseudoElementRemoved', callback)
+    def on_set_child_nodes(self, callback: Callable[[setChildNodesEvent,Optional[str]], None]=None) -> None:
+        """
+    Fired when backend wants to provide client with the missing DOM structure. This happens upon most of the calls requesting node ids.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: setChildNodesEvent, session_id: Optional[str]).
+        """
+        self.client.on('DOM.setChildNodes', callback)
+    def on_shadow_root_popped(self, callback: Callable[[shadowRootPoppedEvent,Optional[str]], None]=None) -> None:
+        """
+    Called when shadow root is popped from the element.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: shadowRootPoppedEvent, session_id: Optional[str]).
+        """
+        self.client.on('DOM.shadowRootPopped', callback)
+    def on_shadow_root_pushed(self, callback: Callable[[shadowRootPushedEvent,Optional[str]], None]=None) -> None:
+        """
+    Called when shadow root is pushed into the element.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: shadowRootPushedEvent, session_id: Optional[str]).
+        """
+        self.client.on('DOM.shadowRootPushed', callback)

cdp/protocol/dom/events/types.py

@@ -0,0 +1,97 @@
+"""CDP DOM 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 BackendNode
+    from cdp.protocol.dom.types import Node
+    from cdp.protocol.dom.types import NodeId
+    from cdp.protocol.dom.types import StyleSheetId
+
+class attributeModifiedEvent(TypedDict, total=True):
+    nodeId: 'NodeId'
+    """Id of the node that has changed."""
+    name: 'str'
+    """Attribute name."""
+    value: 'str'
+    """Attribute value."""
+class adoptedStyleSheetsModifiedEvent(TypedDict, total=True):
+    nodeId: 'NodeId'
+    """Id of the node that has changed."""
+    adoptedStyleSheets: 'List[StyleSheetId]'
+    """New adoptedStyleSheets array."""
+class attributeRemovedEvent(TypedDict, total=True):
+    nodeId: 'NodeId'
+    """Id of the node that has changed."""
+    name: 'str'
+    """A ttribute name."""
+class characterDataModifiedEvent(TypedDict, total=True):
+    nodeId: 'NodeId'
+    """Id of the node that has changed."""
+    characterData: 'str'
+    """New text value."""
+class childNodeCountUpdatedEvent(TypedDict, total=True):
+    nodeId: 'NodeId'
+    """Id of the node that has changed."""
+    childNodeCount: 'int'
+    """New node count."""
+class childNodeInsertedEvent(TypedDict, total=True):
+    parentNodeId: 'NodeId'
+    """Id of the node that has changed."""
+    previousNodeId: 'NodeId'
+    """Id of the previous sibling."""
+    node: 'Node'
+    """Inserted node data."""
+class childNodeRemovedEvent(TypedDict, total=True):
+    parentNodeId: 'NodeId'
+    """Parent id."""
+    nodeId: 'NodeId'
+    """Id of the node that has been removed."""
+class distributedNodesUpdatedEvent(TypedDict, total=True):
+    insertionPointId: 'NodeId'
+    """Insertion point where distributed nodes were updated."""
+    distributedNodes: 'List[BackendNode]'
+    """Distributed nodes for given insertion point."""
+class documentUpdatedEvent(TypedDict, total=True):
+    pass
+class inlineStyleInvalidatedEvent(TypedDict, total=True):
+    nodeIds: 'List[NodeId]'
+    """Ids of the nodes for which the inline styles have been invalidated."""
+class pseudoElementAddedEvent(TypedDict, total=True):
+    parentId: 'NodeId'
+    """Pseudo element's parent element id."""
+    pseudoElement: 'Node'
+    """The added pseudo element."""
+class topLayerElementsUpdatedEvent(TypedDict, total=True):
+    pass
+class scrollableFlagUpdatedEvent(TypedDict, total=True):
+    nodeId: 'NodeId'
+    """The id of the node."""
+    isScrollable: 'bool'
+    """If the node is scrollable."""
+class affectedByStartingStylesFlagUpdatedEvent(TypedDict, total=True):
+    nodeId: 'NodeId'
+    """The id of the node."""
+    affectedByStartingStyles: 'bool'
+    """If the node has starting styles."""
+class pseudoElementRemovedEvent(TypedDict, total=True):
+    parentId: 'NodeId'
+    """Pseudo element's parent element id."""
+    pseudoElementId: 'NodeId'
+    """The removed pseudo element id."""
+class setChildNodesEvent(TypedDict, total=True):
+    parentId: 'NodeId'
+    """Parent node id to populate with children."""
+    nodes: 'List[Node]'
+    """Child nodes array."""
+class shadowRootPoppedEvent(TypedDict, total=True):
+    hostId: 'NodeId'
+    """Host element id."""
+    rootId: 'NodeId'
+    """Shadow root id."""
+class shadowRootPushedEvent(TypedDict, total=True):
+    hostId: 'NodeId'
+    """Host element id."""
+    root: 'Node'
+    """Shadow root."""