basedpyright 1.31.6 → 1.31.7-8064362195d32e67ab0ff5fd0052429de44e1f90

package/dist/typeshed-fallback/stdlib/asyncio/graph.pyi

@@ -1,28 +1,28 @@
-import sys
-from _typeshed import SupportsWrite
-from asyncio import Future
-from dataclasses import dataclass
-from types import FrameType
-from typing import Any, overload
-
-if sys.version_info >= (3, 14):
-    __all__ = ("capture_call_graph", "format_call_graph", "print_call_graph", "FrameCallGraphEntry", "FutureCallGraph")
-
-    @dataclass(frozen=True, slots=True)
-    class FrameCallGraphEntry:
-        frame: FrameType
-
-    @dataclass(frozen=True, slots=True)
-    class FutureCallGraph:
-        future: Future[Any]
-        call_stack: tuple[FrameCallGraphEntry, ...]
-        awaited_by: tuple[FutureCallGraph, ...]
-
-    @overload
-    def capture_call_graph(future: None = None, /, *, depth: int = 1, limit: int | None = None) -> FutureCallGraph | None: ...
-    @overload
-    def capture_call_graph(future: Future[Any], /, *, depth: int = 1, limit: int | None = None) -> FutureCallGraph | None: ...
-    def format_call_graph(future: Future[Any] | None = None, /, *, depth: int = 1, limit: int | None = None) -> str: ...
-    def print_call_graph(
-        future: Future[Any] | None = None, /, *, file: SupportsWrite[str] | None = None, depth: int = 1, limit: int | None = None
-    ) -> None: ...
+import sys
+from _typeshed import SupportsWrite
+from asyncio import Future
+from dataclasses import dataclass
+from types import FrameType
+from typing import Any, overload
+
+if sys.version_info >= (3, 14):
+    __all__ = ("capture_call_graph", "format_call_graph", "print_call_graph", "FrameCallGraphEntry", "FutureCallGraph")
+
+    @dataclass(frozen=True, slots=True)
+    class FrameCallGraphEntry:
+        frame: FrameType
+
+    @dataclass(frozen=True, slots=True)
+    class FutureCallGraph:
+        future: Future[Any]
+        call_stack: tuple[FrameCallGraphEntry, ...]
+        awaited_by: tuple[FutureCallGraph, ...]
+
+    @overload
+    def capture_call_graph(future: None = None, /, *, depth: int = 1, limit: int | None = None) -> FutureCallGraph | None: ...
+    @overload
+    def capture_call_graph(future: Future[Any], /, *, depth: int = 1, limit: int | None = None) -> FutureCallGraph | None: ...
+    def format_call_graph(future: Future[Any] | None = None, /, *, depth: int = 1, limit: int | None = None) -> str: ...
+    def print_call_graph(
+        future: Future[Any] | None = None, /, *, file: SupportsWrite[str] | None = None, depth: int = 1, limit: int | None = None
+    ) -> None: ...

package/dist/typeshed-fallback/stdlib/asyncio/tasks.pyi

@@ -411,7 +411,9 @@ if sys.version_info >= (3, 12):
 else:
     _TaskCompatibleCoro: TypeAlias = Generator[_TaskYieldType, None, _T_co] | Coroutine[Any, Any, _T_co]
 
-def all_tasks(loop: AbstractEventLoop | None = None) -> set[Task[Any]]: ...
+def all_tasks(loop: AbstractEventLoop | None = None) -> set[Task[Any]]:
+    """Return a set of all tasks for the loop."""
+    ...
 
 if sys.version_info >= (3, 11):
     def create_task(coro: _CoroutineLike[_T], *, name: str | None = None, context: Context | None = None) -> Task[_T]: ...

package/dist/typeshed-fallback/stdlib/asyncio/tools.pyi

@@ -1,46 +1,46 @@
-import sys
-from collections.abc import Iterable
-from enum import Enum
-from typing import NamedTuple, SupportsIndex, type_check_only
-
-@type_check_only
-class _AwaitedInfo(NamedTuple):  # AwaitedInfo_Type from _remote_debugging
-    thread_id: int
-    awaited_by: list[_TaskInfo]
-
-@type_check_only
-class _TaskInfo(NamedTuple):  # TaskInfo_Type from _remote_debugging
-    task_id: int
-    task_name: str
-    coroutine_stack: list[_CoroInfo]
-    awaited_by: list[_CoroInfo]
-
-@type_check_only
-class _CoroInfo(NamedTuple):  # CoroInfo_Type from _remote_debugging
-    call_stack: list[_FrameInfo]
-    task_name: int | str
-
-@type_check_only
-class _FrameInfo(NamedTuple):  # FrameInfo_Type from _remote_debugging
-    filename: str
-    lineno: int
-    funcname: str
-
-class NodeType(Enum):
-    COROUTINE = 1
-    TASK = 2
-
-class CycleFoundException(Exception):
-    cycles: list[list[int]]
-    id2name: dict[int, str]
-    def __init__(self, cycles: list[list[int]], id2name: dict[int, str]) -> None: ...
-
-def get_all_awaited_by(pid: SupportsIndex) -> list[_AwaitedInfo]: ...
-def build_async_tree(result: Iterable[_AwaitedInfo], task_emoji: str = "(T)", cor_emoji: str = "") -> list[list[str]]: ...
-def build_task_table(result: Iterable[_AwaitedInfo]) -> list[list[int | str]]: ...
-
-if sys.version_info >= (3, 14):
-    def exit_with_permission_help_text() -> None: ...
-
-def display_awaited_by_tasks_table(pid: SupportsIndex) -> None: ...
-def display_awaited_by_tasks_tree(pid: SupportsIndex) -> None: ...
+import sys
+from collections.abc import Iterable
+from enum import Enum
+from typing import NamedTuple, SupportsIndex, type_check_only
+
+@type_check_only
+class _AwaitedInfo(NamedTuple):  # AwaitedInfo_Type from _remote_debugging
+    thread_id: int
+    awaited_by: list[_TaskInfo]
+
+@type_check_only
+class _TaskInfo(NamedTuple):  # TaskInfo_Type from _remote_debugging
+    task_id: int
+    task_name: str
+    coroutine_stack: list[_CoroInfo]
+    awaited_by: list[_CoroInfo]
+
+@type_check_only
+class _CoroInfo(NamedTuple):  # CoroInfo_Type from _remote_debugging
+    call_stack: list[_FrameInfo]
+    task_name: int | str
+
+@type_check_only
+class _FrameInfo(NamedTuple):  # FrameInfo_Type from _remote_debugging
+    filename: str
+    lineno: int
+    funcname: str
+
+class NodeType(Enum):
+    COROUTINE = 1
+    TASK = 2
+
+class CycleFoundException(Exception):
+    cycles: list[list[int]]
+    id2name: dict[int, str]
+    def __init__(self, cycles: list[list[int]], id2name: dict[int, str]) -> None: ...
+
+def get_all_awaited_by(pid: SupportsIndex) -> list[_AwaitedInfo]: ...
+def build_async_tree(result: Iterable[_AwaitedInfo], task_emoji: str = "(T)", cor_emoji: str = "") -> list[list[str]]: ...
+def build_task_table(result: Iterable[_AwaitedInfo]) -> list[list[int | str]]: ...
+
+if sys.version_info >= (3, 14):
+    def exit_with_permission_help_text() -> None: ...
+
+def display_awaited_by_tasks_table(pid: SupportsIndex) -> None: ...
+def display_awaited_by_tasks_tree(pid: SupportsIndex) -> None: ...

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

@@ -669,15 +669,15 @@ class int:
         """Flooring an Integral returns itself."""
         ...
     if sys.version_info >= (3, 14):
-        def __round__(self, ndigits: SupportsIndex | None = None, /) -> int: ...
-    else:
-        def __round__(self, ndigits: SupportsIndex = ..., /) -> int:
+        def __round__(self, ndigits: SupportsIndex | None = None, /) -> int:
             """
             Rounding an Integral returns itself.
 
             Rounding with an ndigits argument also returns an integer.
             """
             ...
+    else:
+        def __round__(self, ndigits: SupportsIndex = ..., /) -> int: ...
 
     def __getnewargs__(self) -> tuple[int]: ...
     def __eq__(self, value: object, /) -> bool:
@@ -909,7 +909,9 @@ class float:
         ...
     if sys.version_info >= (3, 14):
         @classmethod
-        def from_number(cls, number: float | SupportsIndex | SupportsFloat, /) -> Self: ...
+        def from_number(cls, number: float | SupportsIndex | SupportsFloat, /) -> Self:
+            """Convert real number to a floating-point number."""
+            ...
 
 @disjoint_base
 class complex:
@@ -1001,7 +1003,9 @@ class complex:
             ...
     if sys.version_info >= (3, 14):
         @classmethod
-        def from_number(cls, number: complex | SupportsComplex | SupportsFloat | SupportsIndex, /) -> Self: ...
+        def from_number(cls, number: complex | SupportsComplex | SupportsFloat | SupportsIndex, /) -> Self:
+            """Convert number to a complex floating-point number."""
+            ...
 
 @type_check_only
 class _FormatMapMapping(Protocol):
@@ -2902,7 +2906,14 @@ class bytearray(MutableSequence[int]):
         """Release the buffer object that exposes the underlying memory of the object."""
         ...
     if sys.version_info >= (3, 14):
-        def resize(self, size: int, /) -> None: ...
+        def resize(self, size: int, /) -> None:
+            """
+            Resize the internal buffer of bytearray to len.
+
+            size
+              New size to resize to..
+            """
+            ...
 
 _IntegerFormats: TypeAlias = Literal[
     "b", "B", "@b", "@B", "h", "H", "@h", "@H", "i", "I", "@i", "@I", "l", "L", "@l", "@L", "q", "Q", "@q", "@Q", "P", "@P"
@@ -3088,7 +3099,9 @@ class memoryview(Sequence[_I]):
     index: ClassVar[None]  # type: ignore[assignment]
     count: ClassVar[None]  # type: ignore[assignment]
     if sys.version_info >= (3, 14):
-        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
+        def __class_getitem__(cls, item: Any, /) -> GenericAlias:
+            """See PEP 585"""
+            ...
 
 @final
 class bool(int):
@@ -4550,6 +4563,9 @@ class map(Generic[_S]):
     """
     Make an iterator that computes the function using arguments from
     each of the iterables.  Stops when the shortest iterable is exhausted.
+
+    If strict is true and one of the arguments is exhausted before the others,
+    raise a ValueError.
     """
     # 3.14 adds `strict` argument.
     if sys.version_info >= (3, 14):
@@ -4901,9 +4917,9 @@ def open(
     given, the default buffering policy works as follows:
 
     * Binary files are buffered in fixed-size chunks; the size of the buffer
-      is chosen using a heuristic trying to determine the underlying device's
-      "block size" and falling back on `io.DEFAULT_BUFFER_SIZE`.
-      On many systems, the buffer will typically be 4096 or 8192 bytes long.
+     is max(min(blocksize, 8 MiB), DEFAULT_BUFFER_SIZE)
+     when the device block size is available.
+     On most systems, the buffer will typically be 128 kilobytes long.
 
     * "Interactive" text files (files for which isatty() returns True)
       use line buffering.  Other text files use the policy described above
@@ -5030,9 +5046,9 @@ def open(
     given, the default buffering policy works as follows:
 
     * Binary files are buffered in fixed-size chunks; the size of the buffer
-      is chosen using a heuristic trying to determine the underlying device's
-      "block size" and falling back on `io.DEFAULT_BUFFER_SIZE`.
-      On many systems, the buffer will typically be 4096 or 8192 bytes long.
+     is max(min(blocksize, 8 MiB), DEFAULT_BUFFER_SIZE)
+     when the device block size is available.
+     On most systems, the buffer will typically be 128 kilobytes long.
 
     * "Interactive" text files (files for which isatty() returns True)
       use line buffering.  Other text files use the policy described above
@@ -5159,9 +5175,9 @@ def open(
     given, the default buffering policy works as follows:
 
     * Binary files are buffered in fixed-size chunks; the size of the buffer
-      is chosen using a heuristic trying to determine the underlying device's
-      "block size" and falling back on `io.DEFAULT_BUFFER_SIZE`.
-      On many systems, the buffer will typically be 4096 or 8192 bytes long.
+     is max(min(blocksize, 8 MiB), DEFAULT_BUFFER_SIZE)
+     when the device block size is available.
+     On most systems, the buffer will typically be 128 kilobytes long.
 
     * "Interactive" text files (files for which isatty() returns True)
       use line buffering.  Other text files use the policy described above
@@ -5286,9 +5302,9 @@ def open(
     given, the default buffering policy works as follows:
 
     * Binary files are buffered in fixed-size chunks; the size of the buffer
-      is chosen using a heuristic trying to determine the underlying device's
-      "block size" and falling back on `io.DEFAULT_BUFFER_SIZE`.
-      On many systems, the buffer will typically be 4096 or 8192 bytes long.
+     is max(min(blocksize, 8 MiB), DEFAULT_BUFFER_SIZE)
+     when the device block size is available.
+     On most systems, the buffer will typically be 128 kilobytes long.
 
     * "Interactive" text files (files for which isatty() returns True)
       use line buffering.  Other text files use the policy described above
@@ -5413,9 +5429,9 @@ def open(
     given, the default buffering policy works as follows:
 
     * Binary files are buffered in fixed-size chunks; the size of the buffer
-      is chosen using a heuristic trying to determine the underlying device's
-      "block size" and falling back on `io.DEFAULT_BUFFER_SIZE`.
-      On many systems, the buffer will typically be 4096 or 8192 bytes long.
+     is max(min(blocksize, 8 MiB), DEFAULT_BUFFER_SIZE)
+     when the device block size is available.
+     On most systems, the buffer will typically be 128 kilobytes long.
 
     * "Interactive" text files (files for which isatty() returns True)
       use line buffering.  Other text files use the policy described above
@@ -5542,9 +5558,9 @@ def open(
     given, the default buffering policy works as follows:
 
     * Binary files are buffered in fixed-size chunks; the size of the buffer
-      is chosen using a heuristic trying to determine the underlying device's
-      "block size" and falling back on `io.DEFAULT_BUFFER_SIZE`.
-      On many systems, the buffer will typically be 4096 or 8192 bytes long.
+     is max(min(blocksize, 8 MiB), DEFAULT_BUFFER_SIZE)
+     when the device block size is available.
+     On most systems, the buffer will typically be 128 kilobytes long.
 
     * "Interactive" text files (files for which isatty() returns True)
       use line buffering.  Other text files use the policy described above
@@ -5671,9 +5687,9 @@ def open(
     given, the default buffering policy works as follows:
 
     * Binary files are buffered in fixed-size chunks; the size of the buffer
-      is chosen using a heuristic trying to determine the underlying device's
-      "block size" and falling back on `io.DEFAULT_BUFFER_SIZE`.
-      On many systems, the buffer will typically be 4096 or 8192 bytes long.
+     is max(min(blocksize, 8 MiB), DEFAULT_BUFFER_SIZE)
+     when the device block size is available.
+     On most systems, the buffer will typically be 128 kilobytes long.
 
     * "Interactive" text files (files for which isatty() returns True)
       use line buffering.  Other text files use the policy described above
@@ -6259,19 +6275,13 @@ class BaseException:
     def __new__(cls, *args: Any, **kwds: Any) -> Self: ...
     def __setstate__(self, state: dict[str, Any] | None, /) -> None: ...
     def with_traceback(self, tb: TracebackType | None, /) -> Self:
-        """
-        Exception.with_traceback(tb) --
-        set self.__traceback__ to tb and return self.
-        """
+        """Set self.__traceback__ to tb and return self."""
         ...
     if sys.version_info >= (3, 11):
         # only present after add_note() is called
         __notes__: list[str]
         def add_note(self, note: str, /) -> None:
-            """
-            Exception.add_note(note) --
-            add a note to the exception
-            """
+            """Add a note to the exception"""
             ...
 
 class GeneratorExit(BaseException):

package/dist/typeshed-fallback/stdlib/compression/_common/_streams.pyi

@@ -1,26 +1,26 @@
-from _typeshed import Incomplete, WriteableBuffer
-from collections.abc import Callable
-from io import DEFAULT_BUFFER_SIZE, BufferedIOBase, RawIOBase
-from typing import Any, Protocol, type_check_only
-
-BUFFER_SIZE = DEFAULT_BUFFER_SIZE
-
-@type_check_only
-class _Reader(Protocol):
-    def read(self, n: int, /) -> bytes: ...
-    def seekable(self) -> bool: ...
-    def seek(self, n: int, /) -> Any: ...
-
-class BaseStream(BufferedIOBase): ...
-
-class DecompressReader(RawIOBase):
-    def __init__(
-        self,
-        fp: _Reader,
-        decomp_factory: Callable[..., Incomplete],  # Consider backporting changes to _compression
-        trailing_error: type[Exception] | tuple[type[Exception], ...] = (),
-        **decomp_args: Any,  # These are passed to decomp_factory.
-    ) -> None: ...
-    def readinto(self, b: WriteableBuffer) -> int: ...
-    def read(self, size: int = -1) -> bytes: ...
-    def seek(self, offset: int, whence: int = 0) -> int: ...
+from _typeshed import Incomplete, WriteableBuffer
+from collections.abc import Callable
+from io import DEFAULT_BUFFER_SIZE, BufferedIOBase, RawIOBase
+from typing import Any, Protocol, type_check_only
+
+BUFFER_SIZE = DEFAULT_BUFFER_SIZE
+
+@type_check_only
+class _Reader(Protocol):
+    def read(self, n: int, /) -> bytes: ...
+    def seekable(self) -> bool: ...
+    def seek(self, n: int, /) -> Any: ...
+
+class BaseStream(BufferedIOBase): ...
+
+class DecompressReader(RawIOBase):
+    def __init__(
+        self,
+        fp: _Reader,
+        decomp_factory: Callable[..., Incomplete],  # Consider backporting changes to _compression
+        trailing_error: type[Exception] | tuple[type[Exception], ...] = (),
+        **decomp_args: Any,  # These are passed to decomp_factory.
+    ) -> None: ...
+    def readinto(self, b: WriteableBuffer) -> int: ...
+    def read(self, size: int = -1) -> bytes: ...
+    def seek(self, offset: int, whence: int = 0) -> int: ...

package/dist/typeshed-fallback/stdlib/compression/bz2.pyi

@@ -1 +1 @@
-from bz2 import *
+from bz2 import *

package/dist/typeshed-fallback/stdlib/compression/gzip.pyi

@@ -1 +1 @@
-from gzip import *
+from gzip import *

package/dist/typeshed-fallback/stdlib/compression/lzma.pyi

@@ -1 +1 @@
-from lzma import *
+from lzma import *

package/dist/typeshed-fallback/stdlib/compression/zlib.pyi

@@ -1 +1 @@
-from zlib import *
+from zlib import *

package/dist/typeshed-fallback/stdlib/compression/zstd/__init__.pyi

@@ -1,88 +1,88 @@
-import enum
-from _typeshed import ReadableBuffer
-from collections.abc import Iterable, Mapping
-from compression.zstd._zstdfile import ZstdFile, open
-from typing import Final, final
-
-import _zstd
-from _zstd import ZstdCompressor, ZstdDecompressor, ZstdDict, ZstdError, get_frame_size, zstd_version
-
-__all__ = (
-    # compression.zstd
-    "COMPRESSION_LEVEL_DEFAULT",
-    "compress",
-    "CompressionParameter",
-    "decompress",
-    "DecompressionParameter",
-    "finalize_dict",
-    "get_frame_info",
-    "Strategy",
-    "train_dict",
-    # compression.zstd._zstdfile
-    "open",
-    "ZstdFile",
-    # _zstd
-    "get_frame_size",
-    "zstd_version",
-    "zstd_version_info",
-    "ZstdCompressor",
-    "ZstdDecompressor",
-    "ZstdDict",
-    "ZstdError",
-)
-
-zstd_version_info: Final[tuple[int, int, int]]
-COMPRESSION_LEVEL_DEFAULT: Final = _zstd.ZSTD_CLEVEL_DEFAULT
-
-class FrameInfo:
-    __slots__ = ("decompressed_size", "dictionary_id")
-    decompressed_size: int
-    dictionary_id: int
-    def __init__(self, decompressed_size: int, dictionary_id: int) -> None: ...
-
-def get_frame_info(frame_buffer: ReadableBuffer) -> FrameInfo: ...
-def train_dict(samples: Iterable[ReadableBuffer], dict_size: int) -> ZstdDict: ...
-def finalize_dict(zstd_dict: ZstdDict, /, samples: Iterable[ReadableBuffer], dict_size: int, level: int) -> ZstdDict: ...
-def compress(
-    data: ReadableBuffer, level: int | None = None, options: Mapping[int, int] | None = None, zstd_dict: ZstdDict | None = None
-) -> bytes: ...
-def decompress(data: ReadableBuffer, zstd_dict: ZstdDict | None = None, options: Mapping[int, int] | None = None) -> bytes: ...
-@final
-class CompressionParameter(enum.IntEnum):
-    compression_level = _zstd.ZSTD_c_compressionLevel
-    window_log = _zstd.ZSTD_c_windowLog
-    hash_log = _zstd.ZSTD_c_hashLog
-    chain_log = _zstd.ZSTD_c_chainLog
-    search_log = _zstd.ZSTD_c_searchLog
-    min_match = _zstd.ZSTD_c_minMatch
-    target_length = _zstd.ZSTD_c_targetLength
-    strategy = _zstd.ZSTD_c_strategy
-    enable_long_distance_matching = _zstd.ZSTD_c_enableLongDistanceMatching
-    ldm_hash_log = _zstd.ZSTD_c_ldmHashLog
-    ldm_min_match = _zstd.ZSTD_c_ldmMinMatch
-    ldm_bucket_size_log = _zstd.ZSTD_c_ldmBucketSizeLog
-    ldm_hash_rate_log = _zstd.ZSTD_c_ldmHashRateLog
-    content_size_flag = _zstd.ZSTD_c_contentSizeFlag
-    checksum_flag = _zstd.ZSTD_c_checksumFlag
-    dict_id_flag = _zstd.ZSTD_c_dictIDFlag
-    nb_workers = _zstd.ZSTD_c_nbWorkers
-    job_size = _zstd.ZSTD_c_jobSize
-    overlap_log = _zstd.ZSTD_c_overlapLog
-    def bounds(self) -> tuple[int, int]: ...
-
-@final
-class DecompressionParameter(enum.IntEnum):
-    window_log_max = _zstd.ZSTD_d_windowLogMax
-    def bounds(self) -> tuple[int, int]: ...
-
-@final
-class Strategy(enum.IntEnum):
-    fast = _zstd.ZSTD_fast
-    dfast = _zstd.ZSTD_dfast
-    greedy = _zstd.ZSTD_greedy
-    lazy = _zstd.ZSTD_lazy
-    lazy2 = _zstd.ZSTD_lazy2
-    btlazy2 = _zstd.ZSTD_btlazy2
-    btopt = _zstd.ZSTD_btopt
-    btultra = _zstd.ZSTD_btultra
-    btultra2 = _zstd.ZSTD_btultra2
+import enum
+from _typeshed import ReadableBuffer
+from collections.abc import Iterable, Mapping
+from compression.zstd._zstdfile import ZstdFile, open
+from typing import Final, final
+
+import _zstd
+from _zstd import ZstdCompressor, ZstdDecompressor, ZstdDict, ZstdError, get_frame_size, zstd_version
+
+__all__ = (
+    # compression.zstd
+    "COMPRESSION_LEVEL_DEFAULT",
+    "compress",
+    "CompressionParameter",
+    "decompress",
+    "DecompressionParameter",
+    "finalize_dict",
+    "get_frame_info",
+    "Strategy",
+    "train_dict",
+    # compression.zstd._zstdfile
+    "open",
+    "ZstdFile",
+    # _zstd
+    "get_frame_size",
+    "zstd_version",
+    "zstd_version_info",
+    "ZstdCompressor",
+    "ZstdDecompressor",
+    "ZstdDict",
+    "ZstdError",
+)
+
+zstd_version_info: Final[tuple[int, int, int]]
+COMPRESSION_LEVEL_DEFAULT: Final = _zstd.ZSTD_CLEVEL_DEFAULT
+
+class FrameInfo:
+    __slots__ = ("decompressed_size", "dictionary_id")
+    decompressed_size: int
+    dictionary_id: int
+    def __init__(self, decompressed_size: int, dictionary_id: int) -> None: ...
+
+def get_frame_info(frame_buffer: ReadableBuffer) -> FrameInfo: ...
+def train_dict(samples: Iterable[ReadableBuffer], dict_size: int) -> ZstdDict: ...
+def finalize_dict(zstd_dict: ZstdDict, /, samples: Iterable[ReadableBuffer], dict_size: int, level: int) -> ZstdDict: ...
+def compress(
+    data: ReadableBuffer, level: int | None = None, options: Mapping[int, int] | None = None, zstd_dict: ZstdDict | None = None
+) -> bytes: ...
+def decompress(data: ReadableBuffer, zstd_dict: ZstdDict | None = None, options: Mapping[int, int] | None = None) -> bytes: ...
+@final
+class CompressionParameter(enum.IntEnum):
+    compression_level = _zstd.ZSTD_c_compressionLevel
+    window_log = _zstd.ZSTD_c_windowLog
+    hash_log = _zstd.ZSTD_c_hashLog
+    chain_log = _zstd.ZSTD_c_chainLog
+    search_log = _zstd.ZSTD_c_searchLog
+    min_match = _zstd.ZSTD_c_minMatch
+    target_length = _zstd.ZSTD_c_targetLength
+    strategy = _zstd.ZSTD_c_strategy
+    enable_long_distance_matching = _zstd.ZSTD_c_enableLongDistanceMatching
+    ldm_hash_log = _zstd.ZSTD_c_ldmHashLog
+    ldm_min_match = _zstd.ZSTD_c_ldmMinMatch
+    ldm_bucket_size_log = _zstd.ZSTD_c_ldmBucketSizeLog
+    ldm_hash_rate_log = _zstd.ZSTD_c_ldmHashRateLog
+    content_size_flag = _zstd.ZSTD_c_contentSizeFlag
+    checksum_flag = _zstd.ZSTD_c_checksumFlag
+    dict_id_flag = _zstd.ZSTD_c_dictIDFlag
+    nb_workers = _zstd.ZSTD_c_nbWorkers
+    job_size = _zstd.ZSTD_c_jobSize
+    overlap_log = _zstd.ZSTD_c_overlapLog
+    def bounds(self) -> tuple[int, int]: ...
+
+@final
+class DecompressionParameter(enum.IntEnum):
+    window_log_max = _zstd.ZSTD_d_windowLogMax
+    def bounds(self) -> tuple[int, int]: ...
+
+@final
+class Strategy(enum.IntEnum):
+    fast = _zstd.ZSTD_fast
+    dfast = _zstd.ZSTD_dfast
+    greedy = _zstd.ZSTD_greedy
+    lazy = _zstd.ZSTD_lazy
+    lazy2 = _zstd.ZSTD_lazy2
+    btlazy2 = _zstd.ZSTD_btlazy2
+    btopt = _zstd.ZSTD_btopt
+    btultra = _zstd.ZSTD_btultra
+    btultra2 = _zstd.ZSTD_btultra2