parsek-cdp 0.1.0__py3-none-any.whl

parsek_cdp/cdp/accessibility/types.py

@@ -0,0 +1,235 @@
+"""Custom types and enums for the Accessibility 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 ..page.types import FrameId as Page_FrameId
+
+type AXNodeId = str  # Unique accessibility node identifier.
+
+
+@register("Accessibility.AXValueType")
+class AXValueType(str, Enum):
+    """Enum of possible property types."""
+    BOOLEAN = 'boolean'
+    TRISTATE = 'tristate'
+    BOOLEANORUNDEFINED = 'booleanOrUndefined'
+    IDREF = 'idref'
+    IDREFLIST = 'idrefList'
+    INTEGER = 'integer'
+    NODE = 'node'
+    NODELIST = 'nodeList'
+    NUMBER = 'number'
+    STRING = 'string'
+    COMPUTEDSTRING = 'computedString'
+    TOKEN = 'token'
+    TOKENLIST = 'tokenList'
+    DOMRELATION = 'domRelation'
+    ROLE = 'role'
+    INTERNALROLE = 'internalRole'
+    VALUEUNDEFINED = 'valueUndefined'
+
+
+@register("Accessibility.AXValueSourceType")
+class AXValueSourceType(str, Enum):
+    """Enum of possible property sources."""
+    ATTRIBUTE = 'attribute'
+    IMPLICIT = 'implicit'
+    STYLE = 'style'
+    CONTENTS = 'contents'
+    PLACEHOLDER = 'placeholder'
+    RELATEDELEMENT = 'relatedElement'
+
+
+@register("Accessibility.AXValueNativeSourceType")
+class AXValueNativeSourceType(str, Enum):
+    """Enum of possible native property sources (as a subtype of a particular AXValueSourceType)."""
+    DESCRIPTION = 'description'
+    FIGCAPTION = 'figcaption'
+    LABEL = 'label'
+    LABELFOR = 'labelfor'
+    LABELWRAPPED = 'labelwrapped'
+    LEGEND = 'legend'
+    RUBYANNOTATION = 'rubyannotation'
+    TABLECAPTION = 'tablecaption'
+    TITLE = 'title'
+    OTHER = 'other'
+
+
+@register("Accessibility.AXValueSource")
+@dataclass
+class AXValueSource(DataType):
+    """A single source for a computed AX property."""
+    type_: AXValueSourceType
+    value: Optional[AXValue] = None
+    attribute: Optional[str] = None
+    attribute_value: Optional[AXValue] = None
+    superseded: Optional[bool] = None
+    native_source: Optional[AXValueNativeSourceType] = None
+    native_source_value: Optional[AXValue] = None
+    invalid: Optional[bool] = None
+    invalid_reason: Optional[str] = None
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('type_', 'type', False, 'enum', ref='Accessibility.AXValueSourceType'),
+        FieldMeta('value', 'value', True, 'object', ref='Accessibility.AXValue'),
+        FieldMeta('attribute', 'attribute', True, 'primitive'),
+        FieldMeta('attribute_value', 'attributeValue', True, 'object', ref='Accessibility.AXValue'),
+        FieldMeta('superseded', 'superseded', True, 'primitive'),
+        FieldMeta('native_source', 'nativeSource', True, 'enum', ref='Accessibility.AXValueNativeSourceType'),
+        FieldMeta('native_source_value', 'nativeSourceValue', True, 'object', ref='Accessibility.AXValue'),
+        FieldMeta('invalid', 'invalid', True, 'primitive'),
+        FieldMeta('invalid_reason', 'invalidReason', True, 'primitive'),
+    )
+
+
+@register("Accessibility.AXRelatedNode")
+@dataclass
+class AXRelatedNode(DataType):
+    backend_dom_node_id: DOM_BackendNodeId
+    idref: Optional[str] = None
+    text: Optional[str] = None
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('backend_dom_node_id', 'backendDOMNodeId', False, 'primitive'),
+        FieldMeta('idref', 'idref', True, 'primitive'),
+        FieldMeta('text', 'text', True, 'primitive'),
+    )
+
+
+@register("Accessibility.AXProperty")
+@dataclass
+class AXProperty(DataType):
+    name: AXPropertyName
+    value: AXValue
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('name', 'name', False, 'enum', ref='Accessibility.AXPropertyName'),
+        FieldMeta('value', 'value', False, 'object', ref='Accessibility.AXValue'),
+    )
+
+
+@register("Accessibility.AXValue")
+@dataclass
+class AXValue(DataType):
+    """A single computed AX property."""
+    type_: AXValueType
+    value: Optional[Any] = None
+    related_nodes: Optional[List[AXRelatedNode]] = None
+    sources: Optional[List[AXValueSource]] = None
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('type_', 'type', False, 'enum', ref='Accessibility.AXValueType'),
+        FieldMeta('value', 'value', True, 'primitive'),
+        FieldMeta('related_nodes', 'relatedNodes', True, 'array', inner=FieldMeta('', '', False, 'object', ref='Accessibility.AXRelatedNode')),
+        FieldMeta('sources', 'sources', True, 'array', inner=FieldMeta('', '', False, 'object', ref='Accessibility.AXValueSource')),
+    )
+
+
+@register("Accessibility.AXPropertyName")
+class AXPropertyName(str, Enum):
+    """
+    Values of AXProperty name:
+    - from 'busy' to 'roledescription': states which apply to every AX node
+    - from 'live' to 'root': attributes which apply to nodes in live regions
+    - from 'autocomplete' to 'valuetext': attributes which apply to widgets
+    - from 'checked' to 'selected': states which apply to widgets
+    - from 'activedescendant' to 'owns': relationships between elements other than parent/child/sibling
+    - from 'activeFullscreenElement' to 'uninteresting': reasons why this noode is hidden
+    """
+    ACTIONS = 'actions'
+    BUSY = 'busy'
+    DISABLED = 'disabled'
+    EDITABLE = 'editable'
+    FOCUSABLE = 'focusable'
+    FOCUSED = 'focused'
+    HIDDEN = 'hidden'
+    HIDDENROOT = 'hiddenRoot'
+    INVALID = 'invalid'
+    KEYSHORTCUTS = 'keyshortcuts'
+    SETTABLE = 'settable'
+    ROLEDESCRIPTION = 'roledescription'
+    LIVE = 'live'
+    ATOMIC = 'atomic'
+    RELEVANT = 'relevant'
+    ROOT = 'root'
+    AUTOCOMPLETE = 'autocomplete'
+    HASPOPUP = 'hasPopup'
+    LEVEL = 'level'
+    MULTISELECTABLE = 'multiselectable'
+    ORIENTATION = 'orientation'
+    MULTILINE = 'multiline'
+    READONLY = 'readonly'
+    REQUIRED = 'required'
+    VALUEMIN = 'valuemin'
+    VALUEMAX = 'valuemax'
+    VALUETEXT = 'valuetext'
+    CHECKED = 'checked'
+    EXPANDED = 'expanded'
+    MODAL = 'modal'
+    PRESSED = 'pressed'
+    SELECTED = 'selected'
+    ACTIVEDESCENDANT = 'activedescendant'
+    CONTROLS = 'controls'
+    DESCRIBEDBY = 'describedby'
+    DETAILS = 'details'
+    ERRORMESSAGE = 'errormessage'
+    FLOWTO = 'flowto'
+    LABELLEDBY = 'labelledby'
+    OWNS = 'owns'
+    URL = 'url'
+    ACTIVEFULLSCREENELEMENT = 'activeFullscreenElement'
+    ACTIVEMODALDIALOG = 'activeModalDialog'
+    ACTIVEARIAMODALDIALOG = 'activeAriaModalDialog'
+    ARIAHIDDENELEMENT = 'ariaHiddenElement'
+    ARIAHIDDENSUBTREE = 'ariaHiddenSubtree'
+    EMPTYALT = 'emptyAlt'
+    EMPTYTEXT = 'emptyText'
+    INERTELEMENT = 'inertElement'
+    INERTSUBTREE = 'inertSubtree'
+    LABELCONTAINER = 'labelContainer'
+    LABELFOR = 'labelFor'
+    NOTRENDERED = 'notRendered'
+    NOTVISIBLE = 'notVisible'
+    PRESENTATIONALROLE = 'presentationalRole'
+    PROBABLYPRESENTATIONAL = 'probablyPresentational'
+    INACTIVECAROUSELTABCONTENT = 'inactiveCarouselTabContent'
+    UNINTERESTING = 'uninteresting'
+
+
+@register("Accessibility.AXNode")
+@dataclass
+class AXNode(DataType):
+    """A node in the accessibility tree."""
+    node_id: AXNodeId
+    ignored: bool
+    ignored_reasons: Optional[List[AXProperty]] = None
+    role: Optional[AXValue] = None
+    chrome_role: Optional[AXValue] = None
+    name: Optional[AXValue] = None
+    description: Optional[AXValue] = None
+    value: Optional[AXValue] = None
+    properties: Optional[List[AXProperty]] = None
+    parent_id: Optional[AXNodeId] = None
+    child_ids: Optional[List[AXNodeId]] = None
+    backend_dom_node_id: Optional[DOM_BackendNodeId] = None
+    frame_id: Optional[Page_FrameId] = None
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('node_id', 'nodeId', False, 'primitive'),
+        FieldMeta('ignored', 'ignored', False, 'primitive'),
+        FieldMeta('ignored_reasons', 'ignoredReasons', True, 'array', inner=FieldMeta('', '', False, 'object', ref='Accessibility.AXProperty')),
+        FieldMeta('role', 'role', True, 'object', ref='Accessibility.AXValue'),
+        FieldMeta('chrome_role', 'chromeRole', True, 'object', ref='Accessibility.AXValue'),
+        FieldMeta('name', 'name', True, 'object', ref='Accessibility.AXValue'),
+        FieldMeta('description', 'description', True, 'object', ref='Accessibility.AXValue'),
+        FieldMeta('value', 'value', True, 'object', ref='Accessibility.AXValue'),
+        FieldMeta('properties', 'properties', True, 'array', inner=FieldMeta('', '', False, 'object', ref='Accessibility.AXProperty')),
+        FieldMeta('parent_id', 'parentId', True, 'primitive'),
+        FieldMeta('child_ids', 'childIds', True, 'array', inner=FieldMeta('', '', False, 'primitive')),
+        FieldMeta('backend_dom_node_id', 'backendDOMNodeId', True, 'primitive'),
+        FieldMeta('frame_id', 'frameId', True, 'primitive'),
+    )
+
+__all__ = ["AXNode", "AXNodeId", "AXProperty", "AXPropertyName", "AXRelatedNode", "AXValue", "AXValueNativeSourceType", "AXValueSource", "AXValueSourceType", "AXValueType"]

parsek_cdp/cdp/animation/__init__.py

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

parsek_cdp/cdp/animation/events.py

@@ -0,0 +1,52 @@
+"""Events for the Animation 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 Animation
+
+@register_event("Animation.animationCanceled")
+@dataclass
+class AnimationCanceled(Event):
+    """Event for when an animation has been cancelled."""
+    id: str
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('id', 'id', False, 'primitive'),
+    )
+
+
+@register_event("Animation.animationCreated")
+@dataclass
+class AnimationCreated(Event):
+    """Event for each animation that has been created."""
+    id: str
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('id', 'id', False, 'primitive'),
+    )
+
+
+@register_event("Animation.animationStarted")
+@dataclass
+class AnimationStarted(Event):
+    """Event for animation that has been started."""
+    animation: Animation
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('animation', 'animation', False, 'object', ref='Animation.Animation'),
+    )
+
+
+@register_event("Animation.animationUpdated")
+@dataclass
+class AnimationUpdated(Event):
+    """Event for animation that has been updated."""
+    animation: Animation
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('animation', 'animation', False, 'object', ref='Animation.Animation'),
+    )
+
+__all__ = ["AnimationCanceled", "AnimationCreated", "AnimationStarted", "AnimationUpdated"]

parsek_cdp/cdp/animation/functions.py

@@ -0,0 +1,140 @@
+"""Commands for the Animation 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 ..runtime.types import RemoteObject as Runtime_RemoteObject
+
+@dataclass
+class GetCurrentTimeReturn(DataType):
+    """Return value of :meth:`Animation.get_current_time`."""
+    current_time: float
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('current_time', 'currentTime', False, 'primitive'),
+    )
+
+
+@dataclass
+class GetPlaybackRateReturn(DataType):
+    """Return value of :meth:`Animation.get_playback_rate`."""
+    playback_rate: float
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('playback_rate', 'playbackRate', False, 'primitive'),
+    )
+
+
+@dataclass
+class ResolveAnimationReturn(DataType):
+    """Return value of :meth:`Animation.resolve_animation`."""
+    remote_object: Runtime_RemoteObject
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('remote_object', 'remoteObject', False, 'object', ref='Runtime.RemoteObject'),
+    )
+
+
+class Animation:
+    """Commands of the Animation domain, bound to a target."""
+
+    def __init__(self, target: Any) -> None:
+        self._target = target
+
+
+    async def disable(self) -> None:
+        """Disables animation domain notifications."""
+        _params: Dict[str, Any] = {}
+        _result = await self._target.send('Animation.disable', _params)
+        return None
+
+    async def enable(self) -> None:
+        """Enables animation domain notifications."""
+        _params: Dict[str, Any] = {}
+        _result = await self._target.send('Animation.enable', _params)
+        return None
+
+    async def get_current_time(self, *, id: str) -> GetCurrentTimeReturn:
+        """
+        Returns the current time of the an animation.
+        :param id: Id of animation.
+        """
+        _params: Dict[str, Any] = {}
+        _params['id'] = encode(FieldMeta('', '', False, 'primitive'), id)
+        _result = await self._target.send('Animation.getCurrentTime', _params)
+        return GetCurrentTimeReturn.from_json(_result)
+
+    async def get_playback_rate(self) -> GetPlaybackRateReturn:
+        """Gets the playback rate of the document timeline."""
+        _params: Dict[str, Any] = {}
+        _result = await self._target.send('Animation.getPlaybackRate', _params)
+        return GetPlaybackRateReturn.from_json(_result)
+
+    async def release_animations(self, *, animations: List[str]) -> None:
+        """
+        Releases a set of animations to no longer be manipulated.
+        :param animations: List of animation ids to seek.
+        """
+        _params: Dict[str, Any] = {}
+        _params['animations'] = encode(FieldMeta('', '', False, 'array', inner=FieldMeta('', '', False, 'primitive')), animations)
+        _result = await self._target.send('Animation.releaseAnimations', _params)
+        return None
+
+    async def resolve_animation(self, *, animation_id: str) -> ResolveAnimationReturn:
+        """
+        Gets the remote object of the Animation.
+        :param animation_id: Animation id.
+        """
+        _params: Dict[str, Any] = {}
+        _params['animationId'] = encode(FieldMeta('', '', False, 'primitive'), animation_id)
+        _result = await self._target.send('Animation.resolveAnimation', _params)
+        return ResolveAnimationReturn.from_json(_result)
+
+    async def seek_animations(self, *, animations: List[str], current_time: float) -> None:
+        """
+        Seek a set of animations to a particular time within each animation.
+        :param animations: List of animation ids to seek.
+        :param current_time: Set the current time of each animation.
+        """
+        _params: Dict[str, Any] = {}
+        _params['animations'] = encode(FieldMeta('', '', False, 'array', inner=FieldMeta('', '', False, 'primitive')), animations)
+        _params['currentTime'] = encode(FieldMeta('', '', False, 'primitive'), current_time)
+        _result = await self._target.send('Animation.seekAnimations', _params)
+        return None
+
+    async def set_paused(self, *, animations: List[str], paused: bool) -> None:
+        """
+        Sets the paused state of a set of animations.
+        :param animations: Animations to set the pause state of.
+        :param paused: Paused state to set to.
+        """
+        _params: Dict[str, Any] = {}
+        _params['animations'] = encode(FieldMeta('', '', False, 'array', inner=FieldMeta('', '', False, 'primitive')), animations)
+        _params['paused'] = encode(FieldMeta('', '', False, 'primitive'), paused)
+        _result = await self._target.send('Animation.setPaused', _params)
+        return None
+
+    async def set_playback_rate(self, *, playback_rate: float) -> None:
+        """
+        Sets the playback rate of the document timeline.
+        :param playback_rate: Playback rate for animations on page
+        """
+        _params: Dict[str, Any] = {}
+        _params['playbackRate'] = encode(FieldMeta('', '', False, 'primitive'), playback_rate)
+        _result = await self._target.send('Animation.setPlaybackRate', _params)
+        return None
+
+    async def set_timing(self, *, animation_id: str, duration: float, delay: float) -> None:
+        """
+        Sets the timing of an animation node.
+        :param animation_id: Animation id.
+        :param duration: Duration of the animation.
+        :param delay: Delay of the animation.
+        """
+        _params: Dict[str, Any] = {}
+        _params['animationId'] = encode(FieldMeta('', '', False, 'primitive'), animation_id)
+        _params['duration'] = encode(FieldMeta('', '', False, 'primitive'), duration)
+        _params['delay'] = encode(FieldMeta('', '', False, 'primitive'), delay)
+        _result = await self._target.send('Animation.setTiming', _params)
+        return None

parsek_cdp/cdp/animation/types.py

@@ -0,0 +1,113 @@
+"""Custom types and enums for the Animation 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 ScrollOrientation as DOM_ScrollOrientation
+
+@register("Animation.Animation")
+@dataclass
+class Animation(DataType):
+    """Animation instance."""
+    id: str
+    name: str
+    paused_state: bool
+    play_state: str
+    playback_rate: float
+    start_time: float
+    current_time: float
+    type_: Literal['CSSTransition', 'CSSAnimation', 'WebAnimation']
+    source: Optional[AnimationEffect] = None
+    css_id: Optional[str] = None
+    view_or_scroll_timeline: Optional[ViewOrScrollTimeline] = None
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('id', 'id', False, 'primitive'),
+        FieldMeta('name', 'name', False, 'primitive'),
+        FieldMeta('paused_state', 'pausedState', False, 'primitive'),
+        FieldMeta('play_state', 'playState', False, 'primitive'),
+        FieldMeta('playback_rate', 'playbackRate', False, 'primitive'),
+        FieldMeta('start_time', 'startTime', False, 'primitive'),
+        FieldMeta('current_time', 'currentTime', False, 'primitive'),
+        FieldMeta('type_', 'type', False, 'primitive'),
+        FieldMeta('source', 'source', True, 'object', ref='Animation.AnimationEffect'),
+        FieldMeta('css_id', 'cssId', True, 'primitive'),
+        FieldMeta('view_or_scroll_timeline', 'viewOrScrollTimeline', True, 'object', ref='Animation.ViewOrScrollTimeline'),
+    )
+
+
+@register("Animation.ViewOrScrollTimeline")
+@dataclass
+class ViewOrScrollTimeline(DataType):
+    """Timeline instance"""
+    axis: DOM_ScrollOrientation
+    source_node_id: Optional[DOM_BackendNodeId] = None
+    start_offset: Optional[float] = None
+    end_offset: Optional[float] = None
+    subject_node_id: Optional[DOM_BackendNodeId] = None
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('axis', 'axis', False, 'enum', ref='DOM.ScrollOrientation'),
+        FieldMeta('source_node_id', 'sourceNodeId', True, 'primitive'),
+        FieldMeta('start_offset', 'startOffset', True, 'primitive'),
+        FieldMeta('end_offset', 'endOffset', True, 'primitive'),
+        FieldMeta('subject_node_id', 'subjectNodeId', True, 'primitive'),
+    )
+
+
+@register("Animation.AnimationEffect")
+@dataclass
+class AnimationEffect(DataType):
+    """AnimationEffect instance"""
+    delay: float
+    end_delay: float
+    iteration_start: float
+    duration: float
+    direction: str
+    fill: str
+    easing: str
+    iterations: Optional[float] = None
+    backend_node_id: Optional[DOM_BackendNodeId] = None
+    keyframes_rule: Optional[KeyframesRule] = None
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('delay', 'delay', False, 'primitive'),
+        FieldMeta('end_delay', 'endDelay', False, 'primitive'),
+        FieldMeta('iteration_start', 'iterationStart', False, 'primitive'),
+        FieldMeta('duration', 'duration', False, 'primitive'),
+        FieldMeta('direction', 'direction', False, 'primitive'),
+        FieldMeta('fill', 'fill', False, 'primitive'),
+        FieldMeta('easing', 'easing', False, 'primitive'),
+        FieldMeta('iterations', 'iterations', True, 'primitive'),
+        FieldMeta('backend_node_id', 'backendNodeId', True, 'primitive'),
+        FieldMeta('keyframes_rule', 'keyframesRule', True, 'object', ref='Animation.KeyframesRule'),
+    )
+
+
+@register("Animation.KeyframesRule")
+@dataclass
+class KeyframesRule(DataType):
+    """Keyframes Rule"""
+    keyframes: List[KeyframeStyle]
+    name: Optional[str] = None
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('keyframes', 'keyframes', False, 'array', inner=FieldMeta('', '', False, 'object', ref='Animation.KeyframeStyle')),
+        FieldMeta('name', 'name', True, 'primitive'),
+    )
+
+
+@register("Animation.KeyframeStyle")
+@dataclass
+class KeyframeStyle(DataType):
+    """Keyframe Style"""
+    offset: str
+    easing: str
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('offset', 'offset', False, 'primitive'),
+        FieldMeta('easing', 'easing', False, 'primitive'),
+    )
+
+__all__ = ["Animation", "AnimationEffect", "KeyframeStyle", "KeyframesRule", "ViewOrScrollTimeline"]

parsek_cdp/cdp/audits/__init__.py

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

parsek_cdp/cdp/audits/events.py

@@ -0,0 +1,21 @@
+"""Events for the Audits 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 InspectorIssue
+
+@register_event("Audits.issueAdded")
+@dataclass
+class IssueAdded(Event):
+    issue: InspectorIssue
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('issue', 'issue', False, 'object', ref='Audits.InspectorIssue'),
+    )
+
+__all__ = ["IssueAdded"]