chromedeveloperprotocol-client 0.1.0__py3-none-any.whl

cdp/protocol/autofill/methods/service.py

@@ -0,0 +1,65 @@
+"""CDP Autofill 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 AutofillMethods:
+    """
+    Methods for the Autofill domain.
+    """
+    def __init__(self, client: "Client"):
+        """
+        Initialize the Autofill methods.
+        
+        Args:
+            client ("Client"): The parent CDP client instance.
+        """
+        self.client = client
+
+    async def trigger(self, params: Optional[triggerParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Trigger autofill on a form identified by the fieldId. If the field and related form cannot be autofilled, returns an error.    
+        Args:
+            params (triggerParameters, optional): Parameters for the trigger method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the trigger call.
+        """
+        return await self.client.send(method="Autofill.trigger", params=params,session_id=session_id)
+    async def set_addresses(self, params: Optional[setAddressesParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Set addresses so that developers can verify their forms implementation.    
+        Args:
+            params (setAddressesParameters, optional): Parameters for the setAddresses method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the setAddresses call.
+        """
+        return await self.client.send(method="Autofill.setAddresses", params=params,session_id=session_id)
+    async def disable(self, params: None=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Disables autofill domain notifications.    
+        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="Autofill.disable", params=params,session_id=session_id)
+    async def enable(self, params: None=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Enables autofill domain notifications.    
+        Args:
+            params (None, optional): Parameters for the enable method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the enable call.
+        """
+        return await self.client.send(method="Autofill.enable", params=params,session_id=session_id)

cdp/protocol/autofill/methods/types.py

@@ -0,0 +1,22 @@
+"""CDP Autofill 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.autofill.types import Address
+    from cdp.protocol.autofill.types import CreditCard
+    from cdp.protocol.dom.types import BackendNodeId
+    from cdp.protocol.page.types import FrameId
+
+class triggerParameters(TypedDict, total=True):
+    fieldId: 'BackendNodeId'
+    """Identifies a field that serves as an anchor for autofill."""
+    frameId: NotRequired['FrameId']
+    """Identifies the frame that field belongs to."""
+    card: NotRequired['CreditCard']
+    """Credit card information to fill out the form. Credit card data is not saved.  Mutually exclusive with address."""
+    address: NotRequired['Address']
+    """Address to fill out the form. Address data is not saved. Mutually exclusive with card."""
+class setAddressesParameters(TypedDict, total=True):
+    addresses: 'List[Address]'

cdp/protocol/autofill/service.py

@@ -0,0 +1,21 @@
+"""CDP Autofill Domain"""
+from typing import TYPE_CHECKING
+from .methods.service import AutofillMethods
+from .events.service import AutofillEvents
+
+if TYPE_CHECKING:
+    from ...service import Client
+
+class Autofill(AutofillMethods, AutofillEvents):
+    """
+    Defines commands and events for Autofill.
+    """
+    def __init__(self, client: "Client"):
+        """
+        Initialize the Autofill domain.
+        
+        Args:
+            client ("Client"): The parent CDP client instance.
+        """
+        AutofillMethods.__init__(self, client)
+        AutofillEvents.__init__(self, client)

cdp/protocol/autofill/types.py

@@ -0,0 +1,54 @@
+"""CDP Autofill 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 BackendNodeId
+    from cdp.protocol.page.types import FrameId
+
+class CreditCard(TypedDict, total=True):
+    number: 'str'
+    """16-digit credit card number."""
+    name: 'str'
+    """Name of the credit card owner."""
+    expiryMonth: 'str'
+    """2-digit expiry month."""
+    expiryYear: 'str'
+    """4-digit expiry year."""
+    cvc: 'str'
+    """3-digit card verification code."""
+class AddressField(TypedDict, total=True):
+    name: 'str'
+    """address field name, for example GIVEN_NAME. The full list of supported field names: https://source.chromium.org/chromium/chromium/src/+/main:components/autofill/core/browser/field_types.cc;l=38"""
+    value: 'str'
+    """address field value, for example Jon Doe."""
+class AddressFields(TypedDict, total=True):
+    """A list of address fields."""
+    fields: 'List[AddressField]'
+class Address(TypedDict, total=True):
+    fields: 'List[AddressField]'
+    """fields and values defining an address."""
+class AddressUI(TypedDict, total=True):
+    """Defines how an address can be displayed like in chrome://settings/addresses. Address UI is a two dimensional array, each inner array is an "address information line", and when rendered in a UI surface should be displayed as such. The following address UI for instance: [[{name: "GIVE_NAME", value: "Jon"}, {name: "FAMILY_NAME", value: "Doe"}], [{name: "CITY", value: "Munich"}, {name: "ZIP", value: "81456"}]] should allow the receiver to render: Jon Doe Munich 81456"""
+    addressFields: 'List[AddressFields]'
+    """A two dimension array containing the representation of values from an address profile."""
+FillingStrategy = Literal['autocompleteAttribute','autofillInferred']
+"""Specified whether a filled field was done so by using the html autocomplete attribute or autofill heuristics."""
+class FilledField(TypedDict, total=True):
+    htmlType: 'str'
+    """The type of the field, e.g text, password etc."""
+    id: 'str'
+    """the html id"""
+    name: 'str'
+    """the html name"""
+    value: 'str'
+    """the field value"""
+    autofillType: 'str'
+    """The actual field type, e.g FAMILY_NAME"""
+    fillingStrategy: 'FillingStrategy'
+    """The filling strategy"""
+    frameId: 'FrameId'
+    """The frame the field belongs to"""
+    fieldId: 'BackendNodeId'
+    """The form field's DOM node"""

cdp/protocol/background_service/events/service.py

@@ -0,0 +1,37 @@
+"""CDP BackgroundService 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 BackgroundServiceEvents:
+    """
+    Events for the BackgroundService domain.
+    """
+    def __init__(self, client: "Client"):
+        """
+        Initialize the BackgroundService events.
+        
+        Args:
+            client ("Client"): The parent CDP client instance.
+        """
+        self.client = client
+
+    def on_recording_state_changed(self, callback: Callable[[recordingStateChangedEvent,Optional[str]], None]=None) -> None:
+        """
+    Called when the recording state for the service has been updated.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: recordingStateChangedEvent, session_id: Optional[str]).
+        """
+        self.client.on('BackgroundService.recordingStateChanged', callback)
+    def on_background_service_event_received(self, callback: Callable[[backgroundServiceEventReceivedEvent,Optional[str]], None]=None) -> None:
+        """
+    Called with all existing backgroundServiceEvents when enabled, and all new events afterwards if enabled and recording.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: backgroundServiceEventReceivedEvent, session_id: Optional[str]).
+        """
+        self.client.on('BackgroundService.backgroundServiceEventReceived', callback)

cdp/protocol/background_service/events/types.py

@@ -0,0 +1,14 @@
+"""CDP BackgroundService 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.background_service.types import BackgroundServiceEvent
+    from cdp.protocol.background_service.types import ServiceName
+
+class recordingStateChangedEvent(TypedDict, total=True):
+    isRecording: 'bool'
+    service: 'ServiceName'
+class backgroundServiceEventReceivedEvent(TypedDict, total=True):
+    backgroundServiceEvent: 'BackgroundServiceEvent'

cdp/protocol/background_service/methods/service.py

@@ -0,0 +1,65 @@
+"""CDP BackgroundService 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 BackgroundServiceMethods:
+    """
+    Methods for the BackgroundService domain.
+    """
+    def __init__(self, client: "Client"):
+        """
+        Initialize the BackgroundService methods.
+        
+        Args:
+            client ("Client"): The parent CDP client instance.
+        """
+        self.client = client
+
+    async def start_observing(self, params: Optional[startObservingParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Enables event updates for the service.    
+        Args:
+            params (startObservingParameters, optional): Parameters for the startObserving method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the startObserving call.
+        """
+        return await self.client.send(method="BackgroundService.startObserving", params=params,session_id=session_id)
+    async def stop_observing(self, params: Optional[stopObservingParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Disables event updates for the service.    
+        Args:
+            params (stopObservingParameters, optional): Parameters for the stopObserving method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the stopObserving call.
+        """
+        return await self.client.send(method="BackgroundService.stopObserving", params=params,session_id=session_id)
+    async def set_recording(self, params: Optional[setRecordingParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Set the recording state for the service.    
+        Args:
+            params (setRecordingParameters, optional): Parameters for the setRecording method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the setRecording call.
+        """
+        return await self.client.send(method="BackgroundService.setRecording", params=params,session_id=session_id)
+    async def clear_events(self, params: Optional[clearEventsParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Clears all stored data for the service.    
+        Args:
+            params (clearEventsParameters, optional): Parameters for the clearEvents method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the clearEvents call.
+        """
+        return await self.client.send(method="BackgroundService.clearEvents", params=params,session_id=session_id)

cdp/protocol/background_service/methods/types.py

@@ -0,0 +1,17 @@
+"""CDP BackgroundService 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.background_service.types import ServiceName
+
+class startObservingParameters(TypedDict, total=True):
+    service: 'ServiceName'
+class stopObservingParameters(TypedDict, total=True):
+    service: 'ServiceName'
+class setRecordingParameters(TypedDict, total=True):
+    shouldRecord: 'bool'
+    service: 'ServiceName'
+class clearEventsParameters(TypedDict, total=True):
+    service: 'ServiceName'

cdp/protocol/background_service/service.py

@@ -0,0 +1,21 @@
+"""CDP BackgroundService Domain"""
+from typing import TYPE_CHECKING
+from .methods.service import BackgroundServiceMethods
+from .events.service import BackgroundServiceEvents
+
+if TYPE_CHECKING:
+    from ...service import Client
+
+class BackgroundService(BackgroundServiceMethods, BackgroundServiceEvents):
+    """
+    Defines events for background web platform features.
+    """
+    def __init__(self, client: "Client"):
+        """
+        Initialize the BackgroundService domain.
+        
+        Args:
+            client ("Client"): The parent CDP client instance.
+        """
+        BackgroundServiceMethods.__init__(self, client)
+        BackgroundServiceEvents.__init__(self, client)

cdp/protocol/background_service/types.py

@@ -0,0 +1,32 @@
+"""CDP BackgroundService 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.network.types import TimeSinceEpoch
+    from cdp.protocol.serviceworker.types import RegistrationID
+
+ServiceName = Literal['backgroundFetch','backgroundSync','pushMessaging','notifications','paymentHandler','periodicBackgroundSync']
+"""The Background Service that will be associated with the commands/events. Every Background Service operates independently, but they share the same API."""
+class EventMetadata(TypedDict, total=True):
+    """A key-value pair for additional event information to pass along."""
+    key: 'str'
+    value: 'str'
+class BackgroundServiceEvent(TypedDict, total=True):
+    timestamp: 'TimeSinceEpoch'
+    """Timestamp of the event (in seconds)."""
+    origin: 'str'
+    """The origin this event belongs to."""
+    serviceWorkerRegistrationId: 'RegistrationID'
+    """The Service Worker ID that initiated the event."""
+    service: 'ServiceName'
+    """The Background Service this event belongs to."""
+    eventName: 'str'
+    """A description of the event."""
+    instanceId: 'str'
+    """An identifier that groups related events together."""
+    eventMetadata: 'List[EventMetadata]'
+    """A list of event-specific information."""
+    storageKey: 'str'
+    """Storage key this event belongs to."""

cdp/protocol/bluetooth_emulation/events/service.py

@@ -0,0 +1,45 @@
+"""CDP BluetoothEmulation 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 BluetoothEmulationEvents:
+    """
+    Events for the BluetoothEmulation domain.
+    """
+    def __init__(self, client: "Client"):
+        """
+        Initialize the BluetoothEmulation events.
+        
+        Args:
+            client ("Client"): The parent CDP client instance.
+        """
+        self.client = client
+
+    def on_gatt_operation_received(self, callback: Callable[[gattOperationReceivedEvent,Optional[str]], None]=None) -> None:
+        """
+    Event for when a GATT operation of |type| to the peripheral with |address| happened.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: gattOperationReceivedEvent, session_id: Optional[str]).
+        """
+        self.client.on('BluetoothEmulation.gattOperationReceived', callback)
+    def on_characteristic_operation_received(self, callback: Callable[[characteristicOperationReceivedEvent,Optional[str]], None]=None) -> None:
+        """
+    Event for when a characteristic operation of |type| to the characteristic respresented by |characteristicId| happened. |data| and |writeType| is expected to exist when |type| is write.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: characteristicOperationReceivedEvent, session_id: Optional[str]).
+        """
+        self.client.on('BluetoothEmulation.characteristicOperationReceived', callback)
+    def on_descriptor_operation_received(self, callback: Callable[[descriptorOperationReceivedEvent,Optional[str]], None]=None) -> None:
+        """
+    Event for when a descriptor operation of |type| to the descriptor respresented by |descriptorId| happened. |data| is expected to exist when |type| is write.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: descriptorOperationReceivedEvent, session_id: Optional[str]).
+        """
+        self.client.on('BluetoothEmulation.descriptorOperationReceived', callback)

cdp/protocol/bluetooth_emulation/events/types.py

@@ -0,0 +1,23 @@
+"""CDP BluetoothEmulation 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.bluetooth_emulation.types import CharacteristicOperationType
+    from cdp.protocol.bluetooth_emulation.types import CharacteristicWriteType
+    from cdp.protocol.bluetooth_emulation.types import DescriptorOperationType
+    from cdp.protocol.bluetooth_emulation.types import GATTOperationType
+
+class gattOperationReceivedEvent(TypedDict, total=True):
+    address: 'str'
+    type: 'GATTOperationType'
+class characteristicOperationReceivedEvent(TypedDict, total=True):
+    characteristicId: 'str'
+    type: 'CharacteristicOperationType'
+    data: NotRequired['str']
+    writeType: NotRequired['CharacteristicWriteType']
+class descriptorOperationReceivedEvent(TypedDict, total=True):
+    descriptorId: 'str'
+    type: 'DescriptorOperationType'
+    data: NotRequired['str']

cdp/protocol/bluetooth_emulation/methods/service.py

@@ -0,0 +1,186 @@
+"""CDP BluetoothEmulation 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 BluetoothEmulationMethods:
+    """
+    Methods for the BluetoothEmulation domain.
+    """
+    def __init__(self, client: "Client"):
+        """
+        Initialize the BluetoothEmulation methods.
+        
+        Args:
+            client ("Client"): The parent CDP client instance.
+        """
+        self.client = client
+
+    async def enable(self, params: Optional[enableParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Enable the BluetoothEmulation domain.    
+        Args:
+            params (enableParameters, optional): Parameters for the enable method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the enable call.
+        """
+        return await self.client.send(method="BluetoothEmulation.enable", params=params,session_id=session_id)
+    async def set_simulated_central_state(self, params: Optional[setSimulatedCentralStateParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Set the state of the simulated central.    
+        Args:
+            params (setSimulatedCentralStateParameters, optional): Parameters for the setSimulatedCentralState method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the setSimulatedCentralState call.
+        """
+        return await self.client.send(method="BluetoothEmulation.setSimulatedCentralState", params=params,session_id=session_id)
+    async def disable(self, params: None=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Disable the BluetoothEmulation domain.    
+        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="BluetoothEmulation.disable", params=params,session_id=session_id)
+    async def simulate_preconnected_peripheral(self, params: Optional[simulatePreconnectedPeripheralParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Simulates a peripheral with |address|, |name| and |knownServiceUuids| that has already been connected to the system.    
+        Args:
+            params (simulatePreconnectedPeripheralParameters, optional): Parameters for the simulatePreconnectedPeripheral method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the simulatePreconnectedPeripheral call.
+        """
+        return await self.client.send(method="BluetoothEmulation.simulatePreconnectedPeripheral", params=params,session_id=session_id)
+    async def simulate_advertisement(self, params: Optional[simulateAdvertisementParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Simulates an advertisement packet described in |entry| being received by the central.    
+        Args:
+            params (simulateAdvertisementParameters, optional): Parameters for the simulateAdvertisement method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the simulateAdvertisement call.
+        """
+        return await self.client.send(method="BluetoothEmulation.simulateAdvertisement", params=params,session_id=session_id)
+    async def simulate_gatt_operation_response(self, params: Optional[simulateGATTOperationResponseParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Simulates the response code from the peripheral with |address| for a GATT operation of |type|. The |code| value follows the HCI Error Codes from Bluetooth Core Specification Vol 2 Part D 1.3 List Of Error Codes.    
+        Args:
+            params (simulateGATTOperationResponseParameters, optional): Parameters for the simulateGATTOperationResponse method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the simulateGATTOperationResponse call.
+        """
+        return await self.client.send(method="BluetoothEmulation.simulateGATTOperationResponse", params=params,session_id=session_id)
+    async def simulate_characteristic_operation_response(self, params: Optional[simulateCharacteristicOperationResponseParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Simulates the response from the characteristic with |characteristicId| for a characteristic operation of |type|. The |code| value follows the Error Codes from Bluetooth Core Specification Vol 3 Part F 3.4.1.1 Error Response. The |data| is expected to exist when simulating a successful read operation response.    
+        Args:
+            params (simulateCharacteristicOperationResponseParameters, optional): Parameters for the simulateCharacteristicOperationResponse method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the simulateCharacteristicOperationResponse call.
+        """
+        return await self.client.send(method="BluetoothEmulation.simulateCharacteristicOperationResponse", params=params,session_id=session_id)
+    async def simulate_descriptor_operation_response(self, params: Optional[simulateDescriptorOperationResponseParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Simulates the response from the descriptor with |descriptorId| for a descriptor operation of |type|. The |code| value follows the Error Codes from Bluetooth Core Specification Vol 3 Part F 3.4.1.1 Error Response. The |data| is expected to exist when simulating a successful read operation response.    
+        Args:
+            params (simulateDescriptorOperationResponseParameters, optional): Parameters for the simulateDescriptorOperationResponse method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the simulateDescriptorOperationResponse call.
+        """
+        return await self.client.send(method="BluetoothEmulation.simulateDescriptorOperationResponse", params=params,session_id=session_id)
+    async def add_service(self, params: Optional[addServiceParameters]=None,session_id: Optional[str] = None) -> addServiceReturns:
+        """
+    Adds a service with |serviceUuid| to the peripheral with |address|.    
+        Args:
+            params (addServiceParameters, optional): Parameters for the addService method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    addServiceReturns: The result of the addService call.
+        """
+        return await self.client.send(method="BluetoothEmulation.addService", params=params,session_id=session_id)
+    async def remove_service(self, params: Optional[removeServiceParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Removes the service respresented by |serviceId| from the simulated central.    
+        Args:
+            params (removeServiceParameters, optional): Parameters for the removeService method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the removeService call.
+        """
+        return await self.client.send(method="BluetoothEmulation.removeService", params=params,session_id=session_id)
+    async def add_characteristic(self, params: Optional[addCharacteristicParameters]=None,session_id: Optional[str] = None) -> addCharacteristicReturns:
+        """
+    Adds a characteristic with |characteristicUuid| and |properties| to the service represented by |serviceId|.    
+        Args:
+            params (addCharacteristicParameters, optional): Parameters for the addCharacteristic method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    addCharacteristicReturns: The result of the addCharacteristic call.
+        """
+        return await self.client.send(method="BluetoothEmulation.addCharacteristic", params=params,session_id=session_id)
+    async def remove_characteristic(self, params: Optional[removeCharacteristicParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Removes the characteristic respresented by |characteristicId| from the simulated central.    
+        Args:
+            params (removeCharacteristicParameters, optional): Parameters for the removeCharacteristic method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the removeCharacteristic call.
+        """
+        return await self.client.send(method="BluetoothEmulation.removeCharacteristic", params=params,session_id=session_id)
+    async def add_descriptor(self, params: Optional[addDescriptorParameters]=None,session_id: Optional[str] = None) -> addDescriptorReturns:
+        """
+    Adds a descriptor with |descriptorUuid| to the characteristic respresented by |characteristicId|.    
+        Args:
+            params (addDescriptorParameters, optional): Parameters for the addDescriptor method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    addDescriptorReturns: The result of the addDescriptor call.
+        """
+        return await self.client.send(method="BluetoothEmulation.addDescriptor", params=params,session_id=session_id)
+    async def remove_descriptor(self, params: Optional[removeDescriptorParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Removes the descriptor with |descriptorId| from the simulated central.    
+        Args:
+            params (removeDescriptorParameters, optional): Parameters for the removeDescriptor method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the removeDescriptor call.
+        """
+        return await self.client.send(method="BluetoothEmulation.removeDescriptor", params=params,session_id=session_id)
+    async def simulate_gatt_disconnection(self, params: Optional[simulateGATTDisconnectionParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Simulates a GATT disconnection from the peripheral with |address|.    
+        Args:
+            params (simulateGATTDisconnectionParameters, optional): Parameters for the simulateGATTDisconnection method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the simulateGATTDisconnection call.
+        """
+        return await self.client.send(method="BluetoothEmulation.simulateGATTDisconnection", params=params,session_id=session_id)