chromedeveloperprotocol-client 0.1.0__py3-none-any.whl

cdp/protocol/emulation/methods/types.py

@@ -0,0 +1,261 @@
+"""CDP Emulation Methods Types"""
+
+from typing import TypedDict, NotRequired, Required, Literal, Any, Dict, Union, Optional, List, Set, Tuple
+
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+    from cdp.protocol.dom.types import RGBA
+    from cdp.protocol.emulation.types import DevicePosture
+    from cdp.protocol.emulation.types import DisabledImageType
+    from cdp.protocol.emulation.types import DisplayFeature
+    from cdp.protocol.emulation.types import MediaFeature
+    from cdp.protocol.emulation.types import PressureMetadata
+    from cdp.protocol.emulation.types import PressureSource
+    from cdp.protocol.emulation.types import PressureState
+    from cdp.protocol.emulation.types import SafeAreaInsets
+    from cdp.protocol.emulation.types import ScreenId
+    from cdp.protocol.emulation.types import ScreenInfo
+    from cdp.protocol.emulation.types import ScreenOrientation
+    from cdp.protocol.emulation.types import SensorMetadata
+    from cdp.protocol.emulation.types import SensorReading
+    from cdp.protocol.emulation.types import SensorType
+    from cdp.protocol.emulation.types import UserAgentMetadata
+    from cdp.protocol.emulation.types import VirtualTimePolicy
+    from cdp.protocol.emulation.types import WorkAreaInsets
+    from cdp.protocol.network.types import TimeSinceEpoch
+    from cdp.protocol.page.types import Viewport
+
+
+
+
+class setFocusEmulationEnabledParameters(TypedDict, total=True):
+    enabled: 'bool'
+    """Whether to enable to disable focus emulation."""
+class setAutoDarkModeOverrideParameters(TypedDict, total=False):
+    enabled: NotRequired['bool']
+    """Whether to enable or disable automatic dark mode. If not specified, any existing override will be cleared."""
+class setCPUThrottlingRateParameters(TypedDict, total=True):
+    rate: 'float'
+    """Throttling rate as a slowdown factor (1 is no throttle, 2 is 2x slowdown, etc)."""
+class setDefaultBackgroundColorOverrideParameters(TypedDict, total=False):
+    color: NotRequired['RGBA']
+    """RGBA of the default background color. If not specified, any existing override will be cleared."""
+class setSafeAreaInsetsOverrideParameters(TypedDict, total=True):
+    insets: 'SafeAreaInsets'
+class setDeviceMetricsOverrideParameters(TypedDict, total=True):
+    width: 'int'
+    """Overriding width value in pixels (minimum 0, maximum 10000000). 0 disables the override."""
+    height: 'int'
+    """Overriding height value in pixels (minimum 0, maximum 10000000). 0 disables the override."""
+    deviceScaleFactor: 'float'
+    """Overriding device scale factor value. 0 disables the override."""
+    mobile: 'bool'
+    """Whether to emulate mobile device. This includes viewport meta tag, overlay scrollbars, text autosizing and more."""
+    scale: NotRequired['float']
+    """Scale to apply to resulting view image."""
+    screenWidth: NotRequired['int']
+    """Overriding screen width value in pixels (minimum 0, maximum 10000000)."""
+    screenHeight: NotRequired['int']
+    """Overriding screen height value in pixels (minimum 0, maximum 10000000)."""
+    positionX: NotRequired['int']
+    """Overriding view X position on screen in pixels (minimum 0, maximum 10000000)."""
+    positionY: NotRequired['int']
+    """Overriding view Y position on screen in pixels (minimum 0, maximum 10000000)."""
+    dontSetVisibleSize: NotRequired['bool']
+    """Do not set visible view size, rely upon explicit setVisibleSize call."""
+    screenOrientation: NotRequired['ScreenOrientation']
+    """Screen orientation override."""
+    viewport: NotRequired['Viewport']
+    """If set, the visible area of the page will be overridden to this viewport. This viewport change is not observed by the page, e.g. viewport-relative elements do not change positions."""
+    displayFeature: NotRequired['DisplayFeature']
+    """If set, the display feature of a multi-segment screen. If not set, multi-segment support is turned-off. Deprecated, use Emulation.setDisplayFeaturesOverride."""
+    devicePosture: NotRequired['DevicePosture']
+    """If set, the posture of a foldable device. If not set the posture is set to continuous. Deprecated, use Emulation.setDevicePostureOverride."""
+class setDevicePostureOverrideParameters(TypedDict, total=True):
+    posture: 'DevicePosture'
+
+class setDisplayFeaturesOverrideParameters(TypedDict, total=True):
+    features: 'List[DisplayFeature]'
+
+class setScrollbarsHiddenParameters(TypedDict, total=True):
+    hidden: 'bool'
+    """Whether scrollbars should be always hidden."""
+class setDocumentCookieDisabledParameters(TypedDict, total=True):
+    disabled: 'bool'
+    """Whether document.coookie API should be disabled."""
+class setEmitTouchEventsForMouseParameters(TypedDict, total=True):
+    enabled: 'bool'
+    """Whether touch emulation based on mouse input should be enabled."""
+    configuration: NotRequired['Literal["mobile", "desktop"]']
+    """Touch/gesture events configuration. Default: current platform."""
+class setEmulatedMediaParameters(TypedDict, total=False):
+    media: NotRequired['str']
+    """Media type to emulate. Empty string disables the override."""
+    features: NotRequired['List[MediaFeature]']
+    """Media features to emulate."""
+class setEmulatedVisionDeficiencyParameters(TypedDict, total=True):
+    type: 'Literal["none", "blurredVision", "reducedContrast", "achromatopsia", "deuteranopia", "protanopia", "tritanopia"]'
+    """Vision deficiency to emulate. Order: best-effort emulations come first, followed by any physiologically accurate emulations for medically recognized color vision deficiencies."""
+class setEmulatedOSTextScaleParameters(TypedDict, total=False):
+    scale: NotRequired['float']
+class setGeolocationOverrideParameters(TypedDict, total=False):
+    latitude: NotRequired['float']
+    """Mock latitude"""
+    longitude: NotRequired['float']
+    """Mock longitude"""
+    accuracy: NotRequired['float']
+    """Mock accuracy"""
+    altitude: NotRequired['float']
+    """Mock altitude"""
+    altitudeAccuracy: NotRequired['float']
+    """Mock altitudeAccuracy"""
+    heading: NotRequired['float']
+    """Mock heading"""
+    speed: NotRequired['float']
+    """Mock speed"""
+class getOverriddenSensorInformationParameters(TypedDict, total=True):
+    type: 'SensorType'
+class setSensorOverrideEnabledParameters(TypedDict, total=True):
+    enabled: 'bool'
+    type: 'SensorType'
+    metadata: NotRequired['SensorMetadata']
+class setSensorOverrideReadingsParameters(TypedDict, total=True):
+    type: 'SensorType'
+    reading: 'SensorReading'
+class setPressureSourceOverrideEnabledParameters(TypedDict, total=True):
+    enabled: 'bool'
+    source: 'PressureSource'
+    metadata: NotRequired['PressureMetadata']
+class setPressureStateOverrideParameters(TypedDict, total=True):
+    source: 'PressureSource'
+    state: 'PressureState'
+class setPressureDataOverrideParameters(TypedDict, total=True):
+    source: 'PressureSource'
+    state: 'PressureState'
+    ownContributionEstimate: NotRequired['float']
+class setIdleOverrideParameters(TypedDict, total=True):
+    isUserActive: 'bool'
+    """Mock isUserActive"""
+    isScreenUnlocked: 'bool'
+    """Mock isScreenUnlocked"""
+
+class setPageScaleFactorParameters(TypedDict, total=True):
+    pageScaleFactor: 'float'
+    """Page scale factor."""
+class setScriptExecutionDisabledParameters(TypedDict, total=True):
+    value: 'bool'
+    """Whether script execution should be disabled in the page."""
+class setTouchEmulationEnabledParameters(TypedDict, total=True):
+    enabled: 'bool'
+    """Whether the touch event emulation should be enabled."""
+    maxTouchPoints: NotRequired['int']
+    """Maximum touch points supported. Defaults to one."""
+class setVirtualTimePolicyParameters(TypedDict, total=True):
+    policy: 'VirtualTimePolicy'
+    budget: NotRequired['float']
+    """If set, after this many virtual milliseconds have elapsed virtual time will be paused and a virtualTimeBudgetExpired event is sent."""
+    maxVirtualTimeTaskStarvationCount: NotRequired['int']
+    """If set this specifies the maximum number of tasks that can be run before virtual is forced forwards to prevent deadlock."""
+    initialVirtualTime: NotRequired['TimeSinceEpoch']
+    """If set, base::Time::Now will be overridden to initially return this value."""
+class setLocaleOverrideParameters(TypedDict, total=False):
+    locale: NotRequired['str']
+    """ICU style C locale (e.g. "en_US"). If not specified or empty, disables the override and restores default host system locale."""
+class setTimezoneOverrideParameters(TypedDict, total=True):
+    timezoneId: 'str'
+    """The timezone identifier. List of supported timezones: https://source.chromium.org/chromium/chromium/deps/icu.git/+/faee8bc70570192d82d2978a71e2a615788597d1:source/data/misc/metaZones.txt If empty, disables the override and restores default host system timezone."""
+class setDisabledImageTypesParameters(TypedDict, total=True):
+    imageTypes: 'List[DisabledImageType]'
+    """Image types to disable."""
+class setDataSaverOverrideParameters(TypedDict, total=False):
+    dataSaverEnabled: NotRequired['bool']
+    """Override value. Omitting the parameter disables the override."""
+class setHardwareConcurrencyOverrideParameters(TypedDict, total=True):
+    hardwareConcurrency: 'int'
+    """Hardware concurrency to report"""
+class setUserAgentOverrideParameters(TypedDict, total=True):
+    userAgent: 'str'
+    """User agent to use."""
+    acceptLanguage: NotRequired['str']
+    """Browser language to emulate."""
+    platform: NotRequired['str']
+    """The platform navigator.platform should return."""
+    userAgentMetadata: NotRequired['UserAgentMetadata']
+    """To be sent in Sec-CH-UA-* headers and returned in navigator.userAgentData"""
+class setAutomationOverrideParameters(TypedDict, total=True):
+    enabled: 'bool'
+    """Whether the override should be enabled."""
+class setSmallViewportHeightDifferenceOverrideParameters(TypedDict, total=True):
+    difference: 'int'
+    """This will cause an element of size 100svh to be difference pixels smaller than an element of size 100lvh."""
+
+class addScreenParameters(TypedDict, total=True):
+    left: 'int'
+    """Offset of the left edge of the screen in pixels."""
+    top: 'int'
+    """Offset of the top edge of the screen in pixels."""
+    width: 'int'
+    """The width of the screen in pixels."""
+    height: 'int'
+    """The height of the screen in pixels."""
+    workAreaInsets: NotRequired['WorkAreaInsets']
+    """Specifies the screen's work area. Default is entire screen."""
+    devicePixelRatio: NotRequired['float']
+    """Specifies the screen's device pixel ratio. Default is 1."""
+    rotation: NotRequired['int']
+    """Specifies the screen's rotation angle. Available values are 0, 90, 180 and 270. Default is 0."""
+    colorDepth: NotRequired['int']
+    """Specifies the screen's color depth in bits. Default is 24."""
+    label: NotRequired['str']
+    """Specifies the descriptive label for the screen. Default is none."""
+    isInternal: NotRequired['bool']
+    """Indicates whether the screen is internal to the device or external, attached to the device. Default is false."""
+class removeScreenParameters(TypedDict, total=True):
+    screenId: 'ScreenId'
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+class getOverriddenSensorInformationReturns(TypedDict):
+    requestedSamplingFrequency: 'float'
+
+
+
+
+
+
+
+
+
+
+class setVirtualTimePolicyReturns(TypedDict):
+    virtualTimeTicksBase: 'float'
+    """Absolute timestamp at which virtual time was first enabled (up time in milliseconds)."""
+
+
+
+
+
+
+
+
+class getScreenInfosReturns(TypedDict):
+    screenInfos: 'List[ScreenInfo]'
+class addScreenReturns(TypedDict):
+    screenInfo: 'ScreenInfo'

cdp/protocol/emulation/service.py

@@ -0,0 +1,21 @@
+"""CDP Emulation Domain"""
+from typing import TYPE_CHECKING
+from .methods.service import EmulationMethods
+from .events.service import EmulationEvents
+
+if TYPE_CHECKING:
+    from ...service import Client
+
+class Emulation(EmulationMethods, EmulationEvents):
+    """
+    This domain emulates different environments for the page.
+    """
+    def __init__(self, client: "Client"):
+        """
+        Initialize the Emulation domain.
+        
+        Args:
+            client ("Client"): The parent CDP client instance.
+        """
+        EmulationMethods.__init__(self, client)
+        EmulationEvents.__init__(self, client)

cdp/protocol/emulation/types.py

@@ -0,0 +1,132 @@
+"""CDP Emulation Types"""
+
+from typing import TypedDict, NotRequired, Required, Literal, Any, Dict, Union, Optional, List, Set, Tuple
+
+class SafeAreaInsets(TypedDict, total=False):
+    top: NotRequired['int']
+    """Overrides safe-area-inset-top."""
+    topMax: NotRequired['int']
+    """Overrides safe-area-max-inset-top."""
+    left: NotRequired['int']
+    """Overrides safe-area-inset-left."""
+    leftMax: NotRequired['int']
+    """Overrides safe-area-max-inset-left."""
+    bottom: NotRequired['int']
+    """Overrides safe-area-inset-bottom."""
+    bottomMax: NotRequired['int']
+    """Overrides safe-area-max-inset-bottom."""
+    right: NotRequired['int']
+    """Overrides safe-area-inset-right."""
+    rightMax: NotRequired['int']
+    """Overrides safe-area-max-inset-right."""
+class ScreenOrientation(TypedDict, total=True):
+    """Screen orientation."""
+    type: 'Literal["portraitPrimary", "portraitSecondary", "landscapePrimary", "landscapeSecondary"]'
+    """Orientation type."""
+    angle: 'int'
+    """Orientation angle."""
+class DisplayFeature(TypedDict, total=True):
+    orientation: 'Literal["vertical", "horizontal"]'
+    """Orientation of a display feature in relation to screen"""
+    offset: 'int'
+    """The offset from the screen origin in either the x (for vertical orientation) or y (for horizontal orientation) direction."""
+    maskLength: 'int'
+    """A display feature may mask content such that it is not physically displayed - this length along with the offset describes this area. A display feature that only splits content will have a 0 mask_length."""
+class DevicePosture(TypedDict, total=True):
+    type: 'Literal["continuous", "folded"]'
+    """Current posture of the device"""
+class MediaFeature(TypedDict, total=True):
+    name: 'str'
+    value: 'str'
+VirtualTimePolicy = Literal['advance','pause','pauseIfNetworkFetchesPending']
+"""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."""
+class UserAgentBrandVersion(TypedDict, total=True):
+    """Used to specify User Agent Client Hints to emulate. See https://wicg.github.io/ua-client-hints"""
+    brand: 'str'
+    version: 'str'
+class UserAgentMetadata(TypedDict, total=True):
+    """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'
+    platformVersion: 'str'
+    architecture: 'str'
+    model: 'str'
+    mobile: 'bool'
+    brands: NotRequired['List[UserAgentBrandVersion]']
+    """Brands appearing in Sec-CH-UA."""
+    fullVersionList: NotRequired['List[UserAgentBrandVersion]']
+    """Brands appearing in Sec-CH-UA-Full-Version-List."""
+    bitness: NotRequired['str']
+    wow64: NotRequired['bool']
+    formFactors: NotRequired['List[str]']
+    """Used to specify User Agent form-factor values. See https://wicg.github.io/ua-client-hints/#sec-ch-ua-form-factors"""
+SensorType = Literal['absolute-orientation','accelerometer','ambient-light','gravity','gyroscope','linear-acceleration','magnetometer','relative-orientation']
+"""Used to specify sensor types to emulate. See https://w3c.github.io/sensors/#automation for more information."""
+class SensorMetadata(TypedDict, total=False):
+    available: NotRequired['bool']
+    minimumFrequency: NotRequired['float']
+    maximumFrequency: NotRequired['float']
+class SensorReadingSingle(TypedDict, total=True):
+    value: 'float'
+class SensorReadingXYZ(TypedDict, total=True):
+    x: 'float'
+    y: 'float'
+    z: 'float'
+class SensorReadingQuaternion(TypedDict, total=True):
+    x: 'float'
+    y: 'float'
+    z: 'float'
+    w: 'float'
+class SensorReading(TypedDict, total=False):
+    single: NotRequired['SensorReadingSingle']
+    xyz: NotRequired['SensorReadingXYZ']
+    quaternion: NotRequired['SensorReadingQuaternion']
+PressureSource = Literal['cpu']
+PressureState = Literal['nominal','fair','serious','critical']
+class PressureMetadata(TypedDict, total=False):
+    available: NotRequired['bool']
+class WorkAreaInsets(TypedDict, total=False):
+    top: NotRequired['int']
+    """Work area top inset in pixels. Default is 0;"""
+    left: NotRequired['int']
+    """Work area left inset in pixels. Default is 0;"""
+    bottom: NotRequired['int']
+    """Work area bottom inset in pixels. Default is 0;"""
+    right: NotRequired['int']
+    """Work area right inset in pixels. Default is 0;"""
+ScreenId = str
+class ScreenInfo(TypedDict, total=True):
+    """Screen information similar to the one returned by window.getScreenDetails() method, see https://w3c.github.io/window-management/#screendetailed."""
+    left: 'int'
+    """Offset of the left edge of the screen."""
+    top: 'int'
+    """Offset of the top edge of the screen."""
+    width: 'int'
+    """Width of the screen."""
+    height: 'int'
+    """Height of the screen."""
+    availLeft: 'int'
+    """Offset of the left edge of the available screen area."""
+    availTop: 'int'
+    """Offset of the top edge of the available screen area."""
+    availWidth: 'int'
+    """Width of the available screen area."""
+    availHeight: 'int'
+    """Height of the available screen area."""
+    devicePixelRatio: 'float'
+    """Specifies the screen's device pixel ratio."""
+    orientation: 'ScreenOrientation'
+    """Specifies the screen's orientation."""
+    colorDepth: 'int'
+    """Specifies the screen's color depth in bits."""
+    isExtended: 'bool'
+    """Indicates whether the device has multiple screens."""
+    isInternal: 'bool'
+    """Indicates whether the screen is internal to the device or external, attached to the device."""
+    isPrimary: 'bool'
+    """Indicates whether the screen is set as the the operating system primary screen."""
+    label: 'str'
+    """Specifies the descriptive label for the screen."""
+    id: 'ScreenId'
+    """Specifies the unique identifier of the screen."""
+DisabledImageType = Literal['avif','webp']
+"""Enum of image types that can be disabled."""

cdp/protocol/event_breakpoints/events/service.py

@@ -0,0 +1,20 @@
+"""CDP EventBreakpoints Domain Events"""
+from ..types import *
+from .types import *
+from typing import Optional, Dict, Any, Callable, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ....service import Client
+
+class EventBreakpointsEvents:
+    """
+    Events for the EventBreakpoints domain.
+    """
+    def __init__(self, client: "Client"):
+        """
+        Initialize the EventBreakpoints events.
+        
+        Args:
+            client ("Client"): The parent CDP client instance.
+        """
+        self.client = client

cdp/protocol/event_breakpoints/events/types.py

@@ -0,0 +1,3 @@
+"""CDP EventBreakpoints Events"""
+
+from typing import TypedDict, NotRequired, Required, Literal, Any, Dict, Union, Optional, List, Set, Tuple

cdp/protocol/event_breakpoints/methods/service.py

@@ -0,0 +1,54 @@
+"""CDP EventBreakpoints Domain Methods"""
+from ..types import *
+from .types import *
+from typing import Optional, Dict, Any, Callable, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ....service import Client
+
+class EventBreakpointsMethods:
+    """
+    Methods for the EventBreakpoints domain.
+    """
+    def __init__(self, client: "Client"):
+        """
+        Initialize the EventBreakpoints methods.
+        
+        Args:
+            client ("Client"): The parent CDP client instance.
+        """
+        self.client = client
+
+    async def set_instrumentation_breakpoint(self, params: Optional[setInstrumentationBreakpointParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Sets breakpoint on particular native event.    
+        Args:
+            params (setInstrumentationBreakpointParameters, optional): Parameters for the setInstrumentationBreakpoint method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the setInstrumentationBreakpoint call.
+        """
+        return await self.client.send(method="EventBreakpoints.setInstrumentationBreakpoint", params=params,session_id=session_id)
+    async def remove_instrumentation_breakpoint(self, params: Optional[removeInstrumentationBreakpointParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Removes breakpoint on particular native event.    
+        Args:
+            params (removeInstrumentationBreakpointParameters, optional): Parameters for the removeInstrumentationBreakpoint method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the removeInstrumentationBreakpoint call.
+        """
+        return await self.client.send(method="EventBreakpoints.removeInstrumentationBreakpoint", params=params,session_id=session_id)
+    async def disable(self, params: None=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Removes all breakpoints    
+        Args:
+            params (None, optional): Parameters for the disable method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the disable call.
+        """
+        return await self.client.send(method="EventBreakpoints.disable", params=params,session_id=session_id)

cdp/protocol/event_breakpoints/methods/types.py

@@ -0,0 +1,10 @@
+"""CDP EventBreakpoints Methods Types"""
+
+from typing import TypedDict, NotRequired, Required, Literal, Any, Dict, Union, Optional, List, Set, Tuple
+
+class setInstrumentationBreakpointParameters(TypedDict, total=True):
+    eventName: 'str'
+    """Instrumentation name to stop on."""
+class removeInstrumentationBreakpointParameters(TypedDict, total=True):
+    eventName: 'str'
+    """Instrumentation name to stop on."""

cdp/protocol/event_breakpoints/service.py

@@ -0,0 +1,21 @@
+"""CDP EventBreakpoints Domain"""
+from typing import TYPE_CHECKING
+from .methods.service import EventBreakpointsMethods
+from .events.service import EventBreakpointsEvents
+
+if TYPE_CHECKING:
+    from ...service import Client
+
+class EventBreakpoints(EventBreakpointsMethods, EventBreakpointsEvents):
+    """
+    EventBreakpoints permits setting JavaScript breakpoints on operations and events occurring in native code invoked from JavaScript. Once breakpoint is hit, it is reported through Debugger domain, similarly to regular breakpoints being hit.
+    """
+    def __init__(self, client: "Client"):
+        """
+        Initialize the EventBreakpoints domain.
+        
+        Args:
+            client ("Client"): The parent CDP client instance.
+        """
+        EventBreakpointsMethods.__init__(self, client)
+        EventBreakpointsEvents.__init__(self, client)

cdp/protocol/event_breakpoints/types.py

@@ -0,0 +1,3 @@
+"""CDP EventBreakpoints Types"""
+
+from typing import TypedDict, NotRequired, Required, Literal, Any, Dict, Union, Optional, List, Set, Tuple

cdp/protocol/extensions/events/service.py

@@ -0,0 +1,20 @@
+"""CDP Extensions Domain Events"""
+from ..types import *
+from .types import *
+from typing import Optional, Dict, Any, Callable, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ....service import Client
+
+class ExtensionsEvents:
+    """
+    Events for the Extensions domain.
+    """
+    def __init__(self, client: "Client"):
+        """
+        Initialize the Extensions events.
+        
+        Args:
+            client ("Client"): The parent CDP client instance.
+        """
+        self.client = client

cdp/protocol/extensions/events/types.py

@@ -0,0 +1,3 @@
+"""CDP Extensions Events"""
+
+from typing import TypedDict, NotRequired, Required, Literal, Any, Dict, Union, Optional, List, Set, Tuple