chromedeveloperprotocol-client 0.1.0__py3-none-any.whl

cdp/protocol/service_worker/methods/service.py

@@ -0,0 +1,153 @@
+"""CDP ServiceWorker 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 ServiceWorkerMethods:
+    """
+    Methods for the ServiceWorker domain.
+    """
+    def __init__(self, client: "Client"):
+        """
+        Initialize the ServiceWorker methods.
+        
+        Args:
+            client ("Client"): The parent CDP client instance.
+        """
+        self.client = client
+
+    async def deliver_push_message(self, params: Optional[deliverPushMessageParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    No description available for deliverPushMessage.    
+        Args:
+            params (deliverPushMessageParameters, optional): Parameters for the deliverPushMessage method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the deliverPushMessage call.
+        """
+        return await self.client.send(method="ServiceWorker.deliverPushMessage", params=params,session_id=session_id)
+    async def disable(self, params: None=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    No description available for disable.    
+        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="ServiceWorker.disable", params=params,session_id=session_id)
+    async def dispatch_sync_event(self, params: Optional[dispatchSyncEventParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    No description available for dispatchSyncEvent.    
+        Args:
+            params (dispatchSyncEventParameters, optional): Parameters for the dispatchSyncEvent method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the dispatchSyncEvent call.
+        """
+        return await self.client.send(method="ServiceWorker.dispatchSyncEvent", params=params,session_id=session_id)
+    async def dispatch_periodic_sync_event(self, params: Optional[dispatchPeriodicSyncEventParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    No description available for dispatchPeriodicSyncEvent.    
+        Args:
+            params (dispatchPeriodicSyncEventParameters, optional): Parameters for the dispatchPeriodicSyncEvent method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the dispatchPeriodicSyncEvent call.
+        """
+        return await self.client.send(method="ServiceWorker.dispatchPeriodicSyncEvent", params=params,session_id=session_id)
+    async def enable(self, params: None=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    No description available for enable.    
+        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="ServiceWorker.enable", params=params,session_id=session_id)
+    async def set_force_update_on_page_load(self, params: Optional[setForceUpdateOnPageLoadParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    No description available for setForceUpdateOnPageLoad.    
+        Args:
+            params (setForceUpdateOnPageLoadParameters, optional): Parameters for the setForceUpdateOnPageLoad method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the setForceUpdateOnPageLoad call.
+        """
+        return await self.client.send(method="ServiceWorker.setForceUpdateOnPageLoad", params=params,session_id=session_id)
+    async def skip_waiting(self, params: Optional[skipWaitingParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    No description available for skipWaiting.    
+        Args:
+            params (skipWaitingParameters, optional): Parameters for the skipWaiting method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the skipWaiting call.
+        """
+        return await self.client.send(method="ServiceWorker.skipWaiting", params=params,session_id=session_id)
+    async def start_worker(self, params: Optional[startWorkerParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    No description available for startWorker.    
+        Args:
+            params (startWorkerParameters, optional): Parameters for the startWorker method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the startWorker call.
+        """
+        return await self.client.send(method="ServiceWorker.startWorker", params=params,session_id=session_id)
+    async def stop_all_workers(self, params: None=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    No description available for stopAllWorkers.    
+        Args:
+            params (None, optional): Parameters for the stopAllWorkers method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the stopAllWorkers call.
+        """
+        return await self.client.send(method="ServiceWorker.stopAllWorkers", params=params,session_id=session_id)
+    async def stop_worker(self, params: Optional[stopWorkerParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    No description available for stopWorker.    
+        Args:
+            params (stopWorkerParameters, optional): Parameters for the stopWorker method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the stopWorker call.
+        """
+        return await self.client.send(method="ServiceWorker.stopWorker", params=params,session_id=session_id)
+    async def unregister(self, params: Optional[unregisterParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    No description available for unregister.    
+        Args:
+            params (unregisterParameters, optional): Parameters for the unregister method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the unregister call.
+        """
+        return await self.client.send(method="ServiceWorker.unregister", params=params,session_id=session_id)
+    async def update_registration(self, params: Optional[updateRegistrationParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    No description available for updateRegistration.    
+        Args:
+            params (updateRegistrationParameters, optional): Parameters for the updateRegistration method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the updateRegistration call.
+        """
+        return await self.client.send(method="ServiceWorker.updateRegistration", params=params,session_id=session_id)

cdp/protocol/service_worker/methods/types.py

@@ -0,0 +1,36 @@
+"""CDP ServiceWorker 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.service_worker.types import RegistrationID
+
+class deliverPushMessageParameters(TypedDict, total=True):
+    origin: 'str'
+    registrationId: 'RegistrationID'
+    data: 'str'
+
+class dispatchSyncEventParameters(TypedDict, total=True):
+    origin: 'str'
+    registrationId: 'RegistrationID'
+    tag: 'str'
+    lastChance: 'bool'
+class dispatchPeriodicSyncEventParameters(TypedDict, total=True):
+    origin: 'str'
+    registrationId: 'RegistrationID'
+    tag: 'str'
+
+class setForceUpdateOnPageLoadParameters(TypedDict, total=True):
+    forceUpdateOnPageLoad: 'bool'
+class skipWaitingParameters(TypedDict, total=True):
+    scopeURL: 'str'
+class startWorkerParameters(TypedDict, total=True):
+    scopeURL: 'str'
+
+class stopWorkerParameters(TypedDict, total=True):
+    versionId: 'str'
+class unregisterParameters(TypedDict, total=True):
+    scopeURL: 'str'
+class updateRegistrationParameters(TypedDict, total=True):
+    scopeURL: 'str'

cdp/protocol/service_worker/service.py

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

cdp/protocol/service_worker/types.py

@@ -0,0 +1,38 @@
+"""CDP ServiceWorker 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.target.types import TargetID
+
+RegistrationID = str
+class ServiceWorkerRegistration(TypedDict, total=True):
+    """ServiceWorker registration."""
+    registrationId: 'RegistrationID'
+    scopeURL: 'str'
+    isDeleted: 'bool'
+ServiceWorkerVersionRunningStatus = Literal['stopped','starting','running','stopping']
+ServiceWorkerVersionStatus = Literal['new','installing','installed','activating','activated','redundant']
+class ServiceWorkerVersion(TypedDict, total=True):
+    """ServiceWorker version."""
+    versionId: 'str'
+    registrationId: 'RegistrationID'
+    scriptURL: 'str'
+    runningStatus: 'ServiceWorkerVersionRunningStatus'
+    status: 'ServiceWorkerVersionStatus'
+    scriptLastModified: NotRequired['float']
+    """The Last-Modified header value of the main script."""
+    scriptResponseTime: NotRequired['float']
+    """The time at which the response headers of the main script were received from the server. For cached script it is the last time the cache entry was validated."""
+    controlledClients: NotRequired['List[TargetID]']
+    targetId: NotRequired['TargetID']
+    routerRules: NotRequired['str']
+class ServiceWorkerErrorMessage(TypedDict, total=True):
+    """ServiceWorker error message."""
+    errorMessage: 'str'
+    registrationId: 'RegistrationID'
+    versionId: 'str'
+    sourceURL: 'str'
+    lineNumber: 'int'
+    columnNumber: 'int'

cdp/protocol/storage/events/service.py

@@ -0,0 +1,141 @@
+"""CDP Storage 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 StorageEvents:
+    """
+    Events for the Storage domain.
+    """
+    def __init__(self, client: "Client"):
+        """
+        Initialize the Storage events.
+        
+        Args:
+            client ("Client"): The parent CDP client instance.
+        """
+        self.client = client
+
+    def on_cache_storage_content_updated(self, callback: Callable[[cacheStorageContentUpdatedEvent,Optional[str]], None]=None) -> None:
+        """
+    A cache's contents have been modified.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: cacheStorageContentUpdatedEvent, session_id: Optional[str]).
+        """
+        self.client.on('Storage.cacheStorageContentUpdated', callback)
+    def on_cache_storage_list_updated(self, callback: Callable[[cacheStorageListUpdatedEvent,Optional[str]], None]=None) -> None:
+        """
+    A cache has been added/deleted.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: cacheStorageListUpdatedEvent, session_id: Optional[str]).
+        """
+        self.client.on('Storage.cacheStorageListUpdated', callback)
+    def on_indexed_db_content_updated(self, callback: Callable[[indexedDBContentUpdatedEvent,Optional[str]], None]=None) -> None:
+        """
+    The origin's IndexedDB object store has been modified.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: indexedDBContentUpdatedEvent, session_id: Optional[str]).
+        """
+        self.client.on('Storage.indexedDBContentUpdated', callback)
+    def on_indexed_db_list_updated(self, callback: Callable[[indexedDBListUpdatedEvent,Optional[str]], None]=None) -> None:
+        """
+    The origin's IndexedDB database list has been modified.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: indexedDBListUpdatedEvent, session_id: Optional[str]).
+        """
+        self.client.on('Storage.indexedDBListUpdated', callback)
+    def on_interest_group_accessed(self, callback: Callable[[interestGroupAccessedEvent,Optional[str]], None]=None) -> None:
+        """
+    One of the interest groups was accessed. Note that these events are global to all targets sharing an interest group store.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: interestGroupAccessedEvent, session_id: Optional[str]).
+        """
+        self.client.on('Storage.interestGroupAccessed', callback)
+    def on_interest_group_auction_event_occurred(self, callback: Callable[[interestGroupAuctionEventOccurredEvent,Optional[str]], None]=None) -> None:
+        """
+    An auction involving interest groups is taking place. These events are target-specific.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: interestGroupAuctionEventOccurredEvent, session_id: Optional[str]).
+        """
+        self.client.on('Storage.interestGroupAuctionEventOccurred', callback)
+    def on_interest_group_auction_network_request_created(self, callback: Callable[[interestGroupAuctionNetworkRequestCreatedEvent,Optional[str]], None]=None) -> None:
+        """
+    Specifies which auctions a particular network fetch may be related to, and in what role. Note that it is not ordered with respect to Network.requestWillBeSent (but will happen before loadingFinished loadingFailed).    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: interestGroupAuctionNetworkRequestCreatedEvent, session_id: Optional[str]).
+        """
+        self.client.on('Storage.interestGroupAuctionNetworkRequestCreated', callback)
+    def on_shared_storage_accessed(self, callback: Callable[[sharedStorageAccessedEvent,Optional[str]], None]=None) -> None:
+        """
+    Shared storage was accessed by the associated page. The following parameters are included in all events.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: sharedStorageAccessedEvent, session_id: Optional[str]).
+        """
+        self.client.on('Storage.sharedStorageAccessed', callback)
+    def on_shared_storage_worklet_operation_execution_finished(self, callback: Callable[[sharedStorageWorkletOperationExecutionFinishedEvent,Optional[str]], None]=None) -> None:
+        """
+    A shared storage run or selectURL operation finished its execution. The following parameters are included in all events.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: sharedStorageWorkletOperationExecutionFinishedEvent, session_id: Optional[str]).
+        """
+        self.client.on('Storage.sharedStorageWorkletOperationExecutionFinished', callback)
+    def on_storage_bucket_created_or_updated(self, callback: Callable[[storageBucketCreatedOrUpdatedEvent,Optional[str]], None]=None) -> None:
+        """
+    No description available for storageBucketCreatedOrUpdated.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: storageBucketCreatedOrUpdatedEvent, session_id: Optional[str]).
+        """
+        self.client.on('Storage.storageBucketCreatedOrUpdated', callback)
+    def on_storage_bucket_deleted(self, callback: Callable[[storageBucketDeletedEvent,Optional[str]], None]=None) -> None:
+        """
+    No description available for storageBucketDeleted.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: storageBucketDeletedEvent, session_id: Optional[str]).
+        """
+        self.client.on('Storage.storageBucketDeleted', callback)
+    def on_attribution_reporting_source_registered(self, callback: Callable[[attributionReportingSourceRegisteredEvent,Optional[str]], None]=None) -> None:
+        """
+    No description available for attributionReportingSourceRegistered.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: attributionReportingSourceRegisteredEvent, session_id: Optional[str]).
+        """
+        self.client.on('Storage.attributionReportingSourceRegistered', callback)
+    def on_attribution_reporting_trigger_registered(self, callback: Callable[[attributionReportingTriggerRegisteredEvent,Optional[str]], None]=None) -> None:
+        """
+    No description available for attributionReportingTriggerRegistered.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: attributionReportingTriggerRegisteredEvent, session_id: Optional[str]).
+        """
+        self.client.on('Storage.attributionReportingTriggerRegistered', callback)
+    def on_attribution_reporting_report_sent(self, callback: Callable[[attributionReportingReportSentEvent,Optional[str]], None]=None) -> None:
+        """
+    No description available for attributionReportingReportSent.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: attributionReportingReportSentEvent, session_id: Optional[str]).
+        """
+        self.client.on('Storage.attributionReportingReportSent', callback)
+    def on_attribution_reporting_verbose_debug_report_sent(self, callback: Callable[[attributionReportingVerboseDebugReportSentEvent,Optional[str]], None]=None) -> None:
+        """
+    No description available for attributionReportingVerboseDebugReportSent.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: attributionReportingVerboseDebugReportSentEvent, session_id: Optional[str]).
+        """
+        self.client.on('Storage.attributionReportingVerboseDebugReportSent', callback)

cdp/protocol/storage/events/types.py

@@ -0,0 +1,139 @@
+"""CDP Storage 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.network.types import RequestId
+    from cdp.protocol.network.types import TimeSinceEpoch
+    from cdp.protocol.page.types import FrameId
+    from cdp.protocol.storage.types import AttributionReportingAggregatableResult
+    from cdp.protocol.storage.types import AttributionReportingEventLevelResult
+    from cdp.protocol.storage.types import AttributionReportingReportResult
+    from cdp.protocol.storage.types import AttributionReportingSourceRegistration
+    from cdp.protocol.storage.types import AttributionReportingSourceRegistrationResult
+    from cdp.protocol.storage.types import AttributionReportingTriggerRegistration
+    from cdp.protocol.storage.types import InterestGroupAccessType
+    from cdp.protocol.storage.types import InterestGroupAuctionEventType
+    from cdp.protocol.storage.types import InterestGroupAuctionFetchType
+    from cdp.protocol.storage.types import InterestGroupAuctionId
+    from cdp.protocol.storage.types import SharedStorageAccessMethod
+    from cdp.protocol.storage.types import SharedStorageAccessParams
+    from cdp.protocol.storage.types import SharedStorageAccessScope
+    from cdp.protocol.storage.types import StorageBucketInfo
+    from cdp.protocol.target.types import TargetID
+
+class cacheStorageContentUpdatedEvent(TypedDict, total=True):
+    origin: 'str'
+    """Origin to update."""
+    storageKey: 'str'
+    """Storage key to update."""
+    bucketId: 'str'
+    """Storage bucket to update."""
+    cacheName: 'str'
+    """Name of cache in origin."""
+class cacheStorageListUpdatedEvent(TypedDict, total=True):
+    origin: 'str'
+    """Origin to update."""
+    storageKey: 'str'
+    """Storage key to update."""
+    bucketId: 'str'
+    """Storage bucket to update."""
+class indexedDBContentUpdatedEvent(TypedDict, total=True):
+    origin: 'str'
+    """Origin to update."""
+    storageKey: 'str'
+    """Storage key to update."""
+    bucketId: 'str'
+    """Storage bucket to update."""
+    databaseName: 'str'
+    """Database to update."""
+    objectStoreName: 'str'
+    """ObjectStore to update."""
+class indexedDBListUpdatedEvent(TypedDict, total=True):
+    origin: 'str'
+    """Origin to update."""
+    storageKey: 'str'
+    """Storage key to update."""
+    bucketId: 'str'
+    """Storage bucket to update."""
+class interestGroupAccessedEvent(TypedDict, total=True):
+    accessTime: 'TimeSinceEpoch'
+    type: 'InterestGroupAccessType'
+    ownerOrigin: 'str'
+    name: 'str'
+    componentSellerOrigin: NotRequired['str']
+    """For topLevelBid/topLevelAdditionalBid, and when appropriate, win and additionalBidWin"""
+    bid: NotRequired['float']
+    """For bid or somethingBid event, if done locally and not on a server."""
+    bidCurrency: NotRequired['str']
+    uniqueAuctionId: NotRequired['InterestGroupAuctionId']
+    """For non-global events --- links to interestGroupAuctionEvent"""
+class interestGroupAuctionEventOccurredEvent(TypedDict, total=True):
+    eventTime: 'TimeSinceEpoch'
+    type: 'InterestGroupAuctionEventType'
+    uniqueAuctionId: 'InterestGroupAuctionId'
+    parentAuctionId: NotRequired['InterestGroupAuctionId']
+    """Set for child auctions."""
+    auctionConfig: NotRequired['Dict[str, Any]']
+    """Set for started and configResolved"""
+class interestGroupAuctionNetworkRequestCreatedEvent(TypedDict, total=True):
+    type: 'InterestGroupAuctionFetchType'
+    requestId: 'RequestId'
+    auctions: 'List[InterestGroupAuctionId]'
+    """This is the set of the auctions using the worklet that issued this request.  In the case of trusted signals, it's possible that only some of them actually care about the keys being queried."""
+class sharedStorageAccessedEvent(TypedDict, total=True):
+    accessTime: 'TimeSinceEpoch'
+    """Time of the access."""
+    scope: 'SharedStorageAccessScope'
+    """Enum value indicating the access scope."""
+    method: 'SharedStorageAccessMethod'
+    """Enum value indicating the Shared Storage API method invoked."""
+    mainFrameId: 'FrameId'
+    """DevTools Frame Token for the primary frame tree's root."""
+    ownerOrigin: 'str'
+    """Serialization of the origin owning the Shared Storage data."""
+    ownerSite: 'str'
+    """Serialization of the site owning the Shared Storage data."""
+    params: 'SharedStorageAccessParams'
+    """The sub-parameters wrapped by params are all optional and their presence/absence depends on type."""
+class sharedStorageWorkletOperationExecutionFinishedEvent(TypedDict, total=True):
+    finishedTime: 'TimeSinceEpoch'
+    """Time that the operation finished."""
+    executionTime: 'int'
+    """Time, in microseconds, from start of shared storage JS API call until end of operation execution in the worklet."""
+    method: 'SharedStorageAccessMethod'
+    """Enum value indicating the Shared Storage API method invoked."""
+    operationId: 'str'
+    """ID of the operation call."""
+    workletTargetId: 'TargetID'
+    """Hex representation of the DevTools token used as the TargetID for the associated shared storage worklet."""
+    mainFrameId: 'FrameId'
+    """DevTools Frame Token for the primary frame tree's root."""
+    ownerOrigin: 'str'
+    """Serialization of the origin owning the Shared Storage data."""
+class storageBucketCreatedOrUpdatedEvent(TypedDict, total=True):
+    bucketInfo: 'StorageBucketInfo'
+class storageBucketDeletedEvent(TypedDict, total=True):
+    bucketId: 'str'
+class attributionReportingSourceRegisteredEvent(TypedDict, total=True):
+    registration: 'AttributionReportingSourceRegistration'
+    result: 'AttributionReportingSourceRegistrationResult'
+class attributionReportingTriggerRegisteredEvent(TypedDict, total=True):
+    registration: 'AttributionReportingTriggerRegistration'
+    eventLevel: 'AttributionReportingEventLevelResult'
+    aggregatable: 'AttributionReportingAggregatableResult'
+class attributionReportingReportSentEvent(TypedDict, total=True):
+    url: 'str'
+    body: 'Dict[str, Any]'
+    result: 'AttributionReportingReportResult'
+    netError: NotRequired['int']
+    """If result is sent, populated with net/HTTP status."""
+    netErrorName: NotRequired['str']
+    httpStatusCode: NotRequired['int']
+class attributionReportingVerboseDebugReportSentEvent(TypedDict, total=True):
+    url: 'str'
+    body: NotRequired['List[Dict[str, Any]]']
+    netError: NotRequired['int']
+    netErrorName: NotRequired['str']
+    httpStatusCode: NotRequired['int']