parsek-cdp 0.1.0__py3-none-any.whl

parsek_cdp/cdp/emulation/types.py

@@ -0,0 +1,305 @@
+"""Custom types and enums for the Emulation 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("Emulation.SafeAreaInsets")
+@dataclass
+class SafeAreaInsets(DataType):
+    top: Optional[int] = None
+    top_max: Optional[int] = None
+    left: Optional[int] = None
+    left_max: Optional[int] = None
+    bottom: Optional[int] = None
+    bottom_max: Optional[int] = None
+    right: Optional[int] = None
+    right_max: Optional[int] = None
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('top', 'top', True, 'primitive'),
+        FieldMeta('top_max', 'topMax', True, 'primitive'),
+        FieldMeta('left', 'left', True, 'primitive'),
+        FieldMeta('left_max', 'leftMax', True, 'primitive'),
+        FieldMeta('bottom', 'bottom', True, 'primitive'),
+        FieldMeta('bottom_max', 'bottomMax', True, 'primitive'),
+        FieldMeta('right', 'right', True, 'primitive'),
+        FieldMeta('right_max', 'rightMax', True, 'primitive'),
+    )
+
+
+@register("Emulation.ScreenOrientation")
+@dataclass
+class ScreenOrientation(DataType):
+    """Screen orientation."""
+    type_: Literal['portraitPrimary', 'portraitSecondary', 'landscapePrimary', 'landscapeSecondary']
+    angle: int
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('type_', 'type', False, 'primitive'),
+        FieldMeta('angle', 'angle', False, 'primitive'),
+    )
+
+
+@register("Emulation.DisplayFeature")
+@dataclass
+class DisplayFeature(DataType):
+    orientation: Literal['vertical', 'horizontal']
+    offset: int
+    mask_length: int
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('orientation', 'orientation', False, 'primitive'),
+        FieldMeta('offset', 'offset', False, 'primitive'),
+        FieldMeta('mask_length', 'maskLength', False, 'primitive'),
+    )
+
+
+@register("Emulation.DevicePosture")
+@dataclass
+class DevicePosture(DataType):
+    type_: Literal['continuous', 'folded']
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('type_', 'type', False, 'primitive'),
+    )
+
+
+@register("Emulation.MediaFeature")
+@dataclass
+class MediaFeature(DataType):
+    name: str
+    value: str
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('name', 'name', False, 'primitive'),
+        FieldMeta('value', 'value', False, 'primitive'),
+    )
+
+
+@register("Emulation.VirtualTimePolicy")
+class VirtualTimePolicy(str, Enum):
+    """
+    advance: If the scheduler runs out of immediate work, the virtual time base may fast forward to
+    allow the next delayed task (if any) to run; pause: The virtual time base may not advance;
+    pauseIfNetworkFetchesPending: The virtual time base may not advance if there are any pending
+    resource fetches.
+    """
+    ADVANCE = 'advance'
+    PAUSE = 'pause'
+    PAUSEIFNETWORKFETCHESPENDING = 'pauseIfNetworkFetchesPending'
+
+
+@register("Emulation.UserAgentBrandVersion")
+@dataclass
+class UserAgentBrandVersion(DataType):
+    """Used to specify User Agent Client Hints to emulate. See https://wicg.github.io/ua-client-hints"""
+    brand: str
+    version: str
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('brand', 'brand', False, 'primitive'),
+        FieldMeta('version', 'version', False, 'primitive'),
+    )
+
+
+@register("Emulation.UserAgentMetadata")
+@dataclass
+class UserAgentMetadata(DataType):
+    """
+    Used to specify User Agent Client Hints to emulate. See https://wicg.github.io/ua-client-hints
+    Missing optional values will be filled in by the target with what it would normally use.
+    """
+    platform: str
+    platform_version: str
+    architecture: str
+    model: str
+    mobile: bool
+    brands: Optional[List[UserAgentBrandVersion]] = None
+    full_version_list: Optional[List[UserAgentBrandVersion]] = None
+    full_version: Optional[str] = None
+    bitness: Optional[str] = None
+    wow64: Optional[bool] = None
+    form_factors: Optional[List[str]] = None
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('platform', 'platform', False, 'primitive'),
+        FieldMeta('platform_version', 'platformVersion', False, 'primitive'),
+        FieldMeta('architecture', 'architecture', False, 'primitive'),
+        FieldMeta('model', 'model', False, 'primitive'),
+        FieldMeta('mobile', 'mobile', False, 'primitive'),
+        FieldMeta('brands', 'brands', True, 'array', inner=FieldMeta('', '', False, 'object', ref='Emulation.UserAgentBrandVersion')),
+        FieldMeta('full_version_list', 'fullVersionList', True, 'array', inner=FieldMeta('', '', False, 'object', ref='Emulation.UserAgentBrandVersion')),
+        FieldMeta('full_version', 'fullVersion', True, 'primitive'),
+        FieldMeta('bitness', 'bitness', True, 'primitive'),
+        FieldMeta('wow64', 'wow64', True, 'primitive'),
+        FieldMeta('form_factors', 'formFactors', True, 'array', inner=FieldMeta('', '', False, 'primitive')),
+    )
+
+
+@register("Emulation.SensorType")
+class SensorType(str, Enum):
+    """
+    Used to specify sensor types to emulate.
+    See https://w3c.github.io/sensors/#automation for more information.
+    """
+    ABSOLUTE_ORIENTATION = 'absolute-orientation'
+    ACCELEROMETER = 'accelerometer'
+    AMBIENT_LIGHT = 'ambient-light'
+    GRAVITY = 'gravity'
+    GYROSCOPE = 'gyroscope'
+    LINEAR_ACCELERATION = 'linear-acceleration'
+    MAGNETOMETER = 'magnetometer'
+    RELATIVE_ORIENTATION = 'relative-orientation'
+
+
+@register("Emulation.SensorMetadata")
+@dataclass
+class SensorMetadata(DataType):
+    available: Optional[bool] = None
+    minimum_frequency: Optional[float] = None
+    maximum_frequency: Optional[float] = None
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('available', 'available', True, 'primitive'),
+        FieldMeta('minimum_frequency', 'minimumFrequency', True, 'primitive'),
+        FieldMeta('maximum_frequency', 'maximumFrequency', True, 'primitive'),
+    )
+
+
+@register("Emulation.SensorReadingSingle")
+@dataclass
+class SensorReadingSingle(DataType):
+    value: float
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('value', 'value', False, 'primitive'),
+    )
+
+
+@register("Emulation.SensorReadingXYZ")
+@dataclass
+class SensorReadingXYZ(DataType):
+    x: float
+    y: float
+    z: float
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('x', 'x', False, 'primitive'),
+        FieldMeta('y', 'y', False, 'primitive'),
+        FieldMeta('z', 'z', False, 'primitive'),
+    )
+
+
+@register("Emulation.SensorReadingQuaternion")
+@dataclass
+class SensorReadingQuaternion(DataType):
+    x: float
+    y: float
+    z: float
+    w: float
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('x', 'x', False, 'primitive'),
+        FieldMeta('y', 'y', False, 'primitive'),
+        FieldMeta('z', 'z', False, 'primitive'),
+        FieldMeta('w', 'w', False, 'primitive'),
+    )
+
+
+@register("Emulation.SensorReading")
+@dataclass
+class SensorReading(DataType):
+    single: Optional[SensorReadingSingle] = None
+    xyz: Optional[SensorReadingXYZ] = None
+    quaternion: Optional[SensorReadingQuaternion] = None
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('single', 'single', True, 'object', ref='Emulation.SensorReadingSingle'),
+        FieldMeta('xyz', 'xyz', True, 'object', ref='Emulation.SensorReadingXYZ'),
+        FieldMeta('quaternion', 'quaternion', True, 'object', ref='Emulation.SensorReadingQuaternion'),
+    )
+
+
+@register("Emulation.PressureSource")
+class PressureSource(str, Enum):
+    CPU = 'cpu'
+
+
+@register("Emulation.PressureState")
+class PressureState(str, Enum):
+    NOMINAL = 'nominal'
+    FAIR = 'fair'
+    SERIOUS = 'serious'
+    CRITICAL = 'critical'
+
+
+@register("Emulation.PressureMetadata")
+@dataclass
+class PressureMetadata(DataType):
+    available: Optional[bool] = None
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('available', 'available', True, 'primitive'),
+    )
+
+
+@register("Emulation.WorkAreaInsets")
+@dataclass
+class WorkAreaInsets(DataType):
+    top: Optional[int] = None
+    left: Optional[int] = None
+    bottom: Optional[int] = None
+    right: Optional[int] = None
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('top', 'top', True, 'primitive'),
+        FieldMeta('left', 'left', True, 'primitive'),
+        FieldMeta('bottom', 'bottom', True, 'primitive'),
+        FieldMeta('right', 'right', True, 'primitive'),
+    )
+
+
+type ScreenId = str
+
+
+@register("Emulation.ScreenInfo")
+@dataclass
+class ScreenInfo(DataType):
+    """
+    Screen information similar to the one returned by window.getScreenDetails() method,
+    see https://w3c.github.io/window-management/#screendetailed.
+    """
+    left: int
+    top: int
+    width: int
+    height: int
+    avail_left: int
+    avail_top: int
+    avail_width: int
+    avail_height: int
+    device_pixel_ratio: float
+    orientation: ScreenOrientation
+    color_depth: int
+    is_extended: bool
+    is_internal: bool
+    is_primary: bool
+    label: str
+    id: ScreenId
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('left', 'left', False, 'primitive'),
+        FieldMeta('top', 'top', False, 'primitive'),
+        FieldMeta('width', 'width', False, 'primitive'),
+        FieldMeta('height', 'height', False, 'primitive'),
+        FieldMeta('avail_left', 'availLeft', False, 'primitive'),
+        FieldMeta('avail_top', 'availTop', False, 'primitive'),
+        FieldMeta('avail_width', 'availWidth', False, 'primitive'),
+        FieldMeta('avail_height', 'availHeight', False, 'primitive'),
+        FieldMeta('device_pixel_ratio', 'devicePixelRatio', False, 'primitive'),
+        FieldMeta('orientation', 'orientation', False, 'object', ref='Emulation.ScreenOrientation'),
+        FieldMeta('color_depth', 'colorDepth', False, 'primitive'),
+        FieldMeta('is_extended', 'isExtended', False, 'primitive'),
+        FieldMeta('is_internal', 'isInternal', False, 'primitive'),
+        FieldMeta('is_primary', 'isPrimary', False, 'primitive'),
+        FieldMeta('label', 'label', False, 'primitive'),
+        FieldMeta('id', 'id', False, 'primitive'),
+    )
+
+
+@register("Emulation.DisabledImageType")
+class DisabledImageType(str, Enum):
+    """Enum of image types that can be disabled."""
+    AVIF = 'avif'
+    WEBP = 'webp'
+
+__all__ = ["DevicePosture", "DisabledImageType", "DisplayFeature", "MediaFeature", "PressureMetadata", "PressureSource", "PressureState", "SafeAreaInsets", "ScreenId", "ScreenInfo", "ScreenOrientation", "SensorMetadata", "SensorReading", "SensorReadingQuaternion", "SensorReadingSingle", "SensorReadingXYZ", "SensorType", "UserAgentBrandVersion", "UserAgentMetadata", "VirtualTimePolicy", "WorkAreaInsets"]

parsek_cdp/cdp/eventbreakpoints/__init__.py

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

parsek_cdp/cdp/eventbreakpoints/events.py

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

@@ -0,0 +1,41 @@
+"""Commands for the EventBreakpoints 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 EventBreakpoints:
+    """Commands of the EventBreakpoints domain, bound to a target."""
+
+    def __init__(self, target: Any) -> None:
+        self._target = target
+
+
+    async def set_instrumentation_breakpoint(self, *, event_name: str) -> None:
+        """
+        Sets breakpoint on particular native event.
+        :param event_name: Instrumentation name to stop on.
+        """
+        _params: Dict[str, Any] = {}
+        _params['eventName'] = encode(FieldMeta('', '', False, 'primitive'), event_name)
+        _result = await self._target.send('EventBreakpoints.setInstrumentationBreakpoint', _params)
+        return None
+
+    async def remove_instrumentation_breakpoint(self, *, event_name: str) -> None:
+        """
+        Removes breakpoint on particular native event.
+        :param event_name: Instrumentation name to stop on.
+        """
+        _params: Dict[str, Any] = {}
+        _params['eventName'] = encode(FieldMeta('', '', False, 'primitive'), event_name)
+        _result = await self._target.send('EventBreakpoints.removeInstrumentationBreakpoint', _params)
+        return None
+
+    async def disable(self) -> None:
+        """Removes all breakpoints"""
+        _params: Dict[str, Any] = {}
+        _result = await self._target.send('EventBreakpoints.disable', _params)
+        return None

parsek_cdp/cdp/eventbreakpoints/types.py

@@ -0,0 +1,10 @@
+"""Custom types and enums for the EventBreakpoints 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/extensions/__init__.py

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

parsek_cdp/cdp/extensions/events.py

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

@@ -0,0 +1,118 @@
+"""Commands for the Extensions 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 StorageArea
+
+@dataclass
+class LoadUnpackedReturn(DataType):
+    """Return value of :meth:`Extensions.load_unpacked`."""
+    id: str
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('id', 'id', False, 'primitive'),
+    )
+
+
+@dataclass
+class GetStorageItemsReturn(DataType):
+    """Return value of :meth:`Extensions.get_storage_items`."""
+    data: Dict[str, Any]
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('data', 'data', False, 'primitive'),
+    )
+
+
+class Extensions:
+    """Commands of the Extensions domain, bound to a target."""
+
+    def __init__(self, target: Any) -> None:
+        self._target = target
+
+
+    async def load_unpacked(self, *, path: str) -> LoadUnpackedReturn:
+        """
+        Installs an unpacked extension from the filesystem similar to
+        --load-extension CLI flags. Returns extension ID once the extension
+        has been installed. Available if the client is connected using the
+        --remote-debugging-pipe flag and the --enable-unsafe-extension-debugging
+        flag is set.
+        :param path: Absolute file path.
+        """
+        _params: Dict[str, Any] = {}
+        _params['path'] = encode(FieldMeta('', '', False, 'primitive'), path)
+        _result = await self._target.send('Extensions.loadUnpacked', _params)
+        return LoadUnpackedReturn.from_json(_result)
+
+    async def uninstall(self, *, id: str) -> None:
+        """
+        Uninstalls an unpacked extension (others not supported) from the profile.
+        Available if the client is connected using the --remote-debugging-pipe flag
+        and the --enable-unsafe-extension-debugging.
+        :param id: Extension id.
+        """
+        _params: Dict[str, Any] = {}
+        _params['id'] = encode(FieldMeta('', '', False, 'primitive'), id)
+        _result = await self._target.send('Extensions.uninstall', _params)
+        return None
+
+    async def get_storage_items(self, *, id: str, storage_area: StorageArea, keys: Optional[List[str]] = None) -> GetStorageItemsReturn:
+        """
+        Gets data from extension storage in the given `storageArea`. If `keys` is
+        specified, these are used to filter the result.
+        :param id: ID of extension.
+        :param storage_area: StorageArea to retrieve data from.
+        :param keys: Keys to retrieve.
+        """
+        _params: Dict[str, Any] = {}
+        _params['id'] = encode(FieldMeta('', '', False, 'primitive'), id)
+        _params['storageArea'] = encode(FieldMeta('', '', False, 'enum', ref='Extensions.StorageArea'), storage_area)
+        if keys is not None:
+            _params['keys'] = encode(FieldMeta('', '', False, 'array', inner=FieldMeta('', '', False, 'primitive')), keys)
+        _result = await self._target.send('Extensions.getStorageItems', _params)
+        return GetStorageItemsReturn.from_json(_result)
+
+    async def remove_storage_items(self, *, id: str, storage_area: StorageArea, keys: List[str]) -> None:
+        """
+        Removes `keys` from extension storage in the given `storageArea`.
+        :param id: ID of extension.
+        :param storage_area: StorageArea to remove data from.
+        :param keys: Keys to remove.
+        """
+        _params: Dict[str, Any] = {}
+        _params['id'] = encode(FieldMeta('', '', False, 'primitive'), id)
+        _params['storageArea'] = encode(FieldMeta('', '', False, 'enum', ref='Extensions.StorageArea'), storage_area)
+        _params['keys'] = encode(FieldMeta('', '', False, 'array', inner=FieldMeta('', '', False, 'primitive')), keys)
+        _result = await self._target.send('Extensions.removeStorageItems', _params)
+        return None
+
+    async def clear_storage_items(self, *, id: str, storage_area: StorageArea) -> None:
+        """
+        Clears extension storage in the given `storageArea`.
+        :param id: ID of extension.
+        :param storage_area: StorageArea to remove data from.
+        """
+        _params: Dict[str, Any] = {}
+        _params['id'] = encode(FieldMeta('', '', False, 'primitive'), id)
+        _params['storageArea'] = encode(FieldMeta('', '', False, 'enum', ref='Extensions.StorageArea'), storage_area)
+        _result = await self._target.send('Extensions.clearStorageItems', _params)
+        return None
+
+    async def set_storage_items(self, *, id: str, storage_area: StorageArea, values: Dict[str, Any]) -> None:
+        """
+        Sets `values` in extension storage in the given `storageArea`. The provided `values`
+        will be merged with existing values in the storage area.
+        :param id: ID of extension.
+        :param storage_area: StorageArea to set data in.
+        :param values: Values to set.
+        """
+        _params: Dict[str, Any] = {}
+        _params['id'] = encode(FieldMeta('', '', False, 'primitive'), id)
+        _params['storageArea'] = encode(FieldMeta('', '', False, 'enum', ref='Extensions.StorageArea'), storage_area)
+        _params['values'] = encode(FieldMeta('', '', False, 'primitive'), values)
+        _result = await self._target.send('Extensions.setStorageItems', _params)
+        return None

parsek_cdp/cdp/extensions/types.py

@@ -0,0 +1,19 @@
+"""Custom types and enums for the Extensions 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("Extensions.StorageArea")
+class StorageArea(str, Enum):
+    """Storage areas."""
+    SESSION = 'session'
+    LOCAL = 'local'
+    SYNC = 'sync'
+    MANAGED = 'managed'
+
+__all__ = ["StorageArea"]

parsek_cdp/cdp/fedcm/__init__.py

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

parsek_cdp/cdp/fedcm/events.py

@@ -0,0 +1,45 @@
+"""Events for the FedCm 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 (
+        Account,
+        DialogType,
+    )
+
+@register_event("FedCm.dialogShown")
+@dataclass
+class DialogShown(Event):
+    dialog_id: str
+    dialog_type: DialogType
+    accounts: List[Account]
+    title: str
+    subtitle: Optional[str] = None
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('dialog_id', 'dialogId', False, 'primitive'),
+        FieldMeta('dialog_type', 'dialogType', False, 'enum', ref='FedCm.DialogType'),
+        FieldMeta('accounts', 'accounts', False, 'array', inner=FieldMeta('', '', False, 'object', ref='FedCm.Account')),
+        FieldMeta('title', 'title', False, 'primitive'),
+        FieldMeta('subtitle', 'subtitle', True, 'primitive'),
+    )
+
+
+@register_event("FedCm.dialogClosed")
+@dataclass
+class DialogClosed(Event):
+    """
+    Triggered when a dialog is closed, either by user action, JS abort,
+    or a command below.
+    """
+    dialog_id: str
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('dialog_id', 'dialogId', False, 'primitive'),
+    )
+
+__all__ = ["DialogClosed", "DialogShown"]