diff --git a/mypy/typeshed/stdlib/_codecs.pyi b/mypy/typeshed/stdlib/_codecs.pyi
index 9241ac6a7038..232256fbf614 100644
--- a/mypy/typeshed/stdlib/_codecs.pyi
+++ b/mypy/typeshed/stdlib/_codecs.pyi
@@ -1,5 +1,6 @@
 import codecs
 import sys
+from _typeshed import ReadableBuffer
 from collections.abc import Callable
 from typing import overload
 from typing_extensions import Literal, TypeAlias
@@ -44,13 +45,13 @@ _BytesToBytesEncoding: TypeAlias = Literal[
 _StrToStrEncoding: TypeAlias = Literal["rot13", "rot_13"]
 
 @overload
-def encode(obj: bytes, encoding: _BytesToBytesEncoding, errors: str = ...) -> bytes: ...
+def encode(obj: ReadableBuffer, encoding: _BytesToBytesEncoding, errors: str = ...) -> bytes: ...
 @overload
 def encode(obj: str, encoding: _StrToStrEncoding, errors: str = ...) -> str: ...  # type: ignore[misc]
 @overload
 def encode(obj: str, encoding: str = ..., errors: str = ...) -> bytes: ...
 @overload
-def decode(obj: bytes, encoding: _BytesToBytesEncoding, errors: str = ...) -> bytes: ...  # type: ignore[misc]
+def decode(obj: ReadableBuffer, encoding: _BytesToBytesEncoding, errors: str = ...) -> bytes: ...  # type: ignore[misc]
 @overload
 def decode(obj: str, encoding: _StrToStrEncoding, errors: str = ...) -> str: ...
 
@@ -64,66 +65,72 @@ def decode(
 @overload
 def decode(obj: str, encoding: Literal["hex", "hex_codec"], errors: str = ...) -> bytes: ...
 @overload
-def decode(obj: bytes, encoding: str = ..., errors: str = ...) -> str: ...
+def decode(obj: ReadableBuffer, encoding: str = ..., errors: str = ...) -> str: ...
 def lookup(__encoding: str) -> codecs.CodecInfo: ...
 def charmap_build(__map: str) -> _CharMap: ...
-def ascii_decode(__data: bytes, __errors: str | None = ...) -> tuple[str, int]: ...
+def ascii_decode(__data: ReadableBuffer, __errors: str | None = ...) -> tuple[str, int]: ...
 def ascii_encode(__str: str, __errors: str | None = ...) -> tuple[bytes, int]: ...
-def charmap_decode(__data: bytes, __errors: str | None = ..., __mapping: _CharMap | None = ...) -> tuple[str, int]: ...
+def charmap_decode(__data: ReadableBuffer, __errors: str | None = ..., __mapping: _CharMap | None = ...) -> tuple[str, int]: ...
 def charmap_encode(__str: str, __errors: str | None = ..., __mapping: _CharMap | None = ...) -> tuple[bytes, int]: ...
-def escape_decode(__data: str | bytes, __errors: str | None = ...) -> tuple[str, int]: ...
+def escape_decode(__data: str | ReadableBuffer, __errors: str | None = ...) -> tuple[str, int]: ...
 def escape_encode(__data: bytes, __errors: str | None = ...) -> tuple[bytes, int]: ...
-def latin_1_decode(__data: bytes, __errors: str | None = ...) -> tuple[str, int]: ...
+def latin_1_decode(__data: ReadableBuffer, __errors: str | None = ...) -> tuple[str, int]: ...
 def latin_1_encode(__str: str, __errors: str | None = ...) -> tuple[bytes, int]: ...
 
 if sys.version_info >= (3, 9):
-    def raw_unicode_escape_decode(__data: str | bytes, __errors: str | None = ..., __final: bool = ...) -> tuple[str, int]: ...
+    def raw_unicode_escape_decode(
+        __data: str | ReadableBuffer, __errors: str | None = ..., __final: bool = ...
+    ) -> tuple[str, int]: ...
 
 else:
-    def raw_unicode_escape_decode(__data: str | bytes, __errors: str | None = ...) -> tuple[str, int]: ...
+    def raw_unicode_escape_decode(__data: str | ReadableBuffer, __errors: str | None = ...) -> tuple[str, int]: ...
 
 def raw_unicode_escape_encode(__str: str, __errors: str | None = ...) -> tuple[bytes, int]: ...
-def readbuffer_encode(__data: str | bytes, __errors: str | None = ...) -> tuple[bytes, int]: ...
+def readbuffer_encode(__data: str | ReadableBuffer, __errors: str | None = ...) -> tuple[bytes, int]: ...
 
 if sys.version_info >= (3, 9):
-    def unicode_escape_decode(__data: str | bytes, __errors: str | None = ..., __final: bool = ...) -> tuple[str, int]: ...
+    def unicode_escape_decode(
+        __data: str | ReadableBuffer, __errors: str | None = ..., __final: bool = ...
+    ) -> tuple[str, int]: ...
 
 else:
-    def unicode_escape_decode(__data: str | bytes, __errors: str | None = ...) -> tuple[str, int]: ...
+    def unicode_escape_decode(__data: str | ReadableBuffer, __errors: str | None = ...) -> tuple[str, int]: ...
 
 def unicode_escape_encode(__str: str, __errors: str | None = ...) -> tuple[bytes, int]: ...
 
 if sys.version_info < (3, 8):
-    def unicode_internal_decode(__obj: str | bytes, __errors: str | None = ...) -> tuple[str, int]: ...
-    def unicode_internal_encode(__obj: str | bytes, __errors: str | None = ...) -> tuple[bytes, int]: ...
+    def unicode_internal_decode(__obj: str | ReadableBuffer, __errors: str | None = ...) -> tuple[str, int]: ...
+    def unicode_internal_encode(__obj: str | ReadableBuffer, __errors: str | None = ...) -> tuple[bytes, int]: ...
 
-def utf_16_be_decode(__data: bytes, __errors: str | None = ..., __final: int = ...) -> tuple[str, int]: ...
+def utf_16_be_decode(__data: ReadableBuffer, __errors: str | None = ..., __final: int = ...) -> tuple[str, int]: ...
 def utf_16_be_encode(__str: str, __errors: str | None = ...) -> tuple[bytes, int]: ...
-def utf_16_decode(__data: bytes, __errors: str | None = ..., __final: int = ...) -> tuple[str, int]: ...
+def utf_16_decode(__data: ReadableBuffer, __errors: str | None = ..., __final: int = ...) -> tuple[str, int]: ...
 def utf_16_encode(__str: str, __errors: str | None = ..., __byteorder: int = ...) -> tuple[bytes, int]: ...
 def utf_16_ex_decode(
-    __data: bytes, __errors: str | None = ..., __byteorder: int = ..., __final: int = ...
+    __data: ReadableBuffer, __errors: str | None = ..., __byteorder: int = ..., __final: int = ...
 ) -> tuple[str, int, int]: ...
-def utf_16_le_decode(__data: bytes, __errors: str | None = ..., __final: int = ...) -> tuple[str, int]: ...
+def utf_16_le_decode(__data: ReadableBuffer, __errors: str | None = ..., __final: int = ...) -> tuple[str, int]: ...
 def utf_16_le_encode(__str: str, __errors: str | None = ...) -> tuple[bytes, int]: ...
-def utf_32_be_decode(__data: bytes, __errors: str | None = ..., __final: int = ...) -> tuple[str, int]: ...
+def utf_32_be_decode(__data: ReadableBuffer, __errors: str | None = ..., __final: int = ...) -> tuple[str, int]: ...
 def utf_32_be_encode(__str: str, __errors: str | None = ...) -> tuple[bytes, int]: ...
-def utf_32_decode(__data: bytes, __errors: str | None = ..., __final: int = ...) -> tuple[str, int]: ...
+def utf_32_decode(__data: ReadableBuffer, __errors: str | None = ..., __final: int = ...) -> tuple[str, int]: ...
 def utf_32_encode(__str: str, __errors: str | None = ..., __byteorder: int = ...) -> tuple[bytes, int]: ...
 def utf_32_ex_decode(
-    __data: bytes, __errors: str | None = ..., __byteorder: int = ..., __final: int = ...
+    __data: ReadableBuffer, __errors: str | None = ..., __byteorder: int = ..., __final: int = ...
 ) -> tuple[str, int, int]: ...
-def utf_32_le_decode(__data: bytes, __errors: str | None = ..., __final: int = ...) -> tuple[str, int]: ...
+def utf_32_le_decode(__data: ReadableBuffer, __errors: str | None = ..., __final: int = ...) -> tuple[str, int]: ...
 def utf_32_le_encode(__str: str, __errors: str | None = ...) -> tuple[bytes, int]: ...
-def utf_7_decode(__data: bytes, __errors: str | None = ..., __final: int = ...) -> tuple[str, int]: ...
+def utf_7_decode(__data: ReadableBuffer, __errors: str | None = ..., __final: int = ...) -> tuple[str, int]: ...
 def utf_7_encode(__str: str, __errors: str | None = ...) -> tuple[bytes, int]: ...
-def utf_8_decode(__data: bytes, __errors: str | None = ..., __final: int = ...) -> tuple[str, int]: ...
+def utf_8_decode(__data: ReadableBuffer, __errors: str | None = ..., __final: int = ...) -> tuple[str, int]: ...
 def utf_8_encode(__str: str, __errors: str | None = ...) -> tuple[bytes, int]: ...
 
 if sys.platform == "win32":
-    def mbcs_decode(__data: bytes, __errors: str | None = ..., __final: int = ...) -> tuple[str, int]: ...
+    def mbcs_decode(__data: ReadableBuffer, __errors: str | None = ..., __final: int = ...) -> tuple[str, int]: ...
     def mbcs_encode(__str: str, __errors: str | None = ...) -> tuple[bytes, int]: ...
-    def code_page_decode(__codepage: int, __data: bytes, __errors: str | None = ..., __final: int = ...) -> tuple[str, int]: ...
+    def code_page_decode(
+        __codepage: int, __data: ReadableBuffer, __errors: str | None = ..., __final: int = ...
+    ) -> tuple[str, int]: ...
     def code_page_encode(__code_page: int, __str: str, __errors: str | None = ...) -> tuple[bytes, int]: ...
-    def oem_decode(__data: bytes, __errors: str | None = ..., __final: int = ...) -> tuple[str, int]: ...
+    def oem_decode(__data: ReadableBuffer, __errors: str | None = ..., __final: int = ...) -> tuple[str, int]: ...
     def oem_encode(__str: str, __errors: str | None = ...) -> tuple[bytes, int]: ...
diff --git a/mypy/typeshed/stdlib/_curses.pyi b/mypy/typeshed/stdlib/_curses.pyi
index adb1ea84e45b..7053e85f7b7f 100644
--- a/mypy/typeshed/stdlib/_curses.pyi
+++ b/mypy/typeshed/stdlib/_curses.pyi
@@ -1,9 +1,10 @@
 import sys
-from _typeshed import SupportsRead
+from _typeshed import ReadOnlyBuffer, SupportsRead
 from typing import IO, Any, NamedTuple, overload
 from typing_extensions import TypeAlias, final
 
 if sys.platform != "win32":
+    # Handled by PyCurses_ConvertToChtype in _cursesmodule.c.
     _ChType: TypeAlias = str | bytes | int
 
     # ACS codes are only initialized after initscr is called
@@ -330,7 +331,7 @@ if sys.platform != "win32":
     def noraw() -> None: ...
     def pair_content(__pair_number: int) -> tuple[int, int]: ...
     def pair_number(__attr: int) -> int: ...
-    def putp(__string: bytes) -> None: ...
+    def putp(__string: ReadOnlyBuffer) -> None: ...
     def qiflush(__flag: bool = ...) -> None: ...
     def raw(__flag: bool = ...) -> None: ...
     def reset_prog_mode() -> None: ...
@@ -352,7 +353,7 @@ if sys.platform != "win32":
     def tigetnum(__capname: str) -> int: ...
     def tigetstr(__capname: str) -> bytes | None: ...
     def tparm(
-        __str: bytes,
+        __str: ReadOnlyBuffer,
         __i1: int = ...,
         __i2: int = ...,
         __i3: int = ...,
diff --git a/mypy/typeshed/stdlib/_msi.pyi b/mypy/typeshed/stdlib/_msi.pyi
index 9dda8a598549..1b86904d5ebc 100644
--- a/mypy/typeshed/stdlib/_msi.pyi
+++ b/mypy/typeshed/stdlib/_msi.pyi
@@ -12,11 +12,11 @@ if sys.platform == "win32":
         # Don't exist at runtime
         __new__: None  # type: ignore[assignment]
         __init__: None  # type: ignore[assignment]
-    # Actual typename Summary, not exposed by the implementation
-    class _Summary:
-        def GetProperty(self, propid: int) -> str | bytes | None: ...
+    # Actual typename SummaryInformation, not exposed by the implementation
+    class _SummaryInformation:
+        def GetProperty(self, field: int) -> int | bytes | None: ...
         def GetPropertyCount(self) -> int: ...
-        def SetProperty(self, propid: int, value: str | bytes) -> None: ...
+        def SetProperty(self, field: int, value: int | str) -> None: ...
         def Persist(self) -> None: ...
         # Don't exist at runtime
         __new__: None  # type: ignore[assignment]
@@ -25,7 +25,7 @@ if sys.platform == "win32":
     class _Database:
         def OpenView(self, sql: str) -> _View: ...
         def Commit(self) -> None: ...
-        def GetSummaryInformation(self, updateCount: int) -> _Summary: ...
+        def GetSummaryInformation(self, updateCount: int) -> _SummaryInformation: ...
         def Close(self) -> None: ...
         # Don't exist at runtime
         __new__: None  # type: ignore[assignment]
diff --git a/mypy/typeshed/stdlib/_posixsubprocess.pyi b/mypy/typeshed/stdlib/_posixsubprocess.pyi
index 2d221c4896f6..ca95336bb503 100644
--- a/mypy/typeshed/stdlib/_posixsubprocess.pyi
+++ b/mypy/typeshed/stdlib/_posixsubprocess.pyi
@@ -1,24 +1,32 @@
 import sys
+from _typeshed import StrOrBytesPath
 from collections.abc import Callable, Sequence
+from typing_extensions import SupportsIndex
 
 if sys.platform != "win32":
     def cloexec_pipe() -> tuple[int, int]: ...
     def fork_exec(
-        args: Sequence[str],
-        executable_list: Sequence[bytes],
-        close_fds: bool,
-        fds_to_keep: Sequence[int],
-        cwd: str,
-        env_list: Sequence[bytes],
-        p2cread: int,
-        p2cwrite: int,
-        c2pred: int,
-        c2pwrite: int,
-        errread: int,
-        errwrite: int,
-        errpipe_read: int,
-        errpipe_write: int,
-        restore_signals: int,
-        start_new_session: int,
-        preexec_fn: Callable[[], None],
+        __process_args: Sequence[StrOrBytesPath] | None,
+        __executable_list: Sequence[bytes],
+        __close_fds: bool,
+        __fds_to_keep: tuple[int, ...],
+        __cwd_obj: str,
+        __env_list: Sequence[bytes] | None,
+        __p2cread: int,
+        __p2cwrite: int,
+        __c2pred: int,
+        __c2pwrite: int,
+        __errread: int,
+        __errwrite: int,
+        __errpipe_read: int,
+        __errpipe_write: int,
+        __restore_signals: int,
+        __call_setsid: int,
+        __pgid_to_set: int,
+        __gid_object: SupportsIndex | None,
+        __groups_list: list[int] | None,
+        __uid_object: SupportsIndex | None,
+        __child_umask: int,
+        __preexec_fn: Callable[[], None],
+        __allow_vfork: bool,
     ) -> int: ...
diff --git a/mypy/typeshed/stdlib/_socket.pyi b/mypy/typeshed/stdlib/_socket.pyi
index b2f77893d273..df6b45a2d394 100644
--- a/mypy/typeshed/stdlib/_socket.pyi
+++ b/mypy/typeshed/stdlib/_socket.pyi
@@ -15,10 +15,10 @@ _CMSG: TypeAlias = tuple[int, int, bytes]
 _CMSGArg: TypeAlias = tuple[int, int, ReadableBuffer]
 
 # Addresses can be either tuples of varying lengths (AF_INET, AF_INET6,
-# AF_NETLINK, AF_TIPC) or strings (AF_UNIX).
-_Address: TypeAlias = tuple[Any, ...] | str
+# AF_NETLINK, AF_TIPC) or strings/buffers (AF_UNIX).
+# See getsockaddrarg() in socketmodule.c.
+_Address: TypeAlias = tuple[Any, ...] | str | ReadableBuffer
 _RetAddress: TypeAlias = Any
-# TODO Most methods allow bytes as address objects
 
 # ----- Constants -----
 # Some socket families are listed in the "Socket families" section of the docs,
@@ -584,10 +584,10 @@ class socket:
     @property
     def timeout(self) -> float | None: ...
     def __init__(self, family: int = ..., type: int = ..., proto: int = ..., fileno: _FD | None = ...) -> None: ...
-    def bind(self, __address: _Address | bytes) -> None: ...
+    def bind(self, __address: _Address) -> None: ...
     def close(self) -> None: ...
-    def connect(self, __address: _Address | bytes) -> None: ...
-    def connect_ex(self, __address: _Address | bytes) -> int: ...
+    def connect(self, __address: _Address) -> None: ...
+    def connect_ex(self, __address: _Address) -> int: ...
     def detach(self) -> int: ...
     def fileno(self) -> int: ...
     def getpeername(self) -> _RetAddress: ...
@@ -634,7 +634,7 @@ class socket:
     def setblocking(self, __flag: bool) -> None: ...
     def settimeout(self, __value: float | None) -> None: ...
     @overload
-    def setsockopt(self, __level: int, __optname: int, __value: int | bytes) -> None: ...
+    def setsockopt(self, __level: int, __optname: int, __value: int | ReadableBuffer) -> None: ...
     @overload
     def setsockopt(self, __level: int, __optname: int, __value: None, __optlen: int) -> None: ...
     if sys.platform == "win32":
@@ -671,9 +671,9 @@ def ntohs(__x: int) -> int: ...  # param & ret val are 16-bit ints
 def htonl(__x: int) -> int: ...  # param & ret val are 32-bit ints
 def htons(__x: int) -> int: ...  # param & ret val are 16-bit ints
 def inet_aton(__ip_string: str) -> bytes: ...  # ret val 4 bytes in length
-def inet_ntoa(__packed_ip: bytes) -> str: ...
+def inet_ntoa(__packed_ip: ReadableBuffer) -> str: ...
 def inet_pton(__address_family: int, __ip_string: str) -> bytes: ...
-def inet_ntop(__address_family: int, __packed_ip: bytes) -> str: ...
+def inet_ntop(__address_family: int, __packed_ip: ReadableBuffer) -> str: ...
 def getdefaulttimeout() -> float | None: ...
 def setdefaulttimeout(__timeout: float | None) -> None: ...
 
diff --git a/mypy/typeshed/stdlib/_tkinter.pyi b/mypy/typeshed/stdlib/_tkinter.pyi
index c2cf55505afb..fced8c95d2fa 100644
--- a/mypy/typeshed/stdlib/_tkinter.pyi
+++ b/mypy/typeshed/stdlib/_tkinter.pyi
@@ -17,8 +17,10 @@ from typing_extensions import Literal, final
 #    (<textindex object: '1.0'>, <textindex object: '2.0'>)
 @final
 class Tcl_Obj:
-    string: str | bytes
-    typename: str
+    @property
+    def string(self) -> str: ...
+    @property
+    def typename(self) -> str: ...
     __hash__: ClassVar[None]  # type: ignore[assignment]
     def __eq__(self, __other): ...
     def __ge__(self, __other): ...
diff --git a/mypy/typeshed/stdlib/_typeshed/__init__.pyi b/mypy/typeshed/stdlib/_typeshed/__init__.pyi
index b0ee1f4ad48a..849078e9462e 100644
--- a/mypy/typeshed/stdlib/_typeshed/__init__.pyi
+++ b/mypy/typeshed/stdlib/_typeshed/__init__.pyi
@@ -234,6 +234,7 @@ else:
     WriteableBuffer: TypeAlias = bytearray | memoryview | array.array[Any] | mmap.mmap | ctypes._CData  # stable
 # Same as _WriteableBuffer, but also includes read-only buffer types (like bytes).
 ReadableBuffer: TypeAlias = ReadOnlyBuffer | WriteableBuffer  # stable
+_BufferWithLen: TypeAlias = ReadableBuffer  # not stable  # noqa: Y047
 
 ExcInfo: TypeAlias = tuple[type[BaseException], BaseException, TracebackType]
 OptExcInfo: TypeAlias = Union[ExcInfo, tuple[None, None, None]]
diff --git a/mypy/typeshed/stdlib/_winapi.pyi b/mypy/typeshed/stdlib/_winapi.pyi
index ddea3d67ed14..3ccac7e6b7e6 100644
--- a/mypy/typeshed/stdlib/_winapi.pyi
+++ b/mypy/typeshed/stdlib/_winapi.pyi
@@ -1,4 +1,5 @@
 import sys
+from _typeshed import ReadableBuffer
 from collections.abc import Sequence
 from typing import Any, NoReturn, overload
 from typing_extensions import Literal, final
@@ -198,11 +199,11 @@ if sys.platform == "win32":
     def WaitForSingleObject(__handle: int, __milliseconds: int) -> int: ...
     def WaitNamedPipe(__name: str, __timeout: int) -> None: ...
     @overload
-    def WriteFile(handle: int, buffer: bytes, overlapped: Literal[True]) -> tuple[Overlapped, int]: ...
+    def WriteFile(handle: int, buffer: ReadableBuffer, overlapped: Literal[True]) -> tuple[Overlapped, int]: ...
     @overload
-    def WriteFile(handle: int, buffer: bytes, overlapped: Literal[False] = ...) -> tuple[int, int]: ...
+    def WriteFile(handle: int, buffer: ReadableBuffer, overlapped: Literal[False] = ...) -> tuple[int, int]: ...
     @overload
-    def WriteFile(handle: int, buffer: bytes, overlapped: int | bool) -> tuple[Any, int]: ...
+    def WriteFile(handle: int, buffer: ReadableBuffer, overlapped: int | bool) -> tuple[Any, int]: ...
     @final
     class Overlapped:
         event: int
diff --git a/mypy/typeshed/stdlib/abc.pyi b/mypy/typeshed/stdlib/abc.pyi
index f7f82333a362..110eba24a9ca 100644
--- a/mypy/typeshed/stdlib/abc.pyi
+++ b/mypy/typeshed/stdlib/abc.pyi
@@ -16,10 +16,7 @@ class ABCMeta(type):
             __mcls: type[Self], __name: str, __bases: tuple[type, ...], __namespace: dict[str, Any], **kwargs: Any
         ) -> Self: ...
     else:
-        # pyright doesn't like the first parameter being called mcls, hence the `pyright: ignore`
-        def __new__(
-            mcls: type[Self], name: str, bases: tuple[type, ...], namespace: dict[str, Any], **kwargs: Any  # pyright: ignore
-        ) -> Self: ...
+        def __new__(mcls: type[Self], name: str, bases: tuple[type, ...], namespace: dict[str, Any], **kwargs: Any) -> Self: ...
 
     def __instancecheck__(cls: ABCMeta, instance: Any) -> Any: ...
     def __subclasscheck__(cls: ABCMeta, subclass: Any) -> Any: ...
diff --git a/mypy/typeshed/stdlib/antigravity.pyi b/mypy/typeshed/stdlib/antigravity.pyi
index e30917511030..3986e7d1c9f2 100644
--- a/mypy/typeshed/stdlib/antigravity.pyi
+++ b/mypy/typeshed/stdlib/antigravity.pyi
@@ -1 +1,3 @@
-def geohash(latitude: float, longitude: float, datedow: bytes) -> None: ...
+from _typeshed import ReadableBuffer
+
+def geohash(latitude: float, longitude: float, datedow: ReadableBuffer) -> None: ...
diff --git a/mypy/typeshed/stdlib/array.pyi b/mypy/typeshed/stdlib/array.pyi
index 2d27cd72e8df..e84456049df6 100644
--- a/mypy/typeshed/stdlib/array.pyi
+++ b/mypy/typeshed/stdlib/array.pyi
@@ -21,15 +21,19 @@ class array(MutableSequence[_T], Generic[_T]):
     @property
     def itemsize(self) -> int: ...
     @overload
-    def __init__(self: array[int], __typecode: _IntTypeCode, __initializer: bytes | Iterable[int] = ...) -> None: ...
+    def __init__(self: array[int], __typecode: _IntTypeCode, __initializer: bytes | bytearray | Iterable[int] = ...) -> None: ...
     @overload
-    def __init__(self: array[float], __typecode: _FloatTypeCode, __initializer: bytes | Iterable[float] = ...) -> None: ...
+    def __init__(
+        self: array[float], __typecode: _FloatTypeCode, __initializer: bytes | bytearray | Iterable[float] = ...
+    ) -> None: ...
     @overload
-    def __init__(self: array[str], __typecode: _UnicodeTypeCode, __initializer: bytes | Iterable[str] = ...) -> None: ...
+    def __init__(
+        self: array[str], __typecode: _UnicodeTypeCode, __initializer: bytes | bytearray | Iterable[str] = ...
+    ) -> None: ...
     @overload
     def __init__(self, __typecode: str, __initializer: Iterable[_T]) -> None: ...
     @overload
-    def __init__(self, __typecode: str, __initializer: bytes = ...) -> None: ...
+    def __init__(self, __typecode: str, __initializer: bytes | bytearray = ...) -> None: ...
     def append(self, __v: _T) -> None: ...
     def buffer_info(self) -> tuple[int, int]: ...
     def byteswap(self) -> None: ...
@@ -52,7 +56,7 @@ class array(MutableSequence[_T], Generic[_T]):
     def tolist(self) -> list[_T]: ...
     def tounicode(self) -> str: ...
     if sys.version_info < (3, 9):
-        def fromstring(self, __buffer: bytes) -> None: ...
+        def fromstring(self, __buffer: str | ReadableBuffer) -> None: ...
         def tostring(self) -> bytes: ...
 
     def __len__(self) -> int: ...
diff --git a/mypy/typeshed/stdlib/ast.pyi b/mypy/typeshed/stdlib/ast.pyi
index 6c9dbd0162b8..56c86c950f0c 100644
--- a/mypy/typeshed/stdlib/ast.pyi
+++ b/mypy/typeshed/stdlib/ast.pyi
@@ -1,5 +1,7 @@
+import os
 import sys
 from _ast import *
+from _typeshed import ReadableBuffer
 from collections.abc import Iterator
 from typing import Any, TypeVar, overload
 from typing_extensions import Literal
@@ -157,8 +159,8 @@ _T = TypeVar("_T", bound=AST)
 if sys.version_info >= (3, 8):
     @overload
     def parse(
-        source: str | bytes,
-        filename: str | bytes = ...,
+        source: str | ReadableBuffer,
+        filename: str | ReadableBuffer | os.PathLike[Any] = ...,
         mode: Literal["exec"] = ...,
         *,
         type_comments: bool = ...,
@@ -166,8 +168,8 @@ if sys.version_info >= (3, 8):
     ) -> Module: ...
     @overload
     def parse(
-        source: str | bytes,
-        filename: str | bytes,
+        source: str | ReadableBuffer,
+        filename: str | ReadableBuffer | os.PathLike[Any],
         mode: Literal["eval"],
         *,
         type_comments: bool = ...,
@@ -175,8 +177,8 @@ if sys.version_info >= (3, 8):
     ) -> Expression: ...
     @overload
     def parse(
-        source: str | bytes,
-        filename: str | bytes,
+        source: str | ReadableBuffer,
+        filename: str | ReadableBuffer | os.PathLike[Any],
         mode: Literal["func_type"],
         *,
         type_comments: bool = ...,
@@ -184,8 +186,8 @@ if sys.version_info >= (3, 8):
     ) -> FunctionType: ...
     @overload
     def parse(
-        source: str | bytes,
-        filename: str | bytes,
+        source: str | ReadableBuffer,
+        filename: str | ReadableBuffer | os.PathLike[Any],
         mode: Literal["single"],
         *,
         type_comments: bool = ...,
@@ -193,7 +195,7 @@ if sys.version_info >= (3, 8):
     ) -> Interactive: ...
     @overload
     def parse(
-        source: str | bytes,
+        source: str | ReadableBuffer,
         *,
         mode: Literal["eval"],
         type_comments: bool = ...,
@@ -201,7 +203,7 @@ if sys.version_info >= (3, 8):
     ) -> Expression: ...
     @overload
     def parse(
-        source: str | bytes,
+        source: str | ReadableBuffer,
         *,
         mode: Literal["func_type"],
         type_comments: bool = ...,
@@ -209,7 +211,7 @@ if sys.version_info >= (3, 8):
     ) -> FunctionType: ...
     @overload
     def parse(
-        source: str | bytes,
+        source: str | ReadableBuffer,
         *,
         mode: Literal["single"],
         type_comments: bool = ...,
@@ -217,8 +219,8 @@ if sys.version_info >= (3, 8):
     ) -> Interactive: ...
     @overload
     def parse(
-        source: str | bytes,
-        filename: str | bytes = ...,
+        source: str | ReadableBuffer,
+        filename: str | ReadableBuffer | os.PathLike[Any] = ...,
         mode: str = ...,
         *,
         type_comments: bool = ...,
@@ -227,17 +229,23 @@ if sys.version_info >= (3, 8):
 
 else:
     @overload
-    def parse(source: str | bytes, filename: str | bytes = ..., mode: Literal["exec"] = ...) -> Module: ...
+    def parse(
+        source: str | ReadableBuffer, filename: str | ReadableBuffer | os.PathLike[Any] = ..., mode: Literal["exec"] = ...
+    ) -> Module: ...
     @overload
-    def parse(source: str | bytes, filename: str | bytes, mode: Literal["eval"]) -> Expression: ...
+    def parse(
+        source: str | ReadableBuffer, filename: str | ReadableBuffer | os.PathLike[Any], mode: Literal["eval"]
+    ) -> Expression: ...
     @overload
-    def parse(source: str | bytes, filename: str | bytes, mode: Literal["single"]) -> Interactive: ...
+    def parse(
+        source: str | ReadableBuffer, filename: str | ReadableBuffer | os.PathLike[Any], mode: Literal["single"]
+    ) -> Interactive: ...
     @overload
-    def parse(source: str | bytes, *, mode: Literal["eval"]) -> Expression: ...
+    def parse(source: str | ReadableBuffer, *, mode: Literal["eval"]) -> Expression: ...
     @overload
-    def parse(source: str | bytes, *, mode: Literal["single"]) -> Interactive: ...
+    def parse(source: str | ReadableBuffer, *, mode: Literal["single"]) -> Interactive: ...
     @overload
-    def parse(source: str | bytes, filename: str | bytes = ..., mode: str = ...) -> AST: ...
+    def parse(source: str | ReadableBuffer, filename: str | ReadableBuffer | os.PathLike[Any] = ..., mode: str = ...) -> AST: ...
 
 if sys.version_info >= (3, 9):
     def unparse(ast_obj: AST) -> str: ...
diff --git a/mypy/typeshed/stdlib/asyncio/base_events.pyi b/mypy/typeshed/stdlib/asyncio/base_events.pyi
index 8697bfe306c4..c1ab114b6036 100644
--- a/mypy/typeshed/stdlib/asyncio/base_events.pyi
+++ b/mypy/typeshed/stdlib/asyncio/base_events.pyi
@@ -1,6 +1,6 @@
 import ssl
 import sys
-from _typeshed import FileDescriptorLike, WriteableBuffer
+from _typeshed import FileDescriptorLike, ReadableBuffer, WriteableBuffer
 from asyncio.events import AbstractEventLoop, AbstractServer, Handle, TimerHandle, _TaskFactory
 from asyncio.futures import Future
 from asyncio.protocols import BaseProtocol
@@ -102,7 +102,7 @@ class BaseEventLoop(AbstractEventLoop):
     async def getaddrinfo(
         self,
         host: bytes | str | None,
-        port: str | int | None,
+        port: bytes | str | int | None,
         *,
         family: int = ...,
         type: int = ...,
@@ -411,13 +411,13 @@ class BaseEventLoop(AbstractEventLoop):
     # BaseEventLoop, only on subclasses. We list them here for now for convenience.
     async def sock_recv(self, sock: socket, nbytes: int) -> bytes: ...
     async def sock_recv_into(self, sock: socket, buf: WriteableBuffer) -> int: ...
-    async def sock_sendall(self, sock: socket, data: bytes) -> None: ...
+    async def sock_sendall(self, sock: socket, data: ReadableBuffer) -> None: ...
     async def sock_connect(self, sock: socket, address: _Address) -> None: ...
     async def sock_accept(self, sock: socket) -> tuple[socket, _RetAddress]: ...
     if sys.version_info >= (3, 11):
         async def sock_recvfrom(self, sock: socket, bufsize: int) -> bytes: ...
         async def sock_recvfrom_into(self, sock: socket, buf: WriteableBuffer, nbytes: int = ...) -> int: ...
-        async def sock_sendto(self, sock: socket, data: bytes, address: _Address) -> None: ...
+        async def sock_sendto(self, sock: socket, data: ReadableBuffer, address: _Address) -> None: ...
     # Signal handling.
     def add_signal_handler(self, sig: int, callback: Callable[..., Any], *args: Any) -> None: ...
     def remove_signal_handler(self, sig: int) -> bool: ...
diff --git a/mypy/typeshed/stdlib/asyncio/events.pyi b/mypy/typeshed/stdlib/asyncio/events.pyi
index 586116136c1a..280be4ab5ba9 100644
--- a/mypy/typeshed/stdlib/asyncio/events.pyi
+++ b/mypy/typeshed/stdlib/asyncio/events.pyi
@@ -1,6 +1,6 @@
 import ssl
 import sys
-from _typeshed import FileDescriptorLike, Self, StrPath, WriteableBuffer
+from _typeshed import FileDescriptorLike, ReadableBuffer, Self, StrPath, WriteableBuffer
 from abc import ABCMeta, abstractmethod
 from collections.abc import Awaitable, Callable, Coroutine, Generator, Sequence
 from contextvars import Context
@@ -194,7 +194,7 @@ class AbstractEventLoop:
     async def getaddrinfo(
         self,
         host: bytes | str | None,
-        port: str | int | None,
+        port: bytes | str | int | None,
         *,
         family: int = ...,
         type: int = ...,
@@ -562,7 +562,7 @@ class AbstractEventLoop:
     @abstractmethod
     async def sock_recv_into(self, sock: socket, buf: WriteableBuffer) -> int: ...
     @abstractmethod
-    async def sock_sendall(self, sock: socket, data: bytes) -> None: ...
+    async def sock_sendall(self, sock: socket, data: ReadableBuffer) -> None: ...
     @abstractmethod
     async def sock_connect(self, sock: socket, address: _Address) -> None: ...
     @abstractmethod
@@ -573,7 +573,7 @@ class AbstractEventLoop:
         @abstractmethod
         async def sock_recvfrom_into(self, sock: socket, buf: WriteableBuffer, nbytes: int = ...) -> int: ...
         @abstractmethod
-        async def sock_sendto(self, sock: socket, data: bytes, address: _Address) -> None: ...
+        async def sock_sendto(self, sock: socket, data: ReadableBuffer, address: _Address) -> None: ...
     # Signal handling.
     @abstractmethod
     def add_signal_handler(self, sig: int, callback: Callable[..., object], *args: Any) -> None: ...
diff --git a/mypy/typeshed/stdlib/asyncio/sslproto.pyi b/mypy/typeshed/stdlib/asyncio/sslproto.pyi
index 3bb4db69c123..3c1c7b2e4edb 100644
--- a/mypy/typeshed/stdlib/asyncio/sslproto.pyi
+++ b/mypy/typeshed/stdlib/asyncio/sslproto.pyi
@@ -74,7 +74,7 @@ class _SSLProtocolTransport(transports._FlowControlMixin, transports.Transport):
     def get_extra_info(self, name: str, default: Any | None = ...) -> dict[str, Any]: ...
     @property
     def _protocol_paused(self) -> bool: ...
-    def write(self, data: bytes) -> None: ...
+    def write(self, data: bytes | bytearray | memoryview) -> None: ...
     def can_write_eof(self) -> Literal[False]: ...
     if sys.version_info >= (3, 11):
         def get_write_buffer_limits(self) -> tuple[int, int]: ...
diff --git a/mypy/typeshed/stdlib/asyncio/streams.pyi b/mypy/typeshed/stdlib/asyncio/streams.pyi
index 139d86b292c3..00d95d93f2ff 100644
--- a/mypy/typeshed/stdlib/asyncio/streams.pyi
+++ b/mypy/typeshed/stdlib/asyncio/streams.pyi
@@ -3,7 +3,7 @@ import sys
 from _typeshed import Self, StrPath
 from collections.abc import AsyncIterator, Awaitable, Callable, Iterable, Sequence
 from typing import Any
-from typing_extensions import TypeAlias
+from typing_extensions import SupportsIndex, TypeAlias
 
 from . import events, protocols, transports
 from .base_events import Server
@@ -139,8 +139,8 @@ class StreamWriter:
     ) -> None: ...
     @property
     def transport(self) -> transports.WriteTransport: ...
-    def write(self, data: bytes) -> None: ...
-    def writelines(self, data: Iterable[bytes]) -> None: ...
+    def write(self, data: bytes | bytearray | memoryview) -> None: ...
+    def writelines(self, data: Iterable[bytes | bytearray | memoryview]) -> None: ...
     def write_eof(self) -> None: ...
     def can_write_eof(self) -> bool: ...
     def close(self) -> None: ...
@@ -160,9 +160,10 @@ class StreamReader(AsyncIterator[bytes]):
     def set_transport(self, transport: transports.BaseTransport) -> None: ...
     def feed_eof(self) -> None: ...
     def at_eof(self) -> bool: ...
-    def feed_data(self, data: bytes) -> None: ...
+    def feed_data(self, data: Iterable[SupportsIndex]) -> None: ...
     async def readline(self) -> bytes: ...
-    async def readuntil(self, separator: bytes = ...) -> bytes: ...
+    # Can be any buffer that supports len(); consider changing to a Protocol if PEP 688 is accepted
+    async def readuntil(self, separator: bytes | bytearray | memoryview = ...) -> bytes: ...
     async def read(self, n: int = ...) -> bytes: ...
     async def readexactly(self, n: int) -> bytes: ...
     def __aiter__(self: Self) -> Self: ...
diff --git a/mypy/typeshed/stdlib/asyncio/subprocess.pyi b/mypy/typeshed/stdlib/asyncio/subprocess.pyi
index 32fcf1a65491..7fb588396905 100644
--- a/mypy/typeshed/stdlib/asyncio/subprocess.pyi
+++ b/mypy/typeshed/stdlib/asyncio/subprocess.pyi
@@ -38,7 +38,7 @@ class Process:
     def send_signal(self, signal: int) -> None: ...
     def terminate(self) -> None: ...
     def kill(self) -> None: ...
-    async def communicate(self, input: bytes | None = ...) -> tuple[bytes, bytes]: ...
+    async def communicate(self, input: bytes | bytearray | memoryview | None = ...) -> tuple[bytes, bytes]: ...
 
 if sys.version_info >= (3, 10):
     async def create_subprocess_shell(
diff --git a/mypy/typeshed/stdlib/asyncio/transports.pyi b/mypy/typeshed/stdlib/asyncio/transports.pyi
index 3eb3d1ae3173..893292dd12b6 100644
--- a/mypy/typeshed/stdlib/asyncio/transports.pyi
+++ b/mypy/typeshed/stdlib/asyncio/transports.pyi
@@ -23,8 +23,8 @@ class WriteTransport(BaseTransport):
     def set_write_buffer_limits(self, high: int | None = ..., low: int | None = ...) -> None: ...
     def get_write_buffer_size(self) -> int: ...
     def get_write_buffer_limits(self) -> tuple[int, int]: ...
-    def write(self, data: bytes) -> None: ...
-    def writelines(self, list_of_data: Iterable[bytes]) -> None: ...
+    def write(self, data: bytes | bytearray | memoryview) -> None: ...
+    def writelines(self, list_of_data: Iterable[bytes | bytearray | memoryview]) -> None: ...
     def write_eof(self) -> None: ...
     def can_write_eof(self) -> bool: ...
     def abort(self) -> None: ...
@@ -32,7 +32,7 @@ class WriteTransport(BaseTransport):
 class Transport(ReadTransport, WriteTransport): ...
 
 class DatagramTransport(BaseTransport):
-    def sendto(self, data: bytes, addr: _Address | None = ...) -> None: ...
+    def sendto(self, data: bytes | bytearray | memoryview, addr: _Address | None = ...) -> None: ...
     def abort(self) -> None: ...
 
 class SubprocessTransport(BaseTransport):
diff --git a/mypy/typeshed/stdlib/asyncio/trsock.pyi b/mypy/typeshed/stdlib/asyncio/trsock.pyi
index b8972e43d255..742216a84ccd 100644
--- a/mypy/typeshed/stdlib/asyncio/trsock.pyi
+++ b/mypy/typeshed/stdlib/asyncio/trsock.pyi
@@ -1,5 +1,6 @@
 import socket
 import sys
+from _typeshed import ReadableBuffer
 from builtins import type as Type  # alias to avoid name clashes with property named "type"
 from collections.abc import Iterable
 from types import TracebackType
@@ -7,7 +8,7 @@ from typing import Any, BinaryIO, NoReturn, overload
 from typing_extensions import TypeAlias
 
 # These are based in socket, maybe move them out into _typeshed.pyi or such
-_Address: TypeAlias = tuple[Any, ...] | str
+_Address: TypeAlias = socket._Address
 _RetAddress: TypeAlias = Any
 _WriteBuffer: TypeAlias = bytearray | memoryview
 _CMSG: TypeAlias = tuple[int, int, bytes]
@@ -30,7 +31,7 @@ class TransportSocket:
     @overload
     def getsockopt(self, level: int, optname: int, buflen: int) -> bytes: ...
     @overload
-    def setsockopt(self, level: int, optname: int, value: int | bytes) -> None: ...
+    def setsockopt(self, level: int, optname: int, value: int | ReadableBuffer) -> None: ...
     @overload
     def setsockopt(self, level: int, optname: int, value: None, optlen: int) -> None: ...
     def getpeername(self) -> _RetAddress: ...
@@ -42,9 +43,9 @@ class TransportSocket:
     if sys.version_info < (3, 11):
         def _na(self, what: str) -> None: ...
         def accept(self) -> tuple[socket.socket, _RetAddress]: ...
-        def connect(self, address: _Address | bytes) -> None: ...
-        def connect_ex(self, address: _Address | bytes) -> int: ...
-        def bind(self, address: _Address | bytes) -> None: ...
+        def connect(self, address: _Address) -> None: ...
+        def connect_ex(self, address: _Address) -> int: ...
+        def bind(self, address: _Address) -> None: ...
         if sys.platform == "win32":
             def ioctl(self, control: int, option: int | tuple[int, int, int] | bool) -> None: ...
         else:
@@ -57,22 +58,26 @@ class TransportSocket:
         def detach(self) -> int: ...
         if sys.platform == "linux":
             def sendmsg_afalg(
-                self, msg: Iterable[bytes] = ..., *, op: int, iv: Any = ..., assoclen: int = ..., flags: int = ...
+                self, msg: Iterable[ReadableBuffer] = ..., *, op: int, iv: Any = ..., assoclen: int = ..., flags: int = ...
             ) -> int: ...
         else:
             def sendmsg_afalg(
-                self, msg: Iterable[bytes] = ..., *, op: int, iv: Any = ..., assoclen: int = ..., flags: int = ...
+                self, msg: Iterable[ReadableBuffer] = ..., *, op: int, iv: Any = ..., assoclen: int = ..., flags: int = ...
             ) -> NoReturn: ...
 
         def sendmsg(
-            self, __buffers: Iterable[bytes], __ancdata: Iterable[_CMSG] = ..., __flags: int = ..., __address: _Address = ...
+            self,
+            __buffers: Iterable[ReadableBuffer],
+            __ancdata: Iterable[_CMSG] = ...,
+            __flags: int = ...,
+            __address: _Address = ...,
         ) -> int: ...
         @overload
-        def sendto(self, data: bytes, address: _Address) -> int: ...
+        def sendto(self, data: ReadableBuffer, address: _Address) -> int: ...
         @overload
-        def sendto(self, data: bytes, flags: int, address: _Address) -> int: ...
-        def send(self, data: bytes, flags: int = ...) -> int: ...
-        def sendall(self, data: bytes, flags: int = ...) -> None: ...
+        def sendto(self, data: ReadableBuffer, flags: int, address: _Address) -> int: ...
+        def send(self, data: ReadableBuffer, flags: int = ...) -> int: ...
+        def sendall(self, data: ReadableBuffer, flags: int = ...) -> None: ...
         def set_inheritable(self, inheritable: bool) -> None: ...
         if sys.platform == "win32":
             def share(self, process_id: int) -> bytes: ...
diff --git a/mypy/typeshed/stdlib/asyncio/windows_events.pyi b/mypy/typeshed/stdlib/asyncio/windows_events.pyi
index ffb487fff03a..dca06ea33b13 100644
--- a/mypy/typeshed/stdlib/asyncio/windows_events.pyi
+++ b/mypy/typeshed/stdlib/asyncio/windows_events.pyi
@@ -1,6 +1,6 @@
 import socket
 import sys
-from _typeshed import WriteableBuffer
+from _typeshed import Incomplete, WriteableBuffer
 from collections.abc import Callable
 from typing import IO, Any, ClassVar, NoReturn
 from typing_extensions import Literal
@@ -50,10 +50,14 @@ if sys.platform == "win32":
         def recv_into(self, conn: socket.socket, buf: WriteableBuffer, flags: int = ...) -> futures.Future[Any]: ...
         def send(self, conn: socket.socket, buf: WriteableBuffer, flags: int = ...) -> futures.Future[Any]: ...
         def accept(self, listener: socket.socket) -> futures.Future[Any]: ...
-        def connect(self, conn: socket.socket, address: bytes) -> futures.Future[Any]: ...
+        def connect(
+            self,
+            conn: socket.socket,
+            address: tuple[Incomplete, Incomplete] | tuple[Incomplete, Incomplete, Incomplete, Incomplete],
+        ) -> futures.Future[Any]: ...
         def sendfile(self, sock: socket.socket, file: IO[bytes], offset: int, count: int) -> futures.Future[Any]: ...
         def accept_pipe(self, pipe: socket.socket) -> futures.Future[Any]: ...
-        async def connect_pipe(self, address: bytes) -> windows_utils.PipeHandle: ...
+        async def connect_pipe(self, address: str) -> windows_utils.PipeHandle: ...
         def wait_for_handle(self, handle: windows_utils.PipeHandle, timeout: int | None = ...) -> bool: ...
         def close(self) -> None: ...
     SelectorEventLoop = _WindowsSelectorEventLoop
diff --git a/mypy/typeshed/stdlib/asyncore.pyi b/mypy/typeshed/stdlib/asyncore.pyi
index 0025ec3f9b4e..565deb4d1cad 100644
--- a/mypy/typeshed/stdlib/asyncore.pyi
+++ b/mypy/typeshed/stdlib/asyncore.pyi
@@ -1,5 +1,5 @@
 import sys
-from _typeshed import FileDescriptorLike
+from _typeshed import FileDescriptorLike, ReadableBuffer
 from socket import socket
 from typing import Any, overload
 from typing_extensions import TypeAlias
@@ -45,7 +45,7 @@ class dispatcher:
     def bind(self, addr: tuple[Any, ...] | str) -> None: ...
     def connect(self, address: tuple[Any, ...] | str) -> None: ...
     def accept(self) -> tuple[_Socket, Any] | None: ...
-    def send(self, data: bytes) -> int: ...
+    def send(self, data: ReadableBuffer) -> int: ...
     def recv(self, buffer_size: int) -> bytes: ...
     def close(self) -> None: ...
     def log(self, message: Any) -> None: ...
diff --git a/mypy/typeshed/stdlib/base64.pyi b/mypy/typeshed/stdlib/base64.pyi
index c2ec85cac40a..816622eeb071 100644
--- a/mypy/typeshed/stdlib/base64.pyi
+++ b/mypy/typeshed/stdlib/base64.pyi
@@ -42,7 +42,9 @@ if sys.version_info >= (3, 10):
     def b32hexdecode(s: str | ReadableBuffer, casefold: bool = ...) -> bytes: ...
 
 def a85encode(b: ReadableBuffer, *, foldspaces: bool = ..., wrapcol: int = ..., pad: bool = ..., adobe: bool = ...) -> bytes: ...
-def a85decode(b: str | ReadableBuffer, *, foldspaces: bool = ..., adobe: bool = ..., ignorechars: str | bytes = ...) -> bytes: ...
+def a85decode(
+    b: str | ReadableBuffer, *, foldspaces: bool = ..., adobe: bool = ..., ignorechars: bytearray | bytes = ...
+) -> bytes: ...
 def b85encode(b: ReadableBuffer, pad: bool = ...) -> bytes: ...
 def b85decode(b: str | ReadableBuffer) -> bytes: ...
 def decode(input: IO[bytes], output: IO[bytes]) -> None: ...
diff --git a/mypy/typeshed/stdlib/binhex.pyi b/mypy/typeshed/stdlib/binhex.pyi
index 639d30d1d0de..e0993c840ce7 100644
--- a/mypy/typeshed/stdlib/binhex.pyi
+++ b/mypy/typeshed/stdlib/binhex.pyi
@@ -1,3 +1,4 @@
+from _typeshed import _BufferWithLen
 from typing import IO, Any
 from typing_extensions import Literal, TypeAlias
 
@@ -27,9 +28,9 @@ class openrsrc:
 
 class BinHex:
     def __init__(self, name_finfo_dlen_rlen: _FileInfoTuple, ofp: _FileHandleUnion) -> None: ...
-    def write(self, data: bytes) -> None: ...
+    def write(self, data: _BufferWithLen) -> None: ...
     def close_data(self) -> None: ...
-    def write_rsrc(self, data: bytes) -> None: ...
+    def write_rsrc(self, data: _BufferWithLen) -> None: ...
     def close(self) -> None: ...
 
 def binhex(inp: str, out: str) -> None: ...
diff --git a/mypy/typeshed/stdlib/builtins.pyi b/mypy/typeshed/stdlib/builtins.pyi
index d3b3f677b370..f9433663a7c8 100644
--- a/mypy/typeshed/stdlib/builtins.pyi
+++ b/mypy/typeshed/stdlib/builtins.pyi
@@ -55,7 +55,7 @@ from typing import (  # noqa: Y027
     overload,
     type_check_only,
 )
-from typing_extensions import Literal, SupportsIndex, TypeAlias, TypeGuard, final
+from typing_extensions import Literal, LiteralString, SupportsIndex, TypeAlias, TypeGuard, final
 
 if sys.version_info >= (3, 9):
     from types import GenericAlias
@@ -299,7 +299,7 @@ class int:
     def __index__(self) -> int: ...
 
 class float:
-    def __new__(cls: type[Self], x: SupportsFloat | SupportsIndex | str | ReadableBuffer = ...) -> Self: ...
+    def __new__(cls: type[Self], __x: SupportsFloat | SupportsIndex | str | ReadableBuffer = ...) -> Self: ...
     def as_integer_ratio(self) -> tuple[int, int]: ...
     def hex(self) -> str: ...
     def is_integer(self) -> bool: ...
@@ -414,8 +414,17 @@ class str(Sequence[str]):
     def __new__(cls: type[Self], object: object = ...) -> Self: ...
     @overload
     def __new__(cls: type[Self], object: ReadableBuffer, encoding: str = ..., errors: str = ...) -> Self: ...
+    @overload
+    def capitalize(self: LiteralString) -> LiteralString: ...
+    @overload
     def capitalize(self) -> str: ...  # type: ignore[misc]
+    @overload
+    def casefold(self: LiteralString) -> LiteralString: ...
+    @overload
     def casefold(self) -> str: ...  # type: ignore[misc]
+    @overload
+    def center(self: LiteralString, __width: SupportsIndex, __fillchar: LiteralString = ...) -> LiteralString: ...
+    @overload
     def center(self, __width: SupportsIndex, __fillchar: str = ...) -> str: ...  # type: ignore[misc]
     def count(self, x: str, __start: SupportsIndex | None = ..., __end: SupportsIndex | None = ...) -> int: ...
     def encode(self, encoding: str = ..., errors: str = ...) -> bytes: ...
@@ -423,11 +432,20 @@ class str(Sequence[str]):
         self, __suffix: str | tuple[str, ...], __start: SupportsIndex | None = ..., __end: SupportsIndex | None = ...
     ) -> bool: ...
     if sys.version_info >= (3, 8):
+        @overload
+        def expandtabs(self: LiteralString, tabsize: SupportsIndex = ...) -> LiteralString: ...
+        @overload
         def expandtabs(self, tabsize: SupportsIndex = ...) -> str: ...  # type: ignore[misc]
     else:
+        @overload
+        def expandtabs(self: LiteralString, tabsize: int = ...) -> LiteralString: ...
+        @overload
         def expandtabs(self, tabsize: int = ...) -> str: ...  # type: ignore[misc]
 
     def find(self, __sub: str, __start: SupportsIndex | None = ..., __end: SupportsIndex | None = ...) -> int: ...
+    @overload
+    def format(self: LiteralString, *args: LiteralString, **kwargs: LiteralString) -> LiteralString: ...
+    @overload
     def format(self, *args: object, **kwargs: object) -> str: ...  # type: ignore[misc]
     def format_map(self, map: _FormatMapMapping) -> str: ...
     def index(self, __sub: str, __start: SupportsIndex | None = ..., __end: SupportsIndex | None = ...) -> int: ...
@@ -443,32 +461,91 @@ class str(Sequence[str]):
     def isspace(self) -> bool: ...
     def istitle(self) -> bool: ...
     def isupper(self) -> bool: ...
+    @overload
+    def join(self: LiteralString, __iterable: Iterable[LiteralString]) -> LiteralString: ...
+    @overload
     def join(self, __iterable: Iterable[str]) -> str: ...  # type: ignore[misc]
+    @overload
+    def ljust(self: LiteralString, __width: SupportsIndex, __fillchar: LiteralString = ...) -> LiteralString: ...
+    @overload
     def ljust(self, __width: SupportsIndex, __fillchar: str = ...) -> str: ...  # type: ignore[misc]
+    @overload
+    def lower(self: LiteralString) -> LiteralString: ...
+    @overload
     def lower(self) -> str: ...  # type: ignore[misc]
+    @overload
+    def lstrip(self: LiteralString, __chars: LiteralString | None = ...) -> LiteralString: ...
+    @overload
     def lstrip(self, __chars: str | None = ...) -> str: ...  # type: ignore[misc]
+    @overload
+    def partition(self: LiteralString, __sep: LiteralString) -> tuple[LiteralString, LiteralString, LiteralString]: ...
+    @overload
     def partition(self, __sep: str) -> tuple[str, str, str]: ...  # type: ignore[misc]
+    @overload
+    def replace(
+        self: LiteralString, __old: LiteralString, __new: LiteralString, __count: SupportsIndex = ...
+    ) -> LiteralString: ...
+    @overload
     def replace(self, __old: str, __new: str, __count: SupportsIndex = ...) -> str: ...  # type: ignore[misc]
     if sys.version_info >= (3, 9):
+        @overload
+        def removeprefix(self: LiteralString, __prefix: LiteralString) -> LiteralString: ...
+        @overload
         def removeprefix(self, __prefix: str) -> str: ...  # type: ignore[misc]
+        @overload
+        def removesuffix(self: LiteralString, __suffix: LiteralString) -> LiteralString: ...
+        @overload
         def removesuffix(self, __suffix: str) -> str: ...  # type: ignore[misc]
 
     def rfind(self, __sub: str, __start: SupportsIndex | None = ..., __end: SupportsIndex | None = ...) -> int: ...
     def rindex(self, __sub: str, __start: SupportsIndex | None = ..., __end: SupportsIndex | None = ...) -> int: ...
+    @overload
+    def rjust(self: LiteralString, __width: SupportsIndex, __fillchar: LiteralString = ...) -> LiteralString: ...
+    @overload
     def rjust(self, __width: SupportsIndex, __fillchar: str = ...) -> str: ...  # type: ignore[misc]
+    @overload
+    def rpartition(self: LiteralString, __sep: LiteralString) -> tuple[LiteralString, LiteralString, LiteralString]: ...
+    @overload
     def rpartition(self, __sep: str) -> tuple[str, str, str]: ...  # type: ignore[misc]
+    @overload
+    def rsplit(self: LiteralString, sep: LiteralString | None = ..., maxsplit: SupportsIndex = ...) -> list[LiteralString]: ...
+    @overload
     def rsplit(self, sep: str | None = ..., maxsplit: SupportsIndex = ...) -> list[str]: ...  # type: ignore[misc]
+    @overload
+    def rstrip(self: LiteralString, __chars: LiteralString | None = ...) -> LiteralString: ...
+    @overload
     def rstrip(self, __chars: str | None = ...) -> str: ...  # type: ignore[misc]
+    @overload
+    def split(self: LiteralString, sep: LiteralString | None = ..., maxsplit: SupportsIndex = ...) -> list[LiteralString]: ...
+    @overload
     def split(self, sep: str | None = ..., maxsplit: SupportsIndex = ...) -> list[str]: ...  # type: ignore[misc]
+    @overload
+    def splitlines(self: LiteralString, keepends: bool = ...) -> list[LiteralString]: ...
+    @overload
     def splitlines(self, keepends: bool = ...) -> list[str]: ...  # type: ignore[misc]
     def startswith(
         self, __prefix: str | tuple[str, ...], __start: SupportsIndex | None = ..., __end: SupportsIndex | None = ...
     ) -> bool: ...
+    @overload
+    def strip(self: LiteralString, __chars: LiteralString | None = ...) -> LiteralString: ...
+    @overload
     def strip(self, __chars: str | None = ...) -> str: ...  # type: ignore[misc]
+    @overload
+    def swapcase(self: LiteralString) -> LiteralString: ...
+    @overload
     def swapcase(self) -> str: ...  # type: ignore[misc]
+    @overload
+    def title(self: LiteralString) -> LiteralString: ...
+    @overload
     def title(self) -> str: ...  # type: ignore[misc]
     def translate(self, __table: _TranslateTable) -> str: ...
+    @overload
+    def upper(self: LiteralString) -> LiteralString: ...
+    @overload
     def upper(self) -> str: ...  # type: ignore[misc]
+    @overload
+    def zfill(self: LiteralString, __width: SupportsIndex) -> LiteralString: ...
+    @overload
     def zfill(self, __width: SupportsIndex) -> str: ...  # type: ignore[misc]
     @staticmethod
     @overload
@@ -476,6 +553,9 @@ class str(Sequence[str]):
     @staticmethod
     @overload
     def maketrans(__x: str, __y: str, __z: str | None = ...) -> dict[int, int | None]: ...
+    @overload
+    def __add__(self: LiteralString, __s: LiteralString) -> LiteralString: ...
+    @overload
     def __add__(self, __s: str) -> str: ...  # type: ignore[misc]
     # Incompatible with Sequence.__contains__
     def __contains__(self, __o: str) -> bool: ...  # type: ignore[override]
@@ -483,27 +563,35 @@ class str(Sequence[str]):
     def __ge__(self, __x: str) -> bool: ...
     def __getitem__(self, __i: SupportsIndex | slice) -> str: ...
     def __gt__(self, __x: str) -> bool: ...
+    @overload
+    def __iter__(self: LiteralString) -> Iterator[LiteralString]: ...
+    @overload
     def __iter__(self) -> Iterator[str]: ...  # type: ignore[misc]
     def __le__(self, __x: str) -> bool: ...
     def __len__(self) -> int: ...
     def __lt__(self, __x: str) -> bool: ...
+    @overload
+    def __mod__(self: LiteralString, __x: LiteralString | tuple[LiteralString, ...]) -> LiteralString: ...
+    @overload
     def __mod__(self, __x: Any) -> str: ...  # type: ignore[misc]
+    @overload
+    def __mul__(self: LiteralString, __n: SupportsIndex) -> LiteralString: ...
+    @overload
     def __mul__(self, __n: SupportsIndex) -> str: ...  # type: ignore[misc]
     def __ne__(self, __x: object) -> bool: ...
+    @overload
+    def __rmul__(self: LiteralString, __n: SupportsIndex) -> LiteralString: ...
+    @overload
     def __rmul__(self, __n: SupportsIndex) -> str: ...  # type: ignore[misc]
     def __getnewargs__(self) -> tuple[str]: ...
 
 class bytes(ByteString):
     @overload
-    def __new__(cls: type[Self], __ints: Iterable[SupportsIndex]) -> Self: ...
+    def __new__(cls: type[Self], __o: Iterable[SupportsIndex] | SupportsIndex | SupportsBytes | ReadableBuffer) -> Self: ...
     @overload
     def __new__(cls: type[Self], __string: str, encoding: str, errors: str = ...) -> Self: ...
     @overload
-    def __new__(cls: type[Self], __length: SupportsIndex) -> Self: ...
-    @overload
     def __new__(cls: type[Self]) -> Self: ...
-    @overload
-    def __new__(cls: type[Self], __o: SupportsBytes) -> Self: ...
     def capitalize(self) -> bytes: ...
     def center(self, __width: SupportsIndex, __fillchar: bytes = ...) -> bytes: ...
     def count(
@@ -589,7 +677,7 @@ class bytes(ByteString):
     def __rmul__(self, __n: SupportsIndex) -> bytes: ...
     def __mod__(self, __value: Any) -> bytes: ...
     # Incompatible with Sequence.__contains__
-    def __contains__(self, __o: SupportsIndex | bytes) -> bool: ...  # type: ignore[override]
+    def __contains__(self, __o: SupportsIndex | ReadableBuffer) -> bool: ...  # type: ignore[override]
     def __eq__(self, __x: object) -> bool: ...
     def __ne__(self, __x: object) -> bool: ...
     def __lt__(self, __x: bytes) -> bool: ...
@@ -604,11 +692,9 @@ class bytearray(MutableSequence[int], ByteString):
     @overload
     def __init__(self) -> None: ...
     @overload
-    def __init__(self, __ints: Iterable[SupportsIndex]) -> None: ...
+    def __init__(self, __ints: Iterable[SupportsIndex] | SupportsIndex | ReadableBuffer) -> None: ...
     @overload
     def __init__(self, __string: str, encoding: str, errors: str = ...) -> None: ...
-    @overload
-    def __init__(self, __length: SupportsIndex) -> None: ...
     def append(self, __item: SupportsIndex) -> None: ...
     def capitalize(self) -> bytearray: ...
     def center(self, __width: SupportsIndex, __fillchar: bytes = ...) -> bytearray: ...
@@ -712,14 +798,14 @@ class bytearray(MutableSequence[int], ByteString):
     def __contains__(self, __o: SupportsIndex | ReadableBuffer) -> bool: ...  # type: ignore[override]
     def __eq__(self, __x: object) -> bool: ...
     def __ne__(self, __x: object) -> bool: ...
-    def __lt__(self, __x: bytes) -> bool: ...
-    def __le__(self, __x: bytes) -> bool: ...
-    def __gt__(self, __x: bytes) -> bool: ...
-    def __ge__(self, __x: bytes) -> bool: ...
+    def __lt__(self, __x: ReadableBuffer) -> bool: ...
+    def __le__(self, __x: ReadableBuffer) -> bool: ...
+    def __gt__(self, __x: ReadableBuffer) -> bool: ...
+    def __ge__(self, __x: ReadableBuffer) -> bool: ...
     def __alloc__(self) -> int: ...
 
 @final
-class memoryview(Sized, Sequence[int]):
+class memoryview(Sequence[int]):
     @property
     def format(self) -> str: ...
     @property
@@ -735,7 +821,7 @@ class memoryview(Sized, Sequence[int]):
     @property
     def ndim(self) -> int: ...
     @property
-    def obj(self) -> bytes | bytearray: ...
+    def obj(self) -> ReadableBuffer: ...
     @property
     def c_contiguous(self) -> bool: ...
     @property
@@ -1569,11 +1655,11 @@ _SupportsSumNoDefaultT = TypeVar("_SupportsSumNoDefaultT", bound=_SupportsSumWit
 # Instead, we special-case the most common examples of this: bool and literal integers.
 if sys.version_info >= (3, 8):
     @overload
-    def sum(__iterable: Iterable[bool], start: int = ...) -> int: ...  # type: ignore[misc]
+    def sum(__iterable: Iterable[bool | _LiteralInteger], start: int = ...) -> int: ...  # type: ignore[misc]
 
 else:
     @overload
-    def sum(__iterable: Iterable[bool], __start: int = ...) -> int: ...  # type: ignore[misc]
+    def sum(__iterable: Iterable[bool | _LiteralInteger], __start: int = ...) -> int: ...  # type: ignore[misc]
 
 @overload
 def sum(__iterable: Iterable[_SupportsSumNoDefaultT]) -> _SupportsSumNoDefaultT | Literal[0]: ...
diff --git a/mypy/typeshed/stdlib/bz2.pyi b/mypy/typeshed/stdlib/bz2.pyi
index cea317e28037..295271d4a80b 100644
--- a/mypy/typeshed/stdlib/bz2.pyi
+++ b/mypy/typeshed/stdlib/bz2.pyi
@@ -19,8 +19,8 @@ class _WritableFileobj(Protocol):
     # def fileno(self) -> int: ...
     # def close(self) -> object: ...
 
-def compress(data: bytes, compresslevel: int = ...) -> bytes: ...
-def decompress(data: bytes) -> bytes: ...
+def compress(data: ReadableBuffer, compresslevel: int = ...) -> bytes: ...
+def decompress(data: ReadableBuffer) -> bytes: ...
 
 _ReadBinaryMode: TypeAlias = Literal["", "r", "rb"]
 _WriteBinaryMode: TypeAlias = Literal["w", "wb", "x", "xb", "a", "ab"]
@@ -132,12 +132,12 @@ class BZ2File(BaseStream, IO[bytes]):
 @final
 class BZ2Compressor:
     def __init__(self, compresslevel: int = ...) -> None: ...
-    def compress(self, __data: bytes) -> bytes: ...
+    def compress(self, __data: ReadableBuffer) -> bytes: ...
     def flush(self) -> bytes: ...
 
 @final
 class BZ2Decompressor:
-    def decompress(self, data: bytes, max_length: int = ...) -> bytes: ...
+    def decompress(self, data: ReadableBuffer, max_length: int = ...) -> bytes: ...
     @property
     def eof(self) -> bool: ...
     @property
diff --git a/mypy/typeshed/stdlib/ctypes/__init__.pyi b/mypy/typeshed/stdlib/ctypes/__init__.pyi
index 78f4ee4d5ab3..1851d3481ee2 100644
--- a/mypy/typeshed/stdlib/ctypes/__init__.pyi
+++ b/mypy/typeshed/stdlib/ctypes/__init__.pyi
@@ -194,7 +194,7 @@ class _SimpleCData(Generic[_T], _CData):
 class c_byte(_SimpleCData[int]): ...
 
 class c_char(_SimpleCData[bytes]):
-    def __init__(self, value: int | bytes = ...) -> None: ...
+    def __init__(self, value: int | bytes | bytearray = ...) -> None: ...
 
 class c_char_p(_PointerLike, _SimpleCData[bytes | None]):
     def __init__(self, value: int | bytes | None = ...) -> None: ...
@@ -266,7 +266,11 @@ class Array(Generic[_CT], _CData):
     def _type_(self) -> type[_CT]: ...
     @_type_.setter
     def _type_(self, value: type[_CT]) -> None: ...
-    raw: bytes  # Note: only available if _CT == c_char
+    # Note: only available if _CT == c_char
+    @property
+    def raw(self) -> bytes: ...
+    @raw.setter
+    def raw(self, value: ReadableBuffer) -> None: ...
     value: Any  # Note: bytes if _CT == c_char, str if _CT == c_wchar, unavailable otherwise
     # TODO These methods cannot be annotated correctly at the moment.
     # All of these "Any"s stand for the array's element type, but it's not possible to use _CT
diff --git a/mypy/typeshed/stdlib/datetime.pyi b/mypy/typeshed/stdlib/datetime.pyi
index 5926ff0a808e..b1b3c17ee25b 100644
--- a/mypy/typeshed/stdlib/datetime.pyi
+++ b/mypy/typeshed/stdlib/datetime.pyi
@@ -1,7 +1,8 @@
 import sys
 from _typeshed import Self
+from abc import abstractmethod
 from time import struct_time
-from typing import ClassVar, NamedTuple, NoReturn, SupportsAbs, TypeVar, overload
+from typing import ClassVar, NamedTuple, NoReturn, TypeVar, overload
 from typing_extensions import Literal, TypeAlias, final
 
 if sys.version_info >= (3, 11):
@@ -15,8 +16,11 @@ MINYEAR: Literal[1]
 MAXYEAR: Literal[9999]
 
 class tzinfo:
+    @abstractmethod
     def tzname(self, __dt: datetime | None) -> str | None: ...
+    @abstractmethod
     def utcoffset(self, __dt: datetime | None) -> timedelta | None: ...
+    @abstractmethod
     def dst(self, __dt: datetime | None) -> timedelta | None: ...
     def fromutc(self, __dt: datetime) -> datetime: ...
 
@@ -29,6 +33,9 @@ class timezone(tzinfo):
     min: ClassVar[timezone]
     max: ClassVar[timezone]
     def __init__(self, offset: timedelta, name: str = ...) -> None: ...
+    def tzname(self, __dt: datetime | None) -> str: ...
+    def utcoffset(self, __dt: datetime | None) -> timedelta: ...
+    def dst(self, __dt: datetime | None) -> None: ...
 
 if sys.version_info >= (3, 11):
     UTC: timezone
@@ -152,7 +159,7 @@ class time:
 _Date: TypeAlias = date
 _Time: TypeAlias = time
 
-class timedelta(SupportsAbs[timedelta]):
+class timedelta:
     min: ClassVar[timedelta]
     max: ClassVar[timedelta]
     resolution: ClassVar[timedelta]
diff --git a/mypy/typeshed/stdlib/difflib.pyi b/mypy/typeshed/stdlib/difflib.pyi
index 854a53d433ae..df2f8be0168a 100644
--- a/mypy/typeshed/stdlib/difflib.pyi
+++ b/mypy/typeshed/stdlib/difflib.pyi
@@ -127,12 +127,12 @@ class HtmlDiff:
 def restore(delta: Iterable[str], which: int) -> Iterator[str]: ...
 def diff_bytes(
     dfunc: Callable[[Sequence[str], Sequence[str], str, str, str, str, int, str], Iterator[str]],
-    a: Sequence[bytes],
-    b: Sequence[bytes],
-    fromfile: bytes = ...,
-    tofile: bytes = ...,
-    fromfiledate: bytes = ...,
-    tofiledate: bytes = ...,
+    a: Iterable[bytes | bytearray],
+    b: Iterable[bytes | bytearray],
+    fromfile: bytes | bytearray = ...,
+    tofile: bytes | bytearray = ...,
+    fromfiledate: bytes | bytearray = ...,
+    tofiledate: bytes | bytearray = ...,
     n: int = ...,
-    lineterm: bytes = ...,
+    lineterm: bytes | bytearray = ...,
 ) -> Iterator[bytes]: ...
diff --git a/mypy/typeshed/stdlib/dis.pyi b/mypy/typeshed/stdlib/dis.pyi
index dd31d981071f..73adba5c19f5 100644
--- a/mypy/typeshed/stdlib/dis.pyi
+++ b/mypy/typeshed/stdlib/dis.pyi
@@ -37,7 +37,6 @@ __all__ = [
 # Strictly this should not have to include Callable, but mypy doesn't use FunctionType
 # for functions (python/mypy#3171)
 _HaveCodeType: TypeAlias = types.MethodType | types.FunctionType | types.CodeType | type | Callable[..., Any]
-_HaveCodeOrStringType: TypeAlias = _HaveCodeType | str | bytes
 
 if sys.version_info >= (3, 11):
     class Positions(NamedTuple):
@@ -75,7 +74,7 @@ class Bytecode:
     if sys.version_info >= (3, 11):
         def __init__(
             self,
-            x: _HaveCodeOrStringType,
+            x: _HaveCodeType | str,
             *,
             first_line: int | None = ...,
             current_offset: int | None = ...,
@@ -87,9 +86,7 @@ class Bytecode:
             cls: type[Self], tb: types.TracebackType, *, show_caches: bool = ..., adaptive: bool = ...
         ) -> Self: ...
     else:
-        def __init__(
-            self, x: _HaveCodeOrStringType, *, first_line: int | None = ..., current_offset: int | None = ...
-        ) -> None: ...
+        def __init__(self, x: _HaveCodeType | str, *, first_line: int | None = ..., current_offset: int | None = ...) -> None: ...
         @classmethod
         def from_traceback(cls: type[Self], tb: types.TracebackType) -> Self: ...
 
@@ -102,11 +99,11 @@ COMPILER_FLAG_NAMES: dict[int, str]
 def findlabels(code: _HaveCodeType) -> list[int]: ...
 def findlinestarts(code: _HaveCodeType) -> Iterator[tuple[int, int]]: ...
 def pretty_flags(flags: int) -> str: ...
-def code_info(x: _HaveCodeOrStringType) -> str: ...
+def code_info(x: _HaveCodeType | str) -> str: ...
 
 if sys.version_info >= (3, 11):
     def dis(
-        x: _HaveCodeOrStringType | None = ...,
+        x: _HaveCodeType | str | bytes | bytearray | None = ...,
         *,
         file: IO[str] | None = ...,
         depth: int | None = ...,
@@ -115,7 +112,9 @@ if sys.version_info >= (3, 11):
     ) -> None: ...
 
 else:
-    def dis(x: _HaveCodeOrStringType | None = ..., *, file: IO[str] | None = ..., depth: int | None = ...) -> None: ...
+    def dis(
+        x: _HaveCodeType | str | bytes | bytearray | None = ..., *, file: IO[str] | None = ..., depth: int | None = ...
+    ) -> None: ...
 
 if sys.version_info >= (3, 11):
     def disassemble(
diff --git a/mypy/typeshed/stdlib/encodings/__init__.pyi b/mypy/typeshed/stdlib/encodings/__init__.pyi
index d86466762268..2e83f0f65a71 100644
--- a/mypy/typeshed/stdlib/encodings/__init__.pyi
+++ b/mypy/typeshed/stdlib/encodings/__init__.pyi
@@ -1,5 +1,5 @@
+from _typeshed import Incomplete
 from codecs import CodecInfo
-from typing import Any
 
 class CodecRegistryError(LookupError, SystemError): ...
 
@@ -7,4 +7,4 @@ def normalize_encoding(encoding: str | bytes) -> str: ...
 def search_function(encoding: str) -> CodecInfo | None: ...
 
 # Needed for submodules
-def __getattr__(name: str) -> Any: ...  # incomplete
+def __getattr__(name: str) -> Incomplete: ...
diff --git a/mypy/typeshed/stdlib/encodings/utf_8.pyi b/mypy/typeshed/stdlib/encodings/utf_8.pyi
index 568fa6013373..8e73756199c1 100644
--- a/mypy/typeshed/stdlib/encodings/utf_8.pyi
+++ b/mypy/typeshed/stdlib/encodings/utf_8.pyi
@@ -1,11 +1,12 @@
 import codecs
+from _typeshed import ReadableBuffer
 
 class IncrementalEncoder(codecs.IncrementalEncoder):
     def encode(self, input: str, final: bool = ...) -> bytes: ...
 
 class IncrementalDecoder(codecs.BufferedIncrementalDecoder):
     @staticmethod
-    def _buffer_decode(__data: bytes, __errors: str | None = ..., __final: bool = ...) -> tuple[str, int]: ...
+    def _buffer_decode(__data: ReadableBuffer, __errors: str | None = ..., __final: bool = ...) -> tuple[str, int]: ...
 
 class StreamWriter(codecs.StreamWriter):
     @staticmethod
@@ -13,8 +14,8 @@ class StreamWriter(codecs.StreamWriter):
 
 class StreamReader(codecs.StreamReader):
     @staticmethod
-    def decode(__data: bytes, __errors: str | None = ..., __final: bool = ...) -> tuple[str, int]: ...
+    def decode(__data: ReadableBuffer, __errors: str | None = ..., __final: bool = ...) -> tuple[str, int]: ...
 
 def getregentry() -> codecs.CodecInfo: ...
 def encode(__str: str, __errors: str | None = ...) -> tuple[bytes, int]: ...
-def decode(input: bytes, errors: str | None = ...) -> tuple[str, int]: ...
+def decode(input: ReadableBuffer, errors: str | None = ...) -> tuple[str, int]: ...
diff --git a/mypy/typeshed/stdlib/encodings/utf_8_sig.pyi b/mypy/typeshed/stdlib/encodings/utf_8_sig.pyi
index ad0d5bdc4fc7..27171063f53f 100644
--- a/mypy/typeshed/stdlib/encodings/utf_8_sig.pyi
+++ b/mypy/typeshed/stdlib/encodings/utf_8_sig.pyi
@@ -1,4 +1,5 @@
 import codecs
+from _typeshed import ReadableBuffer
 
 class IncrementalEncoder(codecs.IncrementalEncoder):
     def __init__(self, errors: str = ...) -> None: ...
@@ -8,14 +9,14 @@ class IncrementalEncoder(codecs.IncrementalEncoder):
 
 class IncrementalDecoder(codecs.BufferedIncrementalDecoder):
     def __init__(self, errors: str = ...) -> None: ...
-    def _buffer_decode(self, input: bytes, errors: str | None, final: bool) -> tuple[str, int]: ...
+    def _buffer_decode(self, input: ReadableBuffer, errors: str | None, final: bool) -> tuple[str, int]: ...
 
 class StreamWriter(codecs.StreamWriter):
     def encode(self, input: str, errors: str | None = ...) -> tuple[bytes, int]: ...
 
 class StreamReader(codecs.StreamReader):
-    def decode(self, input: bytes, errors: str | None = ...) -> tuple[str, int]: ...
+    def decode(self, input: ReadableBuffer, errors: str | None = ...) -> tuple[str, int]: ...
 
 def getregentry() -> codecs.CodecInfo: ...
 def encode(input: str, errors: str | None = ...) -> tuple[bytes, int]: ...
-def decode(input: bytes, errors: str | None = ...) -> tuple[str, int]: ...
+def decode(input: ReadableBuffer, errors: str | None = ...) -> tuple[str, int]: ...
diff --git a/mypy/typeshed/stdlib/gzip.pyi b/mypy/typeshed/stdlib/gzip.pyi
index 75a70a5e7a07..79e001bcfbe1 100644
--- a/mypy/typeshed/stdlib/gzip.pyi
+++ b/mypy/typeshed/stdlib/gzip.pyi
@@ -1,7 +1,7 @@
 import _compression
 import sys
 import zlib
-from _typeshed import ReadableBuffer, StrOrBytesPath
+from _typeshed import ReadableBuffer, StrOrBytesPath, _BufferWithLen
 from io import FileIO
 from typing import Any, Protocol, TextIO, overload
 from typing_extensions import Literal, TypeAlias
@@ -159,9 +159,9 @@ class _GzipReader(_compression.DecompressReader):
     def __init__(self, fp: _ReadableFileobj) -> None: ...
 
 if sys.version_info >= (3, 8):
-    def compress(data: bytes, compresslevel: int = ..., *, mtime: float | None = ...) -> bytes: ...
+    def compress(data: _BufferWithLen, compresslevel: int = ..., *, mtime: float | None = ...) -> bytes: ...
 
 else:
-    def compress(data: bytes, compresslevel: int = ...) -> bytes: ...
+    def compress(data: _BufferWithLen, compresslevel: int = ...) -> bytes: ...
 
-def decompress(data: bytes) -> bytes: ...
+def decompress(data: ReadableBuffer) -> bytes: ...
diff --git a/mypy/typeshed/stdlib/hmac.pyi b/mypy/typeshed/stdlib/hmac.pyi
index af69fc7ea46d..c5ab94c6ca4b 100644
--- a/mypy/typeshed/stdlib/hmac.pyi
+++ b/mypy/typeshed/stdlib/hmac.pyi
@@ -1,5 +1,5 @@
 import sys
-from _typeshed import ReadableBuffer
+from _typeshed import ReadableBuffer, _BufferWithLen
 from collections.abc import Callable
 from types import ModuleType
 from typing import Any, AnyStr, overload
@@ -18,9 +18,9 @@ if sys.version_info >= (3, 8):
     # In reality digestmod has a default value, but the function always throws an error
     # if the argument is not given, so we pretend it is a required argument.
     @overload
-    def new(key: bytes, msg: ReadableBuffer | None, digestmod: _DigestMod) -> HMAC: ...
+    def new(key: bytes | bytearray, msg: ReadableBuffer | None, digestmod: _DigestMod) -> HMAC: ...
     @overload
-    def new(key: bytes, *, digestmod: _DigestMod) -> HMAC: ...
+    def new(key: bytes | bytearray, *, digestmod: _DigestMod) -> HMAC: ...
 
 else:
     def new(key: bytes, msg: ReadableBuffer | None = ..., digestmod: _DigestMod | None = ...) -> HMAC: ...
@@ -30,7 +30,7 @@ class HMAC:
     block_size: int
     @property
     def name(self) -> str: ...
-    def __init__(self, key: bytes, msg: ReadableBuffer | None = ..., digestmod: _DigestMod = ...) -> None: ...
+    def __init__(self, key: bytes | bytearray, msg: ReadableBuffer | None = ..., digestmod: _DigestMod = ...) -> None: ...
     def update(self, msg: ReadableBuffer) -> None: ...
     def digest(self) -> bytes: ...
     def hexdigest(self) -> str: ...
@@ -40,4 +40,4 @@ class HMAC:
 def compare_digest(__a: ReadableBuffer, __b: ReadableBuffer) -> bool: ...
 @overload
 def compare_digest(__a: AnyStr, __b: AnyStr) -> bool: ...
-def digest(key: bytes, msg: ReadableBuffer, digest: _DigestMod) -> bytes: ...
+def digest(key: _BufferWithLen, msg: ReadableBuffer, digest: _DigestMod) -> bytes: ...
diff --git a/mypy/typeshed/stdlib/imaplib.pyi b/mypy/typeshed/stdlib/imaplib.pyi
index bd3d0777db15..54760dd036ca 100644
--- a/mypy/typeshed/stdlib/imaplib.pyi
+++ b/mypy/typeshed/stdlib/imaplib.pyi
@@ -1,7 +1,7 @@
 import subprocess
 import sys
 import time
-from _typeshed import Self
+from _typeshed import ReadableBuffer, Self
 from builtins import list as _list  # conflicts with a method named "list"
 from collections.abc import Callable
 from datetime import datetime
@@ -9,7 +9,7 @@ from re import Pattern
 from socket import socket as _socket
 from ssl import SSLContext, SSLSocket
 from types import TracebackType
-from typing import IO, Any
+from typing import IO, Any, SupportsAbs, SupportsInt
 from typing_extensions import Literal, TypeAlias
 
 __all__ = ["IMAP4", "IMAP4_stream", "Internaldate2tuple", "Int2AP", "ParseFlags", "Time2Internaldate", "IMAP4_SSL"]
@@ -54,12 +54,12 @@ class IMAP4:
     file: IO[str] | IO[bytes]
     def read(self, size: int) -> bytes: ...
     def readline(self) -> bytes: ...
-    def send(self, data: bytes) -> None: ...
+    def send(self, data: ReadableBuffer) -> None: ...
     def shutdown(self) -> None: ...
     def socket(self) -> _socket: ...
     def recent(self) -> _CommandResults: ...
     def response(self, code: str) -> _CommandResults: ...
-    def append(self, mailbox: str, flags: str, date_time: str, message: bytes) -> str: ...
+    def append(self, mailbox: str, flags: str, date_time: str, message: ReadableBuffer) -> str: ...
     def authenticate(self, mechanism: str, authobject: Callable[[bytes], bytes | None]) -> tuple[str, str]: ...
     def capability(self) -> _CommandResults: ...
     def check(self) -> _CommandResults: ...
@@ -157,7 +157,7 @@ class _Authenticator:
     def encode(self, inp: bytes) -> str: ...
     def decode(self, inp: str) -> bytes: ...
 
-def Internaldate2tuple(resp: bytes) -> time.struct_time: ...
-def Int2AP(num: int) -> str: ...
-def ParseFlags(resp: bytes) -> tuple[bytes, ...]: ...
+def Internaldate2tuple(resp: ReadableBuffer) -> time.struct_time | None: ...
+def Int2AP(num: SupportsAbs[SupportsInt]) -> bytes: ...
+def ParseFlags(resp: ReadableBuffer) -> tuple[bytes, ...]: ...
 def Time2Internaldate(date_time: float | time.struct_time | time._TimeTuple | datetime | str) -> str: ...
diff --git a/mypy/typeshed/stdlib/io.pyi b/mypy/typeshed/stdlib/io.pyi
index 3e9a6cd6861d..2d3aadc483f0 100644
--- a/mypy/typeshed/stdlib/io.pyi
+++ b/mypy/typeshed/stdlib/io.pyi
@@ -103,7 +103,7 @@ class FileIO(RawIOBase, BinaryIO):
     def __enter__(self: Self) -> Self: ...
 
 class BytesIO(BufferedIOBase, BinaryIO):
-    def __init__(self, initial_bytes: bytes = ...) -> None: ...
+    def __init__(self, initial_bytes: ReadableBuffer = ...) -> None: ...
     # BytesIO does not contain a "name" field. This workaround is necessary
     # to allow BytesIO sub-classes to add this field, as it is defined
     # as a read-only property on IO[].
diff --git a/mypy/typeshed/stdlib/json/__init__.pyi b/mypy/typeshed/stdlib/json/__init__.pyi
index 2fd87622e1fe..64ab8a11a45d 100644
--- a/mypy/typeshed/stdlib/json/__init__.pyi
+++ b/mypy/typeshed/stdlib/json/__init__.pyi
@@ -37,7 +37,7 @@ def dump(
     **kwds: Any,
 ) -> None: ...
 def loads(
-    s: str | bytes,
+    s: str | bytes | bytearray,
     *,
     cls: type[JSONDecoder] | None = ...,
     object_hook: Callable[[dict[Any, Any]], Any] | None = ...,
@@ -58,4 +58,4 @@ def load(
     object_pairs_hook: Callable[[list[tuple[Any, Any]]], Any] | None = ...,
     **kwds: Any,
 ) -> Any: ...
-def detect_encoding(b: bytes) -> str: ...  # undocumented
+def detect_encoding(b: bytes | bytearray) -> str: ...  # undocumented
diff --git a/mypy/typeshed/stdlib/lzma.pyi b/mypy/typeshed/stdlib/lzma.pyi
index 868da0f05567..9d75c627f76d 100644
--- a/mypy/typeshed/stdlib/lzma.pyi
+++ b/mypy/typeshed/stdlib/lzma.pyi
@@ -83,7 +83,7 @@ PRESET_EXTREME: int  # v big number
 @final
 class LZMADecompressor:
     def __init__(self, format: int | None = ..., memlimit: int | None = ..., filters: _FilterChain | None = ...) -> None: ...
-    def decompress(self, data: bytes, max_length: int = ...) -> bytes: ...
+    def decompress(self, data: ReadableBuffer, max_length: int = ...) -> bytes: ...
     @property
     def check(self) -> int: ...
     @property
@@ -99,7 +99,7 @@ class LZMACompressor:
     def __init__(
         self, format: int | None = ..., check: int = ..., preset: int | None = ..., filters: _FilterChain | None = ...
     ) -> None: ...
-    def compress(self, __data: bytes) -> bytes: ...
+    def compress(self, __data: ReadableBuffer) -> bytes: ...
     def flush(self) -> bytes: ...
 
 class LZMAError(Exception): ...
@@ -189,7 +189,9 @@ def open(
     newline: str | None = ...,
 ) -> LZMAFile | TextIO: ...
 def compress(
-    data: bytes, format: int = ..., check: int = ..., preset: int | None = ..., filters: _FilterChain | None = ...
+    data: ReadableBuffer, format: int = ..., check: int = ..., preset: int | None = ..., filters: _FilterChain | None = ...
+) -> bytes: ...
+def decompress(
+    data: ReadableBuffer, format: int = ..., memlimit: int | None = ..., filters: _FilterChain | None = ...
 ) -> bytes: ...
-def decompress(data: bytes, format: int = ..., memlimit: int | None = ..., filters: _FilterChain | None = ...) -> bytes: ...
 def is_check_supported(__check_id: int) -> bool: ...
diff --git a/mypy/typeshed/stdlib/marshal.pyi b/mypy/typeshed/stdlib/marshal.pyi
index b2fde674a647..d68cdd143109 100644
--- a/mypy/typeshed/stdlib/marshal.pyi
+++ b/mypy/typeshed/stdlib/marshal.pyi
@@ -1,8 +1,9 @@
-from typing import IO, Any
+from _typeshed import ReadableBuffer, SupportsRead, SupportsWrite
+from typing import Any
 
 version: int
 
-def dump(__value: Any, __file: IO[Any], __version: int = ...) -> None: ...
-def load(__file: IO[Any]) -> Any: ...
+def dump(__value: Any, __file: SupportsWrite[bytes], __version: int = ...) -> None: ...
+def load(__file: SupportsRead[bytes]) -> Any: ...
 def dumps(__value: Any, __version: int = ...) -> bytes: ...
-def loads(__bytes: bytes) -> Any: ...
+def loads(__bytes: ReadableBuffer) -> Any: ...
diff --git a/mypy/typeshed/stdlib/pathlib.pyi b/mypy/typeshed/stdlib/pathlib.pyi
index 2a0f1760cae5..79c2352a0f85 100644
--- a/mypy/typeshed/stdlib/pathlib.pyi
+++ b/mypy/typeshed/stdlib/pathlib.pyi
@@ -5,10 +5,12 @@ from _typeshed import (
     OpenBinaryModeUpdating,
     OpenBinaryModeWriting,
     OpenTextMode,
+    ReadableBuffer,
     Self,
+    StrOrBytesPath,
     StrPath,
 )
-from collections.abc import Generator, Sequence
+from collections.abc import Callable, Generator, Iterator, Sequence
 from io import BufferedRandom, BufferedReader, BufferedWriter, FileIO, TextIOWrapper
 from os import PathLike, stat_result
 from types import TracebackType
@@ -188,16 +190,20 @@ class Path(PurePath):
     def expanduser(self: Self) -> Self: ...
     def read_bytes(self) -> bytes: ...
     def read_text(self, encoding: str | None = ..., errors: str | None = ...) -> str: ...
-    def samefile(self, other_path: str | bytes | int | Path) -> bool: ...
-    def write_bytes(self, data: bytes) -> int: ...
+    def samefile(self, other_path: StrPath) -> bool: ...
+    def write_bytes(self, data: ReadableBuffer) -> int: ...
     if sys.version_info >= (3, 10):
         def write_text(
             self, data: str, encoding: str | None = ..., errors: str | None = ..., newline: str | None = ...
         ) -> int: ...
     else:
         def write_text(self, data: str, encoding: str | None = ..., errors: str | None = ...) -> int: ...
-    if sys.version_info >= (3, 8):
-        def link_to(self, target: StrPath | bytes) -> None: ...
+    if sys.version_info >= (3, 8) and sys.version_info < (3, 12):
+        def link_to(self, target: StrOrBytesPath) -> None: ...
+    if sys.version_info >= (3, 12):
+        def walk(
+            self: Self, top_down: bool = ..., on_error: Callable[[OSError], object] | None = ..., follow_symlinks: bool = ...
+        ) -> Iterator[tuple[Self, list[str], list[str]]]: ...
 
 class PosixPath(Path, PurePosixPath): ...
 class WindowsPath(Path, PureWindowsPath): ...
diff --git a/mypy/typeshed/stdlib/pyexpat/__init__.pyi b/mypy/typeshed/stdlib/pyexpat/__init__.pyi
index 6a4ed891fe10..cb1266cb198a 100644
--- a/mypy/typeshed/stdlib/pyexpat/__init__.pyi
+++ b/mypy/typeshed/stdlib/pyexpat/__init__.pyi
@@ -1,6 +1,6 @@
 import pyexpat.errors as errors
 import pyexpat.model as model
-from _typeshed import SupportsRead
+from _typeshed import ReadableBuffer, SupportsRead
 from collections.abc import Callable
 from typing import Any
 from typing_extensions import TypeAlias, final
@@ -25,7 +25,7 @@ _Model: TypeAlias = tuple[int, int, str | None, tuple[Any, ...]]
 
 @final
 class XMLParserType:
-    def Parse(self, __data: str | bytes, __isfinal: bool = ...) -> int: ...
+    def Parse(self, __data: str | ReadableBuffer, __isfinal: bool = ...) -> int: ...
     def ParseFile(self, __file: SupportsRead[bytes]) -> int: ...
     def SetBase(self, __base: str) -> None: ...
     def GetBase(self) -> str | None: ...
diff --git a/mypy/typeshed/stdlib/socket.pyi b/mypy/typeshed/stdlib/socket.pyi
index 89a6d059f165..b7ded696c2c6 100644
--- a/mypy/typeshed/stdlib/socket.pyi
+++ b/mypy/typeshed/stdlib/socket.pyi
@@ -738,7 +738,7 @@ if sys.platform != "win32":
     if sys.version_info >= (3, 9):
         # flags and address appear to be unused in send_fds and recv_fds
         def send_fds(
-            sock: socket, buffers: Iterable[bytes], fds: bytes | Iterable[int], flags: int = ..., address: None = ...
+            sock: socket, buffers: Iterable[ReadableBuffer], fds: Iterable[int], flags: int = ..., address: None = ...
         ) -> int: ...
         def recv_fds(sock: socket, bufsize: int, maxfds: int, flags: int = ...) -> tuple[bytes, list[int], int, Any]: ...
 
@@ -768,16 +768,14 @@ if sys.version_info >= (3, 11):
     def create_connection(
         address: tuple[str | None, int],
         timeout: float | None = ...,  # noqa: F811
-        source_address: tuple[bytearray | bytes | str, int] | None = ...,
+        source_address: _Address | None = ...,
         *,
         all_errors: bool = ...,
     ) -> socket: ...
 
 else:
     def create_connection(
-        address: tuple[str | None, int],
-        timeout: float | None = ...,  # noqa: F811
-        source_address: tuple[bytearray | bytes | str, int] | None = ...,
+        address: tuple[str | None, int], timeout: float | None = ..., source_address: _Address | None = ...  # noqa: F811
     ) -> socket: ...
 
 if sys.version_info >= (3, 8):
@@ -788,5 +786,10 @@ if sys.version_info >= (3, 8):
 
 # the 5th tuple item is an address
 def getaddrinfo(
-    host: bytes | str | None, port: str | int | None, family: int = ..., type: int = ..., proto: int = ..., flags: int = ...
+    host: bytes | str | None,
+    port: bytes | str | int | None,
+    family: int = ...,
+    type: int = ...,
+    proto: int = ...,
+    flags: int = ...,
 ) -> list[tuple[AddressFamily, SocketKind, int, str, tuple[str, int] | tuple[str, int, int, int]]]: ...
diff --git a/mypy/typeshed/stdlib/ssl.pyi b/mypy/typeshed/stdlib/ssl.pyi
index 6443a6ea61ba..543433f2fbd0 100644
--- a/mypy/typeshed/stdlib/ssl.pyi
+++ b/mypy/typeshed/stdlib/ssl.pyi
@@ -11,7 +11,7 @@ _PCTRTTT: TypeAlias = tuple[_PCTRTT, ...]
 _PeerCertRetDictType: TypeAlias = dict[str, str | _PCTRTTT | _PCTRTT]
 _PeerCertRetType: TypeAlias = _PeerCertRetDictType | bytes | None
 _EnumRetType: TypeAlias = list[tuple[bytes, str, set[str] | bool]]
-_PasswordType: TypeAlias = Union[Callable[[], str | bytes], str, bytes]
+_PasswordType: TypeAlias = Union[Callable[[], str | bytes | bytearray], str, bytes, bytearray]
 
 _SrvnmeCbType: TypeAlias = Callable[[SSLSocket | SSLObject, str | None, SSLSocket], int | None]
 
@@ -61,7 +61,7 @@ def create_default_context(
     *,
     cafile: StrOrBytesPath | None = ...,
     capath: StrOrBytesPath | None = ...,
-    cadata: str | bytes | None = ...,
+    cadata: str | ReadableBuffer | None = ...,
 ) -> SSLContext: ...
 def _create_unverified_context(
     protocol: int = ...,
@@ -73,7 +73,7 @@ def _create_unverified_context(
     keyfile: StrOrBytesPath | None = ...,
     cafile: StrOrBytesPath | None = ...,
     capath: StrOrBytesPath | None = ...,
-    cadata: str | bytes | None = ...,
+    cadata: str | ReadableBuffer | None = ...,
 ) -> SSLContext: ...
 
 _create_default_https_context: Callable[..., SSLContext]
@@ -82,8 +82,11 @@ def RAND_bytes(__num: int) -> bytes: ...
 def RAND_pseudo_bytes(__num: int) -> tuple[bytes, bool]: ...
 def RAND_status() -> bool: ...
 def RAND_egd(path: str) -> None: ...
-def RAND_add(__s: bytes, __entropy: float) -> None: ...
-def match_hostname(cert: _PeerCertRetType, hostname: str) -> None: ...
+def RAND_add(__string: str | ReadableBuffer, __entropy: float) -> None: ...
+
+if sys.version_info < (3, 12):
+    def match_hostname(cert: _PeerCertRetDictType, hostname: str) -> None: ...
+
 def cert_time_to_seconds(cert_time: str) -> int: ...
 
 if sys.version_info >= (3, 10):
@@ -94,7 +97,7 @@ if sys.version_info >= (3, 10):
 else:
     def get_server_certificate(addr: tuple[str, int], ssl_version: int = ..., ca_certs: str | None = ...) -> str: ...
 
-def DER_cert_to_PEM_cert(der_cert_bytes: bytes) -> str: ...
+def DER_cert_to_PEM_cert(der_cert_bytes: ReadableBuffer) -> str: ...
 def PEM_cert_to_DER_cert(pem_cert_string: str) -> bytes: ...
 
 class DefaultVerifyPaths(NamedTuple):
@@ -290,8 +293,8 @@ class SSLSocket(socket.socket):
     @property
     def session_reused(self) -> bool | None: ...
     def __init__(self, *args: Any, **kwargs: Any) -> None: ...
-    def connect(self, addr: socket._Address | bytes) -> None: ...
-    def connect_ex(self, addr: socket._Address | bytes) -> int: ...
+    def connect(self, addr: socket._Address) -> None: ...
+    def connect_ex(self, addr: socket._Address) -> int: ...
     def recv(self, buflen: int = ..., flags: int = ...) -> bytes: ...
     def recv_into(self, buffer: WriteableBuffer, nbytes: int | None = ..., flags: int = ...) -> int: ...
     def recvfrom(self, buflen: int = ..., flags: int = ...) -> tuple[bytes, socket._RetAddress]: ...
@@ -301,12 +304,12 @@ class SSLSocket(socket.socket):
     def send(self, data: ReadableBuffer, flags: int = ...) -> int: ...
     def sendall(self, data: ReadableBuffer, flags: int = ...) -> None: ...
     @overload
-    def sendto(self, data: ReadableBuffer, flags_or_addr: socket._Address) -> int: ...
+    def sendto(self, data: ReadableBuffer, flags_or_addr: socket._Address, addr: None = ...) -> int: ...
     @overload
-    def sendto(self, data: ReadableBuffer, flags_or_addr: int | socket._Address, addr: socket._Address | None = ...) -> int: ...
+    def sendto(self, data: ReadableBuffer, flags_or_addr: int, addr: socket._Address) -> int: ...
     def shutdown(self, how: int) -> None: ...
     def read(self, len: int = ..., buffer: bytearray | None = ...) -> bytes: ...
-    def write(self, data: bytes) -> int: ...
+    def write(self, data: ReadableBuffer) -> int: ...
     def do_handshake(self, block: bool = ...) -> None: ...  # block is undocumented
     @overload
     def getpeercert(self, binary_form: Literal[False] = ...) -> _PeerCertRetDictType | None: ...
@@ -362,7 +365,7 @@ class SSLContext:
     ) -> None: ...
     def load_default_certs(self, purpose: Purpose = ...) -> None: ...
     def load_verify_locations(
-        self, cafile: StrOrBytesPath | None = ..., capath: StrOrBytesPath | None = ..., cadata: str | bytes | None = ...
+        self, cafile: StrOrBytesPath | None = ..., capath: StrOrBytesPath | None = ..., cadata: str | ReadableBuffer | None = ...
     ) -> None: ...
     @overload
     def get_ca_certs(self, binary_form: Literal[False] = ...) -> list[_PeerCertRetDictType]: ...
@@ -408,7 +411,7 @@ class SSLObject:
     def session_reused(self) -> bool: ...
     def __init__(self, *args: Any, **kwargs: Any) -> None: ...
     def read(self, len: int = ..., buffer: bytearray | None = ...) -> bytes: ...
-    def write(self, data: bytes) -> int: ...
+    def write(self, data: ReadableBuffer) -> int: ...
     @overload
     def getpeercert(self, binary_form: Literal[False] = ...) -> _PeerCertRetDictType | None: ...
     @overload
@@ -433,16 +436,21 @@ class MemoryBIO:
     pending: int
     eof: bool
     def read(self, __size: int = ...) -> bytes: ...
-    def write(self, __buf: bytes) -> int: ...
+    def write(self, __buf: ReadableBuffer) -> int: ...
     def write_eof(self) -> None: ...
 
 @final
 class SSLSession:
-    id: bytes
-    time: int
-    timeout: int
-    ticket_lifetime_hint: int
-    has_ticket: bool
+    @property
+    def has_ticket(self) -> bool: ...
+    @property
+    def id(self) -> bytes: ...
+    @property
+    def ticket_lifetime_hint(self) -> int: ...
+    @property
+    def time(self) -> int: ...
+    @property
+    def timeout(self) -> int: ...
 
 class SSLErrorNumber(enum.IntEnum):
     SSL_ERROR_EOF: int
diff --git a/mypy/typeshed/stdlib/tkinter/commondialog.pyi b/mypy/typeshed/stdlib/tkinter/commondialog.pyi
index 49101c7e6089..edae62582237 100644
--- a/mypy/typeshed/stdlib/tkinter/commondialog.pyi
+++ b/mypy/typeshed/stdlib/tkinter/commondialog.pyi
@@ -10,5 +10,5 @@ class Dialog:
     command: ClassVar[str | None]
     master: Incomplete | None
     options: Mapping[str, Incomplete]
-    def __init__(self, master: Incomplete | None = ..., **options) -> None: ...
-    def show(self, **options): ...
+    def __init__(self, master: Incomplete | None = ..., **options: Incomplete) -> None: ...
+    def show(self, **options: Incomplete) -> Incomplete: ...
diff --git a/mypy/typeshed/stdlib/tkinter/dialog.pyi b/mypy/typeshed/stdlib/tkinter/dialog.pyi
index ef7713f40994..032dac2c15a2 100644
--- a/mypy/typeshed/stdlib/tkinter/dialog.pyi
+++ b/mypy/typeshed/stdlib/tkinter/dialog.pyi
@@ -12,5 +12,5 @@ DIALOG_ICON: str
 class Dialog(Widget):
     widgetName: str
     num: int
-    def __init__(self, master: Incomplete | None = ..., cnf: Mapping[str, Any] = ..., **kw) -> None: ...
+    def __init__(self, master: Incomplete | None = ..., cnf: Mapping[str, Any] = ..., **kw: Incomplete) -> None: ...
     def destroy(self) -> None: ...
diff --git a/mypy/typeshed/stdlib/tkinter/dnd.pyi b/mypy/typeshed/stdlib/tkinter/dnd.pyi
index e2cfc43f606a..ad7972968f81 100644
--- a/mypy/typeshed/stdlib/tkinter/dnd.pyi
+++ b/mypy/typeshed/stdlib/tkinter/dnd.pyi
@@ -16,4 +16,4 @@ class DndHandler:
     def on_motion(self, event: Event[Misc]) -> None: ...
     def on_release(self, event: Event[Misc]) -> None: ...
 
-def dnd_start(source, event) -> DndHandler | None: ...
+def dnd_start(source: _DndSource, event: Event[Misc]) -> DndHandler | None: ...
diff --git a/mypy/typeshed/stdlib/tkinter/scrolledtext.pyi b/mypy/typeshed/stdlib/tkinter/scrolledtext.pyi
index 72f6ca8c0687..4d8a7004c6b9 100644
--- a/mypy/typeshed/stdlib/tkinter/scrolledtext.pyi
+++ b/mypy/typeshed/stdlib/tkinter/scrolledtext.pyi
@@ -1,3 +1,4 @@
+from _typeshed import Incomplete
 from tkinter import Frame, Misc, Scrollbar, Text
 
 __all__ = ["ScrolledText"]
@@ -6,4 +7,4 @@ __all__ = ["ScrolledText"]
 class ScrolledText(Text):
     frame: Frame
     vbar: Scrollbar
-    def __init__(self, master: Misc | None = ..., **kwargs) -> None: ...
+    def __init__(self, master: Misc | None = ..., **kwargs: Incomplete) -> None: ...
diff --git a/mypy/typeshed/stdlib/types.pyi b/mypy/typeshed/stdlib/types.pyi
index 16fe096d3117..c282ab5b8e00 100644
--- a/mypy/typeshed/stdlib/types.pyi
+++ b/mypy/typeshed/stdlib/types.pyi
@@ -591,7 +591,8 @@ if sys.version_info >= (3, 9):
             @property
             def __typing_unpacked_tuple_args__(self) -> tuple[Any, ...] | None: ...
 
-        def __getattr__(self, name: str) -> Any: ...  # incomplete
+        # GenericAlias delegates attr access to `__origin__`
+        def __getattr__(self, name: str) -> Any: ...
 
 if sys.version_info >= (3, 10):
     @final
diff --git a/mypy/typeshed/stdlib/typing.pyi b/mypy/typeshed/stdlib/typing.pyi
index 954f47d14502..d03a3eabbf9e 100644
--- a/mypy/typeshed/stdlib/typing.pyi
+++ b/mypy/typeshed/stdlib/typing.pyi
@@ -452,10 +452,7 @@ class Container(Protocol[_T_co]):
     def __contains__(self, __x: object) -> bool: ...
 
 @runtime_checkable
-class Collection(Iterable[_T_co], Container[_T_co], Protocol[_T_co]):
-    # Implement Sized (but don't have it as a base class).
-    @abstractmethod
-    def __len__(self) -> int: ...
+class Collection(Sized, Iterable[_T_co], Container[_T_co], Protocol[_T_co]): ...
 
 class Sequence(Collection[_T_co], Reversible[_T_co], Generic[_T_co]):
     @overload
@@ -566,7 +563,7 @@ class KeysView(MappingView, AbstractSet[_KT_co], Generic[_KT_co]):
     def __xor__(self, other: Iterable[_T]) -> set[_KT_co | _T]: ...
     def __rxor__(self, other: Iterable[_T]) -> set[_KT_co | _T]: ...
 
-class ValuesView(MappingView, Iterable[_VT_co], Generic[_VT_co]):
+class ValuesView(MappingView, Collection[_VT_co], Generic[_VT_co]):
     def __init__(self, mapping: Mapping[Any, _VT_co]) -> None: ...  # undocumented
     def __contains__(self, value: object) -> bool: ...
     def __iter__(self) -> Iterator[_VT_co]: ...
@@ -638,7 +635,9 @@ TYPE_CHECKING: bool
 # This differs from runtime, but better reflects the fact that in reality
 # classes deriving from IO use different names for the arguments.
 class IO(Iterator[AnyStr], Generic[AnyStr]):
-    # TODO use abstract properties
+    # At runtime these are all abstract properties,
+    # but making them abstract in the stub is hugely disruptive, for not much gain.
+    # See #8726
     @property
     def mode(self) -> str: ...
     @property
@@ -691,7 +690,7 @@ class BinaryIO(IO[bytes]):
     def __enter__(self) -> BinaryIO: ...
 
 class TextIO(IO[str]):
-    # TODO use abstractproperty
+    # See comment regarding the @properties in the `IO` class
     @property
     def buffer(self) -> BinaryIO: ...
     @property
diff --git a/mypy/typeshed/stdlib/zlib.pyi b/mypy/typeshed/stdlib/zlib.pyi
index cfd6784bb771..ea41567eefc5 100644
--- a/mypy/typeshed/stdlib/zlib.pyi
+++ b/mypy/typeshed/stdlib/zlib.pyi
@@ -1,6 +1,5 @@
 import sys
-from array import array
-from typing import Any
+from _typeshed import ReadableBuffer
 from typing_extensions import Literal
 
 DEFLATED: Literal[8]
@@ -29,7 +28,7 @@ Z_TREES: Literal[6]
 class error(Exception): ...
 
 class _Compress:
-    def compress(self, data: bytes) -> bytes: ...
+    def compress(self, data: ReadableBuffer) -> bytes: ...
     def flush(self, mode: int = ...) -> bytes: ...
     def copy(self) -> _Compress: ...
 
@@ -37,21 +36,26 @@ class _Decompress:
     unused_data: bytes
     unconsumed_tail: bytes
     eof: bool
-    def decompress(self, data: bytes, max_length: int = ...) -> bytes: ...
+    def decompress(self, data: ReadableBuffer, max_length: int = ...) -> bytes: ...
     def flush(self, length: int = ...) -> bytes: ...
     def copy(self) -> _Decompress: ...
 
-def adler32(__data: bytes, __value: int = ...) -> int: ...
+def adler32(__data: ReadableBuffer, __value: int = ...) -> int: ...
 
 if sys.version_info >= (3, 11):
-    def compress(__data: bytes, level: int = ..., wbits: int = ...) -> bytes: ...
+    def compress(__data: ReadableBuffer, level: int = ..., wbits: int = ...) -> bytes: ...
 
 else:
-    def compress(__data: bytes, level: int = ...) -> bytes: ...
+    def compress(__data: ReadableBuffer, level: int = ...) -> bytes: ...
 
 def compressobj(
-    level: int = ..., method: int = ..., wbits: int = ..., memLevel: int = ..., strategy: int = ..., zdict: bytes | None = ...
+    level: int = ...,
+    method: int = ...,
+    wbits: int = ...,
+    memLevel: int = ...,
+    strategy: int = ...,
+    zdict: ReadableBuffer | None = ...,
 ) -> _Compress: ...
-def crc32(__data: array[Any] | bytes, __value: int = ...) -> int: ...
-def decompress(__data: bytes, wbits: int = ..., bufsize: int = ...) -> bytes: ...
-def decompressobj(wbits: int = ..., zdict: bytes = ...) -> _Decompress: ...
+def crc32(__data: ReadableBuffer, __value: int = ...) -> int: ...
+def decompress(__data: ReadableBuffer, wbits: int = ..., bufsize: int = ...) -> bytes: ...
+def decompressobj(wbits: int = ..., zdict: ReadableBuffer = ...) -> _Decompress: ...
diff --git a/mypy/typeshed/stdlib/zoneinfo/__init__.pyi b/mypy/typeshed/stdlib/zoneinfo/__init__.pyi
index 7f22c07b32c0..8b9ba9e7023a 100644
--- a/mypy/typeshed/stdlib/zoneinfo/__init__.pyi
+++ b/mypy/typeshed/stdlib/zoneinfo/__init__.pyi
@@ -1,6 +1,6 @@
 from _typeshed import Self, StrPath
 from collections.abc import Iterable, Sequence
-from datetime import tzinfo
+from datetime import datetime, timedelta, tzinfo
 from typing import Any, Protocol
 
 __all__ = ["ZoneInfo", "reset_tzpath", "available_timezones", "TZPATH", "ZoneInfoNotFoundError", "InvalidTZPathWarning"]
@@ -19,6 +19,9 @@ class ZoneInfo(tzinfo):
     def from_file(cls: type[Self], __fobj: _IOBytes, key: str | None = ...) -> Self: ...
     @classmethod
     def clear_cache(cls, *, only_keys: Iterable[str] | None = ...) -> None: ...
+    def tzname(self, __dt: datetime | None) -> str | None: ...
+    def utcoffset(self, __dt: datetime | None) -> timedelta | None: ...
+    def dst(self, __dt: datetime | None) -> timedelta | None: ...
 
 # Note: Both here and in clear_cache, the types allow the use of `str` where
 # a sequence of strings is required. This should be remedied if a solution