parsek-cdp 0.1.0__py3-none-any.whl

parsek_cdp/cdp/domsnapshot/functions.py

@@ -0,0 +1,111 @@
+"""Commands for the DOMSnapshot 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 (
+        ComputedStyle,
+        DOMNode,
+        DocumentSnapshot,
+        LayoutTreeNode,
+    )
+
+@dataclass
+class GetSnapshotReturn(DataType):
+    """Return value of :meth:`DOMSnapshot.get_snapshot`."""
+    dom_nodes: List[DOMNode]
+    layout_tree_nodes: List[LayoutTreeNode]
+    computed_styles: List[ComputedStyle]
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('dom_nodes', 'domNodes', False, 'array', inner=FieldMeta('', '', False, 'object', ref='DOMSnapshot.DOMNode')),
+        FieldMeta('layout_tree_nodes', 'layoutTreeNodes', False, 'array', inner=FieldMeta('', '', False, 'object', ref='DOMSnapshot.LayoutTreeNode')),
+        FieldMeta('computed_styles', 'computedStyles', False, 'array', inner=FieldMeta('', '', False, 'object', ref='DOMSnapshot.ComputedStyle')),
+    )
+
+
+@dataclass
+class CaptureSnapshotReturn(DataType):
+    """Return value of :meth:`DOMSnapshot.capture_snapshot`."""
+    documents: List[DocumentSnapshot]
+    strings: List[str]
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('documents', 'documents', False, 'array', inner=FieldMeta('', '', False, 'object', ref='DOMSnapshot.DocumentSnapshot')),
+        FieldMeta('strings', 'strings', False, 'array', inner=FieldMeta('', '', False, 'primitive')),
+    )
+
+
+class DOMSnapshot:
+    """Commands of the DOMSnapshot domain, bound to a target."""
+
+    def __init__(self, target: Any) -> None:
+        self._target = target
+
+
+    async def disable(self) -> None:
+        """Disables DOM snapshot agent for the given page."""
+        _params: Dict[str, Any] = {}
+        _result = await self._target.send('DOMSnapshot.disable', _params)
+        return None
+
+    async def enable(self) -> None:
+        """Enables DOM snapshot agent for the given page."""
+        _params: Dict[str, Any] = {}
+        _result = await self._target.send('DOMSnapshot.enable', _params)
+        return None
+
+    async def get_snapshot(self, *, computed_style_whitelist: List[str], include_event_listeners: Optional[bool] = None, include_paint_order: Optional[bool] = None, include_user_agent_shadow_tree: Optional[bool] = None) -> GetSnapshotReturn:
+        """
+        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.
+        
+        .. deprecated::
+        :param computed_style_whitelist: Whitelist of computed styles to return.
+        :param include_event_listeners: Whether or not to retrieve details of DOM listeners (default false).
+        :param include_paint_order: Whether to determine and include the paint order index of LayoutTreeNodes (default false).
+        :param include_user_agent_shadow_tree: Whether to include UA shadow tree in the snapshot (default false).
+        """
+        _params: Dict[str, Any] = {}
+        _params['computedStyleWhitelist'] = encode(FieldMeta('', '', False, 'array', inner=FieldMeta('', '', False, 'primitive')), computed_style_whitelist)
+        if include_event_listeners is not None:
+            _params['includeEventListeners'] = encode(FieldMeta('', '', False, 'primitive'), include_event_listeners)
+        if include_paint_order is not None:
+            _params['includePaintOrder'] = encode(FieldMeta('', '', False, 'primitive'), include_paint_order)
+        if include_user_agent_shadow_tree is not None:
+            _params['includeUserAgentShadowTree'] = encode(FieldMeta('', '', False, 'primitive'), include_user_agent_shadow_tree)
+        _result = await self._target.send('DOMSnapshot.getSnapshot', _params)
+        return GetSnapshotReturn.from_json(_result)
+
+    async def capture_snapshot(self, *, computed_styles: List[str], include_paint_order: Optional[bool] = None, include_dom_rects: Optional[bool] = None, include_blended_background_colors: Optional[bool] = None, include_text_color_opacities: Optional[bool] = None) -> CaptureSnapshotReturn:
+        """
+        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.
+        :param computed_styles: Whitelist of computed styles to return.
+        :param include_paint_order: Whether to include layout object paint orders into the snapshot.
+        :param include_dom_rects: Whether to include DOM rectangles (offsetRects, clientRects, scrollRects) into the snapshot
+        :param include_blended_background_colors: 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.
+        :param include_text_color_opacities: 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.
+        """
+        _params: Dict[str, Any] = {}
+        _params['computedStyles'] = encode(FieldMeta('', '', False, 'array', inner=FieldMeta('', '', False, 'primitive')), computed_styles)
+        if include_paint_order is not None:
+            _params['includePaintOrder'] = encode(FieldMeta('', '', False, 'primitive'), include_paint_order)
+        if include_dom_rects is not None:
+            _params['includeDOMRects'] = encode(FieldMeta('', '', False, 'primitive'), include_dom_rects)
+        if include_blended_background_colors is not None:
+            _params['includeBlendedBackgroundColors'] = encode(FieldMeta('', '', False, 'primitive'), include_blended_background_colors)
+        if include_text_color_opacities is not None:
+            _params['includeTextColorOpacities'] = encode(FieldMeta('', '', False, 'primitive'), include_text_color_opacities)
+        _result = await self._target.send('DOMSnapshot.captureSnapshot', _params)
+        return CaptureSnapshotReturn.from_json(_result)

parsek_cdp/cdp/domsnapshot/types.py

@@ -0,0 +1,312 @@
+"""Custom types and enums for the DOMSnapshot domain (generated)."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import Enum
+from typing import TYPE_CHECKING, Any, ClassVar, Dict, List, Literal, Optional
+
+from ..mixins.datatype import DataType, FieldMeta, register
+
+if TYPE_CHECKING:
+    from ..dom.types import BackendNodeId as DOM_BackendNodeId
+    from ..dom.types import PseudoType as DOM_PseudoType
+    from ..dom.types import Rect as DOM_Rect
+    from ..dom.types import ShadowRootType as DOM_ShadowRootType
+    from ..domdebugger.types import EventListener as DOMDebugger_EventListener
+    from ..page.types import FrameId as Page_FrameId
+
+@register("DOMSnapshot.DOMNode")
+@dataclass
+class DOMNode(DataType):
+    """A Node in the DOM tree."""
+    node_type: int
+    node_name: str
+    node_value: str
+    backend_node_id: DOM_BackendNodeId
+    text_value: Optional[str] = None
+    input_value: Optional[str] = None
+    input_checked: Optional[bool] = None
+    option_selected: Optional[bool] = None
+    child_node_indexes: Optional[List[int]] = None
+    attributes: Optional[List[NameValue]] = None
+    pseudo_element_indexes: Optional[List[int]] = None
+    layout_node_index: Optional[int] = None
+    document_url: Optional[str] = None
+    base_url: Optional[str] = None
+    content_language: Optional[str] = None
+    document_encoding: Optional[str] = None
+    public_id: Optional[str] = None
+    system_id: Optional[str] = None
+    frame_id: Optional[Page_FrameId] = None
+    content_document_index: Optional[int] = None
+    pseudo_type: Optional[DOM_PseudoType] = None
+    shadow_root_type: Optional[DOM_ShadowRootType] = None
+    is_clickable: Optional[bool] = None
+    event_listeners: Optional[List[DOMDebugger_EventListener]] = None
+    current_source_url: Optional[str] = None
+    origin_url: Optional[str] = None
+    scroll_offset_x: Optional[float] = None
+    scroll_offset_y: Optional[float] = None
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('node_type', 'nodeType', False, 'primitive'),
+        FieldMeta('node_name', 'nodeName', False, 'primitive'),
+        FieldMeta('node_value', 'nodeValue', False, 'primitive'),
+        FieldMeta('backend_node_id', 'backendNodeId', False, 'primitive'),
+        FieldMeta('text_value', 'textValue', True, 'primitive'),
+        FieldMeta('input_value', 'inputValue', True, 'primitive'),
+        FieldMeta('input_checked', 'inputChecked', True, 'primitive'),
+        FieldMeta('option_selected', 'optionSelected', True, 'primitive'),
+        FieldMeta('child_node_indexes', 'childNodeIndexes', True, 'array', inner=FieldMeta('', '', False, 'primitive')),
+        FieldMeta('attributes', 'attributes', True, 'array', inner=FieldMeta('', '', False, 'object', ref='DOMSnapshot.NameValue')),
+        FieldMeta('pseudo_element_indexes', 'pseudoElementIndexes', True, 'array', inner=FieldMeta('', '', False, 'primitive')),
+        FieldMeta('layout_node_index', 'layoutNodeIndex', True, 'primitive'),
+        FieldMeta('document_url', 'documentURL', True, 'primitive'),
+        FieldMeta('base_url', 'baseURL', True, 'primitive'),
+        FieldMeta('content_language', 'contentLanguage', True, 'primitive'),
+        FieldMeta('document_encoding', 'documentEncoding', True, 'primitive'),
+        FieldMeta('public_id', 'publicId', True, 'primitive'),
+        FieldMeta('system_id', 'systemId', True, 'primitive'),
+        FieldMeta('frame_id', 'frameId', True, 'primitive'),
+        FieldMeta('content_document_index', 'contentDocumentIndex', True, 'primitive'),
+        FieldMeta('pseudo_type', 'pseudoType', True, 'enum', ref='DOM.PseudoType'),
+        FieldMeta('shadow_root_type', 'shadowRootType', True, 'enum', ref='DOM.ShadowRootType'),
+        FieldMeta('is_clickable', 'isClickable', True, 'primitive'),
+        FieldMeta('event_listeners', 'eventListeners', True, 'array', inner=FieldMeta('', '', False, 'object', ref='DOMDebugger.EventListener')),
+        FieldMeta('current_source_url', 'currentSourceURL', True, 'primitive'),
+        FieldMeta('origin_url', 'originURL', True, 'primitive'),
+        FieldMeta('scroll_offset_x', 'scrollOffsetX', True, 'primitive'),
+        FieldMeta('scroll_offset_y', 'scrollOffsetY', True, 'primitive'),
+    )
+
+
+@register("DOMSnapshot.InlineTextBox")
+@dataclass
+class InlineTextBox(DataType):
+    """
+    Details of post layout rendered text positions. The exact layout should not be regarded as
+    stable and may change between versions.
+    """
+    bounding_box: DOM_Rect
+    start_character_index: int
+    num_characters: int
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('bounding_box', 'boundingBox', False, 'object', ref='DOM.Rect'),
+        FieldMeta('start_character_index', 'startCharacterIndex', False, 'primitive'),
+        FieldMeta('num_characters', 'numCharacters', False, 'primitive'),
+    )
+
+
+@register("DOMSnapshot.LayoutTreeNode")
+@dataclass
+class LayoutTreeNode(DataType):
+    """Details of an element in the DOM tree with a LayoutObject."""
+    dom_node_index: int
+    bounding_box: DOM_Rect
+    layout_text: Optional[str] = None
+    inline_text_nodes: Optional[List[InlineTextBox]] = None
+    style_index: Optional[int] = None
+    paint_order: Optional[int] = None
+    is_stacking_context: Optional[bool] = None
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('dom_node_index', 'domNodeIndex', False, 'primitive'),
+        FieldMeta('bounding_box', 'boundingBox', False, 'object', ref='DOM.Rect'),
+        FieldMeta('layout_text', 'layoutText', True, 'primitive'),
+        FieldMeta('inline_text_nodes', 'inlineTextNodes', True, 'array', inner=FieldMeta('', '', False, 'object', ref='DOMSnapshot.InlineTextBox')),
+        FieldMeta('style_index', 'styleIndex', True, 'primitive'),
+        FieldMeta('paint_order', 'paintOrder', True, 'primitive'),
+        FieldMeta('is_stacking_context', 'isStackingContext', True, 'primitive'),
+    )
+
+
+@register("DOMSnapshot.ComputedStyle")
+@dataclass
+class ComputedStyle(DataType):
+    """A subset of the full ComputedStyle as defined by the request whitelist."""
+    properties: List[NameValue]
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('properties', 'properties', False, 'array', inner=FieldMeta('', '', False, 'object', ref='DOMSnapshot.NameValue')),
+    )
+
+
+@register("DOMSnapshot.NameValue")
+@dataclass
+class NameValue(DataType):
+    """A name/value pair."""
+    name: str
+    value: str
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('name', 'name', False, 'primitive'),
+        FieldMeta('value', 'value', False, 'primitive'),
+    )
+
+
+type StringIndex = int  # Index of the string in the strings table.
+
+
+type ArrayOfStrings = List[StringIndex]  # Index of the string in the strings table.
+
+
+@register("DOMSnapshot.RareStringData")
+@dataclass
+class RareStringData(DataType):
+    """Data that is only present on rare nodes."""
+    index: List[int]
+    value: List[StringIndex]
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('index', 'index', False, 'array', inner=FieldMeta('', '', False, 'primitive')),
+        FieldMeta('value', 'value', False, 'array', inner=FieldMeta('', '', False, 'primitive')),
+    )
+
+
+@register("DOMSnapshot.RareBooleanData")
+@dataclass
+class RareBooleanData(DataType):
+    index: List[int]
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('index', 'index', False, 'array', inner=FieldMeta('', '', False, 'primitive')),
+    )
+
+
+@register("DOMSnapshot.RareIntegerData")
+@dataclass
+class RareIntegerData(DataType):
+    index: List[int]
+    value: List[int]
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('index', 'index', False, 'array', inner=FieldMeta('', '', False, 'primitive')),
+        FieldMeta('value', 'value', False, 'array', inner=FieldMeta('', '', False, 'primitive')),
+    )
+
+
+type Rectangle = List[float]
+
+
+@register("DOMSnapshot.DocumentSnapshot")
+@dataclass
+class DocumentSnapshot(DataType):
+    """Document snapshot."""
+    document_url: StringIndex
+    title: StringIndex
+    base_url: StringIndex
+    content_language: StringIndex
+    encoding_name: StringIndex
+    public_id: StringIndex
+    system_id: StringIndex
+    frame_id: StringIndex
+    nodes: NodeTreeSnapshot
+    layout: LayoutTreeSnapshot
+    text_boxes: TextBoxSnapshot
+    scroll_offset_x: Optional[float] = None
+    scroll_offset_y: Optional[float] = None
+    content_width: Optional[float] = None
+    content_height: Optional[float] = None
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('document_url', 'documentURL', False, 'primitive'),
+        FieldMeta('title', 'title', False, 'primitive'),
+        FieldMeta('base_url', 'baseURL', False, 'primitive'),
+        FieldMeta('content_language', 'contentLanguage', False, 'primitive'),
+        FieldMeta('encoding_name', 'encodingName', False, 'primitive'),
+        FieldMeta('public_id', 'publicId', False, 'primitive'),
+        FieldMeta('system_id', 'systemId', False, 'primitive'),
+        FieldMeta('frame_id', 'frameId', False, 'primitive'),
+        FieldMeta('nodes', 'nodes', False, 'object', ref='DOMSnapshot.NodeTreeSnapshot'),
+        FieldMeta('layout', 'layout', False, 'object', ref='DOMSnapshot.LayoutTreeSnapshot'),
+        FieldMeta('text_boxes', 'textBoxes', False, 'object', ref='DOMSnapshot.TextBoxSnapshot'),
+        FieldMeta('scroll_offset_x', 'scrollOffsetX', True, 'primitive'),
+        FieldMeta('scroll_offset_y', 'scrollOffsetY', True, 'primitive'),
+        FieldMeta('content_width', 'contentWidth', True, 'primitive'),
+        FieldMeta('content_height', 'contentHeight', True, 'primitive'),
+    )
+
+
+@register("DOMSnapshot.NodeTreeSnapshot")
+@dataclass
+class NodeTreeSnapshot(DataType):
+    """Table containing nodes."""
+    parent_index: Optional[List[int]] = None
+    node_type: Optional[List[int]] = None
+    shadow_root_type: Optional[RareStringData] = None
+    node_name: Optional[List[StringIndex]] = None
+    node_value: Optional[List[StringIndex]] = None
+    backend_node_id: Optional[List[DOM_BackendNodeId]] = None
+    attributes: Optional[List[ArrayOfStrings]] = None
+    text_value: Optional[RareStringData] = None
+    input_value: Optional[RareStringData] = None
+    input_checked: Optional[RareBooleanData] = None
+    option_selected: Optional[RareBooleanData] = None
+    content_document_index: Optional[RareIntegerData] = None
+    pseudo_type: Optional[RareStringData] = None
+    pseudo_identifier: Optional[RareStringData] = None
+    is_clickable: Optional[RareBooleanData] = None
+    current_source_url: Optional[RareStringData] = None
+    origin_url: Optional[RareStringData] = None
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('parent_index', 'parentIndex', True, 'array', inner=FieldMeta('', '', False, 'primitive')),
+        FieldMeta('node_type', 'nodeType', True, 'array', inner=FieldMeta('', '', False, 'primitive')),
+        FieldMeta('shadow_root_type', 'shadowRootType', True, 'object', ref='DOMSnapshot.RareStringData'),
+        FieldMeta('node_name', 'nodeName', True, 'array', inner=FieldMeta('', '', False, 'primitive')),
+        FieldMeta('node_value', 'nodeValue', True, 'array', inner=FieldMeta('', '', False, 'primitive')),
+        FieldMeta('backend_node_id', 'backendNodeId', True, 'array', inner=FieldMeta('', '', False, 'primitive')),
+        FieldMeta('attributes', 'attributes', True, 'array', inner=FieldMeta('', '', False, 'array', inner=FieldMeta('', '', False, 'primitive'))),
+        FieldMeta('text_value', 'textValue', True, 'object', ref='DOMSnapshot.RareStringData'),
+        FieldMeta('input_value', 'inputValue', True, 'object', ref='DOMSnapshot.RareStringData'),
+        FieldMeta('input_checked', 'inputChecked', True, 'object', ref='DOMSnapshot.RareBooleanData'),
+        FieldMeta('option_selected', 'optionSelected', True, 'object', ref='DOMSnapshot.RareBooleanData'),
+        FieldMeta('content_document_index', 'contentDocumentIndex', True, 'object', ref='DOMSnapshot.RareIntegerData'),
+        FieldMeta('pseudo_type', 'pseudoType', True, 'object', ref='DOMSnapshot.RareStringData'),
+        FieldMeta('pseudo_identifier', 'pseudoIdentifier', True, 'object', ref='DOMSnapshot.RareStringData'),
+        FieldMeta('is_clickable', 'isClickable', True, 'object', ref='DOMSnapshot.RareBooleanData'),
+        FieldMeta('current_source_url', 'currentSourceURL', True, 'object', ref='DOMSnapshot.RareStringData'),
+        FieldMeta('origin_url', 'originURL', True, 'object', ref='DOMSnapshot.RareStringData'),
+    )
+
+
+@register("DOMSnapshot.LayoutTreeSnapshot")
+@dataclass
+class LayoutTreeSnapshot(DataType):
+    """Table of details of an element in the DOM tree with a LayoutObject."""
+    node_index: List[int]
+    styles: List[ArrayOfStrings]
+    bounds: List[Rectangle]
+    text: List[StringIndex]
+    stacking_contexts: RareBooleanData
+    paint_orders: Optional[List[int]] = None
+    offset_rects: Optional[List[Rectangle]] = None
+    scroll_rects: Optional[List[Rectangle]] = None
+    client_rects: Optional[List[Rectangle]] = None
+    blended_background_colors: Optional[List[StringIndex]] = None
+    text_color_opacities: Optional[List[float]] = None
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('node_index', 'nodeIndex', False, 'array', inner=FieldMeta('', '', False, 'primitive')),
+        FieldMeta('styles', 'styles', False, 'array', inner=FieldMeta('', '', False, 'array', inner=FieldMeta('', '', False, 'primitive'))),
+        FieldMeta('bounds', 'bounds', False, 'array', inner=FieldMeta('', '', False, 'array', inner=FieldMeta('', '', False, 'primitive'))),
+        FieldMeta('text', 'text', False, 'array', inner=FieldMeta('', '', False, 'primitive')),
+        FieldMeta('stacking_contexts', 'stackingContexts', False, 'object', ref='DOMSnapshot.RareBooleanData'),
+        FieldMeta('paint_orders', 'paintOrders', True, 'array', inner=FieldMeta('', '', False, 'primitive')),
+        FieldMeta('offset_rects', 'offsetRects', True, 'array', inner=FieldMeta('', '', False, 'array', inner=FieldMeta('', '', False, 'primitive'))),
+        FieldMeta('scroll_rects', 'scrollRects', True, 'array', inner=FieldMeta('', '', False, 'array', inner=FieldMeta('', '', False, 'primitive'))),
+        FieldMeta('client_rects', 'clientRects', True, 'array', inner=FieldMeta('', '', False, 'array', inner=FieldMeta('', '', False, 'primitive'))),
+        FieldMeta('blended_background_colors', 'blendedBackgroundColors', True, 'array', inner=FieldMeta('', '', False, 'primitive')),
+        FieldMeta('text_color_opacities', 'textColorOpacities', True, 'array', inner=FieldMeta('', '', False, 'primitive')),
+    )
+
+
+@register("DOMSnapshot.TextBoxSnapshot")
+@dataclass
+class TextBoxSnapshot(DataType):
+    """
+    Table of details of the post layout rendered text positions. The exact layout should not be regarded as
+    stable and may change between versions.
+    """
+    layout_index: List[int]
+    bounds: List[Rectangle]
+    start: List[int]
+    length: List[int]
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('layout_index', 'layoutIndex', False, 'array', inner=FieldMeta('', '', False, 'primitive')),
+        FieldMeta('bounds', 'bounds', False, 'array', inner=FieldMeta('', '', False, 'array', inner=FieldMeta('', '', False, 'primitive'))),
+        FieldMeta('start', 'start', False, 'array', inner=FieldMeta('', '', False, 'primitive')),
+        FieldMeta('length', 'length', False, 'array', inner=FieldMeta('', '', False, 'primitive')),
+    )
+
+__all__ = ["ArrayOfStrings", "ComputedStyle", "DOMNode", "DocumentSnapshot", "InlineTextBox", "LayoutTreeNode", "LayoutTreeSnapshot", "NameValue", "NodeTreeSnapshot", "RareBooleanData", "RareIntegerData", "RareStringData", "Rectangle", "StringIndex", "TextBoxSnapshot"]

parsek_cdp/cdp/domstorage/__init__.py

@@ -0,0 +1,15 @@
+"""The DOMStorage CDP domain (generated).
+
+Importing ``DOMStorage`` from ``parsek_cdp.cdp`` gives a namespace with this
+domain's events and types as attributes (``DOMStorage.SomeEvent`` /
+``DOMStorage.SomeType``); commands run on a target via ``page.cdp.DOMStorage``.
+"""
+from . import events, functions, types
+from .functions import DOMStorage
+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=(DOMStorage,)``).
+DOMAIN = "DOMStorage"
+
+__all__ = ["events", "functions", "types", "DOMStorage", "DOMAIN"]

parsek_cdp/cdp/domstorage/events.py

@@ -0,0 +1,60 @@
+"""Events for the DOMStorage 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 FieldMeta
+from ..mixins.event import Event, register_event
+
+if TYPE_CHECKING:
+    from .types import StorageId
+
+@register_event("DOMStorage.domStorageItemAdded")
+@dataclass
+class DomStorageItemAdded(Event):
+    storage_id: StorageId
+    key: str
+    new_value: str
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('storage_id', 'storageId', False, 'object', ref='DOMStorage.StorageId'),
+        FieldMeta('key', 'key', False, 'primitive'),
+        FieldMeta('new_value', 'newValue', False, 'primitive'),
+    )
+
+
+@register_event("DOMStorage.domStorageItemRemoved")
+@dataclass
+class DomStorageItemRemoved(Event):
+    storage_id: StorageId
+    key: str
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('storage_id', 'storageId', False, 'object', ref='DOMStorage.StorageId'),
+        FieldMeta('key', 'key', False, 'primitive'),
+    )
+
+
+@register_event("DOMStorage.domStorageItemUpdated")
+@dataclass
+class DomStorageItemUpdated(Event):
+    storage_id: StorageId
+    key: str
+    old_value: str
+    new_value: str
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('storage_id', 'storageId', False, 'object', ref='DOMStorage.StorageId'),
+        FieldMeta('key', 'key', False, 'primitive'),
+        FieldMeta('old_value', 'oldValue', False, 'primitive'),
+        FieldMeta('new_value', 'newValue', False, 'primitive'),
+    )
+
+
+@register_event("DOMStorage.domStorageItemsCleared")
+@dataclass
+class DomStorageItemsCleared(Event):
+    storage_id: StorageId
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('storage_id', 'storageId', False, 'object', ref='DOMStorage.StorageId'),
+    )
+
+__all__ = ["DomStorageItemAdded", "DomStorageItemRemoved", "DomStorageItemUpdated", "DomStorageItemsCleared"]

parsek_cdp/cdp/domstorage/functions.py

@@ -0,0 +1,79 @@
+"""Commands for the DOMStorage 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 (
+        Item,
+        StorageId,
+    )
+
+@dataclass
+class GetDOMStorageItemsReturn(DataType):
+    """Return value of :meth:`DOMStorage.get_dom_storage_items`."""
+    entries: List[Item]
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('entries', 'entries', False, 'array', inner=FieldMeta('', '', False, 'array', inner=FieldMeta('', '', False, 'primitive'))),
+    )
+
+
+class DOMStorage:
+    """Commands of the DOMStorage domain, bound to a target."""
+
+    def __init__(self, target: Any) -> None:
+        self._target = target
+
+
+    async def clear(self, *, storage_id: StorageId) -> None:
+        """:param storage_id:"""
+        _params: Dict[str, Any] = {}
+        _params['storageId'] = encode(FieldMeta('', '', False, 'object', ref='DOMStorage.StorageId'), storage_id)
+        _result = await self._target.send('DOMStorage.clear', _params)
+        return None
+
+    async def disable(self) -> None:
+        """Disables storage tracking, prevents storage events from being sent to the client."""
+        _params: Dict[str, Any] = {}
+        _result = await self._target.send('DOMStorage.disable', _params)
+        return None
+
+    async def enable(self) -> None:
+        """Enables storage tracking, storage events will now be delivered to the client."""
+        _params: Dict[str, Any] = {}
+        _result = await self._target.send('DOMStorage.enable', _params)
+        return None
+
+    async def get_dom_storage_items(self, *, storage_id: StorageId) -> GetDOMStorageItemsReturn:
+        """:param storage_id:"""
+        _params: Dict[str, Any] = {}
+        _params['storageId'] = encode(FieldMeta('', '', False, 'object', ref='DOMStorage.StorageId'), storage_id)
+        _result = await self._target.send('DOMStorage.getDOMStorageItems', _params)
+        return GetDOMStorageItemsReturn.from_json(_result)
+
+    async def remove_dom_storage_item(self, *, storage_id: StorageId, key: str) -> None:
+        """
+        :param storage_id:
+        :param key:
+        """
+        _params: Dict[str, Any] = {}
+        _params['storageId'] = encode(FieldMeta('', '', False, 'object', ref='DOMStorage.StorageId'), storage_id)
+        _params['key'] = encode(FieldMeta('', '', False, 'primitive'), key)
+        _result = await self._target.send('DOMStorage.removeDOMStorageItem', _params)
+        return None
+
+    async def set_dom_storage_item(self, *, storage_id: StorageId, key: str, value: str) -> None:
+        """
+        :param storage_id:
+        :param key:
+        :param value:
+        """
+        _params: Dict[str, Any] = {}
+        _params['storageId'] = encode(FieldMeta('', '', False, 'object', ref='DOMStorage.StorageId'), storage_id)
+        _params['key'] = encode(FieldMeta('', '', False, 'primitive'), key)
+        _params['value'] = encode(FieldMeta('', '', False, 'primitive'), value)
+        _result = await self._target.send('DOMStorage.setDOMStorageItem', _params)
+        return None

parsek_cdp/cdp/domstorage/types.py

@@ -0,0 +1,30 @@
+"""Custom types and enums for the DOMStorage 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
+
+
+type SerializedStorageKey = str
+
+
+@register("DOMStorage.StorageId")
+@dataclass
+class StorageId(DataType):
+    """DOM Storage identifier."""
+    is_local_storage: bool
+    security_origin: Optional[str] = None
+    storage_key: Optional[SerializedStorageKey] = None
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('is_local_storage', 'isLocalStorage', False, 'primitive'),
+        FieldMeta('security_origin', 'securityOrigin', True, 'primitive'),
+        FieldMeta('storage_key', 'storageKey', True, 'primitive'),
+    )
+
+
+type Item = List[str]  # DOM Storage item.
+
+__all__ = ["Item", "SerializedStorageKey", "StorageId"]

parsek_cdp/cdp/emulation/__init__.py

@@ -0,0 +1,15 @@
+"""The Emulation CDP domain (generated).
+
+Importing ``Emulation`` from ``parsek_cdp.cdp`` gives a namespace with this
+domain's events and types as attributes (``Emulation.SomeEvent`` /
+``Emulation.SomeType``); commands run on a target via ``page.cdp.Emulation``.
+"""
+from . import events, functions, types
+from .functions import Emulation
+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=(Emulation,)``).
+DOMAIN = "Emulation"
+
+__all__ = ["events", "functions", "types", "Emulation", "DOMAIN"]

parsek_cdp/cdp/emulation/events.py

@@ -0,0 +1,17 @@
+"""Events for the Emulation 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("Emulation.virtualTimeBudgetExpired")
+@dataclass
+class VirtualTimeBudgetExpired(Event):
+    """Notification sent after the virtual time budget for the current VirtualTimePolicy has run out."""
+    __FIELDS__: ClassVar[tuple] = ()
+
+__all__ = ["VirtualTimeBudgetExpired"]