basedpyright 1.28.3 → 1.28.4

package/dist/typeshed-fallback/stubs/WebOb/webob/acceptparse.pyi

@@ -1,12 +1,67 @@
 from _typeshed import SupportsItems
-from collections.abc import Callable, Iterable, Iterator
-from typing import Any, Literal, NamedTuple, TypeVar, overload
+from collections.abc import Callable, Iterable, Iterator, Sequence
+from typing import Any, Literal, NamedTuple, Protocol, TypeVar, overload
 from typing_extensions import Self, TypeAlias
 
+from webob._types import AsymmetricPropertyWithDelete
+
 _T = TypeVar("_T")
 _ListOrTuple: TypeAlias = list[_T] | tuple[_T, ...]
 _ParsedAccept: TypeAlias = tuple[str, float, list[tuple[str, str]], list[str | tuple[str, str]]]
 
+class _SupportsStr(Protocol):
+    def __str__(self) -> str: ...  # noqa: Y029
+
+_AnyAcceptHeader: TypeAlias = AcceptValidHeader | AcceptInvalidHeader | AcceptNoHeader
+_AnyAcceptCharsetHeader: TypeAlias = AcceptCharsetValidHeader | AcceptCharsetInvalidHeader | AcceptCharsetNoHeader
+_AnyAcceptEncodingHeader: TypeAlias = AcceptEncodingValidHeader | AcceptEncodingInvalidHeader | AcceptEncodingNoHeader
+_AnyAcceptLanguageHeader: TypeAlias = AcceptLanguageValidHeader | AcceptLanguageInvalidHeader | AcceptLanguageNoHeader
+
+_AcceptProperty: TypeAlias = AsymmetricPropertyWithDelete[
+    _AnyAcceptHeader,
+    (
+        _AnyAcceptHeader
+        | SupportsItems[str, float | tuple[float, str]]
+        | _ListOrTuple[str | tuple[str, float, str] | list[Any]]
+        | _SupportsStr
+        | str
+        | None
+    ),
+]
+_AcceptCharsetProperty: TypeAlias = AsymmetricPropertyWithDelete[
+    _AnyAcceptCharsetHeader,
+    (
+        _AnyAcceptCharsetHeader
+        | SupportsItems[str, float]
+        | _ListOrTuple[str | tuple[str, float] | list[Any]]
+        | _SupportsStr
+        | str
+        | None
+    ),
+]
+_AcceptEncodingProperty: TypeAlias = AsymmetricPropertyWithDelete[
+    _AnyAcceptEncodingHeader,
+    (
+        _AnyAcceptEncodingHeader
+        | SupportsItems[str, float]
+        | _ListOrTuple[str | tuple[str, float] | list[Any]]
+        | _SupportsStr
+        | str
+        | None
+    ),
+]
+_AcceptLanguageProperty: TypeAlias = AsymmetricPropertyWithDelete[
+    _AnyAcceptLanguageHeader,
+    (
+        _AnyAcceptLanguageHeader
+        | SupportsItems[str, float]
+        | _ListOrTuple[str | tuple[str, float] | list[Any]]
+        | _SupportsStr
+        | str
+        | None
+    ),
+]
+
 class AcceptOffer(NamedTuple):
     type: str
     subtype: str
@@ -22,30 +77,38 @@ class AcceptValidHeader(Accept):
     @property
     def header_value(self) -> str: ...
     @property
-    def parsed(self) -> list[_ParsedAccept] | None: ...
+    def parsed(self) -> list[_ParsedAccept]: ...
     def __init__(self, header_value: str) -> None: ...
     def copy(self) -> Self: ...
-    @overload
-    def __add__(self, other: str | None) -> Self: ...
-    @overload
-    def __add__(self, other: AcceptNoHeader | AcceptValidHeader | AcceptInvalidHeader) -> Self: ...
-    @overload
-    def __add__(self, other: SupportsItems[str, float | tuple[float, str]]) -> Self: ...
-    @overload
-    def __add__(self, other: _ListOrTuple[str | tuple[str, float, str] | list[Any]]) -> Self: ...
+    def __add__(
+        self,
+        other: (
+            _AnyAcceptHeader
+            | SupportsItems[str, float | tuple[float, str]]
+            | _ListOrTuple[str | tuple[str, float, str] | list[Any]]
+            | _SupportsStr
+            | str
+            | None
+        ),
+    ) -> Self: ...
     def __bool__(self) -> Literal[True]: ...
     def __contains__(self, offer: str) -> bool: ...
     def __iter__(self) -> Iterator[str]: ...
-    @overload
-    def __radd__(self, other: str | None) -> Self: ...
-    @overload
-    def __radd__(self, other: SupportsItems[str, float | tuple[float, str]]) -> Self: ...
-    @overload
-    def __radd__(self, other: _ListOrTuple[str | tuple[str, float, str] | list[Any]]) -> Self: ...
+    def __radd__(
+        self,
+        other: (
+            _AnyAcceptHeader
+            | SupportsItems[str, float | tuple[float, str]]
+            | _ListOrTuple[str | tuple[str, float, str] | list[Any]]
+            | _SupportsStr
+            | str
+            | None
+        ),
+    ) -> Self: ...
     def accept_html(self) -> bool: ...
     @property
     def accepts_html(self) -> bool: ...
-    def acceptable_offers(self, offers: Iterable[str | AcceptOffer]) -> list[tuple[str, float]]: ...
+    def acceptable_offers(self, offers: Sequence[str]) -> list[tuple[str, float]]: ...
     @overload
     def best_match(self, offers: Iterable[str | tuple[str, float] | list[Any]], default_match: None = None) -> str | None: ...
     @overload
@@ -53,40 +116,13 @@ class AcceptValidHeader(Accept):
     def quality(self, offer: str) -> float | None: ...
 
 class _AcceptInvalidOrNoHeader(Accept):
-    @property
-    def parsed(self) -> None: ...
-    def copy(self) -> Self: ...
-    @overload
-    def __add__(self, other: None) -> AcceptNoHeader: ...
-    @overload
-    def __add__(self, other: str) -> AcceptValidHeader | AcceptNoHeader: ...
-    @overload
-    def __add__(self, other: AcceptValidHeader) -> AcceptValidHeader: ...
-    @overload
-    def __add__(self, other: AcceptNoHeader | AcceptInvalidHeader) -> AcceptNoHeader: ...
-    @overload
-    def __add__(self, other: SupportsItems[str, float | tuple[float, str]]) -> AcceptValidHeader | AcceptNoHeader: ...
-    @overload
-    def __add__(self, other: _ListOrTuple[str | tuple[str, float, str] | list[Any]]) -> AcceptValidHeader | AcceptNoHeader: ...
-    @overload
-    def __radd__(self, other: None) -> AcceptNoHeader: ...
-    @overload
-    def __radd__(self, other: str) -> AcceptValidHeader | AcceptNoHeader: ...
-    @overload
-    def __radd__(self, other: AcceptValidHeader) -> AcceptValidHeader: ...
-    @overload
-    def __radd__(self, other: AcceptNoHeader | AcceptInvalidHeader) -> AcceptNoHeader: ...
-    @overload
-    def __radd__(self, other: SupportsItems[str, float | tuple[float, str]]) -> AcceptValidHeader | AcceptNoHeader: ...
-    @overload
-    def __radd__(self, other: _ListOrTuple[str | tuple[str, float, str] | list[Any]]) -> AcceptValidHeader | AcceptNoHeader: ...
     def __bool__(self) -> Literal[False]: ...
     def __contains__(self, offer: str) -> Literal[True]: ...
     def __iter__(self) -> Iterator[str]: ...
     def accept_html(self) -> bool: ...
     @property
     def accepts_html(self) -> bool: ...
-    def acceptable_offers(self, offers: Iterable[str | AcceptOffer]) -> list[tuple[str, float]]: ...
+    def acceptable_offers(self, offers: Sequence[str]) -> list[tuple[str, float]]: ...
     @overload
     def best_match(self, offers: Iterable[str | tuple[str, float] | list[Any]], default_match: None = None) -> str | None: ...
     @overload
@@ -96,33 +132,93 @@ class _AcceptInvalidOrNoHeader(Accept):
 class AcceptNoHeader(_AcceptInvalidOrNoHeader):
     @property
     def header_value(self) -> None: ...
+    @property
+    def parsed(self) -> None: ...
     def __init__(self) -> None: ...
+    def copy(self) -> Self: ...
+    @overload
+    def __add__(self, other: AcceptValidHeader | Literal[""]) -> AcceptValidHeader: ...
+    @overload
+    def __add__(self, other: AcceptNoHeader | AcceptInvalidHeader | None) -> Self: ...
+    @overload
+    def __add__(
+        self,
+        other: (
+            _AnyAcceptHeader
+            | SupportsItems[str, float | tuple[float, str]]
+            | _ListOrTuple[str | tuple[str, float, str] | list[Any]]
+            | _SupportsStr
+            | str
+            | None
+        ),
+    ) -> Self | AcceptValidHeader: ...
+    @overload
+    def __radd__(self, other: AcceptValidHeader | Literal[""]) -> AcceptValidHeader: ...
+    @overload
+    def __radd__(self, other: AcceptNoHeader | AcceptInvalidHeader | None) -> Self: ...
+    @overload
+    def __radd__(
+        self,
+        other: (
+            _AnyAcceptHeader
+            | SupportsItems[str, float | tuple[float, str]]
+            | _ListOrTuple[str | tuple[str, float, str] | list[Any]]
+            | _SupportsStr
+            | str
+            | None
+        ),
+    ) -> Self | AcceptValidHeader: ...
 
 class AcceptInvalidHeader(_AcceptInvalidOrNoHeader):
     @property
     def header_value(self) -> str: ...
+    @property
+    def parsed(self) -> None: ...
     def __init__(self, header_value: str) -> None: ...
-
-@overload
-def create_accept_header(header_value: None) -> AcceptNoHeader: ...
-@overload
-def create_accept_header(header_value: str) -> AcceptValidHeader | AcceptInvalidHeader: ...
-
-class _AcceptProperty:
+    def copy(self) -> Self: ...
     @overload
-    def __get__(self, obj: None, type: type | None = ..., /) -> property: ...
+    def __add__(self, other: AcceptValidHeader | Literal[""]) -> AcceptValidHeader: ...
     @overload
-    def __get__(self, obj: Any, type: type | None = ..., /) -> AcceptNoHeader | AcceptValidHeader | AcceptInvalidHeader: ...
+    def __add__(self, other: AcceptInvalidHeader | AcceptNoHeader | None) -> AcceptNoHeader: ...
     @overload
-    def __set__(self, obj: Any, value: str | None, /) -> None: ...
+    def __add__(
+        self,
+        other: (
+            _AnyAcceptHeader
+            | SupportsItems[str, float | tuple[float, str]]
+            | _ListOrTuple[str | tuple[str, float, str] | list[Any]]
+            | _SupportsStr
+            | str
+            | None
+        ),
+    ) -> AcceptValidHeader | AcceptNoHeader: ...
     @overload
-    def __set__(self, obj: Any, value: AcceptNoHeader | AcceptValidHeader | AcceptInvalidHeader, /) -> None: ...
+    def __radd__(self, other: AcceptValidHeader | Literal[""]) -> AcceptValidHeader: ...
     @overload
-    def __set__(self, obj: Any, value: SupportsItems[str, float | tuple[float, str]], /) -> None: ...
+    def __radd__(self, other: AcceptInvalidHeader | AcceptNoHeader | None) -> AcceptNoHeader: ...
     @overload
-    def __set__(self, obj: Any, value: _ListOrTuple[str | tuple[str, float, str] | list[Any]], /) -> None: ...
-    def __delete__(self, obj: Any, /) -> None: ...
+    def __radd__(
+        self,
+        other: (
+            _AnyAcceptHeader
+            | SupportsItems[str, float | tuple[float, str]]
+            | _ListOrTuple[str | tuple[str, float, str] | list[Any]]
+            | _SupportsStr
+            | str
+            | None
+        ),
+    ) -> AcceptValidHeader | AcceptNoHeader: ...
 
+@overload
+def create_accept_header(header_value: AcceptValidHeader | Literal[""]) -> AcceptValidHeader: ...
+@overload
+def create_accept_header(header_value: AcceptInvalidHeader) -> AcceptInvalidHeader: ...
+@overload
+def create_accept_header(header_value: None | AcceptNoHeader) -> AcceptNoHeader: ...
+@overload
+def create_accept_header(header_value: str) -> AcceptValidHeader | AcceptInvalidHeader: ...
+@overload
+def create_accept_header(header_value: _AnyAcceptHeader | str | None) -> _AnyAcceptHeader: ...
 def accept_property() -> _AcceptProperty: ...
 
 class AcceptCharset:
@@ -136,108 +232,143 @@ class AcceptCharsetValidHeader(AcceptCharset):
     def parsed(self) -> list[tuple[str, float]]: ...
     def __init__(self, header_value: str) -> None: ...
     def copy(self) -> Self: ...
-    @overload
-    def __add__(self, other: str | None) -> Self: ...
-    @overload
-    def __add__(self, other: AcceptCharsetValidHeader | AcceptCharsetNoHeader | AcceptCharsetInvalidHeader) -> Self: ...
-    @overload
-    def __add__(self, other: SupportsItems[str, float]) -> Self: ...
-    @overload
-    def __add__(self, other: _ListOrTuple[str | tuple[str, float] | list[Any]]) -> Self: ...
+    def __add__(
+        self,
+        other: (
+            _AnyAcceptCharsetHeader
+            | SupportsItems[str, float]
+            | _ListOrTuple[str | tuple[str, float] | list[Any]]
+            | _SupportsStr
+            | str
+            | None
+        ),
+    ) -> Self: ...
     def __bool__(self) -> Literal[True]: ...
     def __contains__(self, offer: str) -> bool: ...
     def __iter__(self) -> Iterator[str]: ...
+    def __radd__(
+        self,
+        other: (
+            _AnyAcceptCharsetHeader
+            | SupportsItems[str, float]
+            | _ListOrTuple[str | tuple[str, float] | list[Any]]
+            | _SupportsStr
+            | str
+            | None
+        ),
+    ) -> Self: ...
+    def acceptable_offers(self, offers: Sequence[str]) -> list[tuple[str, float]]: ...
     @overload
-    def __radd__(self, other: str | None) -> Self: ...
-    @overload
-    def __radd__(self, other: AcceptCharsetValidHeader | AcceptCharsetNoHeader | AcceptCharsetInvalidHeader) -> Self: ...
-    @overload
-    def __radd__(self, other: SupportsItems[str, float]) -> Self: ...
-    @overload
-    def __radd__(self, other: _ListOrTuple[str | tuple[str, float] | list[Any]]) -> Self: ...
-    def acceptable_offers(self, offers: Iterable[str]) -> list[tuple[str, float]]: ...
-    @overload
-    def best_match(self, offers: Iterable[str], default_match: None = None) -> str | None: ...
+    def best_match(self, offers: Iterable[str | tuple[str, float] | list[Any]], default_match: None = None) -> str | None: ...
     @overload
-    def best_match(self, offers: Iterable[str], default_match: str) -> str: ...
+    def best_match(self, offers: Iterable[str | tuple[str, float] | list[Any]], default_match: str) -> str: ...
     def quality(self, offer: str) -> float | None: ...
 
 class _AcceptCharsetInvalidOrNoHeader(AcceptCharset):
-    @property
-    def parsed(self) -> None: ...
     def __bool__(self) -> Literal[False]: ...
     def __contains__(self, offer: str) -> Literal[True]: ...
     def __iter__(self) -> Iterator[str]: ...
+    def acceptable_offers(self, offers: Iterable[str]) -> list[tuple[str, float]]: ...
     @overload
-    def __add__(self, other: None) -> AcceptCharsetNoHeader: ...
+    def best_match(self, offers: Iterable[str | tuple[str, float] | list[Any]], default_match: None = None) -> str | None: ...
     @overload
-    def __add__(self, other: str) -> AcceptCharsetValidHeader | AcceptCharsetNoHeader: ...
+    def best_match(self, offers: Iterable[str | tuple[str, float] | list[Any]], default_match: str) -> str: ...
+    def quality(self, offer: str) -> float | None: ...
+
+class AcceptCharsetNoHeader(_AcceptCharsetInvalidOrNoHeader):
+    @property
+    def header_value(self) -> None: ...
+    @property
+    def parsed(self) -> None: ...
+    def __init__(self) -> None: ...
+    def copy(self) -> Self: ...
     @overload
     def __add__(self, other: AcceptCharsetValidHeader) -> AcceptCharsetValidHeader: ...
     @overload
-    def __add__(self, other: AcceptCharsetNoHeader | AcceptCharsetInvalidHeader) -> AcceptCharsetNoHeader: ...
-    @overload
-    def __add__(self, other: SupportsItems[str, float]) -> AcceptCharsetValidHeader | AcceptCharsetNoHeader: ...
+    def __add__(self, other: AcceptCharsetInvalidHeader | AcceptCharsetNoHeader | Literal[""] | None) -> Self: ...
     @overload
     def __add__(
-        self, other: _ListOrTuple[str | tuple[str, float] | list[Any]]
-    ) -> AcceptCharsetValidHeader | AcceptCharsetNoHeader: ...
-    @overload
-    def __radd__(self, other: None) -> AcceptCharsetNoHeader: ...
-    @overload
-    def __radd__(self, other: str) -> AcceptCharsetValidHeader | AcceptCharsetNoHeader: ...
+        self,
+        other: (
+            _AnyAcceptCharsetHeader
+            | SupportsItems[str, float]
+            | _ListOrTuple[str | tuple[str, float] | list[Any]]
+            | _SupportsStr
+            | str
+            | None
+        ),
+    ) -> Self | AcceptCharsetValidHeader: ...
     @overload
     def __radd__(self, other: AcceptCharsetValidHeader) -> AcceptCharsetValidHeader: ...
     @overload
-    def __radd__(self, other: AcceptCharsetNoHeader | AcceptCharsetInvalidHeader) -> AcceptCharsetNoHeader: ...
-    @overload
-    def __radd__(self, other: SupportsItems[str, float]) -> AcceptCharsetValidHeader | AcceptCharsetNoHeader: ...
+    def __radd__(self, other: AcceptCharsetInvalidHeader | AcceptCharsetNoHeader | Literal[""] | None) -> Self: ...
     @overload
     def __radd__(
-        self, other: _ListOrTuple[str | tuple[str, float] | list[Any]]
-    ) -> AcceptCharsetValidHeader | AcceptCharsetNoHeader: ...
-    def copy(self) -> Self: ...
-    def acceptable_offers(self, offers: Iterable[str]) -> list[tuple[str, float]]: ...
-    @overload
-    def best_match(self, offers: Iterable[str], default_match: None = None) -> str | None: ...
-    @overload
-    def best_match(self, offers: Iterable[str], default_match: str) -> str: ...
-    def quality(self, offer: str) -> float | None: ...
-
-class AcceptCharsetNoHeader(_AcceptCharsetInvalidOrNoHeader):
-    @property
-    def header_value(self) -> None: ...
-    def __init__(self) -> None: ...
+        self,
+        other: (
+            _AnyAcceptCharsetHeader
+            | SupportsItems[str, float]
+            | _ListOrTuple[str | tuple[str, float] | list[Any]]
+            | _SupportsStr
+            | str
+            | None
+        ),
+    ) -> Self | AcceptCharsetValidHeader: ...
 
 class AcceptCharsetInvalidHeader(_AcceptCharsetInvalidOrNoHeader):
     @property
     def header_value(self) -> str: ...
+    @property
+    def parsed(self) -> None: ...
     def __init__(self, header_value: str) -> None: ...
-
-@overload
-def create_accept_charset_header(header_value: None) -> AcceptCharsetNoHeader: ...
-@overload
-def create_accept_charset_header(header_value: str) -> AcceptCharsetValidHeader | AcceptCharsetInvalidHeader: ...
-
-class _AcceptCharsetProperty:
+    def copy(self) -> Self: ...
     @overload
-    def __get__(self, obj: None, type: type | None = ..., /) -> property: ...
+    def __add__(self, other: AcceptCharsetValidHeader) -> AcceptCharsetValidHeader: ...
     @overload
-    def __get__(
-        self, obj: Any, type: type | None = ..., /
-    ) -> AcceptCharsetNoHeader | AcceptCharsetValidHeader | AcceptCharsetInvalidHeader: ...
+    def __add__(
+        self, other: AcceptCharsetInvalidHeader | AcceptCharsetNoHeader | Literal[""] | None
+    ) -> AcceptCharsetNoHeader: ...
     @overload
-    def __set__(self, obj: Any, value: str | None, /) -> None: ...
+    def __add__(
+        self,
+        other: (
+            _AnyAcceptCharsetHeader
+            | SupportsItems[str, float]
+            | _ListOrTuple[str | tuple[str, float] | list[Any]]
+            | _SupportsStr
+            | str
+            | None
+        ),
+    ) -> AcceptCharsetValidHeader | AcceptCharsetNoHeader: ...
     @overload
-    def __set__(
-        self, obj: Any, value: AcceptCharsetNoHeader | AcceptCharsetValidHeader | AcceptCharsetInvalidHeader, /
-    ) -> None: ...
+    def __radd__(self, other: AcceptCharsetValidHeader) -> AcceptCharsetValidHeader: ...
     @overload
-    def __set__(self, obj: Any, value: SupportsItems[str, float], /) -> None: ...
+    def __radd__(
+        self, other: AcceptCharsetInvalidHeader | AcceptCharsetNoHeader | Literal[""] | None
+    ) -> AcceptCharsetNoHeader: ...
     @overload
-    def __set__(self, obj: Any, value: _ListOrTuple[str | tuple[str, float] | list[Any]], /) -> None: ...
-    def __delete__(self, obj: Any, /) -> None: ...
+    def __radd__(
+        self,
+        other: (
+            _AnyAcceptCharsetHeader
+            | SupportsItems[str, float]
+            | _ListOrTuple[str | tuple[str, float] | list[Any]]
+            | _SupportsStr
+            | str
+            | None
+        ),
+    ) -> AcceptCharsetValidHeader | AcceptCharsetNoHeader: ...
 
+@overload
+def create_accept_charset_header(header_value: AcceptCharsetValidHeader | Literal[""]) -> AcceptCharsetValidHeader: ...
+@overload
+def create_accept_charset_header(header_value: AcceptCharsetInvalidHeader) -> AcceptCharsetInvalidHeader: ...
+@overload
+def create_accept_charset_header(header_value: AcceptCharsetNoHeader | None) -> AcceptCharsetNoHeader: ...
+@overload
+def create_accept_charset_header(header_value: str) -> AcceptCharsetValidHeader | AcceptCharsetInvalidHeader: ...
+@overload
+def create_accept_charset_header(header_value: _AnyAcceptCharsetHeader | str | None) -> _AnyAcceptCharsetHeader: ...
 def accept_charset_property() -> _AcceptCharsetProperty: ...
 
 class AcceptEncoding:
@@ -251,108 +382,139 @@ class AcceptEncodingValidHeader(AcceptEncoding):
     def parsed(self) -> list[tuple[str, float]]: ...
     def __init__(self, header_value: str) -> None: ...
     def copy(self) -> Self: ...
-    @overload
-    def __add__(self, other: str | None) -> Self: ...
-    @overload
-    def __add__(self, other: AcceptEncodingValidHeader | AcceptEncodingNoHeader | AcceptEncodingInvalidHeader) -> Self: ...
-    @overload
-    def __add__(self, other: SupportsItems[str, float]) -> Self: ...
-    @overload
-    def __add__(self, other: _ListOrTuple[str | tuple[str, float] | list[Any]]) -> Self: ...
+    def __add__(
+        self,
+        other: (
+            _AnyAcceptEncodingHeader
+            | SupportsItems[str, float]
+            | _ListOrTuple[str | tuple[str, float] | list[Any]]
+            | _SupportsStr
+            | str
+            | None
+        ),
+    ) -> Self: ...
     def __bool__(self) -> Literal[True]: ...
     def __contains__(self, offer: str) -> bool: ...
     def __iter__(self) -> Iterator[str]: ...
+    def __radd__(
+        self,
+        other: (
+            _AnyAcceptEncodingHeader
+            | SupportsItems[str, float]
+            | _ListOrTuple[str | tuple[str, float] | list[Any]]
+            | _SupportsStr
+            | str
+            | None
+        ),
+    ) -> Self: ...
+    def acceptable_offers(self, offers: Sequence[str]) -> list[tuple[str, float]]: ...
     @overload
-    def __radd__(self, other: str | None) -> Self: ...
-    @overload
-    def __radd__(self, other: AcceptEncodingValidHeader | AcceptEncodingNoHeader | AcceptEncodingInvalidHeader) -> Self: ...
-    @overload
-    def __radd__(self, other: SupportsItems[str, float]) -> Self: ...
-    @overload
-    def __radd__(self, other: _ListOrTuple[str | tuple[str, float] | list[Any]]) -> Self: ...
-    def acceptable_offers(self, offers: Iterable[str]) -> list[tuple[str, float]]: ...
-    @overload
-    def best_match(self, offers: Iterable[str], default_match: None = None) -> str | None: ...
+    def best_match(self, offers: Iterable[str | tuple[str, float] | list[Any]], default_match: None = None) -> str | None: ...
     @overload
-    def best_match(self, offers: Iterable[str], default_match: str) -> str: ...
+    def best_match(self, offers: Iterable[str | tuple[str, float] | list[Any]], default_match: str) -> str: ...
     def quality(self, offer: str) -> float | None: ...
 
 class _AcceptEncodingInvalidOrNoHeader(AcceptEncoding):
-    @property
-    def parsed(self) -> None: ...
     def __bool__(self) -> Literal[False]: ...
     def __contains__(self, offer: str) -> Literal[True]: ...
     def __iter__(self) -> Iterator[str]: ...
+    def acceptable_offers(self, offers: Iterable[str]) -> list[tuple[str, float]]: ...
     @overload
-    def __add__(self, other: None) -> AcceptEncodingNoHeader: ...
-    @overload
-    def __add__(self, other: str) -> AcceptEncodingValidHeader | AcceptEncodingNoHeader: ...
+    def best_match(self, offers: Iterable[str | tuple[str, float] | list[Any]], default_match: None = None) -> str | None: ...
     @overload
-    def __add__(self, other: AcceptEncodingValidHeader) -> AcceptEncodingValidHeader: ...
+    def best_match(self, offers: Iterable[str | tuple[str, float] | list[Any]], default_match: str) -> str: ...
+    def quality(self, offer: str) -> float | None: ...
+
+class AcceptEncodingNoHeader(_AcceptEncodingInvalidOrNoHeader):
+    @property
+    def header_value(self) -> None: ...
+    @property
+    def parsed(self) -> None: ...
+    def __init__(self) -> None: ...
+    def copy(self) -> Self: ...
     @overload
-    def __add__(self, other: AcceptEncodingNoHeader | AcceptEncodingInvalidHeader) -> AcceptEncodingNoHeader: ...
+    def __add__(self, other: AcceptEncodingValidHeader | Literal[""]) -> AcceptEncodingValidHeader: ...
     @overload
-    def __add__(self, other: SupportsItems[str, float]) -> AcceptEncodingValidHeader | AcceptEncodingNoHeader: ...
+    def __add__(self, other: AcceptEncodingInvalidHeader | AcceptEncodingNoHeader | None) -> Self: ...
     @overload
     def __add__(
-        self, other: _ListOrTuple[str | tuple[str, float] | list[Any]]
-    ) -> AcceptEncodingValidHeader | AcceptEncodingNoHeader: ...
-    @overload
-    def __radd__(self, other: None) -> AcceptEncodingNoHeader: ...
-    @overload
-    def __radd__(self, other: str) -> AcceptEncodingValidHeader | AcceptEncodingNoHeader: ...
-    @overload
-    def __radd__(self, other: AcceptEncodingValidHeader) -> AcceptEncodingValidHeader: ...
+        self,
+        other: (
+            _AnyAcceptEncodingHeader
+            | SupportsItems[str, float]
+            | _ListOrTuple[str | tuple[str, float] | list[Any]]
+            | _SupportsStr
+            | str
+            | None
+        ),
+    ) -> Self | AcceptEncodingValidHeader: ...
     @overload
-    def __radd__(self, other: AcceptEncodingNoHeader | AcceptEncodingInvalidHeader) -> AcceptEncodingNoHeader: ...
+    def __radd__(self, other: AcceptEncodingValidHeader | Literal[""]) -> AcceptEncodingValidHeader: ...
     @overload
-    def __radd__(self, other: SupportsItems[str, float]) -> AcceptEncodingValidHeader | AcceptEncodingNoHeader: ...
+    def __radd__(self, other: AcceptEncodingInvalidHeader | AcceptEncodingNoHeader | None) -> Self: ...
     @overload
     def __radd__(
-        self, other: _ListOrTuple[str | tuple[str, float] | list[Any]]
-    ) -> AcceptEncodingValidHeader | AcceptEncodingNoHeader: ...
-    def copy(self) -> Self: ...
-    def acceptable_offers(self, offers: Iterable[str]) -> list[tuple[str, float]]: ...
-    @overload
-    def best_match(self, offers: Iterable[str], default_match: None = None) -> str | None: ...
-    @overload
-    def best_match(self, offers: Iterable[str], default_match: str) -> str: ...
-    def quality(self, offer: str) -> float | None: ...
-
-class AcceptEncodingNoHeader(_AcceptEncodingInvalidOrNoHeader):
-    @property
-    def header_value(self) -> None: ...
-    def __init__(self) -> None: ...
+        self,
+        other: (
+            _AnyAcceptEncodingHeader
+            | SupportsItems[str, float]
+            | _ListOrTuple[str | tuple[str, float] | list[Any]]
+            | _SupportsStr
+            | str
+            | None
+        ),
+    ) -> Self | AcceptEncodingValidHeader: ...
 
 class AcceptEncodingInvalidHeader(_AcceptEncodingInvalidOrNoHeader):
     @property
     def header_value(self) -> str: ...
+    @property
+    def parsed(self) -> None: ...
     def __init__(self, header_value: str) -> None: ...
-
-@overload
-def create_accept_encoding_header(header_value: None) -> AcceptEncodingNoHeader: ...
-@overload
-def create_accept_encoding_header(header_value: str) -> AcceptEncodingValidHeader | AcceptEncodingInvalidHeader: ...
-
-class _AcceptEncodingProperty:
+    def copy(self) -> Self: ...
     @overload
-    def __get__(self, obj: None, type: type | None = ..., /) -> property: ...
+    def __add__(self, other: AcceptEncodingValidHeader | Literal[""]) -> AcceptEncodingValidHeader: ...
     @overload
-    def __get__(
-        self, obj: Any, type: type | None = ..., /
-    ) -> AcceptEncodingNoHeader | AcceptEncodingValidHeader | AcceptEncodingInvalidHeader: ...
+    def __add__(self, other: AcceptEncodingInvalidHeader | AcceptEncodingNoHeader | None) -> AcceptEncodingNoHeader: ...
     @overload
-    def __set__(self, obj: Any, value: str | None, /) -> None: ...
+    def __add__(
+        self,
+        other: (
+            _AnyAcceptEncodingHeader
+            | SupportsItems[str, float]
+            | _ListOrTuple[str | tuple[str, float] | list[Any]]
+            | _SupportsStr
+            | str
+            | None
+        ),
+    ) -> AcceptEncodingValidHeader | AcceptEncodingNoHeader: ...
     @overload
-    def __set__(
-        self, obj: Any, value: AcceptEncodingNoHeader | AcceptEncodingValidHeader | AcceptEncodingInvalidHeader, /
-    ) -> None: ...
+    def __radd__(self, other: AcceptEncodingValidHeader | Literal[""]) -> AcceptEncodingValidHeader: ...
     @overload
-    def __set__(self, obj: Any, value: SupportsItems[str, float], /) -> None: ...
+    def __radd__(self, other: AcceptEncodingInvalidHeader | AcceptEncodingNoHeader | None) -> AcceptEncodingNoHeader: ...
     @overload
-    def __set__(self, obj: Any, value: _ListOrTuple[str | tuple[str, float] | list[Any]], /) -> None: ...
-    def __delete__(self, obj: Any, /) -> None: ...
+    def __radd__(
+        self,
+        other: (
+            _AnyAcceptEncodingHeader
+            | SupportsItems[str, float]
+            | _ListOrTuple[str | tuple[str, float] | list[Any]]
+            | _SupportsStr
+            | str
+            | None
+        ),
+    ) -> AcceptEncodingValidHeader | AcceptEncodingNoHeader: ...
 
+@overload
+def create_accept_encoding_header(header_value: AcceptEncodingValidHeader | Literal[""]) -> AcceptEncodingValidHeader: ...
+@overload
+def create_accept_encoding_header(header_value: AcceptEncodingInvalidHeader) -> AcceptEncodingInvalidHeader: ...
+@overload
+def create_accept_encoding_header(header_value: AcceptEncodingNoHeader | None) -> AcceptEncodingNoHeader: ...
+@overload
+def create_accept_encoding_header(header_value: str) -> AcceptEncodingValidHeader | AcceptEncodingInvalidHeader: ...
+@overload
+def create_accept_encoding_header(header_value: _AnyAcceptEncodingHeader | str | None) -> _AnyAcceptEncodingHeader: ...
 def accept_encoding_property() -> _AcceptEncodingProperty: ...
 
 class AcceptLanguage:
@@ -360,144 +522,193 @@ class AcceptLanguage:
     def parse(cls, value: str) -> Iterator[tuple[str, float]]: ...
 
 class AcceptLanguageValidHeader(AcceptLanguage):
+    def __init__(self, header_value: str) -> None: ...
+    def copy(self) -> Self: ...
     @property
     def header_value(self) -> str: ...
     @property
     def parsed(self) -> list[tuple[str, float]]: ...
-    def __init__(self, header_value: str) -> None: ...
-    def copy(self) -> Self: ...
-    @overload
-    def __add__(self, other: str | None) -> Self: ...
-    @overload
-    def __add__(self, other: AcceptLanguageValidHeader | AcceptLanguageNoHeader | AcceptLanguageInvalidHeader) -> Self: ...
-    @overload
-    def __add__(self, other: SupportsItems[str, float]) -> Self: ...
-    @overload
-    def __add__(self, other: _ListOrTuple[str | tuple[str, float] | list[Any]]) -> Self: ...
+    def __add__(
+        self,
+        other: (
+            _AnyAcceptLanguageHeader
+            | SupportsItems[str, float]
+            | _ListOrTuple[str | tuple[str, float] | list[Any]]
+            | _SupportsStr
+            | str
+            | None
+        ),
+    ) -> Self: ...
     def __bool__(self) -> Literal[True]: ...
     def __contains__(self, offer: str) -> bool: ...
     def __iter__(self) -> Iterator[str]: ...
+    def __radd__(
+        self,
+        other: (
+            _AnyAcceptLanguageHeader
+            | SupportsItems[str, float]
+            | _ListOrTuple[str | tuple[str, float] | list[Any]]
+            | _SupportsStr
+            | str
+            | None
+        ),
+    ) -> Self: ...
+    def basic_filtering(self, language_tags: Sequence[str]) -> list[tuple[str, float]]: ...
     @overload
-    def __radd__(self, other: str | None) -> Self: ...
+    def best_match(self, offers: Iterable[str | tuple[str, float] | list[Any]], default_match: None = None) -> str | None: ...
     @overload
-    def __radd__(self, other: AcceptLanguageValidHeader | AcceptLanguageNoHeader | AcceptLanguageInvalidHeader) -> Self: ...
+    def best_match(self, offers: Iterable[str | tuple[str, float] | list[Any]], default_match: str) -> str: ...
     @overload
-    def __radd__(self, other: SupportsItems[str, float]) -> Self: ...
+    def lookup(
+        self, language_tags: Sequence[str], default_range: str | None, default_tag: str, default: None = None
+    ) -> str | None: ...
     @overload
-    def __radd__(self, other: _ListOrTuple[str | tuple[str, float] | list[Any]]) -> Self: ...
-    def basic_filtering(self, language_tags: Iterable[str]) -> list[tuple[str, float]]: ...
+    def lookup(
+        self, language_tags: Sequence[str], *, default_range: str | None = None, default_tag: str, default: None = None
+    ) -> str | None: ...
     @overload
-    def best_match(self, offers: Iterable[str], default_match: None = None) -> str | None: ...
+    def lookup(
+        self, language_tags: Sequence[str], default_range: str | None, default_tag: None, default: _T | Callable[[], _T]
+    ) -> _T | str | None: ...
     @overload
-    def best_match(self, offers: Iterable[str], default_match: str) -> str: ...
+    def lookup(
+        self, language_tags: Sequence[str], default_range: str | None, default_tag: str, default: _T | Callable[[], _T]
+    ) -> _T | str: ...
     @overload
     def lookup(
         self,
-        language_tags: Iterable[str],
+        language_tags: Sequence[str],
+        *,
         default_range: str | None = None,
-        default_tag: str = ...,
-        default: str | Callable[[], str | None] | None = None,
-    ) -> str | None: ...
+        default_tag: None = None,
+        default: _T | Callable[[], _T],
+    ) -> _T | str | None: ...
     @overload
     def lookup(
-        self,
-        language_tags: Iterable[str],
-        default_range: str | None = None,
-        default_tag: str | None = None,
-        default: str | Callable[[], str | None] = ...,
-    ) -> str | None: ...
+        self, language_tags: Sequence[str], *, default_range: str | None = None, default_tag: str, default: _T | Callable[[], _T]
+    ) -> _T | str: ...
     def quality(self, offer: str) -> float | None: ...
 
 class _AcceptLanguageInvalidOrNoHeader(AcceptLanguage):
-    @property
-    def parsed(self) -> None: ...
     def __bool__(self) -> Literal[False]: ...
     def __contains__(self, offer: str) -> Literal[True]: ...
     def __iter__(self) -> Iterator[str]: ...
-    @overload
-    def __add__(self, other: None) -> AcceptLanguageNoHeader: ...
-    @overload
-    def __add__(self, other: str) -> AcceptLanguageValidHeader | AcceptLanguageNoHeader: ...
-    @overload
-    def __add__(self, other: AcceptLanguageValidHeader) -> AcceptLanguageValidHeader: ...
-    @overload
-    def __add__(self, other: AcceptLanguageNoHeader | AcceptLanguageInvalidHeader) -> AcceptLanguageNoHeader: ...
-    @overload
-    def __add__(self, other: SupportsItems[str, float]) -> AcceptLanguageValidHeader | AcceptLanguageNoHeader: ...
-    @overload
-    def __add__(
-        self, other: _ListOrTuple[str | tuple[str, float] | list[Any]]
-    ) -> AcceptLanguageValidHeader | AcceptLanguageNoHeader: ...
-    @overload
-    def __radd__(self, other: None) -> AcceptLanguageNoHeader: ...
-    @overload
-    def __radd__(self, other: str) -> AcceptLanguageValidHeader | AcceptLanguageNoHeader: ...
-    @overload
-    def __radd__(self, other: AcceptLanguageValidHeader) -> AcceptLanguageValidHeader: ...
-    @overload
-    def __radd__(self, other: AcceptLanguageNoHeader | AcceptLanguageInvalidHeader) -> AcceptLanguageNoHeader: ...
-    @overload
-    def __radd__(self, other: SupportsItems[str, float]) -> AcceptLanguageValidHeader | AcceptLanguageNoHeader: ...
-    @overload
-    def __radd__(
-        self, other: _ListOrTuple[str | tuple[str, float] | list[Any]]
-    ) -> AcceptLanguageValidHeader | AcceptLanguageNoHeader: ...
-    def copy(self) -> Self: ...
     def basic_filtering(self, language_tags: Iterable[str]) -> list[tuple[str, float]]: ...
     @overload
-    def best_match(self, offers: Iterable[str], default_match: None = None) -> str | None: ...
+    def best_match(self, offers: Iterable[str | tuple[str, float] | list[Any]], default_match: None = None) -> str | None: ...
+    @overload
+    def best_match(self, offers: Iterable[str | tuple[str, float] | list[Any]], default_match: str) -> str: ...
     @overload
-    def best_match(self, offers: Iterable[str], default_match: str) -> str: ...
+    def lookup(self, language_tags: object, default_range: object, default_tag: str, default: object = None) -> str: ...
     @overload
     def lookup(
-        self,
-        language_tags: Iterable[str],
-        default_range: str | None = None,
-        default_tag: str = ...,
-        default: str | Callable[[], str | None] | None = None,
-    ) -> str | None: ...
+        self, language_tags: object = None, *, default_range: object = None, default_tag: str, default: object = None
+    ) -> str: ...
+    @overload
+    def lookup(self, language_tags: object, default_range: object, default_tag: None, default: _T | Callable[[], _T]) -> _T: ...
     @overload
     def lookup(
         self,
-        language_tags: Iterable[str],
-        default_range: str | None = None,
-        default_tag: str | None = None,
-        default: str | Callable[[], str | None] = ...,
-    ) -> str | None: ...
+        language_tags: object = None,
+        *,
+        default_range: object = None,
+        default_tag: None = None,
+        default: _T | Callable[[], _T],
+    ) -> _T: ...
     def quality(self, offer: str) -> float | None: ...
 
 class AcceptLanguageNoHeader(_AcceptLanguageInvalidOrNoHeader):
     def __init__(self) -> None: ...
+    def copy(self) -> Self: ...
     @property
     def header_value(self) -> None: ...
+    @property
+    def parsed(self) -> None: ...
+    @overload
+    def __add__(self, other: AcceptLanguageValidHeader) -> AcceptLanguageValidHeader: ...
+    @overload
+    def __add__(self, other: AcceptLanguageInvalidHeader | AcceptLanguageNoHeader | Literal[""] | None) -> Self: ...
+    @overload
+    def __add__(
+        self,
+        other: (
+            _AnyAcceptLanguageHeader
+            | SupportsItems[str, float]
+            | _ListOrTuple[str | tuple[str, float] | list[Any]]
+            | _SupportsStr
+            | str
+            | None
+        ),
+    ) -> Self | AcceptLanguageValidHeader: ...
+    @overload
+    def __radd__(self, other: AcceptLanguageValidHeader) -> AcceptLanguageValidHeader: ...
+    @overload
+    def __radd__(self, other: AcceptLanguageInvalidHeader | AcceptLanguageNoHeader | Literal[""] | None) -> Self: ...
+    @overload
+    def __radd__(
+        self,
+        other: (
+            _AnyAcceptLanguageHeader
+            | SupportsItems[str, float]
+            | _ListOrTuple[str | tuple[str, float] | list[Any]]
+            | _SupportsStr
+            | str
+            | None
+        ),
+    ) -> Self | AcceptLanguageValidHeader: ...
 
 class AcceptLanguageInvalidHeader(_AcceptLanguageInvalidOrNoHeader):
     def __init__(self, header_value: str) -> None: ...
+    def copy(self) -> Self: ...
     @property
     def header_value(self) -> str: ...
-
-@overload
-def create_accept_language_header(header_value: None) -> AcceptLanguageNoHeader: ...
-@overload
-def create_accept_language_header(header_value: str) -> AcceptLanguageValidHeader | AcceptLanguageInvalidHeader: ...
-
-class _AcceptLanguageProperty:
+    @property
+    def parsed(self) -> None: ...
     @overload
-    def __get__(self, obj: None, type: type | None = ..., /) -> property: ...
+    def __add__(self, other: AcceptLanguageValidHeader) -> AcceptLanguageValidHeader: ...
     @overload
-    def __get__(
-        self, obj: Any, type: type | None = ..., /
-    ) -> AcceptLanguageNoHeader | AcceptLanguageValidHeader | AcceptLanguageInvalidHeader: ...
+    def __add__(
+        self, other: AcceptLanguageInvalidHeader | AcceptLanguageNoHeader | Literal[""] | None
+    ) -> AcceptLanguageNoHeader: ...
     @overload
-    def __set__(self, obj: Any, value: str | None, /) -> None: ...
+    def __add__(
+        self,
+        other: (
+            _AnyAcceptLanguageHeader
+            | SupportsItems[str, float]
+            | _ListOrTuple[str | tuple[str, float] | list[Any]]
+            | _SupportsStr
+            | str
+            | None
+        ),
+    ) -> AcceptLanguageValidHeader | AcceptLanguageNoHeader: ...
     @overload
-    def __set__(
-        self, obj: Any, value: AcceptLanguageNoHeader | AcceptLanguageValidHeader | AcceptLanguageInvalidHeader, /
-    ) -> None: ...
+    def __radd__(self, other: AcceptLanguageValidHeader) -> AcceptLanguageValidHeader: ...
     @overload
-    def __set__(self, obj: Any, value: SupportsItems[str, float], /) -> None: ...
+    def __radd__(
+        self, other: AcceptLanguageInvalidHeader | AcceptLanguageNoHeader | Literal[""] | None
+    ) -> AcceptLanguageNoHeader: ...
     @overload
-    def __set__(self, obj: Any, value: _ListOrTuple[str | tuple[str, float] | list[Any]], /) -> None: ...
-    def __delete__(self, obj: Any, /) -> None: ...
+    def __radd__(
+        self,
+        other: (
+            _AnyAcceptLanguageHeader
+            | SupportsItems[str, float]
+            | _ListOrTuple[str | tuple[str, float] | list[Any]]
+            | _SupportsStr
+            | str
+            | None
+        ),
+    ) -> AcceptLanguageValidHeader | AcceptLanguageNoHeader: ...
 
+@overload
+def create_accept_language_header(header_value: AcceptLanguageValidHeader | Literal[""]) -> AcceptLanguageValidHeader: ...
+@overload
+def create_accept_language_header(header_value: AcceptLanguageNoHeader | None) -> AcceptLanguageNoHeader: ...
+@overload
+def create_accept_language_header(header_value: AcceptLanguageInvalidHeader) -> AcceptLanguageInvalidHeader: ...
+@overload
+def create_accept_language_header(header_value: str) -> AcceptLanguageValidHeader | AcceptLanguageInvalidHeader: ...
+@overload
+def create_accept_language_header(header_value: _AnyAcceptLanguageHeader | str | None) -> _AnyAcceptLanguageHeader: ...
 def accept_language_property() -> _AcceptLanguageProperty: ...