mypy-dev 1.9.0.dev0__py3-none-any.whl

mypy/typeshed/stdlib/csv.pyi

@@ -0,0 +1,147 @@
+import sys
+
+# actually csv.Dialect is a different class to _csv.Dialect at runtime, but for typing purposes, they're identical
+from _csv import (
+    QUOTE_ALL as QUOTE_ALL,
+    QUOTE_MINIMAL as QUOTE_MINIMAL,
+    QUOTE_NONE as QUOTE_NONE,
+    QUOTE_NONNUMERIC as QUOTE_NONNUMERIC,
+    Dialect as Dialect,
+    Error as Error,
+    __version__ as __version__,
+    _DialectLike,
+    _QuotingType,
+    _reader,
+    _writer,
+    field_size_limit as field_size_limit,
+    get_dialect as get_dialect,
+    list_dialects as list_dialects,
+    reader as reader,
+    register_dialect as register_dialect,
+    unregister_dialect as unregister_dialect,
+    writer as writer,
+)
+
+if sys.version_info >= (3, 12):
+    from _csv import QUOTE_NOTNULL as QUOTE_NOTNULL, QUOTE_STRINGS as QUOTE_STRINGS
+
+from _typeshed import SupportsWrite
+from collections.abc import Collection, Iterable, Iterator, Mapping, Sequence
+from typing import Any, Generic, Literal, TypeVar, overload
+from typing_extensions import Self
+
+if sys.version_info >= (3, 12):
+    from types import GenericAlias
+
+__all__ = [
+    "QUOTE_MINIMAL",
+    "QUOTE_ALL",
+    "QUOTE_NONNUMERIC",
+    "QUOTE_NONE",
+    "Error",
+    "Dialect",
+    "__doc__",
+    "excel",
+    "excel_tab",
+    "field_size_limit",
+    "reader",
+    "writer",
+    "register_dialect",
+    "get_dialect",
+    "list_dialects",
+    "Sniffer",
+    "unregister_dialect",
+    "__version__",
+    "DictReader",
+    "DictWriter",
+    "unix_dialect",
+]
+if sys.version_info >= (3, 12):
+    __all__ += ["QUOTE_STRINGS", "QUOTE_NOTNULL"]
+
+_T = TypeVar("_T")
+
+class excel(Dialect): ...
+class excel_tab(excel): ...
+class unix_dialect(Dialect): ...
+
+class DictReader(Iterator[dict[_T | Any, str | Any]], Generic[_T]):
+    fieldnames: Sequence[_T] | None
+    restkey: _T | None
+    restval: str | Any | None
+    reader: _reader
+    dialect: _DialectLike
+    line_num: int
+    @overload
+    def __init__(
+        self,
+        f: Iterable[str],
+        fieldnames: Sequence[_T],
+        restkey: _T | None = None,
+        restval: str | Any | None = None,
+        dialect: _DialectLike = "excel",
+        *,
+        delimiter: str = ",",
+        quotechar: str | None = '"',
+        escapechar: str | None = None,
+        doublequote: bool = True,
+        skipinitialspace: bool = False,
+        lineterminator: str = "\r\n",
+        quoting: _QuotingType = 0,
+        strict: bool = False,
+    ) -> None: ...
+    @overload
+    def __init__(
+        self: DictReader[str],
+        f: Iterable[str],
+        fieldnames: Sequence[str] | None = None,
+        restkey: str | None = None,
+        restval: str | None = None,
+        dialect: _DialectLike = "excel",
+        *,
+        delimiter: str = ",",
+        quotechar: str | None = '"',
+        escapechar: str | None = None,
+        doublequote: bool = True,
+        skipinitialspace: bool = False,
+        lineterminator: str = "\r\n",
+        quoting: _QuotingType = 0,
+        strict: bool = False,
+    ) -> None: ...
+    def __iter__(self) -> Self: ...
+    def __next__(self) -> dict[_T | Any, str | Any]: ...
+    if sys.version_info >= (3, 12):
+        def __class_getitem__(cls, item: Any) -> GenericAlias: ...
+
+class DictWriter(Generic[_T]):
+    fieldnames: Collection[_T]
+    restval: Any | None
+    extrasaction: Literal["raise", "ignore"]
+    writer: _writer
+    def __init__(
+        self,
+        f: SupportsWrite[str],
+        fieldnames: Collection[_T],
+        restval: Any | None = "",
+        extrasaction: Literal["raise", "ignore"] = "raise",
+        dialect: _DialectLike = "excel",
+        *,
+        delimiter: str = ",",
+        quotechar: str | None = '"',
+        escapechar: str | None = None,
+        doublequote: bool = True,
+        skipinitialspace: bool = False,
+        lineterminator: str = "\r\n",
+        quoting: _QuotingType = 0,
+        strict: bool = False,
+    ) -> None: ...
+    def writeheader(self) -> Any: ...
+    def writerow(self, rowdict: Mapping[_T, Any]) -> Any: ...
+    def writerows(self, rowdicts: Iterable[Mapping[_T, Any]]) -> None: ...
+    if sys.version_info >= (3, 12):
+        def __class_getitem__(cls, item: Any) -> GenericAlias: ...
+
+class Sniffer:
+    preferred: list[str]
+    def sniff(self, sample: str, delimiters: str | None = None) -> type[Dialect]: ...
+    def has_header(self, sample: str) -> bool: ...

mypy/typeshed/stdlib/ctypes/__init__.pyi

@@ -0,0 +1,187 @@
+import sys
+from _ctypes import (
+    POINTER as POINTER,
+    RTLD_GLOBAL as RTLD_GLOBAL,
+    RTLD_LOCAL as RTLD_LOCAL,
+    Array as Array,
+    CFuncPtr as _CFuncPtr,
+    Structure as Structure,
+    Union as Union,
+    _CanCastTo as _CanCastTo,
+    _CArgObject as _CArgObject,
+    _CData as _CData,
+    _CDataMeta as _CDataMeta,
+    _CField as _CField,
+    _Pointer as _Pointer,
+    _PointerLike as _PointerLike,
+    _SimpleCData as _SimpleCData,
+    _StructUnionBase as _StructUnionBase,
+    _StructUnionMeta as _StructUnionMeta,
+    addressof as addressof,
+    alignment as alignment,
+    byref as byref,
+    get_errno as get_errno,
+    pointer as pointer,
+    resize as resize,
+    set_errno as set_errno,
+    sizeof as sizeof,
+)
+from ctypes._endian import BigEndianStructure as BigEndianStructure, LittleEndianStructure as LittleEndianStructure
+from typing import Any, ClassVar, Generic, TypeVar
+from typing_extensions import TypeAlias
+
+if sys.platform == "win32":
+    from _ctypes import FormatError as FormatError, get_last_error as get_last_error, set_last_error as set_last_error
+
+if sys.version_info >= (3, 11):
+    from ctypes._endian import BigEndianUnion as BigEndianUnion, LittleEndianUnion as LittleEndianUnion
+
+if sys.version_info >= (3, 9):
+    from types import GenericAlias
+
+_T = TypeVar("_T")
+_DLLT = TypeVar("_DLLT", bound=CDLL)
+
+DEFAULT_MODE: int
+
+class ArgumentError(Exception): ...
+
+class CDLL:
+    _func_flags_: ClassVar[int]
+    _func_restype_: ClassVar[_CData]
+    _name: str
+    _handle: int
+    _FuncPtr: type[_FuncPointer]
+    def __init__(
+        self,
+        name: str | None,
+        mode: int = ...,
+        handle: int | None = None,
+        use_errno: bool = False,
+        use_last_error: bool = False,
+        winmode: int | None = None,
+    ) -> None: ...
+    def __getattr__(self, name: str) -> _NamedFuncPointer: ...
+    def __getitem__(self, name_or_ordinal: str) -> _NamedFuncPointer: ...
+
+if sys.platform == "win32":
+    class OleDLL(CDLL): ...
+    class WinDLL(CDLL): ...
+
+class PyDLL(CDLL): ...
+
+class LibraryLoader(Generic[_DLLT]):
+    def __init__(self, dlltype: type[_DLLT]) -> None: ...
+    def __getattr__(self, name: str) -> _DLLT: ...
+    def __getitem__(self, name: str) -> _DLLT: ...
+    def LoadLibrary(self, name: str) -> _DLLT: ...
+    if sys.version_info >= (3, 9):
+        def __class_getitem__(cls, item: Any) -> GenericAlias: ...
+
+cdll: LibraryLoader[CDLL]
+if sys.platform == "win32":
+    windll: LibraryLoader[WinDLL]
+    oledll: LibraryLoader[OleDLL]
+pydll: LibraryLoader[PyDLL]
+pythonapi: PyDLL
+
+class _FuncPointer(_CFuncPtr): ...
+
+class _NamedFuncPointer(_FuncPointer):
+    __name__: str
+
+def CFUNCTYPE(
+    restype: type[_CData] | None, *argtypes: type[_CData], use_errno: bool = ..., use_last_error: bool = ...
+) -> type[_FuncPointer]: ...
+
+if sys.platform == "win32":
+    def WINFUNCTYPE(
+        restype: type[_CData] | None, *argtypes: type[_CData], use_errno: bool = ..., use_last_error: bool = ...
+    ) -> type[_FuncPointer]: ...
+
+def PYFUNCTYPE(restype: type[_CData] | None, *argtypes: type[_CData]) -> type[_FuncPointer]: ...
+
+# Any type that can be implicitly converted to c_void_p when passed as a C function argument.
+# (bytes is not included here, see below.)
+_CVoidPLike: TypeAlias = _PointerLike | Array[Any] | _CArgObject | int
+# Same as above, but including types known to be read-only (i. e. bytes).
+# This distinction is not strictly necessary (ctypes doesn't differentiate between const
+# and non-const pointers), but it catches errors like memmove(b'foo', buf, 4)
+# when memmove(buf, b'foo', 4) was intended.
+_CVoidConstPLike: TypeAlias = _CVoidPLike | bytes
+
+_CastT = TypeVar("_CastT", bound=_CanCastTo)
+
+def cast(obj: _CData | _CArgObject | int, typ: type[_CastT]) -> _CastT: ...
+def create_string_buffer(init: int | bytes, size: int | None = None) -> Array[c_char]: ...
+
+c_buffer = create_string_buffer
+
+def create_unicode_buffer(init: int | str, size: int | None = None) -> Array[c_wchar]: ...
+
+if sys.platform == "win32":
+    def DllCanUnloadNow() -> int: ...
+    def DllGetClassObject(rclsid: Any, riid: Any, ppv: Any) -> int: ...  # TODO not documented
+    def GetLastError() -> int: ...
+
+def memmove(dst: _CVoidPLike, src: _CVoidConstPLike, count: int) -> int: ...
+def memset(dst: _CVoidPLike, c: int, count: int) -> int: ...
+def string_at(address: _CVoidConstPLike, size: int = -1) -> bytes: ...
+
+if sys.platform == "win32":
+    def WinError(code: int | None = None, descr: str | None = None) -> OSError: ...
+
+def wstring_at(address: _CVoidConstPLike, size: int = -1) -> str: ...
+
+class c_byte(_SimpleCData[int]): ...
+
+class c_char(_SimpleCData[bytes]):
+    def __init__(self, value: int | bytes | bytearray = ...) -> None: ...
+
+class c_char_p(_PointerLike, _SimpleCData[bytes | None]):
+    def __init__(self, value: int | bytes | None = ...) -> None: ...
+
+class c_double(_SimpleCData[float]): ...
+class c_longdouble(_SimpleCData[float]): ...  # can be an alias for c_double
+class c_float(_SimpleCData[float]): ...
+class c_int(_SimpleCData[int]): ...  # can be an alias for c_long
+class c_long(_SimpleCData[int]): ...
+class c_longlong(_SimpleCData[int]): ...  # can be an alias for c_long
+class c_short(_SimpleCData[int]): ...
+class c_size_t(_SimpleCData[int]): ...  # alias for c_uint, c_ulong, or c_ulonglong
+class c_ssize_t(_SimpleCData[int]): ...  # alias for c_int, c_long, or c_longlong
+class c_ubyte(_SimpleCData[int]): ...
+class c_uint(_SimpleCData[int]): ...  # can be an alias for c_ulong
+class c_ulong(_SimpleCData[int]): ...
+class c_ulonglong(_SimpleCData[int]): ...  # can be an alias for c_ulong
+class c_ushort(_SimpleCData[int]): ...
+class c_void_p(_PointerLike, _SimpleCData[int | None]): ...
+class c_wchar(_SimpleCData[str]): ...
+
+c_int8 = c_byte
+
+# these are actually dynamic aliases for c_short, c_int, c_long, or c_longlong
+class c_int16(_SimpleCData[int]): ...
+class c_int32(_SimpleCData[int]): ...
+class c_int64(_SimpleCData[int]): ...
+
+c_uint8 = c_ubyte
+
+# these are actually dynamic aliases for c_ushort, c_uint, c_ulong, or c_ulonglong
+class c_uint16(_SimpleCData[int]): ...
+class c_uint32(_SimpleCData[int]): ...
+class c_uint64(_SimpleCData[int]): ...
+
+class c_wchar_p(_PointerLike, _SimpleCData[str | None]):
+    def __init__(self, value: int | str | None = ...) -> None: ...
+
+class c_bool(_SimpleCData[bool]):
+    def __init__(self, value: bool = ...) -> None: ...
+
+if sys.platform == "win32":
+    class HRESULT(_SimpleCData[int]): ...  # TODO undocumented
+
+if sys.version_info >= (3, 12):
+    c_time_t: type[c_int32 | c_int64]  # alias for one or the other at runtime
+
+class py_object(_CanCastTo, _SimpleCData[_T]): ...

mypy/typeshed/stdlib/ctypes/_endian.pyi

@@ -0,0 +1,19 @@
+import sys
+from _ctypes import RTLD_GLOBAL as RTLD_GLOBAL, RTLD_LOCAL as RTLD_LOCAL, Structure, Union
+from ctypes import DEFAULT_MODE as DEFAULT_MODE, cdll as cdll, pydll as pydll, pythonapi as pythonapi
+
+if sys.version_info >= (3, 12):
+    from _ctypes import SIZEOF_TIME_T as SIZEOF_TIME_T
+
+if sys.platform == "win32":
+    from ctypes import oledll as oledll, windll as windll
+
+# At runtime, the native endianness is an alias for Structure,
+# while the other is a subclass with a metaclass added in.
+class BigEndianStructure(Structure): ...
+class LittleEndianStructure(Structure): ...
+
+# Same thing for these: one is an alias of Union at runtime
+if sys.version_info >= (3, 11):
+    class BigEndianUnion(Union): ...
+    class LittleEndianUnion(Union): ...

mypy/typeshed/stdlib/ctypes/util.pyi

@@ -0,0 +1,6 @@
+import sys
+
+def find_library(name: str) -> str | None: ...
+
+if sys.platform == "win32":
+    def find_msvcrt() -> str | None: ...

mypy/typeshed/stdlib/ctypes/wintypes.pyi

@@ -0,0 +1,298 @@
+from ctypes import (
+    Array,
+    Structure,
+    _CField,
+    _Pointer,
+    _SimpleCData,
+    c_byte,
+    c_char,
+    c_char_p,
+    c_double,
+    c_float,
+    c_int,
+    c_long,
+    c_longlong,
+    c_short,
+    c_uint,
+    c_ulong,
+    c_ulonglong,
+    c_ushort,
+    c_void_p,
+    c_wchar,
+    c_wchar_p,
+)
+from typing import TypeVar
+from typing_extensions import TypeAlias
+
+BYTE = c_byte
+WORD = c_ushort
+DWORD = c_ulong
+CHAR = c_char
+WCHAR = c_wchar
+UINT = c_uint
+INT = c_int
+DOUBLE = c_double
+FLOAT = c_float
+BOOLEAN = BYTE
+BOOL = c_long
+
+class VARIANT_BOOL(_SimpleCData[bool]): ...
+
+ULONG = c_ulong
+LONG = c_long
+USHORT = c_ushort
+SHORT = c_short
+LARGE_INTEGER = c_longlong
+_LARGE_INTEGER = c_longlong
+ULARGE_INTEGER = c_ulonglong
+_ULARGE_INTEGER = c_ulonglong
+
+OLESTR = c_wchar_p
+LPOLESTR = c_wchar_p
+LPCOLESTR = c_wchar_p
+LPWSTR = c_wchar_p
+LPCWSTR = c_wchar_p
+LPSTR = c_char_p
+LPCSTR = c_char_p
+LPVOID = c_void_p
+LPCVOID = c_void_p
+
+# These two types are pointer-sized unsigned and signed ints, respectively.
+# At runtime, they are either c_[u]long or c_[u]longlong, depending on the host's pointer size
+# (they are not really separate classes).
+class WPARAM(_SimpleCData[int]): ...
+class LPARAM(_SimpleCData[int]): ...
+
+ATOM = WORD
+LANGID = WORD
+COLORREF = DWORD
+LGRPID = DWORD
+LCTYPE = DWORD
+LCID = DWORD
+
+HANDLE = c_void_p
+HACCEL = HANDLE
+HBITMAP = HANDLE
+HBRUSH = HANDLE
+HCOLORSPACE = HANDLE
+HDC = HANDLE
+HDESK = HANDLE
+HDWP = HANDLE
+HENHMETAFILE = HANDLE
+HFONT = HANDLE
+HGDIOBJ = HANDLE
+HGLOBAL = HANDLE
+HHOOK = HANDLE
+HICON = HANDLE
+HINSTANCE = HANDLE
+HKEY = HANDLE
+HKL = HANDLE
+HLOCAL = HANDLE
+HMENU = HANDLE
+HMETAFILE = HANDLE
+HMODULE = HANDLE
+HMONITOR = HANDLE
+HPALETTE = HANDLE
+HPEN = HANDLE
+HRGN = HANDLE
+HRSRC = HANDLE
+HSTR = HANDLE
+HTASK = HANDLE
+HWINSTA = HANDLE
+HWND = HANDLE
+SC_HANDLE = HANDLE
+SERVICE_STATUS_HANDLE = HANDLE
+
+_CIntLikeT = TypeVar("_CIntLikeT", bound=_SimpleCData[int])
+_CIntLikeField: TypeAlias = _CField[_CIntLikeT, int, _CIntLikeT | int]
+
+class RECT(Structure):
+    left: _CIntLikeField[LONG]
+    top: _CIntLikeField[LONG]
+    right: _CIntLikeField[LONG]
+    bottom: _CIntLikeField[LONG]
+
+RECTL = RECT
+_RECTL = RECT
+tagRECT = RECT
+
+class _SMALL_RECT(Structure):
+    Left: _CIntLikeField[SHORT]
+    Top: _CIntLikeField[SHORT]
+    Right: _CIntLikeField[SHORT]
+    Bottom: _CIntLikeField[SHORT]
+
+SMALL_RECT = _SMALL_RECT
+
+class _COORD(Structure):
+    X: _CIntLikeField[SHORT]
+    Y: _CIntLikeField[SHORT]
+
+class POINT(Structure):
+    x: _CIntLikeField[LONG]
+    y: _CIntLikeField[LONG]
+
+POINTL = POINT
+_POINTL = POINT
+tagPOINT = POINT
+
+class SIZE(Structure):
+    cx: _CIntLikeField[LONG]
+    cy: _CIntLikeField[LONG]
+
+SIZEL = SIZE
+tagSIZE = SIZE
+
+def RGB(red: int, green: int, blue: int) -> int: ...
+
+class FILETIME(Structure):
+    dwLowDateTime: _CIntLikeField[DWORD]
+    dwHighDateTime: _CIntLikeField[DWORD]
+
+_FILETIME = FILETIME
+
+class MSG(Structure):
+    hWnd: _CField[HWND, int | None, HWND | int | None]
+    message: _CIntLikeField[UINT]
+    wParam: _CIntLikeField[WPARAM]
+    lParam: _CIntLikeField[LPARAM]
+    time: _CIntLikeField[DWORD]
+    pt: _CField[POINT, POINT, POINT]
+
+tagMSG = MSG
+MAX_PATH: int
+
+class WIN32_FIND_DATAA(Structure):
+    dwFileAttributes: _CIntLikeField[DWORD]
+    ftCreationTime: _CField[FILETIME, FILETIME, FILETIME]
+    ftLastAccessTime: _CField[FILETIME, FILETIME, FILETIME]
+    ftLastWriteTime: _CField[FILETIME, FILETIME, FILETIME]
+    nFileSizeHigh: _CIntLikeField[DWORD]
+    nFileSizeLow: _CIntLikeField[DWORD]
+    dwReserved0: _CIntLikeField[DWORD]
+    dwReserved1: _CIntLikeField[DWORD]
+    cFileName: _CField[Array[CHAR], bytes, bytes]
+    cAlternateFileName: _CField[Array[CHAR], bytes, bytes]
+
+class WIN32_FIND_DATAW(Structure):
+    dwFileAttributes: _CIntLikeField[DWORD]
+    ftCreationTime: _CField[FILETIME, FILETIME, FILETIME]
+    ftLastAccessTime: _CField[FILETIME, FILETIME, FILETIME]
+    ftLastWriteTime: _CField[FILETIME, FILETIME, FILETIME]
+    nFileSizeHigh: _CIntLikeField[DWORD]
+    nFileSizeLow: _CIntLikeField[DWORD]
+    dwReserved0: _CIntLikeField[DWORD]
+    dwReserved1: _CIntLikeField[DWORD]
+    cFileName: _CField[Array[WCHAR], str, str]
+    cAlternateFileName: _CField[Array[WCHAR], str, str]
+
+# These are all defined with the POINTER() function, which keeps a cache and will
+# return a previously created class if it can. The self-reported __name__
+# of these classes is f"LP_{typ.__name__}", where typ is the original class
+# passed in to the POINTER() function.
+
+# LP_c_short
+class PSHORT(_Pointer[SHORT]): ...
+
+# LP_c_ushort
+class PUSHORT(_Pointer[USHORT]): ...
+
+PWORD = PUSHORT
+LPWORD = PUSHORT
+
+# LP_c_long
+class PLONG(_Pointer[LONG]): ...
+
+LPLONG = PLONG
+PBOOL = PLONG
+LPBOOL = PLONG
+
+# LP_c_ulong
+class PULONG(_Pointer[ULONG]): ...
+
+PDWORD = PULONG
+LPDWORD = PDWORD
+LPCOLORREF = PDWORD
+PLCID = PDWORD
+
+# LP_c_int (or LP_c_long if int and long have the same size)
+class PINT(_Pointer[INT]): ...
+
+LPINT = PINT
+
+# LP_c_uint (or LP_c_ulong if int and long have the same size)
+class PUINT(_Pointer[UINT]): ...
+
+LPUINT = PUINT
+
+# LP_c_float
+class PFLOAT(_Pointer[FLOAT]): ...
+
+# LP_c_longlong (or LP_c_long if long and long long have the same size)
+class PLARGE_INTEGER(_Pointer[LARGE_INTEGER]): ...
+
+# LP_c_ulonglong (or LP_c_ulong if long and long long have the same size)
+class PULARGE_INTEGER(_Pointer[ULARGE_INTEGER]): ...
+
+# LP_c_byte types
+class PBYTE(_Pointer[BYTE]): ...
+
+LPBYTE = PBYTE
+PBOOLEAN = PBYTE
+
+# LP_c_char
+class PCHAR(_Pointer[CHAR]): ...
+
+# LP_c_wchar
+class PWCHAR(_Pointer[WCHAR]): ...
+
+# LP_c_void_p
+class PHANDLE(_Pointer[HANDLE]): ...
+
+LPHANDLE = PHANDLE
+PHKEY = PHANDLE
+LPHKL = PHANDLE
+LPSC_HANDLE = PHANDLE
+
+# LP_FILETIME
+class PFILETIME(_Pointer[FILETIME]): ...
+
+LPFILETIME = PFILETIME
+
+# LP_MSG
+class PMSG(_Pointer[MSG]): ...
+
+LPMSG = PMSG
+
+# LP_POINT
+class PPOINT(_Pointer[POINT]): ...
+
+LPPOINT = PPOINT
+PPOINTL = PPOINT
+
+# LP_RECT
+class PRECT(_Pointer[RECT]): ...
+
+LPRECT = PRECT
+PRECTL = PRECT
+LPRECTL = PRECT
+
+# LP_SIZE
+class PSIZE(_Pointer[SIZE]): ...
+
+LPSIZE = PSIZE
+PSIZEL = PSIZE
+LPSIZEL = PSIZE
+
+# LP__SMALL_RECT
+class PSMALL_RECT(_Pointer[SMALL_RECT]): ...
+
+# LP_WIN32_FIND_DATAA
+class PWIN32_FIND_DATAA(_Pointer[WIN32_FIND_DATAA]): ...
+
+LPWIN32_FIND_DATAA = PWIN32_FIND_DATAA
+
+# LP_WIN32_FIND_DATAW
+class PWIN32_FIND_DATAW(_Pointer[WIN32_FIND_DATAW]): ...
+
+LPWIN32_FIND_DATAW = PWIN32_FIND_DATAW

mypy/typeshed/stdlib/curses/__init__.pyi

@@ -0,0 +1,21 @@
+import sys
+from collections.abc import Callable
+from typing import TypeVar
+from typing_extensions import Concatenate, ParamSpec
+
+if sys.platform != "win32":
+    from _curses import *
+    from _curses import _CursesWindow as _CursesWindow
+
+    _T = TypeVar("_T")
+    _P = ParamSpec("_P")
+
+    # available after calling `curses.initscr()`
+    LINES: int
+    COLS: int
+
+    # available after calling `curses.start_color()`
+    COLORS: int
+    COLOR_PAIRS: int
+
+    def wrapper(__func: Callable[Concatenate[_CursesWindow, _P], _T], *arg: _P.args, **kwds: _P.kwargs) -> _T: ...