chromedeveloperprotocol-client 0.1.0__py3-none-any.whl

cdp/protocol/network/methods/service.py

@@ -0,0 +1,384 @@
+"""CDP Network 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 NetworkMethods:
+    """
+    Methods for the Network domain.
+    """
+    def __init__(self, client: "Client"):
+        """
+        Initialize the Network methods.
+        
+        Args:
+            client ("Client"): The parent CDP client instance.
+        """
+        self.client = client
+
+    async def set_accepted_encodings(self, params: Optional[setAcceptedEncodingsParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Sets a list of content encodings that will be accepted. Empty list means no encoding is accepted.    
+        Args:
+            params (setAcceptedEncodingsParameters, optional): Parameters for the setAcceptedEncodings method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the setAcceptedEncodings call.
+        """
+        return await self.client.send(method="Network.setAcceptedEncodings", params=params,session_id=session_id)
+    async def clear_accepted_encodings_override(self, params: None=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Clears accepted encodings set by setAcceptedEncodings    
+        Args:
+            params (None, optional): Parameters for the clearAcceptedEncodingsOverride method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the clearAcceptedEncodingsOverride call.
+        """
+        return await self.client.send(method="Network.clearAcceptedEncodingsOverride", params=params,session_id=session_id)
+    async def clear_browser_cache(self, params: None=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Clears browser cache.    
+        Args:
+            params (None, optional): Parameters for the clearBrowserCache method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the clearBrowserCache call.
+        """
+        return await self.client.send(method="Network.clearBrowserCache", params=params,session_id=session_id)
+    async def clear_browser_cookies(self, params: None=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Clears browser cookies.    
+        Args:
+            params (None, optional): Parameters for the clearBrowserCookies method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the clearBrowserCookies call.
+        """
+        return await self.client.send(method="Network.clearBrowserCookies", params=params,session_id=session_id)
+    async def delete_cookies(self, params: Optional[deleteCookiesParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Deletes browser cookies with matching name and url or domain/path/partitionKey pair.    
+        Args:
+            params (deleteCookiesParameters, optional): Parameters for the deleteCookies method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the deleteCookies call.
+        """
+        return await self.client.send(method="Network.deleteCookies", params=params,session_id=session_id)
+    async def disable(self, params: None=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Disables network tracking, prevents network events from being sent to the client.    
+        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="Network.disable", params=params,session_id=session_id)
+    async def emulate_network_conditions_by_rule(self, params: Optional[emulateNetworkConditionsByRuleParameters]=None,session_id: Optional[str] = None) -> emulateNetworkConditionsByRuleReturns:
+        """
+    Activates emulation of network conditions for individual requests using URL match patterns. Unlike the deprecated Network.emulateNetworkConditions this method does not affect `navigator` state. Use Network.overrideNetworkState to explicitly modify `navigator` behavior.    
+        Args:
+            params (emulateNetworkConditionsByRuleParameters, optional): Parameters for the emulateNetworkConditionsByRule method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    emulateNetworkConditionsByRuleReturns: The result of the emulateNetworkConditionsByRule call.
+        """
+        return await self.client.send(method="Network.emulateNetworkConditionsByRule", params=params,session_id=session_id)
+    async def override_network_state(self, params: Optional[overrideNetworkStateParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Override the state of navigator.onLine and navigator.connection.    
+        Args:
+            params (overrideNetworkStateParameters, optional): Parameters for the overrideNetworkState method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the overrideNetworkState call.
+        """
+        return await self.client.send(method="Network.overrideNetworkState", params=params,session_id=session_id)
+    async def enable(self, params: Optional[enableParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Enables network tracking, network events will now be delivered to the client.    
+        Args:
+            params (enableParameters, 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="Network.enable", params=params,session_id=session_id)
+    async def configure_durable_messages(self, params: Optional[configureDurableMessagesParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Configures storing response bodies outside of renderer, so that these survive a cross-process navigation. If maxTotalBufferSize is not set, durable messages are disabled.    
+        Args:
+            params (configureDurableMessagesParameters, optional): Parameters for the configureDurableMessages method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the configureDurableMessages call.
+        """
+        return await self.client.send(method="Network.configureDurableMessages", params=params,session_id=session_id)
+    async def get_certificate(self, params: Optional[getCertificateParameters]=None,session_id: Optional[str] = None) -> getCertificateReturns:
+        """
+    Returns the DER-encoded certificate.    
+        Args:
+            params (getCertificateParameters, optional): Parameters for the getCertificate method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    getCertificateReturns: The result of the getCertificate call.
+        """
+        return await self.client.send(method="Network.getCertificate", params=params,session_id=session_id)
+    async def get_cookies(self, params: Optional[getCookiesParameters]=None,session_id: Optional[str] = None) -> getCookiesReturns:
+        """
+    Returns all browser cookies for the current URL. Depending on the backend support, will return detailed cookie information in the `cookies` field.    
+        Args:
+            params (getCookiesParameters, optional): Parameters for the getCookies method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    getCookiesReturns: The result of the getCookies call.
+        """
+        return await self.client.send(method="Network.getCookies", params=params,session_id=session_id)
+    async def get_response_body(self, params: Optional[getResponseBodyParameters]=None,session_id: Optional[str] = None) -> getResponseBodyReturns:
+        """
+    Returns content served for the given request.    
+        Args:
+            params (getResponseBodyParameters, optional): Parameters for the getResponseBody method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    getResponseBodyReturns: The result of the getResponseBody call.
+        """
+        return await self.client.send(method="Network.getResponseBody", params=params,session_id=session_id)
+    async def get_request_post_data(self, params: Optional[getRequestPostDataParameters]=None,session_id: Optional[str] = None) -> getRequestPostDataReturns:
+        """
+    Returns post data sent with the request. Returns an error when no data was sent with the request.    
+        Args:
+            params (getRequestPostDataParameters, optional): Parameters for the getRequestPostData method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    getRequestPostDataReturns: The result of the getRequestPostData call.
+        """
+        return await self.client.send(method="Network.getRequestPostData", params=params,session_id=session_id)
+    async def get_response_body_for_interception(self, params: Optional[getResponseBodyForInterceptionParameters]=None,session_id: Optional[str] = None) -> getResponseBodyForInterceptionReturns:
+        """
+    Returns content served for the given currently intercepted request.    
+        Args:
+            params (getResponseBodyForInterceptionParameters, optional): Parameters for the getResponseBodyForInterception method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    getResponseBodyForInterceptionReturns: The result of the getResponseBodyForInterception call.
+        """
+        return await self.client.send(method="Network.getResponseBodyForInterception", params=params,session_id=session_id)
+    async def take_response_body_for_interception_as_stream(self, params: Optional[takeResponseBodyForInterceptionAsStreamParameters]=None,session_id: Optional[str] = None) -> takeResponseBodyForInterceptionAsStreamReturns:
+        """
+    Returns a handle to the stream representing the response body. Note that after this command, the intercepted request can't be continued as is -- you either need to cancel it or to provide the response body. The stream only supports sequential read, IO.read will fail if the position is specified.    
+        Args:
+            params (takeResponseBodyForInterceptionAsStreamParameters, optional): Parameters for the takeResponseBodyForInterceptionAsStream method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    takeResponseBodyForInterceptionAsStreamReturns: The result of the takeResponseBodyForInterceptionAsStream call.
+        """
+        return await self.client.send(method="Network.takeResponseBodyForInterceptionAsStream", params=params,session_id=session_id)
+    async def replay_xhr(self, params: Optional[replayXHRParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    This method sends a new XMLHttpRequest which is identical to the original one. The following parameters should be identical: method, url, async, request body, extra headers, withCredentials attribute, user, password.    
+        Args:
+            params (replayXHRParameters, optional): Parameters for the replayXHR method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the replayXHR call.
+        """
+        return await self.client.send(method="Network.replayXHR", params=params,session_id=session_id)
+    async def search_in_response_body(self, params: Optional[searchInResponseBodyParameters]=None,session_id: Optional[str] = None) -> searchInResponseBodyReturns:
+        """
+    Searches for given string in response content.    
+        Args:
+            params (searchInResponseBodyParameters, optional): Parameters for the searchInResponseBody method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    searchInResponseBodyReturns: The result of the searchInResponseBody call.
+        """
+        return await self.client.send(method="Network.searchInResponseBody", params=params,session_id=session_id)
+    async def set_blocked_ur_ls(self, params: Optional[setBlockedURLsParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Blocks URLs from loading.    
+        Args:
+            params (setBlockedURLsParameters, optional): Parameters for the setBlockedURLs method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the setBlockedURLs call.
+        """
+        return await self.client.send(method="Network.setBlockedURLs", params=params,session_id=session_id)
+    async def set_bypass_service_worker(self, params: Optional[setBypassServiceWorkerParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Toggles ignoring of service worker for each request.    
+        Args:
+            params (setBypassServiceWorkerParameters, optional): Parameters for the setBypassServiceWorker method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the setBypassServiceWorker call.
+        """
+        return await self.client.send(method="Network.setBypassServiceWorker", params=params,session_id=session_id)
+    async def set_cache_disabled(self, params: Optional[setCacheDisabledParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Toggles ignoring cache for each request. If `true`, cache will not be used.    
+        Args:
+            params (setCacheDisabledParameters, optional): Parameters for the setCacheDisabled method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the setCacheDisabled call.
+        """
+        return await self.client.send(method="Network.setCacheDisabled", params=params,session_id=session_id)
+    async def set_cookie(self, params: Optional[setCookieParameters]=None,session_id: Optional[str] = None) -> setCookieReturns:
+        """
+    Sets a cookie with the given cookie data; may overwrite equivalent cookies if they exist.    
+        Args:
+            params (setCookieParameters, optional): Parameters for the setCookie method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    setCookieReturns: The result of the setCookie call.
+        """
+        return await self.client.send(method="Network.setCookie", params=params,session_id=session_id)
+    async def set_cookies(self, params: Optional[setCookiesParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Sets given cookies.    
+        Args:
+            params (setCookiesParameters, optional): Parameters for the setCookies method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the setCookies call.
+        """
+        return await self.client.send(method="Network.setCookies", params=params,session_id=session_id)
+    async def set_extra_http_headers(self, params: Optional[setExtraHTTPHeadersParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Specifies whether to always send extra HTTP headers with the requests from this page.    
+        Args:
+            params (setExtraHTTPHeadersParameters, optional): Parameters for the setExtraHTTPHeaders method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the setExtraHTTPHeaders call.
+        """
+        return await self.client.send(method="Network.setExtraHTTPHeaders", params=params,session_id=session_id)
+    async def set_attach_debug_stack(self, params: Optional[setAttachDebugStackParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Specifies whether to attach a page script stack id in requests    
+        Args:
+            params (setAttachDebugStackParameters, optional): Parameters for the setAttachDebugStack method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the setAttachDebugStack call.
+        """
+        return await self.client.send(method="Network.setAttachDebugStack", params=params,session_id=session_id)
+    async def set_user_agent_override(self, params: Optional[setUserAgentOverrideParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Allows overriding user agent with the given string.    
+        Args:
+            params (setUserAgentOverrideParameters, optional): Parameters for the setUserAgentOverride method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the setUserAgentOverride call.
+        """
+        return await self.client.send(method="Network.setUserAgentOverride", params=params,session_id=session_id)
+    async def stream_resource_content(self, params: Optional[streamResourceContentParameters]=None,session_id: Optional[str] = None) -> streamResourceContentReturns:
+        """
+    Enables streaming of the response for the given requestId. If enabled, the dataReceived event contains the data that was received during streaming.    
+        Args:
+            params (streamResourceContentParameters, optional): Parameters for the streamResourceContent method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    streamResourceContentReturns: The result of the streamResourceContent call.
+        """
+        return await self.client.send(method="Network.streamResourceContent", params=params,session_id=session_id)
+    async def get_security_isolation_status(self, params: Optional[getSecurityIsolationStatusParameters]=None,session_id: Optional[str] = None) -> getSecurityIsolationStatusReturns:
+        """
+    Returns information about the COEP/COOP isolation status.    
+        Args:
+            params (getSecurityIsolationStatusParameters, optional): Parameters for the getSecurityIsolationStatus method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    getSecurityIsolationStatusReturns: The result of the getSecurityIsolationStatus call.
+        """
+        return await self.client.send(method="Network.getSecurityIsolationStatus", params=params,session_id=session_id)
+    async def enable_reporting_api(self, params: Optional[enableReportingApiParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Enables tracking for the Reporting API, events generated by the Reporting API will now be delivered to the client. Enabling triggers 'reportingApiReportAdded' for all existing reports.    
+        Args:
+            params (enableReportingApiParameters, optional): Parameters for the enableReportingApi method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the enableReportingApi call.
+        """
+        return await self.client.send(method="Network.enableReportingApi", params=params,session_id=session_id)
+    async def enable_device_bound_sessions(self, params: Optional[enableDeviceBoundSessionsParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Sets up tracking device bound sessions and fetching of initial set of sessions.    
+        Args:
+            params (enableDeviceBoundSessionsParameters, optional): Parameters for the enableDeviceBoundSessions method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the enableDeviceBoundSessions call.
+        """
+        return await self.client.send(method="Network.enableDeviceBoundSessions", params=params,session_id=session_id)
+    async def fetch_schemeful_site(self, params: Optional[fetchSchemefulSiteParameters]=None,session_id: Optional[str] = None) -> fetchSchemefulSiteReturns:
+        """
+    Fetches the schemeful site for a specific origin.    
+        Args:
+            params (fetchSchemefulSiteParameters, optional): Parameters for the fetchSchemefulSite method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    fetchSchemefulSiteReturns: The result of the fetchSchemefulSite call.
+        """
+        return await self.client.send(method="Network.fetchSchemefulSite", params=params,session_id=session_id)
+    async def load_network_resource(self, params: Optional[loadNetworkResourceParameters]=None,session_id: Optional[str] = None) -> loadNetworkResourceReturns:
+        """
+    Fetches the resource and returns the content.    
+        Args:
+            params (loadNetworkResourceParameters, optional): Parameters for the loadNetworkResource method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    loadNetworkResourceReturns: The result of the loadNetworkResource call.
+        """
+        return await self.client.send(method="Network.loadNetworkResource", params=params,session_id=session_id)
+    async def set_cookie_controls(self, params: Optional[setCookieControlsParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Sets Controls for third-party cookie access Page reload is required before the new cookie behavior will be observed    
+        Args:
+            params (setCookieControlsParameters, optional): Parameters for the setCookieControls method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the setCookieControls call.
+        """
+        return await self.client.send(method="Network.setCookieControls", params=params,session_id=session_id)

cdp/protocol/network/methods/types.py

@@ -0,0 +1,252 @@
+"""CDP Network 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.debugger.types import SearchMatch
+    from cdp.protocol.emulation.types import UserAgentMetadata
+    from cdp.protocol.io.types import StreamHandle
+    from cdp.protocol.network.types import BlockPattern
+    from cdp.protocol.network.types import ConnectionType
+    from cdp.protocol.network.types import ContentEncoding
+    from cdp.protocol.network.types import Cookie
+    from cdp.protocol.network.types import CookieParam
+    from cdp.protocol.network.types import CookiePartitionKey
+    from cdp.protocol.network.types import CookiePriority
+    from cdp.protocol.network.types import CookieSameSite
+    from cdp.protocol.network.types import CookieSourceScheme
+    from cdp.protocol.network.types import Headers
+    from cdp.protocol.network.types import InterceptionId
+    from cdp.protocol.network.types import LoadNetworkResourceOptions
+    from cdp.protocol.network.types import LoadNetworkResourcePageResult
+    from cdp.protocol.network.types import NetworkConditions
+    from cdp.protocol.network.types import RequestId
+    from cdp.protocol.network.types import SecurityIsolationStatus
+    from cdp.protocol.network.types import TimeSinceEpoch
+    from cdp.protocol.page.types import FrameId
+
+class setAcceptedEncodingsParameters(TypedDict, total=True):
+    encodings: 'List[ContentEncoding]'
+    """List of accepted content encodings."""
+
+
+
+class deleteCookiesParameters(TypedDict, total=True):
+    name: 'str'
+    """Name of the cookies to remove."""
+    url: NotRequired['str']
+    """If specified, deletes all the cookies with the given name where domain and path match provided URL."""
+    domain: NotRequired['str']
+    """If specified, deletes only cookies with the exact domain."""
+    path: NotRequired['str']
+    """If specified, deletes only cookies with the exact path."""
+    partitionKey: NotRequired['CookiePartitionKey']
+    """If specified, deletes only cookies with the the given name and partitionKey where all partition key attributes match the cookie partition key attribute."""
+
+class emulateNetworkConditionsByRuleParameters(TypedDict, total=True):
+    offline: 'bool'
+    """True to emulate internet disconnection."""
+    matchedNetworkConditions: 'List[NetworkConditions]'
+    """Configure conditions for matching requests. If multiple entries match a request, the first entry wins.  Global conditions can be configured by leaving the urlPattern for the conditions empty. These global conditions are also applied for throttling of p2p connections."""
+class overrideNetworkStateParameters(TypedDict, total=True):
+    offline: 'bool'
+    """True to emulate internet disconnection."""
+    latency: 'float'
+    """Minimum latency from request sent to response headers received (ms)."""
+    downloadThroughput: 'float'
+    """Maximal aggregated download throughput (bytes/sec). -1 disables download throttling."""
+    uploadThroughput: 'float'
+    """Maximal aggregated upload throughput (bytes/sec).  -1 disables upload throttling."""
+    connectionType: NotRequired['ConnectionType']
+    """Connection type if known."""
+class enableParameters(TypedDict, total=False):
+    maxTotalBufferSize: NotRequired['int']
+    """Buffer size in bytes to use when preserving network payloads (XHRs, etc)."""
+    maxResourceBufferSize: NotRequired['int']
+    """Per-resource buffer size in bytes to use when preserving network payloads (XHRs, etc)."""
+    maxPostDataSize: NotRequired['int']
+    """Longest post body size (in bytes) that would be included in requestWillBeSent notification"""
+    reportDirectSocketTraffic: NotRequired['bool']
+    """Whether DirectSocket chunk send/receive events should be reported."""
+    enableDurableMessages: NotRequired['bool']
+    """Enable storing response bodies outside of renderer, so that these survive a cross-process navigation. Requires maxTotalBufferSize to be set. Currently defaults to false. This field is being deprecated in favor of the dedicated configureDurableMessages command, due to the possibility of deadlocks when awaiting Network.enable before issuing Runtime.runIfWaitingForDebugger."""
+class configureDurableMessagesParameters(TypedDict, total=False):
+    maxTotalBufferSize: NotRequired['int']
+    """Buffer size in bytes to use when preserving network payloads (XHRs, etc)."""
+    maxResourceBufferSize: NotRequired['int']
+    """Per-resource buffer size in bytes to use when preserving network payloads (XHRs, etc)."""
+class getCertificateParameters(TypedDict, total=True):
+    origin: 'str'
+    """Origin to get certificate for."""
+class getCookiesParameters(TypedDict, total=False):
+    urls: NotRequired['List[str]']
+    """The list of URLs for which applicable cookies will be fetched. If not specified, it's assumed to be set to the list containing the URLs of the page and all of its subframes."""
+class getResponseBodyParameters(TypedDict, total=True):
+    requestId: 'RequestId'
+    """Identifier of the network request to get content for."""
+class getRequestPostDataParameters(TypedDict, total=True):
+    requestId: 'RequestId'
+    """Identifier of the network request to get content for."""
+class getResponseBodyForInterceptionParameters(TypedDict, total=True):
+    interceptionId: 'InterceptionId'
+    """Identifier for the intercepted request to get body for."""
+class takeResponseBodyForInterceptionAsStreamParameters(TypedDict, total=True):
+    interceptionId: 'InterceptionId'
+class replayXHRParameters(TypedDict, total=True):
+    requestId: 'RequestId'
+    """Identifier of XHR to replay."""
+class searchInResponseBodyParameters(TypedDict, total=True):
+    requestId: 'RequestId'
+    """Identifier of the network response to search."""
+    query: 'str'
+    """String to search for."""
+    caseSensitive: NotRequired['bool']
+    """If true, search is case sensitive."""
+    isRegex: NotRequired['bool']
+    """If true, treats string parameter as regex."""
+class setBlockedURLsParameters(TypedDict, total=False):
+    urlPatterns: NotRequired['List[BlockPattern]']
+    """Patterns to match in the order in which they are given. These patterns also take precedence over any wildcard patterns defined in urls."""
+    urls: NotRequired['List[str]']
+    """URL patterns to block. Wildcards ('*') are allowed."""
+class setBypassServiceWorkerParameters(TypedDict, total=True):
+    bypass: 'bool'
+    """Bypass service worker and load from network."""
+class setCacheDisabledParameters(TypedDict, total=True):
+    cacheDisabled: 'bool'
+    """Cache disabled state."""
+class setCookieParameters(TypedDict, total=True):
+    name: 'str'
+    """Cookie name."""
+    value: 'str'
+    """Cookie value."""
+    url: NotRequired['str']
+    """The request-URI to associate with the setting of the cookie. This value can affect the default domain, path, source port, and source scheme values of the created cookie."""
+    domain: NotRequired['str']
+    """Cookie domain."""
+    path: NotRequired['str']
+    """Cookie path."""
+    secure: NotRequired['bool']
+    """True if cookie is secure."""
+    httpOnly: NotRequired['bool']
+    """True if cookie is http-only."""
+    sameSite: NotRequired['CookieSameSite']
+    """Cookie SameSite type."""
+    expires: NotRequired['TimeSinceEpoch']
+    """Cookie expiration date, session cookie if not set"""
+    priority: NotRequired['CookiePriority']
+    """Cookie Priority type."""
+    sourceScheme: NotRequired['CookieSourceScheme']
+    """Cookie source scheme type."""
+    sourcePort: NotRequired['int']
+    """Cookie source port. Valid values are {-1, [1, 65535]}, -1 indicates an unspecified port. An unspecified port value allows protocol clients to emulate legacy cookie scope for the port. This is a temporary ability and it will be removed in the future."""
+    partitionKey: NotRequired['CookiePartitionKey']
+    """Cookie partition key. If not set, the cookie will be set as not partitioned."""
+class setCookiesParameters(TypedDict, total=True):
+    cookies: 'List[CookieParam]'
+    """Cookies to be set."""
+class setExtraHTTPHeadersParameters(TypedDict, total=True):
+    headers: 'Headers'
+    """Map with extra HTTP headers."""
+class setAttachDebugStackParameters(TypedDict, total=True):
+    enabled: 'bool'
+    """Whether to attach a page script stack for debugging purpose."""
+class setUserAgentOverrideParameters(TypedDict, total=True):
+    userAgent: 'str'
+    """User agent to use."""
+    acceptLanguage: NotRequired['str']
+    """Browser language to emulate."""
+    platform: NotRequired['str']
+    """The platform navigator.platform should return."""
+    userAgentMetadata: NotRequired['UserAgentMetadata']
+    """To be sent in Sec-CH-UA-* headers and returned in navigator.userAgentData"""
+class streamResourceContentParameters(TypedDict, total=True):
+    requestId: 'RequestId'
+    """Identifier of the request to stream."""
+class getSecurityIsolationStatusParameters(TypedDict, total=False):
+    frameId: NotRequired['FrameId']
+    """If no frameId is provided, the status of the target is provided."""
+class enableReportingApiParameters(TypedDict, total=True):
+    enable: 'bool'
+    """Whether to enable or disable events for the Reporting API"""
+class enableDeviceBoundSessionsParameters(TypedDict, total=True):
+    enable: 'bool'
+    """Whether to enable or disable events."""
+class fetchSchemefulSiteParameters(TypedDict, total=True):
+    origin: 'str'
+    """The URL origin."""
+class loadNetworkResourceParameters(TypedDict, total=True):
+    url: 'str'
+    """URL of the resource to get content for."""
+    options: 'LoadNetworkResourceOptions'
+    """Options for the request."""
+    frameId: NotRequired['FrameId']
+    """Frame id to get the resource for. Mandatory for frame targets, and should be omitted for worker targets."""
+class setCookieControlsParameters(TypedDict, total=True):
+    enableThirdPartyCookieRestriction: 'bool'
+    """Whether 3pc restriction is enabled."""
+    disableThirdPartyCookieMetadata: 'bool'
+    """Whether 3pc grace period exception should be enabled; false by default."""
+    disableThirdPartyCookieHeuristics: 'bool'
+    """Whether 3pc heuristics exceptions should be enabled; false by default."""
+
+
+
+
+
+
+class emulateNetworkConditionsByRuleReturns(TypedDict):
+    ruleIds: 'List[str]'
+    """An id for each entry in matchedNetworkConditions. The id will be included in the requestWillBeSentExtraInfo for requests affected by a rule."""
+
+
+
+class getCertificateReturns(TypedDict):
+    tableNames: 'List[str]'
+class getCookiesReturns(TypedDict):
+    cookies: 'List[Cookie]'
+    """Array of cookie objects."""
+class getResponseBodyReturns(TypedDict):
+    body: 'str'
+    """Response body."""
+    base64Encoded: 'bool'
+    """True, if content was sent as base64."""
+class getRequestPostDataReturns(TypedDict):
+    postData: 'str'
+    """Request body string, omitting files from multipart requests"""
+    base64Encoded: 'bool'
+    """True, if content was sent as base64."""
+class getResponseBodyForInterceptionReturns(TypedDict):
+    body: 'str'
+    """Response body."""
+    base64Encoded: 'bool'
+    """True, if content was sent as base64."""
+class takeResponseBodyForInterceptionAsStreamReturns(TypedDict):
+    stream: 'StreamHandle'
+
+class searchInResponseBodyReturns(TypedDict):
+    result: 'List[SearchMatch]'
+    """List of search matches."""
+
+
+
+class setCookieReturns(TypedDict):
+    success: 'bool'
+    """Always set to true. If an error occurs, the response indicates protocol error."""
+
+
+
+
+class streamResourceContentReturns(TypedDict):
+    bufferedData: 'str'
+    """Data that has been buffered until streaming is enabled. (Encoded as a base64 string when passed over JSON)"""
+class getSecurityIsolationStatusReturns(TypedDict):
+    status: 'SecurityIsolationStatus'
+
+
+class fetchSchemefulSiteReturns(TypedDict):
+    schemefulSite: 'str'
+    """The corresponding schemeful site."""
+class loadNetworkResourceReturns(TypedDict):
+    resource: 'LoadNetworkResourcePageResult'

cdp/protocol/network/service.py

@@ -0,0 +1,21 @@
+"""CDP Network Domain"""
+from typing import TYPE_CHECKING
+from .methods.service import NetworkMethods
+from .events.service import NetworkEvents
+
+if TYPE_CHECKING:
+    from ...service import Client
+
+class Network(NetworkMethods, NetworkEvents):
+    """
+    Network domain allows tracking network activities of the page. It exposes information about http, file, data and other requests and responses, their headers, bodies, timing, etc.
+    """
+    def __init__(self, client: "Client"):
+        """
+        Initialize the Network domain.
+        
+        Args:
+            client ("Client"): The parent CDP client instance.
+        """
+        NetworkMethods.__init__(self, client)
+        NetworkEvents.__init__(self, client)