parsek-cdp 0.1.0__py3-none-any.whl

parsek_cdp/cdp/filesystem/types.py

@@ -0,0 +1,54 @@
+"""Custom types and enums for the FileSystem 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 TimeSinceEpoch as Network_TimeSinceEpoch
+    from ..storage.types import SerializedStorageKey as Storage_SerializedStorageKey
+
+@register("FileSystem.File")
+@dataclass
+class File(DataType):
+    name: str
+    last_modified: Network_TimeSinceEpoch
+    size: float
+    type_: str
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('name', 'name', False, 'primitive'),
+        FieldMeta('last_modified', 'lastModified', False, 'primitive'),
+        FieldMeta('size', 'size', False, 'primitive'),
+        FieldMeta('type_', 'type', False, 'primitive'),
+    )
+
+
+@register("FileSystem.Directory")
+@dataclass
+class Directory(DataType):
+    name: str
+    nested_directories: List[str]
+    nested_files: List[File]
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('name', 'name', False, 'primitive'),
+        FieldMeta('nested_directories', 'nestedDirectories', False, 'array', inner=FieldMeta('', '', False, 'primitive')),
+        FieldMeta('nested_files', 'nestedFiles', False, 'array', inner=FieldMeta('', '', False, 'object', ref='FileSystem.File')),
+    )
+
+
+@register("FileSystem.BucketFileSystemLocator")
+@dataclass
+class BucketFileSystemLocator(DataType):
+    storage_key: Storage_SerializedStorageKey
+    path_components: List[str]
+    bucket_name: Optional[str] = None
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('storage_key', 'storageKey', False, 'primitive'),
+        FieldMeta('path_components', 'pathComponents', False, 'array', inner=FieldMeta('', '', False, 'primitive')),
+        FieldMeta('bucket_name', 'bucketName', True, 'primitive'),
+    )
+
+__all__ = ["BucketFileSystemLocator", "Directory", "File"]

parsek_cdp/cdp/headlessexperimental/__init__.py

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

parsek_cdp/cdp/headlessexperimental/events.py

@@ -0,0 +1,13 @@
+"""Events for the HeadlessExperimental 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__ = []

parsek_cdp/cdp/headlessexperimental/functions.py

@@ -0,0 +1,77 @@
+"""Commands for the HeadlessExperimental 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 ScreenshotParams
+
+@dataclass
+class BeginFrameReturn(DataType):
+    """Return value of :meth:`HeadlessExperimental.begin_frame`."""
+    has_damage: bool
+    screenshot_data: Optional[str] = None
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('has_damage', 'hasDamage', False, 'primitive'),
+        FieldMeta('screenshot_data', 'screenshotData', True, 'primitive'),
+    )
+
+
+class HeadlessExperimental:
+    """Commands of the HeadlessExperimental domain, bound to a target."""
+
+    def __init__(self, target: Any) -> None:
+        self._target = target
+
+
+    async def begin_frame(self, *, frame_time_ticks: Optional[float] = None, interval: Optional[float] = None, no_display_updates: Optional[bool] = None, screenshot: Optional[ScreenshotParams] = None) -> BeginFrameReturn:
+        """
+        Sends a BeginFrame to the target and returns when the frame was completed. Optionally captures a
+        screenshot from the resulting frame. Requires that the target was created with enabled
+        BeginFrameControl. Designed for use with --run-all-compositor-stages-before-draw, see also
+        https://goo.gle/chrome-headless-rendering for more background.
+        :param frame_time_ticks: Timestamp of this BeginFrame in Renderer TimeTicks (milliseconds of uptime). If not set,
+        the current time will be used.
+        :param interval: The interval between BeginFrames that is reported to the compositor, in milliseconds.
+        Defaults to a 60 frames/second interval, i.e. about 16.666 milliseconds.
+        :param no_display_updates: Whether updates should not be committed and drawn onto the display. False by default. If
+        true, only side effects of the BeginFrame will be run, such as layout and animations, but
+        any visual updates may not be visible on the display or in screenshots.
+        :param screenshot: If set, a screenshot of the frame will be captured and returned in the response. Otherwise,
+        no screenshot will be captured. Note that capturing a screenshot can fail, for example,
+        during renderer initialization. In such a case, no screenshot data will be returned.
+        """
+        _params: Dict[str, Any] = {}
+        if frame_time_ticks is not None:
+            _params['frameTimeTicks'] = encode(FieldMeta('', '', False, 'primitive'), frame_time_ticks)
+        if interval is not None:
+            _params['interval'] = encode(FieldMeta('', '', False, 'primitive'), interval)
+        if no_display_updates is not None:
+            _params['noDisplayUpdates'] = encode(FieldMeta('', '', False, 'primitive'), no_display_updates)
+        if screenshot is not None:
+            _params['screenshot'] = encode(FieldMeta('', '', False, 'object', ref='HeadlessExperimental.ScreenshotParams'), screenshot)
+        _result = await self._target.send('HeadlessExperimental.beginFrame', _params)
+        return BeginFrameReturn.from_json(_result)
+
+    async def disable(self) -> None:
+        """
+        Disables headless events for the target.
+        
+        .. deprecated::
+        """
+        _params: Dict[str, Any] = {}
+        _result = await self._target.send('HeadlessExperimental.disable', _params)
+        return None
+
+    async def enable(self) -> None:
+        """
+        Enables headless events for the target.
+        
+        .. deprecated::
+        """
+        _params: Dict[str, Any] = {}
+        _result = await self._target.send('HeadlessExperimental.enable', _params)
+        return None

parsek_cdp/cdp/headlessexperimental/types.py

@@ -0,0 +1,24 @@
+"""Custom types and enums for the HeadlessExperimental 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("HeadlessExperimental.ScreenshotParams")
+@dataclass
+class ScreenshotParams(DataType):
+    """Encoding options for a screenshot."""
+    format: Optional[Literal['jpeg', 'png', 'webp']] = None
+    quality: Optional[int] = None
+    optimize_for_speed: Optional[bool] = None
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('format', 'format', True, 'primitive'),
+        FieldMeta('quality', 'quality', True, 'primitive'),
+        FieldMeta('optimize_for_speed', 'optimizeForSpeed', True, 'primitive'),
+    )
+
+__all__ = ["ScreenshotParams"]

parsek_cdp/cdp/heapprofiler/__init__.py

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

parsek_cdp/cdp/heapprofiler/events.py

@@ -0,0 +1,65 @@
+"""Events for the HeapProfiler 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("HeapProfiler.addHeapSnapshotChunk")
+@dataclass
+class AddHeapSnapshotChunk(Event):
+    chunk: str
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('chunk', 'chunk', False, 'primitive'),
+    )
+
+
+@register_event("HeapProfiler.heapStatsUpdate")
+@dataclass
+class HeapStatsUpdate(Event):
+    """If heap objects tracking has been started then backend may send update for one or more fragments"""
+    stats_update: List[int]
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('stats_update', 'statsUpdate', False, 'array', inner=FieldMeta('', '', False, 'primitive')),
+    )
+
+
+@register_event("HeapProfiler.lastSeenObjectId")
+@dataclass
+class LastSeenObjectId(Event):
+    """
+    If heap objects tracking has been started then backend regularly sends a current value for last
+    seen object id and corresponding timestamp. If the were changes in the heap since last event
+    then one or more heapStatsUpdate events will be sent before a new lastSeenObjectId event.
+    """
+    last_seen_object_id: int
+    timestamp: float
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('last_seen_object_id', 'lastSeenObjectId', False, 'primitive'),
+        FieldMeta('timestamp', 'timestamp', False, 'primitive'),
+    )
+
+
+@register_event("HeapProfiler.reportHeapSnapshotProgress")
+@dataclass
+class ReportHeapSnapshotProgress(Event):
+    done: int
+    total: int
+    finished: Optional[bool] = None
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('done', 'done', False, 'primitive'),
+        FieldMeta('total', 'total', False, 'primitive'),
+        FieldMeta('finished', 'finished', True, 'primitive'),
+    )
+
+
+@register_event("HeapProfiler.resetProfiles")
+@dataclass
+class ResetProfiles(Event):
+    pass
+    __FIELDS__: ClassVar[tuple] = ()
+
+__all__ = ["AddHeapSnapshotChunk", "HeapStatsUpdate", "LastSeenObjectId", "ReportHeapSnapshotProgress", "ResetProfiles"]

parsek_cdp/cdp/heapprofiler/functions.py

@@ -0,0 +1,193 @@
+"""Commands for the HeapProfiler 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 (
+        HeapSnapshotObjectId,
+        SamplingHeapProfile,
+    )
+    from ..runtime.types import RemoteObject as Runtime_RemoteObject
+    from ..runtime.types import RemoteObjectId as Runtime_RemoteObjectId
+
+@dataclass
+class GetHeapObjectIdReturn(DataType):
+    """Return value of :meth:`HeapProfiler.get_heap_object_id`."""
+    heap_snapshot_object_id: HeapSnapshotObjectId
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('heap_snapshot_object_id', 'heapSnapshotObjectId', False, 'primitive'),
+    )
+
+
+@dataclass
+class GetObjectByHeapObjectIdReturn(DataType):
+    """Return value of :meth:`HeapProfiler.get_object_by_heap_object_id`."""
+    result: Runtime_RemoteObject
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('result', 'result', False, 'object', ref='Runtime.RemoteObject'),
+    )
+
+
+@dataclass
+class GetSamplingProfileReturn(DataType):
+    """Return value of :meth:`HeapProfiler.get_sampling_profile`."""
+    profile: SamplingHeapProfile
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('profile', 'profile', False, 'object', ref='HeapProfiler.SamplingHeapProfile'),
+    )
+
+
+@dataclass
+class StopSamplingReturn(DataType):
+    """Return value of :meth:`HeapProfiler.stop_sampling`."""
+    profile: SamplingHeapProfile
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('profile', 'profile', False, 'object', ref='HeapProfiler.SamplingHeapProfile'),
+    )
+
+
+class HeapProfiler:
+    """Commands of the HeapProfiler domain, bound to a target."""
+
+    def __init__(self, target: Any) -> None:
+        self._target = target
+
+
+    async def add_inspected_heap_object(self, *, heap_object_id: HeapSnapshotObjectId) -> None:
+        """
+        Enables console to refer to the node with given id via $x (see Command Line API for more details
+        $x functions).
+        :param heap_object_id: Heap snapshot object id to be accessible by means of $x command line API.
+        """
+        _params: Dict[str, Any] = {}
+        _params['heapObjectId'] = encode(FieldMeta('', '', False, 'primitive'), heap_object_id)
+        _result = await self._target.send('HeapProfiler.addInspectedHeapObject', _params)
+        return None
+
+    async def collect_garbage(self) -> None:
+        _params: Dict[str, Any] = {}
+        _result = await self._target.send('HeapProfiler.collectGarbage', _params)
+        return None
+
+    async def disable(self) -> None:
+        _params: Dict[str, Any] = {}
+        _result = await self._target.send('HeapProfiler.disable', _params)
+        return None
+
+    async def enable(self) -> None:
+        _params: Dict[str, Any] = {}
+        _result = await self._target.send('HeapProfiler.enable', _params)
+        return None
+
+    async def get_heap_object_id(self, *, object_id: Runtime_RemoteObjectId) -> GetHeapObjectIdReturn:
+        """:param object_id: Identifier of the object to get heap object id for."""
+        _params: Dict[str, Any] = {}
+        _params['objectId'] = encode(FieldMeta('', '', False, 'primitive'), object_id)
+        _result = await self._target.send('HeapProfiler.getHeapObjectId', _params)
+        return GetHeapObjectIdReturn.from_json(_result)
+
+    async def get_object_by_heap_object_id(self, *, object_id: HeapSnapshotObjectId, object_group: Optional[str] = None) -> GetObjectByHeapObjectIdReturn:
+        """
+        :param object_id:
+        :param object_group: Symbolic group name that can be used to release multiple objects.
+        """
+        _params: Dict[str, Any] = {}
+        _params['objectId'] = encode(FieldMeta('', '', False, 'primitive'), object_id)
+        if object_group is not None:
+            _params['objectGroup'] = encode(FieldMeta('', '', False, 'primitive'), object_group)
+        _result = await self._target.send('HeapProfiler.getObjectByHeapObjectId', _params)
+        return GetObjectByHeapObjectIdReturn.from_json(_result)
+
+    async def get_sampling_profile(self) -> GetSamplingProfileReturn:
+        _params: Dict[str, Any] = {}
+        _result = await self._target.send('HeapProfiler.getSamplingProfile', _params)
+        return GetSamplingProfileReturn.from_json(_result)
+
+    async def start_sampling(self, *, sampling_interval: Optional[float] = None, stack_depth: Optional[float] = None, include_objects_collected_by_major_gc: Optional[bool] = None, include_objects_collected_by_minor_gc: Optional[bool] = None) -> None:
+        """
+        :param sampling_interval: Average sample interval in bytes. Poisson distribution is used for the intervals. The
+        default value is 32768 bytes.
+        :param stack_depth: Maximum stack depth. The default value is 128.
+        :param include_objects_collected_by_major_gc: By default, the sampling heap profiler reports only objects which are
+        still alive when the profile is returned via getSamplingProfile or
+        stopSampling, which is useful for determining what functions contribute
+        the most to steady-state memory usage. This flag instructs the sampling
+        heap profiler to also include information about objects discarded by
+        major GC, which will show which functions cause large temporary memory
+        usage or long GC pauses.
+        :param include_objects_collected_by_minor_gc: By default, the sampling heap profiler reports only objects which are
+        still alive when the profile is returned via getSamplingProfile or
+        stopSampling, which is useful for determining what functions contribute
+        the most to steady-state memory usage. This flag instructs the sampling
+        heap profiler to also include information about objects discarded by
+        minor GC, which is useful when tuning a latency-sensitive application
+        for minimal GC activity.
+        """
+        _params: Dict[str, Any] = {}
+        if sampling_interval is not None:
+            _params['samplingInterval'] = encode(FieldMeta('', '', False, 'primitive'), sampling_interval)
+        if stack_depth is not None:
+            _params['stackDepth'] = encode(FieldMeta('', '', False, 'primitive'), stack_depth)
+        if include_objects_collected_by_major_gc is not None:
+            _params['includeObjectsCollectedByMajorGC'] = encode(FieldMeta('', '', False, 'primitive'), include_objects_collected_by_major_gc)
+        if include_objects_collected_by_minor_gc is not None:
+            _params['includeObjectsCollectedByMinorGC'] = encode(FieldMeta('', '', False, 'primitive'), include_objects_collected_by_minor_gc)
+        _result = await self._target.send('HeapProfiler.startSampling', _params)
+        return None
+
+    async def start_tracking_heap_objects(self, *, track_allocations: Optional[bool] = None) -> None:
+        """:param track_allocations:"""
+        _params: Dict[str, Any] = {}
+        if track_allocations is not None:
+            _params['trackAllocations'] = encode(FieldMeta('', '', False, 'primitive'), track_allocations)
+        _result = await self._target.send('HeapProfiler.startTrackingHeapObjects', _params)
+        return None
+
+    async def stop_sampling(self) -> StopSamplingReturn:
+        _params: Dict[str, Any] = {}
+        _result = await self._target.send('HeapProfiler.stopSampling', _params)
+        return StopSamplingReturn.from_json(_result)
+
+    async def stop_tracking_heap_objects(self, *, report_progress: Optional[bool] = None, treat_global_objects_as_roots: Optional[bool] = None, capture_numeric_value: Optional[bool] = None, expose_internals: Optional[bool] = None) -> None:
+        """
+        :param report_progress: If true 'reportHeapSnapshotProgress' events will be generated while snapshot is being taken
+        when the tracking is stopped.
+        :param treat_global_objects_as_roots: Deprecated in favor of `exposeInternals`.
+        :param capture_numeric_value: If true, numerical values are included in the snapshot
+        :param expose_internals: If true, exposes internals of the snapshot.
+        """
+        _params: Dict[str, Any] = {}
+        if report_progress is not None:
+            _params['reportProgress'] = encode(FieldMeta('', '', False, 'primitive'), report_progress)
+        if treat_global_objects_as_roots is not None:
+            _params['treatGlobalObjectsAsRoots'] = encode(FieldMeta('', '', False, 'primitive'), treat_global_objects_as_roots)
+        if capture_numeric_value is not None:
+            _params['captureNumericValue'] = encode(FieldMeta('', '', False, 'primitive'), capture_numeric_value)
+        if expose_internals is not None:
+            _params['exposeInternals'] = encode(FieldMeta('', '', False, 'primitive'), expose_internals)
+        _result = await self._target.send('HeapProfiler.stopTrackingHeapObjects', _params)
+        return None
+
+    async def take_heap_snapshot(self, *, report_progress: Optional[bool] = None, treat_global_objects_as_roots: Optional[bool] = None, capture_numeric_value: Optional[bool] = None, expose_internals: Optional[bool] = None) -> None:
+        """
+        :param report_progress: If true 'reportHeapSnapshotProgress' events will be generated while snapshot is being taken.
+        :param treat_global_objects_as_roots: If true, a raw snapshot without artificial roots will be generated.
+        Deprecated in favor of `exposeInternals`.
+        :param capture_numeric_value: If true, numerical values are included in the snapshot
+        :param expose_internals: If true, exposes internals of the snapshot.
+        """
+        _params: Dict[str, Any] = {}
+        if report_progress is not None:
+            _params['reportProgress'] = encode(FieldMeta('', '', False, 'primitive'), report_progress)
+        if treat_global_objects_as_roots is not None:
+            _params['treatGlobalObjectsAsRoots'] = encode(FieldMeta('', '', False, 'primitive'), treat_global_objects_as_roots)
+        if capture_numeric_value is not None:
+            _params['captureNumericValue'] = encode(FieldMeta('', '', False, 'primitive'), capture_numeric_value)
+        if expose_internals is not None:
+            _params['exposeInternals'] = encode(FieldMeta('', '', False, 'primitive'), expose_internals)
+        _result = await self._target.send('HeapProfiler.takeHeapSnapshot', _params)
+        return None

parsek_cdp/cdp/heapprofiler/types.py

@@ -0,0 +1,57 @@
+"""Custom types and enums for the HeapProfiler 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 ..runtime.types import CallFrame as Runtime_CallFrame
+
+type HeapSnapshotObjectId = str  # Heap snapshot object id.
+
+
+@register("HeapProfiler.SamplingHeapProfileNode")
+@dataclass
+class SamplingHeapProfileNode(DataType):
+    """Sampling Heap Profile node. Holds callsite information, allocation statistics and child nodes."""
+    call_frame: Runtime_CallFrame
+    self_size: float
+    id: int
+    children: List[SamplingHeapProfileNode]
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('call_frame', 'callFrame', False, 'object', ref='Runtime.CallFrame'),
+        FieldMeta('self_size', 'selfSize', False, 'primitive'),
+        FieldMeta('id', 'id', False, 'primitive'),
+        FieldMeta('children', 'children', False, 'array', inner=FieldMeta('', '', False, 'object', ref='HeapProfiler.SamplingHeapProfileNode')),
+    )
+
+
+@register("HeapProfiler.SamplingHeapProfileSample")
+@dataclass
+class SamplingHeapProfileSample(DataType):
+    """A single sample from a sampling profile."""
+    size: float
+    node_id: int
+    ordinal: float
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('size', 'size', False, 'primitive'),
+        FieldMeta('node_id', 'nodeId', False, 'primitive'),
+        FieldMeta('ordinal', 'ordinal', False, 'primitive'),
+    )
+
+
+@register("HeapProfiler.SamplingHeapProfile")
+@dataclass
+class SamplingHeapProfile(DataType):
+    """Sampling profile."""
+    head: SamplingHeapProfileNode
+    samples: List[SamplingHeapProfileSample]
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('head', 'head', False, 'object', ref='HeapProfiler.SamplingHeapProfileNode'),
+        FieldMeta('samples', 'samples', False, 'array', inner=FieldMeta('', '', False, 'object', ref='HeapProfiler.SamplingHeapProfileSample')),
+    )
+
+__all__ = ["HeapSnapshotObjectId", "SamplingHeapProfile", "SamplingHeapProfileNode", "SamplingHeapProfileSample"]

parsek_cdp/cdp/indexeddb/__init__.py

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

parsek_cdp/cdp/indexeddb/events.py

@@ -0,0 +1,13 @@
+"""Events for the IndexedDB 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__ = []