parsek-cdp 0.1.0__py3-none-any.whl

parsek_cdp/cdp/input/functions.py

@@ -0,0 +1,361 @@
+"""Commands for the Input domain (generated)."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any, ClassVar, Dict, List, Literal, Optional
+
+from ..mixins.datatype import DataType, FieldMeta, encode
+
+if TYPE_CHECKING:
+    from .types import (
+        DragData,
+        GestureSourceType,
+        MouseButton,
+        TimeSinceEpoch,
+        TouchPoint,
+    )
+
+class Input:
+    """Commands of the Input domain, bound to a target."""
+
+    def __init__(self, target: Any) -> None:
+        self._target = target
+
+
+    async def dispatch_drag_event(self, *, type_: Literal['dragEnter', 'dragOver', 'drop', 'dragCancel'], x: float, y: float, data: DragData, modifiers: Optional[int] = None) -> None:
+        """
+        Dispatches a drag event into the page.
+        :param type_: Type of the drag event.
+        :param x: X coordinate of the event relative to the main frame's viewport in CSS pixels.
+        :param y: 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.
+        :param data:
+        :param modifiers: Bit field representing pressed modifier keys. Alt=1, Ctrl=2, Meta/Command=4, Shift=8
+        (default: 0).
+        """
+        _params: Dict[str, Any] = {}
+        _params['type'] = encode(FieldMeta('', '', False, 'primitive'), type_)
+        _params['x'] = encode(FieldMeta('', '', False, 'primitive'), x)
+        _params['y'] = encode(FieldMeta('', '', False, 'primitive'), y)
+        _params['data'] = encode(FieldMeta('', '', False, 'object', ref='Input.DragData'), data)
+        if modifiers is not None:
+            _params['modifiers'] = encode(FieldMeta('', '', False, 'primitive'), modifiers)
+        _result = await self._target.send('Input.dispatchDragEvent', _params)
+        return None
+
+    async def dispatch_key_event(self, *, type_: Literal['keyDown', 'keyUp', 'rawKeyDown', 'char'], modifiers: Optional[int] = None, timestamp: Optional[TimeSinceEpoch] = None, text: Optional[str] = None, unmodified_text: Optional[str] = None, key_identifier: Optional[str] = None, code: Optional[str] = None, key: Optional[str] = None, windows_virtual_key_code: Optional[int] = None, native_virtual_key_code: Optional[int] = None, auto_repeat: Optional[bool] = None, is_keypad: Optional[bool] = None, is_system_key: Optional[bool] = None, location: Optional[int] = None, commands: Optional[List[str]] = None) -> None:
+        """
+        Dispatches a key event to the page.
+        :param type_: Type of the key event.
+        :param modifiers: Bit field representing pressed modifier keys. Alt=1, Ctrl=2, Meta/Command=4, Shift=8
+        (default: 0).
+        :param timestamp: Time at which the event occurred.
+        :param text: Text as generated by processing a virtual key code with a keyboard layout. Not needed for
+        for `keyUp` and `rawKeyDown` events (default: "")
+        :param unmodified_text: Text that would have been generated by the keyboard if no modifiers were pressed (except for
+        shift). Useful for shortcut (accelerator) key handling (default: "").
+        :param key_identifier: Unique key identifier (e.g., 'U+0041') (default: "").
+        :param code: Unique DOM defined string value for each physical key (e.g., 'KeyA') (default: "").
+        :param key: Unique DOM defined string value describing the meaning of the key in the context of active
+        modifiers, keyboard layout, etc (e.g., 'AltGr') (default: "").
+        :param windows_virtual_key_code: Windows virtual key code (default: 0).
+        :param native_virtual_key_code: Native virtual key code (default: 0).
+        :param auto_repeat: Whether the event was generated from auto repeat (default: false).
+        :param is_keypad: Whether the event was generated from the keypad (default: false).
+        :param is_system_key: Whether the event was a system key event (default: false).
+        :param location: Whether the event was from the left or right side of the keyboard. 1=Left, 2=Right (default:
+        0).
+        :param commands: 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.
+        """
+        _params: Dict[str, Any] = {}
+        _params['type'] = encode(FieldMeta('', '', False, 'primitive'), type_)
+        if modifiers is not None:
+            _params['modifiers'] = encode(FieldMeta('', '', False, 'primitive'), modifiers)
+        if timestamp is not None:
+            _params['timestamp'] = encode(FieldMeta('', '', False, 'primitive'), timestamp)
+        if text is not None:
+            _params['text'] = encode(FieldMeta('', '', False, 'primitive'), text)
+        if unmodified_text is not None:
+            _params['unmodifiedText'] = encode(FieldMeta('', '', False, 'primitive'), unmodified_text)
+        if key_identifier is not None:
+            _params['keyIdentifier'] = encode(FieldMeta('', '', False, 'primitive'), key_identifier)
+        if code is not None:
+            _params['code'] = encode(FieldMeta('', '', False, 'primitive'), code)
+        if key is not None:
+            _params['key'] = encode(FieldMeta('', '', False, 'primitive'), key)
+        if windows_virtual_key_code is not None:
+            _params['windowsVirtualKeyCode'] = encode(FieldMeta('', '', False, 'primitive'), windows_virtual_key_code)
+        if native_virtual_key_code is not None:
+            _params['nativeVirtualKeyCode'] = encode(FieldMeta('', '', False, 'primitive'), native_virtual_key_code)
+        if auto_repeat is not None:
+            _params['autoRepeat'] = encode(FieldMeta('', '', False, 'primitive'), auto_repeat)
+        if is_keypad is not None:
+            _params['isKeypad'] = encode(FieldMeta('', '', False, 'primitive'), is_keypad)
+        if is_system_key is not None:
+            _params['isSystemKey'] = encode(FieldMeta('', '', False, 'primitive'), is_system_key)
+        if location is not None:
+            _params['location'] = encode(FieldMeta('', '', False, 'primitive'), location)
+        if commands is not None:
+            _params['commands'] = encode(FieldMeta('', '', False, 'array', inner=FieldMeta('', '', False, 'primitive')), commands)
+        _result = await self._target.send('Input.dispatchKeyEvent', _params)
+        return None
+
+    async def insert_text(self, *, text: str) -> None:
+        """
+        This method emulates inserting text that doesn't come from a key press,
+        for example an emoji keyboard or an IME.
+        :param text: The text to insert.
+        """
+        _params: Dict[str, Any] = {}
+        _params['text'] = encode(FieldMeta('', '', False, 'primitive'), text)
+        _result = await self._target.send('Input.insertText', _params)
+        return None
+
+    async def ime_set_composition(self, *, text: str, selection_start: int, selection_end: int, replacement_start: Optional[int] = None, replacement_end: Optional[int] = None) -> None:
+        """
+        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.
+        :param text: The text to insert
+        :param selection_start: selection start
+        :param selection_end: selection end
+        :param replacement_start: replacement start
+        :param replacement_end: replacement end
+        """
+        _params: Dict[str, Any] = {}
+        _params['text'] = encode(FieldMeta('', '', False, 'primitive'), text)
+        _params['selectionStart'] = encode(FieldMeta('', '', False, 'primitive'), selection_start)
+        _params['selectionEnd'] = encode(FieldMeta('', '', False, 'primitive'), selection_end)
+        if replacement_start is not None:
+            _params['replacementStart'] = encode(FieldMeta('', '', False, 'primitive'), replacement_start)
+        if replacement_end is not None:
+            _params['replacementEnd'] = encode(FieldMeta('', '', False, 'primitive'), replacement_end)
+        _result = await self._target.send('Input.imeSetComposition', _params)
+        return None
+
+    async def dispatch_mouse_event(self, *, type_: Literal['mousePressed', 'mouseReleased', 'mouseMoved', 'mouseWheel'], x: float, y: float, modifiers: Optional[int] = None, timestamp: Optional[TimeSinceEpoch] = None, button: Optional[MouseButton] = None, buttons: Optional[int] = None, click_count: Optional[int] = None, force: Optional[float] = None, tangential_pressure: Optional[float] = None, tilt_x: Optional[float] = None, tilt_y: Optional[float] = None, twist: Optional[int] = None, delta_x: Optional[float] = None, delta_y: Optional[float] = None, pointer_type: Optional[Literal['mouse', 'pen']] = None) -> None:
+        """
+        Dispatches a mouse event to the page.
+        :param type_: Type of the mouse event.
+        :param x: X coordinate of the event relative to the main frame's viewport in CSS pixels.
+        :param y: 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.
+        :param modifiers: Bit field representing pressed modifier keys. Alt=1, Ctrl=2, Meta/Command=4, Shift=8
+        (default: 0).
+        :param timestamp: Time at which the event occurred.
+        :param button: Mouse button (default: "none").
+        :param buttons: 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.
+        :param click_count: Number of times the mouse button was clicked (default: 0).
+        :param force: The normalized pressure, which has a range of [0,1] (default: 0).
+        :param tangential_pressure: The normalized tangential pressure, which has a range of [-1,1] (default: 0).
+        :param tilt_x: 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).
+        :param tilt_y: 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).
+        :param twist: The clockwise rotation of a pen stylus around its own major axis, in degrees in the range [0,359] (default: 0).
+        :param delta_x: X delta in CSS pixels for mouse wheel event (default: 0).
+        :param delta_y: Y delta in CSS pixels for mouse wheel event (default: 0).
+        :param pointer_type: Pointer type (default: "mouse").
+        """
+        _params: Dict[str, Any] = {}
+        _params['type'] = encode(FieldMeta('', '', False, 'primitive'), type_)
+        _params['x'] = encode(FieldMeta('', '', False, 'primitive'), x)
+        _params['y'] = encode(FieldMeta('', '', False, 'primitive'), y)
+        if modifiers is not None:
+            _params['modifiers'] = encode(FieldMeta('', '', False, 'primitive'), modifiers)
+        if timestamp is not None:
+            _params['timestamp'] = encode(FieldMeta('', '', False, 'primitive'), timestamp)
+        if button is not None:
+            _params['button'] = encode(FieldMeta('', '', False, 'enum', ref='Input.MouseButton'), button)
+        if buttons is not None:
+            _params['buttons'] = encode(FieldMeta('', '', False, 'primitive'), buttons)
+        if click_count is not None:
+            _params['clickCount'] = encode(FieldMeta('', '', False, 'primitive'), click_count)
+        if force is not None:
+            _params['force'] = encode(FieldMeta('', '', False, 'primitive'), force)
+        if tangential_pressure is not None:
+            _params['tangentialPressure'] = encode(FieldMeta('', '', False, 'primitive'), tangential_pressure)
+        if tilt_x is not None:
+            _params['tiltX'] = encode(FieldMeta('', '', False, 'primitive'), tilt_x)
+        if tilt_y is not None:
+            _params['tiltY'] = encode(FieldMeta('', '', False, 'primitive'), tilt_y)
+        if twist is not None:
+            _params['twist'] = encode(FieldMeta('', '', False, 'primitive'), twist)
+        if delta_x is not None:
+            _params['deltaX'] = encode(FieldMeta('', '', False, 'primitive'), delta_x)
+        if delta_y is not None:
+            _params['deltaY'] = encode(FieldMeta('', '', False, 'primitive'), delta_y)
+        if pointer_type is not None:
+            _params['pointerType'] = encode(FieldMeta('', '', False, 'primitive'), pointer_type)
+        _result = await self._target.send('Input.dispatchMouseEvent', _params)
+        return None
+
+    async def dispatch_touch_event(self, *, type_: Literal['touchStart', 'touchEnd', 'touchMove', 'touchCancel'], touch_points: List[TouchPoint], modifiers: Optional[int] = None, timestamp: Optional[TimeSinceEpoch] = None) -> None:
+        """
+        Dispatches a touch event to the page.
+        :param type_: Type of the touch event. TouchEnd and TouchCancel must not contain any touch points, while
+        TouchStart and TouchMove must contains at least one.
+        :param touch_points: 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.
+        :param modifiers: Bit field representing pressed modifier keys. Alt=1, Ctrl=2, Meta/Command=4, Shift=8
+        (default: 0).
+        :param timestamp: Time at which the event occurred.
+        """
+        _params: Dict[str, Any] = {}
+        _params['type'] = encode(FieldMeta('', '', False, 'primitive'), type_)
+        _params['touchPoints'] = encode(FieldMeta('', '', False, 'array', inner=FieldMeta('', '', False, 'object', ref='Input.TouchPoint')), touch_points)
+        if modifiers is not None:
+            _params['modifiers'] = encode(FieldMeta('', '', False, 'primitive'), modifiers)
+        if timestamp is not None:
+            _params['timestamp'] = encode(FieldMeta('', '', False, 'primitive'), timestamp)
+        _result = await self._target.send('Input.dispatchTouchEvent', _params)
+        return None
+
+    async def cancel_dragging(self) -> None:
+        """Cancels any active dragging in the page."""
+        _params: Dict[str, Any] = {}
+        _result = await self._target.send('Input.cancelDragging', _params)
+        return None
+
+    async def emulate_touch_from_mouse_event(self, *, type_: Literal['mousePressed', 'mouseReleased', 'mouseMoved', 'mouseWheel'], x: int, y: int, button: MouseButton, timestamp: Optional[TimeSinceEpoch] = None, delta_x: Optional[float] = None, delta_y: Optional[float] = None, modifiers: Optional[int] = None, click_count: Optional[int] = None) -> None:
+        """
+        Emulates touch event from the mouse event parameters.
+        :param type_: Type of the mouse event.
+        :param x: X coordinate of the mouse pointer in DIP.
+        :param y: Y coordinate of the mouse pointer in DIP.
+        :param button: Mouse button. Only "none", "left", "right" are supported.
+        :param timestamp: Time at which the event occurred (default: current time).
+        :param delta_x: X delta in DIP for mouse wheel event (default: 0).
+        :param delta_y: Y delta in DIP for mouse wheel event (default: 0).
+        :param modifiers: Bit field representing pressed modifier keys. Alt=1, Ctrl=2, Meta/Command=4, Shift=8
+        (default: 0).
+        :param click_count: Number of times the mouse button was clicked (default: 0).
+        """
+        _params: Dict[str, Any] = {}
+        _params['type'] = encode(FieldMeta('', '', False, 'primitive'), type_)
+        _params['x'] = encode(FieldMeta('', '', False, 'primitive'), x)
+        _params['y'] = encode(FieldMeta('', '', False, 'primitive'), y)
+        _params['button'] = encode(FieldMeta('', '', False, 'enum', ref='Input.MouseButton'), button)
+        if timestamp is not None:
+            _params['timestamp'] = encode(FieldMeta('', '', False, 'primitive'), timestamp)
+        if delta_x is not None:
+            _params['deltaX'] = encode(FieldMeta('', '', False, 'primitive'), delta_x)
+        if delta_y is not None:
+            _params['deltaY'] = encode(FieldMeta('', '', False, 'primitive'), delta_y)
+        if modifiers is not None:
+            _params['modifiers'] = encode(FieldMeta('', '', False, 'primitive'), modifiers)
+        if click_count is not None:
+            _params['clickCount'] = encode(FieldMeta('', '', False, 'primitive'), click_count)
+        _result = await self._target.send('Input.emulateTouchFromMouseEvent', _params)
+        return None
+
+    async def set_ignore_input_events(self, *, ignore: bool) -> None:
+        """
+        Ignores input events (useful while auditing page).
+        :param ignore: Ignores input events processing when set to true.
+        """
+        _params: Dict[str, Any] = {}
+        _params['ignore'] = encode(FieldMeta('', '', False, 'primitive'), ignore)
+        _result = await self._target.send('Input.setIgnoreInputEvents', _params)
+        return None
+
+    async def set_intercept_drags(self, *, enabled: bool) -> None:
+        """
+        Prevents default drag and drop behavior and instead emits `Input.dragIntercepted` events.
+        Drag and drop behavior can be directly controlled via `Input.dispatchDragEvent`.
+        :param enabled:
+        """
+        _params: Dict[str, Any] = {}
+        _params['enabled'] = encode(FieldMeta('', '', False, 'primitive'), enabled)
+        _result = await self._target.send('Input.setInterceptDrags', _params)
+        return None
+
+    async def synthesize_pinch_gesture(self, *, x: float, y: float, scale_factor: float, relative_speed: Optional[int] = None, gesture_source_type: Optional[GestureSourceType] = None) -> None:
+        """
+        Synthesizes a pinch gesture over a time period by issuing appropriate touch events.
+        :param x: X coordinate of the start of the gesture in CSS pixels.
+        :param y: Y coordinate of the start of the gesture in CSS pixels.
+        :param scale_factor: Relative scale factor after zooming (>1.0 zooms in, <1.0 zooms out).
+        :param relative_speed: Relative pointer speed in pixels per second (default: 800).
+        :param gesture_source_type: Which type of input events to be generated (default: 'default', which queries the platform
+        for the preferred input type).
+        """
+        _params: Dict[str, Any] = {}
+        _params['x'] = encode(FieldMeta('', '', False, 'primitive'), x)
+        _params['y'] = encode(FieldMeta('', '', False, 'primitive'), y)
+        _params['scaleFactor'] = encode(FieldMeta('', '', False, 'primitive'), scale_factor)
+        if relative_speed is not None:
+            _params['relativeSpeed'] = encode(FieldMeta('', '', False, 'primitive'), relative_speed)
+        if gesture_source_type is not None:
+            _params['gestureSourceType'] = encode(FieldMeta('', '', False, 'enum', ref='Input.GestureSourceType'), gesture_source_type)
+        _result = await self._target.send('Input.synthesizePinchGesture', _params)
+        return None
+
+    async def synthesize_scroll_gesture(self, *, x: float, y: float, x_distance: Optional[float] = None, y_distance: Optional[float] = None, x_overscroll: Optional[float] = None, y_overscroll: Optional[float] = None, prevent_fling: Optional[bool] = None, speed: Optional[int] = None, gesture_source_type: Optional[GestureSourceType] = None, repeat_count: Optional[int] = None, repeat_delay_ms: Optional[int] = None, interaction_marker_name: Optional[str] = None) -> None:
+        """
+        Synthesizes a scroll gesture over a time period by issuing appropriate touch events.
+        :param x: X coordinate of the start of the gesture in CSS pixels.
+        :param y: Y coordinate of the start of the gesture in CSS pixels.
+        :param x_distance: The distance to scroll along the X axis (positive to scroll left).
+        :param y_distance: The distance to scroll along the Y axis (positive to scroll up).
+        :param x_overscroll: The number of additional pixels to scroll back along the X axis, in addition to the given
+        distance.
+        :param y_overscroll: The number of additional pixels to scroll back along the Y axis, in addition to the given
+        distance.
+        :param prevent_fling: Prevent fling (default: true).
+        :param speed: Swipe speed in pixels per second (default: 800).
+        :param gesture_source_type: Which type of input events to be generated (default: 'default', which queries the platform
+        for the preferred input type).
+        :param repeat_count: The number of times to repeat the gesture (default: 0).
+        :param repeat_delay_ms: The number of milliseconds delay between each repeat. (default: 250).
+        :param interaction_marker_name: The name of the interaction markers to generate, if not empty (default: "").
+        """
+        _params: Dict[str, Any] = {}
+        _params['x'] = encode(FieldMeta('', '', False, 'primitive'), x)
+        _params['y'] = encode(FieldMeta('', '', False, 'primitive'), y)
+        if x_distance is not None:
+            _params['xDistance'] = encode(FieldMeta('', '', False, 'primitive'), x_distance)
+        if y_distance is not None:
+            _params['yDistance'] = encode(FieldMeta('', '', False, 'primitive'), y_distance)
+        if x_overscroll is not None:
+            _params['xOverscroll'] = encode(FieldMeta('', '', False, 'primitive'), x_overscroll)
+        if y_overscroll is not None:
+            _params['yOverscroll'] = encode(FieldMeta('', '', False, 'primitive'), y_overscroll)
+        if prevent_fling is not None:
+            _params['preventFling'] = encode(FieldMeta('', '', False, 'primitive'), prevent_fling)
+        if speed is not None:
+            _params['speed'] = encode(FieldMeta('', '', False, 'primitive'), speed)
+        if gesture_source_type is not None:
+            _params['gestureSourceType'] = encode(FieldMeta('', '', False, 'enum', ref='Input.GestureSourceType'), gesture_source_type)
+        if repeat_count is not None:
+            _params['repeatCount'] = encode(FieldMeta('', '', False, 'primitive'), repeat_count)
+        if repeat_delay_ms is not None:
+            _params['repeatDelayMs'] = encode(FieldMeta('', '', False, 'primitive'), repeat_delay_ms)
+        if interaction_marker_name is not None:
+            _params['interactionMarkerName'] = encode(FieldMeta('', '', False, 'primitive'), interaction_marker_name)
+        _result = await self._target.send('Input.synthesizeScrollGesture', _params)
+        return None
+
+    async def synthesize_tap_gesture(self, *, x: float, y: float, duration: Optional[int] = None, tap_count: Optional[int] = None, gesture_source_type: Optional[GestureSourceType] = None) -> None:
+        """
+        Synthesizes a tap gesture over a time period by issuing appropriate touch events.
+        :param x: X coordinate of the start of the gesture in CSS pixels.
+        :param y: Y coordinate of the start of the gesture in CSS pixels.
+        :param duration: Duration between touchdown and touchup events in ms (default: 50).
+        :param tap_count: Number of times to perform the tap (e.g. 2 for double tap, default: 1).
+        :param gesture_source_type: Which type of input events to be generated (default: 'default', which queries the platform
+        for the preferred input type).
+        """
+        _params: Dict[str, Any] = {}
+        _params['x'] = encode(FieldMeta('', '', False, 'primitive'), x)
+        _params['y'] = encode(FieldMeta('', '', False, 'primitive'), y)
+        if duration is not None:
+            _params['duration'] = encode(FieldMeta('', '', False, 'primitive'), duration)
+        if tap_count is not None:
+            _params['tapCount'] = encode(FieldMeta('', '', False, 'primitive'), tap_count)
+        if gesture_source_type is not None:
+            _params['gestureSourceType'] = encode(FieldMeta('', '', False, 'enum', ref='Input.GestureSourceType'), gesture_source_type)
+        _result = await self._target.send('Input.synthesizeTapGesture', _params)
+        return None

parsek_cdp/cdp/input/types.py

@@ -0,0 +1,87 @@
+"""Custom types and enums for the Input domain (generated)."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import Enum
+from typing import Any, ClassVar, Dict, List, Literal, Optional
+
+from ..mixins.datatype import DataType, FieldMeta, register
+
+
+@register("Input.TouchPoint")
+@dataclass
+class TouchPoint(DataType):
+    x: float
+    y: float
+    radius_x: Optional[float] = None
+    radius_y: Optional[float] = None
+    rotation_angle: Optional[float] = None
+    force: Optional[float] = None
+    tangential_pressure: Optional[float] = None
+    tilt_x: Optional[float] = None
+    tilt_y: Optional[float] = None
+    twist: Optional[int] = None
+    id: Optional[float] = None
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('x', 'x', False, 'primitive'),
+        FieldMeta('y', 'y', False, 'primitive'),
+        FieldMeta('radius_x', 'radiusX', True, 'primitive'),
+        FieldMeta('radius_y', 'radiusY', True, 'primitive'),
+        FieldMeta('rotation_angle', 'rotationAngle', True, 'primitive'),
+        FieldMeta('force', 'force', True, 'primitive'),
+        FieldMeta('tangential_pressure', 'tangentialPressure', True, 'primitive'),
+        FieldMeta('tilt_x', 'tiltX', True, 'primitive'),
+        FieldMeta('tilt_y', 'tiltY', True, 'primitive'),
+        FieldMeta('twist', 'twist', True, 'primitive'),
+        FieldMeta('id', 'id', True, 'primitive'),
+    )
+
+
+@register("Input.GestureSourceType")
+class GestureSourceType(str, Enum):
+    DEFAULT = 'default'
+    TOUCH = 'touch'
+    MOUSE = 'mouse'
+
+
+@register("Input.MouseButton")
+class MouseButton(str, Enum):
+    NONE = 'none'
+    LEFT = 'left'
+    MIDDLE = 'middle'
+    RIGHT = 'right'
+    BACK = 'back'
+    FORWARD = 'forward'
+
+
+type TimeSinceEpoch = float  # UTC time in seconds, counted from January 1, 1970.
+
+
+@register("Input.DragDataItem")
+@dataclass
+class DragDataItem(DataType):
+    mime_type: str
+    data: str
+    title: Optional[str] = None
+    base_url: Optional[str] = None
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('mime_type', 'mimeType', False, 'primitive'),
+        FieldMeta('data', 'data', False, 'primitive'),
+        FieldMeta('title', 'title', True, 'primitive'),
+        FieldMeta('base_url', 'baseURL', True, 'primitive'),
+    )
+
+
+@register("Input.DragData")
+@dataclass
+class DragData(DataType):
+    items: List[DragDataItem]
+    drag_operations_mask: int
+    files: Optional[List[str]] = None
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('items', 'items', False, 'array', inner=FieldMeta('', '', False, 'object', ref='Input.DragDataItem')),
+        FieldMeta('drag_operations_mask', 'dragOperationsMask', False, 'primitive'),
+        FieldMeta('files', 'files', True, 'array', inner=FieldMeta('', '', False, 'primitive')),
+    )
+
+__all__ = ["DragData", "DragDataItem", "GestureSourceType", "MouseButton", "TimeSinceEpoch", "TouchPoint"]

parsek_cdp/cdp/inspector/__init__.py

@@ -0,0 +1,15 @@
+"""The Inspector CDP domain (generated).
+
+Importing ``Inspector`` from ``parsek_cdp.cdp`` gives a namespace with this
+domain's events and types as attributes (``Inspector.SomeEvent`` /
+``Inspector.SomeType``); commands run on a target via ``page.cdp.Inspector``.
+"""
+from . import events, functions, types
+from .functions import Inspector
+from .events import *  # noqa: F401,F403 -- expose events on the namespace
+from .types import *  # noqa: F401,F403 -- expose types on the namespace
+
+#: Protocol domain name (used by features that declare ``domains=(Inspector,)``).
+DOMAIN = "Inspector"
+
+__all__ = ["events", "functions", "types", "Inspector", "DOMAIN"]

parsek_cdp/cdp/inspector/events.py

@@ -0,0 +1,41 @@
+"""Events for the Inspector domain (generated)."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, ClassVar, Dict, List, Literal, Optional
+
+from ..mixins.datatype import FieldMeta
+from ..mixins.event import Event, register_event
+
+
+@register_event("Inspector.detached")
+@dataclass
+class Detached(Event):
+    """Fired when remote debugging connection is about to be terminated. Contains detach reason."""
+    reason: str
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('reason', 'reason', False, 'primitive'),
+    )
+
+
+@register_event("Inspector.targetCrashed")
+@dataclass
+class TargetCrashed(Event):
+    """Fired when debugging target has crashed"""
+    __FIELDS__: ClassVar[tuple] = ()
+
+
+@register_event("Inspector.targetReloadedAfterCrash")
+@dataclass
+class TargetReloadedAfterCrash(Event):
+    """Fired when debugging target has reloaded after crash"""
+    __FIELDS__: ClassVar[tuple] = ()
+
+
+@register_event("Inspector.workerScriptLoaded")
+@dataclass
+class WorkerScriptLoaded(Event):
+    """Fired on worker targets when main worker script and any imported scripts have been evaluated."""
+    __FIELDS__: ClassVar[tuple] = ()
+
+__all__ = ["Detached", "TargetCrashed", "TargetReloadedAfterCrash", "WorkerScriptLoaded"]

parsek_cdp/cdp/inspector/functions.py

@@ -0,0 +1,27 @@
+"""Commands for the Inspector domain (generated)."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, ClassVar, Dict, List, Literal, Optional
+
+from ..mixins.datatype import DataType, FieldMeta, encode
+
+
+class Inspector:
+    """Commands of the Inspector domain, bound to a target."""
+
+    def __init__(self, target: Any) -> None:
+        self._target = target
+
+
+    async def disable(self) -> None:
+        """Disables inspector domain notifications."""
+        _params: Dict[str, Any] = {}
+        _result = await self._target.send('Inspector.disable', _params)
+        return None
+
+    async def enable(self) -> None:
+        """Enables inspector domain notifications."""
+        _params: Dict[str, Any] = {}
+        _result = await self._target.send('Inspector.enable', _params)
+        return None

parsek_cdp/cdp/inspector/types.py

@@ -0,0 +1,10 @@
+"""Custom types and enums for the Inspector domain (generated)."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import Enum
+from typing import Any, ClassVar, Dict, List, Literal, Optional
+
+from ..mixins.datatype import DataType, FieldMeta, register
+
+__all__ = []

parsek_cdp/cdp/io/__init__.py

@@ -0,0 +1,15 @@
+"""The IO CDP domain (generated).
+
+Importing ``IO`` from ``parsek_cdp.cdp`` gives a namespace with this
+domain's events and types as attributes (``IO.SomeEvent`` /
+``IO.SomeType``); commands run on a target via ``page.cdp.IO``.
+"""
+from . import events, functions, types
+from .functions import IO
+from .events import *  # noqa: F401,F403 -- expose events on the namespace
+from .types import *  # noqa: F401,F403 -- expose types on the namespace
+
+#: Protocol domain name (used by features that declare ``domains=(IO,)``).
+DOMAIN = "IO"
+
+__all__ = ["events", "functions", "types", "IO", "DOMAIN"]

parsek_cdp/cdp/io/events.py

@@ -0,0 +1,13 @@
+"""Events for the IO domain (generated)."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, ClassVar, Dict, List, Literal, Optional
+
+from ..mixins.datatype import FieldMeta
+from ..mixins.event import Event, register_event
+
+
+# This domain defines no events.
+
+__all__ = []