chromedeveloperprotocol-client 0.1.0__py3-none-any.whl

cdp/protocol/runtime/methods/service.py

@@ -0,0 +1,274 @@
+"""CDP Runtime 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 RuntimeMethods:
+    """
+    Methods for the Runtime domain.
+    """
+    def __init__(self, client: "Client"):
+        """
+        Initialize the Runtime methods.
+        
+        Args:
+            client ("Client"): The parent CDP client instance.
+        """
+        self.client = client
+
+    async def await_promise(self, params: Optional[awaitPromiseParameters]=None,session_id: Optional[str] = None) -> awaitPromiseReturns:
+        """
+    Add handler to promise with given promise object id.    
+        Args:
+            params (awaitPromiseParameters, optional): Parameters for the awaitPromise method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    awaitPromiseReturns: The result of the awaitPromise call.
+        """
+        return await self.client.send(method="Runtime.awaitPromise", params=params,session_id=session_id)
+    async def call_function_on(self, params: Optional[callFunctionOnParameters]=None,session_id: Optional[str] = None) -> callFunctionOnReturns:
+        """
+    Calls function with given declaration on the given object. Object group of the result is inherited from the target object.    
+        Args:
+            params (callFunctionOnParameters, optional): Parameters for the callFunctionOn method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    callFunctionOnReturns: The result of the callFunctionOn call.
+        """
+        return await self.client.send(method="Runtime.callFunctionOn", params=params,session_id=session_id)
+    async def compile_script(self, params: Optional[compileScriptParameters]=None,session_id: Optional[str] = None) -> compileScriptReturns:
+        """
+    Compiles expression.    
+        Args:
+            params (compileScriptParameters, optional): Parameters for the compileScript method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    compileScriptReturns: The result of the compileScript call.
+        """
+        return await self.client.send(method="Runtime.compileScript", params=params,session_id=session_id)
+    async def disable(self, params: None=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Disables reporting of execution contexts creation.    
+        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="Runtime.disable", params=params,session_id=session_id)
+    async def discard_console_entries(self, params: None=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Discards collected exceptions and console API calls.    
+        Args:
+            params (None, optional): Parameters for the discardConsoleEntries method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the discardConsoleEntries call.
+        """
+        return await self.client.send(method="Runtime.discardConsoleEntries", params=params,session_id=session_id)
+    async def enable(self, params: None=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Enables reporting of execution contexts creation by means of `executionContextCreated` event. When the reporting gets enabled the event will be sent immediately for each existing execution context.    
+        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="Runtime.enable", params=params,session_id=session_id)
+    async def evaluate(self, params: Optional[evaluateParameters]=None,session_id: Optional[str] = None) -> evaluateReturns:
+        """
+    Evaluates expression on global object.    
+        Args:
+            params (evaluateParameters, optional): Parameters for the evaluate method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    evaluateReturns: The result of the evaluate call.
+        """
+        return await self.client.send(method="Runtime.evaluate", params=params,session_id=session_id)
+    async def get_isolate_id(self, params: None=None,session_id: Optional[str] = None) -> getIsolateIdReturns:
+        """
+    Returns the isolate id.    
+        Args:
+            params (None, optional): Parameters for the getIsolateId method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    getIsolateIdReturns: The result of the getIsolateId call.
+        """
+        return await self.client.send(method="Runtime.getIsolateId", params=params,session_id=session_id)
+    async def get_heap_usage(self, params: None=None,session_id: Optional[str] = None) -> getHeapUsageReturns:
+        """
+    Returns the JavaScript heap usage. It is the total usage of the corresponding isolate not scoped to a particular Runtime.    
+        Args:
+            params (None, optional): Parameters for the getHeapUsage method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    getHeapUsageReturns: The result of the getHeapUsage call.
+        """
+        return await self.client.send(method="Runtime.getHeapUsage", params=params,session_id=session_id)
+    async def get_properties(self, params: Optional[getPropertiesParameters]=None,session_id: Optional[str] = None) -> getPropertiesReturns:
+        """
+    Returns properties of a given object. Object group of the result is inherited from the target object.    
+        Args:
+            params (getPropertiesParameters, optional): Parameters for the getProperties method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    getPropertiesReturns: The result of the getProperties call.
+        """
+        return await self.client.send(method="Runtime.getProperties", params=params,session_id=session_id)
+    async def global_lexical_scope_names(self, params: Optional[globalLexicalScopeNamesParameters]=None,session_id: Optional[str] = None) -> globalLexicalScopeNamesReturns:
+        """
+    Returns all let, const and class variables from global scope.    
+        Args:
+            params (globalLexicalScopeNamesParameters, optional): Parameters for the globalLexicalScopeNames method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    globalLexicalScopeNamesReturns: The result of the globalLexicalScopeNames call.
+        """
+        return await self.client.send(method="Runtime.globalLexicalScopeNames", params=params,session_id=session_id)
+    async def query_objects(self, params: Optional[queryObjectsParameters]=None,session_id: Optional[str] = None) -> queryObjectsReturns:
+        """
+    No description available for queryObjects.    
+        Args:
+            params (queryObjectsParameters, optional): Parameters for the queryObjects method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    queryObjectsReturns: The result of the queryObjects call.
+        """
+        return await self.client.send(method="Runtime.queryObjects", params=params,session_id=session_id)
+    async def release_object(self, params: Optional[releaseObjectParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Releases remote object with given id.    
+        Args:
+            params (releaseObjectParameters, optional): Parameters for the releaseObject method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the releaseObject call.
+        """
+        return await self.client.send(method="Runtime.releaseObject", params=params,session_id=session_id)
+    async def release_object_group(self, params: Optional[releaseObjectGroupParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Releases all remote objects that belong to a given group.    
+        Args:
+            params (releaseObjectGroupParameters, optional): Parameters for the releaseObjectGroup method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the releaseObjectGroup call.
+        """
+        return await self.client.send(method="Runtime.releaseObjectGroup", params=params,session_id=session_id)
+    async def run_if_waiting_for_debugger(self, params: None=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Tells inspected instance to run if it was waiting for debugger to attach.    
+        Args:
+            params (None, optional): Parameters for the runIfWaitingForDebugger method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the runIfWaitingForDebugger call.
+        """
+        return await self.client.send(method="Runtime.runIfWaitingForDebugger", params=params,session_id=session_id)
+    async def run_script(self, params: Optional[runScriptParameters]=None,session_id: Optional[str] = None) -> runScriptReturns:
+        """
+    Runs script with given id in a given context.    
+        Args:
+            params (runScriptParameters, optional): Parameters for the runScript method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    runScriptReturns: The result of the runScript call.
+        """
+        return await self.client.send(method="Runtime.runScript", params=params,session_id=session_id)
+    async def set_async_call_stack_depth(self, params: Optional[setAsyncCallStackDepthParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Enables or disables async call stacks tracking.    
+        Args:
+            params (setAsyncCallStackDepthParameters, optional): Parameters for the setAsyncCallStackDepth method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the setAsyncCallStackDepth call.
+        """
+        return await self.client.send(method="Runtime.setAsyncCallStackDepth", params=params,session_id=session_id)
+    async def set_custom_object_formatter_enabled(self, params: Optional[setCustomObjectFormatterEnabledParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    No description available for setCustomObjectFormatterEnabled.    
+        Args:
+            params (setCustomObjectFormatterEnabledParameters, optional): Parameters for the setCustomObjectFormatterEnabled method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the setCustomObjectFormatterEnabled call.
+        """
+        return await self.client.send(method="Runtime.setCustomObjectFormatterEnabled", params=params,session_id=session_id)
+    async def set_max_call_stack_size_to_capture(self, params: Optional[setMaxCallStackSizeToCaptureParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    No description available for setMaxCallStackSizeToCapture.    
+        Args:
+            params (setMaxCallStackSizeToCaptureParameters, optional): Parameters for the setMaxCallStackSizeToCapture method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the setMaxCallStackSizeToCapture call.
+        """
+        return await self.client.send(method="Runtime.setMaxCallStackSizeToCapture", params=params,session_id=session_id)
+    async def terminate_execution(self, params: None=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Terminate current or next JavaScript execution. Will cancel the termination when the outer-most script execution ends.    
+        Args:
+            params (None, optional): Parameters for the terminateExecution method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the terminateExecution call.
+        """
+        return await self.client.send(method="Runtime.terminateExecution", params=params,session_id=session_id)
+    async def add_binding(self, params: Optional[addBindingParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    If executionContextId is empty, adds binding with the given name on the global objects of all inspected contexts, including those created later, bindings survive reloads. Binding function takes exactly one argument, this argument should be string, in case of any other input, function throws an exception. Each binding function call produces Runtime.bindingCalled notification.    
+        Args:
+            params (addBindingParameters, optional): Parameters for the addBinding method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the addBinding call.
+        """
+        return await self.client.send(method="Runtime.addBinding", params=params,session_id=session_id)
+    async def remove_binding(self, params: Optional[removeBindingParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    This method does not remove binding function from global object but unsubscribes current runtime agent from Runtime.bindingCalled notifications.    
+        Args:
+            params (removeBindingParameters, optional): Parameters for the removeBinding method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the removeBinding call.
+        """
+        return await self.client.send(method="Runtime.removeBinding", params=params,session_id=session_id)
+    async def get_exception_details(self, params: Optional[getExceptionDetailsParameters]=None,session_id: Optional[str] = None) -> getExceptionDetailsReturns:
+        """
+    This method tries to lookup and populate exception details for a JavaScript Error object. Note that the stackTrace portion of the resulting exceptionDetails will only be populated if the Runtime domain was enabled at the time when the Error was thrown.    
+        Args:
+            params (getExceptionDetailsParameters, optional): Parameters for the getExceptionDetails method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    getExceptionDetailsReturns: The result of the getExceptionDetails call.
+        """
+        return await self.client.send(method="Runtime.getExceptionDetails", params=params,session_id=session_id)

cdp/protocol/runtime/methods/types.py

@@ -0,0 +1,226 @@
+"""CDP Runtime 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.runtime.types import CallArgument
+    from cdp.protocol.runtime.types import ExceptionDetails
+    from cdp.protocol.runtime.types import ExecutionContextId
+    from cdp.protocol.runtime.types import InternalPropertyDescriptor
+    from cdp.protocol.runtime.types import PrivatePropertyDescriptor
+    from cdp.protocol.runtime.types import PropertyDescriptor
+    from cdp.protocol.runtime.types import RemoteObject
+    from cdp.protocol.runtime.types import RemoteObjectId
+    from cdp.protocol.runtime.types import ScriptId
+    from cdp.protocol.runtime.types import SerializationOptions
+    from cdp.protocol.runtime.types import TimeDelta
+
+class awaitPromiseParameters(TypedDict, total=True):
+    promiseObjectId: 'RemoteObjectId'
+    """Identifier of the promise."""
+    returnByValue: NotRequired['bool']
+    """Whether the result is expected to be a JSON object that should be sent by value."""
+    generatePreview: NotRequired['bool']
+    """Whether preview should be generated for the result."""
+class callFunctionOnParameters(TypedDict, total=True):
+    functionDeclaration: 'str'
+    """Declaration of the function to call."""
+    objectId: NotRequired['RemoteObjectId']
+    """Identifier of the object to call function on. Either objectId or executionContextId should be specified."""
+    arguments: NotRequired['List[CallArgument]']
+    """Call arguments. All call arguments must belong to the same JavaScript world as the target object."""
+    silent: NotRequired['bool']
+    """In silent mode exceptions thrown during evaluation are not reported and do not pause execution. Overrides setPauseOnException state."""
+    returnByValue: NotRequired['bool']
+    """Whether the result is expected to be a JSON object which should be sent by value. Can be overriden by serializationOptions."""
+    generatePreview: NotRequired['bool']
+    """Whether preview should be generated for the result."""
+    userGesture: NotRequired['bool']
+    """Whether execution should be treated as initiated by user in the UI."""
+    awaitPromise: NotRequired['bool']
+    """Whether execution should await for resulting value and return once awaited promise is resolved."""
+    executionContextId: NotRequired['ExecutionContextId']
+    """Specifies execution context which global object will be used to call function on. Either executionContextId or objectId should be specified."""
+    objectGroup: NotRequired['str']
+    """Symbolic group name that can be used to release multiple objects. If objectGroup is not specified and objectId is, objectGroup will be inherited from object."""
+    throwOnSideEffect: NotRequired['bool']
+    """Whether to throw an exception if side effect cannot be ruled out during evaluation."""
+    uniqueContextId: NotRequired['str']
+    """An alternative way to specify the execution context to call function on. Compared to contextId that may be reused across processes, this is guaranteed to be system-unique, so it can be used to prevent accidental function call in context different than intended (e.g. as a result of navigation across process boundaries). This is mutually exclusive with executionContextId."""
+    serializationOptions: NotRequired['SerializationOptions']
+    """Specifies the result serialization. If provided, overrides generatePreview and returnByValue."""
+class compileScriptParameters(TypedDict, total=True):
+    expression: 'str'
+    """Expression to compile."""
+    sourceURL: 'str'
+    """Source url to be set for the script."""
+    persistScript: 'bool'
+    """Specifies whether the compiled script should be persisted."""
+    executionContextId: NotRequired['ExecutionContextId']
+    """Specifies in which execution context to perform script run. If the parameter is omitted the evaluation will be performed in the context of the inspected page."""
+
+
+
+class evaluateParameters(TypedDict, total=True):
+    expression: 'str'
+    """Expression to evaluate."""
+    objectGroup: NotRequired['str']
+    """Symbolic group name that can be used to release multiple objects."""
+    includeCommandLineAPI: NotRequired['bool']
+    """Determines whether Command Line API should be available during the evaluation."""
+    silent: NotRequired['bool']
+    """In silent mode exceptions thrown during evaluation are not reported and do not pause execution. Overrides setPauseOnException state."""
+    contextId: NotRequired['ExecutionContextId']
+    """Specifies in which execution context to perform evaluation. If the parameter is omitted the evaluation will be performed in the context of the inspected page. This is mutually exclusive with uniqueContextId, which offers an alternative way to identify the execution context that is more reliable in a multi-process environment."""
+    returnByValue: NotRequired['bool']
+    """Whether the result is expected to be a JSON object that should be sent by value."""
+    generatePreview: NotRequired['bool']
+    """Whether preview should be generated for the result."""
+    userGesture: NotRequired['bool']
+    """Whether execution should be treated as initiated by user in the UI."""
+    awaitPromise: NotRequired['bool']
+    """Whether execution should await for resulting value and return once awaited promise is resolved."""
+    throwOnSideEffect: NotRequired['bool']
+    """Whether to throw an exception if side effect cannot be ruled out during evaluation. This implies disableBreaks below."""
+    timeout: NotRequired['TimeDelta']
+    """Terminate execution after timing out (number of milliseconds)."""
+    disableBreaks: NotRequired['bool']
+    """Disable breakpoints during execution."""
+    replMode: NotRequired['bool']
+    """Setting this flag to true enables let re-declaration and top-level await. Note that let variables can only be re-declared if they originate from replMode themselves."""
+    allowUnsafeEvalBlockedByCSP: NotRequired['bool']
+    """The Content Security Policy (CSP) for the target might block 'unsafe-eval' which includes eval(), Function(), setTimeout() and setInterval() when called with non-callable arguments. This flag bypasses CSP for this evaluation and allows unsafe-eval. Defaults to true."""
+    uniqueContextId: NotRequired['str']
+    """An alternative way to specify the execution context to evaluate in. Compared to contextId that may be reused across processes, this is guaranteed to be system-unique, so it can be used to prevent accidental evaluation of the expression in context different than intended (e.g. as a result of navigation across process boundaries). This is mutually exclusive with contextId."""
+    serializationOptions: NotRequired['SerializationOptions']
+    """Specifies the result serialization. If provided, overrides generatePreview and returnByValue."""
+
+
+class getPropertiesParameters(TypedDict, total=True):
+    objectId: 'RemoteObjectId'
+    """Identifier of the object to return properties for."""
+    ownProperties: NotRequired['bool']
+    """If true, returns properties belonging only to the element itself, not to its prototype chain."""
+    accessorPropertiesOnly: NotRequired['bool']
+    """If true, returns accessor properties (with getter/setter) only; internal properties are not returned either."""
+    generatePreview: NotRequired['bool']
+    """Whether preview should be generated for the results."""
+    nonIndexedPropertiesOnly: NotRequired['bool']
+    """If true, returns non-indexed properties only."""
+class globalLexicalScopeNamesParameters(TypedDict, total=False):
+    executionContextId: NotRequired['ExecutionContextId']
+    """Specifies in which execution context to lookup global scope variables."""
+class queryObjectsParameters(TypedDict, total=True):
+    prototypeObjectId: 'RemoteObjectId'
+    """Identifier of the prototype to return objects for."""
+    objectGroup: NotRequired['str']
+    """Symbolic group name that can be used to release the results."""
+class releaseObjectParameters(TypedDict, total=True):
+    objectId: 'RemoteObjectId'
+    """Identifier of the object to release."""
+class releaseObjectGroupParameters(TypedDict, total=True):
+    objectGroup: 'str'
+    """Symbolic object group name."""
+
+class runScriptParameters(TypedDict, total=True):
+    scriptId: 'ScriptId'
+    """Id of the script to run."""
+    executionContextId: NotRequired['ExecutionContextId']
+    """Specifies in which execution context to perform script run. If the parameter is omitted the evaluation will be performed in the context of the inspected page."""
+    objectGroup: NotRequired['str']
+    """Symbolic group name that can be used to release multiple objects."""
+    silent: NotRequired['bool']
+    """In silent mode exceptions thrown during evaluation are not reported and do not pause execution. Overrides setPauseOnException state."""
+    includeCommandLineAPI: NotRequired['bool']
+    """Determines whether Command Line API should be available during the evaluation."""
+    returnByValue: NotRequired['bool']
+    """Whether the result is expected to be a JSON object which should be sent by value."""
+    generatePreview: NotRequired['bool']
+    """Whether preview should be generated for the result."""
+    awaitPromise: NotRequired['bool']
+    """Whether execution should await for resulting value and return once awaited promise is resolved."""
+class setAsyncCallStackDepthParameters(TypedDict, total=True):
+    maxDepth: 'int'
+    """Maximum depth of async call stacks. Setting to 0 will effectively disable collecting async call stacks (default)."""
+class setCustomObjectFormatterEnabledParameters(TypedDict, total=True):
+    enabled: 'bool'
+class setMaxCallStackSizeToCaptureParameters(TypedDict, total=True):
+    size: 'int'
+
+class addBindingParameters(TypedDict, total=True):
+    name: 'str'
+    executionContextId: NotRequired['ExecutionContextId']
+    """If specified, the binding would only be exposed to the specified execution context. If omitted and executionContextName is not set, the binding is exposed to all execution contexts of the target. This parameter is mutually exclusive with executionContextName. Deprecated in favor of executionContextName due to an unclear use case and bugs in implementation (crbug.com/1169639). executionContextId will be removed in the future."""
+    executionContextName: NotRequired['str']
+    """If specified, the binding is exposed to the executionContext with matching name, even for contexts created after the binding is added. See also ExecutionContext.name and worldName parameter to Page.addScriptToEvaluateOnNewDocument. This parameter is mutually exclusive with executionContextId."""
+class removeBindingParameters(TypedDict, total=True):
+    name: 'str'
+class getExceptionDetailsParameters(TypedDict, total=True):
+    errorObjectId: 'RemoteObjectId'
+    """The error object for which to resolve the exception details."""
+class awaitPromiseReturns(TypedDict):
+    result: 'RemoteObject'
+    """Promise result. Will contain rejected value if promise was rejected."""
+    exceptionDetails: 'ExceptionDetails'
+    """Exception details if stack strace is available."""
+class callFunctionOnReturns(TypedDict):
+    result: 'RemoteObject'
+    """Call result."""
+    exceptionDetails: 'ExceptionDetails'
+    """Exception details."""
+class compileScriptReturns(TypedDict):
+    scriptId: 'ScriptId'
+    """Id of the script."""
+    exceptionDetails: 'ExceptionDetails'
+    """Exception details."""
+
+
+
+class evaluateReturns(TypedDict):
+    result: 'RemoteObject'
+    """Evaluation result."""
+    exceptionDetails: 'ExceptionDetails'
+    """Exception details."""
+class getIsolateIdReturns(TypedDict):
+    id: 'str'
+    """The isolate id."""
+class getHeapUsageReturns(TypedDict):
+    usedSize: 'float'
+    """Used JavaScript heap size in bytes."""
+    totalSize: 'float'
+    """Allocated JavaScript heap size in bytes."""
+    embedderHeapUsedSize: 'float'
+    """Used size in bytes in the embedder's garbage-collected heap."""
+    backingStorageSize: 'float'
+    """Size in bytes of backing storage for array buffers and external strings."""
+class getPropertiesReturns(TypedDict):
+    result: 'List[PropertyDescriptor]'
+    """Object properties."""
+    internalProperties: 'List[InternalPropertyDescriptor]'
+    """Internal object properties (only of the element itself)."""
+    privateProperties: 'List[PrivatePropertyDescriptor]'
+    """Object private properties."""
+    exceptionDetails: 'ExceptionDetails'
+    """Exception details."""
+class globalLexicalScopeNamesReturns(TypedDict):
+    names: 'List[str]'
+class queryObjectsReturns(TypedDict):
+    objects: 'RemoteObject'
+    """Array with objects."""
+
+
+
+class runScriptReturns(TypedDict):
+    result: 'RemoteObject'
+    """Run result."""
+    exceptionDetails: 'ExceptionDetails'
+    """Exception details."""
+
+
+
+
+
+
+class getExceptionDetailsReturns(TypedDict):
+    exceptionDetails: 'ExceptionDetails'

cdp/protocol/runtime/service.py

@@ -0,0 +1,21 @@
+"""CDP Runtime Domain"""
+from typing import TYPE_CHECKING
+from .methods.service import RuntimeMethods
+from .events.service import RuntimeEvents
+
+if TYPE_CHECKING:
+    from ...service import Client
+
+class Runtime(RuntimeMethods, RuntimeEvents):
+    """
+    Runtime domain exposes JavaScript runtime by means of remote evaluation and mirror objects. Evaluation results are returned as mirror object that expose object type, string representation and unique identifier that can be used for further object reference. Original objects are maintained in memory unless they are either explicitly released or are released along with the other objects in their object group.
+    """
+    def __init__(self, client: "Client"):
+        """
+        Initialize the Runtime domain.
+        
+        Args:
+            client ("Client"): The parent CDP client instance.
+        """
+        RuntimeMethods.__init__(self, client)
+        RuntimeEvents.__init__(self, client)