chromedeveloperprotocol-client 0.1.0__py3-none-any.whl

cdp/protocol/input/events/service.py

@@ -0,0 +1,29 @@
+"""CDP Input 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 InputEvents:
+    """
+    Events for the Input domain.
+    """
+    def __init__(self, client: "Client"):
+        """
+        Initialize the Input events.
+        
+        Args:
+            client ("Client"): The parent CDP client instance.
+        """
+        self.client = client
+
+    def on_drag_intercepted(self, callback: Callable[[dragInterceptedEvent,Optional[str]], None]=None) -> None:
+        """
+    Emitted only when `Input.setInterceptDrags` is enabled. Use this data with `Input.dispatchDragEvent` to restore normal drag and drop behavior.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: dragInterceptedEvent, session_id: Optional[str]).
+        """
+        self.client.on('Input.dragIntercepted', callback)

cdp/protocol/input/events/types.py

@@ -0,0 +1,10 @@
+"""CDP Input 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.input.types import DragData
+
+class dragInterceptedEvent(TypedDict, total=True):
+    data: 'DragData'

cdp/protocol/input/methods/service.py

@@ -0,0 +1,164 @@
+"""CDP Input 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 InputMethods:
+    """
+    Methods for the Input domain.
+    """
+    def __init__(self, client: "Client"):
+        """
+        Initialize the Input methods.
+        
+        Args:
+            client ("Client"): The parent CDP client instance.
+        """
+        self.client = client
+
+    async def dispatch_drag_event(self, params: Optional[dispatchDragEventParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Dispatches a drag event into the page.    
+        Args:
+            params (dispatchDragEventParameters, optional): Parameters for the dispatchDragEvent method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the dispatchDragEvent call.
+        """
+        return await self.client.send(method="Input.dispatchDragEvent", params=params,session_id=session_id)
+    async def dispatch_key_event(self, params: Optional[dispatchKeyEventParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Dispatches a key event to the page.    
+        Args:
+            params (dispatchKeyEventParameters, optional): Parameters for the dispatchKeyEvent method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the dispatchKeyEvent call.
+        """
+        return await self.client.send(method="Input.dispatchKeyEvent", params=params,session_id=session_id)
+    async def insert_text(self, params: Optional[insertTextParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    This method emulates inserting text that doesn't come from a key press, for example an emoji keyboard or an IME.    
+        Args:
+            params (insertTextParameters, optional): Parameters for the insertText method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the insertText call.
+        """
+        return await self.client.send(method="Input.insertText", params=params,session_id=session_id)
+    async def ime_set_composition(self, params: Optional[imeSetCompositionParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    This method sets the current candidate text for IME. Use imeCommitComposition to commit the final text. Use imeSetComposition with empty string as text to cancel composition.    
+        Args:
+            params (imeSetCompositionParameters, optional): Parameters for the imeSetComposition method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the imeSetComposition call.
+        """
+        return await self.client.send(method="Input.imeSetComposition", params=params,session_id=session_id)
+    async def dispatch_mouse_event(self, params: Optional[dispatchMouseEventParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Dispatches a mouse event to the page.    
+        Args:
+            params (dispatchMouseEventParameters, optional): Parameters for the dispatchMouseEvent method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the dispatchMouseEvent call.
+        """
+        return await self.client.send(method="Input.dispatchMouseEvent", params=params,session_id=session_id)
+    async def dispatch_touch_event(self, params: Optional[dispatchTouchEventParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Dispatches a touch event to the page.    
+        Args:
+            params (dispatchTouchEventParameters, optional): Parameters for the dispatchTouchEvent method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the dispatchTouchEvent call.
+        """
+        return await self.client.send(method="Input.dispatchTouchEvent", params=params,session_id=session_id)
+    async def cancel_dragging(self, params: None=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Cancels any active dragging in the page.    
+        Args:
+            params (None, optional): Parameters for the cancelDragging method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the cancelDragging call.
+        """
+        return await self.client.send(method="Input.cancelDragging", params=params,session_id=session_id)
+    async def emulate_touch_from_mouse_event(self, params: Optional[emulateTouchFromMouseEventParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Emulates touch event from the mouse event parameters.    
+        Args:
+            params (emulateTouchFromMouseEventParameters, optional): Parameters for the emulateTouchFromMouseEvent method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the emulateTouchFromMouseEvent call.
+        """
+        return await self.client.send(method="Input.emulateTouchFromMouseEvent", params=params,session_id=session_id)
+    async def set_ignore_input_events(self, params: Optional[setIgnoreInputEventsParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Ignores input events (useful while auditing page).    
+        Args:
+            params (setIgnoreInputEventsParameters, optional): Parameters for the setIgnoreInputEvents method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the setIgnoreInputEvents call.
+        """
+        return await self.client.send(method="Input.setIgnoreInputEvents", params=params,session_id=session_id)
+    async def set_intercept_drags(self, params: Optional[setInterceptDragsParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Prevents default drag and drop behavior and instead emits `Input.dragIntercepted` events. Drag and drop behavior can be directly controlled via `Input.dispatchDragEvent`.    
+        Args:
+            params (setInterceptDragsParameters, optional): Parameters for the setInterceptDrags method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the setInterceptDrags call.
+        """
+        return await self.client.send(method="Input.setInterceptDrags", params=params,session_id=session_id)
+    async def synthesize_pinch_gesture(self, params: Optional[synthesizePinchGestureParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Synthesizes a pinch gesture over a time period by issuing appropriate touch events.    
+        Args:
+            params (synthesizePinchGestureParameters, optional): Parameters for the synthesizePinchGesture method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the synthesizePinchGesture call.
+        """
+        return await self.client.send(method="Input.synthesizePinchGesture", params=params,session_id=session_id)
+    async def synthesize_scroll_gesture(self, params: Optional[synthesizeScrollGestureParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Synthesizes a scroll gesture over a time period by issuing appropriate touch events.    
+        Args:
+            params (synthesizeScrollGestureParameters, optional): Parameters for the synthesizeScrollGesture method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the synthesizeScrollGesture call.
+        """
+        return await self.client.send(method="Input.synthesizeScrollGesture", params=params,session_id=session_id)
+    async def synthesize_tap_gesture(self, params: Optional[synthesizeTapGestureParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Synthesizes a tap gesture over a time period by issuing appropriate touch events.    
+        Args:
+            params (synthesizeTapGestureParameters, optional): Parameters for the synthesizeTapGesture method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the synthesizeTapGesture call.
+        """
+        return await self.client.send(method="Input.synthesizeTapGesture", params=params,session_id=session_id)

cdp/protocol/input/methods/types.py

@@ -0,0 +1,181 @@
+"""CDP Input 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.input.types import DragData
+    from cdp.protocol.input.types import GestureSourceType
+    from cdp.protocol.input.types import MouseButton
+    from cdp.protocol.input.types import TimeSinceEpoch
+    from cdp.protocol.input.types import TouchPoint
+
+class dispatchDragEventParameters(TypedDict, total=True):
+    type: 'Literal["dragEnter", "dragOver", "drop", "dragCancel"]'
+    """Type of the drag event."""
+    x: 'float'
+    """X coordinate of the event relative to the main frame's viewport in CSS pixels."""
+    y: 'float'
+    """Y coordinate of the event relative to the main frame's viewport in CSS pixels. 0 refers to the top of the viewport and Y increases as it proceeds towards the bottom of the viewport."""
+    data: 'DragData'
+    modifiers: NotRequired['int']
+    """Bit field representing pressed modifier keys. Alt=1, Ctrl=2, Meta/Command=4, Shift=8 (default: 0)."""
+class dispatchKeyEventParameters(TypedDict, total=True):
+    type: 'Literal["keyDown", "keyUp", "rawKeyDown", "char"]'
+    """Type of the key event."""
+    modifiers: NotRequired['int']
+    """Bit field representing pressed modifier keys. Alt=1, Ctrl=2, Meta/Command=4, Shift=8 (default: 0)."""
+    timestamp: NotRequired['TimeSinceEpoch']
+    """Time at which the event occurred."""
+    text: NotRequired['str']
+    """Text as generated by processing a virtual key code with a keyboard layout. Not needed for for keyUp and rawKeyDown events (default: "")"""
+    unmodifiedText: NotRequired['str']
+    """Text that would have been generated by the keyboard if no modifiers were pressed (except for shift). Useful for shortcut (accelerator) key handling (default: "")."""
+    keyIdentifier: NotRequired['str']
+    """Unique key identifier (e.g., 'U+0041') (default: "")."""
+    code: NotRequired['str']
+    """Unique DOM defined string value for each physical key (e.g., 'KeyA') (default: "")."""
+    key: NotRequired['str']
+    """Unique DOM defined string value describing the meaning of the key in the context of active modifiers, keyboard layout, etc (e.g., 'AltGr') (default: "")."""
+    windowsVirtualKeyCode: NotRequired['int']
+    """Windows virtual key code (default: 0)."""
+    nativeVirtualKeyCode: NotRequired['int']
+    """Native virtual key code (default: 0)."""
+    autoRepeat: NotRequired['bool']
+    """Whether the event was generated from auto repeat (default: false)."""
+    isKeypad: NotRequired['bool']
+    """Whether the event was generated from the keypad (default: false)."""
+    isSystemKey: NotRequired['bool']
+    """Whether the event was a system key event (default: false)."""
+    location: NotRequired['int']
+    """Whether the event was from the left or right side of the keyboard. 1=Left, 2=Right (default: 0)."""
+    commands: NotRequired['List[str]']
+    """Editing commands to send with the key event (e.g., 'selectAll') (default: []). These are related to but not equal the command names used in document.execCommand and NSStandardKeyBindingResponding. See https://source.chromium.org/chromium/chromium/src/+/main:third_party/blink/renderer/core/editing/commands/editor_command_names.h for valid command names."""
+class insertTextParameters(TypedDict, total=True):
+    text: 'str'
+    """The text to insert."""
+class imeSetCompositionParameters(TypedDict, total=True):
+    text: 'str'
+    """The text to insert"""
+    selectionStart: 'int'
+    """selection start"""
+    selectionEnd: 'int'
+    """selection end"""
+    replacementStart: NotRequired['int']
+    """replacement start"""
+    replacementEnd: NotRequired['int']
+    """replacement end"""
+class dispatchMouseEventParameters(TypedDict, total=True):
+    type: 'Literal["mousePressed", "mouseReleased", "mouseMoved", "mouseWheel"]'
+    """Type of the mouse event."""
+    x: 'float'
+    """X coordinate of the event relative to the main frame's viewport in CSS pixels."""
+    y: 'float'
+    """Y coordinate of the event relative to the main frame's viewport in CSS pixels. 0 refers to the top of the viewport and Y increases as it proceeds towards the bottom of the viewport."""
+    modifiers: NotRequired['int']
+    """Bit field representing pressed modifier keys. Alt=1, Ctrl=2, Meta/Command=4, Shift=8 (default: 0)."""
+    timestamp: NotRequired['TimeSinceEpoch']
+    """Time at which the event occurred."""
+    button: NotRequired['MouseButton']
+    """Mouse button (default: "none")."""
+    buttons: NotRequired['int']
+    """A number indicating which buttons are pressed on the mouse when a mouse event is triggered. Left=1, Right=2, Middle=4, Back=8, Forward=16, None=0."""
+    clickCount: NotRequired['int']
+    """Number of times the mouse button was clicked (default: 0)."""
+    force: NotRequired['float']
+    """The normalized pressure, which has a range of [0,1] (default: 0)."""
+    tangentialPressure: NotRequired['float']
+    """The normalized tangential pressure, which has a range of [-1,1] (default: 0)."""
+    tiltX: NotRequired['float']
+    """The plane angle between the Y-Z plane and the plane containing both the stylus axis and the Y axis, in degrees of the range [-90,90], a positive tiltX is to the right (default: 0)."""
+    tiltY: NotRequired['float']
+    """The plane angle between the X-Z plane and the plane containing both the stylus axis and the X axis, in degrees of the range [-90,90], a positive tiltY is towards the user (default: 0)."""
+    twist: NotRequired['int']
+    """The clockwise rotation of a pen stylus around its own major axis, in degrees in the range [0,359] (default: 0)."""
+    deltaX: NotRequired['float']
+    """X delta in CSS pixels for mouse wheel event (default: 0)."""
+    deltaY: NotRequired['float']
+    """Y delta in CSS pixels for mouse wheel event (default: 0)."""
+    pointerType: NotRequired['Literal["mouse", "pen"]']
+    """Pointer type (default: "mouse")."""
+class dispatchTouchEventParameters(TypedDict, total=True):
+    type: 'Literal["touchStart", "touchEnd", "touchMove", "touchCancel"]'
+    """Type of the touch event. TouchEnd and TouchCancel must not contain any touch points, while TouchStart and TouchMove must contains at least one."""
+    touchPoints: 'List[TouchPoint]'
+    """Active touch points on the touch device. One event per any changed point (compared to previous touch event in a sequence) is generated, emulating pressing/moving/releasing points one by one."""
+    modifiers: NotRequired['int']
+    """Bit field representing pressed modifier keys. Alt=1, Ctrl=2, Meta/Command=4, Shift=8 (default: 0)."""
+    timestamp: NotRequired['TimeSinceEpoch']
+    """Time at which the event occurred."""
+
+class emulateTouchFromMouseEventParameters(TypedDict, total=True):
+    type: 'Literal["mousePressed", "mouseReleased", "mouseMoved", "mouseWheel"]'
+    """Type of the mouse event."""
+    x: 'int'
+    """X coordinate of the mouse pointer in DIP."""
+    y: 'int'
+    """Y coordinate of the mouse pointer in DIP."""
+    button: 'MouseButton'
+    """Mouse button. Only "none", "left", "right" are supported."""
+    timestamp: NotRequired['TimeSinceEpoch']
+    """Time at which the event occurred (default: current time)."""
+    deltaX: NotRequired['float']
+    """X delta in DIP for mouse wheel event (default: 0)."""
+    deltaY: NotRequired['float']
+    """Y delta in DIP for mouse wheel event (default: 0)."""
+    modifiers: NotRequired['int']
+    """Bit field representing pressed modifier keys. Alt=1, Ctrl=2, Meta/Command=4, Shift=8 (default: 0)."""
+    clickCount: NotRequired['int']
+    """Number of times the mouse button was clicked (default: 0)."""
+class setIgnoreInputEventsParameters(TypedDict, total=True):
+    ignore: 'bool'
+    """Ignores input events processing when set to true."""
+class setInterceptDragsParameters(TypedDict, total=True):
+    enabled: 'bool'
+class synthesizePinchGestureParameters(TypedDict, total=True):
+    x: 'float'
+    """X coordinate of the start of the gesture in CSS pixels."""
+    y: 'float'
+    """Y coordinate of the start of the gesture in CSS pixels."""
+    scaleFactor: 'float'
+    """Relative scale factor after zooming (>1.0 zooms in, <1.0 zooms out)."""
+    relativeSpeed: NotRequired['int']
+    """Relative pointer speed in pixels per second (default: 800)."""
+    gestureSourceType: NotRequired['GestureSourceType']
+    """Which type of input events to be generated (default: 'default', which queries the platform for the preferred input type)."""
+class synthesizeScrollGestureParameters(TypedDict, total=True):
+    x: 'float'
+    """X coordinate of the start of the gesture in CSS pixels."""
+    y: 'float'
+    """Y coordinate of the start of the gesture in CSS pixels."""
+    xDistance: NotRequired['float']
+    """The distance to scroll along the X axis (positive to scroll left)."""
+    yDistance: NotRequired['float']
+    """The distance to scroll along the Y axis (positive to scroll up)."""
+    xOverscroll: NotRequired['float']
+    """The number of additional pixels to scroll back along the X axis, in addition to the given distance."""
+    yOverscroll: NotRequired['float']
+    """The number of additional pixels to scroll back along the Y axis, in addition to the given distance."""
+    preventFling: NotRequired['bool']
+    """Prevent fling (default: true)."""
+    speed: NotRequired['int']
+    """Swipe speed in pixels per second (default: 800)."""
+    gestureSourceType: NotRequired['GestureSourceType']
+    """Which type of input events to be generated (default: 'default', which queries the platform for the preferred input type)."""
+    repeatCount: NotRequired['int']
+    """The number of times to repeat the gesture (default: 0)."""
+    repeatDelayMs: NotRequired['int']
+    """The number of milliseconds delay between each repeat. (default: 250)."""
+    interactionMarkerName: NotRequired['str']
+    """The name of the interaction markers to generate, if not empty (default: "")."""
+class synthesizeTapGestureParameters(TypedDict, total=True):
+    x: 'float'
+    """X coordinate of the start of the gesture in CSS pixels."""
+    y: 'float'
+    """Y coordinate of the start of the gesture in CSS pixels."""
+    duration: NotRequired['int']
+    """Duration between touchdown and touchup events in ms (default: 50)."""
+    tapCount: NotRequired['int']
+    """Number of times to perform the tap (e.g. 2 for double tap, default: 1)."""
+    gestureSourceType: NotRequired['GestureSourceType']
+    """Which type of input events to be generated (default: 'default', which queries the platform for the preferred input type)."""

cdp/protocol/input/service.py

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

cdp/protocol/input/types.py

@@ -0,0 +1,46 @@
+"""CDP Input Types"""
+
+from typing import TypedDict, NotRequired, Required, Literal, Any, Dict, Union, Optional, List, Set, Tuple
+
+class TouchPoint(TypedDict, total=True):
+    x: 'float'
+    """X coordinate of the event relative to the main frame's viewport in CSS pixels."""
+    y: 'float'
+    """Y coordinate of the event relative to the main frame's viewport in CSS pixels. 0 refers to the top of the viewport and Y increases as it proceeds towards the bottom of the viewport."""
+    radiusX: NotRequired['float']
+    """X radius of the touch area (default: 1.0)."""
+    radiusY: NotRequired['float']
+    """Y radius of the touch area (default: 1.0)."""
+    rotationAngle: NotRequired['float']
+    """Rotation angle (default: 0.0)."""
+    force: NotRequired['float']
+    """Force (default: 1.0)."""
+    tangentialPressure: NotRequired['float']
+    """The normalized tangential pressure, which has a range of [-1,1] (default: 0)."""
+    tiltX: NotRequired['float']
+    """The plane angle between the Y-Z plane and the plane containing both the stylus axis and the Y axis, in degrees of the range [-90,90], a positive tiltX is to the right (default: 0)"""
+    tiltY: NotRequired['float']
+    """The plane angle between the X-Z plane and the plane containing both the stylus axis and the X axis, in degrees of the range [-90,90], a positive tiltY is towards the user (default: 0)."""
+    twist: NotRequired['int']
+    """The clockwise rotation of a pen stylus around its own major axis, in degrees in the range [0,359] (default: 0)."""
+    id: NotRequired['float']
+    """Identifier used to track touch sources between events, must be unique within an event."""
+GestureSourceType = Literal['default','touch','mouse']
+MouseButton = Literal['none','left','middle','right','back','forward']
+TimeSinceEpoch = float
+"""UTC time in seconds, counted from January 1, 1970."""
+class DragDataItem(TypedDict, total=True):
+    mimeType: 'str'
+    """Mime type of the dragged data."""
+    data: 'str'
+    """Depending of the value of mimeType, it contains the dragged link, text, HTML markup or any other data."""
+    title: NotRequired['str']
+    """Title associated with a link. Only valid when mimeType == "text/uri-list"."""
+    baseURL: NotRequired['str']
+    """Stores the base URL for the contained markup. Only valid when mimeType == "text/html"."""
+class DragData(TypedDict, total=True):
+    items: 'List[DragDataItem]'
+    dragOperationsMask: 'int'
+    """Bit field representing allowed drag operations. Copy = 1, Link = 2, Move = 16"""
+    files: NotRequired['List[str]']
+    """List of filenames that should be included when dropping"""

cdp/protocol/inspector/events/service.py

@@ -0,0 +1,53 @@
+"""CDP Inspector 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 InspectorEvents:
+    """
+    Events for the Inspector domain.
+    """
+    def __init__(self, client: "Client"):
+        """
+        Initialize the Inspector events.
+        
+        Args:
+            client ("Client"): The parent CDP client instance.
+        """
+        self.client = client
+
+    def on_detached(self, callback: Callable[[detachedEvent,Optional[str]], None]=None) -> None:
+        """
+    Fired when remote debugging connection is about to be terminated. Contains detach reason.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: detachedEvent, session_id: Optional[str]).
+        """
+        self.client.on('Inspector.detached', callback)
+    def on_target_crashed(self, callback: Callable[[targetCrashedEvent,Optional[str]], None]=None) -> None:
+        """
+    Fired when debugging target has crashed    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: targetCrashedEvent, session_id: Optional[str]).
+        """
+        self.client.on('Inspector.targetCrashed', callback)
+    def on_target_reloaded_after_crash(self, callback: Callable[[targetReloadedAfterCrashEvent,Optional[str]], None]=None) -> None:
+        """
+    Fired when debugging target has reloaded after crash    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: targetReloadedAfterCrashEvent, session_id: Optional[str]).
+        """
+        self.client.on('Inspector.targetReloadedAfterCrash', callback)
+    def on_worker_script_loaded(self, callback: Callable[[workerScriptLoadedEvent,Optional[str]], None]=None) -> None:
+        """
+    Fired on worker targets when main worker script and any imported scripts have been evaluated.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: workerScriptLoadedEvent, session_id: Optional[str]).
+        """
+        self.client.on('Inspector.workerScriptLoaded', callback)

cdp/protocol/inspector/events/types.py

@@ -0,0 +1,13 @@
+"""CDP Inspector Events"""
+
+from typing import TypedDict, NotRequired, Required, Literal, Any, Dict, Union, Optional, List, Set, Tuple
+
+class detachedEvent(TypedDict, total=True):
+    reason: 'str'
+    """The reason why connection has been terminated."""
+class targetCrashedEvent(TypedDict, total=True):
+    pass
+class targetReloadedAfterCrashEvent(TypedDict, total=True):
+    pass
+class workerScriptLoadedEvent(TypedDict, total=True):
+    pass

cdp/protocol/inspector/methods/service.py

@@ -0,0 +1,43 @@
+"""CDP Inspector 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 InspectorMethods:
+    """
+    Methods for the Inspector domain.
+    """
+    def __init__(self, client: "Client"):
+        """
+        Initialize the Inspector 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 inspector 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="Inspector.disable", params=params,session_id=session_id)
+    async def enable(self, params: None=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Enables inspector 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="Inspector.enable", params=params,session_id=session_id)

cdp/protocol/inspector/methods/types.py

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

cdp/protocol/inspector/service.py

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

cdp/protocol/inspector/types.py

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

cdp/protocol/io/events/service.py

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

cdp/protocol/io/events/types.py

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