rnet.pyi

# This file is automatically generated by pyo3_stub_gen
# ruff: noqa: E501, F401

import builtins
import datetime
import typing
from enum import Enum, auto

class BlockingClient:
    r"""
    A blocking client for making HTTP requests.
    """

    user_agent: typing.Optional[builtins.str]
    headers: HeaderMap
    def __new__(cls, **kwds): ...
    def get_cookies(self, url: str) -> typing.Optional[typing.Any]:
        r"""
        Returns the cookies for the given URL.

        # Arguments

        * `url` - The URL to get the cookies for.

        # Returns

        A list of cookie strings.
        """
        ...

    def set_cookie(self, url: str, cookie: Cookie) -> None:
        r"""
        Sets the cookies for the given URL.

        # Arguments
        * `url` - The URL to set the cookies for.
        * `cookie` - The cookie to set.

        # Examples

        ```python
        import rnet

        client = rnet.Client(cookie_store=True)
        client.set_cookie("https://example.com", rnet.Cookie(name="foo", value="bar"))
        ```
        """
        ...

    def remove_cookie(self, url: str, name: str) -> None:
        r"""
        Removes the cookie with the given name for the given URL.

        # Arguments
        * `url` - The URL to remove the cookie from.
        * `name` - The name of the cookie to remove.

        # Examples

        ```python
        import rnet

        client = rnet.Client(cookie_store=True)
        client.remove_cookie("https://example.com", "foo")
        """
        ...

    def clear_cookies(self) -> None:
        r"""
        Clears the cookies for the given URL.
        """
        ...

    def update(self, **kwds) -> None:
        r"""
        Updates the client with the given parameters.

        # Arguments
        * `**kwds` - The parameters to update the client with.

            impersonate: typing.Optional[typing.Union[Impersonate, ImpersonateOption]]
            headers: typing.Optional[typing.Dict[str, bytes]]
            headers_order: typing.Optional[typing.List[str]]
            proxies: typing.Optional[builtins.list[Proxy]]
            local_address: typing.Optional[typing.Optional[typing.Union[str, ipaddress.IPv4Address, ipaddress.IPv6Address]]]
            interface: typing.Optional[builtins.str]

        # Examples

        ```python
        import rnet

        client = rnet.BlockingClient()
        client.update(
           impersonate=rnet.Impersonate.Firefox135,
           headers={"X-My-Header": "value"},
           proxies=[rnet.Proxy.all("http://proxy.example.com:8080")],
        )
        ```
        """
        ...

    def request(
        self,
        method: Method,
        url: str,
        kwds: typing.Optional[typing.Dict[str, typing.Any]],
    ) -> BlockingResponse:
        r"""
        Sends a request with the given method and URL.

        # Arguments

        * `method` - The method to use for the request.
        * `url` - The URL to send the request to.
        * `**kwds` - Additional request parameters.

            proxy: typing.Optional[builtins.str]
            local_address: typing.Optional[typing.Optional[typing.Union[str, ipaddress.IPv4Address, ipaddress.IPv6Address]]]
            interface: typing.Optional[builtins.str]
            timeout: typing.Optional[builtins.int]
            read_timeout: typing.Optional[builtins.int]
            version: typing.Optional[Version]
            headers: typing.Optional[typing.Dict[str, bytes]]
            cookies: typing.Optional[typing.Dict[str, str]]
            allow_redirects: typing.Optional[builtins.bool]
            max_redirects: typing.Optional[builtins.int]
            auth: typing.Optional[str]
            bearer_auth: typing.Optional[str]
            basic_auth: typing.Optional[tuple[str, typing.Optional[str]]]
            query: typing.Optional[typing.List[typing.Tuple[str, str]]]
            form: typing.Optional[typing.List[typing.Tuple[str, str]]]
            json: typing.Optional[typing.Any]
            body: typing.Optional[typing.Any]
            multipart: typing.Optional[Multipart]

        # Returns

        A `Response` object.

        # Examples

        ```python
        import rnet
        import asyncio
        from rnet import Method

        async def main():
            client = rnet.BlockingClient()
            response = client.request(Method.GET, "https://httpbin.org/anything")
            print(response.text())

        asyncio.run(main())
        ```
        """
        ...

    def websocket(self, url: str, **kwds) -> BlockingWebSocket:
        r"""
        Sends a WebSocket request.

        # Arguments

        * `url` - The URL to send the WebSocket request to.
        * `**kwds` - Additional WebSocket request parameters.

            proxy: typing.Optional[builtins.str]
            local_address: typing.Optional[typing.Optional[typing.Union[str, ipaddress.IPv4Address, ipaddress.IPv6Address]]]
            interface: typing.Optional[builtins.str]
            headers: typing.Optional[typing.Dict[str, bytes]]
            cookies: typing.Optional[typing.Dict[str, str]]
            protocols: typing.Optional[builtins.list[builtins.str]]
            use_http2: typing.Optional[builtins.bool]
            auth: typing.Optional[builtins.str]
            bearer_auth: typing.Optional[builtins.str]
            basic_auth: typing.Optional[tuple[builtins.str, typing.Optional[builtins.str]]]
            query: typing.Optional[builtins.list[tuple[builtins.str, builtins.str]]]
            read_buffer_size: typing.Optional[builtins.int]
            write_buffer_size: typing.Optional[builtins.int]
            max_write_buffer_size: typing.Optional[builtins.int]
            max_message_size: typing.Optional[builtins.int]
            max_frame_size: typing.Optional[builtins.int]
            accept_unmasked_frames: typing.Optional[builtins.bool]

        # Returns

        A `WebSocket` object representing the WebSocket connection.

        # Examples

        ```python
        import rnet
        import asyncio

        async def main():
            client = rnet.BlockingClient()
            ws = client.websocket("wss://echo.websocket.org")
            ws.send(rnet.Message.from_text("Hello, WebSocket!"))
            message = ws.recv()
            print("Received:", message.data)
            ws.close()

        asyncio.run(main())
        ```
        """
        ...

    def trace(self, url: str, **kwds) -> BlockingResponse:
        r"""
        Sends a request with the given URL.

        # Arguments

        * `url` - The URL to send the request to.
        * `**kwds` - Additional request parameters.

            proxy: typing.Optional[builtins.str]
            local_address: typing.Optional[typing.Optional[typing.Union[str, ipaddress.IPv4Address, ipaddress.IPv6Address]]]
            interface: typing.Optional[builtins.str]
            timeout: typing.Optional[builtins.int]
            read_timeout: typing.Optional[builtins.int]
            version: typing.Optional[Version]
            headers: typing.Optional[typing.Dict[str, bytes]]
            cookies: typing.Optional[typing.Dict[str, str]]
            allow_redirects: typing.Optional[builtins.bool]
            max_redirects: typing.Optional[builtins.int]
            auth: typing.Optional[str]
            bearer_auth: typing.Optional[str]
            basic_auth: typing.Optional[tuple[str, typing.Optional[str]]]
            query: typing.Optional[typing.List[typing.Tuple[str, str]]]
            form: typing.Optional[typing.List[typing.Tuple[str, str]]]
            json: typing.Optional[typing.Any]
            body: typing.Optional[typing.Any]
            multipart: typing.Optional[Multipart]

        # Returns

        A `Response` object.

        # Examples

        ```python
        import rnet
        import asyncio
        from rnet import Method

        async def main():
            client = rnet.BlockingClient()
            response = client.trace("https://httpbin.org/anything")
            print(response.text())

        asyncio.run(main())
        ```
        """
        ...

    def options(self, url: str, **kwds) -> BlockingResponse:
        r"""
        Sends a request with the given URL.

        # Arguments

        * `url` - The URL to send the request to.
        * `**kwds` - Additional request parameters.

            proxy: typing.Optional[builtins.str]
            local_address: typing.Optional[typing.Optional[typing.Union[str, ipaddress.IPv4Address, ipaddress.IPv6Address]]]
            interface: typing.Optional[builtins.str]
            timeout: typing.Optional[builtins.int]
            read_timeout: typing.Optional[builtins.int]
            version: typing.Optional[Version]
            headers: typing.Optional[typing.Dict[str, bytes]]
            cookies: typing.Optional[typing.Dict[str, str]]
            allow_redirects: typing.Optional[builtins.bool]
            max_redirects: typing.Optional[builtins.int]
            auth: typing.Optional[str]
            bearer_auth: typing.Optional[str]
            basic_auth: typing.Optional[tuple[str, typing.Optional[str]]]
            query: typing.Optional[typing.List[typing.Tuple[str, str]]]
            form: typing.Optional[typing.List[typing.Tuple[str, str]]]
            json: typing.Optional[typing.Any]
            body: typing.Optional[typing.Any]
            multipart: typing.Optional[Multipart]

        # Returns

        A `Response` object.

        # Examples

        ```python
        import rnet
        import asyncio
        from rnet import Method

        async def main():
            client = rnet.BlockingClient()
            response = client.options("https://httpbin.org/anything")
            print(response.text())

        asyncio.run(main())
        ```
        """
        ...

    def head(self, url: str, **kwds) -> BlockingResponse:
        r"""
        Sends a request with the given URL.

        # Arguments

        * `url` - The URL to send the request to.
        * `**kwds` - Additional request parameters.

            proxy: typing.Optional[builtins.str]
            local_address: typing.Optional[typing.Optional[typing.Union[str, ipaddress.IPv4Address, ipaddress.IPv6Address]]]
            interface: typing.Optional[builtins.str]
            timeout: typing.Optional[builtins.int]
            read_timeout: typing.Optional[builtins.int]
            version: typing.Optional[Version]
            headers: typing.Optional[typing.Dict[str, bytes]]
            cookies: typing.Optional[typing.Dict[str, str]]
            allow_redirects: typing.Optional[builtins.bool]
            max_redirects: typing.Optional[builtins.int]
            auth: typing.Optional[str]
            bearer_auth: typing.Optional[str]
            basic_auth: typing.Optional[tuple[str, typing.Optional[str]]]
            query: typing.Optional[typing.List[typing.Tuple[str, str]]]
            form: typing.Optional[typing.List[typing.Tuple[str, str]]]
            json: typing.Optional[typing.Any]
            body: typing.Optional[typing.Any]
            multipart: typing.Optional[Multipart]

        # Returns

        A `Response` object.

        # Examples

        ```python
        import rnet
        import asyncio
        from rnet import Method

        async def main():
            client = rnet.BlockingClient()
            response = client.head("https://httpbin.org/anything")
            print(response.text())

        asyncio.run(main())
        ```
        """
        ...

    def delete(self, url: str, **kwds) -> BlockingResponse:
        r"""
        Sends a request with the given URL.

        # Arguments

        * `url` - The URL to send the request to.
        * `**kwds` - Additional request parameters.

            proxy: typing.Optional[builtins.str]
            local_address: typing.Optional[typing.Optional[typing.Union[str, ipaddress.IPv4Address, ipaddress.IPv6Address]]]
            interface: typing.Optional[builtins.str]
            timeout: typing.Optional[builtins.int]
            read_timeout: typing.Optional[builtins.int]
            version: typing.Optional[Version]
            headers: typing.Optional[typing.Dict[str, bytes]]
            cookies: typing.Optional[typing.Dict[str, str]]
            allow_redirects: typing.Optional[builtins.bool]
            max_redirects: typing.Optional[builtins.int]
            auth: typing.Optional[str]
            bearer_auth: typing.Optional[str]
            basic_auth: typing.Optional[tuple[str, typing.Optional[str]]]
            query: typing.Optional[typing.List[typing.Tuple[str, str]]]
            form: typing.Optional[typing.List[typing.Tuple[str, str]]]
            json: typing.Optional[typing.Any]
            body: typing.Optional[typing.Any]
            multipart: typing.Optional[Multipart]

        # Returns

        A `Response` object.

        # Examples

        ```python
        import rnet
        import asyncio
        from rnet import Method

        async def main():
            client = rnet.BlockingClient()
            response = client.delete("https://httpbin.org/anything")
            print(response.text())

        asyncio.run(main())
        ```
        """
        ...

    def patch(self, url: str, **kwds) -> BlockingResponse:
        r"""
        Sends a request with the given URL.

        # Arguments

        * `url` - The URL to send the request to.
        * `**kwds` - Additional request parameters.

            proxy: typing.Optional[builtins.str]
            local_address: typing.Optional[typing.Optional[typing.Union[str, ipaddress.IPv4Address, ipaddress.IPv6Address]]]
            interface: typing.Optional[builtins.str]
            timeout: typing.Optional[builtins.int]
            read_timeout: typing.Optional[builtins.int]
            version: typing.Optional[Version]
            headers: typing.Optional[typing.Dict[str, bytes]]
            cookies: typing.Optional[typing.Dict[str, str]]
            allow_redirects: typing.Optional[builtins.bool]
            max_redirects: typing.Optional[builtins.int]
            auth: typing.Optional[str]
            bearer_auth: typing.Optional[str]
            basic_auth: typing.Optional[tuple[str, typing.Optional[str]]]
            query: typing.Optional[typing.List[typing.Tuple[str, str]]]
            form: typing.Optional[typing.List[typing.Tuple[str, str]]]
            json: typing.Optional[typing.Any]
            body: typing.Optional[typing.Any]
            multipart: typing.Optional[Multipart]

        # Returns

        A `Response` object.

        # Examples

        ```python
        import rnet
        import asyncio
        from rnet import Method

        async def main():
            client = rnet.BlockingClient()
            response = client.patch("https://httpbin.org/anything", json={"key": "value"})
            print(response.text())

        asyncio.run(main())
        ```
        """
        ...

    def put(self, url: str, **kwds) -> BlockingResponse:
        r"""
        Sends a request with the given URL.

        # Arguments

        * `url` - The URL to send the request to.
        * `**kwds` - Additional request parameters.

            proxy: typing.Optional[builtins.str]
            local_address: typing.Optional[typing.Optional[typing.Union[str, ipaddress.IPv4Address, ipaddress.IPv6Address]]]
            interface: typing.Optional[builtins.str]
            timeout: typing.Optional[builtins.int]
            read_timeout: typing.Optional[builtins.int]
            version: typing.Optional[Version]
            headers: typing.Optional[typing.Dict[str, bytes]]
            cookies: typing.Optional[typing.Dict[str, str]]
            allow_redirects: typing.Optional[builtins.bool]
            max_redirects: typing.Optional[builtins.int]
            auth: typing.Optional[str]
            bearer_auth: typing.Optional[str]
            basic_auth: typing.Optional[tuple[str, typing.Optional[str]]]
            query: typing.Optional[typing.List[typing.Tuple[str, str]]]
            form: typing.Optional[typing.List[typing.Tuple[str, str]]]
            json: typing.Optional[typing.Any]
            body: typing.Optional[typing.Any]
            multipart: typing.Optional[Multipart]

        # Returns

        A `Response` object.

        # Examples

        ```python
        import rnet
        import asyncio
        from rnet import Method

        async def main():
            client = rnet.BlockingClient()
            response = client.put("https://httpbin.org/anything", json={"key": "value"})
            print(response.text())

        asyncio.run(main())
        ```
        """
        ...

    def post(self, url: str, **kwds) -> BlockingResponse:
        r"""
        Sends a request with the given URL.

        # Arguments

        * `url` - The URL to send the request to.
        * `**kwds` - Additional request parameters.

            proxy: typing.Optional[builtins.str]
            local_address: typing.Optional[typing.Optional[typing.Union[str, ipaddress.IPv4Address, ipaddress.IPv6Address]]]
            interface: typing.Optional[builtins.str]
            timeout: typing.Optional[builtins.int]
            read_timeout: typing.Optional[builtins.int]
            version: typing.Optional[Version]
            headers: typing.Optional[typing.Dict[str, bytes]]
            cookies: typing.Optional[typing.Dict[str, str]]
            allow_redirects: typing.Optional[builtins.bool]
            max_redirects: typing.Optional[builtins.int]
            auth: typing.Optional[str]
            bearer_auth: typing.Optional[str]
            basic_auth: typing.Optional[tuple[str, typing.Optional[str]]]
            query: typing.Optional[typing.List[typing.Tuple[str, str]]]
            form: typing.Optional[typing.List[typing.Tuple[str, str]]]
            json: typing.Optional[typing.Any]
            body: typing.Optional[typing.Any]
            multipart: typing.Optional[Multipart]

        # Returns

        A `Response` object.

        # Examples

        ```python
        import rnet
        import asyncio
        from rnet import Method

        async def main():
            client = rnet.BlockingClient()
            response = client.post("https://httpbin.org/anything", json={"key": "value"})
            print(response.text())

        asyncio.run(main())
        ```
        """
        ...

    def get(self, url: str, **kwds) -> BlockingResponse:
        r"""
        Sends a request with the given URL.

        # Arguments

        * `url` - The URL to send the request to.
        * `**kwds` - Additional request parameters.

            proxy: typing.Optional[builtins.str]
            local_address: typing.Optional[typing.Optional[typing.Union[str, ipaddress.IPv4Address, ipaddress.IPv6Address]]]
            interface: typing.Optional[builtins.str]
            timeout: typing.Optional[builtins.int]
            read_timeout: typing.Optional[builtins.int]
            version: typing.Optional[Version]
            headers: typing.Optional[typing.Dict[str, bytes]]
            cookies: typing.Optional[typing.Dict[str, str]]
            allow_redirects: typing.Optional[builtins.bool]
            max_redirects: typing.Optional[builtins.int]
            auth: typing.Optional[str]
            bearer_auth: typing.Optional[str]
            basic_auth: typing.Optional[tuple[str, typing.Optional[str]]]
            query: typing.Optional[typing.List[typing.Tuple[str, str]]]
            form: typing.Optional[typing.List[typing.Tuple[str, str]]]
            json: typing.Optional[typing.Any]
            body: typing.Optional[typing.Any]
            multipart: typing.Optional[Multipart]

        # Returns

        A `Response` object.

        # Examples

        ```python
        import rnet
        import asyncio
        from rnet import Method

        async def main():
            client = rnet.BlockingClient()
            response = client.get("https://httpbin.org/anything")
            print(response.text())

        asyncio.run(main())
        ```
        """
        ...

class BlockingResponse:
    r"""
    A bloking response from a request.
    """

    url: builtins.str
    ok: builtins.bool
    status: builtins.int
    status_code: StatusCode
    version: Version
    headers: HeaderMap
    cookies: builtins.list[Cookie]
    content_length: builtins.int
    remote_addr: typing.Optional[SocketAddr]
    encoding: builtins.str
    def __enter__(self) -> BlockingResponse: ...
    def __exit__(
        self, _exc_type: typing.Any, _exc_value: typing.Any, _traceback: typing.Any
    ) -> None: ...
    def peer_certificate(self) -> typing.Optional[typing.Any]:
        r"""
        Returns the TLS peer certificate of the response.

        # Returns

        A Python object representing the TLS peer certificate of the response.
        """
        ...

    def text(self) -> builtins.str:
        r"""
        Returns the text content of the response.

        # Returns

        A Python object representing the text content of the response.
        """
        ...

    def text_with_charset(self, encoding: builtins.str) -> builtins.str:
        r"""
        Returns the text content of the response with a specific charset.

        # Arguments

        * `default_encoding` - The default encoding to use if the charset is not specified.

        # Returns

        A Python object representing the text content of the response.
        """
        ...

    def json(self) -> typing.Dict[str, typing.Any]:
        r"""
        Returns the JSON content of the response.

        # Returns

        A Python object representing the JSON content of the response.
        """
        ...

    def bytes(self) -> typing.Any:
        r"""
        Returns the bytes content of the response.

        # Returns

        A Python object representing the bytes content of the response.
        """
        ...

    def stream(self) -> BlockingStreamer:
        r"""
        Convert the response into a `Stream` of `Bytes` from the body.

        # Returns

        A Python object representing the stream content of the response.
        """
        ...

    def close(self) -> None:
        r"""
        Closes the response connection.
        """
        ...

class BlockingStreamer:
    r"""
    A blocking byte stream response.
    An asynchronous iterator yielding data chunks from the response stream.
    Used for streaming response content.
    Employed in the `stream` method of the `Response` class.
    Utilized in an asynchronous for loop in Python.
    """

    def __iter__(self) -> BlockingStreamer: ...
    def __next__(self) -> typing.Any: ...
    def __enter__(self) -> BlockingStreamer: ...
    def __exit__(
        self, _exc_type: typing.Any, _exc_value: typing.Any, _traceback: typing.Any
    ) -> None: ...

class BlockingWebSocket:
    r"""
    A blocking WebSocket response.
    """

    ok: builtins.bool
    status: builtins.int
    status_code: StatusCode
    version: Version
    headers: HeaderMap
    cookies: builtins.list[Cookie]
    remote_addr: typing.Optional[SocketAddr]
    def __iter__(self) -> BlockingWebSocket: ...
    def __next__(self) -> Message: ...
    def __enter__(self) -> BlockingWebSocket: ...
    def __exit__(
        self, _exc_type: typing.Any, _exc_value: typing.Any, _traceback: typing.Any
    ) -> None: ...
    def protocol(self) -> typing.Optional[builtins.str]:
        r"""
        Returns the WebSocket protocol.

        # Returns

        An optional string representing the WebSocket protocol.
        """
        ...

    def recv(self) -> typing.Optional[Message]:
        r"""
        Receives a message from the WebSocket.

        # Returns

        A `PyResult` containing a `Bound` object with the received message, or `None` if no message is received.
        """
        ...

    def send(self, message: Message) -> None:
        r"""
        Sends a message to the WebSocket.

        # Arguments

        * `message` - The message to send.

        # Returns

        A `PyResult` containing a `Bound` object.
        """
        ...

    def close(
        self,
        code: typing.Optional[builtins.int] = None,
        reason: typing.Optional[str] = None,
    ) -> None:
        r"""
        Closes the WebSocket connection.

        # Arguments

        * `code` - An optional close code.
        * `reason` - An optional reason for closing.

        # Returns

        A `PyResult` containing a `Bound` object.
        """
        ...

class Client:
    r"""
    A client for making HTTP requests.
    """

    user_agent: typing.Optional[builtins.str]
    headers: HeaderMap
    def __new__(cls, **kwds): ...
    def get_cookies(self, url: str) -> typing.Optional[typing.Any]:
        r"""
        Returns the cookies for the given URL.

        # Arguments

        * `url` - The URL to get the cookies for.

        # Returns

        A list of cookie strings.

        # Examples

        ```python
        import rnet

        client = rnet.Client(cookie_store=True)
        cookies = client.get_cookies("https://example.com")
        print(cookies)
        ```
        """
        ...

    def set_cookie(self, url: str, cookie: Cookie) -> None:
        r"""
        Sets the cookies for the given URL.

        # Arguments
        * `url` - The URL to set the cookies for.
        * `cookie` - The cookie to set.

        # Examples

        ```python
        import rnet

        client = rnet.Client(cookie_store=True)
        client.set_cookie("https://example.com", rnet.Cookie(name="foo", value="bar"))
        ```
        """
        ...

    def remove_cookie(self, url: str, name: str) -> None:
        r"""
        Removes the cookie with the given name for the given URL.

        # Arguments
        * `url` - The URL to remove the cookie from.
        * `name` - The name of the cookie to remove.

        # Examples

        ```python
        import rnet

        client = rnet.Client(cookie_store=True)
        client.remove_cookie("https://example.com", "foo")
        """
        ...

    def clear_cookies(self) -> None:
        r"""
        Clears the cookies for the given URL.
        """
        ...

    def update(self, **kwds) -> None:
        r"""
        Updates the client with the given parameters.

        # Arguments
        * `**kwds` - The parameters to update the client with.

            impersonate: typing.Optional[typing.Union[Impersonate, ImpersonateOption]]
            headers: typing.Optional[typing.Dict[str, bytes]]
            headers_order: typing.Optional[typing.List[str]]
            proxies: typing.Optional[builtins.list[Proxy]]
            local_address: typing.Optional[typing.Optional[typing.Union[str, ipaddress.IPv4Address, ipaddress.IPv6Address]]]
            interface: typing.Optional[builtins.str]

        # Examples

        ```python
        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")],
        )
        ```
        """
        ...

    def request(self, method: Method, url: str, **kwds) -> typing.Any:
        r"""
        Sends a request with the given method and URL.

        # Arguments

        * `method` - The method to use for the request.
        * `url` - The URL to send the request to.
        * `**kwds` - Additional request parameters.

            proxy: typing.Optional[builtins.str]
            local_address: typing.Optional[typing.Optional[typing.Union[str, ipaddress.IPv4Address, ipaddress.IPv6Address]]]
            interface: typing.Optional[builtins.str]
            timeout: typing.Optional[builtins.int]
            read_timeout: typing.Optional[builtins.int]
            version: typing.Optional[Version]
            headers: typing.Optional[typing.Dict[str, bytes]]
            cookies: typing.Optional[typing.Dict[str, str]]
            allow_redirects: typing.Optional[builtins.bool]
            max_redirects: typing.Optional[builtins.int]
            auth: typing.Optional[str]
            bearer_auth: typing.Optional[str]
            basic_auth: typing.Optional[tuple[str, typing.Optional[str]]]
            query: typing.Optional[typing.List[typing.Tuple[str, str]]]
            form: typing.Optional[typing.List[typing.Tuple[str, str]]]
            json: typing.Optional[typing.Any]
            body: typing.Optional[typing.Any]
            multipart: typing.Optional[Multipart]

        # Returns

        A `Response` object.

        # Examples

        ```python
        import rnet
        import asyncio
        from rnet import Method

        async def main():
            client = rnet.Client()
            response = await client.request(Method.GET, "https://httpbin.org/anything")
            print(await response.text())

        asyncio.run(main())
        ```
        """
        ...

    def websocket(self, url: str, **kwds) -> typing.Any:
        r"""
        Sends a WebSocket request.

        # Arguments

        * `url` - The URL to send the WebSocket request to.
        * `**kwds` - Additional WebSocket request parameters.

            proxy: typing.Optional[builtins.str]
            local_address: typing.Optional[typing.Optional[typing.Union[str, ipaddress.IPv4Address, ipaddress.IPv6Address]]]
            interface: typing.Optional[builtins.str]
            headers: typing.Optional[typing.Dict[str, bytes]]
            cookies: typing.Optional[typing.Dict[str, str]]
            protocols: typing.Optional[builtins.list[builtins.str]]
            use_http2: typing.Optional[builtins.bool]
            auth: typing.Optional[builtins.str]
            bearer_auth: typing.Optional[builtins.str]
            basic_auth: typing.Optional[tuple[builtins.str, typing.Optional[builtins.str]]]
            query: typing.Optional[builtins.list[tuple[builtins.str, builtins.str]]]
            read_buffer_size: typing.Optional[builtins.int]
            write_buffer_size: typing.Optional[builtins.int]
            max_write_buffer_size: typing.Optional[builtins.int]
            max_message_size: typing.Optional[builtins.int]
            max_frame_size: typing.Optional[builtins.int]
            accept_unmasked_frames: typing.Optional[builtins.bool]

        # Returns

        A `WebSocket` object representing the WebSocket connection.

        # Examples

        ```python
        import rnet
        import asyncio

        async def main():
            client = rnet.Client()
            ws = await client.websocket("wss://echo.websocket.org")
            await ws.send(rnet.Message.from_text("Hello, WebSocket!"))
            message = await ws.recv()
            print("Received:", message.data)
            await ws.close()

        asyncio.run(main())
        ```
        """
        ...

    def trace(self, url: str, **kwds) -> typing.Any:
        r"""
        Sends a request with the given URL

        # Arguments

        * `url` - The URL to send the request to.
        * `**kwds` - Additional request parameters.

            proxy: typing.Optional[builtins.str]
            local_address: typing.Optional[typing.Optional[typing.Union[str, ipaddress.IPv4Address, ipaddress.IPv6Address]]]
            interface: typing.Optional[builtins.str]
            timeout: typing.Optional[builtins.int]
            read_timeout: typing.Optional[builtins.int]
            version: typing.Optional[Version]
            headers: typing.Optional[typing.Dict[str, bytes]]
            cookies: typing.Optional[typing.Dict[str, str]]
            allow_redirects: typing.Optional[builtins.bool]
            max_redirects: typing.Optional[builtins.int]
            auth: typing.Optional[str]
            bearer_auth: typing.Optional[str]
            basic_auth: typing.Optional[tuple[str, typing.Optional[str]]]
            query: typing.Optional[typing.List[typing.Tuple[str, str]]]
            form: typing.Optional[typing.List[typing.Tuple[str, str]]]
            json: typing.Optional[typing.Any]
            body: typing.Optional[typing.Any]
            multipart: typing.Optional[Multipart]

        # Returns

        A `Response` object.

        # Examples

        ```python
        import rnet
        import asyncio
        from rnet import Method

        async def main():
            client = rnet.Client()
            response = await client.trace("https://httpbin.org/anything")
            print(await response.text())

        asyncio.run(main())
        ```
        """
        ...

    def options(self, url: str, **kwds) -> typing.Any:
        r"""
        Sends a request with the given URL

        # Arguments

        * `url` - The URL to send the request to.
        * `**kwds` - Additional request parameters.

            proxy: typing.Optional[builtins.str]
            local_address: typing.Optional[typing.Optional[typing.Union[str, ipaddress.IPv4Address, ipaddress.IPv6Address]]]
            interface: typing.Optional[builtins.str]
            timeout: typing.Optional[builtins.int]
            read_timeout: typing.Optional[builtins.int]
            version: typing.Optional[Version]
            headers: typing.Optional[typing.Dict[str, bytes]]
            cookies: typing.Optional[typing.Dict[str, str]]
            allow_redirects: typing.Optional[builtins.bool]
            max_redirects: typing.Optional[builtins.int]
            auth: typing.Optional[str]
            bearer_auth: typing.Optional[str]
            basic_auth: typing.Optional[tuple[str, typing.Optional[str]]]
            query: typing.Optional[typing.List[typing.Tuple[str, str]]]
            form: typing.Optional[typing.List[typing.Tuple[str, str]]]
            json: typing.Optional[typing.Any]
            body: typing.Optional[typing.Any]
            multipart: typing.Optional[Multipart]

        # Returns

        A `Response` object.

        # Examples

        ```python
        import rnet
        import asyncio
        from rnet import Method

        async def main():
            client = rnet.Client()
            response = await client.options("https://httpbin.org/anything")
            print(await response.text())

        asyncio.run(main())
        ```
        """
        ...

    def patch(self, url: str, **kwds) -> typing.Any:
        r"""
        Sends a request with the given URL

        # Arguments

        * `url` - The URL to send the request to.
        * `**kwds` - Additional request parameters.

            proxy: typing.Optional[builtins.str]
            local_address: typing.Optional[typing.Optional[typing.Union[str, ipaddress.IPv4Address, ipaddress.IPv6Address]]]
            interface: typing.Optional[builtins.str]
            timeout: typing.Optional[builtins.int]
            read_timeout: typing.Optional[builtins.int]
            version: typing.Optional[Version]
            headers: typing.Optional[typing.Dict[str, bytes]]
            cookies: typing.Optional[typing.Dict[str, str]]
            allow_redirects: typing.Optional[builtins.bool]
            max_redirects: typing.Optional[builtins.int]
            auth: typing.Optional[str]
            bearer_auth: typing.Optional[str]
            basic_auth: typing.Optional[tuple[str, typing.Optional[str]]]
            query: typing.Optional[typing.List[typing.Tuple[str, str]]]
            form: typing.Optional[typing.List[typing.Tuple[str, str]]]
            json: typing.Optional[typing.Any]
            body: typing.Optional[typing.Any]
            multipart: typing.Optional[Multipart]

        # Returns

        A `Response` object.

        # Examples

        ```python
        import rnet
        import asyncio
        from rnet import Method

        async def main():
            client = rnet.Client()
            response = await client.patch("https://httpbin.org/anything", json={"key": "value"})
            print(await response.text())

        asyncio.run(main())
        ```
        """
        ...

    def delete(self, url: str, **kwds) -> typing.Any:
        r"""
        Sends a request with the given URL

        # Arguments

        * `url` - The URL to send the request to.
        * `**kwds` - Additional request parameters.

            proxy: typing.Optional[builtins.str]
            local_address: typing.Optional[typing.Optional[typing.Union[str, ipaddress.IPv4Address, ipaddress.IPv6Address]]]
            interface: typing.Optional[builtins.str]
            timeout: typing.Optional[builtins.int]
            read_timeout: typing.Optional[builtins.int]
            version: typing.Optional[Version]
            headers: typing.Optional[typing.Dict[str, bytes]]
            cookies: typing.Optional[typing.Dict[str, str]]
            allow_redirects: typing.Optional[builtins.bool]
            max_redirects: typing.Optional[builtins.int]
            auth: typing.Optional[str]
            bearer_auth: typing.Optional[str]
            basic_auth: typing.Optional[tuple[str, typing.Optional[str]]]
            query: typing.Optional[typing.List[typing.Tuple[str, str]]]
            form: typing.Optional[typing.List[typing.Tuple[str, str]]]
            json: typing.Optional[typing.Any]
            body: typing.Optional[typing.Any]
            multipart: typing.Optional[Multipart]

        # Returns

        A `Response` object.

        # Examples

        ```python
        import rnet
        import asyncio
        from rnet import Method

        async def main():
            client = rnet.Client()
            response = await client.delete("https://httpbin.org/anything")
            print(await response.text())

        asyncio.run(main())
        ```
        """
        ...

    def put(self, url: str, **kwds) -> typing.Any:
        r"""
        Sends a request with the given URL

        # Arguments

        * `url` - The URL to send the request to.
        * `**kwds` - Additional request parameters.

            proxy: typing.Optional[builtins.str]
            local_address: typing.Optional[typing.Optional[typing.Union[str, ipaddress.IPv4Address, ipaddress.IPv6Address]]]
            interface: typing.Optional[builtins.str]
            timeout: typing.Optional[builtins.int]
            read_timeout: typing.Optional[builtins.int]
            version: typing.Optional[Version]
            headers: typing.Optional[typing.Dict[str, bytes]]
            cookies: typing.Optional[typing.Dict[str, str]]
            allow_redirects: typing.Optional[builtins.bool]
            max_redirects: typing.Optional[builtins.int]
            auth: typing.Optional[str]
            bearer_auth: typing.Optional[str]
            basic_auth: typing.Optional[tuple[str, typing.Optional[str]]]
            query: typing.Optional[typing.List[typing.Tuple[str, str]]]
            form: typing.Optional[typing.List[typing.Tuple[str, str]]]
            json: typing.Optional[typing.Any]
            body: typing.Optional[typing.Any]
            multipart: typing.Optional[Multipart]

        # Returns

        A `Response` object.

        # Examples

        ```python
        import rnet
        import asyncio
        from rnet import Method

        async def main():
            client = rnet.Client()
            response = await client.put("https://httpbin.org/anything", json={"key": "value"})
            print(await response.text())

        asyncio.run(main())
        ```
        """
        ...

    def post(self, url: str, **kwds) -> typing.Any:
        r"""
        Sends a request with the given URL

        # Arguments

        * `url` - The URL to send the request to.
        * `**kwds` - Additional request parameters.

            proxy: typing.Optional[builtins.str]
            local_address: typing.Optional[typing.Optional[typing.Union[str, ipaddress.IPv4Address, ipaddress.IPv6Address]]]
            interface: typing.Optional[builtins.str]
            timeout: typing.Optional[builtins.int]
            read_timeout: typing.Optional[builtins.int]
            version: typing.Optional[Version]
            headers: typing.Optional[typing.Dict[str, bytes]]
            cookies: typing.Optional[typing.Dict[str, str]]
            allow_redirects: typing.Optional[builtins.bool]
            max_redirects: typing.Optional[builtins.int]
            auth: typing.Optional[str]
            bearer_auth: typing.Optional[str]
            basic_auth: typing.Optional[tuple[str, typing.Optional[str]]]
            query: typing.Optional[typing.List[typing.Tuple[str, str]]]
            form: typing.Optional[typing.List[typing.Tuple[str, str]]]
            json: typing.Optional[typing.Any]
            body: typing.Optional[typing.Any]
            multipart: typing.Optional[Multipart]

        # Returns

        A `Response` object.

        # Examples

        ```python
        import rnet
        import asyncio
        from rnet import Method

        async def main():
            client = rnet.Client()
            response = await client.post("https://httpbin.org/anything", json={"key": "value"})
            print(await response.text())

        asyncio.run(main())
        ```
        """
        ...

    def head(self, url: str, **kwds) -> typing.Any:
        r"""
        Sends a request with the given URL

        # Arguments

        * `url` - The URL to send the request to.
        * `**kwds` - Additional request parameters.

            proxy: typing.Optional[builtins.str]
            local_address: typing.Optional[typing.Optional[typing.Union[str, ipaddress.IPv4Address, ipaddress.IPv6Address]]]
            interface: typing.Optional[builtins.str]
            timeout: typing.Optional[builtins.int]
            read_timeout: typing.Optional[builtins.int]
            version: typing.Optional[Version]
            headers: typing.Optional[typing.Dict[str, bytes]]
            cookies: typing.Optional[typing.Dict[str, str]]
            allow_redirects: typing.Optional[builtins.bool]
            max_redirects: typing.Optional[builtins.int]
            auth: typing.Optional[str]
            bearer_auth: typing.Optional[str]
            basic_auth: typing.Optional[tuple[str, typing.Optional[str]]]
            query: typing.Optional[typing.List[typing.Tuple[str, str]]]
            form: typing.Optional[typing.List[typing.Tuple[str, str]]]
            json: typing.Optional[typing.Any]
            body: typing.Optional[typing.Any]
            multipart: typing.Optional[Multipart]

        # Returns

        A `Response` object.

        # Examples

        ```python
        import rnet
        import asyncio
        from rnet import Method

        async def main():
            client = rnet.Client()
            response = await client.head("https://httpbin.org/anything")
            print(response.status)

        asyncio.run(main())
        ```
        """
        ...

    def get(self, url: str, **kwds) -> typing.Any:
        r"""
        Sends a request with the given URL

        # Arguments

        * `url` - The URL to send the request to.
        * `**kwds` - Additional request parameters.

            proxy: typing.Optional[builtins.str]
            local_address: typing.Optional[typing.Optional[typing.Union[str, ipaddress.IPv4Address, ipaddress.IPv6Address]]]
            interface: typing.Optional[builtins.str]
            timeout: typing.Optional[builtins.int]
            read_timeout: typing.Optional[builtins.int]
            version: typing.Optional[Version]
            headers: typing.Optional[typing.Dict[str, bytes]]
            cookies: typing.Optional[typing.Dict[str, str]]
            allow_redirects: typing.Optional[builtins.bool]
            max_redirects: typing.Optional[builtins.int]
            auth: typing.Optional[str]
            bearer_auth: typing.Optional[str]
            basic_auth: typing.Optional[tuple[str, typing.Optional[str]]]
            query: typing.Optional[typing.List[typing.Tuple[str, str]]]
            form: typing.Optional[typing.List[typing.Tuple[str, str]]]
            json: typing.Optional[typing.Any]
            body: typing.Optional[typing.Any]
            multipart: typing.Optional[Multipart]

        # Returns

        A `Response` object.

        # Examples

        ```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 Cookie:
    r"""
    A cookie.
    """

    name: builtins.str
    value: builtins.str
    http_only: builtins.bool
    secure: builtins.bool
    same_site_lax: builtins.bool
    same_site_strict: builtins.bool
    path: typing.Optional[builtins.str]
    domain: typing.Optional[builtins.str]
    max_age: typing.Optional[datetime.timedelta]
    expires: typing.Optional[datetime.datetime]
    def __new__(
        cls,
        name: builtins.str,
        value: builtins.str,
        domain: typing.Optional[builtins.str] = None,
        path: typing.Optional[builtins.str] = None,
        max_age: typing.Optional[datetime.timedelta] = None,
        expires: typing.Optional[datetime.datetime] = None,
        http_only: builtins.bool = False,
        secure: builtins.bool = False,
        same_site: typing.Optional[SameSite] = None,
    ): ...
    def __str__(self) -> builtins.str: ...
    def __repr__(self) -> builtins.str: ...

class HeaderMap:
    r"""
    A HTTP header map.
    """

    def __new__(cls, init: typing.Optional[dict]): ...
    def __getitem__(self, key: str) -> typing.Optional[typing.Any]: ...
    def __setitem__(self, key: str, value: str) -> None: ...
    def __delitem__(self, key: str) -> None: ...
    def __contains__(self, key: str) -> builtins.bool: ...
    def __len__(self) -> builtins.int: ...
    def __iter__(self) -> HeaderMapKeysIter: ...
    def items(self) -> HeaderMapItemsIter: ...
    def __str__(self) -> builtins.str: ...
    def __repr__(self) -> builtins.str: ...

class HeaderMapItemsIter:
    r"""
    An iterator over the items in a HeaderMap.
    """

    def __iter__(self) -> HeaderMapItemsIter: ...
    def __next__(
        self,
    ) -> typing.Optional[tuple[typing.Any, typing.Optional[typing.Any]]]: ...

class HeaderMapKeysIter:
    r"""
    An iterator over the keys in a HeaderMap.
    """

    def __iter__(self) -> HeaderMapKeysIter: ...
    def __next__(self) -> typing.Optional[typing.Any]: ...

class ImpersonateOption:
    r"""
    A struct to represent the `ImpersonateOption` class.
    """

    def __new__(
        cls,
        impersonate: Impersonate,
        impersonate_os: typing.Optional[ImpersonateOS] = None,
        skip_http2: typing.Optional[builtins.bool] = None,
        skip_headers: typing.Optional[builtins.bool] = None,
    ): ...
    ...

class Message:
    r"""
    A WebSocket message.
    """

    data: typing.Optional[typing.Any]
    text: typing.Optional[builtins.str]
    binary: typing.Optional[typing.Any]
    ping: typing.Optional[typing.Any]
    pong: typing.Optional[typing.Any]
    close: typing.Optional[tuple[builtins.int, typing.Optional[builtins.str]]]
    def __str__(self) -> builtins.str: ...
    def __repr__(self) -> builtins.str: ...
    @staticmethod
    def text_from_json(json: typing.Dict[str, typing.Any]) -> Message:
        r"""
        Creates a new text message from the JSON representation.

        # Arguments
        * `json` - The JSON representation of the message.

        # Returns

        A new `Message` instance containing the message.
        """
        ...

    @staticmethod
    def binary_from_json(json: typing.Dict[str, typing.Any]) -> Message:
        r"""
        Creates a new binary message from the JSON representation.

        # Arguments
        * `json` - The JSON representation of the message.

        # Returns

        A new `Message` instance containing the message.
        """
        ...

    @staticmethod
    def from_text(text: str) -> Message:
        r"""
        Creates a new text message.

        # Arguments

        * `text` - The text content of the message.

        # Returns

        A new `Message` instance containing the text message.
        """
        ...

    @staticmethod
    def from_binary(data: bytes) -> Message:
        r"""
        Creates a new binary message.

        # Arguments

        * `data` - The binary data of the message.

        # Returns

        A new `Message` instance containing the binary message.
        """
        ...

    @staticmethod
    def from_ping(data: bytes) -> Message:
        r"""
        Creates a new ping message.

        # Arguments

        * `data` - The ping data of the message.

        # Returns

        A new `Message` instance containing the ping message.
        """
        ...

    @staticmethod
    def from_pong(data: bytes) -> Message:
        r"""
        Creates a new pong message.

        # Arguments

        * `data` - The pong data of the message.

        # Returns

        A new `Message` instance containing the pong message.
        """
        ...

    @staticmethod
    def from_close(code: builtins.int, reason: typing.Optional[str] = None) -> Message:
        r"""
        Creates a new close message.

        # Arguments

        * `code` - The close code.
        * `reason` - An optional reason for closing.

        # Returns

        A new `Message` instance containing the close message.
        """
        ...

    def json(self) -> typing.Dict[str, typing.Any]:
        r"""
        Returns the JSON representation of the message.

        # Returns

        A `PyResult` containing the JSON representation of the message.
        """
        ...

class Multipart:
    r"""
    A multipart form for a request.
    """

    def __new__(cls, *parts): ...
    ...

class Part:
    r"""
    A part of a multipart form.
    """

    def __new__(
        cls,
        name: builtins.str,
        value: typing.Any,
        filename: typing.Optional[builtins.str] = None,
        mime: typing.Optional[builtins.str] = None,
    ): ...
    ...

class Proxy:
    r"""
    A proxy server for a request.
    Supports HTTP, HTTPS, SOCKS4, SOCKS4a, SOCKS5, and SOCKS5h protocols.
    """

    @staticmethod
    def http(
        url: builtins.str,
        username: typing.Optional[builtins.str] = None,
        password: typing.Optional[builtins.str] = None,
        custom_http_auth: typing.Optional[builtins.str] = None,
        custom_http_headers: typing.Optional[
            typing.Union[typing.Dict[str, str], HeaderMap]
        ] = None,
        exclusion: typing.Optional[builtins.str] = None,
    ) -> 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.

        # Returns

        A new `Proxy` instance.

        # Examples

        ```python
        import rnet

        proxy = rnet.Proxy.http("http://proxy.example.com")
        ```
        """
        ...

    @staticmethod
    def https(
        url: builtins.str,
        username: typing.Optional[builtins.str] = None,
        password: typing.Optional[builtins.str] = None,
        custom_http_auth: typing.Optional[builtins.str] = None,
        custom_http_headers: typing.Optional[
            typing.Union[typing.Dict[str, str], HeaderMap]
        ] = None,
        exclusion: typing.Optional[builtins.str] = None,
    ) -> 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.

        # Returns

        A new `Proxy` instance.

        # Examples

        ```python
        import rnet

        proxy = rnet.Proxy.https("https://proxy.example.com")
        ```
        """
        ...

    @staticmethod
    def all(
        url: builtins.str,
        username: typing.Optional[builtins.str] = None,
        password: typing.Optional[builtins.str] = None,
        custom_http_auth: typing.Optional[builtins.str] = None,
        custom_http_headers: typing.Optional[
            typing.Union[typing.Dict[str, str], HeaderMap]
        ] = None,
        exclusion: typing.Optional[builtins.str] = None,
    ) -> 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.

        # Returns

        A new `Proxy` instance.

        # Examples

        ```python
        import rnet

        proxy = rnet.Proxy.all("https://proxy.example.com")
        ```
        """
        ...

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: builtins.str
    ok: builtins.bool
    status: builtins.int
    status_code: StatusCode
    version: Version
    headers: HeaderMap
    cookies: builtins.list[Cookie]
    content_length: builtins.int
    remote_addr: typing.Optional[SocketAddr]
    encoding: builtins.str
    def __aenter__(self) -> typing.Any: ...
    def __aexit__(
        self, _exc_type: typing.Any, _exc_value: typing.Any, _traceback: typing.Any
    ) -> typing.Any: ...
    def peer_certificate(self) -> typing.Optional[typing.Any]:
        r"""
        Returns the TLS peer certificate of the response.

        # Returns

        A Python object representing the TLS peer certificate of the response.
        """
        ...

    def text(self) -> typing.Any:
        r"""
        Returns the text content of the response.

        # Returns

        A Python object representing the text content of the response.
        """
        ...

    def text_with_charset(self, encoding: builtins.str) -> typing.Any:
        r"""
        Returns the text content of the response with a specific charset.
        c
        # Arguments

        * `default_encoding` - The default encoding to use if the charset is not specified.

        # Returns

        A Python object representing the text content of the response.
        """
        ...

    def json(self) -> typing.Any:
        r"""
        Returns the JSON content of the response.

        # Returns

        A Python object representing the JSON content of the response.
        """
        ...

    def bytes(self) -> typing.Any:
        r"""
        Returns the bytes content of the response.

        # Returns

        A Python object representing the bytes content of the response.
        """
        ...

    def stream(self) -> Streamer:
        r"""
        Convert the response into a `Stream` of `Bytes` from the body.

        # Returns

        A Python object representing the stream content of the response.
        """
        ...

    def close(self) -> None:
        r"""
        Closes the response connection.
        """
        ...

class SocketAddr:
    r"""
    A IP socket address.
    """

    def __str__(self) -> builtins.str: ...
    def ip(self) -> typing.Any:
        r"""
        Returns the IP address of the socket address.
        """
        ...

    def port(self) -> builtins.int:
        r"""
        Returns the port number of the socket address.
        """
        ...

class StatusCode:
    r"""
    HTTP status code.
    """

    def __str__(self) -> builtins.str: ...
    def __repr__(self) -> builtins.str: ...
    def as_int(self) -> builtins.int:
        r"""
        Return the status code as an integer.
        """
        ...

    def is_informational(self) -> builtins.bool:
        r"""
        Check if status is within 100-199.
        """
        ...

    def is_success(self) -> builtins.bool:
        r"""
        Check if status is within 200-299.
        """
        ...

    def is_redirection(self) -> builtins.bool:
        r"""
        Check if status is within 300-399.
        """
        ...

    def is_client_error(self) -> builtins.bool:
        r"""
        Check if status is within 400-499.
        """
        ...

    def is_server_error(self) -> builtins.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)

        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())
    ```
    """

    def __aiter__(self) -> Streamer: ...
    def __anext__(self) -> typing.Any: ...
    def __aenter__(self) -> typing.Any: ...
    def __aexit__(
        self, _exc_type: typing.Any, _exc_value: typing.Any, _traceback: typing.Any
    ) -> typing.Any: ...

class WebSocket:
    r"""
    A WebSocket response.
    """

    ok: builtins.bool
    status: builtins.int
    status_code: StatusCode
    version: Version
    headers: HeaderMap
    cookies: builtins.list[Cookie]
    remote_addr: typing.Optional[SocketAddr]
    def __aiter__(self) -> WebSocket: ...
    def __anext__(self) -> typing.Any: ...
    def __aenter__(self) -> typing.Any: ...
    def __aexit__(
        self, _exc_type: typing.Any, _exc_value: typing.Any, _traceback: typing.Any
    ) -> typing.Any: ...
    def protocol(self) -> typing.Optional[builtins.str]:
        r"""
        Returns the WebSocket protocol.

        # Returns

        An optional string representing the WebSocket protocol.
        """
        ...

    def recv(self) -> typing.Any:
        r"""
        Receives a message from the WebSocket.

        # Arguments

        * `py` - The Python runtime.

        # Returns

        A `PyResult` containing a `Bound` object with the received message, or `None` if no message is received.
        """
        ...

    def send(self, message: Message) -> typing.Any:
        r"""
        Sends a message to the WebSocket.

        # Arguments

        * `py` - The Python runtime.
        * `message` - The message to send.

        # Returns

        A `PyResult` containing a `Bound` object.
        """
        ...

    def close(
        self,
        code: typing.Optional[builtins.int] = None,
        reason: typing.Optional[str] = None,
    ) -> typing.Any:
        r"""
        Closes the WebSocket connection.

        # Arguments

        * `py` - The Python runtime.
        * `code` - An optional close code.
        * `reason` - An optional reason for closing.

        # Returns

        A `PyResult` containing a `Bound` object.
        """
        ...

class Impersonate(Enum):
    r"""
    An impersonate.
    """

    Chrome100 = auto()
    Chrome101 = auto()
    Chrome104 = auto()
    Chrome105 = auto()
    Chrome106 = auto()
    Chrome107 = auto()
    Chrome108 = auto()
    Chrome109 = auto()
    Chrome114 = auto()
    Chrome116 = auto()
    Chrome117 = auto()
    Chrome118 = auto()
    Chrome119 = auto()
    Chrome120 = auto()
    Chrome123 = auto()
    Chrome124 = auto()
    Chrome126 = auto()
    Chrome127 = auto()
    Chrome128 = auto()
    Chrome129 = auto()
    Chrome130 = auto()
    Chrome131 = auto()
    Chrome132 = auto()
    Chrome133 = auto()
    Chrome134 = auto()
    Edge101 = auto()
    Edge122 = auto()
    Edge127 = auto()
    Edge131 = auto()
    Firefox109 = auto()
    Firefox117 = auto()
    Firefox128 = auto()
    Firefox133 = auto()
    Firefox135 = auto()
    FirefoxPrivate135 = auto()
    FirefoxAndroid135 = auto()
    Firefox136 = auto()
    FirefoxPrivate136 = auto()
    SafariIos17_2 = auto()
    SafariIos17_4_1 = auto()
    SafariIos16_5 = auto()
    Safari15_3 = auto()
    Safari15_5 = auto()
    Safari15_6_1 = auto()
    Safari16 = auto()
    Safari16_5 = auto()
    Safari17_0 = auto()
    Safari17_2_1 = auto()
    Safari17_4_1 = auto()
    Safari17_5 = auto()
    Safari18 = auto()
    SafariIPad18 = auto()
    Safari18_2 = auto()
    Safari18_3 = auto()
    Safari18_3_1 = auto()
    SafariIos18_1_1 = auto()
    OkHttp3_9 = auto()
    OkHttp3_11 = auto()
    OkHttp3_13 = auto()
    OkHttp3_14 = auto()
    OkHttp4_9 = auto()
    OkHttp4_10 = auto()
    OkHttp4_12 = auto()
    OkHttp5 = auto()

class ImpersonateOS(Enum):
    r"""
    An impersonate operating system.
    """

    Windows = auto()
    MacOS = auto()
    Linux = auto()
    Android = auto()
    IOS = auto()

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 SameSite(Enum):
    r"""
    The Cookie SameSite attribute.
    """

    Strict = auto()
    Lax = auto()
    Empty = 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()

def delete(url: str, **kwds) -> typing.Any:
    r"""
    Shortcut method to quickly make a request.

    # Arguments

    * `url` - The URL to send the request to.
    * `**kwds` - Additional request parameters.

        proxy: typing.Optional[builtins.str]
        local_address: typing.Optional[typing.Optional[typing.Union[str, ipaddress.IPv4Address, ipaddress.IPv6Address]]]
        interface: typing.Optional[builtins.str]
        timeout: typing.Optional[builtins.int]
        read_timeout: typing.Optional[builtins.int]
        version: typing.Optional[Version]
        headers: typing.Optional[typing.Dict[str, bytes]]
        cookies: typing.Optional[typing.Dict[str, str]]
        allow_redirects: typing.Optional[builtins.bool]
        max_redirects: typing.Optional[builtins.int]
        auth: typing.Optional[str]
        bearer_auth: typing.Optional[str]
        basic_auth: typing.Optional[tuple[str, typing.Optional[str]]]
        query: typing.Optional[typing.List[typing.Tuple[str, str]]]
        form: typing.Optional[typing.List[typing.Tuple[str, str]]]
        json: typing.Optional[typing.Any]
        body: typing.Optional[typing.Any]
        multipart: typing.Optional[Multipart]

    # Examples

    ```python
    import rnet
    import asyncio

    async def run():
        response = await rnet.delete("https://httpbin.org/anything")
        body = await response.text()
        print(body)

    asyncio.run(run())
    ```
    """
    ...

def get(url: str, **kwds) -> typing.Any:
    r"""
    Shortcut method to quickly make a request.

    # Arguments

    * `url` - The URL to send the request to.
    * `**kwds` - Additional request parameters.

        proxy: typing.Optional[builtins.str]
        local_address: typing.Optional[typing.Optional[typing.Union[str, ipaddress.IPv4Address, ipaddress.IPv6Address]]]
        interface: typing.Optional[builtins.str]
        timeout: typing.Optional[builtins.int]
        read_timeout: typing.Optional[builtins.int]
        version: typing.Optional[Version]
        headers: typing.Optional[typing.Dict[str, bytes]]
        cookies: typing.Optional[typing.Dict[str, str]]
        allow_redirects: typing.Optional[builtins.bool]
        max_redirects: typing.Optional[builtins.int]
        auth: typing.Optional[str]
        bearer_auth: typing.Optional[str]
        basic_auth: typing.Optional[tuple[str, typing.Optional[str]]]
        query: typing.Optional[typing.List[typing.Tuple[str, str]]]
        form: typing.Optional[typing.List[typing.Tuple[str, str]]]
        json: typing.Optional[typing.Any]
        body: typing.Optional[typing.Any]
        multipart: typing.Optional[Multipart]

    # Examples

    ```python
    import rnet
    import asyncio

    async def run():
        response = await rnet.get("https://httpbin.org/anything")
        body = await response.text()
        print(body)

    asyncio.run(run())
    ```
    """
    ...

def head(url: str, **kwds) -> typing.Any:
    r"""
    Shortcut method to quickly make a request.

    # Arguments

    * `url` - The URL to send the request to.
    * `**kwds` - Additional request parameters.

        proxy: typing.Optional[builtins.str]
        local_address: typing.Optional[typing.Optional[typing.Union[str, ipaddress.IPv4Address, ipaddress.IPv6Address]]]
        interface: typing.Optional[builtins.str]
        timeout: typing.Optional[builtins.int]
        read_timeout: typing.Optional[builtins.int]
        version: typing.Optional[Version]
        headers: typing.Optional[typing.Dict[str, bytes]]
        cookies: typing.Optional[typing.Dict[str, str]]
        allow_redirects: typing.Optional[builtins.bool]
        max_redirects: typing.Optional[builtins.int]
        auth: typing.Optional[str]
        bearer_auth: typing.Optional[str]
        basic_auth: typing.Optional[tuple[str, typing.Optional[str]]]
        query: typing.Optional[typing.List[typing.Tuple[str, str]]]
        form: typing.Optional[typing.List[typing.Tuple[str, str]]]
        json: typing.Optional[typing.Any]
        body: typing.Optional[typing.Any]
        multipart: typing.Optional[Multipart]

    # Examples

    ```python
    import rnet
    import asyncio

    async def run():
        response = await rnet.head("https://httpbin.org/anything")
        print(response.status)

    asyncio.run(run())
    ```
    """
    ...

def options(url: str, **kwds) -> typing.Any:
    r"""
    Shortcut method to quickly make a request.

    # Arguments

    * `url` - The URL to send the request to.
    * `**kwds` - Additional request parameters.

        proxy: typing.Optional[builtins.str]
        local_address: typing.Optional[typing.Optional[typing.Union[str, ipaddress.IPv4Address, ipaddress.IPv6Address]]]
        interface: typing.Optional[builtins.str]
        timeout: typing.Optional[builtins.int]
        read_timeout: typing.Optional[builtins.int]
        version: typing.Optional[Version]
        headers: typing.Optional[typing.Dict[str, bytes]]
        cookies: typing.Optional[typing.Dict[str, str]]
        allow_redirects: typing.Optional[builtins.bool]
        max_redirects: typing.Optional[builtins.int]
        auth: typing.Optional[str]
        bearer_auth: typing.Optional[str]
        basic_auth: typing.Optional[tuple[str, typing.Optional[str]]]
        query: typing.Optional[typing.List[typing.Tuple[str, str]]]
        form: typing.Optional[typing.List[typing.Tuple[str, str]]]
        json: typing.Optional[typing.Any]
        body: typing.Optional[typing.Any]
        multipart: typing.Optional[Multipart]

    # Examples

    ```python
    import rnet
    import asyncio

    async def run():
        response = await rnet.options("https://httpbin.org/anything")
        print(response.status)

    asyncio.run(run())
    ```
    """
    ...

def patch(url: str, **kwds) -> typing.Any:
    r"""
    Shortcut method to quickly make a request.

    # Arguments

    * `url` - The URL to send the request to.
    * `**kwds` - Additional request parameters.

        proxy: typing.Optional[builtins.str]
        local_address: typing.Optional[typing.Optional[typing.Union[str, ipaddress.IPv4Address, ipaddress.IPv6Address]]]
        interface: typing.Optional[builtins.str]
        timeout: typing.Optional[builtins.int]
        read_timeout: typing.Optional[builtins.int]
        version: typing.Optional[Version]
        headers: typing.Optional[typing.Dict[str, bytes]]
        cookies: typing.Optional[typing.Dict[str, str]]
        allow_redirects: typing.Optional[builtins.bool]
        max_redirects: typing.Optional[builtins.int]
        auth: typing.Optional[str]
        bearer_auth: typing.Optional[str]
        basic_auth: typing.Optional[tuple[str, typing.Optional[str]]]
        query: typing.Optional[typing.List[typing.Tuple[str, str]]]
        form: typing.Optional[typing.List[typing.Tuple[str, str]]]
        json: typing.Optional[typing.Any]
        body: typing.Optional[typing.Any]
        multipart: typing.Optional[Multipart]

    # Examples

    ```python
    import rnet
    import asyncio

    async def run():
        response = await rnet.patch("https://httpbin.org/anything")
        body = await response.text()
        print(body)

    asyncio.run(run())
    ```
    """
    ...

def post(url: str, **kwds) -> typing.Any:
    r"""
    Shortcut method to quickly make a request.

    # Arguments

    * `url` - The URL to send the request to.
    * `**kwds` - Additional request parameters.

        proxy: typing.Optional[builtins.str]
        local_address: typing.Optional[typing.Optional[typing.Union[str, ipaddress.IPv4Address, ipaddress.IPv6Address]]]
        interface: typing.Optional[builtins.str]
        timeout: typing.Optional[builtins.int]
        read_timeout: typing.Optional[builtins.int]
        version: typing.Optional[Version]
        headers: typing.Optional[typing.Dict[str, bytes]]
        cookies: typing.Optional[typing.Dict[str, str]]
        allow_redirects: typing.Optional[builtins.bool]
        max_redirects: typing.Optional[builtins.int]
        auth: typing.Optional[str]
        bearer_auth: typing.Optional[str]
        basic_auth: typing.Optional[tuple[str, typing.Optional[str]]]
        query: typing.Optional[typing.List[typing.Tuple[str, str]]]
        form: typing.Optional[typing.List[typing.Tuple[str, str]]]
        json: typing.Optional[typing.Any]
        body: typing.Optional[typing.Any]
        multipart: typing.Optional[Multipart]

    # Examples

    ```python
    import rnet
    import asyncio

    async def run():
        response = await rnet.post("https://httpbin.org/anything")
        body = await response.text()
        print(body)

    asyncio.run(run())
    ```
    """
    ...

def put(url: str, **kwds) -> typing.Any:
    r"""
    Shortcut method to quickly make a request.

    # Arguments

    * `url` - The URL to send the request to.
    * `**kwds` - Additional request parameters.

        proxy: typing.Optional[builtins.str]
        local_address: typing.Optional[typing.Optional[typing.Union[str, ipaddress.IPv4Address, ipaddress.IPv6Address]]]
        interface: typing.Optional[builtins.str]
        timeout: typing.Optional[builtins.int]
        read_timeout: typing.Optional[builtins.int]
        version: typing.Optional[Version]
        headers: typing.Optional[typing.Dict[str, bytes]]
        cookies: typing.Optional[typing.Dict[str, str]]
        allow_redirects: typing.Optional[builtins.bool]
        max_redirects: typing.Optional[builtins.int]
        auth: typing.Optional[str]
        bearer_auth: typing.Optional[str]
        basic_auth: typing.Optional[tuple[str, typing.Optional[str]]]
        query: typing.Optional[typing.List[typing.Tuple[str, str]]]
        form: typing.Optional[typing.List[typing.Tuple[str, str]]]
        json: typing.Optional[typing.Any]
        body: typing.Optional[typing.Any]
        multipart: typing.Optional[Multipart]

    # Examples

    ```python
    import rnet
    import asyncio

    async def run():
        response = await rnet.put("https://httpbin.org/anything")
        body = await response.text()
        print(body)

    asyncio.run(run())
    ```
    """
    ...

def request(method: Method, url: str, **kwds) -> typing.Any:
    r"""
    Make a request with the given parameters.

    # Arguments

    * `method` - The method to use for the request.
    * `url` - The URL to send the request to.
    * `**kwds` - Additional request parameters.

        proxy: typing.Optional[builtins.str]
        local_address: typing.Optional[typing.Optional[typing.Union[str, ipaddress.IPv4Address, ipaddress.IPv6Address]]]
        interface: typing.Optional[builtins.str]
        timeout: typing.Optional[builtins.int]
        read_timeout: typing.Optional[builtins.int]
        version: typing.Optional[Version]
        headers: typing.Optional[typing.Dict[str, bytes]]
        cookies: typing.Optional[typing.Dict[str, str]]
        allow_redirects: typing.Optional[builtins.bool]
        max_redirects: typing.Optional[builtins.int]
        auth: typing.Optional[str]
        bearer_auth: typing.Optional[str]
        basic_auth: typing.Optional[tuple[str, typing.Optional[str]]]
        query: typing.Optional[typing.List[typing.Tuple[str, str]]]
        form: typing.Optional[typing.List[typing.Tuple[str, str]]]
        json: typing.Optional[typing.Any]
        body: typing.Optional[typing.Any]
        multipart: typing.Optional[Multipart]

    # Examples

    ```python
    import rnet
    import asyncio
    from rnet import Method

    async def run():
        response = await rnet.request(Method.GET, "https://www.rust-lang.org")
        body = await response.text()
        print(body)

    asyncio.run(run())
    ```
    """
    ...

def trace(url: str, **kwds) -> typing.Any:
    r"""
    Shortcut method to quickly make a request.

    # Arguments

    * `url` - The URL to send the request to.
    * `**kwds` - Additional request parameters.

        proxy: typing.Optional[builtins.str]
        local_address: typing.Optional[typing.Optional[typing.Union[str, ipaddress.IPv4Address, ipaddress.IPv6Address]]]
        interface: typing.Optional[builtins.str]
        timeout: typing.Optional[builtins.int]
        read_timeout: typing.Optional[builtins.int]
        version: typing.Optional[Version]
        headers: typing.Optional[typing.Dict[str, bytes]]
        cookies: typing.Optional[typing.Dict[str, str]]
        allow_redirects: typing.Optional[builtins.bool]
        max_redirects: typing.Optional[builtins.int]
        auth: typing.Optional[str]
        bearer_auth: typing.Optional[str]
        basic_auth: typing.Optional[tuple[str, typing.Optional[str]]]
        query: typing.Optional[typing.List[typing.Tuple[str, str]]]
        form: typing.Optional[typing.List[typing.Tuple[str, str]]]
        json: typing.Optional[typing.Any]
        body: typing.Optional[typing.Any]
        multipart: typing.Optional[Multipart]

    # Examples

    ```python
    import rnet
    import asyncio

    async def run():
        response = await rnet.trace("https://httpbin.org/anything")
        print(response.status)

    asyncio.run(run())
    ```
    """
    ...

def websocket(url: str, **kwds) -> typing.Any:
    r"""
    Make a WebSocket connection with the given parameters.

    # Arguments

    * `url` - The URL to send the WebSocket request to.
    * `**kwds` - Additional WebSocket request parameters.

        proxy: typing.Optional[builtins.str]
        local_address: typing.Optional[typing.Optional[typing.Union[str, ipaddress.IPv4Address, ipaddress.IPv6Address]]]
        interface: typing.Optional[builtins.str]
        headers: typing.Optional[typing.Dict[str, bytes]]
        cookies: typing.Optional[typing.Dict[str, str]]
        protocols: typing.Optional[builtins.list[builtins.str]]
        use_http2: typing.Optional[builtins.bool]
        auth: typing.Optional[builtins.str]
        bearer_auth: typing.Optional[builtins.str]
        basic_auth: typing.Optional[tuple[builtins.str, typing.Optional[builtins.str]]]
        query: typing.Optional[builtins.list[tuple[builtins.str, builtins.str]]]
        read_buffer_size: typing.Optional[builtins.int]
        write_buffer_size: typing.Optional[builtins.int]
        max_write_buffer_size: typing.Optional[builtins.int]
        max_message_size: typing.Optional[builtins.int]
        max_frame_size: typing.Optional[builtins.int]
        accept_unmasked_frames: typing.Optional[builtins.bool]

    # Examples

    ```python
    import rnet
    import asyncio
    from rnet import Message

    async def run():
        ws = await rnet.websocket("wss://echo.websocket.org")
        await ws.send(Message.from_text("Hello, World!"))
        message = await ws.recv()
        print("Received:", message.data)
        await ws.close()

    asyncio.run(run())
    ```
    """
    ...