basedpyright 1.1.389 → 1.1.392

package/dist/typeshed-fallback/stdlib/encodings/mac_turkish.pyi

@@ -0,0 +1,21 @@
+import codecs
+from _codecs import _EncodingMap
+from _typeshed import ReadableBuffer
+
+class Codec(codecs.Codec):
+    def encode(self, input: str, errors: str = "strict") -> tuple[bytes, int]: ...
+    def decode(self, input: bytes, errors: str = "strict") -> tuple[str, int]: ...
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    def encode(self, input: str, final: bool = False) -> bytes: ...
+
+class IncrementalDecoder(codecs.IncrementalDecoder):
+    def decode(self, input: ReadableBuffer, final: bool = False) -> str: ...
+
+class StreamWriter(Codec, codecs.StreamWriter): ...
+class StreamReader(Codec, codecs.StreamReader): ...
+
+def getregentry() -> codecs.CodecInfo: ...
+
+decoding_table: str
+encoding_table: _EncodingMap

package/dist/typeshed-fallback/stdlib/encodings/mbcs.pyi

@@ -0,0 +1,28 @@
+import codecs
+import sys
+from _typeshed import ReadableBuffer
+
+if sys.platform == "win32":
+    encode = codecs.mbcs_encode
+
+    def decode(input: ReadableBuffer, errors: str | None = "strict") -> tuple[str, int]: ...
+
+    class IncrementalEncoder(codecs.IncrementalEncoder):
+        def encode(self, input: str, final: bool = False) -> bytes: ...
+
+    class IncrementalDecoder(codecs.BufferedIncrementalDecoder):
+        # At runtime, this is codecs.mbcs_decode
+        @staticmethod
+        def _buffer_decode(data: ReadableBuffer, errors: str | None = None, final: bool = False, /) -> tuple[str, int]: ...
+
+    class StreamWriter(codecs.StreamWriter):
+        # At runtime, this is codecs.mbcs_encode
+        @staticmethod
+        def encode(str: str, errors: str | None = None, /) -> tuple[bytes, int]: ...
+
+    class StreamReader(codecs.StreamReader):
+        # At runtime, this is codecs.mbcs_decode
+        @staticmethod
+        def decode(data: ReadableBuffer, errors: str | None = None, final: bool = False, /) -> tuple[str, int]: ...
+
+    def getregentry() -> codecs.CodecInfo: ...

package/dist/typeshed-fallback/stdlib/encodings/oem.pyi

@@ -0,0 +1,28 @@
+import codecs
+import sys
+from _typeshed import ReadableBuffer
+
+if sys.platform == "win32":
+    encode = codecs.oem_encode
+
+    def decode(input: ReadableBuffer, errors: str | None = "strict") -> tuple[str, int]: ...
+
+    class IncrementalEncoder(codecs.IncrementalEncoder):
+        def encode(self, input: str, final: bool = False) -> bytes: ...
+
+    class IncrementalDecoder(codecs.BufferedIncrementalDecoder):
+        # At runtime, this is codecs.oem_decode
+        @staticmethod
+        def _buffer_decode(data: ReadableBuffer, errors: str | None = None, final: bool = False, /) -> tuple[str, int]: ...
+
+    class StreamWriter(codecs.StreamWriter):
+        # At runtime, this is codecs.oem_encode
+        @staticmethod
+        def encode(str: str, errors: str | None = None, /) -> tuple[bytes, int]: ...
+
+    class StreamReader(codecs.StreamReader):
+        # At runtime, this is codecs.oem_decode
+        @staticmethod
+        def decode(data: ReadableBuffer, errors: str | None = None, final: bool = False, /) -> tuple[str, int]: ...
+
+    def getregentry() -> codecs.CodecInfo: ...

package/dist/typeshed-fallback/stdlib/encodings/palmos.pyi

@@ -0,0 +1,21 @@
+import codecs
+from _codecs import _EncodingMap
+from _typeshed import ReadableBuffer
+
+class Codec(codecs.Codec):
+    def encode(self, input: str, errors: str = "strict") -> tuple[bytes, int]: ...
+    def decode(self, input: bytes, errors: str = "strict") -> tuple[str, int]: ...
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    def encode(self, input: str, final: bool = False) -> bytes: ...
+
+class IncrementalDecoder(codecs.IncrementalDecoder):
+    def decode(self, input: ReadableBuffer, final: bool = False) -> str: ...
+
+class StreamWriter(Codec, codecs.StreamWriter): ...
+class StreamReader(Codec, codecs.StreamReader): ...
+
+def getregentry() -> codecs.CodecInfo: ...
+
+decoding_table: str
+encoding_table: _EncodingMap

package/dist/typeshed-fallback/stdlib/encodings/ptcp154.pyi

@@ -0,0 +1,21 @@
+import codecs
+from _codecs import _EncodingMap
+from _typeshed import ReadableBuffer
+
+class Codec(codecs.Codec):
+    def encode(self, input: str, errors: str = "strict") -> tuple[bytes, int]: ...
+    def decode(self, input: bytes, errors: str = "strict") -> tuple[str, int]: ...
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    def encode(self, input: str, final: bool = False) -> bytes: ...
+
+class IncrementalDecoder(codecs.IncrementalDecoder):
+    def decode(self, input: ReadableBuffer, final: bool = False) -> str: ...
+
+class StreamWriter(Codec, codecs.StreamWriter): ...
+class StreamReader(Codec, codecs.StreamReader): ...
+
+def getregentry() -> codecs.CodecInfo: ...
+
+decoding_table: str
+encoding_table: _EncodingMap

package/dist/typeshed-fallback/stdlib/encodings/punycode.pyi

@@ -0,0 +1,33 @@
+import codecs
+from typing import Literal
+
+def segregate(str: str) -> tuple[bytes, list[int]]: ...
+def selective_len(str: str, max: int) -> int: ...
+def selective_find(str: str, char: str, index: int, pos: int) -> tuple[int, int]: ...
+def insertion_unsort(str: str, extended: list[int]) -> list[int]: ...
+def T(j: int, bias: int) -> int: ...
+
+digits: Literal[b"abcdefghijklmnopqrstuvwxyz0123456789"]
+
+def generate_generalized_integer(N: int, bias: int) -> bytes: ...
+def adapt(delta: int, first: bool, numchars: int) -> int: ...
+def generate_integers(baselen: int, deltas: list[int]) -> bytes: ...
+def punycode_encode(text: str) -> bytes: ...
+def decode_generalized_number(extended: bytes, extpos: int, bias: int, errors: str) -> tuple[int, int | None]: ...
+def insertion_sort(base: str, extended: bytes, errors: str) -> str: ...
+def punycode_decode(text: memoryview | bytes | bytearray | str, errors: str) -> str: ...
+
+class Codec(codecs.Codec):
+    def encode(self, input: str, errors: str = "strict") -> tuple[bytes, int]: ...
+    def decode(self, input: memoryview | bytes | bytearray | str, errors: str = "strict") -> tuple[str, int]: ...
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    def encode(self, input: str, final: bool = False) -> bytes: ...
+
+class IncrementalDecoder(codecs.IncrementalDecoder):
+    def decode(self, input: memoryview | bytes | bytearray | str, final: bool = False) -> str: ...  # type: ignore[override]
+
+class StreamWriter(Codec, codecs.StreamWriter): ...
+class StreamReader(Codec, codecs.StreamReader): ...
+
+def getregentry() -> codecs.CodecInfo: ...

package/dist/typeshed-fallback/stdlib/encodings/quopri_codec.pyi

@@ -0,0 +1,26 @@
+import codecs
+from _typeshed import ReadableBuffer
+from typing import ClassVar
+
+# This codec is bytes to bytes.
+
+def quopri_encode(input: ReadableBuffer, errors: str = "strict") -> tuple[bytes, int]: ...
+def quopri_decode(input: ReadableBuffer, errors: str = "strict") -> tuple[bytes, int]: ...
+
+class Codec(codecs.Codec):
+    def encode(self, input: ReadableBuffer, errors: str = "strict") -> tuple[bytes, int]: ...  # type: ignore[override]
+    def decode(self, input: ReadableBuffer, errors: str = "strict") -> tuple[bytes, int]: ...  # type: ignore[override]
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    def encode(self, input: ReadableBuffer, final: bool = False) -> bytes: ...  # type: ignore[override]
+
+class IncrementalDecoder(codecs.IncrementalDecoder):
+    def decode(self, input: ReadableBuffer, final: bool = False) -> bytes: ...  # type: ignore[override]
+
+class StreamWriter(Codec, codecs.StreamWriter):
+    charbuffertype: ClassVar[type] = ...
+
+class StreamReader(Codec, codecs.StreamReader):
+    charbuffertype: ClassVar[type] = ...
+
+def getregentry() -> codecs.CodecInfo: ...

package/dist/typeshed-fallback/stdlib/encodings/raw_unicode_escape.pyi

@@ -0,0 +1,34 @@
+import codecs
+import sys
+from _typeshed import ReadableBuffer
+
+class Codec(codecs.Codec):
+    # At runtime, this is codecs.raw_unicode_escape_encode
+    @staticmethod
+    def encode(str: str, errors: str | None = None, /) -> tuple[bytes, int]: ...
+    # At runtime, this is codecs.raw_unicode_escape_decode
+    if sys.version_info >= (3, 9):
+        @staticmethod
+        def decode(data: str | ReadableBuffer, errors: str | None = None, final: bool = True, /) -> tuple[str, int]: ...
+    else:
+        @staticmethod
+        def decode(data: str | ReadableBuffer, errors: str | None = None, /) -> tuple[str, int]: ...
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    def encode(self, input: str, final: bool = False) -> bytes: ...
+
+if sys.version_info >= (3, 9):
+    class IncrementalDecoder(codecs.BufferedIncrementalDecoder):
+        def _buffer_decode(self, input: str | ReadableBuffer, errors: str | None, final: bool) -> tuple[str, int]: ...
+
+else:
+    class IncrementalDecoder(codecs.IncrementalDecoder):
+        def decode(self, input: str | ReadableBuffer, final: bool = False) -> str: ...
+
+class StreamWriter(Codec, codecs.StreamWriter): ...
+
+class StreamReader(Codec, codecs.StreamReader):
+    if sys.version_info >= (3, 9):
+        def decode(self, input: str | ReadableBuffer, errors: str = "strict") -> tuple[str, int]: ...  # type: ignore[override]
+
+def getregentry() -> codecs.CodecInfo: ...

package/dist/typeshed-fallback/stdlib/encodings/rot_13.pyi

@@ -0,0 +1,23 @@
+import codecs
+from _typeshed import SupportsRead, SupportsWrite
+
+# This codec is string to string.
+
+class Codec(codecs.Codec):
+    def encode(self, input: str, errors: str = "strict") -> tuple[str, int]: ...  # type: ignore[override]
+    def decode(self, input: str, errors: str = "strict") -> tuple[str, int]: ...  # type: ignore[override]
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    def encode(self, input: str, final: bool = False) -> str: ...  # type: ignore[override]
+
+class IncrementalDecoder(codecs.IncrementalDecoder):
+    def decode(self, input: str, final: bool = False) -> str: ...  # type: ignore[override]
+
+class StreamWriter(Codec, codecs.StreamWriter): ...
+class StreamReader(Codec, codecs.StreamReader): ...
+
+def getregentry() -> codecs.CodecInfo: ...
+
+rot13_map: dict[int, int]
+
+def rot13(infile: SupportsRead[str], outfile: SupportsWrite[str]) -> None: ...

package/dist/typeshed-fallback/stdlib/encodings/shift_jis.pyi

@@ -0,0 +1,23 @@
+import _multibytecodec as mbc
+import codecs
+from typing import ClassVar
+
+codec: mbc._MultibyteCodec
+
+class Codec(codecs.Codec):
+    encode = codec.encode  # type: ignore[assignment]  # pyright: ignore[reportAssignmentType]
+    decode = codec.decode  # type: ignore[assignment]  # pyright: ignore[reportAssignmentType]
+
+class IncrementalEncoder(mbc.MultibyteIncrementalEncoder, codecs.IncrementalEncoder):  # type: ignore[misc]
+    codec: ClassVar[mbc._MultibyteCodec] = ...
+
+class IncrementalDecoder(mbc.MultibyteIncrementalDecoder, codecs.IncrementalDecoder):
+    codec: ClassVar[mbc._MultibyteCodec] = ...
+
+class StreamReader(Codec, mbc.MultibyteStreamReader, codecs.StreamReader):  # type: ignore[misc]
+    codec: ClassVar[mbc._MultibyteCodec] = ...
+
+class StreamWriter(Codec, mbc.MultibyteStreamWriter, codecs.StreamWriter):
+    codec: ClassVar[mbc._MultibyteCodec] = ...
+
+def getregentry() -> codecs.CodecInfo: ...

package/dist/typeshed-fallback/stdlib/encodings/shift_jis_2004.pyi

@@ -0,0 +1,23 @@
+import _multibytecodec as mbc
+import codecs
+from typing import ClassVar
+
+codec: mbc._MultibyteCodec
+
+class Codec(codecs.Codec):
+    encode = codec.encode  # type: ignore[assignment]  # pyright: ignore[reportAssignmentType]
+    decode = codec.decode  # type: ignore[assignment]  # pyright: ignore[reportAssignmentType]
+
+class IncrementalEncoder(mbc.MultibyteIncrementalEncoder, codecs.IncrementalEncoder):  # type: ignore[misc]
+    codec: ClassVar[mbc._MultibyteCodec] = ...
+
+class IncrementalDecoder(mbc.MultibyteIncrementalDecoder, codecs.IncrementalDecoder):
+    codec: ClassVar[mbc._MultibyteCodec] = ...
+
+class StreamReader(Codec, mbc.MultibyteStreamReader, codecs.StreamReader):  # type: ignore[misc]
+    codec: ClassVar[mbc._MultibyteCodec] = ...
+
+class StreamWriter(Codec, mbc.MultibyteStreamWriter, codecs.StreamWriter):
+    codec: ClassVar[mbc._MultibyteCodec] = ...
+
+def getregentry() -> codecs.CodecInfo: ...

package/dist/typeshed-fallback/stdlib/encodings/shift_jisx0213.pyi

@@ -0,0 +1,23 @@
+import _multibytecodec as mbc
+import codecs
+from typing import ClassVar
+
+codec: mbc._MultibyteCodec
+
+class Codec(codecs.Codec):
+    encode = codec.encode  # type: ignore[assignment]  # pyright: ignore[reportAssignmentType]
+    decode = codec.decode  # type: ignore[assignment]  # pyright: ignore[reportAssignmentType]
+
+class IncrementalEncoder(mbc.MultibyteIncrementalEncoder, codecs.IncrementalEncoder):  # type: ignore[misc]
+    codec: ClassVar[mbc._MultibyteCodec] = ...
+
+class IncrementalDecoder(mbc.MultibyteIncrementalDecoder, codecs.IncrementalDecoder):
+    codec: ClassVar[mbc._MultibyteCodec] = ...
+
+class StreamReader(Codec, mbc.MultibyteStreamReader, codecs.StreamReader):  # type: ignore[misc]
+    codec: ClassVar[mbc._MultibyteCodec] = ...
+
+class StreamWriter(Codec, mbc.MultibyteStreamWriter, codecs.StreamWriter):
+    codec: ClassVar[mbc._MultibyteCodec] = ...
+
+def getregentry() -> codecs.CodecInfo: ...

package/dist/typeshed-fallback/stdlib/encodings/tis_620.pyi

@@ -0,0 +1,21 @@
+import codecs
+from _codecs import _EncodingMap
+from _typeshed import ReadableBuffer
+
+class Codec(codecs.Codec):
+    def encode(self, input: str, errors: str = "strict") -> tuple[bytes, int]: ...
+    def decode(self, input: bytes, errors: str = "strict") -> tuple[str, int]: ...
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    def encode(self, input: str, final: bool = False) -> bytes: ...
+
+class IncrementalDecoder(codecs.IncrementalDecoder):
+    def decode(self, input: ReadableBuffer, final: bool = False) -> str: ...
+
+class StreamWriter(Codec, codecs.StreamWriter): ...
+class StreamReader(Codec, codecs.StreamReader): ...
+
+def getregentry() -> codecs.CodecInfo: ...
+
+decoding_table: str
+encoding_table: _EncodingMap

package/dist/typeshed-fallback/stdlib/encodings/undefined.pyi

@@ -0,0 +1,20 @@
+import codecs
+from _typeshed import ReadableBuffer
+
+# These return types are just to match the base types. In reality, these always
+# raise an error.
+
+class Codec(codecs.Codec):
+    def encode(self, input: str, errors: str = "strict") -> tuple[bytes, int]: ...
+    def decode(self, input: ReadableBuffer, errors: str = "strict") -> tuple[str, int]: ...
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    def encode(self, input: str, final: bool = False) -> bytes: ...
+
+class IncrementalDecoder(codecs.IncrementalDecoder):
+    def decode(self, input: ReadableBuffer, final: bool = False) -> str: ...
+
+class StreamWriter(Codec, codecs.StreamWriter): ...
+class StreamReader(Codec, codecs.StreamReader): ...
+
+def getregentry() -> codecs.CodecInfo: ...

package/dist/typeshed-fallback/stdlib/encodings/unicode_escape.pyi

@@ -0,0 +1,34 @@
+import codecs
+import sys
+from _typeshed import ReadableBuffer
+
+class Codec(codecs.Codec):
+    # At runtime, this is codecs.unicode_escape_encode
+    @staticmethod
+    def encode(str: str, errors: str | None = None, /) -> tuple[bytes, int]: ...
+    # At runtime, this is codecs.unicode_escape_decode
+    if sys.version_info >= (3, 9):
+        @staticmethod
+        def decode(data: str | ReadableBuffer, errors: str | None = None, final: bool = True, /) -> tuple[str, int]: ...
+    else:
+        @staticmethod
+        def decode(data: str | ReadableBuffer, errors: str | None = None, /) -> tuple[str, int]: ...
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    def encode(self, input: str, final: bool = False) -> bytes: ...
+
+if sys.version_info >= (3, 9):
+    class IncrementalDecoder(codecs.BufferedIncrementalDecoder):
+        def _buffer_decode(self, input: str | ReadableBuffer, errors: str | None, final: bool) -> tuple[str, int]: ...
+
+else:
+    class IncrementalDecoder(codecs.IncrementalDecoder):
+        def decode(self, input: str | ReadableBuffer, final: bool = False) -> str: ...
+
+class StreamWriter(Codec, codecs.StreamWriter): ...
+
+class StreamReader(Codec, codecs.StreamReader):
+    if sys.version_info >= (3, 9):
+        def decode(self, input: str | ReadableBuffer, errors: str = "strict") -> tuple[str, int]: ...  # type: ignore[override]
+
+def getregentry() -> codecs.CodecInfo: ...

package/dist/typeshed-fallback/stdlib/encodings/utf_16.pyi

@@ -0,0 +1,20 @@
+import codecs
+from _typeshed import ReadableBuffer
+
+encode = codecs.utf_16_encode
+
+def decode(input: ReadableBuffer, errors: str | None = "strict") -> tuple[str, int]: ...
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    def encode(self, input: str, final: bool = False) -> bytes: ...
+
+class IncrementalDecoder(codecs.BufferedIncrementalDecoder):
+    def _buffer_decode(self, input: ReadableBuffer, errors: str, final: bool) -> tuple[str, int]: ...
+
+class StreamWriter(codecs.StreamWriter):
+    def encode(self, input: str, errors: str = "strict") -> tuple[bytes, int]: ...
+
+class StreamReader(codecs.StreamReader):
+    def decode(self, input: ReadableBuffer, errors: str = "strict") -> tuple[str, int]: ...
+
+def getregentry() -> codecs.CodecInfo: ...

package/dist/typeshed-fallback/stdlib/encodings/utf_16_be.pyi

@@ -0,0 +1,26 @@
+import codecs
+from _typeshed import ReadableBuffer
+
+encode = codecs.utf_16_be_encode
+
+def decode(input: ReadableBuffer, errors: str | None = "strict") -> tuple[str, int]: ...
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    def encode(self, input: str, final: bool = False) -> bytes: ...
+
+class IncrementalDecoder(codecs.BufferedIncrementalDecoder):
+    # At runtime, this is codecs.utf_16_be_decode
+    @staticmethod
+    def _buffer_decode(data: ReadableBuffer, errors: str | None = None, final: bool = False, /) -> tuple[str, int]: ...
+
+class StreamWriter(codecs.StreamWriter):
+    # At runtime, this is codecs.utf_16_be_encode
+    @staticmethod
+    def encode(str: str, errors: str | None = None, /) -> tuple[bytes, int]: ...
+
+class StreamReader(codecs.StreamReader):
+    # At runtime, this is codecs.utf_16_be_decode
+    @staticmethod
+    def decode(data: ReadableBuffer, errors: str | None = None, final: bool = False, /) -> tuple[str, int]: ...
+
+def getregentry() -> codecs.CodecInfo: ...

package/dist/typeshed-fallback/stdlib/encodings/utf_16_le.pyi

@@ -0,0 +1,26 @@
+import codecs
+from _typeshed import ReadableBuffer
+
+encode = codecs.utf_16_le_encode
+
+def decode(input: ReadableBuffer, errors: str | None = "strict") -> tuple[str, int]: ...
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    def encode(self, input: str, final: bool = False) -> bytes: ...
+
+class IncrementalDecoder(codecs.BufferedIncrementalDecoder):
+    # At runtime, this is codecs.utf_16_le_decode
+    @staticmethod
+    def _buffer_decode(data: ReadableBuffer, errors: str | None = None, final: bool = False, /) -> tuple[str, int]: ...
+
+class StreamWriter(codecs.StreamWriter):
+    # At runtime, this is codecs.utf_16_le_encode
+    @staticmethod
+    def encode(str: str, errors: str | None = None, /) -> tuple[bytes, int]: ...
+
+class StreamReader(codecs.StreamReader):
+    # At runtime, this is codecs.utf_16_le_decode
+    @staticmethod
+    def decode(data: ReadableBuffer, errors: str | None = None, final: bool = False, /) -> tuple[str, int]: ...
+
+def getregentry() -> codecs.CodecInfo: ...

package/dist/typeshed-fallback/stdlib/encodings/utf_32.pyi

@@ -0,0 +1,20 @@
+import codecs
+from _typeshed import ReadableBuffer
+
+encode = codecs.utf_32_encode
+
+def decode(input: ReadableBuffer, errors: str | None = "strict") -> tuple[str, int]: ...
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    def encode(self, input: str, final: bool = False) -> bytes: ...
+
+class IncrementalDecoder(codecs.BufferedIncrementalDecoder):
+    def _buffer_decode(self, input: ReadableBuffer, errors: str, final: bool) -> tuple[str, int]: ...
+
+class StreamWriter(codecs.StreamWriter):
+    def encode(self, input: str, errors: str = "strict") -> tuple[bytes, int]: ...
+
+class StreamReader(codecs.StreamReader):
+    def decode(self, input: ReadableBuffer, errors: str = "strict") -> tuple[str, int]: ...
+
+def getregentry() -> codecs.CodecInfo: ...

package/dist/typeshed-fallback/stdlib/encodings/utf_32_be.pyi

@@ -0,0 +1,26 @@
+import codecs
+from _typeshed import ReadableBuffer
+
+encode = codecs.utf_32_be_encode
+
+def decode(input: ReadableBuffer, errors: str | None = "strict") -> tuple[str, int]: ...
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    def encode(self, input: str, final: bool = False) -> bytes: ...
+
+class IncrementalDecoder(codecs.BufferedIncrementalDecoder):
+    # At runtime, this is codecs.utf_32_be_decode
+    @staticmethod
+    def _buffer_decode(data: ReadableBuffer, errors: str | None = None, final: bool = False, /) -> tuple[str, int]: ...
+
+class StreamWriter(codecs.StreamWriter):
+    # At runtime, this is codecs.utf_32_be_encode
+    @staticmethod
+    def encode(str: str, errors: str | None = None, /) -> tuple[bytes, int]: ...
+
+class StreamReader(codecs.StreamReader):
+    # At runtime, this is codecs.utf_32_be_decode
+    @staticmethod
+    def decode(data: ReadableBuffer, errors: str | None = None, final: bool = False, /) -> tuple[str, int]: ...
+
+def getregentry() -> codecs.CodecInfo: ...

package/dist/typeshed-fallback/stdlib/encodings/utf_32_le.pyi

@@ -0,0 +1,26 @@
+import codecs
+from _typeshed import ReadableBuffer
+
+encode = codecs.utf_32_le_encode
+
+def decode(input: ReadableBuffer, errors: str | None = "strict") -> tuple[str, int]: ...
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    def encode(self, input: str, final: bool = False) -> bytes: ...
+
+class IncrementalDecoder(codecs.BufferedIncrementalDecoder):
+    # At runtime, this is codecs.utf_32_le_decode
+    @staticmethod
+    def _buffer_decode(data: ReadableBuffer, errors: str | None = None, final: bool = False, /) -> tuple[str, int]: ...
+
+class StreamWriter(codecs.StreamWriter):
+    # At runtime, this is codecs.utf_32_le_encode
+    @staticmethod
+    def encode(str: str, errors: str | None = None, /) -> tuple[bytes, int]: ...
+
+class StreamReader(codecs.StreamReader):
+    # At runtime, this is codecs.utf_32_le_decode
+    @staticmethod
+    def decode(data: ReadableBuffer, errors: str | None = None, final: bool = False, /) -> tuple[str, int]: ...
+
+def getregentry() -> codecs.CodecInfo: ...

package/dist/typeshed-fallback/stdlib/encodings/utf_7.pyi

@@ -0,0 +1,26 @@
+import codecs
+from _typeshed import ReadableBuffer
+
+encode = codecs.utf_7_encode
+
+def decode(input: ReadableBuffer, errors: str | None = "strict") -> tuple[str, int]: ...
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    def encode(self, input: str, final: bool = False) -> bytes: ...
+
+class IncrementalDecoder(codecs.BufferedIncrementalDecoder):
+    # At runtime, this is codecs.utf_7_decode
+    @staticmethod
+    def _buffer_decode(data: ReadableBuffer, errors: str | None = None, final: bool = False, /) -> tuple[str, int]: ...
+
+class StreamWriter(codecs.StreamWriter):
+    # At runtime, this is codecs.utf_7_encode
+    @staticmethod
+    def encode(str: str, errors: str | None = None, /) -> tuple[bytes, int]: ...
+
+class StreamReader(codecs.StreamReader):
+    # At runtime, this is codecs.utf_7_decode
+    @staticmethod
+    def decode(data: ReadableBuffer, errors: str | None = None, final: bool = False, /) -> tuple[str, int]: ...
+
+def getregentry() -> codecs.CodecInfo: ...

package/dist/typeshed-fallback/stdlib/encodings/utf_8.pyi

@@ -1,21 +1,26 @@
-import codecs
-from _typeshed import ReadableBuffer
-
-class IncrementalEncoder(codecs.IncrementalEncoder):
-    def encode(self, input: str, final: bool = False) -> bytes: ...
-
-class IncrementalDecoder(codecs.BufferedIncrementalDecoder):
-    @staticmethod
-    def _buffer_decode(data: ReadableBuffer, errors: str | None = None, final: bool = False, /) -> tuple[str, int]: ...
-
-class StreamWriter(codecs.StreamWriter):
-    @staticmethod
-    def encode(str: str, errors: str | None = None, /) -> tuple[bytes, int]: ...
-
-class StreamReader(codecs.StreamReader):
-    @staticmethod
-    def decode(data: ReadableBuffer, errors: str | None = None, final: bool = False, /) -> tuple[str, int]: ...
-
-def getregentry() -> codecs.CodecInfo: ...
-def encode(str: str, errors: str | None = None, /) -> tuple[bytes, int]: ...
-def decode(input: ReadableBuffer, errors: str | None = "strict") -> tuple[str, int]: ...
+import codecs
+from _typeshed import ReadableBuffer
+
+encode = codecs.utf_8_encode
+
+def decode(input: ReadableBuffer, errors: str | None = "strict") -> tuple[str, int]: ...
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    def encode(self, input: str, final: bool = False) -> bytes: ...
+
+class IncrementalDecoder(codecs.BufferedIncrementalDecoder):
+    # At runtime, this is codecs.utf_8_decode
+    @staticmethod
+    def _buffer_decode(data: ReadableBuffer, errors: str | None = None, final: bool = False, /) -> tuple[str, int]: ...
+
+class StreamWriter(codecs.StreamWriter):
+    # At runtime, this is codecs.utf_8_encode
+    @staticmethod
+    def encode(str: str, errors: str | None = None, /) -> tuple[bytes, int]: ...
+
+class StreamReader(codecs.StreamReader):
+    # At runtime, this is codecs.utf_8_decode
+    @staticmethod
+    def decode(data: ReadableBuffer, errors: str | None = None, final: bool = False, /) -> tuple[str, int]: ...
+
+def getregentry() -> codecs.CodecInfo: ...