layermap 0.1.0

package/analyzers/project-map-python/typeshed/stdlib/venv/__init__.pyi

@@ -0,0 +1,86 @@
+import logging
+import sys
+from _typeshed import StrOrBytesPath
+from collections.abc import Iterable, Sequence
+from types import SimpleNamespace
+from typing import Final
+
+logger: logging.Logger
+
+CORE_VENV_DEPS: Final[tuple[str, ...]]
+
+class EnvBuilder:
+    system_site_packages: bool
+    clear: bool
+    symlinks: bool
+    upgrade: bool
+    with_pip: bool
+    prompt: str | None
+
+    if sys.version_info >= (3, 13):
+        def __init__(
+            self,
+            system_site_packages: bool = False,
+            clear: bool = False,
+            symlinks: bool = False,
+            upgrade: bool = False,
+            with_pip: bool = False,
+            prompt: str | None = None,
+            upgrade_deps: bool = False,
+            *,
+            scm_ignore_files: Iterable[str] = ...,
+        ) -> None: ...
+    else:
+        def __init__(
+            self,
+            system_site_packages: bool = False,
+            clear: bool = False,
+            symlinks: bool = False,
+            upgrade: bool = False,
+            with_pip: bool = False,
+            prompt: str | None = None,
+            upgrade_deps: bool = False,
+        ) -> None: ...
+
+    def create(self, env_dir: StrOrBytesPath) -> None: ...
+    def clear_directory(self, path: StrOrBytesPath) -> None: ...  # undocumented
+    def ensure_directories(self, env_dir: StrOrBytesPath) -> SimpleNamespace: ...
+    def create_configuration(self, context: SimpleNamespace) -> None: ...
+    def symlink_or_copy(
+        self, src: StrOrBytesPath, dst: StrOrBytesPath, relative_symlinks_ok: bool = False
+    ) -> None: ...  # undocumented
+    def setup_python(self, context: SimpleNamespace) -> None: ...
+    def _setup_pip(self, context: SimpleNamespace) -> None: ...  # undocumented
+    def setup_scripts(self, context: SimpleNamespace) -> None: ...
+    def post_setup(self, context: SimpleNamespace) -> None: ...
+    def replace_variables(self, text: str, context: SimpleNamespace) -> str: ...  # undocumented
+    def install_scripts(self, context: SimpleNamespace, path: str) -> None: ...
+    def upgrade_dependencies(self, context: SimpleNamespace) -> None: ...
+    if sys.version_info >= (3, 13):
+        def create_git_ignore_file(self, context: SimpleNamespace) -> None: ...
+
+if sys.version_info >= (3, 13):
+    def create(
+        env_dir: StrOrBytesPath,
+        system_site_packages: bool = False,
+        clear: bool = False,
+        symlinks: bool = False,
+        with_pip: bool = False,
+        prompt: str | None = None,
+        upgrade_deps: bool = False,
+        *,
+        scm_ignore_files: Iterable[str] = ...,
+    ) -> None: ...
+
+else:
+    def create(
+        env_dir: StrOrBytesPath,
+        system_site_packages: bool = False,
+        clear: bool = False,
+        symlinks: bool = False,
+        with_pip: bool = False,
+        prompt: str | None = None,
+        upgrade_deps: bool = False,
+    ) -> None: ...
+
+def main(args: Sequence[str] | None = None) -> None: ...

package/analyzers/project-map-python/typeshed/stdlib/warnings.pyi

@@ -0,0 +1,146 @@
+import re
+import sys
+from _warnings import warn as warn, warn_explicit as warn_explicit
+from collections.abc import Sequence
+from types import ModuleType, TracebackType
+from typing import Any, Generic, Literal, TextIO, TypeAlias, overload
+from typing_extensions import LiteralString, TypeVar
+
+__all__ = [
+    "warn",
+    "warn_explicit",
+    "showwarning",
+    "formatwarning",
+    "filterwarnings",
+    "simplefilter",
+    "resetwarnings",
+    "catch_warnings",
+]
+
+if sys.version_info >= (3, 13):
+    __all__ += ["deprecated"]
+
+_T = TypeVar("_T")
+_W_co = TypeVar("_W_co", bound=list[WarningMessage] | None, default=list[WarningMessage] | None, covariant=True)
+
+if sys.version_info >= (3, 14):
+    _ActionKind: TypeAlias = Literal["default", "error", "ignore", "always", "module", "once"]
+else:
+    _ActionKind: TypeAlias = Literal["default", "error", "ignore", "always", "all", "module", "once"]
+filters: Sequence[
+    tuple[str, re.Pattern[str] | None, type[Warning] | tuple[type[Warning], ...], re.Pattern[str] | None, int]
+]  # undocumented, do not mutate
+
+def showwarning(
+    message: Warning | str,
+    category: type[Warning],
+    filename: str,
+    lineno: int,
+    file: TextIO | None = None,
+    line: str | None = None,
+) -> None: ...
+def formatwarning(
+    message: Warning | str, category: type[Warning], filename: str, lineno: int, line: str | None = None
+) -> str: ...
+def filterwarnings(
+    action: _ActionKind, message: str = "", category: type[Warning] = ..., module: str = "", lineno: int = 0, append: bool = False
+) -> None: ...
+def simplefilter(
+    action: _ActionKind, category: type[Warning] | tuple[type[Warning], ...] = ..., lineno: int = 0, append: bool = False
+) -> None: ...
+def resetwarnings() -> None: ...
+
+class _OptionError(Exception): ...
+
+class WarningMessage:
+    message: Warning | str
+    category: type[Warning]
+    filename: str
+    lineno: int
+    file: TextIO | None
+    line: str | None
+    source: Any | None
+    if sys.version_info >= (3, 15):
+        module: str | None
+    if sys.version_info >= (3, 15):
+        def __init__(
+            self,
+            message: Warning | str,
+            category: type[Warning],
+            filename: str,
+            lineno: int,
+            file: TextIO | None = None,
+            line: str | None = None,
+            source: Any | None = None,
+            module: str | None = None,
+        ) -> None: ...
+
+    else:
+        def __init__(
+            self,
+            message: Warning | str,
+            category: type[Warning],
+            filename: str,
+            lineno: int,
+            file: TextIO | None = None,
+            line: str | None = None,
+            source: Any | None = None,
+        ) -> None: ...
+
+class catch_warnings(Generic[_W_co]):
+    if sys.version_info >= (3, 11):
+        @overload
+        def __init__(
+            self: catch_warnings[None],
+            *,
+            record: Literal[False] = False,
+            module: ModuleType | None = None,
+            action: _ActionKind | None = None,
+            category: type[Warning] | tuple[type[Warning], ...] = ...,
+            lineno: int = 0,
+            append: bool = False,
+        ) -> None: ...
+        @overload
+        def __init__(
+            self: catch_warnings[list[WarningMessage]],
+            *,
+            record: Literal[True],
+            module: ModuleType | None = None,
+            action: _ActionKind | None = None,
+            category: type[Warning] | tuple[type[Warning], ...] = ...,
+            lineno: int = 0,
+            append: bool = False,
+        ) -> None: ...
+        @overload
+        def __init__(
+            self,
+            *,
+            record: bool,
+            module: ModuleType | None = None,
+            action: _ActionKind | None = None,
+            category: type[Warning] | tuple[type[Warning], ...] = ...,
+            lineno: int = 0,
+            append: bool = False,
+        ) -> None: ...
+    else:
+        @overload
+        def __init__(self: catch_warnings[None], *, record: Literal[False] = False, module: ModuleType | None = None) -> None: ...
+        @overload
+        def __init__(
+            self: catch_warnings[list[WarningMessage]], *, record: Literal[True], module: ModuleType | None = None
+        ) -> None: ...
+        @overload
+        def __init__(self, *, record: bool, module: ModuleType | None = None) -> None: ...
+
+    def __enter__(self) -> _W_co: ...
+    def __exit__(
+        self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: TracebackType | None
+    ) -> None: ...
+
+if sys.version_info >= (3, 13):
+    class deprecated:
+        message: LiteralString
+        category: type[Warning] | None
+        stacklevel: int
+        def __init__(self, message: LiteralString, /, *, category: type[Warning] | None = ..., stacklevel: int = 1) -> None: ...
+        def __call__(self, arg: _T, /) -> _T: ...

package/analyzers/project-map-python/typeshed/stdlib/wave.pyi

@@ -0,0 +1,105 @@
+import sys
+from _typeshed import ReadableBuffer, StrOrBytesPath, Unused
+from typing import IO, Any, BinaryIO, Final, Literal, NamedTuple, NoReturn, TypeAlias, overload
+from typing_extensions import Self, deprecated
+
+__all__ = ["open", "Error", "Wave_read", "Wave_write"]
+if sys.version_info >= (3, 15):
+    __all__ += ["WAVE_FORMAT_PCM", "WAVE_FORMAT_IEEE_FLOAT", "WAVE_FORMAT_EXTENSIBLE"]
+
+if sys.version_info >= (3, 15):
+    _File: TypeAlias = StrOrBytesPath | IO[bytes]
+else:
+    _File: TypeAlias = str | IO[bytes]
+
+class Error(Exception): ...
+
+WAVE_FORMAT_PCM: Final = 0x0001
+if sys.version_info >= (3, 15):
+    WAVE_FORMAT_IEEE_FLOAT: Final = 0x0003
+    WAVE_FORMAT_EXTENSIBLE: Final = 0xFFFE
+
+class _wave_params(NamedTuple):
+    nchannels: int
+    sampwidth: int
+    framerate: int
+    nframes: int
+    comptype: str
+    compname: str
+
+class Wave_read:
+    def __init__(self, f: _File) -> None: ...
+    def __enter__(self) -> Self: ...
+    def __exit__(self, *args: Unused) -> None: ...
+    def __del__(self) -> None: ...
+    def getfp(self) -> BinaryIO | None: ...
+    def rewind(self) -> None: ...
+    def close(self) -> None: ...
+    def tell(self) -> int: ...
+    def getnchannels(self) -> int: ...
+    def getnframes(self) -> int: ...
+    def getsampwidth(self) -> int: ...
+    def getframerate(self) -> int: ...
+    if sys.version_info >= (3, 15):
+        def getformat(self) -> int: ...
+
+    def getcomptype(self) -> str: ...
+    def getcompname(self) -> str: ...
+    def getparams(self) -> _wave_params: ...
+    if sys.version_info < (3, 15):
+        @deprecated("Deprecated since Python 3.13; will be removed in Python 3.15.")
+        def getmarkers(self) -> None: ...
+        @deprecated("Deprecated since Python 3.13; will be removed in Python 3.15.")
+        def getmark(self, id: Any) -> NoReturn: ...
+
+    def setpos(self, pos: int) -> None: ...
+    def readframes(self, nframes: int) -> bytes: ...
+
+class Wave_write:
+    def __init__(self, f: _File) -> None: ...
+    def __enter__(self) -> Self: ...
+    def __exit__(self, *args: Unused) -> None: ...
+    def __del__(self) -> None: ...
+    def setnchannels(self, nchannels: int) -> None: ...
+    def getnchannels(self) -> int: ...
+    def setsampwidth(self, sampwidth: int) -> None: ...
+    def getsampwidth(self) -> int: ...
+    def setframerate(self, framerate: float) -> None: ...
+    def getframerate(self) -> int: ...
+    if sys.version_info >= (3, 15):
+        def setformat(self, format: int) -> None: ...
+        def getformat(self) -> int: ...
+
+    def setnframes(self, nframes: int) -> None: ...
+    def getnframes(self) -> int: ...
+    def setcomptype(self, comptype: str, compname: str) -> None: ...
+    def getcomptype(self) -> str: ...
+    def getcompname(self) -> str: ...
+    if sys.version_info >= (3, 15):
+        def setparams(
+            self, params: _wave_params | tuple[int, int, int, int, str, str] | tuple[int, int, int, int, str, str, int]
+        ) -> None: ...
+    else:
+        def setparams(self, params: _wave_params | tuple[int, int, int, int, str, str]) -> None: ...
+
+    def getparams(self) -> _wave_params: ...
+
+    if sys.version_info < (3, 15):
+        @deprecated("Deprecated since Python 3.13; will be removed in Python 3.15.")
+        def setmark(self, id: Any, pos: Any, name: Any) -> NoReturn: ...
+        @deprecated("Deprecated since Python 3.13; will be removed in Python 3.15.")
+        def getmark(self, id: Any) -> NoReturn: ...
+        @deprecated("Deprecated since Python 3.13; will be removed in Python 3.15.")
+        def getmarkers(self) -> None: ...
+
+    def tell(self) -> int: ...
+    def writeframesraw(self, data: ReadableBuffer) -> None: ...
+    def writeframes(self, data: ReadableBuffer) -> None: ...
+    def close(self) -> None: ...
+
+@overload
+def open(f: _File, mode: Literal["r", "rb"]) -> Wave_read: ...
+@overload
+def open(f: _File, mode: Literal["w", "wb"]) -> Wave_write: ...
+@overload
+def open(f: _File, mode: str | None = None) -> Any: ...

package/analyzers/project-map-python/typeshed/stdlib/weakref.pyi

@@ -0,0 +1,213 @@
+from _typeshed import SupportsKeysAndGetItem
+from _weakref import getweakrefcount as getweakrefcount, getweakrefs as getweakrefs, proxy as proxy
+from _weakrefset import WeakSet as WeakSet
+from collections.abc import Callable, Iterable, Iterator, Mapping, MutableMapping
+from types import GenericAlias
+from typing import Any, ClassVar, Generic, ParamSpec, TypeVar, final, overload
+from typing_extensions import Self, disjoint_base
+
+__all__ = [
+    "ref",
+    "proxy",
+    "getweakrefcount",
+    "getweakrefs",
+    "WeakKeyDictionary",
+    "ReferenceType",
+    "ProxyType",
+    "CallableProxyType",
+    "ProxyTypes",
+    "WeakValueDictionary",
+    "WeakSet",
+    "WeakMethod",
+    "finalize",
+]
+
+_T = TypeVar("_T")
+_T1 = TypeVar("_T1")
+_T2 = TypeVar("_T2")
+_KT = TypeVar("_KT")
+_VT = TypeVar("_VT")
+_CallableT = TypeVar("_CallableT", bound=Callable[..., Any])
+_P = ParamSpec("_P")
+
+ProxyTypes: tuple[type[Any], ...]
+
+# These classes are implemented in C and imported from _weakref at runtime. However,
+# they consider themselves to live in the weakref module for sys.version_info >= (3, 11),
+# so defining their stubs here means we match their __module__ value.
+# Prior to 3.11 they did not declare a module for themselves and ended up looking like they
+# came from the builtin module at runtime, which was just wrong, and we won't attempt to
+# duplicate that.
+
+@final
+class CallableProxyType(Generic[_CallableT]):  # "weakcallableproxy"
+    def __eq__(self, value: object, /) -> bool: ...
+    def __getattr__(self, attr: str) -> Any: ...
+    __call__: _CallableT
+    __hash__: ClassVar[None]  # type: ignore[assignment]
+
+@final
+class ProxyType(Generic[_T]):  # "weakproxy"
+    def __eq__(self, value: object, /) -> bool: ...
+    def __getattr__(self, attr: str) -> Any: ...
+    __hash__: ClassVar[None]  # type: ignore[assignment]
+
+@disjoint_base
+class ReferenceType(Generic[_T]):  # "weakref"
+    __callback__: Callable[[Self], Any]
+    def __new__(cls, o: _T, callback: Callable[[Self], Any] | None = ..., /) -> Self: ...
+    def __call__(self) -> _T | None: ...
+    def __eq__(self, value: object, /) -> bool: ...
+    def __hash__(self) -> int: ...
+    def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
+
+ref = ReferenceType
+
+# everything below here is implemented in weakref.py
+
+class WeakMethod(ref[_CallableT]):
+    __slots__ = ("_func_ref", "_meth_type", "_alive", "__weakref__")
+    def __new__(cls, meth: _CallableT, callback: Callable[[Self], Any] | None = None) -> Self: ...
+    def __call__(self) -> _CallableT | None: ...
+    def __eq__(self, other: object) -> bool: ...
+    def __ne__(self, other: object) -> bool: ...
+    def __hash__(self) -> int: ...
+
+class WeakValueDictionary(MutableMapping[_KT, _VT]):
+    @overload
+    def __init__(self) -> None: ...
+    @overload
+    def __init__(
+        self: WeakValueDictionary[_KT, _VT],  # pyright: ignore[reportInvalidTypeVarUse]  #11780
+        other: Mapping[_KT, _VT] | Iterable[tuple[_KT, _VT]],
+        /,
+    ) -> None: ...
+    @overload
+    def __init__(
+        self: WeakValueDictionary[str, _VT],  # pyright: ignore[reportInvalidTypeVarUse]  #11780
+        other: Mapping[str, _VT] | Iterable[tuple[str, _VT]] = (),
+        /,
+        **kwargs: _VT,
+    ) -> None: ...
+
+    def __len__(self) -> int: ...
+    def __getitem__(self, key: _KT) -> _VT: ...
+    def __setitem__(self, key: _KT, value: _VT) -> None: ...
+    def __delitem__(self, key: _KT) -> None: ...
+    def __contains__(self, key: object) -> bool: ...
+    def __iter__(self) -> Iterator[_KT]: ...
+    def copy(self) -> WeakValueDictionary[_KT, _VT]: ...
+    __copy__ = copy
+    def __deepcopy__(self, memo: Any) -> Self: ...
+
+    @overload
+    def get(self, key: _KT, default: None = None) -> _VT | None: ...
+    @overload
+    def get(self, key: _KT, default: _VT) -> _VT: ...
+    @overload
+    def get(self, key: _KT, default: _T) -> _VT | _T: ...
+
+    # These are incompatible with Mapping
+    def keys(self) -> Iterator[_KT]: ...  # type: ignore[override]
+    def values(self) -> Iterator[_VT]: ...  # type: ignore[override]
+    def items(self) -> Iterator[tuple[_KT, _VT]]: ...  # type: ignore[override]
+    def itervaluerefs(self) -> Iterator[KeyedRef[_KT, _VT]]: ...
+    def valuerefs(self) -> list[KeyedRef[_KT, _VT]]: ...
+    def setdefault(self, key: _KT, default: _VT) -> _VT: ...
+
+    @overload
+    def pop(self, key: _KT) -> _VT: ...
+    @overload
+    def pop(self, key: _KT, default: _VT) -> _VT: ...
+    @overload
+    def pop(self, key: _KT, default: _T) -> _VT | _T: ...
+
+    @overload
+    def update(self, other: SupportsKeysAndGetItem[_KT, _VT], /, **kwargs: _VT) -> None: ...
+    @overload
+    def update(self, other: Iterable[tuple[_KT, _VT]], /, **kwargs: _VT) -> None: ...
+    @overload
+    def update(self, other: None = None, /, **kwargs: _VT) -> None: ...
+
+    def __or__(self, other: Mapping[_T1, _T2]) -> WeakValueDictionary[_KT | _T1, _VT | _T2]: ...
+    def __ror__(self, other: Mapping[_T1, _T2]) -> WeakValueDictionary[_KT | _T1, _VT | _T2]: ...
+
+    # WeakValueDictionary.__ior__ should be kept roughly in line with MutableMapping.update()
+    @overload  # type: ignore[misc]
+    def __ior__(self, other: SupportsKeysAndGetItem[_KT, _VT]) -> Self: ...
+    @overload
+    def __ior__(self, other: Iterable[tuple[_KT, _VT]]) -> Self: ...
+
+class KeyedRef(ref[_T], Generic[_KT, _T]):
+    __slots__ = ("key",)
+    key: _KT
+    def __new__(type, ob: _T, callback: Callable[[Self], Any], key: _KT) -> Self: ...
+    def __init__(self, ob: _T, callback: Callable[[Self], Any], key: _KT) -> None: ...
+
+class WeakKeyDictionary(MutableMapping[_KT, _VT]):
+    @overload
+    def __init__(self, dict: None = None) -> None: ...
+    @overload
+    def __init__(self, dict: Mapping[_KT, _VT] | Iterable[tuple[_KT, _VT]]) -> None: ...
+
+    def __len__(self) -> int: ...
+    def __getitem__(self, key: _KT) -> _VT: ...
+    def __setitem__(self, key: _KT, value: _VT) -> None: ...
+    def __delitem__(self, key: _KT) -> None: ...
+    def __contains__(self, key: object) -> bool: ...
+    def __iter__(self) -> Iterator[_KT]: ...
+    def copy(self) -> WeakKeyDictionary[_KT, _VT]: ...
+    __copy__ = copy
+    def __deepcopy__(self, memo: Any) -> Self: ...
+
+    @overload
+    def get(self, key: _KT, default: None = None) -> _VT | None: ...
+    @overload
+    def get(self, key: _KT, default: _VT) -> _VT: ...
+    @overload
+    def get(self, key: _KT, default: _T) -> _VT | _T: ...
+
+    # These are incompatible with Mapping
+    def keys(self) -> Iterator[_KT]: ...  # type: ignore[override]
+    def values(self) -> Iterator[_VT]: ...  # type: ignore[override]
+    def items(self) -> Iterator[tuple[_KT, _VT]]: ...  # type: ignore[override]
+    def keyrefs(self) -> list[ref[_KT]]: ...
+
+    # Keep WeakKeyDictionary.setdefault in line with MutableMapping.setdefault, modulo positional-only differences
+    @overload
+    def setdefault(self: WeakKeyDictionary[_KT, _VT | None], key: _KT, default: None = None) -> _VT: ...
+    @overload
+    def setdefault(self, key: _KT, default: _VT) -> _VT: ...
+
+    @overload
+    def pop(self, key: _KT) -> _VT: ...
+    @overload
+    def pop(self, key: _KT, default: _VT) -> _VT: ...
+    @overload
+    def pop(self, key: _KT, default: _T) -> _VT | _T: ...
+
+    @overload
+    def update(self, dict: SupportsKeysAndGetItem[_KT, _VT], /, **kwargs: _VT) -> None: ...
+    @overload
+    def update(self, dict: Iterable[tuple[_KT, _VT]], /, **kwargs: _VT) -> None: ...
+    @overload
+    def update(self, dict: None = None, /, **kwargs: _VT) -> None: ...
+
+    def __or__(self, other: Mapping[_T1, _T2]) -> WeakKeyDictionary[_KT | _T1, _VT | _T2]: ...
+    def __ror__(self, other: Mapping[_T1, _T2]) -> WeakKeyDictionary[_KT | _T1, _VT | _T2]: ...
+
+    # WeakKeyDictionary.__ior__ should be kept roughly in line with MutableMapping.update()
+    @overload  # type: ignore[misc]
+    def __ior__(self, other: SupportsKeysAndGetItem[_KT, _VT]) -> Self: ...
+    @overload
+    def __ior__(self, other: Iterable[tuple[_KT, _VT]]) -> Self: ...
+
+class finalize(Generic[_P, _T]):
+    __slots__ = ()
+    def __init__(self, obj: _T, func: Callable[_P, Any], /, *args: _P.args, **kwargs: _P.kwargs) -> None: ...
+    def __call__(self, _: Any = None) -> Any | None: ...
+    def detach(self) -> tuple[_T, Callable[_P, Any], tuple[Any, ...], dict[str, Any]] | None: ...
+    def peek(self) -> tuple[_T, Callable[_P, Any], tuple[Any, ...], dict[str, Any]] | None: ...
+    @property
+    def alive(self) -> bool: ...
+    atexit: bool

package/analyzers/project-map-python/typeshed/stdlib/webbrowser.pyi

@@ -0,0 +1,78 @@
+import sys
+from abc import abstractmethod
+from collections.abc import Callable, Sequence
+from typing import Literal
+from typing_extensions import deprecated
+
+__all__ = ["Error", "open", "open_new", "open_new_tab", "get", "register"]
+
+class Error(Exception): ...
+
+def register(
+    name: str, klass: Callable[[], BaseBrowser] | None, instance: BaseBrowser | None = None, *, preferred: bool = False
+) -> None: ...
+def get(using: str | None = None) -> BaseBrowser: ...
+def open(url: str, new: int = 0, autoraise: bool = True) -> bool: ...
+def open_new(url: str) -> bool: ...
+def open_new_tab(url: str) -> bool: ...
+
+class BaseBrowser:
+    args: list[str]
+    name: str
+    basename: str
+    def __init__(self, name: str = "") -> None: ...
+    @abstractmethod
+    def open(self, url: str, new: int = 0, autoraise: bool = True) -> bool: ...
+    def open_new(self, url: str) -> bool: ...
+    def open_new_tab(self, url: str) -> bool: ...
+
+class GenericBrowser(BaseBrowser):
+    def __init__(self, name: str | Sequence[str]) -> None: ...
+    def open(self, url: str, new: int = 0, autoraise: bool = True) -> bool: ...
+
+class BackgroundBrowser(GenericBrowser): ...
+
+class UnixBrowser(BaseBrowser):
+    def open(self, url: str, new: Literal[0, 1, 2] = 0, autoraise: bool = True) -> bool: ...  # type: ignore[override]
+    raise_opts: list[str] | None
+    background: bool
+    redirect_stdout: bool
+    remote_args: list[str]
+    remote_action: str
+    remote_action_newwin: str
+    remote_action_newtab: str
+
+class Mozilla(UnixBrowser): ...
+
+if sys.version_info < (3, 12):
+    class Galeon(UnixBrowser):
+        raise_opts: list[str]
+
+    class Grail(BaseBrowser):
+        def open(self, url: str, new: int = 0, autoraise: bool = True) -> bool: ...
+
+class Chrome(UnixBrowser): ...
+class Opera(UnixBrowser): ...
+class Elinks(UnixBrowser): ...
+
+class Konqueror(BaseBrowser):
+    def open(self, url: str, new: int = 0, autoraise: bool = True) -> bool: ...
+
+if sys.platform == "win32":
+    class WindowsDefault(BaseBrowser):
+        def open(self, url: str, new: int = 0, autoraise: bool = True) -> bool: ...
+
+if sys.platform == "darwin":
+    if sys.version_info < (3, 13):
+        @deprecated("Deprecated since Python 3.11; removed in Python 3.13.")
+        class MacOSX(BaseBrowser):
+            def __init__(self, name: str) -> None: ...
+            def open(self, url: str, new: int = 0, autoraise: bool = True) -> bool: ...
+
+    class MacOSXOSAScript(BaseBrowser):  # In runtime this class does not have `name` and `basename`
+        if sys.version_info >= (3, 11):
+            def __init__(self, name: str = "default") -> None: ...
+        else:
+            def __init__(self, name: str) -> None: ...
+
+        def open(self, url: str, new: int = 0, autoraise: bool = True) -> bool: ...