rnet 2.4.2__cp313-cp313t-macosx_11_0_arm64.whl → 3.0.0rc10__cp313-cp313t-macosx_11_0_arm64.whl

rnet/__init__.pyi

@@ -1,6 +1,8 @@
+import datetime
 import ipaddress
-import typing
 from typing import (
+    AsyncGenerator,
+    Generator,
     Optional,
     Tuple,
     Union,
@@ -8,311 +10,1096 @@ from typing import (
     Dict,
     List,
     TypedDict,
+    Unpack,
+    NotRequired,
+    final,
 )
 from pathlib import Path
 from enum import Enum, auto
 
-from .blocking import *
+from .http1 import Http1Options
+from .http2 import Http2Options
 from .cookie import *
-from .exceptions import *
 from .header import *
-from .impersonate import *
+from .emulation import *
+from .tls import *
 
-try:
-    from typing import Unpack, NotRequired
-except ImportError:
-    from typing_extensions import Unpack, NotRequired
+@final
+class Method(Enum):
+    r"""
+    An HTTP method.
+    """
+
+    GET = auto()
+    HEAD = auto()
+    POST = auto()
+    PUT = auto()
+    DELETE = auto()
+    OPTIONS = auto()
+    TRACE = auto()
+    PATCH = auto()
+
+@final
+class Version(Enum):
+    r"""
+    An HTTP version.
+    """
+
+    HTTP_09 = auto()
+    HTTP_10 = auto()
+    HTTP_11 = auto()
+    HTTP_2 = auto()
+    HTTP_3 = auto()
+
+@final
+class StatusCode:
+    r"""
+    HTTP status code.
+    """
+
+    def __str__(self) -> str: ...
+    def as_int(self) -> int:
+        r"""
+        Return the status code as an integer.
+        """
+        ...
+
+    def is_informational(self) -> bool:
+        r"""
+        Check if status is within 100-199.
+        """
+        ...
+
+    def is_success(self) -> bool:
+        r"""
+        Check if status is within 200-299.
+        """
+        ...
+
+    def is_redirection(self) -> bool:
+        r"""
+        Check if status is within 300-399.
+        """
+        ...
+
+    def is_client_error(self) -> bool:
+        r"""
+        Check if status is within 400-499.
+        """
+        ...
+
+    def is_server_error(self) -> bool:
+        r"""
+        Check if status is within 500-599.
+        """
+        ...
+
+@final
+class SocketAddr:
+    r"""
+    A IP socket address.
+    """
+
+    def __str__(self) -> str: ...
+    def ip(self) -> Union[ipaddress.IPv4Address, ipaddress.IPv6Address]:
+        r"""
+        Returns the IP address of the socket address.
+        """
+
+    def port(self) -> int:
+        r"""
+        Returns the port number of the socket address.
+        """
+
+@final
+class Multipart:
+    r"""
+    A multipart form for a request.
+    """
+
+    def __init__(self, *parts: Part) -> None:
+        r"""
+        Creates a new multipart form.
+        """
+        ...
+
+@final
+class Part:
+    r"""
+    A part of a multipart form.
+    """
+
+    def __init__(
+        self,
+        name: str,
+        value: Union[
+            str,
+            bytes,
+            Path,
+            Generator[bytes, str, None],
+            AsyncGenerator[bytes, str],
+        ],
+        filename: str | None = None,
+        mime: str | None = None,
+        length: int | None = None,
+        headers: HeaderMap | None = None,
+    ) -> None:
+        r"""
+        Creates a new part.
+
+        # Arguments
+        - `name` - The name of the part.
+        - `value` - The value of the part, either text, bytes, a file path, or a async or sync stream.
+        - `filename` - The filename of the part.
+        - `mime` - The MIME type of the part.
+        - `length` - The length of the part when value is a stream (e.g., for file uploads).
+        - `headers` - The custom headers for the part.
+        """
+        ...
+
+class ProxyParams(TypedDict):
+    username: NotRequired[str]
+    r"""Username for proxy authentication."""
+
+    password: NotRequired[str]
+    r"""Password for proxy authentication."""
+
+    custom_http_auth: NotRequired[str]
+    r"""Custom HTTP proxy authentication header value."""
+
+    custom_http_headers: NotRequired[Union[Dict[str, str], HeaderMap]]
+    r"""Custom HTTP proxy headers."""
+
+    exclusion: NotRequired[str]
+    r"""List of domains to exclude from proxying."""
+
+@final
+class Proxy:
+    r"""
+    A proxy server for a request.
+    Supports HTTP, HTTPS, SOCKS4, SOCKS4a, SOCKS5, and SOCKS5h protocols.
+    """
+
+    @staticmethod
+    def http(url: str, **kwargs: Unpack[ProxyParams]) -> "Proxy":
+        r"""
+        Creates a new HTTP proxy.
+
+        This method sets up a proxy server for HTTP requests.
+
+        # Examples
+
+        ```python
+        import rnet
+
+        proxy = rnet.Proxy.http("http://proxy.example.com")
+        ```
+        """
+
+    @staticmethod
+    def https(url: str, **kwargs: Unpack[ProxyParams]) -> "Proxy":
+        r"""
+        Creates a new HTTPS proxy.
+
+        This method sets up a proxy server for HTTPS requests.
+
+        # Examples
+
+        ```python
+        import rnet
+
+        proxy = rnet.Proxy.https("https://proxy.example.com")
+        ```
+        """
+
+    @staticmethod
+    def all(url: str, **kwargs: Unpack[ProxyParams]) -> "Proxy":
+        r"""
+        Creates a new proxy for all protocols.
+
+        This method sets up a proxy server for all types of requests (HTTP, HTTPS, etc.).
+
+        # Examples
+
+        ```python
+        import rnet
+
+        proxy = rnet.Proxy.all("https://proxy.example.com")
+        ```
+        """
+
+class Message:
+    r"""
+    A WebSocket message.
+    """
+
+    data: Optional[bytes]
+    r"""
+    Returns the data of the message as bytes.
+    """
+
+    text: Optional[str]
+    r"""
+    Returns the text content of the message if it is a text message.
+    """
+
+    binary: Optional[bytes]
+    r"""
+    Returns the binary data of the message if it is a binary message.
+    """
+
+    ping: Optional[bytes]
+    r"""
+    Returns the ping data of the message if it is a ping message.
+    """
+
+    pong: Optional[bytes]
+    r"""
+    Returns the pong data of the message if it is a pong message.
+    """
+
+    close: Optional[Tuple[int, Optional[str]]]
+    r"""
+    Returns the close code and reason of the message if it is a close message.
+    """
+
+    @staticmethod
+    def text_from_json(json: Dict[str, Any]) -> "Message":
+        r"""
+        Creates a new text message from the JSON representation.
+
+        # Arguments
+        * `json` - The JSON representation of the message.
+        """
+    ...
+
+    @staticmethod
+    def binary_from_json(json: Dict[str, Any]) -> "Message":
+        r"""
+        Creates a new binary message from the JSON representation.
+
+        # Arguments
+        * `json` - The JSON representation of the message.
+        """
+
+    @staticmethod
+    def from_text(text: str) -> "Message":
+        r"""
+        Creates a new text message.
+
+        # Arguments
+
+        * `text` - The text content of the message.
+        """
+
+    @staticmethod
+    def from_binary(data: bytes) -> "Message":
+        r"""
+        Creates a new binary message.
+
+        # Arguments
+
+        * `data` - The binary data of the message.
+        """
+
+    @staticmethod
+    def from_ping(data: bytes) -> "Message":
+        r"""
+        Creates a new ping message.
+
+        # Arguments
+
+        * `data` - The ping data of the message.
+        """
+
+    @staticmethod
+    def from_pong(data: bytes) -> "Message":
+        r"""
+        Creates a new pong message.
+
+        # Arguments
+
+        * `data` - The pong data of the message.
+        """
+
+    @staticmethod
+    def from_close(code: int, reason: str | None = None) -> "Message":
+        r"""
+        Creates a new close message.
+
+        # Arguments
+
+        * `code` - The close code.
+        * `reason` - An optional reason for closing.
+        """
+
+    def json(self) -> Dict[str, Any]:
+        r"""
+        Returns the JSON representation of the message.
+        """
+
+    def __str__(self) -> str: ...
+
+@final
+class History:
+    """
+    An entry in the redirect history.
+    """
+
+    status: int
+    """Get the status code of the redirect response."""
+
+    url: str
+    """Get the URL of the redirect response."""
+
+    previous: str
+    """Get the previous URL before the redirect response."""
+
+    headers: HeaderMap
+    """Get the headers of the redirect response."""
+
+    def __str__(self) -> str: ...
+
+class Streamer:
+    r"""
+    A byte stream response.
+    An asynchronous iterator yielding data chunks from the response stream.
+    Used to stream response content.
+    Implemented in the `stream` method of the `Response` class.
+    Can be used in an asynchronous for loop in Python.
+
+    # Examples
+
+    ```python
+    import asyncio
+    import rnet
+    from rnet import Method, Emulation
+
+    async def main():
+        resp = await rnet.get("https://httpbin.org/stream/20")
+        async with resp.stream() as streamer:
+            async for chunk in streamer:
+                print("Chunk: ", chunk)
+                await asyncio.sleep(0.1)
+
+    if __name__ == "__main__":
+        asyncio.run(main())
+    ```
+    """
+
+    async def __aiter__(self) -> "Streamer": ...
+    async def __anext__(self) -> Optional[bytes]: ...
+    async def __aenter__(self) -> Any: ...
+    async def __aexit__(
+        self, _exc_type: Any, _exc_value: Any, _traceback: Any
+    ) -> Any: ...
+    def __iter__(self) -> "Streamer": ...
+    def __next__(self) -> bytes: ...
+    def __enter__(self) -> "Streamer": ...
+    def __exit__(self, _exc_type: Any, _exc_value: Any, _traceback: Any) -> None: ...
+
+class Response:
+    r"""
+    A response from a request.
+
+    # Examples
+
+    ```python
+    import asyncio
+    import rnet
+
+    async def main():
+        response = await rnet.get("https://www.rust-lang.org")
+        print("Status Code: ", response.status)
+        print("Version: ", response.version)
+        print("Response URL: ", response.url)
+        print("Headers: ", response.headers)
+        print("Content-Length: ", response.content_length)
+        print("Encoding: ", response.encoding)
+        print("Remote Address: ", response.remote_addr)
+
+        text_content = await response.text()
+        print("Text: ", text_content)
+
+    if __name__ == "__main__":
+        asyncio.run(main())
+    ```
+    """
+
+    url: str
+    r"""
+    Get the URL of the response.
+    """
+
+    status: StatusCode
+    r"""
+    Get the status code of the response.
+    """
+
+    version: Version
+    r"""
+    Get the HTTP version of the response.
+    """
+
+    headers: HeaderMap
+    r"""
+    Get the headers of the response.
+    """
+
+    cookies: List[Cookie]
+    r"""
+    Get the cookies of the response.
+    """
+
+    content_length: Optional[int]
+    r"""
+    Get the content length of the response.
+    """
+
+    remote_addr: Optional[SocketAddr]
+    r"""
+    Get the remote address of the response.
+    """
+
+    local_addr: Optional[SocketAddr]
+    r"""
+    Get the local address of the response.
+    """
+
+    history: List[History]
+    r"""
+    Get the redirect history of the Response.
+    """
+
+    peer_certificate: Optional[bytes]
+    r"""
+    Get the DER encoded leaf certificate of the response.
+    """
+
+    def raise_for_status(self) -> None:
+        r"""
+        Turn a response into an error if the server returned an error.
+        """
+
+    def stream(self) -> Streamer:
+        r"""
+        Get the response into a `Streamer` of `bytes` from the body.
+        """
+
+    async def text(self) -> str:
+        r"""
+        Get the text content of the response.
+        """
+
+    async def text_with_charset(self, encoding: str) -> str:
+        r"""
+        Get the full response text given a specific encoding.
+        """
+
+    async def json(self) -> Any:
+        r"""
+        Get the JSON content of the response.
+        """
+
+    async def bytes(self) -> bytes:
+        r"""
+        Get the bytes content of the response.
+        """
+
+    async def close(self) -> None:
+        r"""
+        Close the response connection.
+        """
+
+    async def __aenter__(self) -> Any: ...
+    async def __aexit__(
+        self, _exc_type: Any, _exc_value: Any, _traceback: Any
+    ) -> Any: ...
+
+class WebSocket:
+    r"""
+    A WebSocket response.
+    """
+
+    status: StatusCode
+    r"""
+    Get the status code of the response.
+    """
+
+    version: Version
+    r"""
+    Get the HTTP version of the response.
+    """
+
+    headers: HeaderMap
+    r"""
+    Get the headers of the response.
+    """
+
+    cookies: List[Cookie]
+    r"""
+    Get the cookies of the response.
+    """
+
+    remote_addr: Optional[SocketAddr]
+    r"""
+    Get the remote address of the response.
+    """
+
+    protocol: Optional[str]
+    r"""
+    Get the WebSocket protocol.
+    """
+
+    async def recv(
+        self, timeout: datetime.timedelta | None = None
+    ) -> Optional[Message]:
+        r"""
+        Receive a message from the WebSocket.
+        """
+
+    async def send(self, message: Message) -> None:
+        r"""
+        Send a message to the WebSocket.
+        """
+
+    async def send_all(self, messages: List[Message]) -> None:
+        r"""
+        Send multiple messages to the WebSocket.
+        """
+
+    async def close(
+        self,
+        code: int | None = None,
+        reason: str | None = None,
+    ) -> None:
+        r"""
+        Close the WebSocket connection.
+        """
+
+    def __aenter__(self) -> Any: ...
+    def __aexit__(self, _exc_type: Any, _exc_value: Any, _traceback: Any) -> Any: ...
+
+class ClientParams(TypedDict):
+    emulation: NotRequired[Union[Emulation, EmulationOption]]
+    """Emulation config."""
+
+    user_agent: NotRequired[str]
+    """
+    Default User-Agent string.
+    """
+
+    headers: NotRequired[Union[Dict[str, str], HeaderMap]]
+    """
+    Default request headers.
+    """
+
+    orig_headers: NotRequired[Union[List[str], OrigHeaderMap]]
+    """
+    Original request headers (case-sensitive and order).
+    """
+
+    referer: NotRequired[bool]
+    """
+    Automatically set Referer.
+    """
+
+    history: NotRequired[bool]
+    """
+    Store redirect history.
+    """
+
+    allow_redirects: NotRequired[bool]
+    """
+    Allow automatic redirects.
+    """
+
+    max_redirects: NotRequired[int]
+    """
+    Maximum number of redirects.
+    """
+
+    cookie_store: NotRequired[bool]
+    """
+    Enable cookie store.
+    """
+
+    cookie_provider: NotRequired[Jar]
+    """
+    Custom cookie provider.
+    """
+
+    lookup_ip_strategy: NotRequired[str]
+    """
+    IP lookup strategy.
+    """
+
+    timeout: NotRequired[int]
+    """
+    Total timeout (seconds).
+    """
+
+    connect_timeout: NotRequired[int]
+    """
+    Connection timeout (seconds).
+    """
+
+    read_timeout: NotRequired[int]
+    """
+    Read timeout (seconds).
+    """
+
+    tcp_keepalive: NotRequired[int]
+    """
+    TCP keepalive time (seconds).
+    """
+
+    tcp_keepalive_interval: NotRequired[int]
+    """
+    TCP keepalive interval (seconds).
+    """
+
+    tcp_keepalive_retries: NotRequired[int]
+    """
+    TCP keepalive retry count.
+    """
+
+    tcp_user_timeout: NotRequired[int]
+    """
+    TCP user timeout (seconds).
+    """
+
+    tcp_nodelay: NotRequired[bool]
+    """
+    Enable TCP_NODELAY.
+    """
+
+    tcp_reuse_address: NotRequired[bool]
+    """
+    Enable SO_REUSEADDR.
+    """
+
+    pool_idle_timeout: NotRequired[int]
+    """
+    Connection pool idle timeout (seconds).
+    """
+
+    pool_max_idle_per_host: NotRequired[int]
+    """
+    Max idle connections per host.
+    """
+
+    pool_max_size: NotRequired[int]
+    """
+    Max total connections in pool.
+    """
+
+    http1_only: NotRequired[bool]
+    """
+    Enable HTTP/1.1 only.
+    """
+
+    http2_only: NotRequired[bool]
+    """
+    Enable HTTP/2 only.
+    """
+
+    https_only: NotRequired[bool]
+    """
+    Enable HTTPS only.
+    """
+
+    http1_options: NotRequired[Http1Options]
+    """
+    Sets the HTTP/1 options.
+    """
+
+    http2_options: NotRequired[Http2Options]
+    """
+    Sets the HTTP/2 options.
+    """
+
+    verify: NotRequired[Union[bool, Path, CertStore]]
+    """
+    Verify SSL or specify CA path.
+    """
+
+    verify_hostname: NotRequired[bool]
+    """
+    Configures the use of hostname verification when connecting.
+    """
+
+    identity: NotRequired[Identity]
+    """
+    Represents a private key and X509 cert as a client certificate.
+    """
+
+    keylog: NotRequired[KeyLog]
+    """
+    Key logging policy (environment or file).
+    """
+
+    tls_info: NotRequired[bool]
+    """
+    Return TLS info.
+    """
+
+    min_tls_version: NotRequired[TlsVersion]
+    """
+    Minimum TLS version.
+    """
+
+    max_tls_version: NotRequired[TlsVersion]
+    """
+    Maximum TLS version.
+    """
+
+    tls_options: NotRequired[TlsOptions]
+    """
+    Sets the TLS options.
+    """
+
+    no_proxy: NotRequired[bool]
+    """
+    Disable proxy.
+    """
+
+    proxies: NotRequired[List[Proxy]]
+    """
+    Proxy server list.
+    """
+
+    local_address: NotRequired[Union[str, ipaddress.IPv4Address, ipaddress.IPv6Address]]
+    """
+    Local bind address.
+    """
+
+    interface: NotRequired[str]
+    """
+    Local network interface.
+    """
+
+    gzip: NotRequired[bool]
+    """
+    Enable gzip decompression.
+    """
+
+    brotli: NotRequired[bool]
+    """
+    Enable brotli decompression.
+    """
+
+    deflate: NotRequired[bool]
+    """
+    Enable deflate decompression.
+    """
+
+    zstd: NotRequired[bool]
+    """
+    Enable zstd decompression.
+    """
+
+class Request(TypedDict):
+    emulation: NotRequired[Union[Emulation, EmulationOption]]
+    """
+    The Emulation settings for the request.
+    """
+
+    proxy: NotRequired[Proxy]
+    """
+    The proxy to use for the request.
+    """
 
-class RequestParams(TypedDict, closed=True):
-    proxy: NotRequired[Union[str, Proxy]]
     local_address: NotRequired[Union[ipaddress.IPv4Address, ipaddress.IPv6Address]]
+    """
+    Bind to a local IP Address.
+    """
+
     interface: NotRequired[str]
+    """
+    Bind to an interface by SO_BINDTODEVICE.
+    """
+
     timeout: NotRequired[int]
+    """
+    The timeout to use for the request.
+    """
+
     read_timeout: NotRequired[int]
+    """
+    The read timeout to use for the request.
+    """
+
     version: NotRequired[Version]
+    """
+    The HTTP version to use for the request.
+    """
+
     headers: NotRequired[Union[Dict[str, str], HeaderMap]]
+    """
+    The headers to use for the request.
+    """
+
+    orig_headers: NotRequired[Union[List[str], OrigHeaderMap]]
+    """
+    The original headers to use for the request.
+    """
+
+    default_headers: NotRequired[bool]
+    """
+    The option enables default headers.
+    """
+
     cookies: NotRequired[Dict[str, str]]
+    """
+    The cookies to use for the request.
+    """
+
     allow_redirects: NotRequired[bool]
+    """
+    Whether to allow redirects.
+    """
+
     max_redirects: NotRequired[int]
+    """
+    The maximum number of redirects to follow.
+    """
+
+    gzip: NotRequired[bool]
+    """
+    Sets gzip as an accepted encoding.
+    """
+
+    brotli: NotRequired[bool]
+    """
+    Sets brotli as an accepted encoding.
+    """
+
+    deflate: NotRequired[bool]
+    """
+    Sets deflate as an accepted encoding.
+    """
+
+    zstd: NotRequired[bool]
+    """
+    Sets zstd as an accepted encoding.
+    """
+
     auth: NotRequired[str]
+    """
+    The authentication to use for the request.
+    """
+
     bearer_auth: NotRequired[str]
+    """
+    The bearer authentication to use for the request.
+    """
+
     basic_auth: NotRequired[Tuple[str, Optional[str]]]
+    """
+    The basic authentication to use for the request.
+    """
+
     query: NotRequired[List[Tuple[str, str]]]
-    form: NotRequired[List[Tuple[str, str]]]
+    """
+    The query parameters to use for the request.
+    """
+
+    form: NotRequired[Union[List[Tuple[str, str]], Dict[str, str]]]
+    """
+    The form parameters to use for the request.
+    """
+
     json: NotRequired[Dict[str, Any]]
+    """
+    The JSON body to use for the request.
+    """
+
     body: NotRequired[
         Union[
             str,
             bytes,
-            typing.AsyncGenerator[bytes, str],
-            typing.Generator[bytes, str],
+            Generator[bytes, str, None],
+            AsyncGenerator[bytes, str],
         ]
     ]
+    """
+    The body to use for the request.
+    """
+
     multipart: NotRequired[Multipart]
+    """
+    The multipart form to use for the request.
+    """
 
-class WebSocketParams(TypedDict, closed=True):
-    proxy: NotRequired[Union[str, Proxy]]
-    local_address: NotRequired[Union[str, ipaddress.IPv4Address, ipaddress.IPv6Address]]
-    interface: NotRequired[str]
-    headers: NotRequired[Union[Dict[str, str], HeaderMap]]
-    cookies: NotRequired[Dict[str, str]]
-    protocols: NotRequired[List[str]]
-    use_http2: NotRequired[bool]
-    auth: NotRequired[str]
-    bearer_auth: NotRequired[str]
-    basic_auth: NotRequired[Tuple[str, Optional[str]]]
-    query: NotRequired[List[Tuple[str, str]]]
-    read_buffer_size: NotRequired[int]
-    write_buffer_size: NotRequired[int]
-    max_write_buffer_size: NotRequired[int]
-    max_message_size: NotRequired[int]
-    max_frame_size: NotRequired[int]
-    accept_unmasked_frames: NotRequired[bool]
+class WebSocketRequest(TypedDict):
+    emulation: NotRequired[Union[Emulation, EmulationOption]]
+    """
+    The Emulation settings for the request.
+    """
 
-class ProxyParams(TypedDict, closed=True):
-    username: NotRequired[str]
-    password: NotRequired[str]
-    custom_http_auth: NotRequired[str]
-    custom_http_headers: NotRequired[Union[Dict[str, str], HeaderMap]]
-    exclusion: NotRequired[str]
+    proxy: NotRequired[Proxy]
+    """
+    The proxy to use for the request.
+    """
 
-class Client:
-    r"""
-    A client for making HTTP requests.
+    local_address: NotRequired[Union[str, ipaddress.IPv4Address, ipaddress.IPv6Address]]
+    """
+    Bind to a local IP Address.
     """
 
-    user_agent: Optional[str]
-    r"""
-    Returns the user agent of the client.
-    
-    # Examples
-    
-    ```python
-    import rnet
-    
-    client = rnet.Client()
-    user_agent = client.user_agent()
-    print(user_agent)
-    ```
+    interface: NotRequired[str]
     """
-    headers: HeaderMap
-    r"""
-    Returns the headers of the client.
-    
-    # Examples
-    
-    ```python
-    import rnet
-    
-    client = rnet.Client()
-    headers = client.headers()
-    print(headers)
-    ```
+    Bind to an interface by SO_BINDTODEVICE.
     """
-    def __new__(
-        cls,
-        impersonate: Optional[Union[Impersonate, ImpersonateOption]] = None,
-        user_agent: Optional[str] = None,
-        default_headers: Optional[Union[Dict[str, str], HeaderMap]] = None,
-        headers_order: Optional[List[str]] = None,
-        referer: Optional[bool] = None,
-        allow_redirects: Optional[bool] = None,
-        max_redirects: Optional[int] = None,
-        cookie_store: Optional[bool] = None,
-        lookup_ip_strategy: Optional[LookupIpStrategy] = None,
-        timeout: Optional[int] = None,
-        connect_timeout: Optional[int] = None,
-        read_timeout: Optional[int] = None,
-        no_keepalive: Optional[bool] = None,
-        tcp_keepalive: Optional[int] = None,
-        tcp_keepalive_interval: Optional[int] = None,
-        tcp_keepalive_retries: Optional[int] = None,
-        tcp_user_timeout: Optional[int] = None,
-        pool_idle_timeout: Optional[int] = None,
-        pool_max_idle_per_host: Optional[int] = None,
-        pool_max_size: Optional[int] = None,
-        http1_only: Optional[bool] = None,
-        http2_only: Optional[bool] = None,
-        https_only: Optional[bool] = None,
-        tcp_nodelay: Optional[bool] = None,
-        http2_max_retry_count: Optional[int] = None,
-        verify: Optional[Union[bool, Path]] = None,
-        tls_info: Optional[bool] = None,
-        min_tls_version: Optional[TlsVersion] = None,
-        max_tls_version: Optional[TlsVersion] = None,
-        no_proxy: Optional[bool] = None,
-        proxies: Optional[List[Proxy]] = None,
-        local_address: Optional[
-            Union[str, ipaddress.IPv4Address, ipaddress.IPv6Address]
-        ] = None,
-        interface: Optional[str] = None,
-        gzip: Optional[bool] = None,
-        brotli: Optional[bool] = None,
-        deflate: Optional[bool] = None,
-        zstd: Optional[bool] = None,
-    ) -> Client:
-        r"""
-        Creates a new Client instance.
 
-        Args:
-            impersonate: Browser fingerprint/impersonation config.
-            user_agent: Default User-Agent string.
-            default_headers: Default request headers.
-            headers_order: Custom header order.
-            referer: Automatically set Referer.
-            allow_redirects: Allow automatic redirects.
-            max_redirects: Maximum number of redirects.
-            cookie_store: Enable cookie store.
-            lookup_ip_strategy: IP lookup strategy.
-            timeout: Total timeout (seconds).
-            connect_timeout: Connection timeout (seconds).
-            read_timeout: Read timeout (seconds).
-            no_keepalive: Disable HTTP keep-alive.
-            tcp_keepalive: TCP keepalive time (seconds).
-            tcp_keepalive_interval: TCP keepalive interval (seconds).
-            tcp_keepalive_retries: TCP keepalive retry count.
-            tcp_user_timeout: TCP user timeout (seconds).
-            pool_idle_timeout: Connection pool idle timeout (seconds).
-            pool_max_idle_per_host: Max idle connections per host.
-            pool_max_size: Max total connections in pool.
-            http1_only: Enable HTTP/1.1 only.
-            http2_only: Enable HTTP/2 only.
-            https_only: Enable HTTPS only.
-            tcp_nodelay: Enable TCP_NODELAY.
-            http2_max_retry_count: Max HTTP/2 retry count.
-            verify: Verify SSL or specify CA path.
-            tls_info: Return TLS info.
-            min_tls_version: Minimum TLS version.
-            max_tls_version: Maximum TLS version.
-            no_proxy: Disable proxy.
-            proxies: Proxy server list.
-            local_address: Local bind address.
-            interface: Local network interface.
-            gzip: Enable gzip decompression.
-            brotli: Enable brotli decompression.
-            deflate: Enable deflate decompression.
-            zstd: Enable zstd decompression.
+    headers: NotRequired[Union[Dict[str, str], HeaderMap]]
+    """
+    The headers to use for the request.
+    """
 
-        Examples:
+    orig_headers: NotRequired[Union[List[str], OrigHeaderMap]]
+    """
+    The original headers to use for the request.
+    """
 
-            ```python
-            import asyncio
-            import rnet
+    default_headers: NotRequired[bool]
+    """
+    The option enables default headers.
+    """
 
-            client = rnet.Client(
-                user_agent="my-app/0.0.1",
-                timeout=10,
-            )
-            response = await client.get('https://httpbin.org/get')
-            print(response.text)
-            ```
-        """
+    cookies: NotRequired[Dict[str, str]]
+    """
+    The cookies to use for the request.
+    """
 
-    def get_cookies(self, url: str) -> Optional[bytes]:
-        r"""
-        Returns the cookies for the given URL.
+    protocols: NotRequired[List[str]]
+    """
+    The protocols to use for the request.
+    """
 
-        # Arguments
+    force_http2: NotRequired[bool]
+    """
+    Whether to use HTTP/2 for the websocket.
+    """
 
-        * `url` - The URL to get the cookies for.
+    auth: NotRequired[str]
+    """
+    The authentication to use for the request.
+    """
+
+    bearer_auth: NotRequired[str]
+    """
+    The bearer authentication to use for the request.
+    """
 
-        # Returns
+    basic_auth: NotRequired[Tuple[str, Optional[str]]]
+    """
+    The basic authentication to use for the request.
+    """
 
-        A List of cookie strings.
+    query: NotRequired[List[Tuple[str, str]]]
+    """
+    The query parameters to use for the request.
+    """
 
-        # Examples
+    read_buffer_size: NotRequired[int]
+    """
+    Read buffer capacity. This buffer is eagerly allocated and used for receiving messages.
 
-        ```python
-        import rnet
+    For high read load scenarios a larger buffer, e.g. 128 KiB, improves performance.
 
-        client = rnet.Client(cookie_store=True)
-        cookies = client.get_cookies("https://example.com")
-        print(cookies)
-        ```
-        """
+    For scenarios where you expect a lot of connections and don't need high read load
+    performance a smaller buffer, e.g. 4 KiB, would be appropriate to lower total
+    memory usage.
 
-    def set_cookie(self, url: str, cookie: Cookie) -> None:
-        r"""
-        Sets the cookies for the given URL.
+    The default value is 128 KiB.
+    """
 
-        # Arguments
-        * `url` - The URL to set the cookies for.
-        * `cookie` - The cookie to set.
+    write_buffer_size: NotRequired[int]
+    """
+    The target minimum size of the write buffer to reach before writing the data
+    to the underlying stream. The default value is 128 KiB.
 
-        # Examples
+    If set to 0 each message will be eagerly written to the underlying stream.
+    It is often more optimal to allow them to buffer a little, hence the default value.
 
-        ```python
-        import rnet
+    Note: flush() will always fully write the buffer regardless.
+    """
 
-        client = rnet.Client(cookie_store=True)
-        client.set_cookie("https://example.com", rnet.Cookie(name="foo", value="bar"))
-        ```
-        """
+    max_write_buffer_size: NotRequired[int]
+    """
+    The max size of the write buffer in bytes. Setting this can provide backpressure
+    in the case the write buffer is filling up due to write errors.
+    The default value is unlimited.
 
-    def remove_cookie(self, url: str, name: str) -> None:
-        r"""
-        Removes the cookie with the given name for the given URL.
+    Note: The write buffer only builds up past write_buffer_size when writes to the
+    underlying stream are failing. So the write buffer can not fill up if you are not
+    observing write errors even if not flushing.
 
-        # Arguments
-        * `url` - The URL to remove the cookie from.
-        * `name` - The name of the cookie to remove.
+    Note: Should always be at least write_buffer_size + 1 message and probably a little
+    more depending on error handling strategy.
+    """
 
-        # Examples
+    max_message_size: NotRequired[int]
+    """
+    The maximum size of an incoming message. None means no size limit.
+    The default value is 64 MiB which should be reasonably big for all normal use-cases
+    but small enough to prevent memory eating by a malicious user.
+    """
 
-        ```python
-        import rnet
+    max_frame_size: NotRequired[int]
+    """
+    The maximum size of a single incoming message frame. None means no size limit.
+    The limit is for frame payload NOT including the frame header.
+    The default value is 16 MiB which should be reasonably big for all normal use-cases
+    but small enough to prevent memory eating by a malicious user.
+    """
 
-        client = rnet.Client(cookie_store=True)
-        client.remove_cookie("https://example.com", "foo")
-        """
+    accept_unmasked_frames: NotRequired[bool]
+    """
+    When set to True, the server will accept and handle unmasked frames from the client.
+    According to RFC 6455, the server must close the connection to the client in such cases,
+    however it seems like there are some popular libraries that are sending unmasked frames,
+    ignoring the RFC. By default this option is set to False, i.e. according to RFC6455.
+    """
 
-    def clear_cookies(self) -> None:
-        r"""
-        Clears the cookies for the given URL.
-        """
+class Client:
+    r"""
+    A client for making HTTP requests.
+    """
 
-    def update(
+    def __init__(
         self,
-        impersonate: Optional[Union[Impersonate, ImpersonateOption]] = None,
-        headers: Optional[Union[Dict[str, str], HeaderMap]] = None,
-        headers_order: Optional[List[str]] = None,
-        proxies: Optional[List[Proxy]] = None,
-        local_address: Optional[
-            Union[ipaddress.IPv4Address, ipaddress.IPv6Address]
-        ] = None,
-        interface: Optional[str] = None,
+        **kwargs: Unpack[ClientParams],
     ) -> None:
         r"""
-        Updates the client with the given parameters.
-
-        # Arguments
-
-        * `impersonate` - The impersonation settings for the request.
-        * `headers` - The headers to use for the request.
-        * `headers_order` - The order of the headers to use for the request.
-        * `proxies` - The proxy to use for the request.
-        * `local_address` - The local IP address to bind to.
-        * `interface` - The interface to bind to.
+        Creates a new Client instance.
 
-        # Examples
+        Examples:
 
         ```python
+        import asyncio
         import rnet
 
-        client = rnet.Client()
-        client.update(
-           impersonate=rnet.Impersonate.Firefox135,
-           headers={"X-My-Header": "value"},
-           proxies=[rnet.Proxy.all("http://proxy.example.com:8080")],
-        )
+        async def main():
+            client = rnet.Client(
+                user_agent="Mozilla/5.0",
+                timeout=10,
+            )
+            response = await client.get('https://httpbin.org/get')
+            print(await response.text())
+
+        asyncio.run(main())
         ```
         """
+        ...
 
     async def request(
         self,
         method: Method,
         url: str,
-        **kwargs: Unpack[RequestParams],
+        **kwargs: Unpack[Request],
     ) -> Response:
         r"""
         Sends a request with the given method and URL.
@@ -336,7 +1123,7 @@ class Client:
     async def websocket(
         self,
         url: str,
-        **kwargs: Unpack[WebSocketParams],
+        **kwargs: Unpack[WebSocketRequest],
     ) -> WebSocket:
         r"""
         Sends a WebSocket request.
@@ -362,7 +1149,7 @@ class Client:
     async def trace(
         self,
         url: str,
-        **kwargs: Unpack[RequestParams],
+        **kwargs: Unpack[Request],
     ) -> Response:
         r"""
         Sends a request with the given URL
@@ -386,7 +1173,7 @@ class Client:
     async def options(
         self,
         url: str,
-        **kwargs: Unpack[RequestParams],
+        **kwargs: Unpack[Request],
     ) -> Response:
         r"""
         Sends a request with the given URL
@@ -410,7 +1197,7 @@ class Client:
     async def patch(
         self,
         url: str,
-        **kwargs: Unpack[RequestParams],
+        **kwargs: Unpack[Request],
     ) -> Response:
         r"""
         Sends a request with the given URL
@@ -434,7 +1221,7 @@ class Client:
     async def delete(
         self,
         url: str,
-        **kwargs: Unpack[RequestParams],
+        **kwargs: Unpack[Request],
     ) -> Response:
         r"""
         Sends a request with the given URL
@@ -458,7 +1245,7 @@ class Client:
     async def put(
         self,
         url: str,
-        **kwargs: Unpack[RequestParams],
+        **kwargs: Unpack[Request],
     ) -> Response:
         r"""
         Sends a request with the given URL
@@ -482,7 +1269,7 @@ class Client:
     async def post(
         self,
         url: str,
-        **kwargs: Unpack[RequestParams],
+        **kwargs: Unpack[Request],
     ) -> Response:
         r"""
         Sends a request with the given URL
@@ -506,7 +1293,7 @@ class Client:
     async def head(
         self,
         url: str,
-        **kwargs: Unpack[RequestParams],
+        **kwargs: Unpack[Request],
     ) -> Response:
         r"""
         Sends a request with the given URL
@@ -530,7 +1317,7 @@ class Client:
     async def get(
         self,
         url: str,
-        **kwargs: Unpack[RequestParams],
+        **kwargs: Unpack[Request],
     ) -> Response:
         r"""
         Sends a request with the given URL
@@ -540,261 +1327,20 @@ class Client:
         ```python
         import rnet
         import asyncio
-        from rnet import Method
-
-        async def main():
-            client = rnet.Client()
-            response = await client.get("https://httpbin.org/anything")
-            print(await response.text())
-
-        asyncio.run(main())
-        ```
-        """
-
-class Multipart:
-    r"""
-    A multipart form for a request.
-    """
-
-    def __new__(cls, *parts) -> Multipart:
-        r"""
-        Creates a new multipart form.
-        """
-
-class Part:
-    r"""
-    A part of a multipart form.
-    """
-
-    def __new__(
-        cls,
-        name: str,
-        value: Union[
-            str,
-            bytes,
-            Path,
-            typing.AsyncGenerator[bytes, str],
-            typing.Generator[bytes, str],
-        ],
-        filename: Optional[str] = None,
-        mime: Optional[str] = None,
-    ) -> Part:
-        r"""
-        Creates a new part.
-
-        # Arguments
-        - `name` - The name of the part.
-        - `value` - The value of the part, either text, bytes, a file path, or a async or sync stream.
-        - `filename` - The filename of the part.
-        - `mime` - The MIME type of the part.
-        """
-
-class Response:
-    r"""
-    A response from a request.
-
-    # Examples
-
-    ```python
-    import asyncio
-    import rnet
-
-    async def main():
-        response = await rnet.get("https://www.rust-lang.org")
-        print("Status Code: ", response.status_code)
-        print("Version: ", response.version)
-        print("Response URL: ", response.url)
-        print("Headers: ", response.headers)
-        print("Content-Length: ", response.content_length)
-        print("Encoding: ", response.encoding)
-        print("Remote Address: ", response.remote_addr)
-
-        text_content = await response.text()
-        print("Text: ", text_content)
-
-    if __name__ == "__main__":
-        asyncio.run(main())
-    ```
-    """
-
-    url: str
-    r"""
-    Returns the URL of the response.
-    """
-    ok: bool
-    r"""
-    Returns whether the response is successful.
-    """
-    status: int
-    r"""
-    Returns the status code as integer of the response.
-    """
-    status_code: StatusCode
-    r"""
-    Returns the status code of the response.
-    """
-    version: Version
-    r"""
-    Returns the HTTP version of the response.
-    """
-    headers: HeaderMap
-    r"""
-    Returns the headers of the response.
-    """
-    cookies: List[Cookie]
-    r"""
-    Returns the cookies of the response.
-    """
-    content_length: int
-    r"""
-    Returns the content length of the response.
-    """
-    remote_addr: Optional[SocketAddr]
-    r"""
-    Returns the remote address of the response.
-    """
-    encoding: str
-    r"""
-    Encoding to decode with when accessing text.
-    """
-    def __aenter__(self) -> Any: ...
-    def __aexit__(self, _exc_type: Any, _exc_value: Any, _traceback: Any) -> Any: ...
-    def peer_certificate(self) -> Optional[bytes]:
-        r"""
-        Returns the TLS peer certificate of the response.
-        """
-
-    async def text(self) -> str:
-        r"""
-        Returns the text content of the response.
-        """
-
-    async def text_with_charset(self, encoding: str) -> str:
-        r"""
-        Returns the text content of the response with a specific charset.
-
-        # Arguments
-
-        * `encoding` - The default encoding to use if the charset is not specified.
-        """
-
-    async def json(self) -> Any:
-        r"""
-        Returns the JSON content of the response.
-        """
-
-    async def bytes(self) -> bytes:
-        r"""
-        Returns the bytes content of the response.
-        """
-
-    def stream(self) -> Streamer:
-        r"""
-        Convert the response into a `Stream` of `Bytes` from the body.
-        """
-
-    async def close(self) -> None:
-        r"""
-        Closes the response connection.
-        """
-
-class SocketAddr:
-    r"""
-    A IP socket address.
-    """
-
-    def __str__(self) -> str: ...
-    def __repr__(self) -> str: ...
-    def ip(self) -> Union[ipaddress.IPv4Address, ipaddress.IPv6Address]:
-        r"""
-        Returns the IP address of the socket address.
-        """
-
-    def port(self) -> int:
-        r"""
-        Returns the port number of the socket address.
-        """
-
-class StatusCode:
-    r"""
-    HTTP status code.
-    """
-
-    def __str__(self) -> str: ...
-    def __repr__(self) -> str: ...
-    def as_int(self) -> int:
-        r"""
-        Return the status code as an integer.
-        """
-
-    def is_informational(self) -> bool:
-        r"""
-        Check if status is within 100-199.
-        """
-
-    def is_success(self) -> bool:
-        r"""
-        Check if status is within 200-299.
-        """
-
-    def is_redirection(self) -> bool:
-        r"""
-        Check if status is within 300-399.
-        """
-
-    def is_client_error(self) -> bool:
-        r"""
-        Check if status is within 400-499.
-        """
-
-    def is_server_error(self) -> bool:
-        r"""
-        Check if status is within 500-599.
-        """
-
-class Streamer:
-    r"""
-    A byte stream response.
-    An asynchronous iterator yielding data chunks from the response stream.
-    Used to stream response content.
-    Implemented in the `stream` method of the `Response` class.
-    Can be used in an asynchronous for loop in Python.
-
-    # Examples
-
-    ```python
-    import asyncio
-    import rnet
-    from rnet import Method, Impersonate
-
-    async def main():
-        resp = await rnet.get("https://httpbin.org/stream/20")
-        print("Status Code: ", resp.status_code)
-        print("Version: ", resp.version)
-        print("Response URL: ", resp.url)
-        print("Headers: ", resp.headers)
-        print("Content-Length: ", resp.content_length)
-        print("Encoding: ", resp.encoding)
-        print("Remote Address: ", resp.remote_addr)
+        from rnet import Method
 
-        async with resp.stream() as streamer:
-            async for chunk in streamer:
-                print("Chunk: ", chunk)
-                await asyncio.sleep(0.1)
+        async def main():
+            client = rnet.Client()
+            response = await client.get("https://httpbin.org/anything")
+            print(await response.text())
 
-    if __name__ == "__main__":
         asyncio.run(main())
-    ```
-    """
-
-    def __aiter__(self) -> Streamer: ...
-    def __anext__(self) -> Any: ...
-    def __aenter__(self) -> Any: ...
-    def __aexit__(self, _exc_type: Any, _exc_value: Any, _traceback: Any) -> Any: ...
+        ```
+        """
 
 async def delete(
     url: str,
-    **kwargs: Unpack[RequestParams],
+    **kwargs: Unpack[Request],
 ) -> Response:
     r"""
     Shortcut method to quickly make a request.
@@ -816,7 +1362,7 @@ async def delete(
 
 async def get(
     url: str,
-    **kwargs: Unpack[RequestParams],
+    **kwargs: Unpack[Request],
 ) -> Response:
     r"""
     Shortcut method to quickly make a request.
@@ -838,7 +1384,7 @@ async def get(
 
 async def head(
     url: str,
-    **kwargs: Unpack[RequestParams],
+    **kwargs: Unpack[Request],
 ) -> Response:
     r"""
     Shortcut method to quickly make a request.
@@ -859,7 +1405,7 @@ async def head(
 
 async def options(
     url: str,
-    **kwargs: Unpack[RequestParams],
+    **kwargs: Unpack[Request],
 ) -> Response:
     r"""
     Shortcut method to quickly make a request.
@@ -880,7 +1426,7 @@ async def options(
 
 async def patch(
     url: str,
-    **kwargs: Unpack[RequestParams],
+    **kwargs: Unpack[Request],
 ) -> Response:
     r"""
     Shortcut method to quickly make a request.
@@ -902,7 +1448,7 @@ async def patch(
 
 async def post(
     url: str,
-    **kwargs: Unpack[RequestParams],
+    **kwargs: Unpack[Request],
 ) -> Response:
     r"""
     Shortcut method to quickly make a request.
@@ -924,7 +1470,7 @@ async def post(
 
 async def put(
     url: str,
-    **kwargs: Unpack[RequestParams],
+    **kwargs: Unpack[Request],
 ) -> Response:
     r"""
     Shortcut method to quickly make a request.
@@ -947,7 +1493,7 @@ async def put(
 async def request(
     method: Method,
     url: str,
-    **kwargs: Unpack[RequestParams],
+    **kwargs: Unpack[Request],
 ) -> Response:
     r"""
     Make a request with the given parameters.
@@ -976,7 +1522,7 @@ async def request(
 
 async def trace(
     url: str,
-    **kwargs: Unpack[RequestParams],
+    **kwargs: Unpack[Request],
 ) -> Response:
     r"""
     Shortcut method to quickly make a request.
@@ -997,7 +1543,7 @@ async def trace(
 
 async def websocket(
     url: str,
-    **kwargs: Unpack[WebSocketParams],
+    **kwargs: Unpack[WebSocketRequest],
 ) -> WebSocket:
     r"""
     Make a WebSocket connection with the given parameters.
@@ -1019,304 +1565,3 @@ async def websocket(
     asyncio.run(run())
     ```
     """
-
-class Proxy:
-    r"""
-    A proxy server for a request.
-    Supports HTTP, HTTPS, SOCKS4, SOCKS4a, SOCKS5, and SOCKS5h protocols.
-    """
-
-    @staticmethod
-    def http(url: str, **kwargs: Unpack[ProxyParams]) -> Proxy:
-        r"""
-        Creates a new HTTP proxy.
-
-        This method sets up a proxy server for HTTP requests.
-
-        # Arguments
-
-        * `url` - The URL of the proxy server.
-        * `username` - Optional username for proxy authentication.
-        * `password` - Optional password for proxy authentication.
-        * `custom_http_auth` - Optional custom HTTP proxy authentication header value.
-        * `custom_http_headers` - Optional custom HTTP proxy headers.
-        * `exclusion` - Optional List of domains to exclude from proxying.
-
-        # Examples
-
-        ```python
-        import rnet
-
-        proxy = rnet.Proxy.http("http://proxy.example.com")
-        ```
-        """
-
-    @staticmethod
-    def https(url: str, **kwargs: Unpack[ProxyParams]) -> Proxy:
-        r"""
-        Creates a new HTTPS proxy.
-
-        This method sets up a proxy server for HTTPS requests.
-
-        # Arguments
-
-        * `url` - The URL of the proxy server.
-        * `username` - Optional username for proxy authentication.
-        * `password` - Optional password for proxy authentication.
-        * `custom_http_auth` - Optional custom HTTP proxy authentication header value.
-        * `custom_http_headers` - Optional custom HTTP proxy headers.
-        * `exclusion` - Optional List of domains to exclude from proxying.
-
-        # Examples
-
-        ```python
-        import rnet
-
-        proxy = rnet.Proxy.https("https://proxy.example.com")
-        ```
-        """
-
-    @staticmethod
-    def all(url: str, **kwargs: Unpack[ProxyParams]) -> Proxy:
-        r"""
-        Creates a new proxy for all protocols.
-
-        This method sets up a proxy server for all types of requests (HTTP, HTTPS, etc.).
-
-        # Arguments
-
-        * `url` - The URL of the proxy server.
-        * `username` - Optional username for proxy authentication.
-        * `password` - Optional password for proxy authentication.
-        * `custom_http_auth` - Optional custom HTTP proxy authentication header value.
-        * `custom_http_headers` - Optional custom HTTP proxy headers.
-        * `exclusion` - Optional List of domains to exclude from proxying.
-
-        # Examples
-
-        ```python
-        import rnet
-
-        proxy = rnet.Proxy.all("https://proxy.example.com")
-        ```
-        """
-
-class Message:
-    r"""
-    A WebSocket message.
-    """
-
-    data: Optional[bytes]
-    r"""
-    Returns the data of the message as bytes.
-    """
-    text: Optional[str]
-    r"""
-    Returns the text content of the message if it is a text message.
-    """
-    binary: Optional[bytes]
-    r"""
-    Returns the binary data of the message if it is a binary message.
-    """
-    ping: Optional[bytes]
-    r"""
-    Returns the ping data of the message if it is a ping message.
-    """
-    pong: Optional[bytes]
-    r"""
-    Returns the pong data of the message if it is a pong message.
-    """
-    close: Optional[Tuple[int, Optional[str]]]
-    r"""
-    Returns the close code and reason of the message if it is a close message.
-    """
-    def __str__(self) -> str: ...
-    def __repr__(self) -> str: ...
-    @staticmethod
-    def text_from_json(json: Dict[str, Any]) -> Message:
-        r"""
-        Creates a new text message from the JSON representation.
-
-        # Arguments
-        * `json` - The JSON representation of the message.
-        """
-
-    @staticmethod
-    def binary_from_json(json: Dict[str, Any]) -> Message:
-        r"""
-        Creates a new binary message from the JSON representation.
-
-        # Arguments
-        * `json` - The JSON representation of the message.
-        """
-
-    @staticmethod
-    def from_text(text: str) -> Message:
-        r"""
-        Creates a new text message.
-
-        # Arguments
-
-        * `text` - The text content of the message.
-        """
-
-    @staticmethod
-    def from_binary(data: bytes) -> Message:
-        r"""
-        Creates a new binary message.
-
-        # Arguments
-
-        * `data` - The binary data of the message.
-        """
-
-    @staticmethod
-    def from_ping(data: bytes) -> Message:
-        r"""
-        Creates a new ping message.
-
-        # Arguments
-
-        * `data` - The ping data of the message.
-        """
-
-    @staticmethod
-    def from_pong(data: bytes) -> Message:
-        r"""
-        Creates a new pong message.
-
-        # Arguments
-
-        * `data` - The pong data of the message.
-        """
-
-    @staticmethod
-    def from_close(code: int, reason: Optional[str] = None) -> Message:
-        r"""
-        Creates a new close message.
-
-        # Arguments
-
-        * `code` - The close code.
-        * `reason` - An optional reason for closing.
-        """
-
-    def json(self) -> Dict[str, Any]:
-        r"""
-        Returns the JSON representation of the message.
-        """
-
-class WebSocket:
-    r"""
-    A WebSocket response.
-    """
-
-    ok: bool
-    r"""
-    Returns whether the response is successful.
-    """
-    status: int
-    r"""
-    Returns the status code as integer of the response.
-    """
-    status_code: StatusCode
-    r"""
-    Returns the status code of the response.
-    """
-    version: Version
-    r"""
-    Returns the HTTP version of the response.
-    """
-    headers: HeaderMap
-    r"""
-    Returns the headers of the response.
-    """
-    cookies: List[Cookie]
-    r"""
-    Returns the cookies of the response.
-    """
-    remote_addr: Optional[SocketAddr]
-    r"""
-    Returns the remote address of the response.
-    """
-    protocol: Optional[str]
-    r"""
-    Returns the WebSocket protocol.
-    """
-    def __aiter__(self) -> WebSocket: ...
-    def __anext__(self) -> Any: ...
-    def __aenter__(self) -> Any: ...
-    def __aexit__(self, _exc_type: Any, _exc_value: Any, _traceback: Any) -> Any: ...
-    async def recv(self) -> Optional[Message]:
-        r"""
-        Receives a message from the WebSocket.
-        """
-
-    async def send(self, message: Message) -> None:
-        r"""
-        Sends a message to the WebSocket.
-
-        # Arguments
-
-        * `message` - The message to send.
-        """
-
-    async def close(
-        self,
-        code: Optional[int] = None,
-        reason: Optional[str] = None,
-    ) -> None:
-        r"""
-        Closes the WebSocket connection.
-
-        # Arguments
-
-        * `code` - An optional close code.
-        * `reason` - An optional reason for closing.
-        """
-
-class LookupIpStrategy(Enum):
-    r"""
-    The lookup ip strategy.
-    """
-
-    Ipv4Only = auto()
-    Ipv6Only = auto()
-    Ipv4AndIpv6 = auto()
-    Ipv6thenIpv4 = auto()
-    Ipv4thenIpv6 = auto()
-
-class Method(Enum):
-    r"""
-    An HTTP method.
-    """
-
-    GET = auto()
-    HEAD = auto()
-    POST = auto()
-    PUT = auto()
-    DELETE = auto()
-    OPTIONS = auto()
-    TRACE = auto()
-    PATCH = auto()
-
-class TlsVersion(Enum):
-    r"""
-    The TLS version.
-    """
-
-    TLS_1_0 = auto()
-    TLS_1_1 = auto()
-    TLS_1_2 = auto()
-    TLS_1_3 = auto()
-
-class Version(Enum):
-    r"""
-    An HTTP version.
-    """
-
-    HTTP_09 = auto()
-    HTTP_10 = auto()
-    HTTP_11 = auto()
-    HTTP_2 = auto()
-    HTTP_3 = auto()