mithwire 0.50.3__py3-none-any.whl

mithwire/cdp/emulation.py

@@ -0,0 +1,1779 @@
+# DO NOT EDIT THIS FILE!
+#
+# This file is generated from the CDP specification. If you need to make
+# changes, edit the generator and regenerate all of the modules.
+#
+# CDP domain: Emulation
+
+from __future__ import annotations
+import enum
+import typing
+from dataclasses import dataclass
+from .util import event_class, T_JSON_DICT
+
+from . import dom
+from . import network
+from . import page
+from deprecated.sphinx import deprecated # type: ignore
+
+
+@dataclass
+class SafeAreaInsets:
+    #: Overrides safe-area-inset-top.
+    top: typing.Optional[int] = None
+
+    #: Overrides safe-area-max-inset-top.
+    top_max: typing.Optional[int] = None
+
+    #: Overrides safe-area-inset-left.
+    left: typing.Optional[int] = None
+
+    #: Overrides safe-area-max-inset-left.
+    left_max: typing.Optional[int] = None
+
+    #: Overrides safe-area-inset-bottom.
+    bottom: typing.Optional[int] = None
+
+    #: Overrides safe-area-max-inset-bottom.
+    bottom_max: typing.Optional[int] = None
+
+    #: Overrides safe-area-inset-right.
+    right: typing.Optional[int] = None
+
+    #: Overrides safe-area-max-inset-right.
+    right_max: typing.Optional[int] = None
+
+    def to_json(self) -> T_JSON_DICT:
+        json: T_JSON_DICT = dict()
+        if self.top is not None:
+            json['top'] = self.top
+        if self.top_max is not None:
+            json['topMax'] = self.top_max
+        if self.left is not None:
+            json['left'] = self.left
+        if self.left_max is not None:
+            json['leftMax'] = self.left_max
+        if self.bottom is not None:
+            json['bottom'] = self.bottom
+        if self.bottom_max is not None:
+            json['bottomMax'] = self.bottom_max
+        if self.right is not None:
+            json['right'] = self.right
+        if self.right_max is not None:
+            json['rightMax'] = self.right_max
+        return json
+
+    @classmethod
+    def from_json(cls, json: T_JSON_DICT) -> SafeAreaInsets:
+        return cls(
+            top=int(json['top']) if json.get('top', None) is not None else None,
+            top_max=int(json['topMax']) if json.get('topMax', None) is not None else None,
+            left=int(json['left']) if json.get('left', None) is not None else None,
+            left_max=int(json['leftMax']) if json.get('leftMax', None) is not None else None,
+            bottom=int(json['bottom']) if json.get('bottom', None) is not None else None,
+            bottom_max=int(json['bottomMax']) if json.get('bottomMax', None) is not None else None,
+            right=int(json['right']) if json.get('right', None) is not None else None,
+            right_max=int(json['rightMax']) if json.get('rightMax', None) is not None else None,
+        )
+
+
+@dataclass
+class ScreenOrientation:
+    '''
+    Screen orientation.
+    '''
+    #: Orientation type.
+    type_: str
+
+    #: Orientation angle.
+    angle: int
+
+    def to_json(self) -> T_JSON_DICT:
+        json: T_JSON_DICT = dict()
+        json['type'] = self.type_
+        json['angle'] = self.angle
+        return json
+
+    @classmethod
+    def from_json(cls, json: T_JSON_DICT) -> ScreenOrientation:
+        return cls(
+            type_=str(json['type']),
+            angle=int(json['angle']),
+        )
+
+
+@dataclass
+class DisplayFeature:
+    #: Orientation of a display feature in relation to screen
+    orientation: str
+
+    #: The offset from the screen origin in either the x (for vertical
+    #: orientation) or y (for horizontal orientation) direction.
+    offset: 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.
+    mask_length: int
+
+    def to_json(self) -> T_JSON_DICT:
+        json: T_JSON_DICT = dict()
+        json['orientation'] = self.orientation
+        json['offset'] = self.offset
+        json['maskLength'] = self.mask_length
+        return json
+
+    @classmethod
+    def from_json(cls, json: T_JSON_DICT) -> DisplayFeature:
+        return cls(
+            orientation=str(json['orientation']),
+            offset=int(json['offset']),
+            mask_length=int(json['maskLength']),
+        )
+
+
+@dataclass
+class DevicePosture:
+    #: Current posture of the device
+    type_: str
+
+    def to_json(self) -> T_JSON_DICT:
+        json: T_JSON_DICT = dict()
+        json['type'] = self.type_
+        return json
+
+    @classmethod
+    def from_json(cls, json: T_JSON_DICT) -> DevicePosture:
+        return cls(
+            type_=str(json['type']),
+        )
+
+
+@dataclass
+class MediaFeature:
+    name: str
+
+    value: str
+
+    def to_json(self) -> T_JSON_DICT:
+        json: T_JSON_DICT = dict()
+        json['name'] = self.name
+        json['value'] = self.value
+        return json
+
+    @classmethod
+    def from_json(cls, json: T_JSON_DICT) -> MediaFeature:
+        return cls(
+            name=str(json['name']),
+            value=str(json['value']),
+        )
+
+
+class VirtualTimePolicy(enum.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"
+    PAUSE_IF_NETWORK_FETCHES_PENDING = "pauseIfNetworkFetchesPending"
+
+    def to_json(self) -> str:
+        return self.value
+
+    @classmethod
+    def from_json(cls, json: str) -> VirtualTimePolicy:
+        return cls(json)
+
+
+@dataclass
+class UserAgentBrandVersion:
+    '''
+    Used to specify User Agent Client Hints to emulate. See https://wicg.github.io/ua-client-hints
+    '''
+    brand: str
+
+    version: str
+
+    def to_json(self) -> T_JSON_DICT:
+        json: T_JSON_DICT = dict()
+        json['brand'] = self.brand
+        json['version'] = self.version
+        return json
+
+    @classmethod
+    def from_json(cls, json: T_JSON_DICT) -> UserAgentBrandVersion:
+        return cls(
+            brand=str(json['brand']),
+            version=str(json['version']),
+        )
+
+
+@dataclass
+class UserAgentMetadata:
+    '''
+    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 appearing in Sec-CH-UA.
+    brands: typing.Optional[typing.List[UserAgentBrandVersion]] = None
+
+    #: Brands appearing in Sec-CH-UA-Full-Version-List.
+    full_version_list: typing.Optional[typing.List[UserAgentBrandVersion]] = None
+
+    full_version: typing.Optional[str] = None
+
+    bitness: typing.Optional[str] = None
+
+    wow64: typing.Optional[bool] = None
+
+    #: Used to specify User Agent form-factor values.
+    #: See https://wicg.github.io/ua-client-hints/#sec-ch-ua-form-factors
+    form_factors: typing.Optional[typing.List[str]] = None
+
+    def to_json(self) -> T_JSON_DICT:
+        json: T_JSON_DICT = dict()
+        json['platform'] = self.platform
+        json['platformVersion'] = self.platform_version
+        json['architecture'] = self.architecture
+        json['model'] = self.model
+        json['mobile'] = self.mobile
+        if self.brands is not None:
+            json['brands'] = [i.to_json() for i in self.brands]
+        if self.full_version_list is not None:
+            json['fullVersionList'] = [i.to_json() for i in self.full_version_list]
+        if self.full_version is not None:
+            json['fullVersion'] = self.full_version
+        if self.bitness is not None:
+            json['bitness'] = self.bitness
+        if self.wow64 is not None:
+            json['wow64'] = self.wow64
+        if self.form_factors is not None:
+            json['formFactors'] = [i for i in self.form_factors]
+        return json
+
+    @classmethod
+    def from_json(cls, json: T_JSON_DICT) -> UserAgentMetadata:
+        return cls(
+            platform=str(json['platform']),
+            platform_version=str(json['platformVersion']),
+            architecture=str(json['architecture']),
+            model=str(json['model']),
+            mobile=bool(json['mobile']),
+            brands=[UserAgentBrandVersion.from_json(i) for i in json['brands']] if json.get('brands', None) is not None else None,
+            full_version_list=[UserAgentBrandVersion.from_json(i) for i in json['fullVersionList']] if json.get('fullVersionList', None) is not None else None,
+            full_version=str(json['fullVersion']) if json.get('fullVersion', None) is not None else None,
+            bitness=str(json['bitness']) if json.get('bitness', None) is not None else None,
+            wow64=bool(json['wow64']) if json.get('wow64', None) is not None else None,
+            form_factors=[str(i) for i in json['formFactors']] if json.get('formFactors', None) is not None else None,
+        )
+
+
+class SensorType(enum.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"
+
+    def to_json(self) -> str:
+        return self.value
+
+    @classmethod
+    def from_json(cls, json: str) -> SensorType:
+        return cls(json)
+
+
+@dataclass
+class SensorMetadata:
+    available: typing.Optional[bool] = None
+
+    minimum_frequency: typing.Optional[float] = None
+
+    maximum_frequency: typing.Optional[float] = None
+
+    def to_json(self) -> T_JSON_DICT:
+        json: T_JSON_DICT = dict()
+        if self.available is not None:
+            json['available'] = self.available
+        if self.minimum_frequency is not None:
+            json['minimumFrequency'] = self.minimum_frequency
+        if self.maximum_frequency is not None:
+            json['maximumFrequency'] = self.maximum_frequency
+        return json
+
+    @classmethod
+    def from_json(cls, json: T_JSON_DICT) -> SensorMetadata:
+        return cls(
+            available=bool(json['available']) if json.get('available', None) is not None else None,
+            minimum_frequency=float(json['minimumFrequency']) if json.get('minimumFrequency', None) is not None else None,
+            maximum_frequency=float(json['maximumFrequency']) if json.get('maximumFrequency', None) is not None else None,
+        )
+
+
+@dataclass
+class SensorReadingSingle:
+    value: float
+
+    def to_json(self) -> T_JSON_DICT:
+        json: T_JSON_DICT = dict()
+        json['value'] = self.value
+        return json
+
+    @classmethod
+    def from_json(cls, json: T_JSON_DICT) -> SensorReadingSingle:
+        return cls(
+            value=float(json['value']),
+        )
+
+
+@dataclass
+class SensorReadingXYZ:
+    x: float
+
+    y: float
+
+    z: float
+
+    def to_json(self) -> T_JSON_DICT:
+        json: T_JSON_DICT = dict()
+        json['x'] = self.x
+        json['y'] = self.y
+        json['z'] = self.z
+        return json
+
+    @classmethod
+    def from_json(cls, json: T_JSON_DICT) -> SensorReadingXYZ:
+        return cls(
+            x=float(json['x']),
+            y=float(json['y']),
+            z=float(json['z']),
+        )
+
+
+@dataclass
+class SensorReadingQuaternion:
+    x: float
+
+    y: float
+
+    z: float
+
+    w: float
+
+    def to_json(self) -> T_JSON_DICT:
+        json: T_JSON_DICT = dict()
+        json['x'] = self.x
+        json['y'] = self.y
+        json['z'] = self.z
+        json['w'] = self.w
+        return json
+
+    @classmethod
+    def from_json(cls, json: T_JSON_DICT) -> SensorReadingQuaternion:
+        return cls(
+            x=float(json['x']),
+            y=float(json['y']),
+            z=float(json['z']),
+            w=float(json['w']),
+        )
+
+
+@dataclass
+class SensorReading:
+    single: typing.Optional[SensorReadingSingle] = None
+
+    xyz: typing.Optional[SensorReadingXYZ] = None
+
+    quaternion: typing.Optional[SensorReadingQuaternion] = None
+
+    def to_json(self) -> T_JSON_DICT:
+        json: T_JSON_DICT = dict()
+        if self.single is not None:
+            json['single'] = self.single.to_json()
+        if self.xyz is not None:
+            json['xyz'] = self.xyz.to_json()
+        if self.quaternion is not None:
+            json['quaternion'] = self.quaternion.to_json()
+        return json
+
+    @classmethod
+    def from_json(cls, json: T_JSON_DICT) -> SensorReading:
+        return cls(
+            single=SensorReadingSingle.from_json(json['single']) if json.get('single', None) is not None else None,
+            xyz=SensorReadingXYZ.from_json(json['xyz']) if json.get('xyz', None) is not None else None,
+            quaternion=SensorReadingQuaternion.from_json(json['quaternion']) if json.get('quaternion', None) is not None else None,
+        )
+
+
+class PressureSource(enum.Enum):
+    CPU = "cpu"
+
+    def to_json(self) -> str:
+        return self.value
+
+    @classmethod
+    def from_json(cls, json: str) -> PressureSource:
+        return cls(json)
+
+
+class PressureState(enum.Enum):
+    NOMINAL = "nominal"
+    FAIR = "fair"
+    SERIOUS = "serious"
+    CRITICAL = "critical"
+
+    def to_json(self) -> str:
+        return self.value
+
+    @classmethod
+    def from_json(cls, json: str) -> PressureState:
+        return cls(json)
+
+
+@dataclass
+class PressureMetadata:
+    available: typing.Optional[bool] = None
+
+    def to_json(self) -> T_JSON_DICT:
+        json: T_JSON_DICT = dict()
+        if self.available is not None:
+            json['available'] = self.available
+        return json
+
+    @classmethod
+    def from_json(cls, json: T_JSON_DICT) -> PressureMetadata:
+        return cls(
+            available=bool(json['available']) if json.get('available', None) is not None else None,
+        )
+
+
+@dataclass
+class WorkAreaInsets:
+    #: Work area top inset in pixels. Default is 0;
+    top: typing.Optional[int] = None
+
+    #: Work area left inset in pixels. Default is 0;
+    left: typing.Optional[int] = None
+
+    #: Work area bottom inset in pixels. Default is 0;
+    bottom: typing.Optional[int] = None
+
+    #: Work area right inset in pixels. Default is 0;
+    right: typing.Optional[int] = None
+
+    def to_json(self) -> T_JSON_DICT:
+        json: T_JSON_DICT = dict()
+        if self.top is not None:
+            json['top'] = self.top
+        if self.left is not None:
+            json['left'] = self.left
+        if self.bottom is not None:
+            json['bottom'] = self.bottom
+        if self.right is not None:
+            json['right'] = self.right
+        return json
+
+    @classmethod
+    def from_json(cls, json: T_JSON_DICT) -> WorkAreaInsets:
+        return cls(
+            top=int(json['top']) if json.get('top', None) is not None else None,
+            left=int(json['left']) if json.get('left', None) is not None else None,
+            bottom=int(json['bottom']) if json.get('bottom', None) is not None else None,
+            right=int(json['right']) if json.get('right', None) is not None else None,
+        )
+
+
+class ScreenId(str):
+    def to_json(self) -> str:
+        return self
+
+    @classmethod
+    def from_json(cls, json: str) -> ScreenId:
+        return cls(json)
+
+    def __repr__(self):
+        return 'ScreenId({})'.format(super().__repr__())
+
+
+@dataclass
+class ScreenInfo:
+    '''
+    Screen information similar to the one returned by window.getScreenDetails() method,
+    see https://w3c.github.io/window-management/#screendetailed.
+    '''
+    #: Offset of the left edge of the screen.
+    left: int
+
+    #: Offset of the top edge of the screen.
+    top: int
+
+    #: Width of the screen.
+    width: int
+
+    #: Height of the screen.
+    height: int
+
+    #: Offset of the left edge of the available screen area.
+    avail_left: int
+
+    #: Offset of the top edge of the available screen area.
+    avail_top: int
+
+    #: Width of the available screen area.
+    avail_width: int
+
+    #: Height of the available screen area.
+    avail_height: int
+
+    #: Specifies the screen's device pixel ratio.
+    device_pixel_ratio: float
+
+    #: Specifies the screen's orientation.
+    orientation: ScreenOrientation
+
+    #: Specifies the screen's color depth in bits.
+    color_depth: int
+
+    #: Indicates whether the device has multiple screens.
+    is_extended: bool
+
+    #: Indicates whether the screen is internal to the device or external, attached to the device.
+    is_internal: bool
+
+    #: Indicates whether the screen is set as the the operating system primary screen.
+    is_primary: bool
+
+    #: Specifies the descriptive label for the screen.
+    label: str
+
+    #: Specifies the unique identifier of the screen.
+    id_: ScreenId
+
+    def to_json(self) -> T_JSON_DICT:
+        json: T_JSON_DICT = dict()
+        json['left'] = self.left
+        json['top'] = self.top
+        json['width'] = self.width
+        json['height'] = self.height
+        json['availLeft'] = self.avail_left
+        json['availTop'] = self.avail_top
+        json['availWidth'] = self.avail_width
+        json['availHeight'] = self.avail_height
+        json['devicePixelRatio'] = self.device_pixel_ratio
+        json['orientation'] = self.orientation.to_json()
+        json['colorDepth'] = self.color_depth
+        json['isExtended'] = self.is_extended
+        json['isInternal'] = self.is_internal
+        json['isPrimary'] = self.is_primary
+        json['label'] = self.label
+        json['id'] = self.id_.to_json()
+        return json
+
+    @classmethod
+    def from_json(cls, json: T_JSON_DICT) -> ScreenInfo:
+        return cls(
+            left=int(json['left']),
+            top=int(json['top']),
+            width=int(json['width']),
+            height=int(json['height']),
+            avail_left=int(json['availLeft']),
+            avail_top=int(json['availTop']),
+            avail_width=int(json['availWidth']),
+            avail_height=int(json['availHeight']),
+            device_pixel_ratio=float(json['devicePixelRatio']),
+            orientation=ScreenOrientation.from_json(json['orientation']),
+            color_depth=int(json['colorDepth']),
+            is_extended=bool(json['isExtended']),
+            is_internal=bool(json['isInternal']),
+            is_primary=bool(json['isPrimary']),
+            label=str(json['label']),
+            id_=ScreenId.from_json(json['id']),
+        )
+
+
+class DisabledImageType(enum.Enum):
+    '''
+    Enum of image types that can be disabled.
+    '''
+    AVIF = "avif"
+    JXL = "jxl"
+    WEBP = "webp"
+
+    def to_json(self) -> str:
+        return self.value
+
+    @classmethod
+    def from_json(cls, json: str) -> DisabledImageType:
+        return cls(json)
+
+
+@deprecated(version="1.3")
+def can_emulate() -> typing.Generator[T_JSON_DICT,T_JSON_DICT,bool]:
+    '''
+    Tells whether emulation is supported.
+
+    .. deprecated:: 1.3
+
+    :returns: True if emulation is supported.
+    '''
+    cmd_dict: T_JSON_DICT = {
+        'method': 'Emulation.canEmulate',
+    }
+    json = yield cmd_dict
+    return bool(json['result'])
+
+
+def clear_device_metrics_override() -> typing.Generator[T_JSON_DICT,T_JSON_DICT,None]:
+    '''
+    Clears the overridden device metrics.
+    '''
+    cmd_dict: T_JSON_DICT = {
+        'method': 'Emulation.clearDeviceMetricsOverride',
+    }
+    json = yield cmd_dict
+
+
+def clear_geolocation_override() -> typing.Generator[T_JSON_DICT,T_JSON_DICT,None]:
+    '''
+    Clears the overridden Geolocation Position and Error.
+    '''
+    cmd_dict: T_JSON_DICT = {
+        'method': 'Emulation.clearGeolocationOverride',
+    }
+    json = yield cmd_dict
+
+
+def reset_page_scale_factor() -> typing.Generator[T_JSON_DICT,T_JSON_DICT,None]:
+    '''
+    Requests that page scale factor is reset to initial values.
+
+    **EXPERIMENTAL**
+    '''
+    cmd_dict: T_JSON_DICT = {
+        'method': 'Emulation.resetPageScaleFactor',
+    }
+    json = yield cmd_dict
+
+
+def set_focus_emulation_enabled(
+        enabled: bool
+    ) -> typing.Generator[T_JSON_DICT,T_JSON_DICT,None]:
+    '''
+    Enables or disables simulating a focused and active page.
+
+    **EXPERIMENTAL**
+
+    :param enabled: Whether to enable to disable focus emulation.
+    '''
+    params: T_JSON_DICT = dict()
+    params['enabled'] = enabled
+    cmd_dict: T_JSON_DICT = {
+        'method': 'Emulation.setFocusEmulationEnabled',
+        'params': params,
+    }
+    json = yield cmd_dict
+
+
+def set_auto_dark_mode_override(
+        enabled: typing.Optional[bool] = None
+    ) -> typing.Generator[T_JSON_DICT,T_JSON_DICT,None]:
+    '''
+    Automatically render all web contents using a dark theme.
+
+    **EXPERIMENTAL**
+
+    :param enabled: *(Optional)* Whether to enable or disable automatic dark mode. If not specified, any existing override will be cleared.
+    '''
+    params: T_JSON_DICT = dict()
+    if enabled is not None:
+        params['enabled'] = enabled
+    cmd_dict: T_JSON_DICT = {
+        'method': 'Emulation.setAutoDarkModeOverride',
+        'params': params,
+    }
+    json = yield cmd_dict
+
+
+def set_cpu_throttling_rate(
+        rate: float
+    ) -> typing.Generator[T_JSON_DICT,T_JSON_DICT,None]:
+    '''
+    Enables CPU throttling to emulate slow CPUs.
+
+    :param rate: Throttling rate as a slowdown factor (1 is no throttle, 2 is 2x slowdown, etc).
+    '''
+    params: T_JSON_DICT = dict()
+    params['rate'] = rate
+    cmd_dict: T_JSON_DICT = {
+        'method': 'Emulation.setCPUThrottlingRate',
+        'params': params,
+    }
+    json = yield cmd_dict
+
+
+def set_default_background_color_override(
+        color: typing.Optional[dom.RGBA] = None
+    ) -> typing.Generator[T_JSON_DICT,T_JSON_DICT,None]:
+    '''
+    Sets or clears an override of the default background color of the frame. This override is used
+    if the content does not specify one.
+
+    :param color: *(Optional)* RGBA of the default background color. If not specified, any existing override will be cleared.
+    '''
+    params: T_JSON_DICT = dict()
+    if color is not None:
+        params['color'] = color.to_json()
+    cmd_dict: T_JSON_DICT = {
+        'method': 'Emulation.setDefaultBackgroundColorOverride',
+        'params': params,
+    }
+    json = yield cmd_dict
+
+
+def set_safe_area_insets_override(
+        insets: SafeAreaInsets
+    ) -> typing.Generator[T_JSON_DICT,T_JSON_DICT,None]:
+    '''
+    Overrides the values for env(safe-area-inset-*) and env(safe-area-max-inset-*). Unset values will cause the
+    respective variables to be undefined, even if previously overridden.
+
+    **EXPERIMENTAL**
+
+    :param insets:
+    '''
+    params: T_JSON_DICT = dict()
+    params['insets'] = insets.to_json()
+    cmd_dict: T_JSON_DICT = {
+        'method': 'Emulation.setSafeAreaInsetsOverride',
+        'params': params,
+    }
+    json = yield cmd_dict
+
+
+def set_device_metrics_override(
+        width: int,
+        height: int,
+        device_scale_factor: float,
+        mobile: bool,
+        scale: typing.Optional[float] = None,
+        screen_width: typing.Optional[int] = None,
+        screen_height: typing.Optional[int] = None,
+        position_x: typing.Optional[int] = None,
+        position_y: typing.Optional[int] = None,
+        dont_set_visible_size: typing.Optional[bool] = None,
+        screen_orientation: typing.Optional[ScreenOrientation] = None,
+        viewport: typing.Optional[page.Viewport] = None,
+        display_feature: typing.Optional[DisplayFeature] = None,
+        device_posture: typing.Optional[DevicePosture] = None,
+        scrollbar_type: typing.Optional[str] = None,
+        screen_orientation_lock_emulation: typing.Optional[bool] = None
+    ) -> typing.Generator[T_JSON_DICT,T_JSON_DICT,None]:
+    '''
+    Overrides the values of device screen dimensions (window.screen.width, window.screen.height,
+    window.innerWidth, window.innerHeight, and "device-width"/"device-height"-related CSS media
+    query results).
+
+    :param width: Overriding width value in pixels (minimum 0, maximum 10000000). 0 disables the override.
+    :param height: Overriding height value in pixels (minimum 0, maximum 10000000). 0 disables the override.
+    :param device_scale_factor: Overriding device scale factor value. 0 disables the override.
+    :param mobile: Whether to emulate mobile device. This includes viewport meta tag, overlay scrollbars, text autosizing and more.
+    :param scale: **(EXPERIMENTAL)** *(Optional)* Scale to apply to resulting view image.
+    :param screen_width: **(EXPERIMENTAL)** *(Optional)* Overriding screen width value in pixels (minimum 0, maximum 10000000).
+    :param screen_height: **(EXPERIMENTAL)** *(Optional)* Overriding screen height value in pixels (minimum 0, maximum 10000000).
+    :param position_x: **(EXPERIMENTAL)** *(Optional)* Overriding view X position on screen in pixels (minimum 0, maximum 10000000).
+    :param position_y: **(EXPERIMENTAL)** *(Optional)* Overriding view Y position on screen in pixels (minimum 0, maximum 10000000).
+    :param dont_set_visible_size: **(EXPERIMENTAL)** *(Optional)* Do not set visible view size, rely upon explicit setVisibleSize call.
+    :param screen_orientation: *(Optional)* Screen orientation override.
+    :param viewport: **(EXPERIMENTAL)** *(Optional)* 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.
+    :param display_feature: **(DEPRECATED)** **(EXPERIMENTAL)** *(Optional)* If set, the display feature of a multi-segment screen. If not set, multi-segment support is turned-off. Deprecated, use Emulation.setDisplayFeaturesOverride.
+    :param device_posture: **(DEPRECATED)** **(EXPERIMENTAL)** *(Optional)* If set, the posture of a foldable device. If not set the posture is set to continuous. Deprecated, use Emulation.setDevicePostureOverride.
+    :param scrollbar_type: **(EXPERIMENTAL)** *(Optional)* Scrollbar type. Default: ```default```.
+    :param screen_orientation_lock_emulation: **(EXPERIMENTAL)** *(Optional)* If set to true, enables screen orientation lock emulation, which intercepts screen.orientation.lock() calls from the page and reports orientation changes via screenOrientationLockChanged events. This is useful for emulating mobile device orientation lock behavior in responsive design mode.
+    '''
+    params: T_JSON_DICT = dict()
+    params['width'] = width
+    params['height'] = height
+    params['deviceScaleFactor'] = device_scale_factor
+    params['mobile'] = mobile
+    if scale is not None:
+        params['scale'] = scale
+    if screen_width is not None:
+        params['screenWidth'] = screen_width
+    if screen_height is not None:
+        params['screenHeight'] = screen_height
+    if position_x is not None:
+        params['positionX'] = position_x
+    if position_y is not None:
+        params['positionY'] = position_y
+    if dont_set_visible_size is not None:
+        params['dontSetVisibleSize'] = dont_set_visible_size
+    if screen_orientation is not None:
+        params['screenOrientation'] = screen_orientation.to_json()
+    if viewport is not None:
+        params['viewport'] = viewport.to_json()
+    if display_feature is not None:
+        params['displayFeature'] = display_feature.to_json()
+    if device_posture is not None:
+        params['devicePosture'] = device_posture.to_json()
+    if scrollbar_type is not None:
+        params['scrollbarType'] = scrollbar_type
+    if screen_orientation_lock_emulation is not None:
+        params['screenOrientationLockEmulation'] = screen_orientation_lock_emulation
+    cmd_dict: T_JSON_DICT = {
+        'method': 'Emulation.setDeviceMetricsOverride',
+        'params': params,
+    }
+    json = yield cmd_dict
+
+
+def set_device_posture_override(
+        posture: DevicePosture
+    ) -> typing.Generator[T_JSON_DICT,T_JSON_DICT,None]:
+    '''
+    Start reporting the given posture value to the Device Posture API.
+    This override can also be set in setDeviceMetricsOverride().
+
+    **EXPERIMENTAL**
+
+    :param posture:
+    '''
+    params: T_JSON_DICT = dict()
+    params['posture'] = posture.to_json()
+    cmd_dict: T_JSON_DICT = {
+        'method': 'Emulation.setDevicePostureOverride',
+        'params': params,
+    }
+    json = yield cmd_dict
+
+
+def clear_device_posture_override() -> typing.Generator[T_JSON_DICT,T_JSON_DICT,None]:
+    '''
+    Clears a device posture override set with either setDeviceMetricsOverride()
+    or setDevicePostureOverride() and starts using posture information from the
+    platform again.
+    Does nothing if no override is set.
+
+    **EXPERIMENTAL**
+    '''
+    cmd_dict: T_JSON_DICT = {
+        'method': 'Emulation.clearDevicePostureOverride',
+    }
+    json = yield cmd_dict
+
+
+def set_display_features_override(
+        features: typing.List[DisplayFeature]
+    ) -> typing.Generator[T_JSON_DICT,T_JSON_DICT,None]:
+    '''
+    Start using the given display features to pupulate the Viewport Segments API.
+    This override can also be set in setDeviceMetricsOverride().
+
+    **EXPERIMENTAL**
+
+    :param features:
+    '''
+    params: T_JSON_DICT = dict()
+    params['features'] = [i.to_json() for i in features]
+    cmd_dict: T_JSON_DICT = {
+        'method': 'Emulation.setDisplayFeaturesOverride',
+        'params': params,
+    }
+    json = yield cmd_dict
+
+
+def clear_display_features_override() -> typing.Generator[T_JSON_DICT,T_JSON_DICT,None]:
+    '''
+    Clears the display features override set with either setDeviceMetricsOverride()
+    or setDisplayFeaturesOverride() and starts using display features from the
+    platform again.
+    Does nothing if no override is set.
+
+    **EXPERIMENTAL**
+    '''
+    cmd_dict: T_JSON_DICT = {
+        'method': 'Emulation.clearDisplayFeaturesOverride',
+    }
+    json = yield cmd_dict
+
+
+def set_scrollbars_hidden(
+        hidden: bool
+    ) -> typing.Generator[T_JSON_DICT,T_JSON_DICT,None]:
+    '''
+
+
+    **EXPERIMENTAL**
+
+    :param hidden: Whether scrollbars should be always hidden.
+    '''
+    params: T_JSON_DICT = dict()
+    params['hidden'] = hidden
+    cmd_dict: T_JSON_DICT = {
+        'method': 'Emulation.setScrollbarsHidden',
+        'params': params,
+    }
+    json = yield cmd_dict
+
+
+def set_document_cookie_disabled(
+        disabled: bool
+    ) -> typing.Generator[T_JSON_DICT,T_JSON_DICT,None]:
+    '''
+
+
+    **EXPERIMENTAL**
+
+    :param disabled: Whether document.coookie API should be disabled.
+    '''
+    params: T_JSON_DICT = dict()
+    params['disabled'] = disabled
+    cmd_dict: T_JSON_DICT = {
+        'method': 'Emulation.setDocumentCookieDisabled',
+        'params': params,
+    }
+    json = yield cmd_dict
+
+
+def set_emit_touch_events_for_mouse(
+        enabled: bool,
+        configuration: typing.Optional[str] = None
+    ) -> typing.Generator[T_JSON_DICT,T_JSON_DICT,None]:
+    '''
+
+
+    **EXPERIMENTAL**
+
+    :param enabled: Whether touch emulation based on mouse input should be enabled.
+    :param configuration: *(Optional)* Touch/gesture events configuration. Default: current platform.
+    '''
+    params: T_JSON_DICT = dict()
+    params['enabled'] = enabled
+    if configuration is not None:
+        params['configuration'] = configuration
+    cmd_dict: T_JSON_DICT = {
+        'method': 'Emulation.setEmitTouchEventsForMouse',
+        'params': params,
+    }
+    json = yield cmd_dict
+
+
+def set_emulated_media(
+        media: typing.Optional[str] = None,
+        features: typing.Optional[typing.List[MediaFeature]] = None
+    ) -> typing.Generator[T_JSON_DICT,T_JSON_DICT,None]:
+    '''
+    Emulates the given media type or media feature for CSS media queries.
+
+    :param media: *(Optional)* Media type to emulate. Empty string disables the override.
+    :param features: *(Optional)* Media features to emulate.
+    '''
+    params: T_JSON_DICT = dict()
+    if media is not None:
+        params['media'] = media
+    if features is not None:
+        params['features'] = [i.to_json() for i in features]
+    cmd_dict: T_JSON_DICT = {
+        'method': 'Emulation.setEmulatedMedia',
+        'params': params,
+    }
+    json = yield cmd_dict
+
+
+def set_emulated_vision_deficiency(
+        type_: str
+    ) -> typing.Generator[T_JSON_DICT,T_JSON_DICT,None]:
+    '''
+    Emulates the given vision deficiency.
+
+    :param type_: Vision deficiency to emulate. Order: best-effort emulations come first, followed by any physiologically accurate emulations for medically recognized color vision deficiencies.
+    '''
+    params: T_JSON_DICT = dict()
+    params['type'] = type_
+    cmd_dict: T_JSON_DICT = {
+        'method': 'Emulation.setEmulatedVisionDeficiency',
+        'params': params,
+    }
+    json = yield cmd_dict
+
+
+def set_emulated_os_text_scale(
+        scale: typing.Optional[float] = None
+    ) -> typing.Generator[T_JSON_DICT,T_JSON_DICT,None]:
+    '''
+    Emulates the given OS text scale.
+
+    :param scale: *(Optional)*
+    '''
+    params: T_JSON_DICT = dict()
+    if scale is not None:
+        params['scale'] = scale
+    cmd_dict: T_JSON_DICT = {
+        'method': 'Emulation.setEmulatedOSTextScale',
+        'params': params,
+    }
+    json = yield cmd_dict
+
+
+def set_geolocation_override(
+        latitude: typing.Optional[float] = None,
+        longitude: typing.Optional[float] = None,
+        accuracy: typing.Optional[float] = None,
+        altitude: typing.Optional[float] = None,
+        altitude_accuracy: typing.Optional[float] = None,
+        heading: typing.Optional[float] = None,
+        speed: typing.Optional[float] = None
+    ) -> typing.Generator[T_JSON_DICT,T_JSON_DICT,None]:
+    '''
+    Overrides the Geolocation Position or Error. Omitting latitude, longitude or
+    accuracy emulates position unavailable.
+
+    :param latitude: *(Optional)* Mock latitude
+    :param longitude: *(Optional)* Mock longitude
+    :param accuracy: *(Optional)* Mock accuracy
+    :param altitude: *(Optional)* Mock altitude
+    :param altitude_accuracy: *(Optional)* Mock altitudeAccuracy
+    :param heading: *(Optional)* Mock heading
+    :param speed: *(Optional)* Mock speed
+    '''
+    params: T_JSON_DICT = dict()
+    if latitude is not None:
+        params['latitude'] = latitude
+    if longitude is not None:
+        params['longitude'] = longitude
+    if accuracy is not None:
+        params['accuracy'] = accuracy
+    if altitude is not None:
+        params['altitude'] = altitude
+    if altitude_accuracy is not None:
+        params['altitudeAccuracy'] = altitude_accuracy
+    if heading is not None:
+        params['heading'] = heading
+    if speed is not None:
+        params['speed'] = speed
+    cmd_dict: T_JSON_DICT = {
+        'method': 'Emulation.setGeolocationOverride',
+        'params': params,
+    }
+    json = yield cmd_dict
+
+
+def get_overridden_sensor_information(
+        type_: SensorType
+    ) -> typing.Generator[T_JSON_DICT,T_JSON_DICT,float]:
+    '''
+
+
+    **EXPERIMENTAL**
+
+    :param type_:
+    :returns: 
+    '''
+    params: T_JSON_DICT = dict()
+    params['type'] = type_.to_json()
+    cmd_dict: T_JSON_DICT = {
+        'method': 'Emulation.getOverriddenSensorInformation',
+        'params': params,
+    }
+    json = yield cmd_dict
+    return float(json['requestedSamplingFrequency'])
+
+
+def set_sensor_override_enabled(
+        enabled: bool,
+        type_: SensorType,
+        metadata: typing.Optional[SensorMetadata] = None
+    ) -> typing.Generator[T_JSON_DICT,T_JSON_DICT,None]:
+    '''
+    Overrides a platform sensor of a given type. If ``enabled`` is true, calls to
+    Sensor.start() will use a virtual sensor as backend rather than fetching
+    data from a real hardware sensor. Otherwise, existing virtual
+    sensor-backend Sensor objects will fire an error event and new calls to
+    Sensor.start() will attempt to use a real sensor instead.
+
+    **EXPERIMENTAL**
+
+    :param enabled:
+    :param type_:
+    :param metadata: *(Optional)*
+    '''
+    params: T_JSON_DICT = dict()
+    params['enabled'] = enabled
+    params['type'] = type_.to_json()
+    if metadata is not None:
+        params['metadata'] = metadata.to_json()
+    cmd_dict: T_JSON_DICT = {
+        'method': 'Emulation.setSensorOverrideEnabled',
+        'params': params,
+    }
+    json = yield cmd_dict
+
+
+def set_sensor_override_readings(
+        type_: SensorType,
+        reading: SensorReading
+    ) -> typing.Generator[T_JSON_DICT,T_JSON_DICT,None]:
+    '''
+    Updates the sensor readings reported by a sensor type previously overridden
+    by setSensorOverrideEnabled.
+
+    **EXPERIMENTAL**
+
+    :param type_:
+    :param reading:
+    '''
+    params: T_JSON_DICT = dict()
+    params['type'] = type_.to_json()
+    params['reading'] = reading.to_json()
+    cmd_dict: T_JSON_DICT = {
+        'method': 'Emulation.setSensorOverrideReadings',
+        'params': params,
+    }
+    json = yield cmd_dict
+
+
+def set_pressure_source_override_enabled(
+        enabled: bool,
+        source: PressureSource,
+        metadata: typing.Optional[PressureMetadata] = None
+    ) -> typing.Generator[T_JSON_DICT,T_JSON_DICT,None]:
+    '''
+    Overrides a pressure source of a given type, as used by the Compute
+    Pressure API, so that updates to PressureObserver.observe() are provided
+    via setPressureStateOverride instead of being retrieved from
+    platform-provided telemetry data.
+
+    **EXPERIMENTAL**
+
+    :param enabled:
+    :param source:
+    :param metadata: *(Optional)*
+    '''
+    params: T_JSON_DICT = dict()
+    params['enabled'] = enabled
+    params['source'] = source.to_json()
+    if metadata is not None:
+        params['metadata'] = metadata.to_json()
+    cmd_dict: T_JSON_DICT = {
+        'method': 'Emulation.setPressureSourceOverrideEnabled',
+        'params': params,
+    }
+    json = yield cmd_dict
+
+
+def set_pressure_state_override(
+        source: PressureSource,
+        state: PressureState
+    ) -> typing.Generator[T_JSON_DICT,T_JSON_DICT,None]:
+    '''
+    TODO: OBSOLETE: To remove when setPressureDataOverride is merged.
+    Provides a given pressure state that will be processed and eventually be
+    delivered to PressureObserver users. ``source`` must have been previously
+    overridden by setPressureSourceOverrideEnabled.
+
+    **EXPERIMENTAL**
+
+    :param source:
+    :param state:
+    '''
+    params: T_JSON_DICT = dict()
+    params['source'] = source.to_json()
+    params['state'] = state.to_json()
+    cmd_dict: T_JSON_DICT = {
+        'method': 'Emulation.setPressureStateOverride',
+        'params': params,
+    }
+    json = yield cmd_dict
+
+
+def set_pressure_data_override(
+        source: PressureSource,
+        state: PressureState,
+        own_contribution_estimate: typing.Optional[float] = None
+    ) -> typing.Generator[T_JSON_DICT,T_JSON_DICT,None]:
+    '''
+    Provides a given pressure data set that will be processed and eventually be
+    delivered to PressureObserver users. ``source`` must have been previously
+    overridden by setPressureSourceOverrideEnabled.
+
+    **EXPERIMENTAL**
+
+    :param source:
+    :param state:
+    :param own_contribution_estimate: *(Optional)*
+    '''
+    params: T_JSON_DICT = dict()
+    params['source'] = source.to_json()
+    params['state'] = state.to_json()
+    if own_contribution_estimate is not None:
+        params['ownContributionEstimate'] = own_contribution_estimate
+    cmd_dict: T_JSON_DICT = {
+        'method': 'Emulation.setPressureDataOverride',
+        'params': params,
+    }
+    json = yield cmd_dict
+
+
+def set_idle_override(
+        is_user_active: bool,
+        is_screen_unlocked: bool
+    ) -> typing.Generator[T_JSON_DICT,T_JSON_DICT,None]:
+    '''
+    Overrides the Idle state.
+
+    :param is_user_active: Mock isUserActive
+    :param is_screen_unlocked: Mock isScreenUnlocked
+    '''
+    params: T_JSON_DICT = dict()
+    params['isUserActive'] = is_user_active
+    params['isScreenUnlocked'] = is_screen_unlocked
+    cmd_dict: T_JSON_DICT = {
+        'method': 'Emulation.setIdleOverride',
+        'params': params,
+    }
+    json = yield cmd_dict
+
+
+def clear_idle_override() -> typing.Generator[T_JSON_DICT,T_JSON_DICT,None]:
+    '''
+    Clears Idle state overrides.
+    '''
+    cmd_dict: T_JSON_DICT = {
+        'method': 'Emulation.clearIdleOverride',
+    }
+    json = yield cmd_dict
+
+
+@deprecated(version="1.3")
+def set_navigator_overrides(
+        platform: str
+    ) -> typing.Generator[T_JSON_DICT,T_JSON_DICT,None]:
+    '''
+    Overrides value returned by the javascript navigator object.
+
+    .. deprecated:: 1.3
+
+    **EXPERIMENTAL**
+
+    :param platform: The platform navigator.platform should return.
+    '''
+    params: T_JSON_DICT = dict()
+    params['platform'] = platform
+    cmd_dict: T_JSON_DICT = {
+        'method': 'Emulation.setNavigatorOverrides',
+        'params': params,
+    }
+    json = yield cmd_dict
+
+
+def set_page_scale_factor(
+        page_scale_factor: float
+    ) -> typing.Generator[T_JSON_DICT,T_JSON_DICT,None]:
+    '''
+    Sets a specified page scale factor.
+
+    **EXPERIMENTAL**
+
+    :param page_scale_factor: Page scale factor.
+    '''
+    params: T_JSON_DICT = dict()
+    params['pageScaleFactor'] = page_scale_factor
+    cmd_dict: T_JSON_DICT = {
+        'method': 'Emulation.setPageScaleFactor',
+        'params': params,
+    }
+    json = yield cmd_dict
+
+
+def set_script_execution_disabled(
+        value: bool
+    ) -> typing.Generator[T_JSON_DICT,T_JSON_DICT,None]:
+    '''
+    Switches script execution in the page.
+
+    :param value: Whether script execution should be disabled in the page.
+    '''
+    params: T_JSON_DICT = dict()
+    params['value'] = value
+    cmd_dict: T_JSON_DICT = {
+        'method': 'Emulation.setScriptExecutionDisabled',
+        'params': params,
+    }
+    json = yield cmd_dict
+
+
+def set_touch_emulation_enabled(
+        enabled: bool,
+        max_touch_points: typing.Optional[int] = None
+    ) -> typing.Generator[T_JSON_DICT,T_JSON_DICT,None]:
+    '''
+    Enables touch on platforms which do not support them.
+
+    :param enabled: Whether the touch event emulation should be enabled.
+    :param max_touch_points: *(Optional)* Maximum touch points supported. Defaults to one.
+    '''
+    params: T_JSON_DICT = dict()
+    params['enabled'] = enabled
+    if max_touch_points is not None:
+        params['maxTouchPoints'] = max_touch_points
+    cmd_dict: T_JSON_DICT = {
+        'method': 'Emulation.setTouchEmulationEnabled',
+        'params': params,
+    }
+    json = yield cmd_dict
+
+
+def set_virtual_time_policy(
+        policy: VirtualTimePolicy,
+        budget: typing.Optional[float] = None,
+        max_virtual_time_task_starvation_count: typing.Optional[int] = None,
+        initial_virtual_time: typing.Optional[network.TimeSinceEpoch] = None
+    ) -> typing.Generator[T_JSON_DICT,T_JSON_DICT,float]:
+    '''
+    Turns on virtual time for all frames (replacing real-time with a synthetic time source) and sets
+    the current virtual time policy.  Note this supersedes any previous time budget.
+
+    **EXPERIMENTAL**
+
+    :param policy:
+    :param budget: *(Optional)* If set, after this many virtual milliseconds have elapsed virtual time will be paused and a virtualTimeBudgetExpired event is sent.
+    :param max_virtual_time_task_starvation_count: *(Optional)* If set this specifies the maximum number of tasks that can be run before virtual is forced forwards to prevent deadlock.
+    :param initial_virtual_time: *(Optional)* If set, base::Time::Now will be overridden to initially return this value.
+    :returns: Absolute timestamp at which virtual time was first enabled (up time in milliseconds).
+    '''
+    params: T_JSON_DICT = dict()
+    params['policy'] = policy.to_json()
+    if budget is not None:
+        params['budget'] = budget
+    if max_virtual_time_task_starvation_count is not None:
+        params['maxVirtualTimeTaskStarvationCount'] = max_virtual_time_task_starvation_count
+    if initial_virtual_time is not None:
+        params['initialVirtualTime'] = initial_virtual_time.to_json()
+    cmd_dict: T_JSON_DICT = {
+        'method': 'Emulation.setVirtualTimePolicy',
+        'params': params,
+    }
+    json = yield cmd_dict
+    return float(json['virtualTimeTicksBase'])
+
+
+def set_locale_override(
+        locale: typing.Optional[str] = None
+    ) -> typing.Generator[T_JSON_DICT,T_JSON_DICT,None]:
+    '''
+    Overrides default host system locale with the specified one.
+
+    **EXPERIMENTAL**
+
+    :param locale: *(Optional)* ICU style C locale (e.g. "en_US"). If not specified or empty, disables the override and restores default host system locale.
+    '''
+    params: T_JSON_DICT = dict()
+    if locale is not None:
+        params['locale'] = locale
+    cmd_dict: T_JSON_DICT = {
+        'method': 'Emulation.setLocaleOverride',
+        'params': params,
+    }
+    json = yield cmd_dict
+
+
+def set_timezone_override(
+        timezone_id: str
+    ) -> typing.Generator[T_JSON_DICT,T_JSON_DICT,None]:
+    '''
+    Overrides default host system timezone with the specified one.
+
+    :param timezone_id: 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.
+    '''
+    params: T_JSON_DICT = dict()
+    params['timezoneId'] = timezone_id
+    cmd_dict: T_JSON_DICT = {
+        'method': 'Emulation.setTimezoneOverride',
+        'params': params,
+    }
+    json = yield cmd_dict
+
+
+@deprecated(version="1.3")
+def set_visible_size(
+        width: int,
+        height: int
+    ) -> typing.Generator[T_JSON_DICT,T_JSON_DICT,None]:
+    '''
+    Resizes the frame/viewport of the page. Note that this does not affect the frame's container
+    (e.g. browser window). Can be used to produce screenshots of the specified size. Not supported
+    on Android.
+
+    .. deprecated:: 1.3
+
+    **EXPERIMENTAL**
+
+    :param width: Frame width (DIP).
+    :param height: Frame height (DIP).
+    '''
+    params: T_JSON_DICT = dict()
+    params['width'] = width
+    params['height'] = height
+    cmd_dict: T_JSON_DICT = {
+        'method': 'Emulation.setVisibleSize',
+        'params': params,
+    }
+    json = yield cmd_dict
+
+
+def set_disabled_image_types(
+        image_types: typing.List[DisabledImageType]
+    ) -> typing.Generator[T_JSON_DICT,T_JSON_DICT,None]:
+    '''
+
+
+    **EXPERIMENTAL**
+
+    :param image_types: Image types to disable.
+    '''
+    params: T_JSON_DICT = dict()
+    params['imageTypes'] = [i.to_json() for i in image_types]
+    cmd_dict: T_JSON_DICT = {
+        'method': 'Emulation.setDisabledImageTypes',
+        'params': params,
+    }
+    json = yield cmd_dict
+
+
+def set_data_saver_override(
+        data_saver_enabled: typing.Optional[bool] = None
+    ) -> typing.Generator[T_JSON_DICT,T_JSON_DICT,None]:
+    '''
+    Override the value of navigator.connection.saveData
+
+    **EXPERIMENTAL**
+
+    :param data_saver_enabled: *(Optional)* Override value. Omitting the parameter disables the override.
+    '''
+    params: T_JSON_DICT = dict()
+    if data_saver_enabled is not None:
+        params['dataSaverEnabled'] = data_saver_enabled
+    cmd_dict: T_JSON_DICT = {
+        'method': 'Emulation.setDataSaverOverride',
+        'params': params,
+    }
+    json = yield cmd_dict
+
+
+def set_hardware_concurrency_override(
+        hardware_concurrency: int
+    ) -> typing.Generator[T_JSON_DICT,T_JSON_DICT,None]:
+    '''
+
+
+    **EXPERIMENTAL**
+
+    :param hardware_concurrency: Hardware concurrency to report
+    '''
+    params: T_JSON_DICT = dict()
+    params['hardwareConcurrency'] = hardware_concurrency
+    cmd_dict: T_JSON_DICT = {
+        'method': 'Emulation.setHardwareConcurrencyOverride',
+        'params': params,
+    }
+    json = yield cmd_dict
+
+
+def set_user_agent_override(
+        user_agent: str,
+        accept_language: typing.Optional[str] = None,
+        platform: typing.Optional[str] = None,
+        user_agent_metadata: typing.Optional[UserAgentMetadata] = None
+    ) -> typing.Generator[T_JSON_DICT,T_JSON_DICT,None]:
+    '''
+    Allows overriding user agent with the given string.
+    ``userAgentMetadata`` must be set for Client Hint headers to be sent.
+
+    :param user_agent: User agent to use.
+    :param accept_language: *(Optional)* Browser language to emulate.
+    :param platform: *(Optional)* The platform navigator.platform should return.
+    :param user_agent_metadata: **(EXPERIMENTAL)** *(Optional)* To be sent in Sec-CH-UA-* headers and returned in navigator.userAgentData
+    '''
+    params: T_JSON_DICT = dict()
+    params['userAgent'] = user_agent
+    if accept_language is not None:
+        params['acceptLanguage'] = accept_language
+    if platform is not None:
+        params['platform'] = platform
+    if user_agent_metadata is not None:
+        params['userAgentMetadata'] = user_agent_metadata.to_json()
+    cmd_dict: T_JSON_DICT = {
+        'method': 'Emulation.setUserAgentOverride',
+        'params': params,
+    }
+    json = yield cmd_dict
+
+
+def set_automation_override(
+        enabled: bool
+    ) -> typing.Generator[T_JSON_DICT,T_JSON_DICT,None]:
+    '''
+    Allows overriding the automation flag.
+
+    **EXPERIMENTAL**
+
+    :param enabled: Whether the override should be enabled.
+    '''
+    params: T_JSON_DICT = dict()
+    params['enabled'] = enabled
+    cmd_dict: T_JSON_DICT = {
+        'method': 'Emulation.setAutomationOverride',
+        'params': params,
+    }
+    json = yield cmd_dict
+
+
+def set_small_viewport_height_difference_override(
+        difference: int
+    ) -> typing.Generator[T_JSON_DICT,T_JSON_DICT,None]:
+    '''
+    Allows overriding the difference between the small and large viewport sizes, which determine the
+    value of the ``svh`` and ``lvh`` unit, respectively. Only supported for top-level frames.
+
+    **EXPERIMENTAL**
+
+    :param difference: This will cause an element of size 100svh to be ```difference``` pixels smaller than an element of size 100lvh.
+    '''
+    params: T_JSON_DICT = dict()
+    params['difference'] = difference
+    cmd_dict: T_JSON_DICT = {
+        'method': 'Emulation.setSmallViewportHeightDifferenceOverride',
+        'params': params,
+    }
+    json = yield cmd_dict
+
+
+def get_screen_infos() -> typing.Generator[T_JSON_DICT,T_JSON_DICT,typing.List[ScreenInfo]]:
+    '''
+    Returns device's screen configuration. In headful mode, the physical screens configuration is returned,
+    whereas in headless mode, a virtual headless screen configuration is provided instead.
+
+    **EXPERIMENTAL**
+
+    :returns: 
+    '''
+    cmd_dict: T_JSON_DICT = {
+        'method': 'Emulation.getScreenInfos',
+    }
+    json = yield cmd_dict
+    return [ScreenInfo.from_json(i) for i in json['screenInfos']]
+
+
+def add_screen(
+        left: int,
+        top: int,
+        width: int,
+        height: int,
+        work_area_insets: typing.Optional[WorkAreaInsets] = None,
+        device_pixel_ratio: typing.Optional[float] = None,
+        rotation: typing.Optional[int] = None,
+        color_depth: typing.Optional[int] = None,
+        label: typing.Optional[str] = None,
+        is_internal: typing.Optional[bool] = None
+    ) -> typing.Generator[T_JSON_DICT,T_JSON_DICT,ScreenInfo]:
+    '''
+    Add a new screen to the device. Only supported in headless mode.
+
+    **EXPERIMENTAL**
+
+    :param left: Offset of the left edge of the screen in pixels.
+    :param top: Offset of the top edge of the screen in pixels.
+    :param width: The width of the screen in pixels.
+    :param height: The height of the screen in pixels.
+    :param work_area_insets: *(Optional)* Specifies the screen's work area. Default is entire screen.
+    :param device_pixel_ratio: *(Optional)* Specifies the screen's device pixel ratio. Default is 1.
+    :param rotation: *(Optional)* Specifies the screen's rotation angle. Available values are 0, 90, 180 and 270. Default is 0.
+    :param color_depth: *(Optional)* Specifies the screen's color depth in bits. Default is 24.
+    :param label: *(Optional)* Specifies the descriptive label for the screen. Default is none.
+    :param is_internal: *(Optional)* Indicates whether the screen is internal to the device or external, attached to the device. Default is false.
+    :returns: 
+    '''
+    params: T_JSON_DICT = dict()
+    params['left'] = left
+    params['top'] = top
+    params['width'] = width
+    params['height'] = height
+    if work_area_insets is not None:
+        params['workAreaInsets'] = work_area_insets.to_json()
+    if device_pixel_ratio is not None:
+        params['devicePixelRatio'] = device_pixel_ratio
+    if rotation is not None:
+        params['rotation'] = rotation
+    if color_depth is not None:
+        params['colorDepth'] = color_depth
+    if label is not None:
+        params['label'] = label
+    if is_internal is not None:
+        params['isInternal'] = is_internal
+    cmd_dict: T_JSON_DICT = {
+        'method': 'Emulation.addScreen',
+        'params': params,
+    }
+    json = yield cmd_dict
+    return ScreenInfo.from_json(json['screenInfo'])
+
+
+def update_screen(
+        screen_id: ScreenId,
+        left: typing.Optional[int] = None,
+        top: typing.Optional[int] = None,
+        width: typing.Optional[int] = None,
+        height: typing.Optional[int] = None,
+        work_area_insets: typing.Optional[WorkAreaInsets] = None,
+        device_pixel_ratio: typing.Optional[float] = None,
+        rotation: typing.Optional[int] = None,
+        color_depth: typing.Optional[int] = None,
+        label: typing.Optional[str] = None,
+        is_internal: typing.Optional[bool] = None
+    ) -> typing.Generator[T_JSON_DICT,T_JSON_DICT,ScreenInfo]:
+    '''
+    Updates specified screen parameters. Only supported in headless mode.
+
+    **EXPERIMENTAL**
+
+    :param screen_id: Target screen identifier.
+    :param left: *(Optional)* Offset of the left edge of the screen in pixels.
+    :param top: *(Optional)* Offset of the top edge of the screen in pixels.
+    :param width: *(Optional)* The width of the screen in pixels.
+    :param height: *(Optional)* The height of the screen in pixels.
+    :param work_area_insets: *(Optional)* Specifies the screen's work area.
+    :param device_pixel_ratio: *(Optional)* Specifies the screen's device pixel ratio.
+    :param rotation: *(Optional)* Specifies the screen's rotation angle. Available values are 0, 90, 180 and 270.
+    :param color_depth: *(Optional)* Specifies the screen's color depth in bits.
+    :param label: *(Optional)* Specifies the descriptive label for the screen.
+    :param is_internal: *(Optional)* Indicates whether the screen is internal to the device or external, attached to the device. Default is false.
+    :returns: 
+    '''
+    params: T_JSON_DICT = dict()
+    params['screenId'] = screen_id.to_json()
+    if left is not None:
+        params['left'] = left
+    if top is not None:
+        params['top'] = top
+    if width is not None:
+        params['width'] = width
+    if height is not None:
+        params['height'] = height
+    if work_area_insets is not None:
+        params['workAreaInsets'] = work_area_insets.to_json()
+    if device_pixel_ratio is not None:
+        params['devicePixelRatio'] = device_pixel_ratio
+    if rotation is not None:
+        params['rotation'] = rotation
+    if color_depth is not None:
+        params['colorDepth'] = color_depth
+    if label is not None:
+        params['label'] = label
+    if is_internal is not None:
+        params['isInternal'] = is_internal
+    cmd_dict: T_JSON_DICT = {
+        'method': 'Emulation.updateScreen',
+        'params': params,
+    }
+    json = yield cmd_dict
+    return ScreenInfo.from_json(json['screenInfo'])
+
+
+def remove_screen(
+        screen_id: ScreenId
+    ) -> typing.Generator[T_JSON_DICT,T_JSON_DICT,None]:
+    '''
+    Remove screen from the device. Only supported in headless mode.
+
+    **EXPERIMENTAL**
+
+    :param screen_id:
+    '''
+    params: T_JSON_DICT = dict()
+    params['screenId'] = screen_id.to_json()
+    cmd_dict: T_JSON_DICT = {
+        'method': 'Emulation.removeScreen',
+        'params': params,
+    }
+    json = yield cmd_dict
+
+
+def set_primary_screen(
+        screen_id: ScreenId
+    ) -> typing.Generator[T_JSON_DICT,T_JSON_DICT,None]:
+    '''
+    Set primary screen. Only supported in headless mode.
+    Note that this changes the coordinate system origin to the top-left
+    of the new primary screen, updating the bounds and work areas
+    of all existing screens accordingly.
+
+    **EXPERIMENTAL**
+
+    :param screen_id:
+    '''
+    params: T_JSON_DICT = dict()
+    params['screenId'] = screen_id.to_json()
+    cmd_dict: T_JSON_DICT = {
+        'method': 'Emulation.setPrimaryScreen',
+        'params': params,
+    }
+    json = yield cmd_dict
+
+
+@event_class('Emulation.virtualTimeBudgetExpired')
+@dataclass
+class VirtualTimeBudgetExpired:
+    '''
+    **EXPERIMENTAL**
+
+    Notification sent after the virtual time budget for the current VirtualTimePolicy has run out.
+    '''
+
+
+    @classmethod
+    def from_json(cls, json: T_JSON_DICT) -> VirtualTimeBudgetExpired:
+        return cls(
+
+        )
+
+
+@event_class('Emulation.screenOrientationLockChanged')
+@dataclass
+class ScreenOrientationLockChanged:
+    '''
+    **EXPERIMENTAL**
+
+    Fired when a page calls screen.orientation.lock() or screen.orientation.unlock()
+    while device emulation is enabled. This allows the DevTools frontend to update the
+    emulated device orientation accordingly.
+    '''
+    #: Whether the screen orientation is currently locked.
+    locked: bool
+    #: The orientation lock type requested by the page. Only set when locked is true.
+    orientation: typing.Optional[ScreenOrientation]
+
+    @classmethod
+    def from_json(cls, json: T_JSON_DICT) -> ScreenOrientationLockChanged:
+        return cls(
+            locked=bool(json['locked']),
+            orientation=ScreenOrientation.from_json(json['orientation']) if json.get('orientation', None) is not None else None
+        )