basedpyright 1.28.4 → 1.28.5

package/dist/typeshed-fallback/stubs/jwcrypto/jwcrypto/jwk.pyi

@@ -1,8 +1,10 @@
-from _typeshed import Incomplete
-from collections.abc import Sequence
+from collections.abc import Callable, Sequence
 from enum import Enum
-from typing import Any, NamedTuple
+from typing import Any, Literal, NamedTuple, TypeVar, overload
+from typing_extensions import Self, deprecated
 
+from cryptography.hazmat.primitives import hashes
+from cryptography.hazmat.primitives.asymmetric import ec, rsa
 from cryptography.hazmat.primitives.asymmetric.ed448 import Ed448PrivateKey as Ed448PrivateKey, Ed448PublicKey as Ed448PublicKey
 from cryptography.hazmat.primitives.asymmetric.ed25519 import (
     Ed25519PrivateKey as Ed25519PrivateKey,
@@ -15,6 +17,8 @@ from cryptography.hazmat.primitives.asymmetric.x25519 import (
 )
 from jwcrypto.common import JWException
 
+_T = TypeVar("_T")
+
 class UnimplementedOKPCurveKey:
     @classmethod
     def generate(cls) -> None: ...
@@ -24,9 +28,25 @@ class UnimplementedOKPCurveKey:
     def from_private_bytes(cls, *args) -> None: ...
 
 ImplementedOkpCurves: Sequence[str]
-priv_bytes: Incomplete
+priv_bytes: Callable[[bytes], X25519PrivateKey] | None
+
+class _Ed25519_CURVE(NamedTuple):
+    pubkey: UnimplementedOKPCurveKey
+    privkey: UnimplementedOKPCurveKey
+
+class _Ed448_CURVE(NamedTuple):
+    pubkey: UnimplementedOKPCurveKey
+    privkey: UnimplementedOKPCurveKey
 
-JWKTypesRegistry: Incomplete
+class _X25519_CURVE(NamedTuple):
+    pubkey: UnimplementedOKPCurveKey
+    privkey: UnimplementedOKPCurveKey
+
+class _X448_CURVE(NamedTuple):
+    pubkey: UnimplementedOKPCurveKey
+    privkey: UnimplementedOKPCurveKey
+
+JWKTypesRegistry: dict[str, str]
 
 class ParmType(Enum):
     name = "A string with a name"  # pyright: ignore[reportAssignmentType]
@@ -35,48 +55,80 @@ class ParmType(Enum):
     unsupported = "Unsupported Parameter"
 
 class JWKParameter(NamedTuple):
-    description: Incomplete
-    public: Incomplete
-    required: Incomplete
-    type: Incomplete
-
-JWKValuesRegistry: Incomplete
-JWKParamsRegistry: Incomplete
-JWKEllipticCurveRegistry: Incomplete
-JWKUseRegistry: Incomplete
-JWKOperationsRegistry: Incomplete
-JWKpycaCurveMap: Incomplete
-IANANamedInformationHashAlgorithmRegistry: Incomplete
+    description: str
+    public: bool
+    required: bool | None
+    type: ParmType | None
+
+JWKValuesRegistry: dict[str, dict[str, JWKParameter]]
+JWKParamsRegistry: dict[str, JWKParameter]
+JWKEllipticCurveRegistry: dict[str, str]
+JWKUseRegistry: dict[str, str]
+JWKOperationsRegistry: dict[str, str]
+JWKpycaCurveMap: dict[str, str]
+IANANamedInformationHashAlgorithmRegistry: dict[
+    str,
+    hashes.SHA256
+    | hashes.SHA384
+    | hashes.SHA512
+    | hashes.SHA3_224
+    | hashes.SHA3_256
+    | hashes.SHA3_384
+    | hashes.SHA3_512
+    | hashes.BLAKE2s
+    | hashes.BLAKE2b
+    | None,
+]
 
 class InvalidJWKType(JWException):
-    value: Incomplete
-    def __init__(self, value: Incomplete | None = None) -> None: ...
+    value: str | None
+    def __init__(self, value: str | None = None) -> None: ...
 
 class InvalidJWKUsage(JWException):
-    value: Incomplete
-    use: Incomplete
-    def __init__(self, use, value) -> None: ...
+    value: str
+    use: str
+    def __init__(self, use: str, value: str) -> None: ...
 
 class InvalidJWKOperation(JWException):
-    op: Incomplete
-    values: Incomplete
-    def __init__(self, operation, values) -> None: ...
+    op: str
+    values: Sequence[str]
+    def __init__(self, operation: str, values: Sequence[str]) -> None: ...
 
 class InvalidJWKValue(JWException): ...
 
 class JWK(dict[str, Any]):
     def __init__(self, **kwargs) -> None: ...
     @classmethod
-    def generate(cls, **kwargs): ...
+    def generate(cls, **kwargs) -> Self: ...
     def generate_key(self, **params) -> None: ...
     def import_key(self, **kwargs) -> None: ...
     @classmethod
-    def from_json(cls, key): ...
-    def export(self, private_key: bool = True, as_dict: bool = False): ...
-    def export_public(self, as_dict: bool = False): ...
-    def export_private(self, as_dict: bool = False): ...
-    def export_symmetric(self, as_dict: bool = False): ...
-    def public(self): ...
+    def from_json(cls, key) -> Self: ...
+    @overload
+    def export(self, private_key: bool = True, as_dict: Literal[False] = False) -> str: ...
+    @overload
+    def export(self, private_key: bool, as_dict: Literal[True]) -> dict[str, Any]: ...
+    @overload
+    def export(self, *, as_dict: Literal[True]) -> dict[str, Any]: ...
+    @overload
+    def export_public(self, as_dict: Literal[False] = False) -> str: ...
+    @overload
+    def export_public(self, as_dict: Literal[True]) -> dict[str, Any]: ...
+    @overload
+    def export_public(self, as_dict: bool = False) -> str | dict[str, Any]: ...
+    @overload
+    def export_private(self, as_dict: Literal[False] = False) -> str: ...
+    @overload
+    def export_private(self, as_dict: Literal[True]) -> dict[str, Any]: ...
+    @overload
+    def export_private(self, as_dict: bool = False) -> str | dict[str, Any]: ...
+    @overload
+    def export_symmetric(self, as_dict: Literal[False] = False) -> str: ...
+    @overload
+    def export_symmetric(self, as_dict: Literal[True]) -> dict[str, Any]: ...
+    @overload
+    def export_symmetric(self, as_dict: bool = False) -> str | dict[str, Any]: ...
+    def public(self) -> Self: ...
     @property
     def has_public(self) -> bool: ...
     @property
@@ -84,32 +136,89 @@ class JWK(dict[str, Any]):
     @property
     def is_symmetric(self) -> bool: ...
     @property
-    def key_type(self): ...
+    @deprecated("")
+    def key_type(self) -> str | None: ...
     @property
-    def key_id(self): ...
+    @deprecated("")
+    def key_id(self) -> str | None: ...
     @property
-    def key_curve(self): ...
-    def get_curve(self, arg): ...
-    def get_op_key(self, operation: Incomplete | None = None, arg: Incomplete | None = None): ...
-    def import_from_pyca(self, key) -> None: ...
-    def import_from_pem(self, data, password: Incomplete | None = None, kid: Incomplete | None = None) -> None: ...
-    def export_to_pem(self, private_key: bool = False, password: bool = False): ...
+    @deprecated("")
+    def key_curve(self) -> str | None: ...
+    @deprecated("")
+    def get_curve(
+        self, arg: str
+    ) -> (
+        ec.SECP256R1
+        | ec.SECP384R1
+        | ec.SECP521R1
+        | ec.SECP256K1
+        | ec.BrainpoolP256R1
+        | ec.BrainpoolP384R1
+        | ec.BrainpoolP512R1
+        | _Ed25519_CURVE
+        | _Ed448_CURVE
+        | _X25519_CURVE
+        | _X448_CURVE
+    ): ...
+    def get_op_key(
+        self, operation: str | None = None, arg: str | None = None
+    ) -> str | rsa.RSAPrivateKey | rsa.RSAPublicKey | ec.EllipticCurvePrivateKey | ec.EllipticCurvePublicKey | None: ...
+    def import_from_pyca(
+        self,
+        key: (
+            rsa.RSAPrivateKey
+            | rsa.RSAPublicKey
+            | ec.EllipticCurvePrivateKey
+            | ec.EllipticCurvePublicKey
+            | Ed25519PrivateKey
+            | Ed448PrivateKey
+            | X25519PrivateKey
+            | Ed25519PublicKey
+            | Ed448PublicKey
+            | X25519PublicKey
+        ),
+    ) -> None: ...
+    def import_from_pem(self, data: bytes, password: bytes | None = None, kid: str | None = None) -> None: ...
+    def export_to_pem(self, private_key: bool = False, password: bool = False) -> bytes: ...
     @classmethod
-    def from_pyca(cls, key): ...
+    def from_pyca(
+        cls,
+        key: (
+            rsa.RSAPrivateKey
+            | rsa.RSAPublicKey
+            | ec.EllipticCurvePrivateKey
+            | ec.EllipticCurvePublicKey
+            | Ed25519PrivateKey
+            | Ed448PrivateKey
+            | X25519PrivateKey
+            | Ed25519PublicKey
+            | Ed448PublicKey
+            | X25519PublicKey
+        ),
+    ) -> Self: ...
     @classmethod
-    def from_pem(cls, data, password: Incomplete | None = None): ...
-    def thumbprint(self, hashalg=...): ...
-    def thumbprint_uri(self, hname: str = "sha-256"): ...
+    def from_pem(cls, data: bytes, password: bytes | None = None) -> Self: ...
+    def thumbprint(self, hashalg: hashes.HashAlgorithm = ...) -> str: ...
+    def thumbprint_uri(self, hname: str = "sha-256") -> str: ...
     @classmethod
-    def from_password(cls, password): ...
-    def setdefault(self, key: str, default: Incomplete | None = None): ...
+    def from_password(cls, password: str) -> Self: ...
+    def setdefault(self, key: str, default: _T | None = None) -> _T: ...
 
-class JWKSet(dict[str, Any]):
-    def add(self, elem) -> None: ...
-    def export(self, private_keys: bool = True, as_dict: bool = False): ...
-    def import_keyset(self, keyset) -> None: ...
+class JWKSet(dict[Literal["keys"], set[JWK]]):
+    @overload
+    def __setitem__(self, key: Literal["keys"], val: JWK) -> None: ...
+    @overload
+    def __setitem__(self, key: str, val: Any) -> None: ...
+    def add(self, elem: JWK) -> None: ...
+    @overload
+    def export(self, private_keys: bool = True, as_dict: Literal[False] = False) -> str: ...
+    @overload
+    def export(self, private_keys: bool, as_dict: Literal[True]) -> dict[str, Any]: ...
+    @overload
+    def export(self, *, as_dict: Literal[True]) -> dict[str, Any]: ...
+    def import_keyset(self, keyset: str | bytes) -> None: ...
     @classmethod
-    def from_json(cls, keyset): ...
-    def get_key(self, kid): ...
-    def get_keys(self, kid): ...
-    def setdefault(self, key: str, default: Incomplete | None = None): ...
+    def from_json(cls, keyset: str | bytes) -> Self: ...
+    def get_key(self, kid: str) -> JWK | None: ...
+    def get_keys(self, kid: str) -> set[JWK]: ...
+    def setdefault(self, key: str, default: _T | None = None) -> _T: ...

package/dist/typeshed-fallback/stubs/jwcrypto/jwcrypto/jws.pyi

@@ -1,9 +1,14 @@
 from _typeshed import Incomplete
+from collections.abc import Mapping
+from typing import Any, Literal
+from typing_extensions import Self
 
-from jwcrypto.common import JWException
+from jwcrypto.common import JWException, JWSEHeaderParameter
+from jwcrypto.jwa import JWAAlgorithm
+from jwcrypto.jwk import JWK, JWKSet
 
-JWSHeaderRegistry: Incomplete
-default_allowed_algs: Incomplete
+JWSHeaderRegistry: Mapping[str, JWSEHeaderParameter]
+default_allowed_algs: list[str]
 
 class InvalidJWSSignature(JWException):
     def __init__(self, message: str | None = None, exception: BaseException | None = None) -> None: ...
@@ -15,19 +20,26 @@ class InvalidJWSOperation(JWException):
     def __init__(self, message: str | None = None, exception: BaseException | None = None) -> None: ...
 
 class JWSCore:
-    alg: Incomplete
-    engine: Incomplete
-    key: Incomplete
-    header: Incomplete
-    protected: Incomplete
-    payload: Incomplete
-    def __init__(self, alg, key, header, payload, algs: Incomplete | None = None) -> None: ...
-    def sign(self): ...
-    def verify(self, signature): ...
+    alg: str
+    engine: JWAAlgorithm
+    key: JWK | JWKSet
+    header: dict[str, Any]
+    protected: str
+    payload: bytes
+    def __init__(
+        self,
+        alg: str,
+        key: JWK | JWKSet,
+        header: dict[str, Any] | str | None,
+        payload: str | bytes,
+        algs: list[str] | None = None,
+    ) -> None: ...
+    def sign(self) -> dict[str, str | bytes]: ...
+    def verify(self, signature: bytes) -> Literal[True]: ...
 
 class JWS:
     objects: Incomplete
-    verifylog: Incomplete
+    verifylog: list[str] | None
     header_registry: Incomplete
     def __init__(self, payload: Incomplete | None = None, header_registry: Incomplete | None = None) -> None: ...
     @property
@@ -41,12 +53,12 @@ class JWS:
     def add_signature(
         self, key, alg: Incomplete | None = None, protected: Incomplete | None = None, header: Incomplete | None = None
     ) -> None: ...
-    def serialize(self, compact: bool = False): ...
+    def serialize(self, compact: bool = False) -> str: ...
     @property
     def payload(self): ...
     def detach_payload(self) -> None: ...
     @property
     def jose_header(self): ...
     @classmethod
-    def from_jose_token(cls, token): ...
+    def from_jose_token(cls, token: str | bytes) -> Self: ...
     def __eq__(self, other: object) -> bool: ...

package/dist/typeshed-fallback/stubs/jwcrypto/jwcrypto/jwt.pyi

@@ -1,5 +1,6 @@
 from _typeshed import Incomplete
 from collections.abc import Mapping
+from typing import Any
 from typing_extensions import deprecated
 
 from jwcrypto.common import JWException, JWKeyNotFound
@@ -31,11 +32,11 @@ class JWTMissingKey(JWKeyNotFound):
     def __init__(self, message: str | None = None, exception: BaseException | None = None) -> None: ...
 
 class JWT:
-    deserializelog: Incomplete
+    deserializelog: list[str] | None
     def __init__(
         self,
-        header: dict[Incomplete, Incomplete] | str | None = None,
-        claims: dict[Incomplete, Incomplete] | str | None = None,
+        header: dict[str, Any] | str | None = None,
+        claims: dict[str, Any] | str | None = None,
         jwt: Incomplete | None = None,
         key: JWK | JWKSet | None = None,
         algs: Incomplete | None = None,
@@ -44,9 +45,9 @@ class JWT:
         expected_type: Incomplete | None = None,
     ) -> None: ...
     @property
-    def header(self): ...
+    def header(self) -> str: ...
     @header.setter
-    def header(self, h) -> None: ...
+    def header(self, h: dict[str, Any] | str) -> None: ...
     @property
     def claims(self): ...
     @claims.setter

package/dist/typeshed-fallback/stubs/libsass/sass.pyi

@@ -183,3 +183,20 @@ class SassMap(Mapping[_KT, _VT_co]):
     def __iter__(self) -> Iterator[_KT]: ...
     def __len__(self) -> int: ...
     def __hash__(self) -> int: ...
+
+__all__ = (
+    "MODES",
+    "OUTPUT_STYLES",
+    "SOURCE_COMMENTS",
+    "CompileError",
+    "SassColor",
+    "SassError",
+    "SassFunction",
+    "SassList",
+    "SassMap",
+    "SassNumber",
+    "SassWarning",
+    "and_join",
+    "compile",
+    "libsass_version",
+)

package/dist/typeshed-fallback/stubs/libsass/sassutils/builder.pyi

@@ -32,3 +32,5 @@ class Manifest:
     def unresolve_filename(self, package_dir: str, filename: str) -> str: ...
     def build(self, package_dir: str, output_style: _OutputStyle = "nested") -> frozenset[str]: ...
     def build_one(self, package_dir: str, filename: str, source_map: bool = False) -> str: ...
+
+__all__ = ("SUFFIXES", "SUFFIX_PATTERN", "Manifest", "build_directory")

package/dist/typeshed-fallback/stubs/libsass/sassutils/distutils.pyi

@@ -14,3 +14,5 @@ class build_sass(Command):
     def finalize_options(self) -> None: ...
     def run(self) -> None: ...
     def get_package_dir(self, package: str) -> str: ...
+
+__all__ = ("build_sass", "validate_manifests")

package/dist/typeshed-fallback/stubs/libsass/sassutils/wsgi.pyi

@@ -20,3 +20,5 @@ class SassMiddleware:
     def __call__(self, environ: WSGIEnvironment, start_response: StartResponse) -> Iterable[bytes]: ...
     @staticmethod
     def quote_css_string(s: str) -> str: ...
+
+__all__ = ("SassMiddleware",)

package/dist/typeshed-fallback/stubs/mypy-extensions/mypy_extensions.pyi

@@ -1,5 +1,4 @@
 import abc
-import sys
 from _collections_abc import dict_items, dict_keys, dict_values
 from _typeshed import IdentityFunction, Unused
 from collections.abc import Mapping
@@ -27,17 +26,16 @@ class _TypedDict(Mapping[str, object], metaclass=abc.ABCMeta):
     def keys(self) -> dict_keys[str, object]: ...
     def values(self) -> dict_values[str, object]: ...
     def __delitem__(self, k: Never) -> None: ...
-    if sys.version_info >= (3, 9):
-        @overload
-        def __or__(self, value: Self, /) -> Self: ...
-        @overload
-        def __or__(self, value: dict[str, Any], /) -> dict[str, object]: ...
-        @overload
-        def __ror__(self, value: Self, /) -> Self: ...
-        @overload
-        def __ror__(self, value: dict[str, Any], /) -> dict[str, object]: ...
-        # supposedly incompatible definitions of `__or__` and `__ior__`:
-        def __ior__(self, value: Self, /) -> Self: ...  # type: ignore[misc]
+    @overload
+    def __or__(self, value: Self, /) -> Self: ...
+    @overload
+    def __or__(self, value: dict[str, Any], /) -> dict[str, object]: ...
+    @overload
+    def __ror__(self, value: Self, /) -> Self: ...
+    @overload
+    def __ror__(self, value: dict[str, Any], /) -> dict[str, object]: ...
+    # supposedly incompatible definitions of `__or__` and `__ior__`:
+    def __ior__(self, value: Self, /) -> Self: ...  # type: ignore[misc]
 
 def TypedDict(typename: str, fields: dict[str, type[Any]], total: bool = ...) -> type[dict[str, Any]]: ...
 @overload

package/dist/typeshed-fallback/stubs/mysqlclient/MySQLdb/__init__.pyi

@@ -49,3 +49,47 @@ def Binary(x): ...
 def Connect(*args, **kwargs) -> Connection: ...
 
 connect = Connect
+
+__all__ = [
+    "BINARY",
+    "Binary",
+    "Connect",
+    "Connection",
+    "DATE",
+    "Date",
+    "Time",
+    "Timestamp",
+    "DateFromTicks",
+    "TimeFromTicks",
+    "TimestampFromTicks",
+    "DataError",
+    "DatabaseError",
+    "Error",
+    "FIELD_TYPE",
+    "IntegrityError",
+    "InterfaceError",
+    "InternalError",
+    "MySQLError",
+    "NUMBER",
+    "NotSupportedError",
+    "DBAPISet",
+    "OperationalError",
+    "ProgrammingError",
+    "ROWID",
+    "STRING",
+    "TIME",
+    "TIMESTAMP",
+    "Warning",
+    "apilevel",
+    "connect",
+    "connections",
+    "constants",
+    "converters",
+    "cursors",
+    "debug",
+    "get_client_info",
+    "paramstyle",
+    "string_literal",
+    "threadsafety",
+    "version_info",
+]

package/dist/typeshed-fallback/stubs/mysqlclient/MySQLdb/constants/__init__.pyi

@@ -1 +1,3 @@
 from . import CLIENT as CLIENT, CR as CR, ER as ER, FIELD_TYPE as FIELD_TYPE, FLAG as FLAG
+
+__all__ = ["CR", "FIELD_TYPE", "CLIENT", "ER", "FLAG"]

package/dist/typeshed-fallback/stubs/oauthlib/oauthlib/__init__.pyi

@@ -1,2 +1,7 @@
-def set_debug(debug_val) -> None: ...
-def get_debug(): ...
+from typing import Final
+
+__author__: Final[str]
+__version__: Final[str]
+
+def set_debug(debug_val: bool) -> None: ...
+def get_debug() -> bool: ...

package/dist/typeshed-fallback/stubs/oauthlib/oauthlib/common.pyi

@@ -1,64 +1,81 @@
-from _typeshed import Incomplete
-from typing import Any
+import re
+from _typeshed import Incomplete, SupportsLenAndGetItem
+from collections.abc import Iterable, Mapping
+from logging import Logger
+from typing import Any, Final, Literal, TypeVar, overload
+from typing_extensions import TypeAlias
 
-UNICODE_ASCII_CHARACTER_SET: str
-CLIENT_ID_CHARACTER_SET: str
-SANITIZE_PATTERN: Any
-INVALID_HEX_PATTERN: Any
-always_safe: str
-log: Any
+_T = TypeVar("_T")
+_V = TypeVar("_V")
 
-def quote(s, safe: bytes = b"/"): ...
-def unquote(s): ...
-def urlencode(params): ...
-def encode_params_utf8(params): ...
-def decode_params_utf8(params): ...
+_HTTPMethod: TypeAlias = Literal["CONNECT", "DELETE", "GET", "HEAD", "OPTIONS", "PATCH", "POST", "PUT", "TRACE"]
 
-urlencoded: Any
+UNICODE_ASCII_CHARACTER_SET: Final[str]
+CLIENT_ID_CHARACTER_SET: Final[str]
+SANITIZE_PATTERN: Final[re.Pattern[str]]
+INVALID_HEX_PATTERN: Final[re.Pattern[str]]
+always_safe: Final[str]
+log: Logger
 
-def urldecode(query): ...
-def extract_params(raw): ...
-def generate_nonce(): ...
-def generate_timestamp(): ...
-def generate_token(length: int = 30, chars=...): ...
-def generate_signed_token(private_pem, request): ...
+def quote(s: str | bytes, safe: bytes = b"/") -> str: ...
+def unquote(s: str | bytes) -> str: ...
+def urlencode(params: Iterable[tuple[str | bytes, str | bytes]]) -> str: ...
+def encode_params_utf8(params: Iterable[tuple[str | bytes, str | bytes]]) -> list[tuple[bytes, bytes]]: ...
+def decode_params_utf8(params: Iterable[tuple[str | bytes, str | bytes]]) -> list[tuple[str, str]]: ...
+
+urlencoded: Final[set[str]]
+
+def urldecode(query: str | bytes) -> list[tuple[str, str]]: ...
+def extract_params(raw: str | bytes | dict[str, str] | Iterable[tuple[str, str]]) -> list[tuple[str, str]] | None: ...
+def generate_nonce() -> str: ...
+def generate_timestamp() -> str: ...
+def generate_token(length: int = 30, chars: SupportsLenAndGetItem[str] = ...) -> str: ...
+def generate_signed_token(private_pem: str, request: Request) -> str: ...
 def verify_signed_token(public_pem, token): ...
-def generate_client_id(length: int = 30, chars=...): ...
-def add_params_to_qs(query, params): ...
-def add_params_to_uri(uri, params, fragment: bool = False): ...
-def safe_string_equals(a, b): ...
-def to_unicode(data, encoding: str = "UTF-8"): ...
+def generate_client_id(length: int = 30, chars: SupportsLenAndGetItem[str] = ...) -> str: ...
+def add_params_to_qs(query: str, params: dict[str, str] | Iterable[tuple[str, str]]) -> str: ...
+def add_params_to_uri(uri: str, params: dict[str, str] | Iterable[tuple[str, str]], fragment: bool = False) -> str: ...
+def safe_string_equals(a: str, b: str) -> bool: ...
+@overload
+def to_unicode(data: str | bytes, encoding: str = "UTF-8") -> str: ...
+@overload
+def to_unicode(data: Mapping[str, _V] | Mapping[bytes, _V], encoding: str = "UTF-8") -> dict[str, _V]: ...
+@overload
+def to_unicode(data: _T, encoding: str = "UTF-8") -> _T: ...
 
-class CaseInsensitiveDict(dict[Any, Any]):
-    proxy: Any
-    def __init__(self, data) -> None: ...
-    def __contains__(self, k): ...
-    def __delitem__(self, k) -> None: ...
-    def __getitem__(self, k): ...
-    def get(self, k, default: Incomplete | None = None): ...
-    def __setitem__(self, k, v) -> None: ...
+class CaseInsensitiveDict(dict[str, Incomplete]):
+    proxy: dict[str, str]
+    def __init__(self, data: dict[str, Incomplete]) -> None: ...
+    @overload
+    def __contains__(self, k: str) -> bool: ...
+    @overload
+    def __contains__(self, k: object) -> bool: ...
+    def __delitem__(self, k: str) -> None: ...
+    def __getitem__(self, k: str): ...
+    def get(self, k: str, default: Incomplete | None = None) -> Incomplete | None: ...
+    def __setitem__(self, k: str, v) -> None: ...
     def update(self, *args, **kwargs) -> None: ...
 
 class Request:
-    uri: Any
-    http_method: Any
-    headers: Any
-    body: Any
-    decoded_body: Any
-    oauth_params: Any
-    validator_log: Any
+    uri: str
+    http_method: _HTTPMethod
+    headers: CaseInsensitiveDict
+    body: str | dict[str, str] | list[tuple[str, str]] | None
+    decoded_body: list[tuple[str, str]] | None
+    oauth_params: list[str]
+    validator_log: dict[str, Any]  # value type depends on the key
     def __init__(
         self,
-        uri,
-        http_method: str = "GET",
-        body: Incomplete | None = None,
-        headers: Incomplete | None = None,
+        uri: str,
+        http_method: _HTTPMethod = "GET",
+        body: str | dict[str, str] | list[tuple[str, str]] | None = None,
+        headers: Mapping[str, str] | None = None,
         encoding: str = "utf-8",
     ): ...
-    def __getattr__(self, name: str): ...
+    def __getattr__(self, name: str) -> str | None: ...  # or raises AttributeError if attribute is not found
     @property
-    def uri_query(self): ...
+    def uri_query(self) -> str: ...
     @property
-    def uri_query_params(self): ...
+    def uri_query_params(self) -> list[tuple[str, str]]: ...
     @property
-    def duplicate_params(self): ...
+    def duplicate_params(self) -> list[str]: ...