parsek-cdp 0.1.0__py3-none-any.whl

parsek_cdp/cdp/fedcm/functions.py

@@ -0,0 +1,93 @@
+"""Commands for the FedCm domain (generated)."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any, ClassVar, Dict, List, Literal, Optional
+
+from ..mixins.datatype import DataType, FieldMeta, encode
+
+if TYPE_CHECKING:
+    from .types import (
+        AccountUrlType,
+        DialogButton,
+    )
+
+class FedCm:
+    """Commands of the FedCm domain, bound to a target."""
+
+    def __init__(self, target: Any) -> None:
+        self._target = target
+
+
+    async def enable(self, *, disable_rejection_delay: Optional[bool] = None) -> None:
+        """
+        :param disable_rejection_delay: 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)
+        """
+        _params: Dict[str, Any] = {}
+        if disable_rejection_delay is not None:
+            _params['disableRejectionDelay'] = encode(FieldMeta('', '', False, 'primitive'), disable_rejection_delay)
+        _result = await self._target.send('FedCm.enable', _params)
+        return None
+
+    async def disable(self) -> None:
+        _params: Dict[str, Any] = {}
+        _result = await self._target.send('FedCm.disable', _params)
+        return None
+
+    async def select_account(self, *, dialog_id: str, account_index: int) -> None:
+        """
+        :param dialog_id:
+        :param account_index:
+        """
+        _params: Dict[str, Any] = {}
+        _params['dialogId'] = encode(FieldMeta('', '', False, 'primitive'), dialog_id)
+        _params['accountIndex'] = encode(FieldMeta('', '', False, 'primitive'), account_index)
+        _result = await self._target.send('FedCm.selectAccount', _params)
+        return None
+
+    async def click_dialog_button(self, *, dialog_id: str, dialog_button: DialogButton) -> None:
+        """
+        :param dialog_id:
+        :param dialog_button:
+        """
+        _params: Dict[str, Any] = {}
+        _params['dialogId'] = encode(FieldMeta('', '', False, 'primitive'), dialog_id)
+        _params['dialogButton'] = encode(FieldMeta('', '', False, 'enum', ref='FedCm.DialogButton'), dialog_button)
+        _result = await self._target.send('FedCm.clickDialogButton', _params)
+        return None
+
+    async def open_url(self, *, dialog_id: str, account_index: int, account_url_type: AccountUrlType) -> None:
+        """
+        :param dialog_id:
+        :param account_index:
+        :param account_url_type:
+        """
+        _params: Dict[str, Any] = {}
+        _params['dialogId'] = encode(FieldMeta('', '', False, 'primitive'), dialog_id)
+        _params['accountIndex'] = encode(FieldMeta('', '', False, 'primitive'), account_index)
+        _params['accountUrlType'] = encode(FieldMeta('', '', False, 'enum', ref='FedCm.AccountUrlType'), account_url_type)
+        _result = await self._target.send('FedCm.openUrl', _params)
+        return None
+
+    async def dismiss_dialog(self, *, dialog_id: str, trigger_cooldown: Optional[bool] = None) -> None:
+        """
+        :param dialog_id:
+        :param trigger_cooldown:
+        """
+        _params: Dict[str, Any] = {}
+        _params['dialogId'] = encode(FieldMeta('', '', False, 'primitive'), dialog_id)
+        if trigger_cooldown is not None:
+            _params['triggerCooldown'] = encode(FieldMeta('', '', False, 'primitive'), trigger_cooldown)
+        _result = await self._target.send('FedCm.dismissDialog', _params)
+        return None
+
+    async def reset_cooldown(self) -> None:
+        """
+        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.
+        """
+        _params: Dict[str, Any] = {}
+        _result = await self._target.send('FedCm.resetCooldown', _params)
+        return None

parsek_cdp/cdp/fedcm/types.py

@@ -0,0 +1,72 @@
+"""Custom types and enums for the FedCm domain (generated)."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import Enum
+from typing import Any, ClassVar, Dict, List, Literal, Optional
+
+from ..mixins.datatype import DataType, FieldMeta, register
+
+
+@register("FedCm.LoginState")
+class LoginState(str, Enum):
+    """
+    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.
+    """
+    SIGNIN = 'SignIn'
+    SIGNUP = 'SignUp'
+
+
+@register("FedCm.DialogType")
+class DialogType(str, Enum):
+    """The types of FedCM dialogs."""
+    ACCOUNTCHOOSER = 'AccountChooser'
+    AUTOREAUTHN = 'AutoReauthn'
+    CONFIRMIDPLOGIN = 'ConfirmIdpLogin'
+    ERROR = 'Error'
+
+
+@register("FedCm.DialogButton")
+class DialogButton(str, Enum):
+    """The buttons on the FedCM dialog."""
+    CONFIRMIDPLOGINCONTINUE = 'ConfirmIdpLoginContinue'
+    ERRORGOTIT = 'ErrorGotIt'
+    ERRORMOREDETAILS = 'ErrorMoreDetails'
+
+
+@register("FedCm.AccountUrlType")
+class AccountUrlType(str, Enum):
+    """The URLs that each account has"""
+    TERMSOFSERVICE = 'TermsOfService'
+    PRIVACYPOLICY = 'PrivacyPolicy'
+
+
+@register("FedCm.Account")
+@dataclass
+class Account(DataType):
+    """Corresponds to IdentityRequestAccount"""
+    account_id: str
+    email: str
+    name: str
+    given_name: str
+    picture_url: str
+    idp_config_url: str
+    idp_login_url: str
+    login_state: LoginState
+    terms_of_service_url: Optional[str] = None
+    privacy_policy_url: Optional[str] = None
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('account_id', 'accountId', False, 'primitive'),
+        FieldMeta('email', 'email', False, 'primitive'),
+        FieldMeta('name', 'name', False, 'primitive'),
+        FieldMeta('given_name', 'givenName', False, 'primitive'),
+        FieldMeta('picture_url', 'pictureUrl', False, 'primitive'),
+        FieldMeta('idp_config_url', 'idpConfigUrl', False, 'primitive'),
+        FieldMeta('idp_login_url', 'idpLoginUrl', False, 'primitive'),
+        FieldMeta('login_state', 'loginState', False, 'enum', ref='FedCm.LoginState'),
+        FieldMeta('terms_of_service_url', 'termsOfServiceUrl', True, 'primitive'),
+        FieldMeta('privacy_policy_url', 'privacyPolicyUrl', True, 'primitive'),
+    )
+
+__all__ = ["Account", "AccountUrlType", "DialogButton", "DialogType", "LoginState"]

parsek_cdp/cdp/fetch/__init__.py

@@ -0,0 +1,15 @@
+"""The Fetch CDP domain (generated).
+
+Importing ``Fetch`` from ``parsek_cdp.cdp`` gives a namespace with this
+domain's events and types as attributes (``Fetch.SomeEvent`` /
+``Fetch.SomeType``); commands run on a target via ``page.cdp.Fetch``.
+"""
+from . import events, functions, types
+from .functions import Fetch
+from .events import *  # noqa: F401,F403 -- expose events on the namespace
+from .types import *  # noqa: F401,F403 -- expose types on the namespace
+
+#: Protocol domain name (used by features that declare ``domains=(Fetch,)``).
+DOMAIN = "Fetch"
+
+__all__ = ["events", "functions", "types", "Fetch", "DOMAIN"]

parsek_cdp/cdp/fetch/events.py

@@ -0,0 +1,82 @@
+"""Events for the Fetch domain (generated)."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any, ClassVar, Dict, List, Literal, Optional
+
+from ..mixins.datatype import FieldMeta
+from ..mixins.event import Event, register_event
+
+if TYPE_CHECKING:
+    from .types import (
+        AuthChallenge,
+        HeaderEntry,
+        RequestId,
+    )
+    from ..network.types import ErrorReason as Network_ErrorReason
+    from ..network.types import Request as Network_Request
+    from ..network.types import RequestId as Network_RequestId
+    from ..network.types import ResourceType as Network_ResourceType
+    from ..page.types import FrameId as Page_FrameId
+
+@register_event("Fetch.requestPaused")
+@dataclass
+class RequestPaused(Event):
+    """
+    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.
+    """
+    request_id: RequestId
+    request: Network_Request
+    frame_id: Page_FrameId
+    resource_type: Network_ResourceType
+    response_error_reason: Optional[Network_ErrorReason] = None
+    response_status_code: Optional[int] = None
+    response_status_text: Optional[str] = None
+    response_headers: Optional[List[HeaderEntry]] = None
+    network_id: Optional[Network_RequestId] = None
+    redirected_request_id: Optional[RequestId] = None
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('request_id', 'requestId', False, 'primitive'),
+        FieldMeta('request', 'request', False, 'object', ref='Network.Request'),
+        FieldMeta('frame_id', 'frameId', False, 'primitive'),
+        FieldMeta('resource_type', 'resourceType', False, 'enum', ref='Network.ResourceType'),
+        FieldMeta('response_error_reason', 'responseErrorReason', True, 'enum', ref='Network.ErrorReason'),
+        FieldMeta('response_status_code', 'responseStatusCode', True, 'primitive'),
+        FieldMeta('response_status_text', 'responseStatusText', True, 'primitive'),
+        FieldMeta('response_headers', 'responseHeaders', True, 'array', inner=FieldMeta('', '', False, 'object', ref='Fetch.HeaderEntry')),
+        FieldMeta('network_id', 'networkId', True, 'primitive'),
+        FieldMeta('redirected_request_id', 'redirectedRequestId', True, 'primitive'),
+    )
+
+
+@register_event("Fetch.authRequired")
+@dataclass
+class AuthRequired(Event):
+    """
+    Issued when the domain is enabled with handleAuthRequests set to true.
+    The request is paused until client responds with continueWithAuth.
+    """
+    request_id: RequestId
+    request: Network_Request
+    frame_id: Page_FrameId
+    resource_type: Network_ResourceType
+    auth_challenge: AuthChallenge
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('request_id', 'requestId', False, 'primitive'),
+        FieldMeta('request', 'request', False, 'object', ref='Network.Request'),
+        FieldMeta('frame_id', 'frameId', False, 'primitive'),
+        FieldMeta('resource_type', 'resourceType', False, 'enum', ref='Network.ResourceType'),
+        FieldMeta('auth_challenge', 'authChallenge', False, 'object', ref='Fetch.AuthChallenge'),
+    )
+
+__all__ = ["AuthRequired", "RequestPaused"]

parsek_cdp/cdp/fetch/functions.py

@@ -0,0 +1,215 @@
+"""Commands for the Fetch domain (generated)."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any, ClassVar, Dict, List, Literal, Optional
+
+from ..mixins.datatype import DataType, FieldMeta, encode
+
+if TYPE_CHECKING:
+    from .types import (
+        AuthChallengeResponse,
+        HeaderEntry,
+        RequestId,
+        RequestPattern,
+    )
+    from ..io.types import StreamHandle as IO_StreamHandle
+    from ..network.types import ErrorReason as Network_ErrorReason
+
+@dataclass
+class GetResponseBodyReturn(DataType):
+    """Return value of :meth:`Fetch.get_response_body`."""
+    body: str
+    base64_encoded: bool
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('body', 'body', False, 'primitive'),
+        FieldMeta('base64_encoded', 'base64Encoded', False, 'primitive'),
+    )
+
+
+@dataclass
+class TakeResponseBodyAsStreamReturn(DataType):
+    """Return value of :meth:`Fetch.take_response_body_as_stream`."""
+    stream: IO_StreamHandle
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('stream', 'stream', False, 'primitive'),
+    )
+
+
+class Fetch:
+    """Commands of the Fetch domain, bound to a target."""
+
+    def __init__(self, target: Any) -> None:
+        self._target = target
+
+
+    async def disable(self) -> None:
+        """Disables the fetch domain."""
+        _params: Dict[str, Any] = {}
+        _result = await self._target.send('Fetch.disable', _params)
+        return None
+
+    async def enable(self, *, patterns: Optional[List[RequestPattern]] = None, handle_auth_requests: Optional[bool] = None) -> None:
+        """
+        Enables issuing of requestPaused events. A request will be paused until client
+        calls one of failRequest, fulfillRequest or continueRequest/continueWithAuth.
+        :param patterns: If specified, only requests matching any of these patterns will produce
+        fetchRequested event and will be paused until clients response. If not set,
+        all requests will be affected.
+        :param handle_auth_requests: If true, authRequired events will be issued and requests will be paused
+        expecting a call to continueWithAuth.
+        """
+        _params: Dict[str, Any] = {}
+        if patterns is not None:
+            _params['patterns'] = encode(FieldMeta('', '', False, 'array', inner=FieldMeta('', '', False, 'object', ref='Fetch.RequestPattern')), patterns)
+        if handle_auth_requests is not None:
+            _params['handleAuthRequests'] = encode(FieldMeta('', '', False, 'primitive'), handle_auth_requests)
+        _result = await self._target.send('Fetch.enable', _params)
+        return None
+
+    async def fail_request(self, *, request_id: RequestId, error_reason: Network_ErrorReason) -> None:
+        """
+        Causes the request to fail with specified reason.
+        :param request_id: An id the client received in requestPaused event.
+        :param error_reason: Causes the request to fail with the given reason.
+        """
+        _params: Dict[str, Any] = {}
+        _params['requestId'] = encode(FieldMeta('', '', False, 'primitive'), request_id)
+        _params['errorReason'] = encode(FieldMeta('', '', False, 'enum', ref='Network.ErrorReason'), error_reason)
+        _result = await self._target.send('Fetch.failRequest', _params)
+        return None
+
+    async def fulfill_request(self, *, request_id: RequestId, response_code: int, response_headers: Optional[List[HeaderEntry]] = None, binary_response_headers: Optional[str] = None, body: Optional[str] = None, response_phrase: Optional[str] = None) -> None:
+        """
+        Provides response to the request.
+        :param request_id: An id the client received in requestPaused event.
+        :param response_code: An HTTP response code.
+        :param response_headers: Response headers.
+        :param binary_response_headers: Alternative way of specifying response headers as a \\0-separated
+        series of name: value pairs. Prefer the above method unless you
+        need to represent some non-UTF8 values that can't be transmitted
+        over the protocol as text. (Encoded as a base64 string when passed over JSON)
+        :param body: A response body. If absent, original response body will be used if
+        the request is intercepted at the response stage and empty body
+        will be used if the request is intercepted at the request stage. (Encoded as a base64 string when passed over JSON)
+        :param response_phrase: A textual representation of responseCode.
+        If absent, a standard phrase matching responseCode is used.
+        """
+        _params: Dict[str, Any] = {}
+        _params['requestId'] = encode(FieldMeta('', '', False, 'primitive'), request_id)
+        _params['responseCode'] = encode(FieldMeta('', '', False, 'primitive'), response_code)
+        if response_headers is not None:
+            _params['responseHeaders'] = encode(FieldMeta('', '', False, 'array', inner=FieldMeta('', '', False, 'object', ref='Fetch.HeaderEntry')), response_headers)
+        if binary_response_headers is not None:
+            _params['binaryResponseHeaders'] = encode(FieldMeta('', '', False, 'primitive'), binary_response_headers)
+        if body is not None:
+            _params['body'] = encode(FieldMeta('', '', False, 'primitive'), body)
+        if response_phrase is not None:
+            _params['responsePhrase'] = encode(FieldMeta('', '', False, 'primitive'), response_phrase)
+        _result = await self._target.send('Fetch.fulfillRequest', _params)
+        return None
+
+    async def continue_request(self, *, request_id: RequestId, url: Optional[str] = None, method: Optional[str] = None, post_data: Optional[str] = None, headers: Optional[List[HeaderEntry]] = None, intercept_response: Optional[bool] = None) -> None:
+        """
+        Continues the request, optionally modifying some of its parameters.
+        :param request_id: An id the client received in requestPaused event.
+        :param url: If set, the request url will be modified in a way that's not observable by page.
+        :param method: If set, the request method is overridden.
+        :param post_data: If set, overrides the post data in the request. (Encoded as a base64 string when passed over JSON)
+        :param headers: If set, overrides the request headers. Note that the overrides do not
+        extend to subsequent redirect hops, if a redirect happens. Another override
+        may be applied to a different request produced by a redirect.
+        :param intercept_response: If set, overrides response interception behavior for this request.
+        """
+        _params: Dict[str, Any] = {}
+        _params['requestId'] = encode(FieldMeta('', '', False, 'primitive'), request_id)
+        if url is not None:
+            _params['url'] = encode(FieldMeta('', '', False, 'primitive'), url)
+        if method is not None:
+            _params['method'] = encode(FieldMeta('', '', False, 'primitive'), method)
+        if post_data is not None:
+            _params['postData'] = encode(FieldMeta('', '', False, 'primitive'), post_data)
+        if headers is not None:
+            _params['headers'] = encode(FieldMeta('', '', False, 'array', inner=FieldMeta('', '', False, 'object', ref='Fetch.HeaderEntry')), headers)
+        if intercept_response is not None:
+            _params['interceptResponse'] = encode(FieldMeta('', '', False, 'primitive'), intercept_response)
+        _result = await self._target.send('Fetch.continueRequest', _params)
+        return None
+
+    async def continue_with_auth(self, *, request_id: RequestId, auth_challenge_response: AuthChallengeResponse) -> None:
+        """
+        Continues a request supplying authChallengeResponse following authRequired event.
+        :param request_id: An id the client received in authRequired event.
+        :param auth_challenge_response: Response to  with an authChallenge.
+        """
+        _params: Dict[str, Any] = {}
+        _params['requestId'] = encode(FieldMeta('', '', False, 'primitive'), request_id)
+        _params['authChallengeResponse'] = encode(FieldMeta('', '', False, 'object', ref='Fetch.AuthChallengeResponse'), auth_challenge_response)
+        _result = await self._target.send('Fetch.continueWithAuth', _params)
+        return None
+
+    async def continue_response(self, *, request_id: RequestId, response_code: Optional[int] = None, response_phrase: Optional[str] = None, response_headers: Optional[List[HeaderEntry]] = None, binary_response_headers: Optional[str] = None) -> None:
+        """
+        Continues loading of the paused response, optionally modifying the
+        response headers. If either responseCode or headers are modified, all of them
+        must be present.
+        :param request_id: An id the client received in requestPaused event.
+        :param response_code: An HTTP response code. If absent, original response code will be used.
+        :param response_phrase: A textual representation of responseCode.
+        If absent, a standard phrase matching responseCode is used.
+        :param response_headers: Response headers. If absent, original response headers will be used.
+        :param binary_response_headers: Alternative way of specifying response headers as a \\0-separated
+        series of name: value pairs. Prefer the above method unless you
+        need to represent some non-UTF8 values that can't be transmitted
+        over the protocol as text. (Encoded as a base64 string when passed over JSON)
+        """
+        _params: Dict[str, Any] = {}
+        _params['requestId'] = encode(FieldMeta('', '', False, 'primitive'), request_id)
+        if response_code is not None:
+            _params['responseCode'] = encode(FieldMeta('', '', False, 'primitive'), response_code)
+        if response_phrase is not None:
+            _params['responsePhrase'] = encode(FieldMeta('', '', False, 'primitive'), response_phrase)
+        if response_headers is not None:
+            _params['responseHeaders'] = encode(FieldMeta('', '', False, 'array', inner=FieldMeta('', '', False, 'object', ref='Fetch.HeaderEntry')), response_headers)
+        if binary_response_headers is not None:
+            _params['binaryResponseHeaders'] = encode(FieldMeta('', '', False, 'primitive'), binary_response_headers)
+        _result = await self._target.send('Fetch.continueResponse', _params)
+        return None
+
+    async def get_response_body(self, *, request_id: RequestId) -> GetResponseBodyReturn:
+        """
+        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.
+        :param request_id: Identifier for the intercepted request to get body for.
+        """
+        _params: Dict[str, Any] = {}
+        _params['requestId'] = encode(FieldMeta('', '', False, 'primitive'), request_id)
+        _result = await self._target.send('Fetch.getResponseBody', _params)
+        return GetResponseBodyReturn.from_json(_result)
+
+    async def take_response_body_as_stream(self, *, request_id: RequestId) -> TakeResponseBodyAsStreamReturn:
+        """
+        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.
+        :param request_id:
+        """
+        _params: Dict[str, Any] = {}
+        _params['requestId'] = encode(FieldMeta('', '', False, 'primitive'), request_id)
+        _result = await self._target.send('Fetch.takeResponseBodyAsStream', _params)
+        return TakeResponseBodyAsStreamReturn.from_json(_result)

parsek_cdp/cdp/fetch/types.py

@@ -0,0 +1,81 @@
+"""Custom types and enums for the Fetch domain (generated)."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import Enum
+from typing import TYPE_CHECKING, Any, ClassVar, Dict, List, Literal, Optional
+
+from ..mixins.datatype import DataType, FieldMeta, register
+
+if TYPE_CHECKING:
+    from ..network.types import ResourceType as Network_ResourceType
+
+type RequestId = str  # Unique request identifier.
+
+
+@register("Fetch.RequestStage")
+class RequestStage(str, Enum):
+    """
+    Stages of the request to handle. Request will intercept before the request is
+    sent. Response will intercept after the response is received (but before response
+    body is received).
+    """
+    REQUEST = 'Request'
+    RESPONSE = 'Response'
+
+
+@register("Fetch.RequestPattern")
+@dataclass
+class RequestPattern(DataType):
+    url_pattern: Optional[str] = None
+    resource_type: Optional[Network_ResourceType] = None
+    request_stage: Optional[RequestStage] = None
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('url_pattern', 'urlPattern', True, 'primitive'),
+        FieldMeta('resource_type', 'resourceType', True, 'enum', ref='Network.ResourceType'),
+        FieldMeta('request_stage', 'requestStage', True, 'enum', ref='Fetch.RequestStage'),
+    )
+
+
+@register("Fetch.HeaderEntry")
+@dataclass
+class HeaderEntry(DataType):
+    """Response HTTP header entry"""
+    name: str
+    value: str
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('name', 'name', False, 'primitive'),
+        FieldMeta('value', 'value', False, 'primitive'),
+    )
+
+
+@register("Fetch.AuthChallenge")
+@dataclass
+class AuthChallenge(DataType):
+    """Authorization challenge for HTTP status code 401 or 407."""
+    origin: str
+    scheme: str
+    realm: str
+    source: Optional[Literal['Server', 'Proxy']] = None
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('origin', 'origin', False, 'primitive'),
+        FieldMeta('scheme', 'scheme', False, 'primitive'),
+        FieldMeta('realm', 'realm', False, 'primitive'),
+        FieldMeta('source', 'source', True, 'primitive'),
+    )
+
+
+@register("Fetch.AuthChallengeResponse")
+@dataclass
+class AuthChallengeResponse(DataType):
+    """Response to an AuthChallenge."""
+    response: Literal['Default', 'CancelAuth', 'ProvideCredentials']
+    username: Optional[str] = None
+    password: Optional[str] = None
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('response', 'response', False, 'primitive'),
+        FieldMeta('username', 'username', True, 'primitive'),
+        FieldMeta('password', 'password', True, 'primitive'),
+    )
+
+__all__ = ["AuthChallenge", "AuthChallengeResponse", "HeaderEntry", "RequestId", "RequestPattern", "RequestStage"]

parsek_cdp/cdp/filesystem/__init__.py

@@ -0,0 +1,15 @@
+"""The FileSystem CDP domain (generated).
+
+Importing ``FileSystem`` from ``parsek_cdp.cdp`` gives a namespace with this
+domain's events and types as attributes (``FileSystem.SomeEvent`` /
+``FileSystem.SomeType``); commands run on a target via ``page.cdp.FileSystem``.
+"""
+from . import events, functions, types
+from .functions import FileSystem
+from .events import *  # noqa: F401,F403 -- expose events on the namespace
+from .types import *  # noqa: F401,F403 -- expose types on the namespace
+
+#: Protocol domain name (used by features that declare ``domains=(FileSystem,)``).
+DOMAIN = "FileSystem"
+
+__all__ = ["events", "functions", "types", "FileSystem", "DOMAIN"]

parsek_cdp/cdp/filesystem/events.py

@@ -0,0 +1,13 @@
+"""Events for the FileSystem domain (generated)."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, ClassVar, Dict, List, Literal, Optional
+
+from ..mixins.datatype import FieldMeta
+from ..mixins.event import Event, register_event
+
+
+# This domain defines no events.
+
+__all__ = []

parsek_cdp/cdp/filesystem/functions.py

@@ -0,0 +1,36 @@
+"""Commands for the FileSystem domain (generated)."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any, ClassVar, Dict, List, Literal, Optional
+
+from ..mixins.datatype import DataType, FieldMeta, encode
+
+if TYPE_CHECKING:
+    from .types import (
+        BucketFileSystemLocator,
+        Directory,
+    )
+
+@dataclass
+class GetDirectoryReturn(DataType):
+    """Return value of :meth:`FileSystem.get_directory`."""
+    directory: Directory
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('directory', 'directory', False, 'object', ref='FileSystem.Directory'),
+    )
+
+
+class FileSystem:
+    """Commands of the FileSystem domain, bound to a target."""
+
+    def __init__(self, target: Any) -> None:
+        self._target = target
+
+
+    async def get_directory(self, *, bucket_file_system_locator: BucketFileSystemLocator) -> GetDirectoryReturn:
+        """:param bucket_file_system_locator:"""
+        _params: Dict[str, Any] = {}
+        _params['bucketFileSystemLocator'] = encode(FieldMeta('', '', False, 'object', ref='FileSystem.BucketFileSystemLocator'), bucket_file_system_locator)
+        _result = await self._target.send('FileSystem.getDirectory', _params)
+        return GetDirectoryReturn.from_json(_result)