parsek-cdp 0.1.0__py3-none-any.whl

parsek_cdp/cdp/tracing/events.py

@@ -0,0 +1,61 @@
+"""Events for the Tracing domain (generated)."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any, ClassVar, Dict, List, Literal, Optional
+
+from ..mixins.datatype import FieldMeta
+from ..mixins.event import Event, register_event
+
+if TYPE_CHECKING:
+    from .types import (
+        StreamCompression,
+        StreamFormat,
+    )
+    from ..io.types import StreamHandle as IO_StreamHandle
+
+@register_event("Tracing.bufferUsage")
+@dataclass
+class BufferUsage(Event):
+    percent_full: Optional[float] = None
+    event_count: Optional[float] = None
+    value: Optional[float] = None
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('percent_full', 'percentFull', True, 'primitive'),
+        FieldMeta('event_count', 'eventCount', True, 'primitive'),
+        FieldMeta('value', 'value', True, 'primitive'),
+    )
+
+
+@register_event("Tracing.dataCollected")
+@dataclass
+class DataCollected(Event):
+    """
+    Contains a bucket of collected trace events. When tracing is stopped collected events will be
+    sent as a sequence of dataCollected events followed by tracingComplete event.
+    """
+    value: List[Dict[str, Any]]
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('value', 'value', False, 'array', inner=FieldMeta('', '', False, 'primitive')),
+    )
+
+
+@register_event("Tracing.tracingComplete")
+@dataclass
+class TracingComplete(Event):
+    """
+    Signals that tracing is stopped and there is no trace buffers pending flush, all data were
+    delivered via dataCollected events.
+    """
+    data_loss_occurred: bool
+    stream: Optional[IO_StreamHandle] = None
+    trace_format: Optional[StreamFormat] = None
+    stream_compression: Optional[StreamCompression] = None
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('data_loss_occurred', 'dataLossOccurred', False, 'primitive'),
+        FieldMeta('stream', 'stream', True, 'primitive'),
+        FieldMeta('trace_format', 'traceFormat', True, 'enum', ref='Tracing.StreamFormat'),
+        FieldMeta('stream_compression', 'streamCompression', True, 'enum', ref='Tracing.StreamCompression'),
+    )
+
+__all__ = ["BufferUsage", "DataCollected", "TracingComplete"]

parsek_cdp/cdp/tracing/functions.py

@@ -0,0 +1,119 @@
+"""Commands for the Tracing domain (generated)."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any, ClassVar, Dict, List, Literal, Optional
+
+from ..mixins.datatype import DataType, FieldMeta, encode
+
+if TYPE_CHECKING:
+    from .types import (
+        MemoryDumpLevelOfDetail,
+        StreamCompression,
+        StreamFormat,
+        TraceConfig,
+        TracingBackend,
+    )
+
+@dataclass
+class GetCategoriesReturn(DataType):
+    """Return value of :meth:`Tracing.get_categories`."""
+    categories: List[str]
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('categories', 'categories', False, 'array', inner=FieldMeta('', '', False, 'primitive')),
+    )
+
+
+@dataclass
+class RequestMemoryDumpReturn(DataType):
+    """Return value of :meth:`Tracing.request_memory_dump`."""
+    dump_guid: str
+    success: bool
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('dump_guid', 'dumpGuid', False, 'primitive'),
+        FieldMeta('success', 'success', False, 'primitive'),
+    )
+
+
+class Tracing:
+    """Commands of the Tracing domain, bound to a target."""
+
+    def __init__(self, target: Any) -> None:
+        self._target = target
+
+
+    async def end(self) -> None:
+        """Stop trace events collection."""
+        _params: Dict[str, Any] = {}
+        _result = await self._target.send('Tracing.end', _params)
+        return None
+
+    async def get_categories(self) -> GetCategoriesReturn:
+        """Gets supported tracing categories."""
+        _params: Dict[str, Any] = {}
+        _result = await self._target.send('Tracing.getCategories', _params)
+        return GetCategoriesReturn.from_json(_result)
+
+    async def record_clock_sync_marker(self, *, sync_id: str) -> None:
+        """
+        Record a clock sync marker in the trace.
+        :param sync_id: The ID of this clock sync marker
+        """
+        _params: Dict[str, Any] = {}
+        _params['syncId'] = encode(FieldMeta('', '', False, 'primitive'), sync_id)
+        _result = await self._target.send('Tracing.recordClockSyncMarker', _params)
+        return None
+
+    async def request_memory_dump(self, *, deterministic: Optional[bool] = None, level_of_detail: Optional[MemoryDumpLevelOfDetail] = None) -> RequestMemoryDumpReturn:
+        """
+        Request a global memory dump.
+        :param deterministic: Enables more deterministic results by forcing garbage collection
+        :param level_of_detail: Specifies level of details in memory dump. Defaults to "detailed".
+        """
+        _params: Dict[str, Any] = {}
+        if deterministic is not None:
+            _params['deterministic'] = encode(FieldMeta('', '', False, 'primitive'), deterministic)
+        if level_of_detail is not None:
+            _params['levelOfDetail'] = encode(FieldMeta('', '', False, 'enum', ref='Tracing.MemoryDumpLevelOfDetail'), level_of_detail)
+        _result = await self._target.send('Tracing.requestMemoryDump', _params)
+        return RequestMemoryDumpReturn.from_json(_result)
+
+    async def start(self, *, categories: Optional[str] = None, options: Optional[str] = None, buffer_usage_reporting_interval: Optional[float] = None, transfer_mode: Optional[Literal['ReportEvents', 'ReturnAsStream']] = None, stream_format: Optional[StreamFormat] = None, stream_compression: Optional[StreamCompression] = None, trace_config: Optional[TraceConfig] = None, perfetto_config: Optional[str] = None, tracing_backend: Optional[TracingBackend] = None) -> None:
+        """
+        Start trace events collection.
+        :param categories: Category/tag filter
+        :param options: Tracing options
+        :param buffer_usage_reporting_interval: If set, the agent will issue bufferUsage events at this interval, specified in milliseconds
+        :param transfer_mode: Whether to report trace events as series of dataCollected events or to save trace to a
+        stream (defaults to `ReportEvents`).
+        :param stream_format: Trace data format to use. This only applies when using `ReturnAsStream`
+        transfer mode (defaults to `json`).
+        :param stream_compression: Compression format to use. This only applies when using `ReturnAsStream`
+        transfer mode (defaults to `none`)
+        :param trace_config:
+        :param perfetto_config: 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)
+        :param tracing_backend: Backend type (defaults to `auto`)
+        """
+        _params: Dict[str, Any] = {}
+        if categories is not None:
+            _params['categories'] = encode(FieldMeta('', '', False, 'primitive'), categories)
+        if options is not None:
+            _params['options'] = encode(FieldMeta('', '', False, 'primitive'), options)
+        if buffer_usage_reporting_interval is not None:
+            _params['bufferUsageReportingInterval'] = encode(FieldMeta('', '', False, 'primitive'), buffer_usage_reporting_interval)
+        if transfer_mode is not None:
+            _params['transferMode'] = encode(FieldMeta('', '', False, 'primitive'), transfer_mode)
+        if stream_format is not None:
+            _params['streamFormat'] = encode(FieldMeta('', '', False, 'enum', ref='Tracing.StreamFormat'), stream_format)
+        if stream_compression is not None:
+            _params['streamCompression'] = encode(FieldMeta('', '', False, 'enum', ref='Tracing.StreamCompression'), stream_compression)
+        if trace_config is not None:
+            _params['traceConfig'] = encode(FieldMeta('', '', False, 'object', ref='Tracing.TraceConfig'), trace_config)
+        if perfetto_config is not None:
+            _params['perfettoConfig'] = encode(FieldMeta('', '', False, 'primitive'), perfetto_config)
+        if tracing_backend is not None:
+            _params['tracingBackend'] = encode(FieldMeta('', '', False, 'enum', ref='Tracing.TracingBackend'), tracing_backend)
+        _result = await self._target.send('Tracing.start', _params)
+        return None

parsek_cdp/cdp/tracing/types.py

@@ -0,0 +1,81 @@
+"""Custom types and enums for the Tracing domain (generated)."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import Enum
+from typing import Any, ClassVar, Dict, List, Literal, Optional
+
+from ..mixins.datatype import DataType, FieldMeta, register
+
+
+type MemoryDumpConfig = Dict[str, Any]  # Configuration for memory dump. Used only when "memory-infra" category is enabled.
+
+
+@register("Tracing.TraceConfig")
+@dataclass
+class TraceConfig(DataType):
+    record_mode: Optional[Literal['recordUntilFull', 'recordContinuously', 'recordAsMuchAsPossible', 'echoToConsole']] = None
+    trace_buffer_size_in_kb: Optional[float] = None
+    enable_sampling: Optional[bool] = None
+    enable_systrace: Optional[bool] = None
+    enable_argument_filter: Optional[bool] = None
+    included_categories: Optional[List[str]] = None
+    excluded_categories: Optional[List[str]] = None
+    synthetic_delays: Optional[List[str]] = None
+    memory_dump_config: Optional[MemoryDumpConfig] = None
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('record_mode', 'recordMode', True, 'primitive'),
+        FieldMeta('trace_buffer_size_in_kb', 'traceBufferSizeInKb', True, 'primitive'),
+        FieldMeta('enable_sampling', 'enableSampling', True, 'primitive'),
+        FieldMeta('enable_systrace', 'enableSystrace', True, 'primitive'),
+        FieldMeta('enable_argument_filter', 'enableArgumentFilter', True, 'primitive'),
+        FieldMeta('included_categories', 'includedCategories', True, 'array', inner=FieldMeta('', '', False, 'primitive')),
+        FieldMeta('excluded_categories', 'excludedCategories', True, 'array', inner=FieldMeta('', '', False, 'primitive')),
+        FieldMeta('synthetic_delays', 'syntheticDelays', True, 'array', inner=FieldMeta('', '', False, 'primitive')),
+        FieldMeta('memory_dump_config', 'memoryDumpConfig', True, 'primitive'),
+    )
+
+
+@register("Tracing.StreamFormat")
+class StreamFormat(str, Enum):
+    """
+    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.
+    """
+    JSON = 'json'
+    PROTO = 'proto'
+
+
+@register("Tracing.StreamCompression")
+class StreamCompression(str, Enum):
+    """Compression type to use for traces returned via streams."""
+    NONE = 'none'
+    GZIP = 'gzip'
+
+
+@register("Tracing.MemoryDumpLevelOfDetail")
+class MemoryDumpLevelOfDetail(str, Enum):
+    """
+    Details exposed when memory request explicitly declared.
+    Keep consistent with memory_dump_request_args.h and
+    memory_instrumentation.mojom
+    """
+    BACKGROUND = 'background'
+    LIGHT = 'light'
+    DETAILED = 'detailed'
+
+
+@register("Tracing.TracingBackend")
+class TracingBackend(str, Enum):
+    """
+    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`.
+    """
+    AUTO = 'auto'
+    CHROME = 'chrome'
+    SYSTEM = 'system'
+
+__all__ = ["MemoryDumpConfig", "MemoryDumpLevelOfDetail", "StreamCompression", "StreamFormat", "TraceConfig", "TracingBackend"]

parsek_cdp/cdp/webaudio/__init__.py

@@ -0,0 +1,15 @@
+"""The WebAudio CDP domain (generated).
+
+Importing ``WebAudio`` from ``parsek_cdp.cdp`` gives a namespace with this
+domain's events and types as attributes (``WebAudio.SomeEvent`` /
+``WebAudio.SomeType``); commands run on a target via ``page.cdp.WebAudio``.
+"""
+from . import events, functions, types
+from .functions import WebAudio
+from .events import *  # noqa: F401,F403 -- expose events on the namespace
+from .types import *  # noqa: F401,F403 -- expose types on the namespace
+
+#: Protocol domain name (used by features that declare ``domains=(WebAudio,)``).
+DOMAIN = "WebAudio"
+
+__all__ = ["events", "functions", "types", "WebAudio", "DOMAIN"]

parsek_cdp/cdp/webaudio/events.py

@@ -0,0 +1,184 @@
+"""Events for the WebAudio domain (generated)."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any, ClassVar, Dict, List, Literal, Optional
+
+from ..mixins.datatype import FieldMeta
+from ..mixins.event import Event, register_event
+
+if TYPE_CHECKING:
+    from .types import (
+        AudioListener,
+        AudioNode,
+        AudioParam,
+        BaseAudioContext,
+        GraphObjectId,
+    )
+
+@register_event("WebAudio.contextCreated")
+@dataclass
+class ContextCreated(Event):
+    """Notifies that a new BaseAudioContext has been created."""
+    context: BaseAudioContext
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('context', 'context', False, 'object', ref='WebAudio.BaseAudioContext'),
+    )
+
+
+@register_event("WebAudio.contextWillBeDestroyed")
+@dataclass
+class ContextWillBeDestroyed(Event):
+    """Notifies that an existing BaseAudioContext will be destroyed."""
+    context_id: GraphObjectId
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('context_id', 'contextId', False, 'primitive'),
+    )
+
+
+@register_event("WebAudio.contextChanged")
+@dataclass
+class ContextChanged(Event):
+    """Notifies that existing BaseAudioContext has changed some properties (id stays the same).."""
+    context: BaseAudioContext
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('context', 'context', False, 'object', ref='WebAudio.BaseAudioContext'),
+    )
+
+
+@register_event("WebAudio.audioListenerCreated")
+@dataclass
+class AudioListenerCreated(Event):
+    """Notifies that the construction of an AudioListener has finished."""
+    listener: AudioListener
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('listener', 'listener', False, 'object', ref='WebAudio.AudioListener'),
+    )
+
+
+@register_event("WebAudio.audioListenerWillBeDestroyed")
+@dataclass
+class AudioListenerWillBeDestroyed(Event):
+    """Notifies that a new AudioListener has been created."""
+    context_id: GraphObjectId
+    listener_id: GraphObjectId
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('context_id', 'contextId', False, 'primitive'),
+        FieldMeta('listener_id', 'listenerId', False, 'primitive'),
+    )
+
+
+@register_event("WebAudio.audioNodeCreated")
+@dataclass
+class AudioNodeCreated(Event):
+    """Notifies that a new AudioNode has been created."""
+    node: AudioNode
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('node', 'node', False, 'object', ref='WebAudio.AudioNode'),
+    )
+
+
+@register_event("WebAudio.audioNodeWillBeDestroyed")
+@dataclass
+class AudioNodeWillBeDestroyed(Event):
+    """Notifies that an existing AudioNode has been destroyed."""
+    context_id: GraphObjectId
+    node_id: GraphObjectId
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('context_id', 'contextId', False, 'primitive'),
+        FieldMeta('node_id', 'nodeId', False, 'primitive'),
+    )
+
+
+@register_event("WebAudio.audioParamCreated")
+@dataclass
+class AudioParamCreated(Event):
+    """Notifies that a new AudioParam has been created."""
+    param: AudioParam
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('param', 'param', False, 'object', ref='WebAudio.AudioParam'),
+    )
+
+
+@register_event("WebAudio.audioParamWillBeDestroyed")
+@dataclass
+class AudioParamWillBeDestroyed(Event):
+    """Notifies that an existing AudioParam has been destroyed."""
+    context_id: GraphObjectId
+    node_id: GraphObjectId
+    param_id: GraphObjectId
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('context_id', 'contextId', False, 'primitive'),
+        FieldMeta('node_id', 'nodeId', False, 'primitive'),
+        FieldMeta('param_id', 'paramId', False, 'primitive'),
+    )
+
+
+@register_event("WebAudio.nodesConnected")
+@dataclass
+class NodesConnected(Event):
+    """Notifies that two AudioNodes are connected."""
+    context_id: GraphObjectId
+    source_id: GraphObjectId
+    destination_id: GraphObjectId
+    source_output_index: Optional[float] = None
+    destination_input_index: Optional[float] = None
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('context_id', 'contextId', False, 'primitive'),
+        FieldMeta('source_id', 'sourceId', False, 'primitive'),
+        FieldMeta('destination_id', 'destinationId', False, 'primitive'),
+        FieldMeta('source_output_index', 'sourceOutputIndex', True, 'primitive'),
+        FieldMeta('destination_input_index', 'destinationInputIndex', True, 'primitive'),
+    )
+
+
+@register_event("WebAudio.nodesDisconnected")
+@dataclass
+class NodesDisconnected(Event):
+    """Notifies that AudioNodes are disconnected. The destination can be null, and it means all the outgoing connections from the source are disconnected."""
+    context_id: GraphObjectId
+    source_id: GraphObjectId
+    destination_id: GraphObjectId
+    source_output_index: Optional[float] = None
+    destination_input_index: Optional[float] = None
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('context_id', 'contextId', False, 'primitive'),
+        FieldMeta('source_id', 'sourceId', False, 'primitive'),
+        FieldMeta('destination_id', 'destinationId', False, 'primitive'),
+        FieldMeta('source_output_index', 'sourceOutputIndex', True, 'primitive'),
+        FieldMeta('destination_input_index', 'destinationInputIndex', True, 'primitive'),
+    )
+
+
+@register_event("WebAudio.nodeParamConnected")
+@dataclass
+class NodeParamConnected(Event):
+    """Notifies that an AudioNode is connected to an AudioParam."""
+    context_id: GraphObjectId
+    source_id: GraphObjectId
+    destination_id: GraphObjectId
+    source_output_index: Optional[float] = None
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('context_id', 'contextId', False, 'primitive'),
+        FieldMeta('source_id', 'sourceId', False, 'primitive'),
+        FieldMeta('destination_id', 'destinationId', False, 'primitive'),
+        FieldMeta('source_output_index', 'sourceOutputIndex', True, 'primitive'),
+    )
+
+
+@register_event("WebAudio.nodeParamDisconnected")
+@dataclass
+class NodeParamDisconnected(Event):
+    """Notifies that an AudioNode is disconnected to an AudioParam."""
+    context_id: GraphObjectId
+    source_id: GraphObjectId
+    destination_id: GraphObjectId
+    source_output_index: Optional[float] = None
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('context_id', 'contextId', False, 'primitive'),
+        FieldMeta('source_id', 'sourceId', False, 'primitive'),
+        FieldMeta('destination_id', 'destinationId', False, 'primitive'),
+        FieldMeta('source_output_index', 'sourceOutputIndex', True, 'primitive'),
+    )
+
+__all__ = ["AudioListenerCreated", "AudioListenerWillBeDestroyed", "AudioNodeCreated", "AudioNodeWillBeDestroyed", "AudioParamCreated", "AudioParamWillBeDestroyed", "ContextChanged", "ContextCreated", "ContextWillBeDestroyed", "NodeParamConnected", "NodeParamDisconnected", "NodesConnected", "NodesDisconnected"]

parsek_cdp/cdp/webaudio/functions.py

@@ -0,0 +1,51 @@
+"""Commands for the WebAudio domain (generated)."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any, ClassVar, Dict, List, Literal, Optional
+
+from ..mixins.datatype import DataType, FieldMeta, encode
+
+if TYPE_CHECKING:
+    from .types import (
+        ContextRealtimeData,
+        GraphObjectId,
+    )
+
+@dataclass
+class GetRealtimeDataReturn(DataType):
+    """Return value of :meth:`WebAudio.get_realtime_data`."""
+    realtime_data: ContextRealtimeData
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('realtime_data', 'realtimeData', False, 'object', ref='WebAudio.ContextRealtimeData'),
+    )
+
+
+class WebAudio:
+    """Commands of the WebAudio domain, bound to a target."""
+
+    def __init__(self, target: Any) -> None:
+        self._target = target
+
+
+    async def enable(self) -> None:
+        """Enables the WebAudio domain and starts sending context lifetime events."""
+        _params: Dict[str, Any] = {}
+        _result = await self._target.send('WebAudio.enable', _params)
+        return None
+
+    async def disable(self) -> None:
+        """Disables the WebAudio domain."""
+        _params: Dict[str, Any] = {}
+        _result = await self._target.send('WebAudio.disable', _params)
+        return None
+
+    async def get_realtime_data(self, *, context_id: GraphObjectId) -> GetRealtimeDataReturn:
+        """
+        Fetch the realtime data from the registered contexts.
+        :param context_id:
+        """
+        _params: Dict[str, Any] = {}
+        _params['contextId'] = encode(FieldMeta('', '', False, 'primitive'), context_id)
+        _result = await self._target.send('WebAudio.getRealtimeData', _params)
+        return GetRealtimeDataReturn.from_json(_result)

parsek_cdp/cdp/webaudio/types.py

@@ -0,0 +1,155 @@
+"""Custom types and enums for the WebAudio domain (generated)."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import Enum
+from typing import Any, ClassVar, Dict, List, Literal, Optional
+
+from ..mixins.datatype import DataType, FieldMeta, register
+
+
+type GraphObjectId = str  # An unique ID for a graph object (AudioContext, AudioNode, AudioParam) in Web Audio API
+
+
+@register("WebAudio.ContextType")
+class ContextType(str, Enum):
+    """Enum of BaseAudioContext types"""
+    REALTIME = 'realtime'
+    OFFLINE = 'offline'
+
+
+@register("WebAudio.ContextState")
+class ContextState(str, Enum):
+    """Enum of AudioContextState from the spec"""
+    SUSPENDED = 'suspended'
+    RUNNING = 'running'
+    CLOSED = 'closed'
+    INTERRUPTED = 'interrupted'
+
+
+type NodeType = str  # Enum of AudioNode types
+
+
+@register("WebAudio.ChannelCountMode")
+class ChannelCountMode(str, Enum):
+    """Enum of AudioNode::ChannelCountMode from the spec"""
+    CLAMPED_MAX = 'clamped-max'
+    EXPLICIT = 'explicit'
+    MAX = 'max'
+
+
+@register("WebAudio.ChannelInterpretation")
+class ChannelInterpretation(str, Enum):
+    """Enum of AudioNode::ChannelInterpretation from the spec"""
+    DISCRETE = 'discrete'
+    SPEAKERS = 'speakers'
+
+
+type ParamType = str  # Enum of AudioParam types
+
+
+@register("WebAudio.AutomationRate")
+class AutomationRate(str, Enum):
+    """Enum of AudioParam::AutomationRate from the spec"""
+    A_RATE = 'a-rate'
+    K_RATE = 'k-rate'
+
+
+@register("WebAudio.ContextRealtimeData")
+@dataclass
+class ContextRealtimeData(DataType):
+    """Fields in AudioContext that change in real-time."""
+    current_time: float
+    render_capacity: float
+    callback_interval_mean: float
+    callback_interval_variance: float
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('current_time', 'currentTime', False, 'primitive'),
+        FieldMeta('render_capacity', 'renderCapacity', False, 'primitive'),
+        FieldMeta('callback_interval_mean', 'callbackIntervalMean', False, 'primitive'),
+        FieldMeta('callback_interval_variance', 'callbackIntervalVariance', False, 'primitive'),
+    )
+
+
+@register("WebAudio.BaseAudioContext")
+@dataclass
+class BaseAudioContext(DataType):
+    """Protocol object for BaseAudioContext"""
+    context_id: GraphObjectId
+    context_type: ContextType
+    context_state: ContextState
+    callback_buffer_size: float
+    max_output_channel_count: float
+    sample_rate: float
+    realtime_data: Optional[ContextRealtimeData] = None
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('context_id', 'contextId', False, 'primitive'),
+        FieldMeta('context_type', 'contextType', False, 'enum', ref='WebAudio.ContextType'),
+        FieldMeta('context_state', 'contextState', False, 'enum', ref='WebAudio.ContextState'),
+        FieldMeta('callback_buffer_size', 'callbackBufferSize', False, 'primitive'),
+        FieldMeta('max_output_channel_count', 'maxOutputChannelCount', False, 'primitive'),
+        FieldMeta('sample_rate', 'sampleRate', False, 'primitive'),
+        FieldMeta('realtime_data', 'realtimeData', True, 'object', ref='WebAudio.ContextRealtimeData'),
+    )
+
+
+@register("WebAudio.AudioListener")
+@dataclass
+class AudioListener(DataType):
+    """Protocol object for AudioListener"""
+    listener_id: GraphObjectId
+    context_id: GraphObjectId
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('listener_id', 'listenerId', False, 'primitive'),
+        FieldMeta('context_id', 'contextId', False, 'primitive'),
+    )
+
+
+@register("WebAudio.AudioNode")
+@dataclass
+class AudioNode(DataType):
+    """Protocol object for AudioNode"""
+    node_id: GraphObjectId
+    context_id: GraphObjectId
+    node_type: NodeType
+    number_of_inputs: float
+    number_of_outputs: float
+    channel_count: float
+    channel_count_mode: ChannelCountMode
+    channel_interpretation: ChannelInterpretation
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('node_id', 'nodeId', False, 'primitive'),
+        FieldMeta('context_id', 'contextId', False, 'primitive'),
+        FieldMeta('node_type', 'nodeType', False, 'primitive'),
+        FieldMeta('number_of_inputs', 'numberOfInputs', False, 'primitive'),
+        FieldMeta('number_of_outputs', 'numberOfOutputs', False, 'primitive'),
+        FieldMeta('channel_count', 'channelCount', False, 'primitive'),
+        FieldMeta('channel_count_mode', 'channelCountMode', False, 'enum', ref='WebAudio.ChannelCountMode'),
+        FieldMeta('channel_interpretation', 'channelInterpretation', False, 'enum', ref='WebAudio.ChannelInterpretation'),
+    )
+
+
+@register("WebAudio.AudioParam")
+@dataclass
+class AudioParam(DataType):
+    """Protocol object for AudioParam"""
+    param_id: GraphObjectId
+    node_id: GraphObjectId
+    context_id: GraphObjectId
+    param_type: ParamType
+    rate: AutomationRate
+    default_value: float
+    min_value: float
+    max_value: float
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('param_id', 'paramId', False, 'primitive'),
+        FieldMeta('node_id', 'nodeId', False, 'primitive'),
+        FieldMeta('context_id', 'contextId', False, 'primitive'),
+        FieldMeta('param_type', 'paramType', False, 'primitive'),
+        FieldMeta('rate', 'rate', False, 'enum', ref='WebAudio.AutomationRate'),
+        FieldMeta('default_value', 'defaultValue', False, 'primitive'),
+        FieldMeta('min_value', 'minValue', False, 'primitive'),
+        FieldMeta('max_value', 'maxValue', False, 'primitive'),
+    )
+
+__all__ = ["AudioListener", "AudioNode", "AudioParam", "AutomationRate", "BaseAudioContext", "ChannelCountMode", "ChannelInterpretation", "ContextRealtimeData", "ContextState", "ContextType", "GraphObjectId", "NodeType", "ParamType"]