chromedeveloperprotocol-client 0.1.0__py3-none-any.whl

cdp/protocol/bluetooth_emulation/methods/types.py

@@ -0,0 +1,81 @@
+"""CDP BluetoothEmulation 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.bluetooth_emulation.types import CentralState
+    from cdp.protocol.bluetooth_emulation.types import CharacteristicOperationType
+    from cdp.protocol.bluetooth_emulation.types import CharacteristicProperties
+    from cdp.protocol.bluetooth_emulation.types import DescriptorOperationType
+    from cdp.protocol.bluetooth_emulation.types import GATTOperationType
+    from cdp.protocol.bluetooth_emulation.types import ManufacturerData
+    from cdp.protocol.bluetooth_emulation.types import ScanEntry
+
+class enableParameters(TypedDict, total=True):
+    state: 'CentralState'
+    """State of the simulated central."""
+    leSupported: 'bool'
+    """If the simulated central supports low-energy."""
+class setSimulatedCentralStateParameters(TypedDict, total=True):
+    state: 'CentralState'
+    """State of the simulated central."""
+
+class simulatePreconnectedPeripheralParameters(TypedDict, total=True):
+    address: 'str'
+    name: 'str'
+    manufacturerData: 'List[ManufacturerData]'
+    knownServiceUuids: 'List[str]'
+class simulateAdvertisementParameters(TypedDict, total=True):
+    entry: 'ScanEntry'
+class simulateGATTOperationResponseParameters(TypedDict, total=True):
+    address: 'str'
+    type: 'GATTOperationType'
+    code: 'int'
+class simulateCharacteristicOperationResponseParameters(TypedDict, total=True):
+    characteristicId: 'str'
+    type: 'CharacteristicOperationType'
+    code: 'int'
+    data: NotRequired['str']
+class simulateDescriptorOperationResponseParameters(TypedDict, total=True):
+    descriptorId: 'str'
+    type: 'DescriptorOperationType'
+    code: 'int'
+    data: NotRequired['str']
+class addServiceParameters(TypedDict, total=True):
+    address: 'str'
+    serviceUuid: 'str'
+class removeServiceParameters(TypedDict, total=True):
+    serviceId: 'str'
+class addCharacteristicParameters(TypedDict, total=True):
+    serviceId: 'str'
+    characteristicUuid: 'str'
+    properties: 'CharacteristicProperties'
+class removeCharacteristicParameters(TypedDict, total=True):
+    characteristicId: 'str'
+class addDescriptorParameters(TypedDict, total=True):
+    characteristicId: 'str'
+    descriptorUuid: 'str'
+class removeDescriptorParameters(TypedDict, total=True):
+    descriptorId: 'str'
+class simulateGATTDisconnectionParameters(TypedDict, total=True):
+    address: 'str'
+
+
+
+
+
+
+
+
+class addServiceReturns(TypedDict):
+    serviceId: 'str'
+    """An identifier that uniquely represents this service."""
+
+class addCharacteristicReturns(TypedDict):
+    characteristicId: 'str'
+    """An identifier that uniquely represents this characteristic."""
+
+class addDescriptorReturns(TypedDict):
+    descriptorId: 'str'
+    """An identifier that uniquely represents this descriptor."""

cdp/protocol/bluetooth_emulation/service.py

@@ -0,0 +1,21 @@
+"""CDP BluetoothEmulation Domain"""
+from typing import TYPE_CHECKING
+from .methods.service import BluetoothEmulationMethods
+from .events.service import BluetoothEmulationEvents
+
+if TYPE_CHECKING:
+    from ...service import Client
+
+class BluetoothEmulation(BluetoothEmulationMethods, BluetoothEmulationEvents):
+    """
+    This domain allows configuring virtual Bluetooth devices to test the web-bluetooth API.
+    """
+    def __init__(self, client: "Client"):
+        """
+        Initialize the BluetoothEmulation domain.
+        
+        Args:
+            client ("Client"): The parent CDP client instance.
+        """
+        BluetoothEmulationMethods.__init__(self, client)
+        BluetoothEmulationEvents.__init__(self, client)

cdp/protocol/bluetooth_emulation/types.py

@@ -0,0 +1,45 @@
+"""CDP BluetoothEmulation Types"""
+
+from typing import TypedDict, NotRequired, Required, Literal, Any, Dict, Union, Optional, List, Set, Tuple
+
+CentralState = Literal['absent','powered-off','powered-on']
+"""Indicates the various states of Central."""
+GATTOperationType = Literal['connection','discovery']
+"""Indicates the various types of GATT event."""
+CharacteristicWriteType = Literal['write-default-deprecated','write-with-response','write-without-response']
+"""Indicates the various types of characteristic write."""
+CharacteristicOperationType = Literal['read','write','subscribe-to-notifications','unsubscribe-from-notifications']
+"""Indicates the various types of characteristic operation."""
+DescriptorOperationType = Literal['read','write']
+"""Indicates the various types of descriptor operation."""
+class ManufacturerData(TypedDict, total=True):
+    """Stores the manufacturer data"""
+    key: 'int'
+    """Company identifier https://bitbucket.org/bluetooth-SIG/public/src/main/assigned_numbers/company_identifiers/company_identifiers.yaml https://usb.org/developers"""
+    data: 'str'
+    """Manufacturer-specific data (Encoded as a base64 string when passed over JSON)"""
+class ScanRecord(TypedDict, total=False):
+    """Stores the byte data of the advertisement packet sent by a Bluetooth device."""
+    name: NotRequired['str']
+    uuids: NotRequired['List[str]']
+    appearance: NotRequired['int']
+    """Stores the external appearance description of the device."""
+    txPower: NotRequired['int']
+    """Stores the transmission power of a broadcasting device."""
+    manufacturerData: NotRequired['List[ManufacturerData]']
+    """Key is the company identifier and the value is an array of bytes of manufacturer specific data."""
+class ScanEntry(TypedDict, total=True):
+    """Stores the advertisement packet information that is sent by a Bluetooth device."""
+    deviceAddress: 'str'
+    rssi: 'int'
+    scanRecord: 'ScanRecord'
+class CharacteristicProperties(TypedDict, total=False):
+    """Describes the properties of a characteristic. This follows Bluetooth Core Specification BT 4.2 Vol 3 Part G 3.3.1. Characteristic Properties."""
+    broadcast: NotRequired['bool']
+    read: NotRequired['bool']
+    writeWithoutResponse: NotRequired['bool']
+    write: NotRequired['bool']
+    notify: NotRequired['bool']
+    indicate: NotRequired['bool']
+    authenticatedSignedWrites: NotRequired['bool']
+    extendedProperties: NotRequired['bool']

cdp/protocol/browser/events/service.py

@@ -0,0 +1,37 @@
+"""CDP Browser 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 BrowserEvents:
+    """
+    Events for the Browser domain.
+    """
+    def __init__(self, client: "Client"):
+        """
+        Initialize the Browser events.
+        
+        Args:
+            client ("Client"): The parent CDP client instance.
+        """
+        self.client = client
+
+    def on_download_will_begin(self, callback: Callable[[downloadWillBeginEvent,Optional[str]], None]=None) -> None:
+        """
+    Fired when page is about to start a download.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: downloadWillBeginEvent, session_id: Optional[str]).
+        """
+        self.client.on('Browser.downloadWillBegin', callback)
+    def on_download_progress(self, callback: Callable[[downloadProgressEvent,Optional[str]], None]=None) -> None:
+        """
+    Fired when download makes progress. Last call has |done| == true.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: downloadProgressEvent, session_id: Optional[str]).
+        """
+        self.client.on('Browser.downloadProgress', callback)

cdp/protocol/browser/events/types.py

@@ -0,0 +1,28 @@
+"""CDP Browser Events"""
+
+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.page.types import FrameId
+
+class downloadWillBeginEvent(TypedDict, total=True):
+    frameId: 'FrameId'
+    """Id of the frame that caused the download to begin."""
+    guid: 'str'
+    """Global unique identifier of the download."""
+    url: 'str'
+    """URL of the resource being downloaded."""
+    suggestedFilename: 'str'
+    """Suggested file name of the resource (the actual name of the file saved on disk may differ)."""
+class downloadProgressEvent(TypedDict, total=True):
+    guid: 'str'
+    """Global unique identifier of the download."""
+    totalBytes: 'float'
+    """Total expected bytes to download."""
+    receivedBytes: 'float'
+    """Total bytes received."""
+    state: 'Literal["inProgress", "completed", "canceled"]'
+    """Download status."""
+    filePath: NotRequired['str']
+    """If download is "completed", provides the path of the downloaded file. Depending on the platform, it is not guaranteed to be set, nor the file is guaranteed to exist."""

cdp/protocol/browser/methods/service.py

@@ -0,0 +1,230 @@
+"""CDP Browser 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 BrowserMethods:
+    """
+    Methods for the Browser domain.
+    """
+    def __init__(self, client: "Client"):
+        """
+        Initialize the Browser methods.
+        
+        Args:
+            client ("Client"): The parent CDP client instance.
+        """
+        self.client = client
+
+    async def set_permission(self, params: Optional[setPermissionParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Set permission settings for given embedding and embedded origins.    
+        Args:
+            params (setPermissionParameters, optional): Parameters for the setPermission method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the setPermission call.
+        """
+        return await self.client.send(method="Browser.setPermission", params=params,session_id=session_id)
+    async def reset_permissions(self, params: Optional[resetPermissionsParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Reset all permission management for all origins.    
+        Args:
+            params (resetPermissionsParameters, optional): Parameters for the resetPermissions method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the resetPermissions call.
+        """
+        return await self.client.send(method="Browser.resetPermissions", params=params,session_id=session_id)
+    async def set_download_behavior(self, params: Optional[setDownloadBehaviorParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Set the behavior when downloading a file.    
+        Args:
+            params (setDownloadBehaviorParameters, optional): Parameters for the setDownloadBehavior method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the setDownloadBehavior call.
+        """
+        return await self.client.send(method="Browser.setDownloadBehavior", params=params,session_id=session_id)
+    async def cancel_download(self, params: Optional[cancelDownloadParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Cancel a download if in progress    
+        Args:
+            params (cancelDownloadParameters, optional): Parameters for the cancelDownload method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the cancelDownload call.
+        """
+        return await self.client.send(method="Browser.cancelDownload", params=params,session_id=session_id)
+    async def close(self, params: None=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Close browser gracefully.    
+        Args:
+            params (None, optional): Parameters for the close method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the close call.
+        """
+        return await self.client.send(method="Browser.close", params=params,session_id=session_id)
+    async def crash(self, params: None=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Crashes browser on the main thread.    
+        Args:
+            params (None, optional): Parameters for the crash method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the crash call.
+        """
+        return await self.client.send(method="Browser.crash", params=params,session_id=session_id)
+    async def crash_gpu_process(self, params: None=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Crashes GPU process.    
+        Args:
+            params (None, optional): Parameters for the crashGpuProcess method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the crashGpuProcess call.
+        """
+        return await self.client.send(method="Browser.crashGpuProcess", params=params,session_id=session_id)
+    async def get_version(self, params: None=None,session_id: Optional[str] = None) -> getVersionReturns:
+        """
+    Returns version information.    
+        Args:
+            params (None, optional): Parameters for the getVersion method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    getVersionReturns: The result of the getVersion call.
+        """
+        return await self.client.send(method="Browser.getVersion", params=params,session_id=session_id)
+    async def get_browser_command_line(self, params: None=None,session_id: Optional[str] = None) -> getBrowserCommandLineReturns:
+        """
+    Returns the command line switches for the browser process if, and only if --enable-automation is on the commandline.    
+        Args:
+            params (None, optional): Parameters for the getBrowserCommandLine method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    getBrowserCommandLineReturns: The result of the getBrowserCommandLine call.
+        """
+        return await self.client.send(method="Browser.getBrowserCommandLine", params=params,session_id=session_id)
+    async def get_histograms(self, params: Optional[getHistogramsParameters]=None,session_id: Optional[str] = None) -> getHistogramsReturns:
+        """
+    Get Chrome histograms.    
+        Args:
+            params (getHistogramsParameters, optional): Parameters for the getHistograms method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    getHistogramsReturns: The result of the getHistograms call.
+        """
+        return await self.client.send(method="Browser.getHistograms", params=params,session_id=session_id)
+    async def get_histogram(self, params: Optional[getHistogramParameters]=None,session_id: Optional[str] = None) -> getHistogramReturns:
+        """
+    Get a Chrome histogram by name.    
+        Args:
+            params (getHistogramParameters, optional): Parameters for the getHistogram method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    getHistogramReturns: The result of the getHistogram call.
+        """
+        return await self.client.send(method="Browser.getHistogram", params=params,session_id=session_id)
+    async def get_window_bounds(self, params: Optional[getWindowBoundsParameters]=None,session_id: Optional[str] = None) -> getWindowBoundsReturns:
+        """
+    Get position and size of the browser window.    
+        Args:
+            params (getWindowBoundsParameters, optional): Parameters for the getWindowBounds method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    getWindowBoundsReturns: The result of the getWindowBounds call.
+        """
+        return await self.client.send(method="Browser.getWindowBounds", params=params,session_id=session_id)
+    async def get_window_for_target(self, params: Optional[getWindowForTargetParameters]=None,session_id: Optional[str] = None) -> getWindowForTargetReturns:
+        """
+    Get the browser window that contains the devtools target.    
+        Args:
+            params (getWindowForTargetParameters, optional): Parameters for the getWindowForTarget method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    getWindowForTargetReturns: The result of the getWindowForTarget call.
+        """
+        return await self.client.send(method="Browser.getWindowForTarget", params=params,session_id=session_id)
+    async def set_window_bounds(self, params: Optional[setWindowBoundsParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Set position and/or size of the browser window.    
+        Args:
+            params (setWindowBoundsParameters, optional): Parameters for the setWindowBounds method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the setWindowBounds call.
+        """
+        return await self.client.send(method="Browser.setWindowBounds", params=params,session_id=session_id)
+    async def set_contents_size(self, params: Optional[setContentsSizeParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Set size of the browser contents resizing browser window as necessary.    
+        Args:
+            params (setContentsSizeParameters, optional): Parameters for the setContentsSize method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the setContentsSize call.
+        """
+        return await self.client.send(method="Browser.setContentsSize", params=params,session_id=session_id)
+    async def set_dock_tile(self, params: Optional[setDockTileParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Set dock tile details, platform-specific.    
+        Args:
+            params (setDockTileParameters, optional): Parameters for the setDockTile method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the setDockTile call.
+        """
+        return await self.client.send(method="Browser.setDockTile", params=params,session_id=session_id)
+    async def execute_browser_command(self, params: Optional[executeBrowserCommandParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Invoke custom browser commands used by telemetry.    
+        Args:
+            params (executeBrowserCommandParameters, optional): Parameters for the executeBrowserCommand method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the executeBrowserCommand call.
+        """
+        return await self.client.send(method="Browser.executeBrowserCommand", params=params,session_id=session_id)
+    async def add_privacy_sandbox_enrollment_override(self, params: Optional[addPrivacySandboxEnrollmentOverrideParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Allows a site to use privacy sandbox features that require enrollment without the site actually being enrolled. Only supported on page targets.    
+        Args:
+            params (addPrivacySandboxEnrollmentOverrideParameters, optional): Parameters for the addPrivacySandboxEnrollmentOverride method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the addPrivacySandboxEnrollmentOverride call.
+        """
+        return await self.client.send(method="Browser.addPrivacySandboxEnrollmentOverride", params=params,session_id=session_id)
+    async def add_privacy_sandbox_coordinator_key_config(self, params: Optional[addPrivacySandboxCoordinatorKeyConfigParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Configures encryption keys used with a given privacy sandbox API to talk to a trusted coordinator.  Since this is intended for test automation only, coordinatorOrigin must be a .test domain. No existing coordinator configuration for the origin may exist.    
+        Args:
+            params (addPrivacySandboxCoordinatorKeyConfigParameters, optional): Parameters for the addPrivacySandboxCoordinatorKeyConfig method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the addPrivacySandboxCoordinatorKeyConfig call.
+        """
+        return await self.client.send(method="Browser.addPrivacySandboxCoordinatorKeyConfig", params=params,session_id=session_id)

cdp/protocol/browser/methods/types.py

@@ -0,0 +1,126 @@
+"""CDP Browser 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.browser.types import Bounds
+    from cdp.protocol.browser.types import BrowserCommandId
+    from cdp.protocol.browser.types import BrowserContextID
+    from cdp.protocol.browser.types import Histogram
+    from cdp.protocol.browser.types import PermissionDescriptor
+    from cdp.protocol.browser.types import PermissionSetting
+    from cdp.protocol.browser.types import PrivacySandboxAPI
+    from cdp.protocol.browser.types import WindowID
+    from cdp.protocol.target.types import TargetID
+
+class setPermissionParameters(TypedDict, total=True):
+    permission: 'PermissionDescriptor'
+    """Descriptor of permission to override."""
+    setting: 'PermissionSetting'
+    """Setting of the permission."""
+    origin: NotRequired['str']
+    """Embedding origin the permission applies to, all origins if not specified."""
+    embeddedOrigin: NotRequired['str']
+    """Embedded origin the permission applies to. It is ignored unless the embedding origin is present and valid. If the embedding origin is provided but the embedded origin isn't, the embedding origin is used as the embedded origin."""
+    browserContextId: NotRequired['BrowserContextID']
+    """Context to override. When omitted, default browser context is used."""
+class resetPermissionsParameters(TypedDict, total=False):
+    browserContextId: NotRequired['BrowserContextID']
+    """BrowserContext to reset permissions. When omitted, default browser context is used."""
+class setDownloadBehaviorParameters(TypedDict, total=True):
+    behavior: 'Literal["deny", "allow", "allowAndName", "default"]'
+    """Whether to allow all or deny all download requests, or use default Chrome behavior if available (otherwise deny). |allowAndName| allows download and names files according to their download guids."""
+    browserContextId: NotRequired['BrowserContextID']
+    """BrowserContext to set download behavior. When omitted, default browser context is used."""
+    downloadPath: NotRequired['str']
+    """The default path to save downloaded files to. This is required if behavior is set to 'allow' or 'allowAndName'."""
+    eventsEnabled: NotRequired['bool']
+    """Whether to emit download events (defaults to false)."""
+class cancelDownloadParameters(TypedDict, total=True):
+    guid: 'str'
+    """Global unique identifier of the download."""
+    browserContextId: NotRequired['BrowserContextID']
+    """BrowserContext to perform the action in. When omitted, default browser context is used."""
+
+
+
+
+
+class getHistogramsParameters(TypedDict, total=False):
+    query: NotRequired['str']
+    """Requested substring in name. Only histograms which have query as a substring in their name are extracted. An empty or absent query returns all histograms."""
+    delta: NotRequired['bool']
+    """If true, retrieve delta since last delta call."""
+class getHistogramParameters(TypedDict, total=True):
+    name: 'str'
+    """Requested histogram name."""
+    delta: NotRequired['bool']
+    """If true, retrieve delta since last delta call."""
+class getWindowBoundsParameters(TypedDict, total=True):
+    windowId: 'WindowID'
+    """Browser window id."""
+class getWindowForTargetParameters(TypedDict, total=False):
+    targetId: NotRequired['TargetID']
+    """Devtools agent host id. If called as a part of the session, associated targetId is used."""
+class setWindowBoundsParameters(TypedDict, total=True):
+    windowId: 'WindowID'
+    """Browser window id."""
+    bounds: 'Bounds'
+    """New window bounds. The 'minimized', 'maximized' and 'fullscreen' states cannot be combined with 'left', 'top', 'width' or 'height'. Leaves unspecified fields unchanged."""
+class setContentsSizeParameters(TypedDict, total=True):
+    windowId: 'WindowID'
+    """Browser window id."""
+    width: NotRequired['int']
+    """The window contents width in DIP. Assumes current width if omitted. Must be specified if 'height' is omitted."""
+    height: NotRequired['int']
+    """The window contents height in DIP. Assumes current height if omitted. Must be specified if 'width' is omitted."""
+class setDockTileParameters(TypedDict, total=False):
+    badgeLabel: NotRequired['str']
+    image: NotRequired['str']
+    """Png encoded image. (Encoded as a base64 string when passed over JSON)"""
+class executeBrowserCommandParameters(TypedDict, total=True):
+    commandId: 'BrowserCommandId'
+class addPrivacySandboxEnrollmentOverrideParameters(TypedDict, total=True):
+    url: 'str'
+class addPrivacySandboxCoordinatorKeyConfigParameters(TypedDict, total=True):
+    api: 'PrivacySandboxAPI'
+    coordinatorOrigin: 'str'
+    keyConfig: 'str'
+    browserContextId: NotRequired['BrowserContextID']
+    """BrowserContext to perform the action in. When omitted, default browser context is used."""
+
+
+
+
+
+
+
+class getVersionReturns(TypedDict):
+    protocolVersion: 'str'
+    """Protocol version."""
+    product: 'str'
+    """Product name."""
+    revision: 'str'
+    """Product revision."""
+    userAgent: 'str'
+    """User-Agent."""
+    jsVersion: 'str'
+    """V8 version."""
+class getBrowserCommandLineReturns(TypedDict):
+    arguments: 'List[str]'
+    """Commandline parameters"""
+class getHistogramsReturns(TypedDict):
+    histograms: 'List[Histogram]'
+    """Histograms."""
+class getHistogramReturns(TypedDict):
+    histogram: 'Histogram'
+    """Histogram."""
+class getWindowBoundsReturns(TypedDict):
+    bounds: 'Bounds'
+    """Bounds information of the window. When window state is 'minimized', the restored window position and size are returned."""
+class getWindowForTargetReturns(TypedDict):
+    windowId: 'WindowID'
+    """Browser window id."""
+    bounds: 'Bounds'
+    """Bounds information of the window. When window state is 'minimized', the restored window position and size are returned."""

cdp/protocol/browser/service.py

@@ -0,0 +1,21 @@
+"""CDP Browser Domain"""
+from typing import TYPE_CHECKING
+from .methods.service import BrowserMethods
+from .events.service import BrowserEvents
+
+if TYPE_CHECKING:
+    from ...service import Client
+
+class Browser(BrowserMethods, BrowserEvents):
+    """
+    The Browser domain defines methods and events for browser managing.
+    """
+    def __init__(self, client: "Client"):
+        """
+        Initialize the Browser domain.
+        
+        Args:
+            client ("Client"): The parent CDP client instance.
+        """
+        BrowserMethods.__init__(self, client)
+        BrowserEvents.__init__(self, client)

cdp/protocol/browser/types.py

@@ -0,0 +1,57 @@
+"""CDP Browser Types"""
+
+from typing import TypedDict, NotRequired, Required, Literal, Any, Dict, Union, Optional, List, Set, Tuple
+
+BrowserContextID = str
+WindowID = int
+WindowState = Literal['normal','minimized','maximized','fullscreen']
+"""The state of the browser window."""
+class Bounds(TypedDict, total=False):
+    """Browser window bounds information"""
+    left: NotRequired['int']
+    """The offset from the left edge of the screen to the window in pixels."""
+    top: NotRequired['int']
+    """The offset from the top edge of the screen to the window in pixels."""
+    width: NotRequired['int']
+    """The window width in pixels."""
+    height: NotRequired['int']
+    """The window height in pixels."""
+    windowState: NotRequired['WindowState']
+    """The window state. Default to normal."""
+PermissionType = Literal['ar','audioCapture','automaticFullscreen','backgroundFetch','backgroundSync','cameraPanTiltZoom','capturedSurfaceControl','clipboardReadWrite','clipboardSanitizedWrite','displayCapture','durableStorage','geolocation','handTracking','idleDetection','keyboardLock','localFonts','localNetwork','localNetworkAccess','loopbackNetwork','midi','midiSysex','nfc','notifications','paymentHandler','periodicBackgroundSync','pointerLock','protectedMediaIdentifier','sensors','smartCard','speakerSelection','storageAccess','topLevelStorageAccess','videoCapture','vr','wakeLockScreen','wakeLockSystem','webAppInstallation','webPrinting','windowManagement']
+PermissionSetting = Literal['granted','denied','prompt']
+class PermissionDescriptor(TypedDict, total=True):
+    """Definition of PermissionDescriptor defined in the Permissions API: https://w3c.github.io/permissions/#dom-permissiondescriptor."""
+    name: 'str'
+    """Name of permission. See https://cs.chromium.org/chromium/src/third_party/blink/renderer/modules/permissions/permission_descriptor.idl for valid permission names."""
+    sysex: NotRequired['bool']
+    """For "midi" permission, may also specify sysex control."""
+    userVisibleOnly: NotRequired['bool']
+    """For "push" permission, may specify userVisibleOnly. Note that userVisibleOnly = true is the only currently supported type."""
+    allowWithoutSanitization: NotRequired['bool']
+    """For "clipboard" permission, may specify allowWithoutSanitization."""
+    allowWithoutGesture: NotRequired['bool']
+    """For "fullscreen" permission, must specify allowWithoutGesture:true."""
+    panTiltZoom: NotRequired['bool']
+    """For "camera" permission, may specify panTiltZoom."""
+BrowserCommandId = Literal['openTabSearch','closeTabSearch','openGlic']
+"""Browser command ids used by executeBrowserCommand."""
+class Bucket(TypedDict, total=True):
+    """Chrome histogram bucket."""
+    low: 'int'
+    """Minimum value (inclusive)."""
+    high: 'int'
+    """Maximum value (exclusive)."""
+    count: 'int'
+    """Number of samples."""
+class Histogram(TypedDict, total=True):
+    """Chrome histogram."""
+    name: 'str'
+    """Name."""
+    sum: 'int'
+    """Sum of sample values."""
+    count: 'int'
+    """Total number of samples."""
+    buckets: 'List[Bucket]'
+    """Buckets."""
+PrivacySandboxAPI = Literal['BiddingAndAuctionServices','TrustedKeyValue']