chromedeveloperprotocol-client 0.1.0__py3-none-any.whl

cdp/protocol/extensions/methods/service.py

@@ -0,0 +1,87 @@
+"""CDP Extensions 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 ExtensionsMethods:
+    """
+    Methods for the Extensions domain.
+    """
+    def __init__(self, client: "Client"):
+        """
+        Initialize the Extensions methods.
+        
+        Args:
+            client ("Client"): The parent CDP client instance.
+        """
+        self.client = client
+
+    async def load_unpacked(self, params: Optional[loadUnpackedParameters]=None,session_id: Optional[str] = None) -> loadUnpackedReturns:
+        """
+    Installs an unpacked extension from the filesystem similar to --load-extension CLI flags. Returns extension ID once the extension has been installed. Available if the client is connected using the --remote-debugging-pipe flag and the --enable-unsafe-extension-debugging flag is set.    
+        Args:
+            params (loadUnpackedParameters, optional): Parameters for the loadUnpacked method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    loadUnpackedReturns: The result of the loadUnpacked call.
+        """
+        return await self.client.send(method="Extensions.loadUnpacked", params=params,session_id=session_id)
+    async def uninstall(self, params: Optional[uninstallParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Uninstalls an unpacked extension (others not supported) from the profile. Available if the client is connected using the --remote-debugging-pipe flag and the --enable-unsafe-extension-debugging.    
+        Args:
+            params (uninstallParameters, optional): Parameters for the uninstall method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the uninstall call.
+        """
+        return await self.client.send(method="Extensions.uninstall", params=params,session_id=session_id)
+    async def get_storage_items(self, params: Optional[getStorageItemsParameters]=None,session_id: Optional[str] = None) -> getStorageItemsReturns:
+        """
+    Gets data from extension storage in the given `storageArea`. If `keys` is specified, these are used to filter the result.    
+        Args:
+            params (getStorageItemsParameters, optional): Parameters for the getStorageItems method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    getStorageItemsReturns: The result of the getStorageItems call.
+        """
+        return await self.client.send(method="Extensions.getStorageItems", params=params,session_id=session_id)
+    async def remove_storage_items(self, params: Optional[removeStorageItemsParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Removes `keys` from extension storage in the given `storageArea`.    
+        Args:
+            params (removeStorageItemsParameters, optional): Parameters for the removeStorageItems method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the removeStorageItems call.
+        """
+        return await self.client.send(method="Extensions.removeStorageItems", params=params,session_id=session_id)
+    async def clear_storage_items(self, params: Optional[clearStorageItemsParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Clears extension storage in the given `storageArea`.    
+        Args:
+            params (clearStorageItemsParameters, optional): Parameters for the clearStorageItems method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the clearStorageItems call.
+        """
+        return await self.client.send(method="Extensions.clearStorageItems", params=params,session_id=session_id)
+    async def set_storage_items(self, params: Optional[setStorageItemsParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Sets `values` in extension storage in the given `storageArea`. The provided `values` will be merged with existing values in the storage area.    
+        Args:
+            params (setStorageItemsParameters, optional): Parameters for the setStorageItems method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the setStorageItems call.
+        """
+        return await self.client.send(method="Extensions.setStorageItems", params=params,session_id=session_id)

cdp/protocol/extensions/methods/types.py

@@ -0,0 +1,46 @@
+"""CDP Extensions 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.extensions.types import StorageArea
+
+class loadUnpackedParameters(TypedDict, total=True):
+    path: 'str'
+    """Absolute file path."""
+class uninstallParameters(TypedDict, total=True):
+    id: 'str'
+    """Extension id."""
+class getStorageItemsParameters(TypedDict, total=True):
+    id: 'str'
+    """ID of extension."""
+    storageArea: 'StorageArea'
+    """StorageArea to retrieve data from."""
+    keys: NotRequired['List[str]']
+    """Keys to retrieve."""
+class removeStorageItemsParameters(TypedDict, total=True):
+    id: 'str'
+    """ID of extension."""
+    storageArea: 'StorageArea'
+    """StorageArea to remove data from."""
+    keys: 'List[str]'
+    """Keys to remove."""
+class clearStorageItemsParameters(TypedDict, total=True):
+    id: 'str'
+    """ID of extension."""
+    storageArea: 'StorageArea'
+    """StorageArea to remove data from."""
+class setStorageItemsParameters(TypedDict, total=True):
+    id: 'str'
+    """ID of extension."""
+    storageArea: 'StorageArea'
+    """StorageArea to set data in."""
+    values: 'Dict[str, Any]'
+    """Values to set."""
+class loadUnpackedReturns(TypedDict):
+    id: 'str'
+    """Extension id."""
+
+class getStorageItemsReturns(TypedDict):
+    data: 'Dict[str, Any]'

cdp/protocol/extensions/service.py

@@ -0,0 +1,21 @@
+"""CDP Extensions Domain"""
+from typing import TYPE_CHECKING
+from .methods.service import ExtensionsMethods
+from .events.service import ExtensionsEvents
+
+if TYPE_CHECKING:
+    from ...service import Client
+
+class Extensions(ExtensionsMethods, ExtensionsEvents):
+    """
+    Defines commands and events for browser extensions.
+    """
+    def __init__(self, client: "Client"):
+        """
+        Initialize the Extensions domain.
+        
+        Args:
+            client ("Client"): The parent CDP client instance.
+        """
+        ExtensionsMethods.__init__(self, client)
+        ExtensionsEvents.__init__(self, client)

cdp/protocol/extensions/types.py

@@ -0,0 +1,6 @@
+"""CDP Extensions Types"""
+
+from typing import TypedDict, NotRequired, Required, Literal, Any, Dict, Union, Optional, List, Set, Tuple
+
+StorageArea = Literal['session','local','sync','managed']
+"""Storage areas."""

cdp/protocol/fed_cm/events/service.py

@@ -0,0 +1,37 @@
+"""CDP FedCm 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 FedCmEvents:
+    """
+    Events for the FedCm domain.
+    """
+    def __init__(self, client: "Client"):
+        """
+        Initialize the FedCm events.
+        
+        Args:
+            client ("Client"): The parent CDP client instance.
+        """
+        self.client = client
+
+    def on_dialog_shown(self, callback: Callable[[dialogShownEvent,Optional[str]], None]=None) -> None:
+        """
+    No description available for dialogShown.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: dialogShownEvent, session_id: Optional[str]).
+        """
+        self.client.on('FedCm.dialogShown', callback)
+    def on_dialog_closed(self, callback: Callable[[dialogClosedEvent,Optional[str]], None]=None) -> None:
+        """
+    Triggered when a dialog is closed, either by user action, JS abort, or a command below.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: dialogClosedEvent, session_id: Optional[str]).
+        """
+        self.client.on('FedCm.dialogClosed', callback)

cdp/protocol/fed_cm/events/types.py

@@ -0,0 +1,18 @@
+"""CDP FedCm Events"""
+
+from typing import TypedDict, NotRequired, Required, Literal, Any, Dict, Union, Optional, List, Set, Tuple
+
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+    from cdp.protocol.fed_cm.types import Account
+    from cdp.protocol.fed_cm.types import DialogType
+
+class dialogShownEvent(TypedDict, total=True):
+    dialogId: 'str'
+    dialogType: 'DialogType'
+    accounts: 'List[Account]'
+    title: 'str'
+    """These exist primarily so that the caller can verify the RP context was used appropriately."""
+    subtitle: NotRequired['str']
+class dialogClosedEvent(TypedDict, total=True):
+    dialogId: 'str'

cdp/protocol/fed_cm/methods/service.py

@@ -0,0 +1,98 @@
+"""CDP FedCm 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 FedCmMethods:
+    """
+    Methods for the FedCm domain.
+    """
+    def __init__(self, client: "Client"):
+        """
+        Initialize the FedCm methods.
+        
+        Args:
+            client ("Client"): The parent CDP client instance.
+        """
+        self.client = client
+
+    async def enable(self, params: Optional[enableParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    No description available for enable.    
+        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="FedCm.enable", 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="FedCm.disable", params=params,session_id=session_id)
+    async def select_account(self, params: Optional[selectAccountParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    No description available for selectAccount.    
+        Args:
+            params (selectAccountParameters, optional): Parameters for the selectAccount method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the selectAccount call.
+        """
+        return await self.client.send(method="FedCm.selectAccount", params=params,session_id=session_id)
+    async def click_dialog_button(self, params: Optional[clickDialogButtonParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    No description available for clickDialogButton.    
+        Args:
+            params (clickDialogButtonParameters, optional): Parameters for the clickDialogButton method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the clickDialogButton call.
+        """
+        return await self.client.send(method="FedCm.clickDialogButton", params=params,session_id=session_id)
+    async def open_url(self, params: Optional[openUrlParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    No description available for openUrl.    
+        Args:
+            params (openUrlParameters, optional): Parameters for the openUrl method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the openUrl call.
+        """
+        return await self.client.send(method="FedCm.openUrl", params=params,session_id=session_id)
+    async def dismiss_dialog(self, params: Optional[dismissDialogParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    No description available for dismissDialog.    
+        Args:
+            params (dismissDialogParameters, optional): Parameters for the dismissDialog method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the dismissDialog call.
+        """
+        return await self.client.send(method="FedCm.dismissDialog", params=params,session_id=session_id)
+    async def reset_cooldown(self, params: None=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Resets the cooldown time, if any, to allow the next FedCM call to show a dialog even if one was recently dismissed by the user.    
+        Args:
+            params (None, optional): Parameters for the resetCooldown method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the resetCooldown call.
+        """
+        return await self.client.send(method="FedCm.resetCooldown", params=params,session_id=session_id)

cdp/protocol/fed_cm/methods/types.py

@@ -0,0 +1,26 @@
+"""CDP FedCm 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.fed_cm.types import AccountUrlType
+    from cdp.protocol.fed_cm.types import DialogButton
+
+class enableParameters(TypedDict, total=False):
+    disableRejectionDelay: NotRequired['bool']
+    """Allows callers to disable the promise rejection delay that would normally happen, if this is unimportant to what's being tested. (step 4 of https://fedidcg.github.io/FedCM/#browser-api-rp-sign-in)"""
+
+class selectAccountParameters(TypedDict, total=True):
+    dialogId: 'str'
+    accountIndex: 'int'
+class clickDialogButtonParameters(TypedDict, total=True):
+    dialogId: 'str'
+    dialogButton: 'DialogButton'
+class openUrlParameters(TypedDict, total=True):
+    dialogId: 'str'
+    accountIndex: 'int'
+    accountUrlType: 'AccountUrlType'
+class dismissDialogParameters(TypedDict, total=True):
+    dialogId: 'str'
+    triggerCooldown: NotRequired['bool']

cdp/protocol/fed_cm/service.py

@@ -0,0 +1,21 @@
+"""CDP FedCm Domain"""
+from typing import TYPE_CHECKING
+from .methods.service import FedCmMethods
+from .events.service import FedCmEvents
+
+if TYPE_CHECKING:
+    from ...service import Client
+
+class FedCm(FedCmMethods, FedCmEvents):
+    """
+    This domain allows interacting with the FedCM dialog.
+    """
+    def __init__(self, client: "Client"):
+        """
+        Initialize the FedCm domain.
+        
+        Args:
+            client ("Client"): The parent CDP client instance.
+        """
+        FedCmMethods.__init__(self, client)
+        FedCmEvents.__init__(self, client)

cdp/protocol/fed_cm/types.py

@@ -0,0 +1,25 @@
+"""CDP FedCm Types"""
+
+from typing import TypedDict, NotRequired, Required, Literal, Any, Dict, Union, Optional, List, Set, Tuple
+
+LoginState = Literal['SignIn','SignUp']
+"""Whether this is a sign-up or sign-in action for this account, i.e. whether this account has ever been used to sign in to this RP before."""
+DialogType = Literal['AccountChooser','AutoReauthn','ConfirmIdpLogin','Error']
+"""The types of FedCM dialogs."""
+DialogButton = Literal['ConfirmIdpLoginContinue','ErrorGotIt','ErrorMoreDetails']
+"""The buttons on the FedCM dialog."""
+AccountUrlType = Literal['TermsOfService','PrivacyPolicy']
+"""The URLs that each account has"""
+class Account(TypedDict, total=True):
+    """Corresponds to IdentityRequestAccount"""
+    accountId: 'str'
+    email: 'str'
+    name: 'str'
+    givenName: 'str'
+    pictureUrl: 'str'
+    idpConfigUrl: 'str'
+    idpLoginUrl: 'str'
+    loginState: 'LoginState'
+    termsOfServiceUrl: NotRequired['str']
+    """These two are only set if the loginState is signUp"""
+    privacyPolicyUrl: NotRequired['str']

cdp/protocol/fetch/events/service.py

@@ -0,0 +1,37 @@
+"""CDP Fetch 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 FetchEvents:
+    """
+    Events for the Fetch domain.
+    """
+    def __init__(self, client: "Client"):
+        """
+        Initialize the Fetch events.
+        
+        Args:
+            client ("Client"): The parent CDP client instance.
+        """
+        self.client = client
+
+    def on_request_paused(self, callback: Callable[[requestPausedEvent,Optional[str]], None]=None) -> None:
+        """
+    Issued when the domain is enabled and the request URL matches the specified filter. The request is paused until the client responds with one of continueRequest, failRequest or fulfillRequest. The stage of the request can be determined by presence of responseErrorReason and responseStatusCode -- the request is at the response stage if either of these fields is present and in the request stage otherwise. Redirect responses and subsequent requests are reported similarly to regular responses and requests. Redirect responses may be distinguished by the value of `responseStatusCode` (which is one of 301, 302, 303, 307, 308) along with presence of the `location` header. Requests resulting from a redirect will have `redirectedRequestId` field set.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: requestPausedEvent, session_id: Optional[str]).
+        """
+        self.client.on('Fetch.requestPaused', callback)
+    def on_auth_required(self, callback: Callable[[authRequiredEvent,Optional[str]], None]=None) -> None:
+        """
+    Issued when the domain is enabled with handleAuthRequests set to true. The request is paused until client responds with continueWithAuth.    
+        Args:
+            callback (callable, optional): Function called when the event is fired. 
+                The callback receives (params: authRequiredEvent, session_id: Optional[str]).
+        """
+        self.client.on('Fetch.authRequired', callback)

cdp/protocol/fetch/events/types.py

@@ -0,0 +1,47 @@
+"""CDP Fetch Events"""
+
+from typing import TypedDict, NotRequired, Required, Literal, Any, Dict, Union, Optional, List, Set, Tuple
+
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+    from cdp.protocol.fetch.types import AuthChallenge
+    from cdp.protocol.fetch.types import HeaderEntry
+    from cdp.protocol.fetch.types import RequestId
+    from cdp.protocol.network.types import ErrorReason
+    from cdp.protocol.network.types import Request
+    from cdp.protocol.network.types import RequestId
+    from cdp.protocol.network.types import ResourceType
+    from cdp.protocol.page.types import FrameId
+
+class requestPausedEvent(TypedDict, total=True):
+    requestId: 'RequestId'
+    """Each request the page makes will have a unique id."""
+    request: 'Request'
+    """The details of the request."""
+    frameId: 'FrameId'
+    """The id of the frame that initiated the request."""
+    resourceType: 'ResourceType'
+    """How the requested resource will be used."""
+    responseErrorReason: NotRequired['ErrorReason']
+    """Response error if intercepted at response stage."""
+    responseStatusCode: NotRequired['int']
+    """Response code if intercepted at response stage."""
+    responseStatusText: NotRequired['str']
+    """Response status text if intercepted at response stage."""
+    responseHeaders: NotRequired['List[HeaderEntry]']
+    """Response headers if intercepted at the response stage."""
+    networkId: NotRequired['RequestId']
+    """If the intercepted request had a corresponding Network.requestWillBeSent event fired for it, then this networkId will be the same as the requestId present in the requestWillBeSent event."""
+    redirectedRequestId: NotRequired['RequestId']
+    """If the request is due to a redirect response from the server, the id of the request that has caused the redirect."""
+class authRequiredEvent(TypedDict, total=True):
+    requestId: 'RequestId'
+    """Each request the page makes will have a unique id."""
+    request: 'Request'
+    """The details of the request."""
+    frameId: 'FrameId'
+    """The id of the frame that initiated the request."""
+    resourceType: 'ResourceType'
+    """How the requested resource will be used."""
+    authChallenge: 'AuthChallenge'
+    """Details of the Authorization Challenge encountered. If this is set, client should respond with continueRequest that contains AuthChallengeResponse."""

cdp/protocol/fetch/methods/service.py

@@ -0,0 +1,120 @@
+"""CDP Fetch 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 FetchMethods:
+    """
+    Methods for the Fetch domain.
+    """
+    def __init__(self, client: "Client"):
+        """
+        Initialize the Fetch methods.
+        
+        Args:
+            client ("Client"): The parent CDP client instance.
+        """
+        self.client = client
+
+    async def disable(self, params: None=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Disables the fetch domain.    
+        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="Fetch.disable", params=params,session_id=session_id)
+    async def enable(self, params: Optional[enableParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Enables issuing of requestPaused events. A request will be paused until client calls one of failRequest, fulfillRequest or continueRequest/continueWithAuth.    
+        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="Fetch.enable", params=params,session_id=session_id)
+    async def fail_request(self, params: Optional[failRequestParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Causes the request to fail with specified reason.    
+        Args:
+            params (failRequestParameters, optional): Parameters for the failRequest method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the failRequest call.
+        """
+        return await self.client.send(method="Fetch.failRequest", params=params,session_id=session_id)
+    async def fulfill_request(self, params: Optional[fulfillRequestParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Provides response to the request.    
+        Args:
+            params (fulfillRequestParameters, optional): Parameters for the fulfillRequest method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the fulfillRequest call.
+        """
+        return await self.client.send(method="Fetch.fulfillRequest", params=params,session_id=session_id)
+    async def continue_request(self, params: Optional[continueRequestParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Continues the request, optionally modifying some of its parameters.    
+        Args:
+            params (continueRequestParameters, optional): Parameters for the continueRequest method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the continueRequest call.
+        """
+        return await self.client.send(method="Fetch.continueRequest", params=params,session_id=session_id)
+    async def continue_with_auth(self, params: Optional[continueWithAuthParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Continues a request supplying authChallengeResponse following authRequired event.    
+        Args:
+            params (continueWithAuthParameters, optional): Parameters for the continueWithAuth method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the continueWithAuth call.
+        """
+        return await self.client.send(method="Fetch.continueWithAuth", params=params,session_id=session_id)
+    async def continue_response(self, params: Optional[continueResponseParameters]=None,session_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+    Continues loading of the paused response, optionally modifying the response headers. If either responseCode or headers are modified, all of them must be present.    
+        Args:
+            params (continueResponseParameters, optional): Parameters for the continueResponse method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    Dict[str, Any]: The result of the continueResponse call.
+        """
+        return await self.client.send(method="Fetch.continueResponse", params=params,session_id=session_id)
+    async def get_response_body(self, params: Optional[getResponseBodyParameters]=None,session_id: Optional[str] = None) -> getResponseBodyReturns:
+        """
+    Causes the body of the response to be received from the server and returned as a single string. May only be issued for a request that is paused in the Response stage and is mutually exclusive with takeResponseBodyForInterceptionAsStream. Calling other methods that affect the request or disabling fetch domain before body is received results in an undefined behavior. Note that the response body is not available for redirects. Requests paused in the _redirect received_ state may be differentiated by `responseCode` and presence of `location` response header, see comments to `requestPaused` for details.    
+        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="Fetch.getResponseBody", params=params,session_id=session_id)
+    async def take_response_body_as_stream(self, params: Optional[takeResponseBodyAsStreamParameters]=None,session_id: Optional[str] = None) -> takeResponseBodyAsStreamReturns:
+        """
+    Returns a handle to the stream representing the response body. The request must be paused in the HeadersReceived stage. Note that after this command the request can't be continued as is -- client either needs to cancel it or to provide the response body. The stream only supports sequential read, IO.read will fail if the position is specified. This method is mutually exclusive with getResponseBody. Calling other methods that affect the request or disabling fetch domain before body is received results in an undefined behavior.    
+        Args:
+            params (takeResponseBodyAsStreamParameters, optional): Parameters for the takeResponseBodyAsStream method.
+            session_id (str, optional): Target session ID for flat protocol usage.
+            
+        Returns:
+    takeResponseBodyAsStreamReturns: The result of the takeResponseBodyAsStream call.
+        """
+        return await self.client.send(method="Fetch.takeResponseBodyAsStream", params=params,session_id=session_id)