parsek-cdp 0.1.0__py3-none-any.whl

parsek_cdp/cdp/debugger/types.py

@@ -0,0 +1,171 @@
+"""Custom types and enums for the Debugger 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 RemoteObject as Runtime_RemoteObject
+    from ..runtime.types import ScriptId as Runtime_ScriptId
+
+type BreakpointId = str  # Breakpoint identifier.
+
+
+type CallFrameId = str  # Call frame identifier.
+
+
+@register("Debugger.Location")
+@dataclass
+class Location(DataType):
+    """Location in the source code."""
+    script_id: Runtime_ScriptId
+    line_number: int
+    column_number: Optional[int] = None
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('script_id', 'scriptId', False, 'primitive'),
+        FieldMeta('line_number', 'lineNumber', False, 'primitive'),
+        FieldMeta('column_number', 'columnNumber', True, 'primitive'),
+    )
+
+
+@register("Debugger.ScriptPosition")
+@dataclass
+class ScriptPosition(DataType):
+    """Location in the source code."""
+    line_number: int
+    column_number: int
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('line_number', 'lineNumber', False, 'primitive'),
+        FieldMeta('column_number', 'columnNumber', False, 'primitive'),
+    )
+
+
+@register("Debugger.LocationRange")
+@dataclass
+class LocationRange(DataType):
+    """Location range within one script."""
+    script_id: Runtime_ScriptId
+    start: ScriptPosition
+    end: ScriptPosition
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('script_id', 'scriptId', False, 'primitive'),
+        FieldMeta('start', 'start', False, 'object', ref='Debugger.ScriptPosition'),
+        FieldMeta('end', 'end', False, 'object', ref='Debugger.ScriptPosition'),
+    )
+
+
+@register("Debugger.CallFrame")
+@dataclass
+class CallFrame(DataType):
+    """JavaScript call frame. Array of call frames form the call stack."""
+    call_frame_id: CallFrameId
+    function_name: str
+    location: Location
+    url: str
+    scope_chain: List[Scope]
+    this: Runtime_RemoteObject
+    function_location: Optional[Location] = None
+    return_value: Optional[Runtime_RemoteObject] = None
+    can_be_restarted: Optional[bool] = None
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('call_frame_id', 'callFrameId', False, 'primitive'),
+        FieldMeta('function_name', 'functionName', False, 'primitive'),
+        FieldMeta('location', 'location', False, 'object', ref='Debugger.Location'),
+        FieldMeta('url', 'url', False, 'primitive'),
+        FieldMeta('scope_chain', 'scopeChain', False, 'array', inner=FieldMeta('', '', False, 'object', ref='Debugger.Scope')),
+        FieldMeta('this', 'this', False, 'object', ref='Runtime.RemoteObject'),
+        FieldMeta('function_location', 'functionLocation', True, 'object', ref='Debugger.Location'),
+        FieldMeta('return_value', 'returnValue', True, 'object', ref='Runtime.RemoteObject'),
+        FieldMeta('can_be_restarted', 'canBeRestarted', True, 'primitive'),
+    )
+
+
+@register("Debugger.Scope")
+@dataclass
+class Scope(DataType):
+    """Scope description."""
+    type_: Literal['global', 'local', 'with', 'closure', 'catch', 'block', 'script', 'eval', 'module', 'wasm-expression-stack']
+    object: Runtime_RemoteObject
+    name: Optional[str] = None
+    start_location: Optional[Location] = None
+    end_location: Optional[Location] = None
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('type_', 'type', False, 'primitive'),
+        FieldMeta('object', 'object', False, 'object', ref='Runtime.RemoteObject'),
+        FieldMeta('name', 'name', True, 'primitive'),
+        FieldMeta('start_location', 'startLocation', True, 'object', ref='Debugger.Location'),
+        FieldMeta('end_location', 'endLocation', True, 'object', ref='Debugger.Location'),
+    )
+
+
+@register("Debugger.SearchMatch")
+@dataclass
+class SearchMatch(DataType):
+    """Search match for resource."""
+    line_number: float
+    line_content: str
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('line_number', 'lineNumber', False, 'primitive'),
+        FieldMeta('line_content', 'lineContent', False, 'primitive'),
+    )
+
+
+@register("Debugger.BreakLocation")
+@dataclass
+class BreakLocation(DataType):
+    script_id: Runtime_ScriptId
+    line_number: int
+    column_number: Optional[int] = None
+    type_: Optional[Literal['debuggerStatement', 'call', 'return']] = None
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('script_id', 'scriptId', False, 'primitive'),
+        FieldMeta('line_number', 'lineNumber', False, 'primitive'),
+        FieldMeta('column_number', 'columnNumber', True, 'primitive'),
+        FieldMeta('type_', 'type', True, 'primitive'),
+    )
+
+
+@register("Debugger.WasmDisassemblyChunk")
+@dataclass
+class WasmDisassemblyChunk(DataType):
+    lines: List[str]
+    bytecode_offsets: List[int]
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('lines', 'lines', False, 'array', inner=FieldMeta('', '', False, 'primitive')),
+        FieldMeta('bytecode_offsets', 'bytecodeOffsets', False, 'array', inner=FieldMeta('', '', False, 'primitive')),
+    )
+
+
+@register("Debugger.ScriptLanguage")
+class ScriptLanguage(str, Enum):
+    """Enum of possible script languages."""
+    JAVASCRIPT = 'JavaScript'
+    WEBASSEMBLY = 'WebAssembly'
+
+
+@register("Debugger.DebugSymbols")
+@dataclass
+class DebugSymbols(DataType):
+    """Debug symbols available for a wasm script."""
+    type_: Literal['SourceMap', 'EmbeddedDWARF', 'ExternalDWARF']
+    external_url: Optional[str] = None
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('type_', 'type', False, 'primitive'),
+        FieldMeta('external_url', 'externalURL', True, 'primitive'),
+    )
+
+
+@register("Debugger.ResolvedBreakpoint")
+@dataclass
+class ResolvedBreakpoint(DataType):
+    breakpoint_id: BreakpointId
+    location: Location
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('breakpoint_id', 'breakpointId', False, 'primitive'),
+        FieldMeta('location', 'location', False, 'object', ref='Debugger.Location'),
+    )
+
+__all__ = ["BreakLocation", "BreakpointId", "CallFrame", "CallFrameId", "DebugSymbols", "Location", "LocationRange", "ResolvedBreakpoint", "Scope", "ScriptLanguage", "ScriptPosition", "SearchMatch", "WasmDisassemblyChunk"]

parsek_cdp/cdp/deviceaccess/__init__.py

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

parsek_cdp/cdp/deviceaccess/events.py

@@ -0,0 +1,30 @@
+"""Events for the DeviceAccess 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 (
+        PromptDevice,
+        RequestId,
+    )
+
+@register_event("DeviceAccess.deviceRequestPrompted")
+@dataclass
+class DeviceRequestPrompted(Event):
+    """
+    A device request opened a user prompt to select a device. Respond with the
+    selectPrompt or cancelPrompt command.
+    """
+    id: RequestId
+    devices: List[PromptDevice]
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('id', 'id', False, 'primitive'),
+        FieldMeta('devices', 'devices', False, 'array', inner=FieldMeta('', '', False, 'object', ref='DeviceAccess.PromptDevice')),
+    )
+
+__all__ = ["DeviceRequestPrompted"]

parsek_cdp/cdp/deviceaccess/functions.py

@@ -0,0 +1,54 @@
+"""Commands for the DeviceAccess 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 (
+        DeviceId,
+        RequestId,
+    )
+
+class DeviceAccess:
+    """Commands of the DeviceAccess domain, bound to a target."""
+
+    def __init__(self, target: Any) -> None:
+        self._target = target
+
+
+    async def enable(self) -> None:
+        """Enable events in this domain."""
+        _params: Dict[str, Any] = {}
+        _result = await self._target.send('DeviceAccess.enable', _params)
+        return None
+
+    async def disable(self) -> None:
+        """Disable events in this domain."""
+        _params: Dict[str, Any] = {}
+        _result = await self._target.send('DeviceAccess.disable', _params)
+        return None
+
+    async def select_prompt(self, *, id: RequestId, device_id: DeviceId) -> None:
+        """
+        Select a device in response to a DeviceAccess.deviceRequestPrompted event.
+        :param id:
+        :param device_id:
+        """
+        _params: Dict[str, Any] = {}
+        _params['id'] = encode(FieldMeta('', '', False, 'primitive'), id)
+        _params['deviceId'] = encode(FieldMeta('', '', False, 'primitive'), device_id)
+        _result = await self._target.send('DeviceAccess.selectPrompt', _params)
+        return None
+
+    async def cancel_prompt(self, *, id: RequestId) -> None:
+        """
+        Cancel a prompt in response to a DeviceAccess.deviceRequestPrompted event.
+        :param id:
+        """
+        _params: Dict[str, Any] = {}
+        _params['id'] = encode(FieldMeta('', '', False, 'primitive'), id)
+        _result = await self._target.send('DeviceAccess.cancelPrompt', _params)
+        return None

parsek_cdp/cdp/deviceaccess/types.py

@@ -0,0 +1,28 @@
+"""Custom types and enums for the DeviceAccess 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 RequestId = str  # Device request id.
+
+
+type DeviceId = str  # A device id.
+
+
+@register("DeviceAccess.PromptDevice")
+@dataclass
+class PromptDevice(DataType):
+    """Device information displayed in a user prompt to select a device."""
+    id: DeviceId
+    name: str
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('id', 'id', False, 'primitive'),
+        FieldMeta('name', 'name', False, 'primitive'),
+    )
+
+__all__ = ["DeviceId", "PromptDevice", "RequestId"]

parsek_cdp/cdp/deviceorientation/__init__.py

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

parsek_cdp/cdp/deviceorientation/events.py

@@ -0,0 +1,13 @@
+"""Events for the DeviceOrientation 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/deviceorientation/functions.py

@@ -0,0 +1,35 @@
+"""Commands for the DeviceOrientation domain (generated)."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, ClassVar, Dict, List, Literal, Optional
+
+from ..mixins.datatype import DataType, FieldMeta, encode
+
+
+class DeviceOrientation:
+    """Commands of the DeviceOrientation domain, bound to a target."""
+
+    def __init__(self, target: Any) -> None:
+        self._target = target
+
+
+    async def clear_device_orientation_override(self) -> None:
+        """Clears the overridden Device Orientation."""
+        _params: Dict[str, Any] = {}
+        _result = await self._target.send('DeviceOrientation.clearDeviceOrientationOverride', _params)
+        return None
+
+    async def set_device_orientation_override(self, *, alpha: float, beta: float, gamma: float) -> None:
+        """
+        Overrides the Device Orientation.
+        :param alpha: Mock alpha
+        :param beta: Mock beta
+        :param gamma: Mock gamma
+        """
+        _params: Dict[str, Any] = {}
+        _params['alpha'] = encode(FieldMeta('', '', False, 'primitive'), alpha)
+        _params['beta'] = encode(FieldMeta('', '', False, 'primitive'), beta)
+        _params['gamma'] = encode(FieldMeta('', '', False, 'primitive'), gamma)
+        _result = await self._target.send('DeviceOrientation.setDeviceOrientationOverride', _params)
+        return None

parsek_cdp/cdp/deviceorientation/types.py

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

parsek_cdp/cdp/dom/__init__.py

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

parsek_cdp/cdp/dom/events.py

@@ -0,0 +1,228 @@
+"""Events for the DOM 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 (
+        BackendNode,
+        Node,
+        NodeId,
+        StyleSheetId,
+    )
+
+@register_event("DOM.attributeModified")
+@dataclass
+class AttributeModified(Event):
+    """Fired when `Element`'s attribute is modified."""
+    node_id: NodeId
+    name: str
+    value: str
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('node_id', 'nodeId', False, 'primitive'),
+        FieldMeta('name', 'name', False, 'primitive'),
+        FieldMeta('value', 'value', False, 'primitive'),
+    )
+
+
+@register_event("DOM.adoptedStyleSheetsModified")
+@dataclass
+class AdoptedStyleSheetsModified(Event):
+    """Fired when `Element`'s adoptedStyleSheets are modified."""
+    node_id: NodeId
+    adopted_style_sheets: List[StyleSheetId]
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('node_id', 'nodeId', False, 'primitive'),
+        FieldMeta('adopted_style_sheets', 'adoptedStyleSheets', False, 'array', inner=FieldMeta('', '', False, 'primitive')),
+    )
+
+
+@register_event("DOM.attributeRemoved")
+@dataclass
+class AttributeRemoved(Event):
+    """Fired when `Element`'s attribute is removed."""
+    node_id: NodeId
+    name: str
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('node_id', 'nodeId', False, 'primitive'),
+        FieldMeta('name', 'name', False, 'primitive'),
+    )
+
+
+@register_event("DOM.characterDataModified")
+@dataclass
+class CharacterDataModified(Event):
+    """Mirrors `DOMCharacterDataModified` event."""
+    node_id: NodeId
+    character_data: str
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('node_id', 'nodeId', False, 'primitive'),
+        FieldMeta('character_data', 'characterData', False, 'primitive'),
+    )
+
+
+@register_event("DOM.childNodeCountUpdated")
+@dataclass
+class ChildNodeCountUpdated(Event):
+    """Fired when `Container`'s child node count has changed."""
+    node_id: NodeId
+    child_node_count: int
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('node_id', 'nodeId', False, 'primitive'),
+        FieldMeta('child_node_count', 'childNodeCount', False, 'primitive'),
+    )
+
+
+@register_event("DOM.childNodeInserted")
+@dataclass
+class ChildNodeInserted(Event):
+    """Mirrors `DOMNodeInserted` event."""
+    parent_node_id: NodeId
+    previous_node_id: NodeId
+    node: Node
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('parent_node_id', 'parentNodeId', False, 'primitive'),
+        FieldMeta('previous_node_id', 'previousNodeId', False, 'primitive'),
+        FieldMeta('node', 'node', False, 'object', ref='DOM.Node'),
+    )
+
+
+@register_event("DOM.childNodeRemoved")
+@dataclass
+class ChildNodeRemoved(Event):
+    """Mirrors `DOMNodeRemoved` event."""
+    parent_node_id: NodeId
+    node_id: NodeId
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('parent_node_id', 'parentNodeId', False, 'primitive'),
+        FieldMeta('node_id', 'nodeId', False, 'primitive'),
+    )
+
+
+@register_event("DOM.distributedNodesUpdated")
+@dataclass
+class DistributedNodesUpdated(Event):
+    """Called when distribution is changed."""
+    insertion_point_id: NodeId
+    distributed_nodes: List[BackendNode]
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('insertion_point_id', 'insertionPointId', False, 'primitive'),
+        FieldMeta('distributed_nodes', 'distributedNodes', False, 'array', inner=FieldMeta('', '', False, 'object', ref='DOM.BackendNode')),
+    )
+
+
+@register_event("DOM.documentUpdated")
+@dataclass
+class DocumentUpdated(Event):
+    """Fired when `Document` has been totally updated. Node ids are no longer valid."""
+    __FIELDS__: ClassVar[tuple] = ()
+
+
+@register_event("DOM.inlineStyleInvalidated")
+@dataclass
+class InlineStyleInvalidated(Event):
+    """Fired when `Element`'s inline style is modified via a CSS property modification."""
+    node_ids: List[NodeId]
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('node_ids', 'nodeIds', False, 'array', inner=FieldMeta('', '', False, 'primitive')),
+    )
+
+
+@register_event("DOM.pseudoElementAdded")
+@dataclass
+class PseudoElementAdded(Event):
+    """Called when a pseudo element is added to an element."""
+    parent_id: NodeId
+    pseudo_element: Node
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('parent_id', 'parentId', False, 'primitive'),
+        FieldMeta('pseudo_element', 'pseudoElement', False, 'object', ref='DOM.Node'),
+    )
+
+
+@register_event("DOM.topLayerElementsUpdated")
+@dataclass
+class TopLayerElementsUpdated(Event):
+    """Called when top layer elements are changed."""
+    __FIELDS__: ClassVar[tuple] = ()
+
+
+@register_event("DOM.scrollableFlagUpdated")
+@dataclass
+class ScrollableFlagUpdated(Event):
+    """Fired when a node's scrollability state changes."""
+    node_id: NodeId
+    is_scrollable: bool
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('node_id', 'nodeId', False, 'primitive'),
+        FieldMeta('is_scrollable', 'isScrollable', False, 'primitive'),
+    )
+
+
+@register_event("DOM.affectedByStartingStylesFlagUpdated")
+@dataclass
+class AffectedByStartingStylesFlagUpdated(Event):
+    """Fired when a node's starting styles changes."""
+    node_id: NodeId
+    affected_by_starting_styles: bool
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('node_id', 'nodeId', False, 'primitive'),
+        FieldMeta('affected_by_starting_styles', 'affectedByStartingStyles', False, 'primitive'),
+    )
+
+
+@register_event("DOM.pseudoElementRemoved")
+@dataclass
+class PseudoElementRemoved(Event):
+    """Called when a pseudo element is removed from an element."""
+    parent_id: NodeId
+    pseudo_element_id: NodeId
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('parent_id', 'parentId', False, 'primitive'),
+        FieldMeta('pseudo_element_id', 'pseudoElementId', False, 'primitive'),
+    )
+
+
+@register_event("DOM.setChildNodes")
+@dataclass
+class SetChildNodes(Event):
+    """
+    Fired when backend wants to provide client with the missing DOM structure. This happens upon
+    most of the calls requesting node ids.
+    """
+    parent_id: NodeId
+    nodes: List[Node]
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('parent_id', 'parentId', False, 'primitive'),
+        FieldMeta('nodes', 'nodes', False, 'array', inner=FieldMeta('', '', False, 'object', ref='DOM.Node')),
+    )
+
+
+@register_event("DOM.shadowRootPopped")
+@dataclass
+class ShadowRootPopped(Event):
+    """Called when shadow root is popped from the element."""
+    host_id: NodeId
+    root_id: NodeId
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('host_id', 'hostId', False, 'primitive'),
+        FieldMeta('root_id', 'rootId', False, 'primitive'),
+    )
+
+
+@register_event("DOM.shadowRootPushed")
+@dataclass
+class ShadowRootPushed(Event):
+    """Called when shadow root is pushed into the element."""
+    host_id: NodeId
+    root: Node
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('host_id', 'hostId', False, 'primitive'),
+        FieldMeta('root', 'root', False, 'object', ref='DOM.Node'),
+    )
+
+__all__ = ["AdoptedStyleSheetsModified", "AffectedByStartingStylesFlagUpdated", "AttributeModified", "AttributeRemoved", "CharacterDataModified", "ChildNodeCountUpdated", "ChildNodeInserted", "ChildNodeRemoved", "DistributedNodesUpdated", "DocumentUpdated", "InlineStyleInvalidated", "PseudoElementAdded", "PseudoElementRemoved", "ScrollableFlagUpdated", "SetChildNodes", "ShadowRootPopped", "ShadowRootPushed", "TopLayerElementsUpdated"]