chromedeveloperprotocol-client 0.1.0__py3-none-any.whl

cdp/protocol/heap_profiler/methods/service.py

@@ -0,0 +1,153 @@
+"""CDP HeapProfiler 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 HeapProfilerMethods:
+    """
+    Methods for the HeapProfiler domain.
+    """
+    def __init__(self, client: "Client"):
+        """
+        Initialize the HeapProfiler methods.
+        
+        Args:
+            client ("Client"): The parent CDP client instance.
+        """
+        self.client = client
+
+    async def add_inspected_heap_object(self, params: Optional[addInspectedHeapObjectParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Enables console to refer to the node with given id via $x (see Command Line API for more details $x functions).    
+        Args:
+            params (addInspectedHeapObjectParameters, optional): Parameters for the addInspectedHeapObject method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the addInspectedHeapObject call.
+        """
+        return await self.client.send(method="HeapProfiler.addInspectedHeapObject", params=params,session_id=session_id)
+    async def collect_garbage(self, params: None=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    No description available for collectGarbage.    
+        Args:
+            params (None, optional): Parameters for the collectGarbage method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the collectGarbage call.
+        """
+        return await self.client.send(method="HeapProfiler.collectGarbage", 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="HeapProfiler.disable", 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="HeapProfiler.enable", params=params,session_id=session_id)
+    async def get_heap_object_id(self, params: Optional[getHeapObjectIdParameters]=None,session_id: Optional[str] = None) -> getHeapObjectIdReturns:
+        """
+    No description available for getHeapObjectId.    
+        Args:
+            params (getHeapObjectIdParameters, optional): Parameters for the getHeapObjectId method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    getHeapObjectIdReturns: The result of the getHeapObjectId call.
+        """
+        return await self.client.send(method="HeapProfiler.getHeapObjectId", params=params,session_id=session_id)
+    async def get_object_by_heap_object_id(self, params: Optional[getObjectByHeapObjectIdParameters]=None,session_id: Optional[str] = None) -> getObjectByHeapObjectIdReturns:
+        """
+    No description available for getObjectByHeapObjectId.    
+        Args:
+            params (getObjectByHeapObjectIdParameters, optional): Parameters for the getObjectByHeapObjectId method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    getObjectByHeapObjectIdReturns: The result of the getObjectByHeapObjectId call.
+        """
+        return await self.client.send(method="HeapProfiler.getObjectByHeapObjectId", params=params,session_id=session_id)
+    async def get_sampling_profile(self, params: None=None,session_id: Optional[str] = None) -> getSamplingProfileReturns:
+        """
+    No description available for getSamplingProfile.    
+        Args:
+            params (None, optional): Parameters for the getSamplingProfile method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    getSamplingProfileReturns: The result of the getSamplingProfile call.
+        """
+        return await self.client.send(method="HeapProfiler.getSamplingProfile", params=params,session_id=session_id)
+    async def start_sampling(self, params: Optional[startSamplingParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    No description available for startSampling.    
+        Args:
+            params (startSamplingParameters, optional): Parameters for the startSampling method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the startSampling call.
+        """
+        return await self.client.send(method="HeapProfiler.startSampling", params=params,session_id=session_id)
+    async def start_tracking_heap_objects(self, params: Optional[startTrackingHeapObjectsParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    No description available for startTrackingHeapObjects.    
+        Args:
+            params (startTrackingHeapObjectsParameters, optional): Parameters for the startTrackingHeapObjects method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the startTrackingHeapObjects call.
+        """
+        return await self.client.send(method="HeapProfiler.startTrackingHeapObjects", params=params,session_id=session_id)
+    async def stop_sampling(self, params: None=None,session_id: Optional[str] = None) -> stopSamplingReturns:
+        """
+    No description available for stopSampling.    
+        Args:
+            params (None, optional): Parameters for the stopSampling method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    stopSamplingReturns: The result of the stopSampling call.
+        """
+        return await self.client.send(method="HeapProfiler.stopSampling", params=params,session_id=session_id)
+    async def stop_tracking_heap_objects(self, params: Optional[stopTrackingHeapObjectsParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    No description available for stopTrackingHeapObjects.    
+        Args:
+            params (stopTrackingHeapObjectsParameters, optional): Parameters for the stopTrackingHeapObjects method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the stopTrackingHeapObjects call.
+        """
+        return await self.client.send(method="HeapProfiler.stopTrackingHeapObjects", params=params,session_id=session_id)
+    async def take_heap_snapshot(self, params: Optional[takeHeapSnapshotParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    No description available for takeHeapSnapshot.    
+        Args:
+            params (takeHeapSnapshotParameters, optional): Parameters for the takeHeapSnapshot method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the takeHeapSnapshot call.
+        """
+        return await self.client.send(method="HeapProfiler.takeHeapSnapshot", params=params,session_id=session_id)

cdp/protocol/heap_profiler/methods/types.py

@@ -0,0 +1,73 @@
+"""CDP HeapProfiler 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.heap_profiler.types import HeapSnapshotObjectId
+    from cdp.protocol.heap_profiler.types import SamplingHeapProfile
+    from cdp.protocol.runtime.types import RemoteObject
+    from cdp.protocol.runtime.types import RemoteObjectId
+
+class addInspectedHeapObjectParameters(TypedDict, total=True):
+    heapObjectId: 'HeapSnapshotObjectId'
+    """Heap snapshot object id to be accessible by means of $x command line API."""
+
+
+
+class getHeapObjectIdParameters(TypedDict, total=True):
+    objectId: 'RemoteObjectId'
+    """Identifier of the object to get heap object id for."""
+class getObjectByHeapObjectIdParameters(TypedDict, total=True):
+    objectId: 'HeapSnapshotObjectId'
+    objectGroup: NotRequired['str']
+    """Symbolic group name that can be used to release multiple objects."""
+
+class startSamplingParameters(TypedDict, total=False):
+    samplingInterval: NotRequired['float']
+    """Average sample interval in bytes. Poisson distribution is used for the intervals. The default value is 32768 bytes."""
+    stackDepth: NotRequired['float']
+    """Maximum stack depth. The default value is 128."""
+    includeObjectsCollectedByMajorGC: NotRequired['bool']
+    """By default, the sampling heap profiler reports only objects which are still alive when the profile is returned via getSamplingProfile or stopSampling, which is useful for determining what functions contribute the most to steady-state memory usage. This flag instructs the sampling heap profiler to also include information about objects discarded by major GC, which will show which functions cause large temporary memory usage or long GC pauses."""
+    includeObjectsCollectedByMinorGC: NotRequired['bool']
+    """By default, the sampling heap profiler reports only objects which are still alive when the profile is returned via getSamplingProfile or stopSampling, which is useful for determining what functions contribute the most to steady-state memory usage. This flag instructs the sampling heap profiler to also include information about objects discarded by minor GC, which is useful when tuning a latency-sensitive application for minimal GC activity."""
+class startTrackingHeapObjectsParameters(TypedDict, total=False):
+    trackAllocations: NotRequired['bool']
+
+class stopTrackingHeapObjectsParameters(TypedDict, total=False):
+    reportProgress: NotRequired['bool']
+    """If true 'reportHeapSnapshotProgress' events will be generated while snapshot is being taken when the tracking is stopped."""
+    treatGlobalObjectsAsRoots: NotRequired['bool']
+    """Deprecated in favor of exposeInternals."""
+    captureNumericValue: NotRequired['bool']
+    """If true, numerical values are included in the snapshot"""
+    exposeInternals: NotRequired['bool']
+    """If true, exposes internals of the snapshot."""
+class takeHeapSnapshotParameters(TypedDict, total=False):
+    reportProgress: NotRequired['bool']
+    """If true 'reportHeapSnapshotProgress' events will be generated while snapshot is being taken."""
+    treatGlobalObjectsAsRoots: NotRequired['bool']
+    """If true, a raw snapshot without artificial roots will be generated. Deprecated in favor of exposeInternals."""
+    captureNumericValue: NotRequired['bool']
+    """If true, numerical values are included in the snapshot"""
+    exposeInternals: NotRequired['bool']
+    """If true, exposes internals of the snapshot."""
+
+
+
+
+class getHeapObjectIdReturns(TypedDict):
+    heapSnapshotObjectId: 'HeapSnapshotObjectId'
+    """Id of the heap snapshot object corresponding to the passed remote object id."""
+class getObjectByHeapObjectIdReturns(TypedDict):
+    result: 'RemoteObject'
+    """Evaluation result."""
+class getSamplingProfileReturns(TypedDict):
+    profile: 'SamplingHeapProfile'
+    """Return the sampling profile being collected."""
+
+
+class stopSamplingReturns(TypedDict):
+    profile: 'SamplingHeapProfile'
+    """Recorded sampling heap profile."""

cdp/protocol/heap_profiler/service.py

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

cdp/protocol/heap_profiler/types.py

@@ -0,0 +1,32 @@
+"""CDP HeapProfiler 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.runtime.types import CallFrame
+
+HeapSnapshotObjectId = str
+"""Heap snapshot object id."""
+class SamplingHeapProfileNode(TypedDict, total=True):
+    """Sampling Heap Profile node. Holds callsite information, allocation statistics and child nodes."""
+    callFrame: 'CallFrame'
+    """Function location."""
+    selfSize: 'float'
+    """Allocations size in bytes for the node excluding children."""
+    id: 'int'
+    """Node id. Ids are unique across all profiles collected between startSampling and stopSampling."""
+    children: 'List[SamplingHeapProfileNode]'
+    """Child nodes."""
+class SamplingHeapProfileSample(TypedDict, total=True):
+    """A single sample from a sampling profile."""
+    size: 'float'
+    """Allocation size in bytes attributed to the sample."""
+    nodeId: 'int'
+    """Id of the corresponding profile tree node."""
+    ordinal: 'float'
+    """Time-ordered sample ordinal number. It is unique across all profiles retrieved between startSampling and stopSampling."""
+class SamplingHeapProfile(TypedDict, total=True):
+    """Sampling profile."""
+    head: 'SamplingHeapProfileNode'
+    samples: 'List[SamplingHeapProfileSample]'

cdp/protocol/indexed_db/events/service.py

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

cdp/protocol/indexed_db/events/types.py

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

cdp/protocol/indexed_db/methods/service.py

@@ -0,0 +1,120 @@
+"""CDP IndexedDB 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 IndexedDBMethods:
+    """
+    Methods for the IndexedDB domain.
+    """
+    def __init__(self, client: "Client"):
+        """
+        Initialize the IndexedDB methods.
+        
+        Args:
+            client ("Client"): The parent CDP client instance.
+        """
+        self.client = client
+
+    async def clear_object_store(self, params: Optional[clearObjectStoreParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Clears all entries from an object store.    
+        Args:
+            params (clearObjectStoreParameters, optional): Parameters for the clearObjectStore method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the clearObjectStore call.
+        """
+        return await self.client.send(method="IndexedDB.clearObjectStore", params=params,session_id=session_id)
+    async def delete_database(self, params: Optional[deleteDatabaseParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Deletes a database.    
+        Args:
+            params (deleteDatabaseParameters, optional): Parameters for the deleteDatabase method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the deleteDatabase call.
+        """
+        return await self.client.send(method="IndexedDB.deleteDatabase", params=params,session_id=session_id)
+    async def delete_object_store_entries(self, params: Optional[deleteObjectStoreEntriesParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Delete a range of entries from an object store    
+        Args:
+            params (deleteObjectStoreEntriesParameters, optional): Parameters for the deleteObjectStoreEntries method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the deleteObjectStoreEntries call.
+        """
+        return await self.client.send(method="IndexedDB.deleteObjectStoreEntries", params=params,session_id=session_id)
+    async def disable(self, params: None=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Disables events from backend.    
+        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="IndexedDB.disable", params=params,session_id=session_id)
+    async def enable(self, params: None=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Enables events from backend.    
+        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="IndexedDB.enable", params=params,session_id=session_id)
+    async def request_data(self, params: Optional[requestDataParameters]=None,session_id: Optional[str] = None) -> requestDataReturns:
+        """
+    Requests data from object store or index.    
+        Args:
+            params (requestDataParameters, optional): Parameters for the requestData method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    requestDataReturns: The result of the requestData call.
+        """
+        return await self.client.send(method="IndexedDB.requestData", params=params,session_id=session_id)
+    async def get_metadata(self, params: Optional[getMetadataParameters]=None,session_id: Optional[str] = None) -> getMetadataReturns:
+        """
+    Gets metadata of an object store.    
+        Args:
+            params (getMetadataParameters, optional): Parameters for the getMetadata method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    getMetadataReturns: The result of the getMetadata call.
+        """
+        return await self.client.send(method="IndexedDB.getMetadata", params=params,session_id=session_id)
+    async def request_database(self, params: Optional[requestDatabaseParameters]=None,session_id: Optional[str] = None) -> requestDatabaseReturns:
+        """
+    Requests database with given name in given frame.    
+        Args:
+            params (requestDatabaseParameters, optional): Parameters for the requestDatabase method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    requestDatabaseReturns: The result of the requestDatabase call.
+        """
+        return await self.client.send(method="IndexedDB.requestDatabase", params=params,session_id=session_id)
+    async def request_database_names(self, params: Optional[requestDatabaseNamesParameters]=None,session_id: Optional[str] = None) -> requestDatabaseNamesReturns:
+        """
+    Requests database names for given security origin.    
+        Args:
+            params (requestDatabaseNamesParameters, optional): Parameters for the requestDatabaseNames method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    requestDatabaseNamesReturns: The result of the requestDatabaseNames call.
+        """
+        return await self.client.send(method="IndexedDB.requestDatabaseNames", params=params,session_id=session_id)

cdp/protocol/indexed_db/methods/types.py

@@ -0,0 +1,111 @@
+"""CDP IndexedDB 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.indexed_db.types import DataEntry
+    from cdp.protocol.indexed_db.types import DatabaseWithObjectStores
+    from cdp.protocol.indexed_db.types import KeyRange
+    from cdp.protocol.storage.types import StorageBucket
+
+class clearObjectStoreParameters(TypedDict, total=True):
+    databaseName: 'str'
+    """Database name."""
+    objectStoreName: 'str'
+    """Object store name."""
+    securityOrigin: NotRequired['str']
+    """At least and at most one of securityOrigin, storageKey, or storageBucket must be specified. Security origin."""
+    storageKey: NotRequired['str']
+    """Storage key."""
+    storageBucket: NotRequired['StorageBucket']
+    """Storage bucket. If not specified, it uses the default bucket."""
+class deleteDatabaseParameters(TypedDict, total=True):
+    databaseName: 'str'
+    """Database name."""
+    securityOrigin: NotRequired['str']
+    """At least and at most one of securityOrigin, storageKey, or storageBucket must be specified. Security origin."""
+    storageKey: NotRequired['str']
+    """Storage key."""
+    storageBucket: NotRequired['StorageBucket']
+    """Storage bucket. If not specified, it uses the default bucket."""
+class deleteObjectStoreEntriesParameters(TypedDict, total=True):
+    databaseName: 'str'
+    objectStoreName: 'str'
+    keyRange: 'KeyRange'
+    """Range of entry keys to delete"""
+    securityOrigin: NotRequired['str']
+    """At least and at most one of securityOrigin, storageKey, or storageBucket must be specified. Security origin."""
+    storageKey: NotRequired['str']
+    """Storage key."""
+    storageBucket: NotRequired['StorageBucket']
+    """Storage bucket. If not specified, it uses the default bucket."""
+
+
+class requestDataParameters(TypedDict, total=True):
+    databaseName: 'str'
+    """Database name."""
+    objectStoreName: 'str'
+    """Object store name."""
+    skipCount: 'int'
+    """Number of records to skip."""
+    pageSize: 'int'
+    """Number of records to fetch."""
+    securityOrigin: NotRequired['str']
+    """At least and at most one of securityOrigin, storageKey, or storageBucket must be specified. Security origin."""
+    storageKey: NotRequired['str']
+    """Storage key."""
+    storageBucket: NotRequired['StorageBucket']
+    """Storage bucket. If not specified, it uses the default bucket."""
+    indexName: NotRequired['str']
+    """Index name. If not specified, it performs an object store data request."""
+    keyRange: NotRequired['KeyRange']
+    """Key range."""
+class getMetadataParameters(TypedDict, total=True):
+    databaseName: 'str'
+    """Database name."""
+    objectStoreName: 'str'
+    """Object store name."""
+    securityOrigin: NotRequired['str']
+    """At least and at most one of securityOrigin, storageKey, or storageBucket must be specified. Security origin."""
+    storageKey: NotRequired['str']
+    """Storage key."""
+    storageBucket: NotRequired['StorageBucket']
+    """Storage bucket. If not specified, it uses the default bucket."""
+class requestDatabaseParameters(TypedDict, total=True):
+    databaseName: 'str'
+    """Database name."""
+    securityOrigin: NotRequired['str']
+    """At least and at most one of securityOrigin, storageKey, or storageBucket must be specified. Security origin."""
+    storageKey: NotRequired['str']
+    """Storage key."""
+    storageBucket: NotRequired['StorageBucket']
+    """Storage bucket. If not specified, it uses the default bucket."""
+class requestDatabaseNamesParameters(TypedDict, total=False):
+    securityOrigin: NotRequired['str']
+    """At least and at most one of securityOrigin, storageKey, or storageBucket must be specified. Security origin."""
+    storageKey: NotRequired['str']
+    """Storage key."""
+    storageBucket: NotRequired['StorageBucket']
+    """Storage bucket. If not specified, it uses the default bucket."""
+
+
+
+
+
+class requestDataReturns(TypedDict):
+    objectStoreDataEntries: 'List[DataEntry]'
+    """Array of object store data entries."""
+    hasMore: 'bool'
+    """If true, there are more entries to fetch in the given range."""
+class getMetadataReturns(TypedDict):
+    entriesCount: 'float'
+    """the entries count"""
+    keyGeneratorValue: 'float'
+    """the current value of key generator, to become the next inserted key into the object store. Valid if objectStore.autoIncrement is true."""
+class requestDatabaseReturns(TypedDict):
+    databaseWithObjectStores: 'DatabaseWithObjectStores'
+    """Database with an array of object stores."""
+class requestDatabaseNamesReturns(TypedDict):
+    databaseNames: 'List[str]'
+    """Database names for origin."""

cdp/protocol/indexed_db/service.py

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

cdp/protocol/indexed_db/types.py

@@ -0,0 +1,74 @@
+"""CDP IndexedDB 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.runtime.types import RemoteObject
+
+class DatabaseWithObjectStores(TypedDict, total=True):
+    """Database with an array of object stores."""
+    name: 'str'
+    """Database name."""
+    version: 'float'
+    """Database version (type is not 'integer', as the standard requires the version number to be 'unsigned long long')"""
+    objectStores: 'List[ObjectStore]'
+    """Object stores in this database."""
+class ObjectStore(TypedDict, total=True):
+    """Object store."""
+    name: 'str'
+    """Object store name."""
+    keyPath: 'KeyPath'
+    """Object store key path."""
+    autoIncrement: 'bool'
+    """If true, object store has auto increment flag set."""
+    indexes: 'List[ObjectStoreIndex]'
+    """Indexes in this object store."""
+class ObjectStoreIndex(TypedDict, total=True):
+    """Object store index."""
+    name: 'str'
+    """Index name."""
+    keyPath: 'KeyPath'
+    """Index key path."""
+    unique: 'bool'
+    """If true, index is unique."""
+    multiEntry: 'bool'
+    """If true, index allows multiple entries for a key."""
+class Key(TypedDict, total=True):
+    """Key."""
+    type: 'Literal["number", "string", "date", "array"]'
+    """Key type."""
+    number: NotRequired['float']
+    """Number value."""
+    string: NotRequired['str']
+    """String value."""
+    date: NotRequired['float']
+    """Date value."""
+    array: NotRequired['List[Key]']
+    """Array value."""
+class KeyRange(TypedDict, total=True):
+    """Key range."""
+    lowerOpen: 'bool'
+    """If true lower bound is open."""
+    upperOpen: 'bool'
+    """If true upper bound is open."""
+    lower: NotRequired['Key']
+    """Lower bound."""
+    upper: NotRequired['Key']
+    """Upper bound."""
+class DataEntry(TypedDict, total=True):
+    """Data entry."""
+    key: 'RemoteObject'
+    """Key object."""
+    primaryKey: 'RemoteObject'
+    """Primary key object."""
+    value: 'RemoteObject'
+    """Value object."""
+class KeyPath(TypedDict, total=True):
+    """Key path."""
+    type: 'Literal["null", "string", "array"]'
+    """Key path type."""
+    string: NotRequired['str']
+    """String value."""
+    array: NotRequired['List[str]']
+    """Array value."""