chromedeveloperprotocol-client 0.1.0__py3-none-any.whl

cdp/protocol/tracing/methods/service.py

@@ -0,0 +1,87 @@
+"""CDP Tracing 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 TracingMethods:
+    """
+    Methods for the Tracing domain.
+    """
+    def __init__(self, client: "Client"):
+        """
+        Initialize the Tracing methods.
+        
+        Args:
+            client ("Client"): The parent CDP client instance.
+        """
+        self.client = client
+
+    async def end(self, params: None=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Stop trace events collection.    
+        Args:
+            params (None, optional): Parameters for the end method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the end call.
+        """
+        return await self.client.send(method="Tracing.end", params=params,session_id=session_id)
+    async def get_categories(self, params: None=None,session_id: Optional[str] = None) -> getCategoriesReturns:
+        """
+    Gets supported tracing categories.    
+        Args:
+            params (None, optional): Parameters for the getCategories method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    getCategoriesReturns: The result of the getCategories call.
+        """
+        return await self.client.send(method="Tracing.getCategories", params=params,session_id=session_id)
+    async def get_track_event_descriptor(self, params: None=None,session_id: Optional[str] = None) -> getTrackEventDescriptorReturns:
+        """
+    Return a descriptor for all available tracing categories.    
+        Args:
+            params (None, optional): Parameters for the getTrackEventDescriptor method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    getTrackEventDescriptorReturns: The result of the getTrackEventDescriptor call.
+        """
+        return await self.client.send(method="Tracing.getTrackEventDescriptor", params=params,session_id=session_id)
+    async def record_clock_sync_marker(self, params: Optional[recordClockSyncMarkerParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Record a clock sync marker in the trace.    
+        Args:
+            params (recordClockSyncMarkerParameters, optional): Parameters for the recordClockSyncMarker method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the recordClockSyncMarker call.
+        """
+        return await self.client.send(method="Tracing.recordClockSyncMarker", params=params,session_id=session_id)
+    async def request_memory_dump(self, params: Optional[requestMemoryDumpParameters]=None,session_id: Optional[str] = None) -> requestMemoryDumpReturns:
+        """
+    Request a global memory dump.    
+        Args:
+            params (requestMemoryDumpParameters, optional): Parameters for the requestMemoryDump method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    requestMemoryDumpReturns: The result of the requestMemoryDump call.
+        """
+        return await self.client.send(method="Tracing.requestMemoryDump", params=params,session_id=session_id)
+    async def start(self, params: Optional[startParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Start trace events collection.    
+        Args:
+            params (startParameters, optional): Parameters for the start method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the start call.
+        """
+        return await self.client.send(method="Tracing.start", params=params,session_id=session_id)

cdp/protocol/tracing/methods/types.py

@@ -0,0 +1,54 @@
+"""CDP Tracing 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.tracing.types import MemoryDumpLevelOfDetail
+    from cdp.protocol.tracing.types import StreamCompression
+    from cdp.protocol.tracing.types import StreamFormat
+    from cdp.protocol.tracing.types import TraceConfig
+    from cdp.protocol.tracing.types import TracingBackend
+
+
+
+
+class recordClockSyncMarkerParameters(TypedDict, total=True):
+    syncId: 'str'
+    """The ID of this clock sync marker"""
+class requestMemoryDumpParameters(TypedDict, total=False):
+    deterministic: NotRequired['bool']
+    """Enables more deterministic results by forcing garbage collection"""
+    levelOfDetail: NotRequired['MemoryDumpLevelOfDetail']
+    """Specifies level of details in memory dump. Defaults to "detailed"."""
+class startParameters(TypedDict, total=False):
+    categories: NotRequired['str']
+    """Category/tag filter"""
+    options: NotRequired['str']
+    """Tracing options"""
+    bufferUsageReportingInterval: NotRequired['float']
+    """If set, the agent will issue bufferUsage events at this interval, specified in milliseconds"""
+    transferMode: NotRequired['Literal["ReportEvents", "ReturnAsStream"]']
+    """Whether to report trace events as series of dataCollected events or to save trace to a stream (defaults to ReportEvents)."""
+    streamFormat: NotRequired['StreamFormat']
+    """Trace data format to use. This only applies when using ReturnAsStream transfer mode (defaults to json)."""
+    streamCompression: NotRequired['StreamCompression']
+    """Compression format to use. This only applies when using ReturnAsStream transfer mode (defaults to none)"""
+    traceConfig: NotRequired['TraceConfig']
+    perfettoConfig: NotRequired['str']
+    """Base64-encoded serialized perfetto.protos.TraceConfig protobuf message When specified, the parameters categories, options, traceConfig are ignored. (Encoded as a base64 string when passed over JSON)"""
+    tracingBackend: NotRequired['TracingBackend']
+    """Backend type (defaults to auto)"""
+
+class getCategoriesReturns(TypedDict):
+    categories: 'List[str]'
+    """A list of supported tracing categories."""
+class getTrackEventDescriptorReturns(TypedDict):
+    descriptor: 'str'
+    """Base64-encoded serialized perfetto.protos.TrackEventDescriptor protobuf message. (Encoded as a base64 string when passed over JSON)"""
+
+class requestMemoryDumpReturns(TypedDict):
+    dumpGuid: 'str'
+    """GUID of the resulting global memory dump."""
+    success: 'bool'
+    """True iff the global memory dump succeeded."""

cdp/protocol/tracing/service.py

@@ -0,0 +1,21 @@
+"""CDP Tracing Domain"""
+from typing import TYPE_CHECKING
+from .methods.service import TracingMethods
+from .events.service import TracingEvents
+
+if TYPE_CHECKING:
+    from ...service import Client
+
+class Tracing(TracingMethods, TracingEvents):
+    """
+    Access the Tracing domain.
+    """
+    def __init__(self, client: "Client"):
+        """
+        Initialize the Tracing domain.
+        
+        Args:
+            client ("Client"): The parent CDP client instance.
+        """
+        TracingMethods.__init__(self, client)
+        TracingEvents.__init__(self, client)

cdp/protocol/tracing/types.py

@@ -0,0 +1,34 @@
+"""CDP Tracing Types"""
+
+from typing import TypedDict, NotRequired, Required, Literal, Any, Dict, Union, Optional, List, Set, Tuple
+
+class MemoryDumpConfig(TypedDict, total=True):
+    """Configuration for memory dump. Used only when "memory-infra" category is enabled."""
+    pass
+class TraceConfig(TypedDict, total=False):
+    recordMode: NotRequired['Literal["recordUntilFull", "recordContinuously", "recordAsMuchAsPossible", "echoToConsole"]']
+    """Controls how the trace buffer stores data. The default is recordUntilFull."""
+    traceBufferSizeInKb: NotRequired['float']
+    """Size of the trace buffer in kilobytes. If not specified or zero is passed, a default value of 200 MB would be used."""
+    enableSampling: NotRequired['bool']
+    """Turns on JavaScript stack sampling."""
+    enableSystrace: NotRequired['bool']
+    """Turns on system tracing."""
+    enableArgumentFilter: NotRequired['bool']
+    """Turns on argument filter."""
+    includedCategories: NotRequired['List[str]']
+    """Included category filters."""
+    excludedCategories: NotRequired['List[str]']
+    """Excluded category filters."""
+    syntheticDelays: NotRequired['List[str]']
+    """Configuration to synthesize the delays in tracing."""
+    memoryDumpConfig: NotRequired['MemoryDumpConfig']
+    """Configuration for memory dump triggers. Used only when "memory-infra" category is enabled."""
+StreamFormat = Literal['json','proto']
+"""Data format of a trace. Can be either the legacy JSON format or the protocol buffer format. Note that the JSON format will be deprecated soon."""
+StreamCompression = Literal['none','gzip']
+"""Compression type to use for traces returned via streams."""
+MemoryDumpLevelOfDetail = Literal['background','light','detailed']
+"""Details exposed when memory request explicitly declared. Keep consistent with memory_dump_request_args.h and memory_instrumentation.mojom"""
+TracingBackend = Literal['auto','chrome','system']
+"""Backend type to use for tracing. `chrome` uses the Chrome-integrated tracing service and is supported on all platforms. `system` is only supported on Chrome OS and uses the Perfetto system tracing service. `auto` chooses `system` when the perfettoConfig provided to Tracing.start specifies at least one non-Chrome data source; otherwise uses `chrome`."""

cdp/protocol/web_audio/events/service.py

@@ -0,0 +1,125 @@
+"""CDP WebAudio 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 WebAudioEvents:
+    """
+    Events for the WebAudio domain.
+    """
+    def __init__(self, client: "Client"):
+        """
+        Initialize the WebAudio events.
+        
+        Args:
+            client ("Client"): The parent CDP client instance.
+        """
+        self.client = client
+
+    def on_context_created(self, callback: Callable[[contextCreatedEvent,Optional[str]], None]=None) -> None:
+        """
+    Notifies that a new BaseAudioContext has been created.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: contextCreatedEvent, session_id: Optional[str]).
+        """
+        self.client.on('WebAudio.contextCreated', callback)
+    def on_context_will_be_destroyed(self, callback: Callable[[contextWillBeDestroyedEvent,Optional[str]], None]=None) -> None:
+        """
+    Notifies that an existing BaseAudioContext will be destroyed.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: contextWillBeDestroyedEvent, session_id: Optional[str]).
+        """
+        self.client.on('WebAudio.contextWillBeDestroyed', callback)
+    def on_context_changed(self, callback: Callable[[contextChangedEvent,Optional[str]], None]=None) -> None:
+        """
+    Notifies that existing BaseAudioContext has changed some properties (id stays the same)..    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: contextChangedEvent, session_id: Optional[str]).
+        """
+        self.client.on('WebAudio.contextChanged', callback)
+    def on_audio_listener_created(self, callback: Callable[[audioListenerCreatedEvent,Optional[str]], None]=None) -> None:
+        """
+    Notifies that the construction of an AudioListener has finished.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: audioListenerCreatedEvent, session_id: Optional[str]).
+        """
+        self.client.on('WebAudio.audioListenerCreated', callback)
+    def on_audio_listener_will_be_destroyed(self, callback: Callable[[audioListenerWillBeDestroyedEvent,Optional[str]], None]=None) -> None:
+        """
+    Notifies that a new AudioListener has been created.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: audioListenerWillBeDestroyedEvent, session_id: Optional[str]).
+        """
+        self.client.on('WebAudio.audioListenerWillBeDestroyed', callback)
+    def on_audio_node_created(self, callback: Callable[[audioNodeCreatedEvent,Optional[str]], None]=None) -> None:
+        """
+    Notifies that a new AudioNode has been created.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: audioNodeCreatedEvent, session_id: Optional[str]).
+        """
+        self.client.on('WebAudio.audioNodeCreated', callback)
+    def on_audio_node_will_be_destroyed(self, callback: Callable[[audioNodeWillBeDestroyedEvent,Optional[str]], None]=None) -> None:
+        """
+    Notifies that an existing AudioNode has been destroyed.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: audioNodeWillBeDestroyedEvent, session_id: Optional[str]).
+        """
+        self.client.on('WebAudio.audioNodeWillBeDestroyed', callback)
+    def on_audio_param_created(self, callback: Callable[[audioParamCreatedEvent,Optional[str]], None]=None) -> None:
+        """
+    Notifies that a new AudioParam has been created.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: audioParamCreatedEvent, session_id: Optional[str]).
+        """
+        self.client.on('WebAudio.audioParamCreated', callback)
+    def on_audio_param_will_be_destroyed(self, callback: Callable[[audioParamWillBeDestroyedEvent,Optional[str]], None]=None) -> None:
+        """
+    Notifies that an existing AudioParam has been destroyed.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: audioParamWillBeDestroyedEvent, session_id: Optional[str]).
+        """
+        self.client.on('WebAudio.audioParamWillBeDestroyed', callback)
+    def on_nodes_connected(self, callback: Callable[[nodesConnectedEvent,Optional[str]], None]=None) -> None:
+        """
+    Notifies that two AudioNodes are connected.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: nodesConnectedEvent, session_id: Optional[str]).
+        """
+        self.client.on('WebAudio.nodesConnected', callback)
+    def on_nodes_disconnected(self, callback: Callable[[nodesDisconnectedEvent,Optional[str]], None]=None) -> None:
+        """
+    Notifies that AudioNodes are disconnected. The destination can be null, and it means all the outgoing connections from the source are disconnected.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: nodesDisconnectedEvent, session_id: Optional[str]).
+        """
+        self.client.on('WebAudio.nodesDisconnected', callback)
+    def on_node_param_connected(self, callback: Callable[[nodeParamConnectedEvent,Optional[str]], None]=None) -> None:
+        """
+    Notifies that an AudioNode is connected to an AudioParam.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: nodeParamConnectedEvent, session_id: Optional[str]).
+        """
+        self.client.on('WebAudio.nodeParamConnected', callback)
+    def on_node_param_disconnected(self, callback: Callable[[nodeParamDisconnectedEvent,Optional[str]], None]=None) -> None:
+        """
+    Notifies that an AudioNode is disconnected to an AudioParam.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: nodeParamDisconnectedEvent, session_id: Optional[str]).
+        """
+        self.client.on('WebAudio.nodeParamDisconnected', callback)

cdp/protocol/web_audio/events/types.py

@@ -0,0 +1,56 @@
+"""CDP WebAudio 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.web_audio.types import AudioListener
+    from cdp.protocol.web_audio.types import AudioNode
+    from cdp.protocol.web_audio.types import AudioParam
+    from cdp.protocol.web_audio.types import BaseAudioContext
+    from cdp.protocol.web_audio.types import GraphObjectId
+
+class contextCreatedEvent(TypedDict, total=True):
+    context: 'BaseAudioContext'
+class contextWillBeDestroyedEvent(TypedDict, total=True):
+    contextId: 'GraphObjectId'
+class contextChangedEvent(TypedDict, total=True):
+    context: 'BaseAudioContext'
+class audioListenerCreatedEvent(TypedDict, total=True):
+    listener: 'AudioListener'
+class audioListenerWillBeDestroyedEvent(TypedDict, total=True):
+    contextId: 'GraphObjectId'
+    listenerId: 'GraphObjectId'
+class audioNodeCreatedEvent(TypedDict, total=True):
+    node: 'AudioNode'
+class audioNodeWillBeDestroyedEvent(TypedDict, total=True):
+    contextId: 'GraphObjectId'
+    nodeId: 'GraphObjectId'
+class audioParamCreatedEvent(TypedDict, total=True):
+    param: 'AudioParam'
+class audioParamWillBeDestroyedEvent(TypedDict, total=True):
+    contextId: 'GraphObjectId'
+    nodeId: 'GraphObjectId'
+    paramId: 'GraphObjectId'
+class nodesConnectedEvent(TypedDict, total=True):
+    contextId: 'GraphObjectId'
+    sourceId: 'GraphObjectId'
+    destinationId: 'GraphObjectId'
+    sourceOutputIndex: NotRequired['float']
+    destinationInputIndex: NotRequired['float']
+class nodesDisconnectedEvent(TypedDict, total=True):
+    contextId: 'GraphObjectId'
+    sourceId: 'GraphObjectId'
+    destinationId: 'GraphObjectId'
+    sourceOutputIndex: NotRequired['float']
+    destinationInputIndex: NotRequired['float']
+class nodeParamConnectedEvent(TypedDict, total=True):
+    contextId: 'GraphObjectId'
+    sourceId: 'GraphObjectId'
+    destinationId: 'GraphObjectId'
+    sourceOutputIndex: NotRequired['float']
+class nodeParamDisconnectedEvent(TypedDict, total=True):
+    contextId: 'GraphObjectId'
+    sourceId: 'GraphObjectId'
+    destinationId: 'GraphObjectId'
+    sourceOutputIndex: NotRequired['float']

cdp/protocol/web_audio/methods/service.py

@@ -0,0 +1,54 @@
+"""CDP WebAudio 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 WebAudioMethods:
+    """
+    Methods for the WebAudio domain.
+    """
+    def __init__(self, client: "Client"):
+        """
+        Initialize the WebAudio methods.
+        
+        Args:
+            client ("Client"): The parent CDP client instance.
+        """
+        self.client = client
+
+    async def enable(self, params: None=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Enables the WebAudio domain and starts sending context lifetime events.    
+        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="WebAudio.enable", params=params,session_id=session_id)
+    async def disable(self, params: None=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Disables the WebAudio 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="WebAudio.disable", params=params,session_id=session_id)
+    async def get_realtime_data(self, params: Optional[getRealtimeDataParameters]=None,session_id: Optional[str] = None) -> getRealtimeDataReturns:
+        """
+    Fetch the realtime data from the registered contexts.    
+        Args:
+            params (getRealtimeDataParameters, optional): Parameters for the getRealtimeData method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    getRealtimeDataReturns: The result of the getRealtimeData call.
+        """
+        return await self.client.send(method="WebAudio.getRealtimeData", params=params,session_id=session_id)

cdp/protocol/web_audio/methods/types.py

@@ -0,0 +1,17 @@
+"""CDP WebAudio 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.web_audio.types import ContextRealtimeData
+    from cdp.protocol.web_audio.types import GraphObjectId
+
+
+
+class getRealtimeDataParameters(TypedDict, total=True):
+    contextId: 'GraphObjectId'
+
+
+class getRealtimeDataReturns(TypedDict):
+    realtimeData: 'ContextRealtimeData'

cdp/protocol/web_audio/service.py

@@ -0,0 +1,21 @@
+"""CDP WebAudio Domain"""
+from typing import TYPE_CHECKING
+from .methods.service import WebAudioMethods
+from .events.service import WebAudioEvents
+
+if TYPE_CHECKING:
+    from ...service import Client
+
+class WebAudio(WebAudioMethods, WebAudioEvents):
+    """
+    This domain allows inspection of Web Audio API. https://webaudio.github.io/web-audio-api/
+    """
+    def __init__(self, client: "Client"):
+        """
+        Initialize the WebAudio domain.
+        
+        Args:
+            client ("Client"): The parent CDP client instance.
+        """
+        WebAudioMethods.__init__(self, client)
+        WebAudioEvents.__init__(self, client)

cdp/protocol/web_audio/types.py

@@ -0,0 +1,66 @@
+"""CDP WebAudio Types"""
+
+from typing import TypedDict, NotRequired, Required, Literal, Any, Dict, Union, Optional, List, Set, Tuple
+
+GraphObjectId = str
+"""An unique ID for a graph object (AudioContext, AudioNode, AudioParam) in Web Audio API"""
+ContextType = Literal['realtime','offline']
+"""Enum of BaseAudioContext types"""
+ContextState = Literal['suspended','running','closed','interrupted']
+"""Enum of AudioContextState from the spec"""
+NodeType = str
+"""Enum of AudioNode types"""
+ChannelCountMode = Literal['clamped-max','explicit','max']
+"""Enum of AudioNode::ChannelCountMode from the spec"""
+ChannelInterpretation = Literal['discrete','speakers']
+"""Enum of AudioNode::ChannelInterpretation from the spec"""
+ParamType = str
+"""Enum of AudioParam types"""
+AutomationRate = Literal['a-rate','k-rate']
+"""Enum of AudioParam::AutomationRate from the spec"""
+class ContextRealtimeData(TypedDict, total=True):
+    """Fields in AudioContext that change in real-time."""
+    currentTime: 'float'
+    """The current context time in second in BaseAudioContext."""
+    renderCapacity: 'float'
+    """The time spent on rendering graph divided by render quantum duration, and multiplied by 100. 100 means the audio renderer reached the full capacity and glitch may occur."""
+    callbackIntervalMean: 'float'
+    """A running mean of callback interval."""
+    callbackIntervalVariance: 'float'
+    """A running variance of callback interval."""
+class BaseAudioContext(TypedDict, total=True):
+    """Protocol object for BaseAudioContext"""
+    contextId: 'GraphObjectId'
+    contextType: 'ContextType'
+    contextState: 'ContextState'
+    callbackBufferSize: 'float'
+    """Platform-dependent callback buffer size."""
+    maxOutputChannelCount: 'float'
+    """Number of output channels supported by audio hardware in use."""
+    sampleRate: 'float'
+    """Context sample rate."""
+    realtimeData: NotRequired['ContextRealtimeData']
+class AudioListener(TypedDict, total=True):
+    """Protocol object for AudioListener"""
+    listenerId: 'GraphObjectId'
+    contextId: 'GraphObjectId'
+class AudioNode(TypedDict, total=True):
+    """Protocol object for AudioNode"""
+    nodeId: 'GraphObjectId'
+    contextId: 'GraphObjectId'
+    nodeType: 'NodeType'
+    numberOfInputs: 'float'
+    numberOfOutputs: 'float'
+    channelCount: 'float'
+    channelCountMode: 'ChannelCountMode'
+    channelInterpretation: 'ChannelInterpretation'
+class AudioParam(TypedDict, total=True):
+    """Protocol object for AudioParam"""
+    paramId: 'GraphObjectId'
+    nodeId: 'GraphObjectId'
+    contextId: 'GraphObjectId'
+    paramType: 'ParamType'
+    rate: 'AutomationRate'
+    defaultValue: 'float'
+    minValue: 'float'
+    maxValue: 'float'

cdp/protocol/web_authn/events/service.py

@@ -0,0 +1,53 @@
+"""CDP WebAuthn 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 WebAuthnEvents:
+    """
+    Events for the WebAuthn domain.
+    """
+    def __init__(self, client: "Client"):
+        """
+        Initialize the WebAuthn events.
+        
+        Args:
+            client ("Client"): The parent CDP client instance.
+        """
+        self.client = client
+
+    def on_credential_added(self, callback: Callable[[credentialAddedEvent,Optional[str]], None]=None) -> None:
+        """
+    Triggered when a credential is added to an authenticator.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: credentialAddedEvent, session_id: Optional[str]).
+        """
+        self.client.on('WebAuthn.credentialAdded', callback)
+    def on_credential_deleted(self, callback: Callable[[credentialDeletedEvent,Optional[str]], None]=None) -> None:
+        """
+    Triggered when a credential is deleted, e.g. through PublicKeyCredential.signalUnknownCredential().    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: credentialDeletedEvent, session_id: Optional[str]).
+        """
+        self.client.on('WebAuthn.credentialDeleted', callback)
+    def on_credential_updated(self, callback: Callable[[credentialUpdatedEvent,Optional[str]], None]=None) -> None:
+        """
+    Triggered when a credential is updated, e.g. through PublicKeyCredential.signalCurrentUserDetails().    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: credentialUpdatedEvent, session_id: Optional[str]).
+        """
+        self.client.on('WebAuthn.credentialUpdated', callback)
+    def on_credential_asserted(self, callback: Callable[[credentialAssertedEvent,Optional[str]], None]=None) -> None:
+        """
+    Triggered when a credential is used in a webauthn assertion.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: credentialAssertedEvent, session_id: Optional[str]).
+        """
+        self.client.on('WebAuthn.credentialAsserted', callback)

cdp/protocol/web_authn/events/types.py

@@ -0,0 +1,21 @@
+"""CDP WebAuthn 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.web_authn.types import AuthenticatorId
+    from cdp.protocol.web_authn.types import Credential
+
+class credentialAddedEvent(TypedDict, total=True):
+    authenticatorId: 'AuthenticatorId'
+    credential: 'Credential'
+class credentialDeletedEvent(TypedDict, total=True):
+    authenticatorId: 'AuthenticatorId'
+    credentialId: 'str'
+class credentialUpdatedEvent(TypedDict, total=True):
+    authenticatorId: 'AuthenticatorId'
+    credential: 'Credential'
+class credentialAssertedEvent(TypedDict, total=True):
+    authenticatorId: 'AuthenticatorId'
+    credential: 'Credential'