basedpyright 1.18.3 → 1.18.4

package/dist/typeshed-fallback/stdlib/_curses.pyi

@@ -428,7 +428,7 @@ def getsyx() -> tuple[int, int]:
     Return a (y, x) tuple.  If leaveok is currently true, return (-1, -1).
     """
     ...
-def getwin(file: SupportsRead[bytes], /) -> _CursesWindow:
+def getwin(file: SupportsRead[bytes], /) -> window:
     """
     Read window related data stored in the file by an earlier putwin() call.
 
@@ -507,7 +507,7 @@ def init_pair(pair_number: int, fg: int, bg: int, /) -> None:
     all occurrences of that color-pair are changed to the new definition.
     """
     ...
-def initscr() -> _CursesWindow:
+def initscr() -> window:
     """
     Initialize the library.
 
@@ -585,7 +585,7 @@ def napms(ms: int, /) -> int:
       Duration in milliseconds.
     """
     ...
-def newpad(nlines: int, ncols: int, /) -> _CursesWindow:
+def newpad(nlines: int, ncols: int, /) -> window:
     """
     Create and return a pointer to a new pad data structure.
 
@@ -595,7 +595,7 @@ def newpad(nlines: int, ncols: int, /) -> _CursesWindow:
       Width.
     """
     ...
-def newwin(nlines: int, ncols: int, begin_y: int = ..., begin_x: int = ..., /) -> _CursesWindow:
+def newwin(nlines: int, ncols: int, begin_y: int = ..., begin_x: int = ..., /) -> window:
     """
     newwin(nlines, ncols, [begin_y=0, begin_x=0])
     Return a new window.
@@ -926,25 +926,167 @@ def use_env(flag: bool, /) -> None:
 class error(Exception): ...
 
 @final
-class _CursesWindow:
+class window:  # undocumented
     encoding: str
     @overload
-    def addch(self, ch: _ChType, attr: int = ...) -> None: ...
+    def addch(self, ch: _ChType, attr: int = ...) -> None:
+        """
+        addch([y, x,] ch, [attr=_curses.A_NORMAL])
+        Paint the character.
+
+          y
+            Y-coordinate.
+          x
+            X-coordinate.
+          ch
+            Character to add.
+          attr
+            Attributes for the character.
+
+        Paint character ch at (y, x) with attributes attr,
+        overwriting any character previously painted at that location.
+        By default, the character position and attributes are the
+        current settings for the window object.
+        """
+        ...
     @overload
-    def addch(self, y: int, x: int, ch: _ChType, attr: int = ...) -> None: ...
+    def addch(self, y: int, x: int, ch: _ChType, attr: int = ...) -> None:
+        """
+        addch([y, x,] ch, [attr=_curses.A_NORMAL])
+        Paint the character.
+
+          y
+            Y-coordinate.
+          x
+            X-coordinate.
+          ch
+            Character to add.
+          attr
+            Attributes for the character.
+
+        Paint character ch at (y, x) with attributes attr,
+        overwriting any character previously painted at that location.
+        By default, the character position and attributes are the
+        current settings for the window object.
+        """
+        ...
     @overload
-    def addnstr(self, str: str, n: int, attr: int = ...) -> None: ...
+    def addnstr(self, str: str, n: int, attr: int = ...) -> None:
+        """
+        addnstr([y, x,] str, n, [attr])
+        Paint at most n characters of the string.
+
+          y
+            Y-coordinate.
+          x
+            X-coordinate.
+          str
+            String to add.
+          n
+            Maximal number of characters.
+          attr
+            Attributes for characters.
+
+        Paint at most n characters of the string str at (y, x) with
+        attributes attr, overwriting anything previously on the display.
+        By default, the character position and attributes are the
+        current settings for the window object.
+        """
+        ...
     @overload
-    def addnstr(self, y: int, x: int, str: str, n: int, attr: int = ...) -> None: ...
+    def addnstr(self, y: int, x: int, str: str, n: int, attr: int = ...) -> None:
+        """
+        addnstr([y, x,] str, n, [attr])
+        Paint at most n characters of the string.
+
+          y
+            Y-coordinate.
+          x
+            X-coordinate.
+          str
+            String to add.
+          n
+            Maximal number of characters.
+          attr
+            Attributes for characters.
+
+        Paint at most n characters of the string str at (y, x) with
+        attributes attr, overwriting anything previously on the display.
+        By default, the character position and attributes are the
+        current settings for the window object.
+        """
+        ...
     @overload
-    def addstr(self, str: str, attr: int = ...) -> None: ...
+    def addstr(self, str: str, attr: int = ...) -> None:
+        """
+        addstr([y, x,] str, [attr])
+        Paint the string.
+
+          y
+            Y-coordinate.
+          x
+            X-coordinate.
+          str
+            String to add.
+          attr
+            Attributes for characters.
+
+        Paint the string str at (y, x) with attributes attr,
+        overwriting anything previously on the display.
+        By default, the character position and attributes are the
+        current settings for the window object.
+        """
+        ...
     @overload
-    def addstr(self, y: int, x: int, str: str, attr: int = ...) -> None: ...
-    def attroff(self, attr: int, /) -> None: ...
-    def attron(self, attr: int, /) -> None: ...
-    def attrset(self, attr: int, /) -> None: ...
-    def bkgd(self, ch: _ChType, attr: int = ..., /) -> None: ...
-    def bkgdset(self, ch: _ChType, attr: int = ..., /) -> None: ...
+    def addstr(self, y: int, x: int, str: str, attr: int = ...) -> None:
+        """
+        addstr([y, x,] str, [attr])
+        Paint the string.
+
+          y
+            Y-coordinate.
+          x
+            X-coordinate.
+          str
+            String to add.
+          attr
+            Attributes for characters.
+
+        Paint the string str at (y, x) with attributes attr,
+        overwriting anything previously on the display.
+        By default, the character position and attributes are the
+        current settings for the window object.
+        """
+        ...
+    def attroff(self, attr: int, /) -> None:
+        """Remove attribute attr from the "background" set."""
+        ...
+    def attron(self, attr: int, /) -> None:
+        """Add attribute attr from the "background" set."""
+        ...
+    def attrset(self, attr: int, /) -> None:
+        """Set the "background" set of attributes."""
+        ...
+    def bkgd(self, ch: _ChType, attr: int = ..., /) -> None:
+        """
+        Set the background property of the window.
+
+        ch
+          Background character.
+        attr
+          Background attributes.
+        """
+        ...
+    def bkgdset(self, ch: _ChType, attr: int = ..., /) -> None:
+        """
+        Set the window's background.
+
+        ch
+          Background character.
+        attr
+          Background attributes.
+        """
+        ...
     def border(
         self,
         ls: _ChType = ...,
@@ -955,11 +1097,63 @@ class _CursesWindow:
         tr: _ChType = ...,
         bl: _ChType = ...,
         br: _ChType = ...,
-    ) -> None: ...
+    ) -> None:
+        """
+        Draw a border around the edges of the window.
+
+          ls
+            Left side.
+          rs
+            Right side.
+          ts
+            Top side.
+          bs
+            Bottom side.
+          tl
+            Upper-left corner.
+          tr
+            Upper-right corner.
+          bl
+            Bottom-left corner.
+          br
+            Bottom-right corner.
+
+        Each parameter specifies the character to use for a specific part of the
+        border.  The characters can be specified as integers or as one-character
+        strings.  A 0 value for any parameter will cause the default character to be
+        used for that parameter.
+        """
+        ...
     @overload
-    def box(self) -> None: ...
+    def box(self) -> None:
+        """
+        box([verch=0, horch=0])
+        Draw a border around the edges of the window.
+
+          verch
+            Left and right side.
+          horch
+            Top and bottom side.
+
+        Similar to border(), but both ls and rs are verch and both ts and bs are
+        horch.  The default corner characters are always used by this function.
+        """
+        ...
     @overload
-    def box(self, vertch: _ChType = ..., horch: _ChType = ...) -> None: ...
+    def box(self, vertch: _ChType = ..., horch: _ChType = ...) -> None:
+        """
+        box([verch=0, horch=0])
+        Draw a border around the edges of the window.
+
+          verch
+            Left and right side.
+          horch
+            Top and bottom side.
+
+        Similar to border(), but both ls and rs are verch and both ts and bs are
+        horch.  The default corner characters are always used by this function.
+        """
+        ...
     @overload
     def chgat(self, attr: int) -> None: ...
     @overload
@@ -974,31 +1168,189 @@ class _CursesWindow:
     def clrtoeol(self) -> None: ...
     def cursyncup(self) -> None: ...
     @overload
-    def delch(self) -> None: ...
+    def delch(self) -> None:
+        """
+        delch([y, x])
+        Delete any character at (y, x).
+
+          y
+            Y-coordinate.
+          x
+            X-coordinate.
+        """
+        ...
     @overload
-    def delch(self, y: int, x: int) -> None: ...
+    def delch(self, y: int, x: int) -> None:
+        """
+        delch([y, x])
+        Delete any character at (y, x).
+
+          y
+            Y-coordinate.
+          x
+            X-coordinate.
+        """
+        ...
     def deleteln(self) -> None: ...
     @overload
-    def derwin(self, begin_y: int, begin_x: int) -> _CursesWindow: ...
+    def derwin(self, begin_y: int, begin_x: int) -> window:
+        """
+        derwin([nlines=0, ncols=0,] begin_y, begin_x)
+        Create a sub-window (window-relative coordinates).
+
+          nlines
+            Height.
+          ncols
+            Width.
+          begin_y
+            Top side y-coordinate.
+          begin_x
+            Left side x-coordinate.
+
+        derwin() is the same as calling subwin(), except that begin_y and begin_x
+        are relative to the origin of the window, rather than relative to the entire
+        screen.
+        """
+        ...
     @overload
-    def derwin(self, nlines: int, ncols: int, begin_y: int, begin_x: int) -> _CursesWindow: ...
-    def echochar(self, ch: _ChType, attr: int = ..., /) -> None: ...
-    def enclose(self, y: int, x: int, /) -> bool: ...
+    def derwin(self, nlines: int, ncols: int, begin_y: int, begin_x: int) -> window:
+        """
+        derwin([nlines=0, ncols=0,] begin_y, begin_x)
+        Create a sub-window (window-relative coordinates).
+
+          nlines
+            Height.
+          ncols
+            Width.
+          begin_y
+            Top side y-coordinate.
+          begin_x
+            Left side x-coordinate.
+
+        derwin() is the same as calling subwin(), except that begin_y and begin_x
+        are relative to the origin of the window, rather than relative to the entire
+        screen.
+        """
+        ...
+    def echochar(self, ch: _ChType, attr: int = ..., /) -> None:
+        """
+        Add character ch with attribute attr, and refresh.
+
+        ch
+          Character to add.
+        attr
+          Attributes for the character.
+        """
+        ...
+    def enclose(self, y: int, x: int, /) -> bool:
+        """
+        Return True if the screen-relative coordinates are enclosed by the window.
+
+        y
+          Y-coordinate.
+        x
+          X-coordinate.
+        """
+        ...
     def erase(self) -> None: ...
     def getbegyx(self) -> tuple[int, int]: ...
-    def getbkgd(self) -> tuple[int, int]: ...
+    def getbkgd(self) -> tuple[int, int]:
+        """Return the window's current background character/attribute pair."""
+        ...
     @overload
-    def getch(self) -> int: ...
+    def getch(self) -> int:
+        """
+        getch([y, x])
+        Get a character code from terminal keyboard.
+
+          y
+            Y-coordinate.
+          x
+            X-coordinate.
+
+        The integer returned does not have to be in ASCII range: function keys,
+        keypad keys and so on return numbers higher than 256.  In no-delay mode, -1
+        is returned if there is no input, else getch() waits until a key is pressed.
+        """
+        ...
     @overload
-    def getch(self, y: int, x: int) -> int: ...
+    def getch(self, y: int, x: int) -> int:
+        """
+        getch([y, x])
+        Get a character code from terminal keyboard.
+
+          y
+            Y-coordinate.
+          x
+            X-coordinate.
+
+        The integer returned does not have to be in ASCII range: function keys,
+        keypad keys and so on return numbers higher than 256.  In no-delay mode, -1
+        is returned if there is no input, else getch() waits until a key is pressed.
+        """
+        ...
     @overload
-    def get_wch(self) -> int | str: ...
+    def get_wch(self) -> int | str:
+        """
+        get_wch([y, x])
+        Get a wide character from terminal keyboard.
+
+          y
+            Y-coordinate.
+          x
+            X-coordinate.
+
+        Return a character for most keys, or an integer for function keys,
+        keypad keys, and other special keys.
+        """
+        ...
     @overload
-    def get_wch(self, y: int, x: int) -> int | str: ...
+    def get_wch(self, y: int, x: int) -> int | str:
+        """
+        get_wch([y, x])
+        Get a wide character from terminal keyboard.
+
+          y
+            Y-coordinate.
+          x
+            X-coordinate.
+
+        Return a character for most keys, or an integer for function keys,
+        keypad keys, and other special keys.
+        """
+        ...
     @overload
-    def getkey(self) -> str: ...
+    def getkey(self) -> str:
+        """
+        getkey([y, x])
+        Get a character (string) from terminal keyboard.
+
+          y
+            Y-coordinate.
+          x
+            X-coordinate.
+
+        Returning a string instead of an integer, as getch() does.  Function keys,
+        keypad keys and other special keys return a multibyte string containing the
+        key name.  In no-delay mode, an exception is raised if there is no input.
+        """
+        ...
     @overload
-    def getkey(self, y: int, x: int) -> str: ...
+    def getkey(self, y: int, x: int) -> str:
+        """
+        getkey([y, x])
+        Get a character (string) from terminal keyboard.
+
+          y
+            Y-coordinate.
+          x
+            X-coordinate.
+
+        Returning a string instead of an integer, as getch() does.  Function keys,
+        keypad keys and other special keys return a multibyte string containing the
+        key name.  In no-delay mode, an exception is raised if there is no input.
+        """
+        ...
     def getmaxyx(self) -> tuple[int, int]: ...
     def getparyx(self) -> tuple[int, int]: ...
     @overload
@@ -1011,35 +1363,220 @@ class _CursesWindow:
     def getstr(self, y: int, x: int, n: int) -> bytes: ...
     def getyx(self) -> tuple[int, int]: ...
     @overload
-    def hline(self, ch: _ChType, n: int) -> None: ...
+    def hline(self, ch: _ChType, n: int) -> None:
+        """
+        hline([y, x,] ch, n, [attr=_curses.A_NORMAL])
+        Display a horizontal line.
+
+          y
+            Starting Y-coordinate.
+          x
+            Starting X-coordinate.
+          ch
+            Character to draw.
+          n
+            Line length.
+          attr
+            Attributes for the characters.
+        """
+        ...
     @overload
-    def hline(self, y: int, x: int, ch: _ChType, n: int) -> None: ...
+    def hline(self, y: int, x: int, ch: _ChType, n: int) -> None:
+        """
+        hline([y, x,] ch, n, [attr=_curses.A_NORMAL])
+        Display a horizontal line.
+
+          y
+            Starting Y-coordinate.
+          x
+            Starting X-coordinate.
+          ch
+            Character to draw.
+          n
+            Line length.
+          attr
+            Attributes for the characters.
+        """
+        ...
     def idcok(self, flag: bool) -> None: ...
     def idlok(self, yes: bool) -> None: ...
     def immedok(self, flag: bool) -> None: ...
     @overload
-    def inch(self) -> int: ...
+    def inch(self) -> int:
+        """
+        inch([y, x])
+        Return the character at the given position in the window.
+
+          y
+            Y-coordinate.
+          x
+            X-coordinate.
+
+        The bottom 8 bits are the character proper, and upper bits are the attributes.
+        """
+        ...
     @overload
-    def inch(self, y: int, x: int) -> int: ...
+    def inch(self, y: int, x: int) -> int:
+        """
+        inch([y, x])
+        Return the character at the given position in the window.
+
+          y
+            Y-coordinate.
+          x
+            X-coordinate.
+
+        The bottom 8 bits are the character proper, and upper bits are the attributes.
+        """
+        ...
     @overload
-    def insch(self, ch: _ChType, attr: int = ...) -> None: ...
+    def insch(self, ch: _ChType, attr: int = ...) -> None:
+        """
+        insch([y, x,] ch, [attr=_curses.A_NORMAL])
+        Insert a character before the current or specified position.
+
+          y
+            Y-coordinate.
+          x
+            X-coordinate.
+          ch
+            Character to insert.
+          attr
+            Attributes for the character.
+
+        All characters to the right of the cursor are shifted one position right, with
+        the rightmost characters on the line being lost.
+        """
+        ...
     @overload
-    def insch(self, y: int, x: int, ch: _ChType, attr: int = ...) -> None: ...
+    def insch(self, y: int, x: int, ch: _ChType, attr: int = ...) -> None:
+        """
+        insch([y, x,] ch, [attr=_curses.A_NORMAL])
+        Insert a character before the current or specified position.
+
+          y
+            Y-coordinate.
+          x
+            X-coordinate.
+          ch
+            Character to insert.
+          attr
+            Attributes for the character.
+
+        All characters to the right of the cursor are shifted one position right, with
+        the rightmost characters on the line being lost.
+        """
+        ...
     def insdelln(self, nlines: int) -> None: ...
     def insertln(self) -> None: ...
     @overload
-    def insnstr(self, str: str, n: int, attr: int = ...) -> None: ...
+    def insnstr(self, str: str, n: int, attr: int = ...) -> None:
+        """
+        insnstr([y, x,] str, n, [attr])
+        Insert at most n characters of the string.
+
+          y
+            Y-coordinate.
+          x
+            X-coordinate.
+          str
+            String to insert.
+          n
+            Maximal number of characters.
+          attr
+            Attributes for characters.
+
+        Insert a character string (as many characters as will fit on the line)
+        before the character under the cursor, up to n characters.  If n is zero
+        or negative, the entire string is inserted.  All characters to the right
+        of the cursor are shifted right, with the rightmost characters on the line
+        being lost.  The cursor position does not change (after moving to y, x, if
+        specified).
+        """
+        ...
     @overload
-    def insnstr(self, y: int, x: int, str: str, n: int, attr: int = ...) -> None: ...
+    def insnstr(self, y: int, x: int, str: str, n: int, attr: int = ...) -> None:
+        """
+        insnstr([y, x,] str, n, [attr])
+        Insert at most n characters of the string.
+
+          y
+            Y-coordinate.
+          x
+            X-coordinate.
+          str
+            String to insert.
+          n
+            Maximal number of characters.
+          attr
+            Attributes for characters.
+
+        Insert a character string (as many characters as will fit on the line)
+        before the character under the cursor, up to n characters.  If n is zero
+        or negative, the entire string is inserted.  All characters to the right
+        of the cursor are shifted right, with the rightmost characters on the line
+        being lost.  The cursor position does not change (after moving to y, x, if
+        specified).
+        """
+        ...
     @overload
-    def insstr(self, str: str, attr: int = ...) -> None: ...
+    def insstr(self, str: str, attr: int = ...) -> None:
+        """
+        insstr([y, x,] str, [attr])
+        Insert the string before the current or specified position.
+
+          y
+            Y-coordinate.
+          x
+            X-coordinate.
+          str
+            String to insert.
+          attr
+            Attributes for characters.
+
+        Insert a character string (as many characters as will fit on the line)
+        before the character under the cursor.  All characters to the right of
+        the cursor are shifted right, with the rightmost characters on the line
+        being lost.  The cursor position does not change (after moving to y, x,
+        if specified).
+        """
+        ...
     @overload
-    def insstr(self, y: int, x: int, str: str, attr: int = ...) -> None: ...
+    def insstr(self, y: int, x: int, str: str, attr: int = ...) -> None:
+        """
+        insstr([y, x,] str, [attr])
+        Insert the string before the current or specified position.
+
+          y
+            Y-coordinate.
+          x
+            X-coordinate.
+          str
+            String to insert.
+          attr
+            Attributes for characters.
+
+        Insert a character string (as many characters as will fit on the line)
+        before the character under the cursor.  All characters to the right of
+        the cursor are shifted right, with the rightmost characters on the line
+        being lost.  The cursor position does not change (after moving to y, x,
+        if specified).
+        """
+        ...
     @overload
     def instr(self, n: int = ...) -> bytes: ...
     @overload
     def instr(self, y: int, x: int, n: int = ...) -> bytes: ...
-    def is_linetouched(self, line: int, /) -> bool: ...
+    def is_linetouched(self, line: int, /) -> bool:
+        """
+        Return True if the specified line was modified, otherwise return False.
+
+          line
+            Line number.
+
+        Raise a curses.error exception if line is not valid for the given window.
+        """
+        ...
     def is_wintouched(self) -> bool: ...
     def keypad(self, yes: bool, /) -> None: ...
     def leaveok(self, yes: bool) -> None: ...
@@ -1049,53 +1586,309 @@ class _CursesWindow:
     def nodelay(self, yes: bool) -> None: ...
     def notimeout(self, yes: bool) -> None: ...
     @overload
-    def noutrefresh(self) -> None: ...
+    def noutrefresh(self) -> None:
+        """
+        noutrefresh([pminrow, pmincol, sminrow, smincol, smaxrow, smaxcol])
+        Mark for refresh but wait.
+
+        This function updates the data structure representing the desired state of the
+        window, but does not force an update of the physical screen.  To accomplish
+        that, call doupdate().
+        """
+        ...
     @overload
-    def noutrefresh(self, pminrow: int, pmincol: int, sminrow: int, smincol: int, smaxrow: int, smaxcol: int) -> None: ...
+    def noutrefresh(self, pminrow: int, pmincol: int, sminrow: int, smincol: int, smaxrow: int, smaxcol: int) -> None:
+        """
+        noutrefresh([pminrow, pmincol, sminrow, smincol, smaxrow, smaxcol])
+        Mark for refresh but wait.
+
+        This function updates the data structure representing the desired state of the
+        window, but does not force an update of the physical screen.  To accomplish
+        that, call doupdate().
+        """
+        ...
     @overload
-    def overlay(self, destwin: _CursesWindow) -> None: ...
+    def overlay(self, destwin: window) -> None:
+        """
+        overlay(destwin, [sminrow, smincol, dminrow, dmincol, dmaxrow, dmaxcol])
+        Overlay the window on top of destwin.
+
+        The windows need not be the same size, only the overlapping region is copied.
+        This copy is non-destructive, which means that the current background
+        character does not overwrite the old contents of destwin.
+
+        To get fine-grained control over the copied region, the second form of
+        overlay() can be used.  sminrow and smincol are the upper-left coordinates
+        of the source window, and the other variables mark a rectangle in the
+        destination window.
+        """
+        ...
     @overload
     def overlay(
-        self, destwin: _CursesWindow, sminrow: int, smincol: int, dminrow: int, dmincol: int, dmaxrow: int, dmaxcol: int
-    ) -> None: ...
+        self, destwin: window, sminrow: int, smincol: int, dminrow: int, dmincol: int, dmaxrow: int, dmaxcol: int
+    ) -> None:
+        """
+        overlay(destwin, [sminrow, smincol, dminrow, dmincol, dmaxrow, dmaxcol])
+        Overlay the window on top of destwin.
+
+        The windows need not be the same size, only the overlapping region is copied.
+        This copy is non-destructive, which means that the current background
+        character does not overwrite the old contents of destwin.
+
+        To get fine-grained control over the copied region, the second form of
+        overlay() can be used.  sminrow and smincol are the upper-left coordinates
+        of the source window, and the other variables mark a rectangle in the
+        destination window.
+        """
+        ...
     @overload
-    def overwrite(self, destwin: _CursesWindow) -> None: ...
+    def overwrite(self, destwin: window) -> None:
+        """
+        overwrite(destwin, [sminrow, smincol, dminrow, dmincol, dmaxrow,
+                  dmaxcol])
+        Overwrite the window on top of destwin.
+
+        The windows need not be the same size, in which case only the overlapping
+        region is copied.  This copy is destructive, which means that the current
+        background character overwrites the old contents of destwin.
+
+        To get fine-grained control over the copied region, the second form of
+        overwrite() can be used. sminrow and smincol are the upper-left coordinates
+        of the source window, the other variables mark a rectangle in the destination
+        window.
+        """
+        ...
     @overload
     def overwrite(
-        self, destwin: _CursesWindow, sminrow: int, smincol: int, dminrow: int, dmincol: int, dmaxrow: int, dmaxcol: int
-    ) -> None: ...
-    def putwin(self, file: IO[Any], /) -> None: ...
-    def redrawln(self, beg: int, num: int, /) -> None: ...
+        self, destwin: window, sminrow: int, smincol: int, dminrow: int, dmincol: int, dmaxrow: int, dmaxcol: int
+    ) -> None:
+        """
+        overwrite(destwin, [sminrow, smincol, dminrow, dmincol, dmaxrow,
+                  dmaxcol])
+        Overwrite the window on top of destwin.
+
+        The windows need not be the same size, in which case only the overlapping
+        region is copied.  This copy is destructive, which means that the current
+        background character overwrites the old contents of destwin.
+
+        To get fine-grained control over the copied region, the second form of
+        overwrite() can be used. sminrow and smincol are the upper-left coordinates
+        of the source window, the other variables mark a rectangle in the destination
+        window.
+        """
+        ...
+    def putwin(self, file: IO[Any], /) -> None:
+        """
+        Write all data associated with the window into the provided file object.
+
+        This information can be later retrieved using the getwin() function.
+        """
+        ...
+    def redrawln(self, beg: int, num: int, /) -> None:
+        """
+        Mark the specified lines corrupted.
+
+          beg
+            Starting line number.
+          num
+            The number of lines.
+
+        They should be completely redrawn on the next refresh() call.
+        """
+        ...
     def redrawwin(self) -> None: ...
     @overload
-    def refresh(self) -> None: ...
+    def refresh(self) -> None:
+        """
+        refresh([pminrow, pmincol, sminrow, smincol, smaxrow, smaxcol])
+        Update the display immediately.
+
+        Synchronize actual screen with previous drawing/deleting methods.
+        The 6 optional arguments can only be specified when the window is a pad
+        created with newpad().  The additional parameters are needed to indicate
+        what part of the pad and screen are involved.  pminrow and pmincol specify
+        the upper left-hand corner of the rectangle to be displayed in the pad.
+        sminrow, smincol, smaxrow, and smaxcol specify the edges of the rectangle to
+        be displayed on the screen.  The lower right-hand corner of the rectangle to
+        be displayed in the pad is calculated from the screen coordinates, since the
+        rectangles must be the same size.  Both rectangles must be entirely contained
+        within their respective structures.  Negative values of pminrow, pmincol,
+        sminrow, or smincol are treated as if they were zero.
+        """
+        ...
     @overload
-    def refresh(self, pminrow: int, pmincol: int, sminrow: int, smincol: int, smaxrow: int, smaxcol: int) -> None: ...
+    def refresh(self, pminrow: int, pmincol: int, sminrow: int, smincol: int, smaxrow: int, smaxcol: int) -> None:
+        """
+        refresh([pminrow, pmincol, sminrow, smincol, smaxrow, smaxcol])
+        Update the display immediately.
+
+        Synchronize actual screen with previous drawing/deleting methods.
+        The 6 optional arguments can only be specified when the window is a pad
+        created with newpad().  The additional parameters are needed to indicate
+        what part of the pad and screen are involved.  pminrow and pmincol specify
+        the upper left-hand corner of the rectangle to be displayed in the pad.
+        sminrow, smincol, smaxrow, and smaxcol specify the edges of the rectangle to
+        be displayed on the screen.  The lower right-hand corner of the rectangle to
+        be displayed in the pad is calculated from the screen coordinates, since the
+        rectangles must be the same size.  Both rectangles must be entirely contained
+        within their respective structures.  Negative values of pminrow, pmincol,
+        sminrow, or smincol are treated as if they were zero.
+        """
+        ...
     def resize(self, nlines: int, ncols: int) -> None: ...
-    def scroll(self, lines: int = ...) -> None: ...
+    def scroll(self, lines: int = ...) -> None:
+        """
+        scroll([lines=1])
+        Scroll the screen or scrolling region.
+
+          lines
+            Number of lines to scroll.
+
+        Scroll upward if the argument is positive and downward if it is negative.
+        """
+        ...
     def scrollok(self, flag: bool) -> None: ...
-    def setscrreg(self, top: int, bottom: int, /) -> None: ...
+    def setscrreg(self, top: int, bottom: int, /) -> None:
+        """
+        Define a software scrolling region.
+
+          top
+            First line number.
+          bottom
+            Last line number.
+
+        All scrolling actions will take place in this region.
+        """
+        ...
     def standend(self) -> None: ...
     def standout(self) -> None: ...
     @overload
-    def subpad(self, begin_y: int, begin_x: int) -> _CursesWindow: ...
+    def subpad(self, begin_y: int, begin_x: int) -> window:
+        """
+        subwin([nlines=0, ncols=0,] begin_y, begin_x)
+        Create a sub-window (screen-relative coordinates).
+
+          nlines
+            Height.
+          ncols
+            Width.
+          begin_y
+            Top side y-coordinate.
+          begin_x
+            Left side x-coordinate.
+
+        By default, the sub-window will extend from the specified position to the
+        lower right corner of the window.
+        """
+        ...
     @overload
-    def subpad(self, nlines: int, ncols: int, begin_y: int, begin_x: int) -> _CursesWindow: ...
+    def subpad(self, nlines: int, ncols: int, begin_y: int, begin_x: int) -> window:
+        """
+        subwin([nlines=0, ncols=0,] begin_y, begin_x)
+        Create a sub-window (screen-relative coordinates).
+
+          nlines
+            Height.
+          ncols
+            Width.
+          begin_y
+            Top side y-coordinate.
+          begin_x
+            Left side x-coordinate.
+
+        By default, the sub-window will extend from the specified position to the
+        lower right corner of the window.
+        """
+        ...
     @overload
-    def subwin(self, begin_y: int, begin_x: int) -> _CursesWindow: ...
+    def subwin(self, begin_y: int, begin_x: int) -> window:
+        """
+        subwin([nlines=0, ncols=0,] begin_y, begin_x)
+        Create a sub-window (screen-relative coordinates).
+
+          nlines
+            Height.
+          ncols
+            Width.
+          begin_y
+            Top side y-coordinate.
+          begin_x
+            Left side x-coordinate.
+
+        By default, the sub-window will extend from the specified position to the
+        lower right corner of the window.
+        """
+        ...
     @overload
-    def subwin(self, nlines: int, ncols: int, begin_y: int, begin_x: int) -> _CursesWindow: ...
+    def subwin(self, nlines: int, ncols: int, begin_y: int, begin_x: int) -> window:
+        """
+        subwin([nlines=0, ncols=0,] begin_y, begin_x)
+        Create a sub-window (screen-relative coordinates).
+
+          nlines
+            Height.
+          ncols
+            Width.
+          begin_y
+            Top side y-coordinate.
+          begin_x
+            Left side x-coordinate.
+
+        By default, the sub-window will extend from the specified position to the
+        lower right corner of the window.
+        """
+        ...
     def syncdown(self) -> None: ...
     def syncok(self, flag: bool) -> None: ...
     def syncup(self) -> None: ...
     def timeout(self, delay: int) -> None: ...
-    def touchline(self, start: int, count: int, changed: bool = ...) -> None: ...
+    def touchline(self, start: int, count: int, changed: bool = ...) -> None:
+        """
+        touchline(start, count, [changed=True])
+        Pretend count lines have been changed, starting with line start.
+
+        If changed is supplied, it specifies whether the affected lines are marked
+        as having been changed (changed=True) or unchanged (changed=False).
+        """
+        ...
     def touchwin(self) -> None: ...
     def untouchwin(self) -> None: ...
     @overload
-    def vline(self, ch: _ChType, n: int) -> None: ...
+    def vline(self, ch: _ChType, n: int) -> None:
+        """
+        vline([y, x,] ch, n, [attr=_curses.A_NORMAL])
+        Display a vertical line.
+
+          y
+            Starting Y-coordinate.
+          x
+            Starting X-coordinate.
+          ch
+            Character to draw.
+          n
+            Line length.
+          attr
+            Attributes for the character.
+        """
+        ...
     @overload
-    def vline(self, y: int, x: int, ch: _ChType, n: int) -> None: ...
+    def vline(self, y: int, x: int, ch: _ChType, n: int) -> None:
+        """
+        vline([y, x,] ch, n, [attr=_curses.A_NORMAL])
+        Display a vertical line.
+
+          y
+            Starting Y-coordinate.
+          x
+            Starting X-coordinate.
+          ch
+            Character to draw.
+          n
+            Line length.
+          attr
+            Attributes for the character.
+        """
+        ...
 
 class _ncurses_version(NamedTuple):
     major: int
@@ -1103,4 +1896,3 @@ class _ncurses_version(NamedTuple):
     patch: int
 
 ncurses_version: _ncurses_version
-window = _CursesWindow  # undocumented