chromedeveloperprotocol-client 0.1.0__py3-none-any.whl

cdp/protocol/storage/types.py

@@ -0,0 +1,236 @@
+"""CDP Storage 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.target.types import TargetID
+
+SerializedStorageKey = str
+StorageType = Literal['cookies','file_systems','indexeddb','local_storage','shader_cache','websql','service_workers','cache_storage','interest_groups','shared_storage','storage_buckets','all','other']
+"""Enum of possible storage types."""
+class UsageForType(TypedDict, total=True):
+    """Usage for a storage type."""
+    storageType: 'StorageType'
+    """Name of storage type."""
+    usage: 'float'
+    """Storage usage (bytes)."""
+class TrustTokens(TypedDict, total=True):
+    """Pair of issuer origin and number of available (signed, but not used) Trust Tokens from that issuer."""
+    issuerOrigin: 'str'
+    count: 'float'
+InterestGroupAuctionId = str
+"""Protected audience interest group auction identifier."""
+InterestGroupAccessType = Literal['join','leave','update','loaded','bid','win','additionalBid','additionalBidWin','topLevelBid','topLevelAdditionalBid','clear']
+"""Enum of interest group access types."""
+InterestGroupAuctionEventType = Literal['started','configResolved']
+"""Enum of auction events."""
+InterestGroupAuctionFetchType = Literal['bidderJs','bidderWasm','sellerJs','bidderTrustedSignals','sellerTrustedSignals']
+"""Enum of network fetches auctions can do."""
+SharedStorageAccessScope = Literal['window','sharedStorageWorklet','protectedAudienceWorklet','header']
+"""Enum of shared storage access scopes."""
+SharedStorageAccessMethod = Literal['addModule','createWorklet','selectURL','run','batchUpdate','set','append','delete','clear','get','keys','values','entries','length','remainingBudget']
+"""Enum of shared storage access methods."""
+class SharedStorageEntry(TypedDict, total=True):
+    """Struct for a single key-value pair in an origin's shared storage."""
+    key: 'str'
+    value: 'str'
+class SharedStorageMetadata(TypedDict, total=True):
+    """Details for an origin's shared storage."""
+    creationTime: 'TimeSinceEpoch'
+    """Time when the origin's shared storage was last created."""
+    length: 'int'
+    """Number of key-value pairs stored in origin's shared storage."""
+    remainingBudget: 'float'
+    """Current amount of bits of entropy remaining in the navigation budget."""
+    bytesUsed: 'int'
+    """Total number of bytes stored as key-value pairs in origin's shared storage."""
+class SharedStoragePrivateAggregationConfig(TypedDict, total=True):
+    """Represents a dictionary object passed in as privateAggregationConfig to run or selectURL."""
+    filteringIdMaxBytes: 'int'
+    """Configures the maximum size allowed for filtering IDs."""
+    aggregationCoordinatorOrigin: NotRequired['str']
+    """The chosen aggregation service deployment."""
+    contextId: NotRequired['str']
+    """The context ID provided."""
+    maxContributions: NotRequired['int']
+    """The limit on the number of contributions in the final report."""
+class SharedStorageReportingMetadata(TypedDict, total=True):
+    """Pair of reporting metadata details for a candidate URL for selectURL()."""
+    eventType: 'str'
+    reportingUrl: 'str'
+class SharedStorageUrlWithMetadata(TypedDict, total=True):
+    """Bundles a candidate URL with its reporting metadata."""
+    url: 'str'
+    """Spec of candidate URL."""
+    reportingMetadata: 'List[SharedStorageReportingMetadata]'
+    """Any associated reporting metadata."""
+class SharedStorageAccessParams(TypedDict, total=False):
+    """Bundles the parameters for shared storage access events whose presence/absence can vary according to SharedStorageAccessType."""
+    scriptSourceUrl: NotRequired['str']
+    """Spec of the module script URL. Present only for SharedStorageAccessMethods: addModule and createWorklet."""
+    dataOrigin: NotRequired['str']
+    """String denoting "context-origin", "script-origin", or a custom origin to be used as the worklet's data origin. Present only for SharedStorageAccessMethod: createWorklet."""
+    operationName: NotRequired['str']
+    """Name of the registered operation to be run. Present only for SharedStorageAccessMethods: run and selectURL."""
+    operationId: NotRequired['str']
+    """ID of the operation call. Present only for SharedStorageAccessMethods: run and selectURL."""
+    keepAlive: NotRequired['bool']
+    """Whether or not to keep the worket alive for future run or selectURL calls. Present only for SharedStorageAccessMethods: run and selectURL."""
+    privateAggregationConfig: NotRequired['SharedStoragePrivateAggregationConfig']
+    """Configures the private aggregation options. Present only for SharedStorageAccessMethods: run and selectURL."""
+    serializedData: NotRequired['str']
+    """The operation's serialized data in bytes (converted to a string). Present only for SharedStorageAccessMethods: run and selectURL. TODO(crbug.com/401011862): Consider updating this parameter to binary."""
+    urlsWithMetadata: NotRequired['List[SharedStorageUrlWithMetadata]']
+    """Array of candidate URLs' specs, along with any associated metadata. Present only for SharedStorageAccessMethod: selectURL."""
+    urnUuid: NotRequired['str']
+    """Spec of the URN:UUID generated for a selectURL call. Present only for SharedStorageAccessMethod: selectURL."""
+    key: NotRequired['str']
+    """Key for a specific entry in an origin's shared storage. Present only for SharedStorageAccessMethods: set, append, delete, and get."""
+    value: NotRequired['str']
+    """Value for a specific entry in an origin's shared storage. Present only for SharedStorageAccessMethods: set and append."""
+    ignoreIfPresent: NotRequired['bool']
+    """Whether or not to set an entry for a key if that key is already present. Present only for SharedStorageAccessMethod: set."""
+    workletOrdinal: NotRequired['int']
+    """A number denoting the (0-based) order of the worklet's creation relative to all other shared storage worklets created by documents using the current storage partition. Present only for SharedStorageAccessMethods: addModule, createWorklet."""
+    workletTargetId: NotRequired['TargetID']
+    """Hex representation of the DevTools token used as the TargetID for the associated shared storage worklet. Present only for SharedStorageAccessMethods: addModule, createWorklet, run, selectURL, and any other SharedStorageAccessMethod when the SharedStorageAccessScope is sharedStorageWorklet."""
+    withLock: NotRequired['str']
+    """Name of the lock to be acquired, if present. Optionally present only for SharedStorageAccessMethods: batchUpdate, set, append, delete, and clear."""
+    batchUpdateId: NotRequired['str']
+    """If the method has been called as part of a batchUpdate, then this number identifies the batch to which it belongs. Optionally present only for SharedStorageAccessMethods: batchUpdate (required), set, append, delete, and clear."""
+    batchSize: NotRequired['int']
+    """Number of modifier methods sent in batch. Present only for SharedStorageAccessMethod: batchUpdate."""
+StorageBucketsDurability = Literal['relaxed','strict']
+class StorageBucket(TypedDict, total=True):
+    storageKey: 'SerializedStorageKey'
+    name: NotRequired['str']
+    """If not specified, it is the default bucket of the storageKey."""
+class StorageBucketInfo(TypedDict, total=True):
+    bucket: 'StorageBucket'
+    id: 'str'
+    expiration: 'TimeSinceEpoch'
+    quota: 'float'
+    """Storage quota (bytes)."""
+    persistent: 'bool'
+    durability: 'StorageBucketsDurability'
+AttributionReportingSourceType = Literal['navigation','event']
+UnsignedInt64AsBase10 = str
+UnsignedInt128AsBase16 = str
+SignedInt64AsBase10 = str
+class AttributionReportingFilterDataEntry(TypedDict, total=True):
+    key: 'str'
+    values: 'List[str]'
+class AttributionReportingFilterConfig(TypedDict, total=True):
+    filterValues: 'List[AttributionReportingFilterDataEntry]'
+    lookbackWindow: NotRequired['int']
+    """duration in seconds"""
+class AttributionReportingFilterPair(TypedDict, total=True):
+    filters: 'List[AttributionReportingFilterConfig]'
+    notFilters: 'List[AttributionReportingFilterConfig]'
+class AttributionReportingAggregationKeysEntry(TypedDict, total=True):
+    key: 'str'
+    value: 'UnsignedInt128AsBase16'
+class AttributionReportingEventReportWindows(TypedDict, total=True):
+    start: 'int'
+    """duration in seconds"""
+    ends: 'List[int]'
+    """duration in seconds"""
+AttributionReportingTriggerDataMatching = Literal['exact','modulus']
+class AttributionReportingAggregatableDebugReportingData(TypedDict, total=True):
+    keyPiece: 'UnsignedInt128AsBase16'
+    value: 'float'
+    """number instead of integer because not all uint32 can be represented by int"""
+    types: 'List[str]'
+class AttributionReportingAggregatableDebugReportingConfig(TypedDict, total=True):
+    keyPiece: 'UnsignedInt128AsBase16'
+    debugData: 'List[AttributionReportingAggregatableDebugReportingData]'
+    budget: NotRequired['float']
+    """number instead of integer because not all uint32 can be represented by int, only present for source registrations"""
+    aggregationCoordinatorOrigin: NotRequired['str']
+class AttributionScopesData(TypedDict, total=True):
+    values: 'List[str]'
+    limit: 'float'
+    """number instead of integer because not all uint32 can be represented by int"""
+    maxEventStates: 'float'
+class AttributionReportingNamedBudgetDef(TypedDict, total=True):
+    name: 'str'
+    budget: 'int'
+class AttributionReportingSourceRegistration(TypedDict, total=True):
+    time: 'TimeSinceEpoch'
+    expiry: 'int'
+    """duration in seconds"""
+    triggerData: 'List[float]'
+    """number instead of integer because not all uint32 can be represented by int"""
+    eventReportWindows: 'AttributionReportingEventReportWindows'
+    aggregatableReportWindow: 'int'
+    """duration in seconds"""
+    type: 'AttributionReportingSourceType'
+    sourceOrigin: 'str'
+    reportingOrigin: 'str'
+    destinationSites: 'List[str]'
+    eventId: 'UnsignedInt64AsBase10'
+    priority: 'SignedInt64AsBase10'
+    filterData: 'List[AttributionReportingFilterDataEntry]'
+    aggregationKeys: 'List[AttributionReportingAggregationKeysEntry]'
+    triggerDataMatching: 'AttributionReportingTriggerDataMatching'
+    destinationLimitPriority: 'SignedInt64AsBase10'
+    aggregatableDebugReportingConfig: 'AttributionReportingAggregatableDebugReportingConfig'
+    maxEventLevelReports: 'int'
+    namedBudgets: 'List[AttributionReportingNamedBudgetDef]'
+    debugReporting: 'bool'
+    eventLevelEpsilon: 'float'
+    debugKey: NotRequired['UnsignedInt64AsBase10']
+    scopesData: NotRequired['AttributionScopesData']
+AttributionReportingSourceRegistrationResult = Literal['success','internalError','insufficientSourceCapacity','insufficientUniqueDestinationCapacity','excessiveReportingOrigins','prohibitedByBrowserPolicy','successNoised','destinationReportingLimitReached','destinationGlobalLimitReached','destinationBothLimitsReached','reportingOriginsPerSiteLimitReached','exceedsMaxChannelCapacity','exceedsMaxScopesChannelCapacity','exceedsMaxTriggerStateCardinality','exceedsMaxEventStatesLimit','destinationPerDayReportingLimitReached']
+AttributionReportingSourceRegistrationTimeConfig = Literal['include','exclude']
+class AttributionReportingAggregatableValueDictEntry(TypedDict, total=True):
+    key: 'str'
+    value: 'float'
+    """number instead of integer because not all uint32 can be represented by int"""
+    filteringId: 'UnsignedInt64AsBase10'
+class AttributionReportingAggregatableValueEntry(TypedDict, total=True):
+    values: 'List[AttributionReportingAggregatableValueDictEntry]'
+    filters: 'AttributionReportingFilterPair'
+class AttributionReportingEventTriggerData(TypedDict, total=True):
+    data: 'UnsignedInt64AsBase10'
+    priority: 'SignedInt64AsBase10'
+    filters: 'AttributionReportingFilterPair'
+    dedupKey: NotRequired['UnsignedInt64AsBase10']
+class AttributionReportingAggregatableTriggerData(TypedDict, total=True):
+    keyPiece: 'UnsignedInt128AsBase16'
+    sourceKeys: 'List[str]'
+    filters: 'AttributionReportingFilterPair'
+class AttributionReportingAggregatableDedupKey(TypedDict, total=True):
+    filters: 'AttributionReportingFilterPair'
+    dedupKey: NotRequired['UnsignedInt64AsBase10']
+class AttributionReportingNamedBudgetCandidate(TypedDict, total=True):
+    filters: 'AttributionReportingFilterPair'
+    name: NotRequired['str']
+class AttributionReportingTriggerRegistration(TypedDict, total=True):
+    filters: 'AttributionReportingFilterPair'
+    aggregatableDedupKeys: 'List[AttributionReportingAggregatableDedupKey]'
+    eventTriggerData: 'List[AttributionReportingEventTriggerData]'
+    aggregatableTriggerData: 'List[AttributionReportingAggregatableTriggerData]'
+    aggregatableValues: 'List[AttributionReportingAggregatableValueEntry]'
+    aggregatableFilteringIdMaxBytes: 'int'
+    debugReporting: 'bool'
+    sourceRegistrationTimeConfig: 'AttributionReportingSourceRegistrationTimeConfig'
+    aggregatableDebugReportingConfig: 'AttributionReportingAggregatableDebugReportingConfig'
+    scopes: 'List[str]'
+    namedBudgets: 'List[AttributionReportingNamedBudgetCandidate]'
+    debugKey: NotRequired['UnsignedInt64AsBase10']
+    aggregationCoordinatorOrigin: NotRequired['str']
+    triggerContextId: NotRequired['str']
+AttributionReportingEventLevelResult = Literal['success','successDroppedLowerPriority','internalError','noCapacityForAttributionDestination','noMatchingSources','deduplicated','excessiveAttributions','priorityTooLow','neverAttributedSource','excessiveReportingOrigins','noMatchingSourceFilterData','prohibitedByBrowserPolicy','noMatchingConfigurations','excessiveReports','falselyAttributedSource','reportWindowPassed','notRegistered','reportWindowNotStarted','noMatchingTriggerData']
+AttributionReportingAggregatableResult = Literal['success','internalError','noCapacityForAttributionDestination','noMatchingSources','excessiveAttributions','excessiveReportingOrigins','noHistograms','insufficientBudget','insufficientNamedBudget','noMatchingSourceFilterData','notRegistered','prohibitedByBrowserPolicy','deduplicated','reportWindowPassed','excessiveReports']
+AttributionReportingReportResult = Literal['sent','prohibited','failedToAssemble','expired']
+class RelatedWebsiteSet(TypedDict, total=True):
+    """A single Related Website Set object."""
+    primarySites: 'List[str]'
+    """The primary site of this set, along with the ccTLDs if there is any."""
+    associatedSites: 'List[str]'
+    """The associated sites of this set, along with the ccTLDs if there is any."""
+    serviceSites: 'List[str]'
+    """The service sites of this set, along with the ccTLDs if there is any."""

cdp/protocol/system_info/events/service.py

@@ -0,0 +1,20 @@
+"""CDP SystemInfo 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 SystemInfoEvents:
+    """
+    Events for the SystemInfo domain.
+    """
+    def __init__(self, client: "Client"):
+        """
+        Initialize the SystemInfo events.
+        
+        Args:
+            client ("Client"): The parent CDP client instance.
+        """
+        self.client = client

cdp/protocol/system_info/events/types.py

@@ -0,0 +1,3 @@
+"""CDP SystemInfo Events"""
+
+from typing import TypedDict, NotRequired, Required, Literal, Any, Dict, Union, Optional, List, Set, Tuple

cdp/protocol/system_info/methods/service.py

@@ -0,0 +1,54 @@
+"""CDP SystemInfo 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 SystemInfoMethods:
+    """
+    Methods for the SystemInfo domain.
+    """
+    def __init__(self, client: "Client"):
+        """
+        Initialize the SystemInfo methods.
+        
+        Args:
+            client ("Client"): The parent CDP client instance.
+        """
+        self.client = client
+
+    async def get_info(self, params: None=None,session_id: Optional[str] = None) -> getInfoReturns:
+        """
+    Returns information about the system.    
+        Args:
+            params (None, optional): Parameters for the getInfo method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    getInfoReturns: The result of the getInfo call.
+        """
+        return await self.client.send(method="SystemInfo.getInfo", params=params,session_id=session_id)
+    async def get_feature_state(self, params: Optional[getFeatureStateParameters]=None,session_id: Optional[str] = None) -> getFeatureStateReturns:
+        """
+    Returns information about the feature state.    
+        Args:
+            params (getFeatureStateParameters, optional): Parameters for the getFeatureState method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    getFeatureStateReturns: The result of the getFeatureState call.
+        """
+        return await self.client.send(method="SystemInfo.getFeatureState", params=params,session_id=session_id)
+    async def get_process_info(self, params: None=None,session_id: Optional[str] = None) -> getProcessInfoReturns:
+        """
+    Returns information about all running processes.    
+        Args:
+            params (None, optional): Parameters for the getProcessInfo method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    getProcessInfoReturns: The result of the getProcessInfo call.
+        """
+        return await self.client.send(method="SystemInfo.getProcessInfo", params=params,session_id=session_id)

cdp/protocol/system_info/methods/types.py

@@ -0,0 +1,27 @@
+"""CDP SystemInfo 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.system_info.types import GPUInfo
+    from cdp.protocol.system_info.types import ProcessInfo
+
+
+class getFeatureStateParameters(TypedDict, total=True):
+    featureState: 'str'
+
+class getInfoReturns(TypedDict):
+    gpu: 'GPUInfo'
+    """Information about the GPUs on the system."""
+    modelName: 'str'
+    """A platform-dependent description of the model of the machine. On Mac OS, this is, for example, 'MacBookPro'. Will be the empty string if not supported."""
+    modelVersion: 'str'
+    """A platform-dependent description of the version of the machine. On Mac OS, this is, for example, '10.1'. Will be the empty string if not supported."""
+    commandLine: 'str'
+    """The command line string used to launch the browser. Will be the empty string if not supported."""
+class getFeatureStateReturns(TypedDict):
+    featureEnabled: 'bool'
+class getProcessInfoReturns(TypedDict):
+    processInfo: 'List[ProcessInfo]'
+    """An array of process info blocks."""

cdp/protocol/system_info/service.py

@@ -0,0 +1,21 @@
+"""CDP SystemInfo Domain"""
+from typing import TYPE_CHECKING
+from .methods.service import SystemInfoMethods
+from .events.service import SystemInfoEvents
+
+if TYPE_CHECKING:
+    from ...service import Client
+
+class SystemInfo(SystemInfoMethods, SystemInfoEvents):
+    """
+    The SystemInfo domain defines methods and events for querying low-level system information.
+    """
+    def __init__(self, client: "Client"):
+        """
+        Initialize the SystemInfo domain.
+        
+        Args:
+            client ("Client"): The parent CDP client instance.
+        """
+        SystemInfoMethods.__init__(self, client)
+        SystemInfoEvents.__init__(self, client)

cdp/protocol/system_info/types.py

@@ -0,0 +1,71 @@
+"""CDP SystemInfo Types"""
+
+from typing import TypedDict, NotRequired, Required, Literal, Any, Dict, Union, Optional, List, Set, Tuple
+
+class GPUDevice(TypedDict, total=True):
+    """Describes a single graphics processor (GPU)."""
+    vendorId: 'float'
+    """PCI ID of the GPU vendor, if available; 0 otherwise."""
+    deviceId: 'float'
+    """PCI ID of the GPU device, if available; 0 otherwise."""
+    vendorString: 'str'
+    """String description of the GPU vendor, if the PCI ID is not available."""
+    deviceString: 'str'
+    """String description of the GPU device, if the PCI ID is not available."""
+    driverVendor: 'str'
+    """String description of the GPU driver vendor."""
+    driverVersion: 'str'
+    """String description of the GPU driver version."""
+    subSysId: NotRequired['float']
+    """Sub sys ID of the GPU, only available on Windows."""
+    revision: NotRequired['float']
+    """Revision of the GPU, only available on Windows."""
+class Size(TypedDict, total=True):
+    """Describes the width and height dimensions of an entity."""
+    width: 'int'
+    """Width in pixels."""
+    height: 'int'
+    """Height in pixels."""
+class VideoDecodeAcceleratorCapability(TypedDict, total=True):
+    """Describes a supported video decoding profile with its associated minimum and maximum resolutions."""
+    profile: 'str'
+    """Video codec profile that is supported, e.g. VP9 Profile 2."""
+    maxResolution: 'Size'
+    """Maximum video dimensions in pixels supported for this |profile|."""
+    minResolution: 'Size'
+    """Minimum video dimensions in pixels supported for this |profile|."""
+class VideoEncodeAcceleratorCapability(TypedDict, total=True):
+    """Describes a supported video encoding profile with its associated maximum resolution and maximum framerate."""
+    profile: 'str'
+    """Video codec profile that is supported, e.g H264 Main."""
+    maxResolution: 'Size'
+    """Maximum video dimensions in pixels supported for this |profile|."""
+    maxFramerateNumerator: 'int'
+    """Maximum encoding framerate in frames per second supported for this |profile|, as fraction's numerator and denominator, e.g. 24/1 fps, 24000/1001 fps, etc."""
+    maxFramerateDenominator: 'int'
+SubsamplingFormat = Literal['yuv420','yuv422','yuv444']
+"""YUV subsampling type of the pixels of a given image."""
+ImageType = Literal['jpeg','webp','unknown']
+"""Image format of a given image."""
+class GPUInfo(TypedDict, total=True):
+    """Provides information about the GPU(s) on the system."""
+    devices: 'List[GPUDevice]'
+    """The graphics devices on the system. Element 0 is the primary GPU."""
+    driverBugWorkarounds: 'List[str]'
+    """An optional array of GPU driver bug workarounds."""
+    videoDecoding: 'List[VideoDecodeAcceleratorCapability]'
+    """Supported accelerated video decoding capabilities."""
+    videoEncoding: 'List[VideoEncodeAcceleratorCapability]'
+    """Supported accelerated video encoding capabilities."""
+    auxAttributes: NotRequired['Dict[str, Any]']
+    """An optional dictionary of additional GPU related attributes."""
+    featureStatus: NotRequired['Dict[str, Any]']
+    """An optional dictionary of graphics features and their status."""
+class ProcessInfo(TypedDict, total=True):
+    """Represents process info."""
+    type: 'str'
+    """Specifies process type."""
+    id: 'int'
+    """Specifies process id."""
+    cpuTime: 'float'
+    """Specifies cumulative CPU usage in seconds across all threads of the process since the process start."""

cdp/protocol/target/events/service.py

@@ -0,0 +1,77 @@
+"""CDP Target 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 TargetEvents:
+    """
+    Events for the Target domain.
+    """
+    def __init__(self, client: "Client"):
+        """
+        Initialize the Target events.
+        
+        Args:
+            client ("Client"): The parent CDP client instance.
+        """
+        self.client = client
+
+    def on_attached_to_target(self, callback: Callable[[attachedToTargetEvent,Optional[str]], None]=None) -> None:
+        """
+    Issued when attached to target because of auto-attach or `attachToTarget` command.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: attachedToTargetEvent, session_id: Optional[str]).
+        """
+        self.client.on('Target.attachedToTarget', callback)
+    def on_detached_from_target(self, callback: Callable[[detachedFromTargetEvent,Optional[str]], None]=None) -> None:
+        """
+    Issued when detached from target for any reason (including `detachFromTarget` command). Can be issued multiple times per target if multiple sessions have been attached to it.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: detachedFromTargetEvent, session_id: Optional[str]).
+        """
+        self.client.on('Target.detachedFromTarget', callback)
+    def on_received_message_from_target(self, callback: Callable[[receivedMessageFromTargetEvent,Optional[str]], None]=None) -> None:
+        """
+    Notifies about a new protocol message received from the session (as reported in `attachedToTarget` event).    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: receivedMessageFromTargetEvent, session_id: Optional[str]).
+        """
+        self.client.on('Target.receivedMessageFromTarget', callback)
+    def on_target_created(self, callback: Callable[[targetCreatedEvent,Optional[str]], None]=None) -> None:
+        """
+    Issued when a possible inspection target is created.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: targetCreatedEvent, session_id: Optional[str]).
+        """
+        self.client.on('Target.targetCreated', callback)
+    def on_target_destroyed(self, callback: Callable[[targetDestroyedEvent,Optional[str]], None]=None) -> None:
+        """
+    Issued when a target is destroyed.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: targetDestroyedEvent, session_id: Optional[str]).
+        """
+        self.client.on('Target.targetDestroyed', callback)
+    def on_target_crashed(self, callback: Callable[[targetCrashedEvent,Optional[str]], None]=None) -> None:
+        """
+    Issued when a target has crashed.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: targetCrashedEvent, session_id: Optional[str]).
+        """
+        self.client.on('Target.targetCrashed', callback)
+    def on_target_info_changed(self, callback: Callable[[targetInfoChangedEvent,Optional[str]], None]=None) -> None:
+        """
+    Issued when some information about a target has changed. This only happens between `targetCreated` and `targetDestroyed`.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: targetInfoChangedEvent, session_id: Optional[str]).
+        """
+        self.client.on('Target.targetInfoChanged', callback)

cdp/protocol/target/events/types.py

@@ -0,0 +1,38 @@
+"""CDP Target 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.target.types import SessionID
+    from cdp.protocol.target.types import TargetID
+    from cdp.protocol.target.types import TargetInfo
+
+class attachedToTargetEvent(TypedDict, total=True):
+    sessionId: 'SessionID'
+    """Identifier assigned to the session used to send/receive messages."""
+    targetInfo: 'TargetInfo'
+    waitingForDebugger: 'bool'
+class detachedFromTargetEvent(TypedDict, total=True):
+    sessionId: 'SessionID'
+    """Detached session identifier."""
+    targetId: NotRequired['TargetID']
+    """Deprecated."""
+class receivedMessageFromTargetEvent(TypedDict, total=True):
+    sessionId: 'SessionID'
+    """Identifier of a session which sends a message."""
+    message: 'str'
+    targetId: NotRequired['TargetID']
+    """Deprecated."""
+class targetCreatedEvent(TypedDict, total=True):
+    targetInfo: 'TargetInfo'
+class targetDestroyedEvent(TypedDict, total=True):
+    targetId: 'TargetID'
+class targetCrashedEvent(TypedDict, total=True):
+    targetId: 'TargetID'
+    status: 'str'
+    """Termination status type."""
+    errorCode: 'int'
+    """Termination error code."""
+class targetInfoChangedEvent(TypedDict, total=True):
+    targetInfo: 'TargetInfo'