jaclang 0.6.1__py3-none-any.whl → 0.6.2__py3-none-any.whl

jaclang/vendor/mypy/typeshed/stdlib/uuid.pyi

@@ -0,0 +1,100 @@
+import builtins
+import sys
+from _typeshed import Unused
+from enum import Enum
+from typing_extensions import TypeAlias
+
+_FieldsType: TypeAlias = tuple[int, int, int, int, int, int]
+
+class SafeUUID(Enum):
+    safe: int
+    unsafe: int
+    unknown: None
+
+class UUID:
+    def __init__(
+        self,
+        hex: str | None = None,
+        bytes: builtins.bytes | None = None,
+        bytes_le: builtins.bytes | None = None,
+        fields: _FieldsType | None = None,
+        int: builtins.int | None = None,
+        version: builtins.int | None = None,
+        *,
+        is_safe: SafeUUID = ...,
+    ) -> None: ...
+    @property
+    def is_safe(self) -> SafeUUID: ...
+    @property
+    def bytes(self) -> builtins.bytes: ...
+    @property
+    def bytes_le(self) -> builtins.bytes: ...
+    @property
+    def clock_seq(self) -> builtins.int: ...
+    @property
+    def clock_seq_hi_variant(self) -> builtins.int: ...
+    @property
+    def clock_seq_low(self) -> builtins.int: ...
+    @property
+    def fields(self) -> _FieldsType: ...
+    @property
+    def hex(self) -> str: ...
+    @property
+    def int(self) -> builtins.int: ...
+    @property
+    def node(self) -> builtins.int: ...
+    @property
+    def time(self) -> builtins.int: ...
+    @property
+    def time_hi_version(self) -> builtins.int: ...
+    @property
+    def time_low(self) -> builtins.int: ...
+    @property
+    def time_mid(self) -> builtins.int: ...
+    @property
+    def urn(self) -> str: ...
+    @property
+    def variant(self) -> str: ...
+    @property
+    def version(self) -> builtins.int | None: ...
+    def __int__(self) -> builtins.int: ...
+    def __eq__(self, other: object) -> bool: ...
+    def __lt__(self, other: UUID) -> bool: ...
+    def __le__(self, other: UUID) -> bool: ...
+    def __gt__(self, other: UUID) -> bool: ...
+    def __ge__(self, other: UUID) -> bool: ...
+    def __hash__(self) -> builtins.int: ...
+
+if sys.version_info >= (3, 9):
+    def getnode() -> int: ...
+
+else:
+    def getnode(*, getters: Unused = None) -> int: ...  # undocumented
+
+def uuid1(node: int | None = None, clock_seq: int | None = None) -> UUID: ...
+
+if sys.version_info >= (3, 12):
+    def uuid3(namespace: UUID, name: str | bytes) -> UUID: ...
+
+else:
+    def uuid3(namespace: UUID, name: str) -> UUID: ...
+
+def uuid4() -> UUID: ...
+
+if sys.version_info >= (3, 12):
+    def uuid5(namespace: UUID, name: str | bytes) -> UUID: ...
+
+else:
+    def uuid5(namespace: UUID, name: str) -> UUID: ...
+
+NAMESPACE_DNS: UUID
+NAMESPACE_URL: UUID
+NAMESPACE_OID: UUID
+NAMESPACE_X500: UUID
+RESERVED_NCS: str
+RFC_4122: str
+RESERVED_MICROSOFT: str
+RESERVED_FUTURE: str
+
+if sys.version_info >= (3, 12):
+    def main() -> None: ...

jaclang/vendor/mypy/typeshed/stdlib/warnings.pyi

@@ -0,0 +1,144 @@
+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, TypeVar, overload
+from typing_extensions import TypeAlias
+
+__all__ = [
+    "warn",
+    "warn_explicit",
+    "showwarning",
+    "formatwarning",
+    "filterwarnings",
+    "simplefilter",
+    "resetwarnings",
+    "catch_warnings",
+]
+
+_W = TypeVar("_W", bound=list[WarningMessage] | None)
+_ActionKind: TypeAlias = Literal[
+    "default", "error", "ignore", "always", "module", "once"
+]
+
+filters: Sequence[
+    tuple[str, str | None, type[Warning], 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] = ...,
+    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
+    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]):
+    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] = ...,
+            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] = ...,
+            lineno: int = 0,
+            append: bool = False,
+        ) -> None: ...
+        @overload
+        def __init__(
+            self: catch_warnings[list[WarningMessage] | None],
+            *,
+            record: bool,
+            module: ModuleType | None = None,
+            action: _ActionKind | None = None,
+            category: 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: catch_warnings[list[WarningMessage] | None],
+            *,
+            record: bool,
+            module: ModuleType | None = None,
+        ) -> None: ...
+
+    def __enter__(self) -> _W: ...
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> None: ...

jaclang/vendor/mypy/typeshed/stdlib/wave.pyi

@@ -0,0 +1,87 @@
+import sys
+from _typeshed import ReadableBuffer, Unused
+from typing import IO, Any, BinaryIO, Literal, NamedTuple, NoReturn, overload
+from typing_extensions import Self, TypeAlias, deprecated
+
+if sys.version_info >= (3, 9):
+    __all__ = ["open", "Error", "Wave_read", "Wave_write"]
+else:
+    __all__ = ["open", "openfp", "Error", "Wave_read", "Wave_write"]
+
+_File: TypeAlias = str | IO[bytes]
+
+class Error(Exception): ...
+
+WAVE_FORMAT_PCM: Literal[1]
+
+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: ...
+    def getcomptype(self) -> str: ...
+    def getcompname(self) -> str: ...
+    def getparams(self) -> _wave_params: ...
+    @deprecated("Deprecated in Python 3.13; removal scheduled for Python 3.15")
+    def getmarkers(self) -> None: ...
+    @deprecated("Deprecated in Python 3.13; removal scheduled for 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: ...
+    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: ...
+    def setparams(
+        self, params: _wave_params | tuple[int, int, int, int, str, str]
+    ) -> None: ...
+    def getparams(self) -> _wave_params: ...
+    @deprecated("Deprecated in Python 3.13; removal scheduled for Python 3.15")
+    def setmark(self, id: Any, pos: Any, name: Any) -> NoReturn: ...
+    @deprecated("Deprecated in Python 3.13; removal scheduled for Python 3.15")
+    def getmark(self, id: Any) -> NoReturn: ...
+    @deprecated("Deprecated in Python 3.13; removal scheduled for 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: ...
+
+if sys.version_info < (3, 9):
+    openfp = open

jaclang/vendor/mypy/typeshed/stdlib/weakref.pyi

@@ -0,0 +1,173 @@
+import sys
+from _typeshed import SupportsKeysAndGetItem
+from _weakref import (
+    CallableProxyType as CallableProxyType,
+    ProxyType as ProxyType,
+    ReferenceType as ReferenceType,
+    getweakrefcount as getweakrefcount,
+    getweakrefs as getweakrefs,
+    proxy as proxy,
+    ref as ref,
+)
+from _weakrefset import WeakSet as WeakSet
+from collections.abc import Callable, Iterable, Iterator, Mapping, MutableMapping
+from typing import Any, Generic, TypeVar, overload
+from typing_extensions import ParamSpec, Self
+
+__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], ...]
+
+class WeakMethod(ref[_CallableT]):
+    def __new__(
+        cls, meth: _CallableT, callback: Callable[[Self], object] | 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],
+        __other: Mapping[_KT, _VT] | Iterable[tuple[_KT, _VT]],
+    ) -> None: ...
+    @overload
+    def __init__(
+        self: WeakValueDictionary[str, _VT],
+        __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: _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: ...
+    if sys.version_info >= (3, 9):
+        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]):
+    key: _KT
+    # This __new__ method uses a non-standard name for the "cls" parameter
+    def __new__(type, ob: _T, callback: Callable[[_T], Any], key: _KT) -> Self: ...
+    def __init__(self, ob: _T, callback: Callable[[_T], 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: _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: ...
+    if sys.version_info >= (3, 9):
+        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:  # TODO: This is a good candidate for to be a `Generic[_P, _T]` class
+    def __init__(
+        self,
+        __obj: object,
+        __func: Callable[_P, Any],
+        *args: _P.args,
+        **kwargs: _P.kwargs
+    ) -> None: ...
+    def __call__(self, _: Any = None) -> Any | None: ...
+    def detach(self) -> tuple[Any, Any, tuple[Any, ...], dict[str, Any]] | None: ...
+    def peek(self) -> tuple[Any, Any, tuple[Any, ...], dict[str, Any]] | None: ...
+    @property
+    def alive(self) -> bool: ...
+    atexit: bool

jaclang/vendor/mypy/typeshed/stdlib/webbrowser.pyi

@@ -0,0 +1,80 @@
+import sys
+from abc import abstractmethod
+from collections.abc import Callable, Sequence
+from typing import Literal
+
+__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":
+    class MacOSX(BaseBrowser):
+        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: ...

jaclang/vendor/mypy/typeshed/stdlib/winreg.pyi

@@ -0,0 +1,120 @@
+import sys
+from types import TracebackType
+from typing import Any, Literal, final
+from typing_extensions import Self, TypeAlias
+
+if sys.platform == "win32":
+    _KeyType: TypeAlias = HKEYType | int
+    def CloseKey(__hkey: _KeyType) -> None: ...
+    def ConnectRegistry(__computer_name: str | None, __key: _KeyType) -> HKEYType: ...
+    def CreateKey(__key: _KeyType, __sub_key: str | None) -> HKEYType: ...
+    def CreateKeyEx(
+        key: _KeyType, sub_key: str | None, reserved: int = 0, access: int = 131078
+    ) -> HKEYType: ...
+    def DeleteKey(__key: _KeyType, __sub_key: str) -> None: ...
+    def DeleteKeyEx(
+        key: _KeyType, sub_key: str, access: int = 256, reserved: int = 0
+    ) -> None: ...
+    def DeleteValue(__key: _KeyType, __value: str) -> None: ...
+    def EnumKey(__key: _KeyType, __index: int) -> str: ...
+    def EnumValue(__key: _KeyType, __index: int) -> tuple[str, Any, int]: ...
+    def ExpandEnvironmentStrings(__string: str) -> str: ...
+    def FlushKey(__key: _KeyType) -> None: ...
+    def LoadKey(__key: _KeyType, __sub_key: str, __file_name: str) -> None: ...
+    def OpenKey(
+        key: _KeyType, sub_key: str, reserved: int = 0, access: int = 131097
+    ) -> HKEYType: ...
+    def OpenKeyEx(
+        key: _KeyType, sub_key: str, reserved: int = 0, access: int = 131097
+    ) -> HKEYType: ...
+    def QueryInfoKey(__key: _KeyType) -> tuple[int, int, int]: ...
+    def QueryValue(__key: _KeyType, __sub_key: str | None) -> str: ...
+    def QueryValueEx(__key: _KeyType, __name: str) -> tuple[Any, int]: ...
+    def SaveKey(__key: _KeyType, __file_name: str) -> None: ...
+    def SetValue(
+        __key: _KeyType, __sub_key: str, __type: int, __value: str
+    ) -> None: ...
+    def SetValueEx(
+        __key: _KeyType,
+        __value_name: str | None,
+        __reserved: Any,
+        __type: int,
+        __value: str | int,
+    ) -> None: ...  # reserved is ignored
+    def DisableReflectionKey(__key: _KeyType) -> None: ...
+    def EnableReflectionKey(__key: _KeyType) -> None: ...
+    def QueryReflectionKey(__key: _KeyType) -> bool: ...
+    HKEY_CLASSES_ROOT: int
+    HKEY_CURRENT_USER: int
+    HKEY_LOCAL_MACHINE: int
+    HKEY_USERS: int
+    HKEY_PERFORMANCE_DATA: int
+    HKEY_CURRENT_CONFIG: int
+    HKEY_DYN_DATA: int
+
+    KEY_ALL_ACCESS: Literal[983103]
+    KEY_WRITE: Literal[131078]
+    KEY_READ: Literal[131097]
+    KEY_EXECUTE: Literal[131097]
+    KEY_QUERY_VALUE: Literal[1]
+    KEY_SET_VALUE: Literal[2]
+    KEY_CREATE_SUB_KEY: Literal[4]
+    KEY_ENUMERATE_SUB_KEYS: Literal[8]
+    KEY_NOTIFY: Literal[16]
+    KEY_CREATE_LINK: Literal[32]
+
+    KEY_WOW64_64KEY: Literal[256]
+    KEY_WOW64_32KEY: Literal[512]
+
+    REG_BINARY: Literal[3]
+    REG_DWORD: Literal[4]
+    REG_DWORD_LITTLE_ENDIAN: Literal[4]
+    REG_DWORD_BIG_ENDIAN: Literal[5]
+    REG_EXPAND_SZ: Literal[2]
+    REG_LINK: Literal[6]
+    REG_MULTI_SZ: Literal[7]
+    REG_NONE: Literal[0]
+    REG_QWORD: Literal[11]
+    REG_QWORD_LITTLE_ENDIAN: Literal[11]
+    REG_RESOURCE_LIST: Literal[8]
+    REG_FULL_RESOURCE_DESCRIPTOR: Literal[9]
+    REG_RESOURCE_REQUIREMENTS_LIST: Literal[10]
+    REG_SZ: Literal[1]
+
+    REG_CREATED_NEW_KEY: int  # undocumented
+    REG_LEGAL_CHANGE_FILTER: int  # undocumented
+    REG_LEGAL_OPTION: int  # undocumented
+    REG_NOTIFY_CHANGE_ATTRIBUTES: int  # undocumented
+    REG_NOTIFY_CHANGE_LAST_SET: int  # undocumented
+    REG_NOTIFY_CHANGE_NAME: int  # undocumented
+    REG_NOTIFY_CHANGE_SECURITY: int  # undocumented
+    REG_NO_LAZY_FLUSH: int  # undocumented
+    REG_OPENED_EXISTING_KEY: int  # undocumented
+    REG_OPTION_BACKUP_RESTORE: int  # undocumented
+    REG_OPTION_CREATE_LINK: int  # undocumented
+    REG_OPTION_NON_VOLATILE: int  # undocumented
+    REG_OPTION_OPEN_LINK: int  # undocumented
+    REG_OPTION_RESERVED: int  # undocumented
+    REG_OPTION_VOLATILE: int  # undocumented
+    REG_REFRESH_HIVE: int  # undocumented
+    REG_WHOLE_HIVE_VOLATILE: int  # undocumented
+
+    error = OSError
+
+    # Though this class has a __name__ of PyHKEY, it's exposed as HKEYType for some reason
+    @final
+    class HKEYType:
+        def __bool__(self) -> bool: ...
+        def __int__(self) -> int: ...
+        def __enter__(self) -> Self: ...
+        def __exit__(
+            self,
+            exc_type: type[BaseException] | None,
+            exc_value: BaseException | None,
+            traceback: TracebackType | None,
+        ) -> bool | None: ...
+        def Close(self) -> None: ...
+        def Detach(self) -> int: ...
+        def __hash__(self) -> int: ...
+        @property
+        def handle(self) -> int: ...