parsek-cdp 0.1.0__py3-none-any.whl

parsek_cdp/cdp/io/functions.py

@@ -0,0 +1,77 @@
+"""Commands for the IO 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 StreamHandle
+    from ..runtime.types import RemoteObjectId as Runtime_RemoteObjectId
+
+@dataclass
+class ReadReturn(DataType):
+    """Return value of :meth:`IO.read`."""
+    data: str
+    eof: bool
+    base64_encoded: Optional[bool] = None
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('data', 'data', False, 'primitive'),
+        FieldMeta('eof', 'eof', False, 'primitive'),
+        FieldMeta('base64_encoded', 'base64Encoded', True, 'primitive'),
+    )
+
+
+@dataclass
+class ResolveBlobReturn(DataType):
+    """Return value of :meth:`IO.resolve_blob`."""
+    uuid: str
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('uuid', 'uuid', False, 'primitive'),
+    )
+
+
+class IO:
+    """Commands of the IO domain, bound to a target."""
+
+    def __init__(self, target: Any) -> None:
+        self._target = target
+
+
+    async def close(self, *, handle: StreamHandle) -> None:
+        """
+        Close the stream, discard any temporary backing storage.
+        :param handle: Handle of the stream to close.
+        """
+        _params: Dict[str, Any] = {}
+        _params['handle'] = encode(FieldMeta('', '', False, 'primitive'), handle)
+        _result = await self._target.send('IO.close', _params)
+        return None
+
+    async def read(self, *, handle: StreamHandle, offset: Optional[int] = None, size: Optional[int] = None) -> ReadReturn:
+        """
+        Read a chunk of the stream
+        :param handle: Handle of the stream to read.
+        :param offset: Seek to the specified offset before reading (if not specified, proceed with offset
+        following the last read). Some types of streams may only support sequential reads.
+        :param size: Maximum number of bytes to read (left upon the agent discretion if not specified).
+        """
+        _params: Dict[str, Any] = {}
+        _params['handle'] = encode(FieldMeta('', '', False, 'primitive'), handle)
+        if offset is not None:
+            _params['offset'] = encode(FieldMeta('', '', False, 'primitive'), offset)
+        if size is not None:
+            _params['size'] = encode(FieldMeta('', '', False, 'primitive'), size)
+        _result = await self._target.send('IO.read', _params)
+        return ReadReturn.from_json(_result)
+
+    async def resolve_blob(self, *, object_id: Runtime_RemoteObjectId) -> ResolveBlobReturn:
+        """
+        Return UUID of Blob object specified by a remote object id.
+        :param object_id: Object id of a Blob object wrapper.
+        """
+        _params: Dict[str, Any] = {}
+        _params['objectId'] = encode(FieldMeta('', '', False, 'primitive'), object_id)
+        _result = await self._target.send('IO.resolveBlob', _params)
+        return ResolveBlobReturn.from_json(_result)

parsek_cdp/cdp/io/types.py

@@ -0,0 +1,13 @@
+"""Custom types and enums for the IO 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 StreamHandle = str  # This is either obtained from another method or specified as `blob:<uuid>` where
+
+__all__ = ["StreamHandle"]

parsek_cdp/cdp/layertree/__init__.py

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

parsek_cdp/cdp/layertree/events.py

@@ -0,0 +1,36 @@
+"""Events for the LayerTree 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 (
+        Layer,
+        LayerId,
+    )
+    from ..dom.types import Rect as DOM_Rect
+
+@register_event("LayerTree.layerPainted")
+@dataclass
+class LayerPainted(Event):
+    layer_id: LayerId
+    clip: DOM_Rect
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('layer_id', 'layerId', False, 'primitive'),
+        FieldMeta('clip', 'clip', False, 'object', ref='DOM.Rect'),
+    )
+
+
+@register_event("LayerTree.layerTreeDidChange")
+@dataclass
+class LayerTreeDidChange(Event):
+    layers: Optional[List[Layer]] = None
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('layers', 'layers', True, 'array', inner=FieldMeta('', '', False, 'object', ref='LayerTree.Layer')),
+    )
+
+__all__ = ["LayerPainted", "LayerTreeDidChange"]

parsek_cdp/cdp/layertree/functions.py

@@ -0,0 +1,178 @@
+"""Commands for the LayerTree 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 (
+        LayerId,
+        PaintProfile,
+        PictureTile,
+        SnapshotId,
+    )
+    from ..dom.types import Rect as DOM_Rect
+
+@dataclass
+class CompositingReasonsReturn(DataType):
+    """Return value of :meth:`LayerTree.compositing_reasons`."""
+    compositing_reasons: List[str]
+    compositing_reason_ids: List[str]
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('compositing_reasons', 'compositingReasons', False, 'array', inner=FieldMeta('', '', False, 'primitive')),
+        FieldMeta('compositing_reason_ids', 'compositingReasonIds', False, 'array', inner=FieldMeta('', '', False, 'primitive')),
+    )
+
+
+@dataclass
+class LoadSnapshotReturn(DataType):
+    """Return value of :meth:`LayerTree.load_snapshot`."""
+    snapshot_id: SnapshotId
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('snapshot_id', 'snapshotId', False, 'primitive'),
+    )
+
+
+@dataclass
+class MakeSnapshotReturn(DataType):
+    """Return value of :meth:`LayerTree.make_snapshot`."""
+    snapshot_id: SnapshotId
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('snapshot_id', 'snapshotId', False, 'primitive'),
+    )
+
+
+@dataclass
+class ProfileSnapshotReturn(DataType):
+    """Return value of :meth:`LayerTree.profile_snapshot`."""
+    timings: List[PaintProfile]
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('timings', 'timings', False, 'array', inner=FieldMeta('', '', False, 'array', inner=FieldMeta('', '', False, 'primitive'))),
+    )
+
+
+@dataclass
+class ReplaySnapshotReturn(DataType):
+    """Return value of :meth:`LayerTree.replay_snapshot`."""
+    data_url: str
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('data_url', 'dataURL', False, 'primitive'),
+    )
+
+
+@dataclass
+class SnapshotCommandLogReturn(DataType):
+    """Return value of :meth:`LayerTree.snapshot_command_log`."""
+    command_log: List[Dict[str, Any]]
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('command_log', 'commandLog', False, 'array', inner=FieldMeta('', '', False, 'primitive')),
+    )
+
+
+class LayerTree:
+    """Commands of the LayerTree domain, bound to a target."""
+
+    def __init__(self, target: Any) -> None:
+        self._target = target
+
+
+    async def compositing_reasons(self, *, layer_id: LayerId) -> CompositingReasonsReturn:
+        """
+        Provides the reasons why the given layer was composited.
+        :param layer_id: The id of the layer for which we want to get the reasons it was composited.
+        """
+        _params: Dict[str, Any] = {}
+        _params['layerId'] = encode(FieldMeta('', '', False, 'primitive'), layer_id)
+        _result = await self._target.send('LayerTree.compositingReasons', _params)
+        return CompositingReasonsReturn.from_json(_result)
+
+    async def disable(self) -> None:
+        """Disables compositing tree inspection."""
+        _params: Dict[str, Any] = {}
+        _result = await self._target.send('LayerTree.disable', _params)
+        return None
+
+    async def enable(self) -> None:
+        """Enables compositing tree inspection."""
+        _params: Dict[str, Any] = {}
+        _result = await self._target.send('LayerTree.enable', _params)
+        return None
+
+    async def load_snapshot(self, *, tiles: List[PictureTile]) -> LoadSnapshotReturn:
+        """
+        Returns the snapshot identifier.
+        :param tiles: An array of tiles composing the snapshot.
+        """
+        _params: Dict[str, Any] = {}
+        _params['tiles'] = encode(FieldMeta('', '', False, 'array', inner=FieldMeta('', '', False, 'object', ref='LayerTree.PictureTile')), tiles)
+        _result = await self._target.send('LayerTree.loadSnapshot', _params)
+        return LoadSnapshotReturn.from_json(_result)
+
+    async def make_snapshot(self, *, layer_id: LayerId) -> MakeSnapshotReturn:
+        """
+        Returns the layer snapshot identifier.
+        :param layer_id: The id of the layer.
+        """
+        _params: Dict[str, Any] = {}
+        _params['layerId'] = encode(FieldMeta('', '', False, 'primitive'), layer_id)
+        _result = await self._target.send('LayerTree.makeSnapshot', _params)
+        return MakeSnapshotReturn.from_json(_result)
+
+    async def profile_snapshot(self, *, snapshot_id: SnapshotId, min_repeat_count: Optional[int] = None, min_duration: Optional[float] = None, clip_rect: Optional[DOM_Rect] = None) -> ProfileSnapshotReturn:
+        """
+        :param snapshot_id: The id of the layer snapshot.
+        :param min_repeat_count: The maximum number of times to replay the snapshot (1, if not specified).
+        :param min_duration: The minimum duration (in seconds) to replay the snapshot.
+        :param clip_rect: The clip rectangle to apply when replaying the snapshot.
+        """
+        _params: Dict[str, Any] = {}
+        _params['snapshotId'] = encode(FieldMeta('', '', False, 'primitive'), snapshot_id)
+        if min_repeat_count is not None:
+            _params['minRepeatCount'] = encode(FieldMeta('', '', False, 'primitive'), min_repeat_count)
+        if min_duration is not None:
+            _params['minDuration'] = encode(FieldMeta('', '', False, 'primitive'), min_duration)
+        if clip_rect is not None:
+            _params['clipRect'] = encode(FieldMeta('', '', False, 'object', ref='DOM.Rect'), clip_rect)
+        _result = await self._target.send('LayerTree.profileSnapshot', _params)
+        return ProfileSnapshotReturn.from_json(_result)
+
+    async def release_snapshot(self, *, snapshot_id: SnapshotId) -> None:
+        """
+        Releases layer snapshot captured by the back-end.
+        :param snapshot_id: The id of the layer snapshot.
+        """
+        _params: Dict[str, Any] = {}
+        _params['snapshotId'] = encode(FieldMeta('', '', False, 'primitive'), snapshot_id)
+        _result = await self._target.send('LayerTree.releaseSnapshot', _params)
+        return None
+
+    async def replay_snapshot(self, *, snapshot_id: SnapshotId, from_step: Optional[int] = None, to_step: Optional[int] = None, scale: Optional[float] = None) -> ReplaySnapshotReturn:
+        """
+        Replays the layer snapshot and returns the resulting bitmap.
+        :param snapshot_id: The id of the layer snapshot.
+        :param from_step: The first step to replay from (replay from the very start if not specified).
+        :param to_step: The last step to replay to (replay till the end if not specified).
+        :param scale: The scale to apply while replaying (defaults to 1).
+        """
+        _params: Dict[str, Any] = {}
+        _params['snapshotId'] = encode(FieldMeta('', '', False, 'primitive'), snapshot_id)
+        if from_step is not None:
+            _params['fromStep'] = encode(FieldMeta('', '', False, 'primitive'), from_step)
+        if to_step is not None:
+            _params['toStep'] = encode(FieldMeta('', '', False, 'primitive'), to_step)
+        if scale is not None:
+            _params['scale'] = encode(FieldMeta('', '', False, 'primitive'), scale)
+        _result = await self._target.send('LayerTree.replaySnapshot', _params)
+        return ReplaySnapshotReturn.from_json(_result)
+
+    async def snapshot_command_log(self, *, snapshot_id: SnapshotId) -> SnapshotCommandLogReturn:
+        """
+        Replays the layer snapshot and returns canvas log.
+        :param snapshot_id: The id of the layer snapshot.
+        """
+        _params: Dict[str, Any] = {}
+        _params['snapshotId'] = encode(FieldMeta('', '', False, 'primitive'), snapshot_id)
+        _result = await self._target.send('LayerTree.snapshotCommandLog', _params)
+        return SnapshotCommandLogReturn.from_json(_result)

parsek_cdp/cdp/layertree/types.py

@@ -0,0 +1,104 @@
+"""Custom types and enums for the LayerTree 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 Rect as DOM_Rect
+
+type LayerId = str  # Unique Layer identifier.
+
+
+type SnapshotId = str  # Unique snapshot identifier.
+
+
+@register("LayerTree.ScrollRect")
+@dataclass
+class ScrollRect(DataType):
+    """Rectangle where scrolling happens on the main thread."""
+    rect: DOM_Rect
+    type_: Literal['RepaintsOnScroll', 'TouchEventHandler', 'WheelEventHandler']
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('rect', 'rect', False, 'object', ref='DOM.Rect'),
+        FieldMeta('type_', 'type', False, 'primitive'),
+    )
+
+
+@register("LayerTree.StickyPositionConstraint")
+@dataclass
+class StickyPositionConstraint(DataType):
+    """Sticky position constraints."""
+    sticky_box_rect: DOM_Rect
+    containing_block_rect: DOM_Rect
+    nearest_layer_shifting_sticky_box: Optional[LayerId] = None
+    nearest_layer_shifting_containing_block: Optional[LayerId] = None
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('sticky_box_rect', 'stickyBoxRect', False, 'object', ref='DOM.Rect'),
+        FieldMeta('containing_block_rect', 'containingBlockRect', False, 'object', ref='DOM.Rect'),
+        FieldMeta('nearest_layer_shifting_sticky_box', 'nearestLayerShiftingStickyBox', True, 'primitive'),
+        FieldMeta('nearest_layer_shifting_containing_block', 'nearestLayerShiftingContainingBlock', True, 'primitive'),
+    )
+
+
+@register("LayerTree.PictureTile")
+@dataclass
+class PictureTile(DataType):
+    """Serialized fragment of layer picture along with its offset within the layer."""
+    x: float
+    y: float
+    picture: str
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('x', 'x', False, 'primitive'),
+        FieldMeta('y', 'y', False, 'primitive'),
+        FieldMeta('picture', 'picture', False, 'primitive'),
+    )
+
+
+@register("LayerTree.Layer")
+@dataclass
+class Layer(DataType):
+    """Information about a compositing layer."""
+    layer_id: LayerId
+    offset_x: float
+    offset_y: float
+    width: float
+    height: float
+    paint_count: int
+    draws_content: bool
+    parent_layer_id: Optional[LayerId] = None
+    backend_node_id: Optional[DOM_BackendNodeId] = None
+    transform: Optional[List[float]] = None
+    anchor_x: Optional[float] = None
+    anchor_y: Optional[float] = None
+    anchor_z: Optional[float] = None
+    invisible: Optional[bool] = None
+    scroll_rects: Optional[List[ScrollRect]] = None
+    sticky_position_constraint: Optional[StickyPositionConstraint] = None
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('layer_id', 'layerId', False, 'primitive'),
+        FieldMeta('offset_x', 'offsetX', False, 'primitive'),
+        FieldMeta('offset_y', 'offsetY', False, 'primitive'),
+        FieldMeta('width', 'width', False, 'primitive'),
+        FieldMeta('height', 'height', False, 'primitive'),
+        FieldMeta('paint_count', 'paintCount', False, 'primitive'),
+        FieldMeta('draws_content', 'drawsContent', False, 'primitive'),
+        FieldMeta('parent_layer_id', 'parentLayerId', True, 'primitive'),
+        FieldMeta('backend_node_id', 'backendNodeId', True, 'primitive'),
+        FieldMeta('transform', 'transform', True, 'array', inner=FieldMeta('', '', False, 'primitive')),
+        FieldMeta('anchor_x', 'anchorX', True, 'primitive'),
+        FieldMeta('anchor_y', 'anchorY', True, 'primitive'),
+        FieldMeta('anchor_z', 'anchorZ', True, 'primitive'),
+        FieldMeta('invisible', 'invisible', True, 'primitive'),
+        FieldMeta('scroll_rects', 'scrollRects', True, 'array', inner=FieldMeta('', '', False, 'object', ref='LayerTree.ScrollRect')),
+        FieldMeta('sticky_position_constraint', 'stickyPositionConstraint', True, 'object', ref='LayerTree.StickyPositionConstraint'),
+    )
+
+
+type PaintProfile = List[float]  # Array of timings, one per paint step.
+
+__all__ = ["Layer", "LayerId", "PaintProfile", "PictureTile", "ScrollRect", "SnapshotId", "StickyPositionConstraint"]

parsek_cdp/cdp/log/__init__.py

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

parsek_cdp/cdp/log/events.py

@@ -0,0 +1,22 @@
+"""Events for the Log 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 LogEntry
+
+@register_event("Log.entryAdded")
+@dataclass
+class EntryAdded(Event):
+    """Issued when new message was logged."""
+    entry: LogEntry
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('entry', 'entry', False, 'object', ref='Log.LogEntry'),
+    )
+
+__all__ = ["EntryAdded"]

parsek_cdp/cdp/log/functions.py

@@ -0,0 +1,54 @@
+"""Commands for the Log 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 ViolationSetting
+
+class Log:
+    """Commands of the Log domain, bound to a target."""
+
+    def __init__(self, target: Any) -> None:
+        self._target = target
+
+
+    async def clear(self) -> None:
+        """Clears the log."""
+        _params: Dict[str, Any] = {}
+        _result = await self._target.send('Log.clear', _params)
+        return None
+
+    async def disable(self) -> None:
+        """Disables log domain, prevents further log entries from being reported to the client."""
+        _params: Dict[str, Any] = {}
+        _result = await self._target.send('Log.disable', _params)
+        return None
+
+    async def enable(self) -> None:
+        """
+        Enables log domain, sends the entries collected so far to the client by means of the
+        `entryAdded` notification.
+        """
+        _params: Dict[str, Any] = {}
+        _result = await self._target.send('Log.enable', _params)
+        return None
+
+    async def start_violations_report(self, *, config: List[ViolationSetting]) -> None:
+        """
+        start violation reporting.
+        :param config: Configuration for violations.
+        """
+        _params: Dict[str, Any] = {}
+        _params['config'] = encode(FieldMeta('', '', False, 'array', inner=FieldMeta('', '', False, 'object', ref='Log.ViolationSetting')), config)
+        _result = await self._target.send('Log.startViolationsReport', _params)
+        return None
+
+    async def stop_violations_report(self) -> None:
+        """Stop violation reporting."""
+        _params: Dict[str, Any] = {}
+        _result = await self._target.send('Log.stopViolationsReport', _params)
+        return None

parsek_cdp/cdp/log/types.py

@@ -0,0 +1,57 @@
+"""Custom types and enums for the Log 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 ..network.types import RequestId as Network_RequestId
+    from ..runtime.types import RemoteObject as Runtime_RemoteObject
+    from ..runtime.types import StackTrace as Runtime_StackTrace
+    from ..runtime.types import Timestamp as Runtime_Timestamp
+
+@register("Log.LogEntry")
+@dataclass
+class LogEntry(DataType):
+    """Log entry."""
+    source: Literal['xml', 'javascript', 'network', 'storage', 'appcache', 'rendering', 'security', 'deprecation', 'worker', 'violation', 'intervention', 'recommendation', 'other']
+    level: Literal['verbose', 'info', 'warning', 'error']
+    text: str
+    timestamp: Runtime_Timestamp
+    category: Optional[Literal['cors']] = None
+    url: Optional[str] = None
+    line_number: Optional[int] = None
+    stack_trace: Optional[Runtime_StackTrace] = None
+    network_request_id: Optional[Network_RequestId] = None
+    worker_id: Optional[str] = None
+    args: Optional[List[Runtime_RemoteObject]] = None
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('source', 'source', False, 'primitive'),
+        FieldMeta('level', 'level', False, 'primitive'),
+        FieldMeta('text', 'text', False, 'primitive'),
+        FieldMeta('timestamp', 'timestamp', False, 'primitive'),
+        FieldMeta('category', 'category', True, 'primitive'),
+        FieldMeta('url', 'url', True, 'primitive'),
+        FieldMeta('line_number', 'lineNumber', True, 'primitive'),
+        FieldMeta('stack_trace', 'stackTrace', True, 'object', ref='Runtime.StackTrace'),
+        FieldMeta('network_request_id', 'networkRequestId', True, 'primitive'),
+        FieldMeta('worker_id', 'workerId', True, 'primitive'),
+        FieldMeta('args', 'args', True, 'array', inner=FieldMeta('', '', False, 'object', ref='Runtime.RemoteObject')),
+    )
+
+
+@register("Log.ViolationSetting")
+@dataclass
+class ViolationSetting(DataType):
+    """Violation configuration setting."""
+    name: Literal['longTask', 'longLayout', 'blockedEvent', 'blockedParser', 'discouragedAPIUse', 'handler', 'recurringHandler']
+    threshold: float
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('name', 'name', False, 'primitive'),
+        FieldMeta('threshold', 'threshold', False, 'primitive'),
+    )
+
+__all__ = ["LogEntry", "ViolationSetting"]

parsek_cdp/cdp/media/__init__.py

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