assertpy 2.35.0__py3-none-any.whl

assertpy/_engine/_negated_typing.py

@@ -0,0 +1,2176 @@
+"""The negation twin of every assertion protocol.
+
+Generated by `scripts/generate_poll_protocols.py`.
+
+Do not edit.  `not_` on a view hands one of these back, and every assertion on it hands the view back:
+`NegatedBuilder` inverts one assertion and returns the builder it wrapped, so the type has to say
+`positive -> negated -> positive` rather than making the negation permanent.
+
+The narrowing ladders are absent by construction.  A negated `is_instance_of(str)` asserts the value is
+*not* a string, so answering the string view promises the opposite of what was checked: that shipped,
+typed an `int` as `str`, and all four checkers accepted it.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Protocol
+
+if TYPE_CHECKING:
+    import datetime
+    import re
+    from collections.abc import Callable, Hashable, Iterable, Mapping, Sized
+    from pathlib import Path
+    from typing import Any, SupportsFloat, SupportsIndex, TypeVar, overload
+
+    from .._matcher_impls import ClassInfo, ExceptionInfo
+    from ..matchers import Matcher
+    from ._introspection import MappingLike
+    from ._typing import (
+        _U,
+        _ArrayT_co,
+        _Exc,
+        _FrameT_co,
+        _Landed,
+        _Other,
+        _P_co,
+        _T_co,
+    )
+
+    _KeySpecs = Hashable | list[Hashable] | set[Hashable] | frozenset[Hashable]
+
+    _E = TypeVar("_E")
+    _N = TypeVar("_N", int, float)
+    _K = TypeVar("_K")
+    _V = TypeVar("_V")
+    _R = TypeVar("_R")
+    _B_co = TypeVar("_B_co", bytes, bytearray, covariant=True)
+    _U2 = TypeVar("_U2")
+    _U3 = TypeVar("_U3")
+    _Number = SupportsFloat
+
+    # the rungs below restrict `self` with the annotations `assert_that()` overloads are written with
+    _T = TypeVar("_T")
+    _P = TypeVar("_P")
+    from ._typing import (
+        _ArrayAssertion,
+        _BoolAssertion,
+        _BytesAssertion,
+        _CallableAssertion,
+        _CompletedAssertion,
+        _ComplexAssertion,
+        _CoreAssertion,
+        _DateAssertion,
+        _DateTimeAssertion,
+        _DictAssertion,
+        _ExpectedCompletionAssertion,
+        _ExpectedRaiseAssertion,
+        _ExpectedWarningAssertion,
+        _FrameAssertion,
+        _InvokedAssertion,
+        _IterableAssertion,
+        _ListAssertion,
+        _NumericAssertion,
+        _ObjectAssertion,
+        _PathAssertion,
+        _StringAssertion,
+        _TextAssertion,
+        _WarnedAssertion,
+    )
+
+    class _NegatedStringAssertion(Protocol):
+        """The negation twin of `_StringAssertion`."""
+
+        def satisfies(self, matcher: Matcher[str] | Callable[[str], object]) -> _StringAssertion: ...
+        def contains(self, *items: str | Matcher[str]) -> _StringAssertion: ...
+        def is_equal_to_ignoring_case(self, other: str) -> _StringAssertion: ...
+        def is_equal_to_ignoring_whitespace(self, other: str) -> _StringAssertion: ...
+        def contains_ignoring_case(self, *items: str) -> _StringAssertion: ...
+        def starts_with(self, prefix: str) -> _StringAssertion: ...
+        def starts_with_ignoring_case(self, prefix: str) -> _StringAssertion: ...
+        def ends_with(self, suffix: str) -> _StringAssertion: ...
+        def ends_with_ignoring_case(self, suffix: str) -> _StringAssertion: ...
+        def matches(self, pattern: str | re.Pattern[str]) -> _StringAssertion: ...
+        def does_not_match(self, pattern: str | re.Pattern[str]) -> _StringAssertion: ...
+        def is_alpha(self) -> _StringAssertion: ...
+        def is_digit(self) -> _StringAssertion: ...
+        def is_lower(self) -> _StringAssertion: ...
+        def is_upper(self) -> _StringAssertion: ...
+        def is_alphanumeric(self) -> _StringAssertion: ...
+        def is_whitespace(self) -> _StringAssertion: ...
+        def contains_any_of(self, *items: str) -> _StringAssertion: ...
+        def contains_none_of(self, *items: str) -> _StringAssertion: ...
+        def is_unicode(self) -> _StringAssertion: ...
+        def is_greater_than(self, other: str) -> _StringAssertion: ...
+        def is_greater_than_or_equal_to(self, other: str) -> _StringAssertion: ...
+        def is_less_than(self, other: str) -> _StringAssertion: ...
+        def is_less_than_or_equal_to(self, other: str) -> _StringAssertion: ...
+        def does_not_contain(self, *items: str | Matcher[str]) -> _StringAssertion: ...
+        def contains_only(self, *items: str | Matcher[str]) -> _StringAssertion: ...
+        def contains_sequence(self, *items: str | Matcher[str]) -> _StringAssertion: ...
+        def contains_exactly(self, *items: str | Matcher[str]) -> _StringAssertion: ...
+        def contains_exactly_in_any_order(self, *items: str | Matcher[str]) -> _StringAssertion: ...
+        def is_sorted(
+            self, key: Callable[[str], object] = ..., reverse: bool = ..., *, allow_empty: bool = ...
+        ) -> _StringAssertion: ...
+        def each(
+            self, matcher: Matcher[str] | Callable[[str], object], *, allow_empty: bool = ...
+        ) -> _StringAssertion: ...
+        def all_satisfy(
+            self, matcher: Matcher[str] | Callable[[str], object], *, allow_empty: bool = ...
+        ) -> _StringAssertion: ...
+        def any_satisfy(self, matcher: Matcher[str] | Callable[[str], object]) -> _StringAssertion: ...
+        def none_satisfy(self, matcher: Matcher[str] | Callable[[str], object]) -> _StringAssertion: ...
+        def satisfies_exactly(self, *matchers: Matcher[str] | Callable[[str], object]) -> _StringAssertion: ...
+        def satisfies_exactly_in_any_order(
+            self, *matchers: Matcher[str] | Callable[[str], object]
+        ) -> _StringAssertion: ...
+        def zip_satisfies(
+            self, other: Iterable[_Other], predicate: Callable[[str, _Other], object], *, allow_empty: bool = ...
+        ) -> _StringAssertion: ...
+        def extracting_group(self, pattern: str | re.Pattern[str], group: int | str = ...) -> _StringAssertion: ...
+        def matches_with_groups(self, pattern: str | re.Pattern[str]) -> _StringAssertion: ...
+        def exists(self) -> _StringAssertion: ...
+        def does_not_exist(self) -> _StringAssertion: ...
+        def is_file(self) -> _StringAssertion: ...
+        def is_directory(self) -> _StringAssertion: ...
+        def is_named(self, filename: str) -> _StringAssertion: ...
+        def is_child_of(self, parent: object) -> _StringAssertion: ...
+        def is_readable(self) -> _StringAssertion: ...
+        def is_writable(self) -> _StringAssertion: ...
+        def is_executable(self) -> _StringAssertion: ...
+        def is_subset_of(self, *supersets: object, allow_empty: bool = ...) -> _StringAssertion: ...
+        def contains_duplicates(self) -> _StringAssertion: ...
+        def does_not_contain_duplicates(self) -> _StringAssertion: ...
+        def contains_only_once(self, *items: object) -> _StringAssertion: ...
+        def contains_in_order(self, *items: str | Matcher[str]) -> _StringAssertion: ...
+        def has_same_size_as(self, other: Sized) -> _StringAssertion: ...
+        def has_size_greater_than(self, size: SupportsIndex) -> _StringAssertion: ...
+        def has_size_less_than(self, size: SupportsIndex) -> _StringAssertion: ...
+        def has_size_between(self, low: SupportsIndex, high: SupportsIndex) -> _StringAssertion: ...
+        def is_empty(self) -> _StringAssertion: ...
+        def is_not_empty(self) -> _StringAssertion: ...
+        def is_equal_to(
+            self,
+            other: object,
+            *,
+            ignore: _KeySpecs | None = ...,
+            include: _KeySpecs | None = ...,
+            tolerance: float | None = ...,
+            rel: float | None = ...,
+            comparators: dict[Any, Callable[[Any, Any], Any]] | None = ...,
+            ignore_null: bool = ...,
+            strict_types: bool = ...,
+        ) -> _StringAssertion: ...
+        def is_not_equal_to(self, other: object) -> _StringAssertion: ...
+        def is_same_as(self, other: object) -> _StringAssertion: ...
+        def is_not_same_as(self, other: object) -> _StringAssertion: ...
+        def is_true(self) -> _StringAssertion: ...
+        def is_false(self) -> _StringAssertion: ...
+        def is_none(self) -> _StringAssertion: ...
+        def is_not_none(self) -> _StringAssertion: ...
+        def is_type_of(self, some_type: type) -> _StringAssertion: ...
+        def is_instance_of(self, some_class: ClassInfo) -> _StringAssertion: ...
+        def is_instance_of_any(self, *some_classes: ClassInfo) -> _StringAssertion: ...
+        def is_subclass_of(self, some_class: ClassInfo) -> _StringAssertion: ...
+        def is_length(self, length: SupportsIndex | Matcher[int]) -> _StringAssertion: ...
+        def is_length_between(self, low: SupportsIndex, high: SupportsIndex) -> _StringAssertion: ...
+        def is_callable(self) -> _StringAssertion: ...
+        def is_not_callable(self) -> _StringAssertion: ...
+        def is_iterable(self) -> _StringAssertion: ...
+        def is_not_iterable(self) -> _StringAssertion: ...
+        def all_fields_satisfy(
+            self, matcher: Matcher[Any] | Callable[[Any], object], *, allow_empty: bool = ...
+        ) -> _StringAssertion: ...
+        def has_no_none_fields(self, *, allow_empty: bool = ...) -> _StringAssertion: ...
+        def is_in(self, *items: object) -> _StringAssertion: ...
+        def is_not_in(self, *items: object) -> _StringAssertion: ...
+        def snapshot(
+            self,
+            id: str | None = ...,
+            path: str = ...,
+            *,
+            ignore: _KeySpecs | None = ...,
+            include: _KeySpecs | None = ...,
+            tolerance: float | None = ...,
+            rel: float | None = ...,
+            comparators: dict[Any, Callable[[Any, Any], Any]] | None = ...,
+            placeholders: Mapping[Any, Matcher[Any] | Callable[[Any], object]] | None = ...,
+        ) -> _StringAssertion: ...
+        def matches_contract_snapshot(self, id: str | None = ..., path: str = ...) -> _StringAssertion: ...
+        def matches_inline(
+            self,
+            expected: object = ...,
+            *,
+            ignore: _KeySpecs | None = ...,
+            include: _KeySpecs | None = ...,
+            tolerance: float | None = ...,
+            rel: float | None = ...,
+            comparators: dict[Any, Callable[[Any, Any], Any]] | None = ...,
+            placeholders: Mapping[Any, Matcher[Any] | Callable[[Any], object]] | None = ...,
+        ) -> _StringAssertion: ...
+
+    class _NegatedBoolAssertion(Protocol):
+        """The negation twin of `_BoolAssertion`."""
+
+        def is_positive(self) -> _BoolAssertion: ...
+        def is_negative(self) -> _BoolAssertion: ...
+        def is_nan(self) -> _BoolAssertion: ...
+        def is_not_nan(self) -> _BoolAssertion: ...
+        def is_inf(self) -> _BoolAssertion: ...
+        def is_not_inf(self) -> _BoolAssertion: ...
+        def is_not_between(self, low: _Number, high: _Number) -> _BoolAssertion: ...
+        def is_between(self, low: _Number, high: _Number) -> _BoolAssertion: ...
+        def is_greater_than(self, other: _Number) -> _BoolAssertion: ...
+        def is_greater_than_or_equal_to(self, other: _Number) -> _BoolAssertion: ...
+        def is_less_than(self, other: _Number) -> _BoolAssertion: ...
+        def is_less_than_or_equal_to(self, other: _Number) -> _BoolAssertion: ...
+        def is_zero(self) -> _BoolAssertion: ...
+        def is_not_zero(self) -> _BoolAssertion: ...
+        def is_equal_to(
+            self,
+            other: object,
+            *,
+            ignore: _KeySpecs | None = ...,
+            include: _KeySpecs | None = ...,
+            tolerance: float | None = ...,
+            rel: float | None = ...,
+            comparators: dict[Any, Callable[[Any, Any], Any]] | None = ...,
+            ignore_null: bool = ...,
+            strict_types: bool = ...,
+        ) -> _BoolAssertion: ...
+        def is_not_equal_to(self, other: object) -> _BoolAssertion: ...
+        def is_same_as(self, other: object) -> _BoolAssertion: ...
+        def is_not_same_as(self, other: object) -> _BoolAssertion: ...
+        def is_true(self) -> _BoolAssertion: ...
+        def is_false(self) -> _BoolAssertion: ...
+        def is_none(self) -> _BoolAssertion: ...
+        def is_not_none(self) -> _BoolAssertion: ...
+        def is_type_of(self, some_type: type) -> _BoolAssertion: ...
+        def is_instance_of(self, some_class: ClassInfo) -> _BoolAssertion: ...
+        def is_instance_of_any(self, *some_classes: ClassInfo) -> _BoolAssertion: ...
+        def is_subclass_of(self, some_class: ClassInfo) -> _BoolAssertion: ...
+        def is_length(self, length: SupportsIndex | Matcher[int]) -> _BoolAssertion: ...
+        def is_length_between(self, low: SupportsIndex, high: SupportsIndex) -> _BoolAssertion: ...
+        def is_callable(self) -> _BoolAssertion: ...
+        def is_not_callable(self) -> _BoolAssertion: ...
+        def is_iterable(self) -> _BoolAssertion: ...
+        def is_not_iterable(self) -> _BoolAssertion: ...
+        def satisfies(self, matcher: Matcher[Any] | Callable[[Any], object]) -> _BoolAssertion: ...
+        def all_fields_satisfy(
+            self, matcher: Matcher[Any] | Callable[[Any], object], *, allow_empty: bool = ...
+        ) -> _BoolAssertion: ...
+        def has_no_none_fields(self, *, allow_empty: bool = ...) -> _BoolAssertion: ...
+        def is_in(self, *items: object) -> _BoolAssertion: ...
+        def is_not_in(self, *items: object) -> _BoolAssertion: ...
+        def snapshot(
+            self,
+            id: str | None = ...,
+            path: str = ...,
+            *,
+            ignore: _KeySpecs | None = ...,
+            include: _KeySpecs | None = ...,
+            tolerance: float | None = ...,
+            rel: float | None = ...,
+            comparators: dict[Any, Callable[[Any, Any], Any]] | None = ...,
+            placeholders: Mapping[Any, Matcher[Any] | Callable[[Any], object]] | None = ...,
+        ) -> _BoolAssertion: ...
+        def matches_contract_snapshot(self, id: str | None = ..., path: str = ...) -> _BoolAssertion: ...
+        def matches_inline(
+            self,
+            expected: object = ...,
+            *,
+            ignore: _KeySpecs | None = ...,
+            include: _KeySpecs | None = ...,
+            tolerance: float | None = ...,
+            rel: float | None = ...,
+            comparators: dict[Any, Callable[[Any, Any], Any]] | None = ...,
+            placeholders: Mapping[Any, Matcher[Any] | Callable[[Any], object]] | None = ...,
+        ) -> _BoolAssertion: ...
+
+    class _NegatedNumericAssertion(Protocol[_N]):
+        """The negation twin of `_NumericAssertion`."""
+
+        def is_close_to(
+            self, other: _Number, tolerance: _Number | None = ..., *, rel: _Number | None = ...
+        ) -> _NumericAssertion[_N]: ...
+        def is_not_close_to(
+            self, other: _Number, tolerance: _Number | None = ..., *, rel: _Number | None = ...
+        ) -> _NumericAssertion[_N]: ...
+        def satisfies(self, matcher: Matcher[_N] | Callable[[_N], object]) -> _NumericAssertion[_N]: ...
+        def is_even(self) -> _NumericAssertion[_N]: ...
+        def is_odd(self) -> _NumericAssertion[_N]: ...
+        def is_divisible_by(self, divisor: SupportsIndex) -> _NumericAssertion[_N]: ...
+        def is_positive(self) -> _NumericAssertion[_N]: ...
+        def is_negative(self) -> _NumericAssertion[_N]: ...
+        def is_nan(self) -> _NumericAssertion[_N]: ...
+        def is_not_nan(self) -> _NumericAssertion[_N]: ...
+        def is_inf(self) -> _NumericAssertion[_N]: ...
+        def is_not_inf(self) -> _NumericAssertion[_N]: ...
+        def is_not_between(self, low: _Number, high: _Number) -> _NumericAssertion[_N]: ...
+        def is_between(self, low: _Number, high: _Number) -> _NumericAssertion[_N]: ...
+        def is_greater_than(self, other: _Number) -> _NumericAssertion[_N]: ...
+        def is_greater_than_or_equal_to(self, other: _Number) -> _NumericAssertion[_N]: ...
+        def is_less_than(self, other: _Number) -> _NumericAssertion[_N]: ...
+        def is_less_than_or_equal_to(self, other: _Number) -> _NumericAssertion[_N]: ...
+        def is_zero(self) -> _NumericAssertion[_N]: ...
+        def is_not_zero(self) -> _NumericAssertion[_N]: ...
+        def is_equal_to(
+            self,
+            other: object,
+            *,
+            ignore: _KeySpecs | None = ...,
+            include: _KeySpecs | None = ...,
+            tolerance: float | None = ...,
+            rel: float | None = ...,
+            comparators: dict[Any, Callable[[Any, Any], Any]] | None = ...,
+            ignore_null: bool = ...,
+            strict_types: bool = ...,
+        ) -> _NumericAssertion[_N]: ...
+        def is_not_equal_to(self, other: object) -> _NumericAssertion[_N]: ...
+        def is_same_as(self, other: object) -> _NumericAssertion[_N]: ...
+        def is_not_same_as(self, other: object) -> _NumericAssertion[_N]: ...
+        def is_true(self) -> _NumericAssertion[_N]: ...
+        def is_false(self) -> _NumericAssertion[_N]: ...
+        def is_none(self) -> _NumericAssertion[_N]: ...
+        def is_not_none(self) -> _NumericAssertion[_N]: ...
+        def is_type_of(self, some_type: type) -> _NumericAssertion[_N]: ...
+        def is_instance_of(self, some_class: ClassInfo) -> _NumericAssertion[_N]: ...
+        def is_instance_of_any(self, *some_classes: ClassInfo) -> _NumericAssertion[_N]: ...
+        def is_subclass_of(self, some_class: ClassInfo) -> _NumericAssertion[_N]: ...
+        def is_length(self, length: SupportsIndex | Matcher[int]) -> _NumericAssertion[_N]: ...
+        def is_length_between(self, low: SupportsIndex, high: SupportsIndex) -> _NumericAssertion[_N]: ...
+        def is_callable(self) -> _NumericAssertion[_N]: ...
+        def is_not_callable(self) -> _NumericAssertion[_N]: ...
+        def is_iterable(self) -> _NumericAssertion[_N]: ...
+        def is_not_iterable(self) -> _NumericAssertion[_N]: ...
+        def all_fields_satisfy(
+            self, matcher: Matcher[Any] | Callable[[Any], object], *, allow_empty: bool = ...
+        ) -> _NumericAssertion[_N]: ...
+        def has_no_none_fields(self, *, allow_empty: bool = ...) -> _NumericAssertion[_N]: ...
+        def is_in(self, *items: object) -> _NumericAssertion[_N]: ...
+        def is_not_in(self, *items: object) -> _NumericAssertion[_N]: ...
+        def snapshot(
+            self,
+            id: str | None = ...,
+            path: str = ...,
+            *,
+            ignore: _KeySpecs | None = ...,
+            include: _KeySpecs | None = ...,
+            tolerance: float | None = ...,
+            rel: float | None = ...,
+            comparators: dict[Any, Callable[[Any, Any], Any]] | None = ...,
+            placeholders: Mapping[Any, Matcher[Any] | Callable[[Any], object]] | None = ...,
+        ) -> _NumericAssertion[_N]: ...
+        def matches_contract_snapshot(self, id: str | None = ..., path: str = ...) -> _NumericAssertion[_N]: ...
+        def matches_inline(
+            self,
+            expected: object = ...,
+            *,
+            ignore: _KeySpecs | None = ...,
+            include: _KeySpecs | None = ...,
+            tolerance: float | None = ...,
+            rel: float | None = ...,
+            comparators: dict[Any, Callable[[Any, Any], Any]] | None = ...,
+            placeholders: Mapping[Any, Matcher[Any] | Callable[[Any], object]] | None = ...,
+        ) -> _NumericAssertion[_N]: ...
+
+    class _NegatedComplexAssertion(Protocol):
+        """The negation twin of `_ComplexAssertion`."""
+
+        def is_zero(self) -> _ComplexAssertion: ...
+        def is_not_zero(self) -> _ComplexAssertion: ...
+        def is_equal_to(
+            self,
+            other: object,
+            *,
+            ignore: _KeySpecs | None = ...,
+            include: _KeySpecs | None = ...,
+            tolerance: float | None = ...,
+            rel: float | None = ...,
+            comparators: dict[Any, Callable[[Any, Any], Any]] | None = ...,
+            ignore_null: bool = ...,
+            strict_types: bool = ...,
+        ) -> _ComplexAssertion: ...
+        def is_not_equal_to(self, other: object) -> _ComplexAssertion: ...
+        def is_same_as(self, other: object) -> _ComplexAssertion: ...
+        def is_not_same_as(self, other: object) -> _ComplexAssertion: ...
+        def is_true(self) -> _ComplexAssertion: ...
+        def is_false(self) -> _ComplexAssertion: ...
+        def is_none(self) -> _ComplexAssertion: ...
+        def is_not_none(self) -> _ComplexAssertion: ...
+        def is_type_of(self, some_type: type) -> _ComplexAssertion: ...
+        def is_instance_of(self, some_class: ClassInfo) -> _ComplexAssertion: ...
+        def is_instance_of_any(self, *some_classes: ClassInfo) -> _ComplexAssertion: ...
+        def is_subclass_of(self, some_class: ClassInfo) -> _ComplexAssertion: ...
+        def is_length(self, length: SupportsIndex | Matcher[int]) -> _ComplexAssertion: ...
+        def is_length_between(self, low: SupportsIndex, high: SupportsIndex) -> _ComplexAssertion: ...
+        def is_callable(self) -> _ComplexAssertion: ...
+        def is_not_callable(self) -> _ComplexAssertion: ...
+        def is_iterable(self) -> _ComplexAssertion: ...
+        def is_not_iterable(self) -> _ComplexAssertion: ...
+        def satisfies(self, matcher: Matcher[Any] | Callable[[Any], object]) -> _ComplexAssertion: ...
+        def all_fields_satisfy(
+            self, matcher: Matcher[Any] | Callable[[Any], object], *, allow_empty: bool = ...
+        ) -> _ComplexAssertion: ...
+        def has_no_none_fields(self, *, allow_empty: bool = ...) -> _ComplexAssertion: ...
+        def is_in(self, *items: object) -> _ComplexAssertion: ...
+        def is_not_in(self, *items: object) -> _ComplexAssertion: ...
+        def snapshot(
+            self,
+            id: str | None = ...,
+            path: str = ...,
+            *,
+            ignore: _KeySpecs | None = ...,
+            include: _KeySpecs | None = ...,
+            tolerance: float | None = ...,
+            rel: float | None = ...,
+            comparators: dict[Any, Callable[[Any, Any], Any]] | None = ...,
+            placeholders: Mapping[Any, Matcher[Any] | Callable[[Any], object]] | None = ...,
+        ) -> _ComplexAssertion: ...
+        def matches_contract_snapshot(self, id: str | None = ..., path: str = ...) -> _ComplexAssertion: ...
+        def matches_inline(
+            self,
+            expected: object = ...,
+            *,
+            ignore: _KeySpecs | None = ...,
+            include: _KeySpecs | None = ...,
+            tolerance: float | None = ...,
+            rel: float | None = ...,
+            comparators: dict[Any, Callable[[Any, Any], Any]] | None = ...,
+            placeholders: Mapping[Any, Matcher[Any] | Callable[[Any], object]] | None = ...,
+        ) -> _ComplexAssertion: ...
+
+    class _NegatedDictAssertion(Protocol[_K, _V]):
+        """The negation twin of `_DictAssertion`."""
+
+        def is_subset_of(
+            self, *supersets: Mapping[Any, Any] | MappingLike, allow_empty: bool = ...
+        ) -> _DictAssertion[_K, _V]: ...
+        def contains(self, *items: object) -> _DictAssertion[_K, _V]: ...
+        def each(
+            self, matcher: Matcher[_K] | Callable[[_K], object], *, allow_empty: bool = ...
+        ) -> _DictAssertion[_K, _V]: ...
+        def all_satisfy(
+            self, matcher: Matcher[_K] | Callable[[_K], object], *, allow_empty: bool = ...
+        ) -> _DictAssertion[_K, _V]: ...
+        def contains_key(self, *keys: _K | Matcher[_K]) -> _DictAssertion[_K, _V]: ...
+        def does_not_contain_key(self, *keys: _K | Matcher[_K]) -> _DictAssertion[_K, _V]: ...
+        def contains_value(self, *values: _V | Matcher[_V]) -> _DictAssertion[_K, _V]: ...
+        def does_not_contain_value(self, *values: _V | Matcher[_V]) -> _DictAssertion[_K, _V]: ...
+        def contains_entry(self, *args: object, **kwargs: object) -> _DictAssertion[_K, _V]: ...
+        def does_not_contain_entry(self, *args: object, **kwargs: object) -> _DictAssertion[_K, _V]: ...
+        def does_not_contain(self, *items: object) -> _DictAssertion[_K, _V]: ...
+        def contains_only(self, *keys: object) -> _DictAssertion[_K, _V]: ...
+        def is_sorted(
+            self, key: Callable[[_K], object] = ..., reverse: bool = ..., *, allow_empty: bool = ...
+        ) -> _DictAssertion[_K, _V]: ...
+        def matches_structure(self, spec: dict[Any, Any]) -> _DictAssertion[_K, _V]: ...
+        def has_same_size_as(self, other: Sized) -> _DictAssertion[_K, _V]: ...
+        def has_size_greater_than(self, size: SupportsIndex) -> _DictAssertion[_K, _V]: ...
+        def has_size_less_than(self, size: SupportsIndex) -> _DictAssertion[_K, _V]: ...
+        def has_size_between(self, low: SupportsIndex, high: SupportsIndex) -> _DictAssertion[_K, _V]: ...
+        def is_empty(self) -> _DictAssertion[_K, _V]: ...
+        def is_not_empty(self) -> _DictAssertion[_K, _V]: ...
+        def is_equal_to(
+            self,
+            other: object,
+            *,
+            ignore: _KeySpecs | None = ...,
+            include: _KeySpecs | None = ...,
+            tolerance: float | None = ...,
+            rel: float | None = ...,
+            comparators: dict[Any, Callable[[Any, Any], Any]] | None = ...,
+            ignore_null: bool = ...,
+            strict_types: bool = ...,
+        ) -> _DictAssertion[_K, _V]: ...
+        def is_not_equal_to(self, other: object) -> _DictAssertion[_K, _V]: ...
+        def is_same_as(self, other: object) -> _DictAssertion[_K, _V]: ...
+        def is_not_same_as(self, other: object) -> _DictAssertion[_K, _V]: ...
+        def is_true(self) -> _DictAssertion[_K, _V]: ...
+        def is_false(self) -> _DictAssertion[_K, _V]: ...
+        def is_none(self) -> _DictAssertion[_K, _V]: ...
+        def is_not_none(self) -> _DictAssertion[_K, _V]: ...
+        def is_type_of(self, some_type: type) -> _DictAssertion[_K, _V]: ...
+        def is_instance_of(self, some_class: ClassInfo) -> _DictAssertion[_K, _V]: ...
+        def is_instance_of_any(self, *some_classes: ClassInfo) -> _DictAssertion[_K, _V]: ...
+        def is_subclass_of(self, some_class: ClassInfo) -> _DictAssertion[_K, _V]: ...
+        def is_length(self, length: SupportsIndex | Matcher[int]) -> _DictAssertion[_K, _V]: ...
+        def is_length_between(self, low: SupportsIndex, high: SupportsIndex) -> _DictAssertion[_K, _V]: ...
+        def is_callable(self) -> _DictAssertion[_K, _V]: ...
+        def is_not_callable(self) -> _DictAssertion[_K, _V]: ...
+        def is_iterable(self) -> _DictAssertion[_K, _V]: ...
+        def is_not_iterable(self) -> _DictAssertion[_K, _V]: ...
+        def satisfies(self, matcher: Matcher[Any] | Callable[[Any], object]) -> _DictAssertion[_K, _V]: ...
+        def all_fields_satisfy(
+            self, matcher: Matcher[Any] | Callable[[Any], object], *, allow_empty: bool = ...
+        ) -> _DictAssertion[_K, _V]: ...
+        def has_no_none_fields(self, *, allow_empty: bool = ...) -> _DictAssertion[_K, _V]: ...
+        def is_in(self, *items: object) -> _DictAssertion[_K, _V]: ...
+        def is_not_in(self, *items: object) -> _DictAssertion[_K, _V]: ...
+        def snapshot(
+            self,
+            id: str | None = ...,
+            path: str = ...,
+            *,
+            ignore: _KeySpecs | None = ...,
+            include: _KeySpecs | None = ...,
+            tolerance: float | None = ...,
+            rel: float | None = ...,
+            comparators: dict[Any, Callable[[Any, Any], Any]] | None = ...,
+            placeholders: Mapping[Any, Matcher[Any] | Callable[[Any], object]] | None = ...,
+        ) -> _DictAssertion[_K, _V]: ...
+        def matches_contract_snapshot(self, id: str | None = ..., path: str = ...) -> _DictAssertion[_K, _V]: ...
+        def matches_inline(
+            self,
+            expected: object = ...,
+            *,
+            ignore: _KeySpecs | None = ...,
+            include: _KeySpecs | None = ...,
+            tolerance: float | None = ...,
+            rel: float | None = ...,
+            comparators: dict[Any, Callable[[Any, Any], Any]] | None = ...,
+            placeholders: Mapping[Any, Matcher[Any] | Callable[[Any], object]] | None = ...,
+        ) -> _DictAssertion[_K, _V]: ...
+        def has_json_path(self, path: str) -> _DictAssertion[_K, _V]: ...
+        def does_not_have_json_path(self, path: str) -> _DictAssertion[_K, _V]: ...
+        def matches_json_schema(self, schema: dict[str, Any]) -> _DictAssertion[_K, _V]: ...
+        def matches_json_schema_from_file(self, path: str | Path) -> _DictAssertion[_K, _V]: ...
+        def conforms_to_openapi(
+            self,
+            spec: dict[str, Any],
+            path: str,
+            method: str,
+            *,
+            status: str | int | None = ...,
+            content_type: str = ...,
+            strict_nullable: bool = ...,
+        ) -> _DictAssertion[_K, _V]: ...
+
+    class _NegatedIterableAssertion(Protocol[_E]):
+        """The negation twin of `_IterableAssertion`."""
+
+        def contains(self, *items: _E | Matcher[_E]) -> _IterableAssertion[_E]: ...
+        def does_not_contain(self, *items: _E | Matcher[_E]) -> _IterableAssertion[_E]: ...
+        def contains_only(self, *items: _E | Matcher[_E]) -> _IterableAssertion[_E]: ...
+        def contains_sequence(self, *items: _E | Matcher[_E]) -> _IterableAssertion[_E]: ...
+        def contains_exactly(self, *items: _E | Matcher[_E]) -> _IterableAssertion[_E]: ...
+        def contains_exactly_in_any_order(self, *items: _E | Matcher[_E]) -> _IterableAssertion[_E]: ...
+        def is_sorted(
+            self, key: Callable[[_E], object] = ..., reverse: bool = ..., *, allow_empty: bool = ...
+        ) -> _IterableAssertion[_E]: ...
+        def starts_with(self, prefix: _E) -> _IterableAssertion[_E]: ...
+        def ends_with(self, suffix: _E) -> _IterableAssertion[_E]: ...
+        def each(
+            self, matcher: Matcher[_E] | Callable[[_E], object], *, allow_empty: bool = ...
+        ) -> _IterableAssertion[_E]: ...
+        def all_satisfy(
+            self, matcher: Matcher[_E] | Callable[[_E], object], *, allow_empty: bool = ...
+        ) -> _IterableAssertion[_E]: ...
+        def any_satisfy(self, matcher: Matcher[_E] | Callable[[_E], object]) -> _IterableAssertion[_E]: ...
+        def none_satisfy(self, matcher: Matcher[_E] | Callable[[_E], object]) -> _IterableAssertion[_E]: ...
+        def satisfies_exactly(self, *matchers: Matcher[_E] | Callable[[_E], object]) -> _IterableAssertion[_E]: ...
+        def satisfies_exactly_in_any_order(
+            self, *matchers: Matcher[_E] | Callable[[_E], object]
+        ) -> _IterableAssertion[_E]: ...
+        def zip_satisfies(
+            self, other: Iterable[_Other], predicate: Callable[[_E, _Other], object], *, allow_empty: bool = ...
+        ) -> _IterableAssertion[_E]: ...
+        def is_subset_of(self, *supersets: object, allow_empty: bool = ...) -> _IterableAssertion[_E]: ...
+        def contains_duplicates(self) -> _IterableAssertion[_E]: ...
+        def does_not_contain_duplicates(self) -> _IterableAssertion[_E]: ...
+        def contains_only_once(self, *items: object) -> _IterableAssertion[_E]: ...
+        def contains_in_order(self, *items: _E | Matcher[_E]) -> _IterableAssertion[_E]: ...
+        def has_same_size_as(self, other: Sized) -> _IterableAssertion[_E]: ...
+        def has_size_greater_than(self, size: SupportsIndex) -> _IterableAssertion[_E]: ...
+        def has_size_less_than(self, size: SupportsIndex) -> _IterableAssertion[_E]: ...
+        def has_size_between(self, low: SupportsIndex, high: SupportsIndex) -> _IterableAssertion[_E]: ...
+        def is_empty(self) -> _IterableAssertion[_E]: ...
+        def is_not_empty(self) -> _IterableAssertion[_E]: ...
+        def is_equal_to(
+            self,
+            other: object,
+            *,
+            ignore: _KeySpecs | None = ...,
+            include: _KeySpecs | None = ...,
+            tolerance: float | None = ...,
+            rel: float | None = ...,
+            comparators: dict[Any, Callable[[Any, Any], Any]] | None = ...,
+            ignore_null: bool = ...,
+            strict_types: bool = ...,
+        ) -> _IterableAssertion[_E]: ...
+        def is_not_equal_to(self, other: object) -> _IterableAssertion[_E]: ...
+        def is_same_as(self, other: object) -> _IterableAssertion[_E]: ...
+        def is_not_same_as(self, other: object) -> _IterableAssertion[_E]: ...
+        def is_true(self) -> _IterableAssertion[_E]: ...
+        def is_false(self) -> _IterableAssertion[_E]: ...
+        def is_none(self) -> _IterableAssertion[_E]: ...
+        def is_not_none(self) -> _IterableAssertion[_E]: ...
+        def is_type_of(self, some_type: type) -> _IterableAssertion[_E]: ...
+        def is_instance_of(self, some_class: ClassInfo) -> _IterableAssertion[_E]: ...
+        def is_instance_of_any(self, *some_classes: ClassInfo) -> _IterableAssertion[_E]: ...
+        def is_subclass_of(self, some_class: ClassInfo) -> _IterableAssertion[_E]: ...
+        def is_length(self, length: SupportsIndex | Matcher[int]) -> _IterableAssertion[_E]: ...
+        def is_length_between(self, low: SupportsIndex, high: SupportsIndex) -> _IterableAssertion[_E]: ...
+        def is_callable(self) -> _IterableAssertion[_E]: ...
+        def is_not_callable(self) -> _IterableAssertion[_E]: ...
+        def is_iterable(self) -> _IterableAssertion[_E]: ...
+        def is_not_iterable(self) -> _IterableAssertion[_E]: ...
+        def satisfies(self, matcher: Matcher[Any] | Callable[[Any], object]) -> _IterableAssertion[_E]: ...
+        def all_fields_satisfy(
+            self, matcher: Matcher[Any] | Callable[[Any], object], *, allow_empty: bool = ...
+        ) -> _IterableAssertion[_E]: ...
+        def has_no_none_fields(self, *, allow_empty: bool = ...) -> _IterableAssertion[_E]: ...
+        def is_in(self, *items: object) -> _IterableAssertion[_E]: ...
+        def is_not_in(self, *items: object) -> _IterableAssertion[_E]: ...
+        def snapshot(
+            self,
+            id: str | None = ...,
+            path: str = ...,
+            *,
+            ignore: _KeySpecs | None = ...,
+            include: _KeySpecs | None = ...,
+            tolerance: float | None = ...,
+            rel: float | None = ...,
+            comparators: dict[Any, Callable[[Any, Any], Any]] | None = ...,
+            placeholders: Mapping[Any, Matcher[Any] | Callable[[Any], object]] | None = ...,
+        ) -> _IterableAssertion[_E]: ...
+        def matches_contract_snapshot(self, id: str | None = ..., path: str = ...) -> _IterableAssertion[_E]: ...
+        def matches_inline(
+            self,
+            expected: object = ...,
+            *,
+            ignore: _KeySpecs | None = ...,
+            include: _KeySpecs | None = ...,
+            tolerance: float | None = ...,
+            rel: float | None = ...,
+            comparators: dict[Any, Callable[[Any, Any], Any]] | None = ...,
+            placeholders: Mapping[Any, Matcher[Any] | Callable[[Any], object]] | None = ...,
+        ) -> _IterableAssertion[_E]: ...
+        def has_json_path(self, path: str) -> _IterableAssertion[_E]: ...
+        def does_not_have_json_path(self, path: str) -> _IterableAssertion[_E]: ...
+        def matches_json_schema(self, schema: dict[str, Any]) -> _IterableAssertion[_E]: ...
+        def matches_json_schema_from_file(self, path: str | Path) -> _IterableAssertion[_E]: ...
+        def conforms_to_openapi(
+            self,
+            spec: dict[str, Any],
+            path: str,
+            method: str,
+            *,
+            status: str | int | None = ...,
+            content_type: str = ...,
+            strict_nullable: bool = ...,
+        ) -> _IterableAssertion[_E]: ...
+
+    class _NegatedDateTimeAssertion(Protocol):
+        """The negation twin of `_DateTimeAssertion`."""
+
+        def is_greater_than(self, other: datetime.datetime) -> _DateTimeAssertion: ...
+        def is_greater_than_or_equal_to(self, other: datetime.datetime) -> _DateTimeAssertion: ...
+        def is_less_than(self, other: datetime.datetime) -> _DateTimeAssertion: ...
+        def is_less_than_or_equal_to(self, other: datetime.datetime) -> _DateTimeAssertion: ...
+        def is_between(self, low: datetime.datetime, high: datetime.datetime) -> _DateTimeAssertion: ...
+        def is_not_between(self, low: datetime.datetime, high: datetime.datetime) -> _DateTimeAssertion: ...
+        def is_before(self, other: datetime.datetime) -> _DateTimeAssertion: ...
+        def is_after(self, other: datetime.datetime) -> _DateTimeAssertion: ...
+        def is_before_or_equal_to(self, other: datetime.datetime) -> _DateTimeAssertion: ...
+        def is_after_or_equal_to(self, other: datetime.datetime) -> _DateTimeAssertion: ...
+        def is_equal_to_ignoring_milliseconds(self, other: datetime.datetime) -> _DateTimeAssertion: ...
+        def is_equal_to_ignoring_seconds(self, other: datetime.datetime) -> _DateTimeAssertion: ...
+        def is_equal_to_ignoring_time(self, other: datetime.datetime) -> _DateTimeAssertion: ...
+        def is_close_to(
+            self, other: datetime.datetime, tolerance: datetime.timedelta | None = ..., *, rel: None = ...
+        ) -> _DateTimeAssertion: ...
+        def is_not_close_to(
+            self, other: datetime.datetime, tolerance: datetime.timedelta | None = ..., *, rel: None = ...
+        ) -> _DateTimeAssertion: ...
+        def is_equal_to(
+            self,
+            other: object,
+            *,
+            ignore: _KeySpecs | None = ...,
+            include: _KeySpecs | None = ...,
+            tolerance: float | None = ...,
+            rel: float | None = ...,
+            comparators: dict[Any, Callable[[Any, Any], Any]] | None = ...,
+            ignore_null: bool = ...,
+            strict_types: bool = ...,
+        ) -> _DateTimeAssertion: ...
+        def is_not_equal_to(self, other: object) -> _DateTimeAssertion: ...
+        def is_same_as(self, other: object) -> _DateTimeAssertion: ...
+        def is_not_same_as(self, other: object) -> _DateTimeAssertion: ...
+        def is_true(self) -> _DateTimeAssertion: ...
+        def is_false(self) -> _DateTimeAssertion: ...
+        def is_none(self) -> _DateTimeAssertion: ...
+        def is_not_none(self) -> _DateTimeAssertion: ...
+        def is_type_of(self, some_type: type) -> _DateTimeAssertion: ...
+        def is_instance_of(self, some_class: ClassInfo) -> _DateTimeAssertion: ...
+        def is_instance_of_any(self, *some_classes: ClassInfo) -> _DateTimeAssertion: ...
+        def is_subclass_of(self, some_class: ClassInfo) -> _DateTimeAssertion: ...
+        def is_length(self, length: SupportsIndex | Matcher[int]) -> _DateTimeAssertion: ...
+        def is_length_between(self, low: SupportsIndex, high: SupportsIndex) -> _DateTimeAssertion: ...
+        def is_callable(self) -> _DateTimeAssertion: ...
+        def is_not_callable(self) -> _DateTimeAssertion: ...
+        def is_iterable(self) -> _DateTimeAssertion: ...
+        def is_not_iterable(self) -> _DateTimeAssertion: ...
+        def satisfies(self, matcher: Matcher[Any] | Callable[[Any], object]) -> _DateTimeAssertion: ...
+        def all_fields_satisfy(
+            self, matcher: Matcher[Any] | Callable[[Any], object], *, allow_empty: bool = ...
+        ) -> _DateTimeAssertion: ...
+        def has_no_none_fields(self, *, allow_empty: bool = ...) -> _DateTimeAssertion: ...
+        def is_in(self, *items: object) -> _DateTimeAssertion: ...
+        def is_not_in(self, *items: object) -> _DateTimeAssertion: ...
+        def snapshot(
+            self,
+            id: str | None = ...,
+            path: str = ...,
+            *,
+            ignore: _KeySpecs | None = ...,
+            include: _KeySpecs | None = ...,
+            tolerance: float | None = ...,
+            rel: float | None = ...,
+            comparators: dict[Any, Callable[[Any, Any], Any]] | None = ...,
+            placeholders: Mapping[Any, Matcher[Any] | Callable[[Any], object]] | None = ...,
+        ) -> _DateTimeAssertion: ...
+        def matches_contract_snapshot(self, id: str | None = ..., path: str = ...) -> _DateTimeAssertion: ...
+        def matches_inline(
+            self,
+            expected: object = ...,
+            *,
+            ignore: _KeySpecs | None = ...,
+            include: _KeySpecs | None = ...,
+            tolerance: float | None = ...,
+            rel: float | None = ...,
+            comparators: dict[Any, Callable[[Any, Any], Any]] | None = ...,
+            placeholders: Mapping[Any, Matcher[Any] | Callable[[Any], object]] | None = ...,
+        ) -> _DateTimeAssertion: ...
+
+    class _NegatedDateAssertion(Protocol):
+        """The negation twin of `_DateAssertion`."""
+
+        def is_greater_than(self, other: datetime.date) -> _DateAssertion: ...
+        def is_greater_than_or_equal_to(self, other: datetime.date) -> _DateAssertion: ...
+        def is_less_than(self, other: datetime.date) -> _DateAssertion: ...
+        def is_less_than_or_equal_to(self, other: datetime.date) -> _DateAssertion: ...
+        def is_between(self, low: datetime.date, high: datetime.date) -> _DateAssertion: ...
+        def is_not_between(self, low: datetime.date, high: datetime.date) -> _DateAssertion: ...
+        def is_equal_to(
+            self,
+            other: object,
+            *,
+            ignore: _KeySpecs | None = ...,
+            include: _KeySpecs | None = ...,
+            tolerance: float | None = ...,
+            rel: float | None = ...,
+            comparators: dict[Any, Callable[[Any, Any], Any]] | None = ...,
+            ignore_null: bool = ...,
+            strict_types: bool = ...,
+        ) -> _DateAssertion: ...
+        def is_not_equal_to(self, other: object) -> _DateAssertion: ...
+        def is_same_as(self, other: object) -> _DateAssertion: ...
+        def is_not_same_as(self, other: object) -> _DateAssertion: ...
+        def is_true(self) -> _DateAssertion: ...
+        def is_false(self) -> _DateAssertion: ...
+        def is_none(self) -> _DateAssertion: ...
+        def is_not_none(self) -> _DateAssertion: ...
+        def is_type_of(self, some_type: type) -> _DateAssertion: ...
+        def is_instance_of(self, some_class: ClassInfo) -> _DateAssertion: ...
+        def is_instance_of_any(self, *some_classes: ClassInfo) -> _DateAssertion: ...
+        def is_subclass_of(self, some_class: ClassInfo) -> _DateAssertion: ...
+        def is_length(self, length: SupportsIndex | Matcher[int]) -> _DateAssertion: ...
+        def is_length_between(self, low: SupportsIndex, high: SupportsIndex) -> _DateAssertion: ...
+        def is_callable(self) -> _DateAssertion: ...
+        def is_not_callable(self) -> _DateAssertion: ...
+        def is_iterable(self) -> _DateAssertion: ...
+        def is_not_iterable(self) -> _DateAssertion: ...
+        def satisfies(self, matcher: Matcher[Any] | Callable[[Any], object]) -> _DateAssertion: ...
+        def all_fields_satisfy(
+            self, matcher: Matcher[Any] | Callable[[Any], object], *, allow_empty: bool = ...
+        ) -> _DateAssertion: ...
+        def has_no_none_fields(self, *, allow_empty: bool = ...) -> _DateAssertion: ...
+        def is_in(self, *items: object) -> _DateAssertion: ...
+        def is_not_in(self, *items: object) -> _DateAssertion: ...
+        def snapshot(
+            self,
+            id: str | None = ...,
+            path: str = ...,
+            *,
+            ignore: _KeySpecs | None = ...,
+            include: _KeySpecs | None = ...,
+            tolerance: float | None = ...,
+            rel: float | None = ...,
+            comparators: dict[Any, Callable[[Any, Any], Any]] | None = ...,
+            placeholders: Mapping[Any, Matcher[Any] | Callable[[Any], object]] | None = ...,
+        ) -> _DateAssertion: ...
+        def matches_contract_snapshot(self, id: str | None = ..., path: str = ...) -> _DateAssertion: ...
+        def matches_inline(
+            self,
+            expected: object = ...,
+            *,
+            ignore: _KeySpecs | None = ...,
+            include: _KeySpecs | None = ...,
+            tolerance: float | None = ...,
+            rel: float | None = ...,
+            comparators: dict[Any, Callable[[Any, Any], Any]] | None = ...,
+            placeholders: Mapping[Any, Matcher[Any] | Callable[[Any], object]] | None = ...,
+        ) -> _DateAssertion: ...
+
+    class _NegatedPathAssertion(Protocol):
+        """The negation twin of `_PathAssertion`."""
+
+        def exists(self) -> _PathAssertion: ...
+        def does_not_exist(self) -> _PathAssertion: ...
+        def is_file(self) -> _PathAssertion: ...
+        def is_directory(self) -> _PathAssertion: ...
+        def is_named(self, filename: str) -> _PathAssertion: ...
+        def is_child_of(self, parent: object) -> _PathAssertion: ...
+        def is_readable(self) -> _PathAssertion: ...
+        def is_writable(self) -> _PathAssertion: ...
+        def is_executable(self) -> _PathAssertion: ...
+        def is_equal_to(
+            self,
+            other: object,
+            *,
+            ignore: _KeySpecs | None = ...,
+            include: _KeySpecs | None = ...,
+            tolerance: float | None = ...,
+            rel: float | None = ...,
+            comparators: dict[Any, Callable[[Any, Any], Any]] | None = ...,
+            ignore_null: bool = ...,
+            strict_types: bool = ...,
+        ) -> _PathAssertion: ...
+        def is_not_equal_to(self, other: object) -> _PathAssertion: ...
+        def is_same_as(self, other: object) -> _PathAssertion: ...
+        def is_not_same_as(self, other: object) -> _PathAssertion: ...
+        def is_true(self) -> _PathAssertion: ...
+        def is_false(self) -> _PathAssertion: ...
+        def is_none(self) -> _PathAssertion: ...
+        def is_not_none(self) -> _PathAssertion: ...
+        def is_type_of(self, some_type: type) -> _PathAssertion: ...
+        def is_instance_of(self, some_class: ClassInfo) -> _PathAssertion: ...
+        def is_instance_of_any(self, *some_classes: ClassInfo) -> _PathAssertion: ...
+        def is_subclass_of(self, some_class: ClassInfo) -> _PathAssertion: ...
+        def is_length(self, length: SupportsIndex | Matcher[int]) -> _PathAssertion: ...
+        def is_length_between(self, low: SupportsIndex, high: SupportsIndex) -> _PathAssertion: ...
+        def is_callable(self) -> _PathAssertion: ...
+        def is_not_callable(self) -> _PathAssertion: ...
+        def is_iterable(self) -> _PathAssertion: ...
+        def is_not_iterable(self) -> _PathAssertion: ...
+        def satisfies(self, matcher: Matcher[Any] | Callable[[Any], object]) -> _PathAssertion: ...
+        def all_fields_satisfy(
+            self, matcher: Matcher[Any] | Callable[[Any], object], *, allow_empty: bool = ...
+        ) -> _PathAssertion: ...
+        def has_no_none_fields(self, *, allow_empty: bool = ...) -> _PathAssertion: ...
+        def is_in(self, *items: object) -> _PathAssertion: ...
+        def is_not_in(self, *items: object) -> _PathAssertion: ...
+        def snapshot(
+            self,
+            id: str | None = ...,
+            path: str = ...,
+            *,
+            ignore: _KeySpecs | None = ...,
+            include: _KeySpecs | None = ...,
+            tolerance: float | None = ...,
+            rel: float | None = ...,
+            comparators: dict[Any, Callable[[Any, Any], Any]] | None = ...,
+            placeholders: Mapping[Any, Matcher[Any] | Callable[[Any], object]] | None = ...,
+        ) -> _PathAssertion: ...
+        def matches_contract_snapshot(self, id: str | None = ..., path: str = ...) -> _PathAssertion: ...
+        def matches_inline(
+            self,
+            expected: object = ...,
+            *,
+            ignore: _KeySpecs | None = ...,
+            include: _KeySpecs | None = ...,
+            tolerance: float | None = ...,
+            rel: float | None = ...,
+            comparators: dict[Any, Callable[[Any, Any], Any]] | None = ...,
+            placeholders: Mapping[Any, Matcher[Any] | Callable[[Any], object]] | None = ...,
+        ) -> _PathAssertion: ...
+
+    class _NegatedBytesAssertion(Protocol[_B_co]):
+        """The negation twin of `_BytesAssertion`."""
+
+        def contains(self, *items: object) -> _BytesAssertion[_B_co]: ...
+        def does_not_contain(self, *items: object) -> _BytesAssertion[_B_co]: ...
+        def is_sorted(
+            self, key: Callable[[int], object] = ..., reverse: bool = ..., *, allow_empty: bool = ...
+        ) -> _BytesAssertion[_B_co]: ...
+        def starts_with(self, prefix: bytes | bytearray) -> _BytesAssertion[_B_co]: ...
+        def ends_with(self, suffix: bytes | bytearray) -> _BytesAssertion[_B_co]: ...
+        def is_valid_utf8(self) -> _BytesAssertion[_B_co]: ...
+        def is_valid_encoding(self, encoding: str) -> _BytesAssertion[_B_co]: ...
+        def starts_with_bytes(self, prefix: bytes | bytearray) -> _BytesAssertion[_B_co]: ...
+        def contains_bytes(self, sub: bytes | bytearray) -> _BytesAssertion[_B_co]: ...
+        def has_byte_at(self, index: SupportsIndex, expected: SupportsIndex) -> _BytesAssertion[_B_co]: ...
+        def is_hex_equal_to(self, expected_hex: str) -> _BytesAssertion[_B_co]: ...
+        def is_greater_than(self, other: bytes | bytearray) -> _BytesAssertion[_B_co]: ...
+        def is_greater_than_or_equal_to(self, other: bytes | bytearray) -> _BytesAssertion[_B_co]: ...
+        def is_less_than(self, other: bytes | bytearray) -> _BytesAssertion[_B_co]: ...
+        def is_less_than_or_equal_to(self, other: bytes | bytearray) -> _BytesAssertion[_B_co]: ...
+        def is_subset_of(self, *supersets: object, allow_empty: bool = ...) -> _BytesAssertion[_B_co]: ...
+        def has_same_size_as(self, other: Sized) -> _BytesAssertion[_B_co]: ...
+        def has_size_greater_than(self, size: SupportsIndex) -> _BytesAssertion[_B_co]: ...
+        def has_size_less_than(self, size: SupportsIndex) -> _BytesAssertion[_B_co]: ...
+        def has_size_between(self, low: SupportsIndex, high: SupportsIndex) -> _BytesAssertion[_B_co]: ...
+        def is_empty(self) -> _BytesAssertion[_B_co]: ...
+        def is_not_empty(self) -> _BytesAssertion[_B_co]: ...
+        def is_equal_to(
+            self,
+            other: object,
+            *,
+            ignore: _KeySpecs | None = ...,
+            include: _KeySpecs | None = ...,
+            tolerance: float | None = ...,
+            rel: float | None = ...,
+            comparators: dict[Any, Callable[[Any, Any], Any]] | None = ...,
+            ignore_null: bool = ...,
+            strict_types: bool = ...,
+        ) -> _BytesAssertion[_B_co]: ...
+        def is_not_equal_to(self, other: object) -> _BytesAssertion[_B_co]: ...
+        def is_same_as(self, other: object) -> _BytesAssertion[_B_co]: ...
+        def is_not_same_as(self, other: object) -> _BytesAssertion[_B_co]: ...
+        def is_true(self) -> _BytesAssertion[_B_co]: ...
+        def is_false(self) -> _BytesAssertion[_B_co]: ...
+        def is_none(self) -> _BytesAssertion[_B_co]: ...
+        def is_not_none(self) -> _BytesAssertion[_B_co]: ...
+        def is_type_of(self, some_type: type) -> _BytesAssertion[_B_co]: ...
+        def is_instance_of(self, some_class: ClassInfo) -> _BytesAssertion[_B_co]: ...
+        def is_instance_of_any(self, *some_classes: ClassInfo) -> _BytesAssertion[_B_co]: ...
+        def is_subclass_of(self, some_class: ClassInfo) -> _BytesAssertion[_B_co]: ...
+        def is_length(self, length: SupportsIndex | Matcher[int]) -> _BytesAssertion[_B_co]: ...
+        def is_length_between(self, low: SupportsIndex, high: SupportsIndex) -> _BytesAssertion[_B_co]: ...
+        def is_callable(self) -> _BytesAssertion[_B_co]: ...
+        def is_not_callable(self) -> _BytesAssertion[_B_co]: ...
+        def is_iterable(self) -> _BytesAssertion[_B_co]: ...
+        def is_not_iterable(self) -> _BytesAssertion[_B_co]: ...
+        def satisfies(self, matcher: Matcher[Any] | Callable[[Any], object]) -> _BytesAssertion[_B_co]: ...
+        def all_fields_satisfy(
+            self, matcher: Matcher[Any] | Callable[[Any], object], *, allow_empty: bool = ...
+        ) -> _BytesAssertion[_B_co]: ...
+        def has_no_none_fields(self, *, allow_empty: bool = ...) -> _BytesAssertion[_B_co]: ...
+        def is_in(self, *items: object) -> _BytesAssertion[_B_co]: ...
+        def is_not_in(self, *items: object) -> _BytesAssertion[_B_co]: ...
+        def snapshot(
+            self,
+            id: str | None = ...,
+            path: str = ...,
+            *,
+            ignore: _KeySpecs | None = ...,
+            include: _KeySpecs | None = ...,
+            tolerance: float | None = ...,
+            rel: float | None = ...,
+            comparators: dict[Any, Callable[[Any, Any], Any]] | None = ...,
+            placeholders: Mapping[Any, Matcher[Any] | Callable[[Any], object]] | None = ...,
+        ) -> _BytesAssertion[_B_co]: ...
+        def matches_contract_snapshot(self, id: str | None = ..., path: str = ...) -> _BytesAssertion[_B_co]: ...
+        def matches_inline(
+            self,
+            expected: object = ...,
+            *,
+            ignore: _KeySpecs | None = ...,
+            include: _KeySpecs | None = ...,
+            tolerance: float | None = ...,
+            rel: float | None = ...,
+            comparators: dict[Any, Callable[[Any, Any], Any]] | None = ...,
+            placeholders: Mapping[Any, Matcher[Any] | Callable[[Any], object]] | None = ...,
+        ) -> _BytesAssertion[_B_co]: ...
+
+    class _NegatedFrameAssertion(Protocol[_FrameT_co]):
+        """The negation twin of `_FrameAssertion`."""
+
+        def is_frame_equal(self, expected: object, **options: Any) -> _FrameAssertion[_FrameT_co]: ...
+        def is_array_equal(self, expected: object, **options: Any) -> _FrameAssertion[_FrameT_co]: ...
+        def is_array_close_to(
+            self, expected: object, *, rtol: float = ..., atol: float = ..., equal_nan: bool = ..., **options: Any
+        ) -> _FrameAssertion[_FrameT_co]: ...
+        def contains(self, *items: object) -> _FrameAssertion[_FrameT_co]: ...
+        def does_not_contain(self, *items: object) -> _FrameAssertion[_FrameT_co]: ...
+        def contains_only(self, *items: object) -> _FrameAssertion[_FrameT_co]: ...
+        def is_equal_to(
+            self,
+            other: object,
+            *,
+            ignore: _KeySpecs | None = ...,
+            include: _KeySpecs | None = ...,
+            tolerance: float | None = ...,
+            rel: float | None = ...,
+            comparators: dict[Any, Callable[[Any, Any], Any]] | None = ...,
+            ignore_null: bool = ...,
+            strict_types: bool = ...,
+        ) -> _FrameAssertion[_FrameT_co]: ...
+        def is_not_equal_to(self, other: object) -> _FrameAssertion[_FrameT_co]: ...
+        def is_same_as(self, other: object) -> _FrameAssertion[_FrameT_co]: ...
+        def is_not_same_as(self, other: object) -> _FrameAssertion[_FrameT_co]: ...
+        def is_true(self) -> _FrameAssertion[_FrameT_co]: ...
+        def is_false(self) -> _FrameAssertion[_FrameT_co]: ...
+        def is_none(self) -> _FrameAssertion[_FrameT_co]: ...
+        def is_not_none(self) -> _FrameAssertion[_FrameT_co]: ...
+        def is_type_of(self, some_type: type) -> _FrameAssertion[_FrameT_co]: ...
+        def is_instance_of(self, some_class: ClassInfo) -> _FrameAssertion[_FrameT_co]: ...
+        def is_instance_of_any(self, *some_classes: ClassInfo) -> _FrameAssertion[_FrameT_co]: ...
+        def is_subclass_of(self, some_class: ClassInfo) -> _FrameAssertion[_FrameT_co]: ...
+        def is_length(self, length: SupportsIndex | Matcher[int]) -> _FrameAssertion[_FrameT_co]: ...
+        def is_length_between(self, low: SupportsIndex, high: SupportsIndex) -> _FrameAssertion[_FrameT_co]: ...
+        def is_callable(self) -> _FrameAssertion[_FrameT_co]: ...
+        def is_not_callable(self) -> _FrameAssertion[_FrameT_co]: ...
+        def is_iterable(self) -> _FrameAssertion[_FrameT_co]: ...
+        def is_not_iterable(self) -> _FrameAssertion[_FrameT_co]: ...
+        def satisfies(self, matcher: Matcher[Any] | Callable[[Any], object]) -> _FrameAssertion[_FrameT_co]: ...
+        def all_fields_satisfy(
+            self, matcher: Matcher[Any] | Callable[[Any], object], *, allow_empty: bool = ...
+        ) -> _FrameAssertion[_FrameT_co]: ...
+        def has_no_none_fields(self, *, allow_empty: bool = ...) -> _FrameAssertion[_FrameT_co]: ...
+        def is_in(self, *items: object) -> _FrameAssertion[_FrameT_co]: ...
+        def is_not_in(self, *items: object) -> _FrameAssertion[_FrameT_co]: ...
+        def snapshot(
+            self,
+            id: str | None = ...,
+            path: str = ...,
+            *,
+            ignore: _KeySpecs | None = ...,
+            include: _KeySpecs | None = ...,
+            tolerance: float | None = ...,
+            rel: float | None = ...,
+            comparators: dict[Any, Callable[[Any, Any], Any]] | None = ...,
+            placeholders: Mapping[Any, Matcher[Any] | Callable[[Any], object]] | None = ...,
+        ) -> _FrameAssertion[_FrameT_co]: ...
+        def matches_contract_snapshot(self, id: str | None = ..., path: str = ...) -> _FrameAssertion[_FrameT_co]: ...
+        def matches_inline(
+            self,
+            expected: object = ...,
+            *,
+            ignore: _KeySpecs | None = ...,
+            include: _KeySpecs | None = ...,
+            tolerance: float | None = ...,
+            rel: float | None = ...,
+            comparators: dict[Any, Callable[[Any, Any], Any]] | None = ...,
+            placeholders: Mapping[Any, Matcher[Any] | Callable[[Any], object]] | None = ...,
+        ) -> _FrameAssertion[_FrameT_co]: ...
+        def has_same_size_as(self, other: Sized) -> _FrameAssertion[_FrameT_co]: ...
+        def has_size_greater_than(self, size: SupportsIndex) -> _FrameAssertion[_FrameT_co]: ...
+        def has_size_less_than(self, size: SupportsIndex) -> _FrameAssertion[_FrameT_co]: ...
+        def has_size_between(self, low: SupportsIndex, high: SupportsIndex) -> _FrameAssertion[_FrameT_co]: ...
+        def is_empty(self) -> _FrameAssertion[_FrameT_co]: ...
+        def is_not_empty(self) -> _FrameAssertion[_FrameT_co]: ...
+        def is_subset_of(self, *supersets: object, allow_empty: bool = ...) -> _FrameAssertion[_FrameT_co]: ...
+        def each(
+            self, matcher: Matcher[Any] | Callable[[Any], object], *, allow_empty: bool = ...
+        ) -> _FrameAssertion[_FrameT_co]: ...
+        def all_satisfy(
+            self, matcher: Matcher[Any] | Callable[[Any], object], *, allow_empty: bool = ...
+        ) -> _FrameAssertion[_FrameT_co]: ...
+
+    class _NegatedArrayAssertion(Protocol[_ArrayT_co]):
+        """The negation twin of `_ArrayAssertion`."""
+
+        def is_array_equal(self, expected: object, **options: Any) -> _ArrayAssertion[_ArrayT_co]: ...
+        def is_array_close_to(
+            self, expected: object, *, rtol: float = ..., atol: float = ..., equal_nan: bool = ..., **options: Any
+        ) -> _ArrayAssertion[_ArrayT_co]: ...
+        def contains(self, *items: object) -> _ArrayAssertion[_ArrayT_co]: ...
+        def does_not_contain(self, *items: object) -> _ArrayAssertion[_ArrayT_co]: ...
+        def contains_only(self, *items: object) -> _ArrayAssertion[_ArrayT_co]: ...
+        def is_equal_to(
+            self,
+            other: object,
+            *,
+            ignore: _KeySpecs | None = ...,
+            include: _KeySpecs | None = ...,
+            tolerance: float | None = ...,
+            rel: float | None = ...,
+            comparators: dict[Any, Callable[[Any, Any], Any]] | None = ...,
+            ignore_null: bool = ...,
+            strict_types: bool = ...,
+        ) -> _ArrayAssertion[_ArrayT_co]: ...
+        def is_not_equal_to(self, other: object) -> _ArrayAssertion[_ArrayT_co]: ...
+        def is_same_as(self, other: object) -> _ArrayAssertion[_ArrayT_co]: ...
+        def is_not_same_as(self, other: object) -> _ArrayAssertion[_ArrayT_co]: ...
+        def is_true(self) -> _ArrayAssertion[_ArrayT_co]: ...
+        def is_false(self) -> _ArrayAssertion[_ArrayT_co]: ...
+        def is_none(self) -> _ArrayAssertion[_ArrayT_co]: ...
+        def is_not_none(self) -> _ArrayAssertion[_ArrayT_co]: ...
+        def is_type_of(self, some_type: type) -> _ArrayAssertion[_ArrayT_co]: ...
+        def is_instance_of(self, some_class: ClassInfo) -> _ArrayAssertion[_ArrayT_co]: ...
+        def is_instance_of_any(self, *some_classes: ClassInfo) -> _ArrayAssertion[_ArrayT_co]: ...
+        def is_subclass_of(self, some_class: ClassInfo) -> _ArrayAssertion[_ArrayT_co]: ...
+        def is_length(self, length: SupportsIndex | Matcher[int]) -> _ArrayAssertion[_ArrayT_co]: ...
+        def is_length_between(self, low: SupportsIndex, high: SupportsIndex) -> _ArrayAssertion[_ArrayT_co]: ...
+        def is_callable(self) -> _ArrayAssertion[_ArrayT_co]: ...
+        def is_not_callable(self) -> _ArrayAssertion[_ArrayT_co]: ...
+        def is_iterable(self) -> _ArrayAssertion[_ArrayT_co]: ...
+        def is_not_iterable(self) -> _ArrayAssertion[_ArrayT_co]: ...
+        def satisfies(self, matcher: Matcher[Any] | Callable[[Any], object]) -> _ArrayAssertion[_ArrayT_co]: ...
+        def all_fields_satisfy(
+            self, matcher: Matcher[Any] | Callable[[Any], object], *, allow_empty: bool = ...
+        ) -> _ArrayAssertion[_ArrayT_co]: ...
+        def has_no_none_fields(self, *, allow_empty: bool = ...) -> _ArrayAssertion[_ArrayT_co]: ...
+        def is_in(self, *items: object) -> _ArrayAssertion[_ArrayT_co]: ...
+        def is_not_in(self, *items: object) -> _ArrayAssertion[_ArrayT_co]: ...
+        def snapshot(
+            self,
+            id: str | None = ...,
+            path: str = ...,
+            *,
+            ignore: _KeySpecs | None = ...,
+            include: _KeySpecs | None = ...,
+            tolerance: float | None = ...,
+            rel: float | None = ...,
+            comparators: dict[Any, Callable[[Any, Any], Any]] | None = ...,
+            placeholders: Mapping[Any, Matcher[Any] | Callable[[Any], object]] | None = ...,
+        ) -> _ArrayAssertion[_ArrayT_co]: ...
+        def matches_contract_snapshot(self, id: str | None = ..., path: str = ...) -> _ArrayAssertion[_ArrayT_co]: ...
+        def matches_inline(
+            self,
+            expected: object = ...,
+            *,
+            ignore: _KeySpecs | None = ...,
+            include: _KeySpecs | None = ...,
+            tolerance: float | None = ...,
+            rel: float | None = ...,
+            comparators: dict[Any, Callable[[Any, Any], Any]] | None = ...,
+            placeholders: Mapping[Any, Matcher[Any] | Callable[[Any], object]] | None = ...,
+        ) -> _ArrayAssertion[_ArrayT_co]: ...
+        def has_same_size_as(self, other: Sized) -> _ArrayAssertion[_ArrayT_co]: ...
+        def has_size_greater_than(self, size: SupportsIndex) -> _ArrayAssertion[_ArrayT_co]: ...
+        def has_size_less_than(self, size: SupportsIndex) -> _ArrayAssertion[_ArrayT_co]: ...
+        def has_size_between(self, low: SupportsIndex, high: SupportsIndex) -> _ArrayAssertion[_ArrayT_co]: ...
+        def is_empty(self) -> _ArrayAssertion[_ArrayT_co]: ...
+        def is_not_empty(self) -> _ArrayAssertion[_ArrayT_co]: ...
+        def is_subset_of(self, *supersets: object, allow_empty: bool = ...) -> _ArrayAssertion[_ArrayT_co]: ...
+        def each(
+            self, matcher: Matcher[Any] | Callable[[Any], object], *, allow_empty: bool = ...
+        ) -> _ArrayAssertion[_ArrayT_co]: ...
+        def all_satisfy(
+            self, matcher: Matcher[Any] | Callable[[Any], object], *, allow_empty: bool = ...
+        ) -> _ArrayAssertion[_ArrayT_co]: ...
+
+    class _NegatedCallableAssertion(Protocol[_P_co]):
+        """The negation twin of `_CallableAssertion`."""
+
+        def is_equal_to(
+            self,
+            other: object,
+            *,
+            ignore: _KeySpecs | None = ...,
+            include: _KeySpecs | None = ...,
+            tolerance: float | None = ...,
+            rel: float | None = ...,
+            comparators: dict[Any, Callable[[Any, Any], Any]] | None = ...,
+            ignore_null: bool = ...,
+            strict_types: bool = ...,
+        ) -> _CallableAssertion[_P_co]: ...
+        def is_not_equal_to(self, other: object) -> _CallableAssertion[_P_co]: ...
+        def is_same_as(self, other: object) -> _CallableAssertion[_P_co]: ...
+        def is_not_same_as(self, other: object) -> _CallableAssertion[_P_co]: ...
+        def is_true(self) -> _CallableAssertion[_P_co]: ...
+        def is_false(self) -> _CallableAssertion[_P_co]: ...
+        def is_none(self) -> _CallableAssertion[_P_co]: ...
+        def is_not_none(self) -> _CallableAssertion[_P_co]: ...
+        def is_type_of(self, some_type: type) -> _CallableAssertion[_P_co]: ...
+        def is_instance_of(self, some_class: ClassInfo) -> _CallableAssertion[_P_co]: ...
+        def is_instance_of_any(self, *some_classes: ClassInfo) -> _CallableAssertion[_P_co]: ...
+        def is_subclass_of(self, some_class: ClassInfo) -> _CallableAssertion[_P_co]: ...
+        def is_length(self, length: SupportsIndex | Matcher[int]) -> _CallableAssertion[_P_co]: ...
+        def is_length_between(self, low: SupportsIndex, high: SupportsIndex) -> _CallableAssertion[_P_co]: ...
+        def is_callable(self) -> _CallableAssertion[_P_co]: ...
+        def is_not_callable(self) -> _CallableAssertion[_P_co]: ...
+        def is_iterable(self) -> _CallableAssertion[_P_co]: ...
+        def is_not_iterable(self) -> _CallableAssertion[_P_co]: ...
+        def satisfies(self, matcher: Matcher[Any] | Callable[[Any], object]) -> _CallableAssertion[_P_co]: ...
+        def all_fields_satisfy(
+            self, matcher: Matcher[Any] | Callable[[Any], object], *, allow_empty: bool = ...
+        ) -> _CallableAssertion[_P_co]: ...
+        def has_no_none_fields(self, *, allow_empty: bool = ...) -> _CallableAssertion[_P_co]: ...
+        def is_in(self, *items: object) -> _CallableAssertion[_P_co]: ...
+        def is_not_in(self, *items: object) -> _CallableAssertion[_P_co]: ...
+        def snapshot(
+            self,
+            id: str | None = ...,
+            path: str = ...,
+            *,
+            ignore: _KeySpecs | None = ...,
+            include: _KeySpecs | None = ...,
+            tolerance: float | None = ...,
+            rel: float | None = ...,
+            comparators: dict[Any, Callable[[Any, Any], Any]] | None = ...,
+            placeholders: Mapping[Any, Matcher[Any] | Callable[[Any], object]] | None = ...,
+        ) -> _CallableAssertion[_P_co]: ...
+        def matches_contract_snapshot(self, id: str | None = ..., path: str = ...) -> _CallableAssertion[_P_co]: ...
+        def matches_inline(
+            self,
+            expected: object = ...,
+            *,
+            ignore: _KeySpecs | None = ...,
+            include: _KeySpecs | None = ...,
+            tolerance: float | None = ...,
+            rel: float | None = ...,
+            comparators: dict[Any, Callable[[Any, Any], Any]] | None = ...,
+            placeholders: Mapping[Any, Matcher[Any] | Callable[[Any], object]] | None = ...,
+        ) -> _CallableAssertion[_P_co]: ...
+
+    class _NegatedObjectAssertion(Protocol[_T_co]):
+        """The negation twin of `_ObjectAssertion`."""
+
+        def matches_structure(self, spec: dict[Any, Any]) -> _ObjectAssertion[_T_co]: ...
+        def is_greater_than(self, other: Any) -> _ObjectAssertion[_T_co]: ...
+        def is_greater_than_or_equal_to(self, other: Any) -> _ObjectAssertion[_T_co]: ...
+        def is_less_than(self, other: Any) -> _ObjectAssertion[_T_co]: ...
+        def is_less_than_or_equal_to(self, other: Any) -> _ObjectAssertion[_T_co]: ...
+        def is_between(self, low: Any, high: Any) -> _ObjectAssertion[_T_co]: ...
+        def is_not_between(self, low: Any, high: Any) -> _ObjectAssertion[_T_co]: ...
+        def is_zero(self: _NegatedObjectAssertion[SupportsFloat | SupportsIndex]) -> _ObjectAssertion[_T_co]: ...
+        def is_not_zero(self: _NegatedObjectAssertion[SupportsFloat | SupportsIndex]) -> _ObjectAssertion[_T_co]: ...
+        def is_close_to(
+            self: _NegatedObjectAssertion[SupportsFloat | SupportsIndex],
+            other: SupportsFloat | SupportsIndex,
+            tolerance: SupportsFloat | SupportsIndex | None = ...,
+            *,
+            rel: SupportsFloat | SupportsIndex | None = ...,
+        ) -> _ObjectAssertion[_T_co]: ...
+        def is_not_close_to(
+            self: _NegatedObjectAssertion[SupportsFloat | SupportsIndex],
+            other: SupportsFloat | SupportsIndex,
+            tolerance: SupportsFloat | SupportsIndex | None = ...,
+            *,
+            rel: SupportsFloat | SupportsIndex | None = ...,
+        ) -> _ObjectAssertion[_T_co]: ...
+        def is_not_none(self) -> _ObjectAssertion[_T_co]: ...
+        @overload
+        def is_instance_of(self, some_class: type[str]) -> _ObjectAssertion[_T_co]: ...
+        @overload
+        def is_instance_of(self, some_class: type[bool]) -> _ObjectAssertion[_T_co]: ...
+        @overload
+        def is_instance_of(self, some_class: type[int]) -> _ObjectAssertion[_T_co]: ...
+        @overload
+        def is_instance_of(self, some_class: type[float]) -> _ObjectAssertion[_T_co]: ...
+        @overload
+        def is_instance_of(self, some_class: type[complex]) -> _ObjectAssertion[_T_co]: ...
+        @overload
+        def is_instance_of(self, some_class: type[dict[_K, _V]]) -> _ObjectAssertion[_T_co]: ...
+        @overload
+        def is_instance_of(self, some_class: type[list[_E] | tuple[_E, ...]]) -> _ObjectAssertion[_T_co]: ...
+        @overload
+        def is_instance_of(self, some_class: type[set[_E] | frozenset[_E]]) -> _ObjectAssertion[_T_co]: ...
+        @overload
+        def is_instance_of(self, some_class: type[datetime.datetime]) -> _ObjectAssertion[_T_co]: ...
+        @overload
+        def is_instance_of(self, some_class: type[datetime.date]) -> _ObjectAssertion[_T_co]: ...
+        @overload
+        def is_instance_of(self, some_class: type[Path]) -> _ObjectAssertion[_T_co]: ...
+        @overload
+        def is_instance_of(self, some_class: type[bytes]) -> _ObjectAssertion[_T_co]: ...
+        @overload
+        def is_instance_of(self, some_class: type[bytearray]) -> _ObjectAssertion[_T_co]: ...
+        @overload
+        def is_instance_of(self, some_class: tuple[type[_U], type[_U2]]) -> _ObjectAssertion[_T_co]: ...
+        @overload
+        def is_instance_of(self, some_class: tuple[type[_U], type[_U2], type[_U3]]) -> _ObjectAssertion[_T_co]: ...
+        @overload
+        def is_instance_of(self, some_class: type[_U]) -> _ObjectAssertion[_T_co]: ...
+        @overload
+        def is_instance_of(self, some_class: ClassInfo) -> _ObjectAssertion[_T_co]: ...
+        @overload
+        def is_instance_of_any(self, first: type[_U], second: type[_U2], /) -> _ObjectAssertion[_T_co]: ...
+        @overload
+        def is_instance_of_any(
+            self, first: type[_U], second: type[_U2], third: type[_U3], /
+        ) -> _ObjectAssertion[_T_co]: ...
+        @overload
+        def is_instance_of_any(self, *some_classes: ClassInfo) -> _ObjectAssertion[_T_co]: ...
+        def is_equal_to(
+            self,
+            other: object,
+            *,
+            ignore: _KeySpecs | None = ...,
+            include: _KeySpecs | None = ...,
+            tolerance: float | None = ...,
+            rel: float | None = ...,
+            comparators: dict[Any, Callable[[Any, Any], Any]] | None = ...,
+            ignore_null: bool = ...,
+            strict_types: bool = ...,
+        ) -> _ObjectAssertion[_T_co]: ...
+        def is_not_equal_to(self, other: object) -> _ObjectAssertion[_T_co]: ...
+        def is_same_as(self, other: object) -> _ObjectAssertion[_T_co]: ...
+        def is_not_same_as(self, other: object) -> _ObjectAssertion[_T_co]: ...
+        def is_true(self) -> _ObjectAssertion[_T_co]: ...
+        def is_false(self) -> _ObjectAssertion[_T_co]: ...
+        def is_none(self) -> _ObjectAssertion[_T_co]: ...
+        def is_type_of(self, some_type: type) -> _ObjectAssertion[_T_co]: ...
+        def is_subclass_of(self, some_class: ClassInfo) -> _ObjectAssertion[_T_co]: ...
+        def is_length(self, length: SupportsIndex | Matcher[int]) -> _ObjectAssertion[_T_co]: ...
+        def is_length_between(self, low: SupportsIndex, high: SupportsIndex) -> _ObjectAssertion[_T_co]: ...
+        def is_callable(self) -> _ObjectAssertion[_T_co]: ...
+        def is_not_callable(self) -> _ObjectAssertion[_T_co]: ...
+        def is_iterable(self) -> _ObjectAssertion[_T_co]: ...
+        def is_not_iterable(self) -> _ObjectAssertion[_T_co]: ...
+        def satisfies(self, matcher: Matcher[Any] | Callable[[Any], object]) -> _ObjectAssertion[_T_co]: ...
+        def all_fields_satisfy(
+            self, matcher: Matcher[Any] | Callable[[Any], object], *, allow_empty: bool = ...
+        ) -> _ObjectAssertion[_T_co]: ...
+        def has_no_none_fields(self, *, allow_empty: bool = ...) -> _ObjectAssertion[_T_co]: ...
+        def is_in(self, *items: object) -> _ObjectAssertion[_T_co]: ...
+        def is_not_in(self, *items: object) -> _ObjectAssertion[_T_co]: ...
+        def snapshot(
+            self,
+            id: str | None = ...,
+            path: str = ...,
+            *,
+            ignore: _KeySpecs | None = ...,
+            include: _KeySpecs | None = ...,
+            tolerance: float | None = ...,
+            rel: float | None = ...,
+            comparators: dict[Any, Callable[[Any, Any], Any]] | None = ...,
+            placeholders: Mapping[Any, Matcher[Any] | Callable[[Any], object]] | None = ...,
+        ) -> _ObjectAssertion[_T_co]: ...
+        def matches_contract_snapshot(self, id: str | None = ..., path: str = ...) -> _ObjectAssertion[_T_co]: ...
+        def matches_inline(
+            self,
+            expected: object = ...,
+            *,
+            ignore: _KeySpecs | None = ...,
+            include: _KeySpecs | None = ...,
+            tolerance: float | None = ...,
+            rel: float | None = ...,
+            comparators: dict[Any, Callable[[Any, Any], Any]] | None = ...,
+            placeholders: Mapping[Any, Matcher[Any] | Callable[[Any], object]] | None = ...,
+        ) -> _ObjectAssertion[_T_co]: ...
+
+    class _NegatedExpectedRaiseAssertion(Protocol[_P_co, _Exc]):
+        """The negation twin of `_ExpectedRaiseAssertion`."""
+
+        def when_called_with(
+            self, *some_args: object, **some_kwargs: object
+        ) -> _ExpectedRaiseAssertion[_P_co, _Exc]: ...
+        def is_equal_to(
+            self,
+            other: object,
+            *,
+            ignore: _KeySpecs | None = ...,
+            include: _KeySpecs | None = ...,
+            tolerance: float | None = ...,
+            rel: float | None = ...,
+            comparators: dict[Any, Callable[[Any, Any], Any]] | None = ...,
+            ignore_null: bool = ...,
+            strict_types: bool = ...,
+        ) -> _ExpectedRaiseAssertion[_P_co, _Exc]: ...
+        def is_not_equal_to(self, other: object) -> _ExpectedRaiseAssertion[_P_co, _Exc]: ...
+        def is_same_as(self, other: object) -> _ExpectedRaiseAssertion[_P_co, _Exc]: ...
+        def is_not_same_as(self, other: object) -> _ExpectedRaiseAssertion[_P_co, _Exc]: ...
+        def is_true(self) -> _ExpectedRaiseAssertion[_P_co, _Exc]: ...
+        def is_false(self) -> _ExpectedRaiseAssertion[_P_co, _Exc]: ...
+        def is_none(self) -> _ExpectedRaiseAssertion[_P_co, _Exc]: ...
+        def is_not_none(self) -> _ExpectedRaiseAssertion[_P_co, _Exc]: ...
+        def is_type_of(self, some_type: type) -> _ExpectedRaiseAssertion[_P_co, _Exc]: ...
+        def is_instance_of(self, some_class: ClassInfo) -> _ExpectedRaiseAssertion[_P_co, _Exc]: ...
+        def is_instance_of_any(self, *some_classes: ClassInfo) -> _ExpectedRaiseAssertion[_P_co, _Exc]: ...
+        def is_subclass_of(self, some_class: ClassInfo) -> _ExpectedRaiseAssertion[_P_co, _Exc]: ...
+        def is_length(self, length: SupportsIndex | Matcher[int]) -> _ExpectedRaiseAssertion[_P_co, _Exc]: ...
+        def is_length_between(
+            self, low: SupportsIndex, high: SupportsIndex
+        ) -> _ExpectedRaiseAssertion[_P_co, _Exc]: ...
+        def is_callable(self) -> _ExpectedRaiseAssertion[_P_co, _Exc]: ...
+        def is_not_callable(self) -> _ExpectedRaiseAssertion[_P_co, _Exc]: ...
+        def is_iterable(self) -> _ExpectedRaiseAssertion[_P_co, _Exc]: ...
+        def is_not_iterable(self) -> _ExpectedRaiseAssertion[_P_co, _Exc]: ...
+        def satisfies(
+            self, matcher: Matcher[Any] | Callable[[Any], object]
+        ) -> _ExpectedRaiseAssertion[_P_co, _Exc]: ...
+        def all_fields_satisfy(
+            self, matcher: Matcher[Any] | Callable[[Any], object], *, allow_empty: bool = ...
+        ) -> _ExpectedRaiseAssertion[_P_co, _Exc]: ...
+        def has_no_none_fields(self, *, allow_empty: bool = ...) -> _ExpectedRaiseAssertion[_P_co, _Exc]: ...
+        def is_in(self, *items: object) -> _ExpectedRaiseAssertion[_P_co, _Exc]: ...
+        def is_not_in(self, *items: object) -> _ExpectedRaiseAssertion[_P_co, _Exc]: ...
+        def snapshot(
+            self,
+            id: str | None = ...,
+            path: str = ...,
+            *,
+            ignore: _KeySpecs | None = ...,
+            include: _KeySpecs | None = ...,
+            tolerance: float | None = ...,
+            rel: float | None = ...,
+            comparators: dict[Any, Callable[[Any, Any], Any]] | None = ...,
+            placeholders: Mapping[Any, Matcher[Any] | Callable[[Any], object]] | None = ...,
+        ) -> _ExpectedRaiseAssertion[_P_co, _Exc]: ...
+        def matches_contract_snapshot(
+            self, id: str | None = ..., path: str = ...
+        ) -> _ExpectedRaiseAssertion[_P_co, _Exc]: ...
+        def matches_inline(
+            self,
+            expected: object = ...,
+            *,
+            ignore: _KeySpecs | None = ...,
+            include: _KeySpecs | None = ...,
+            tolerance: float | None = ...,
+            rel: float | None = ...,
+            comparators: dict[Any, Callable[[Any, Any], Any]] | None = ...,
+            placeholders: Mapping[Any, Matcher[Any] | Callable[[Any], object]] | None = ...,
+        ) -> _ExpectedRaiseAssertion[_P_co, _Exc]: ...
+
+    class _NegatedExpectedCompletionAssertion(Protocol[_P_co]):
+        """The negation twin of `_ExpectedCompletionAssertion`."""
+
+        def when_called_with(
+            self, *some_args: object, **some_kwargs: object
+        ) -> _ExpectedCompletionAssertion[_P_co]: ...
+        def is_equal_to(
+            self,
+            other: object,
+            *,
+            ignore: _KeySpecs | None = ...,
+            include: _KeySpecs | None = ...,
+            tolerance: float | None = ...,
+            rel: float | None = ...,
+            comparators: dict[Any, Callable[[Any, Any], Any]] | None = ...,
+            ignore_null: bool = ...,
+            strict_types: bool = ...,
+        ) -> _ExpectedCompletionAssertion[_P_co]: ...
+        def is_not_equal_to(self, other: object) -> _ExpectedCompletionAssertion[_P_co]: ...
+        def is_same_as(self, other: object) -> _ExpectedCompletionAssertion[_P_co]: ...
+        def is_not_same_as(self, other: object) -> _ExpectedCompletionAssertion[_P_co]: ...
+        def is_true(self) -> _ExpectedCompletionAssertion[_P_co]: ...
+        def is_false(self) -> _ExpectedCompletionAssertion[_P_co]: ...
+        def is_none(self) -> _ExpectedCompletionAssertion[_P_co]: ...
+        def is_not_none(self) -> _ExpectedCompletionAssertion[_P_co]: ...
+        def is_type_of(self, some_type: type) -> _ExpectedCompletionAssertion[_P_co]: ...
+        def is_instance_of(self, some_class: ClassInfo) -> _ExpectedCompletionAssertion[_P_co]: ...
+        def is_instance_of_any(self, *some_classes: ClassInfo) -> _ExpectedCompletionAssertion[_P_co]: ...
+        def is_subclass_of(self, some_class: ClassInfo) -> _ExpectedCompletionAssertion[_P_co]: ...
+        def is_length(self, length: SupportsIndex | Matcher[int]) -> _ExpectedCompletionAssertion[_P_co]: ...
+        def is_length_between(self, low: SupportsIndex, high: SupportsIndex) -> _ExpectedCompletionAssertion[_P_co]: ...
+        def is_callable(self) -> _ExpectedCompletionAssertion[_P_co]: ...
+        def is_not_callable(self) -> _ExpectedCompletionAssertion[_P_co]: ...
+        def is_iterable(self) -> _ExpectedCompletionAssertion[_P_co]: ...
+        def is_not_iterable(self) -> _ExpectedCompletionAssertion[_P_co]: ...
+        def satisfies(self, matcher: Matcher[Any] | Callable[[Any], object]) -> _ExpectedCompletionAssertion[_P_co]: ...
+        def all_fields_satisfy(
+            self, matcher: Matcher[Any] | Callable[[Any], object], *, allow_empty: bool = ...
+        ) -> _ExpectedCompletionAssertion[_P_co]: ...
+        def has_no_none_fields(self, *, allow_empty: bool = ...) -> _ExpectedCompletionAssertion[_P_co]: ...
+        def is_in(self, *items: object) -> _ExpectedCompletionAssertion[_P_co]: ...
+        def is_not_in(self, *items: object) -> _ExpectedCompletionAssertion[_P_co]: ...
+        def snapshot(
+            self,
+            id: str | None = ...,
+            path: str = ...,
+            *,
+            ignore: _KeySpecs | None = ...,
+            include: _KeySpecs | None = ...,
+            tolerance: float | None = ...,
+            rel: float | None = ...,
+            comparators: dict[Any, Callable[[Any, Any], Any]] | None = ...,
+            placeholders: Mapping[Any, Matcher[Any] | Callable[[Any], object]] | None = ...,
+        ) -> _ExpectedCompletionAssertion[_P_co]: ...
+        def matches_contract_snapshot(
+            self, id: str | None = ..., path: str = ...
+        ) -> _ExpectedCompletionAssertion[_P_co]: ...
+        def matches_inline(
+            self,
+            expected: object = ...,
+            *,
+            ignore: _KeySpecs | None = ...,
+            include: _KeySpecs | None = ...,
+            tolerance: float | None = ...,
+            rel: float | None = ...,
+            comparators: dict[Any, Callable[[Any, Any], Any]] | None = ...,
+            placeholders: Mapping[Any, Matcher[Any] | Callable[[Any], object]] | None = ...,
+        ) -> _ExpectedCompletionAssertion[_P_co]: ...
+
+    class _NegatedExpectedWarningAssertion(Protocol[_P_co]):
+        """The negation twin of `_ExpectedWarningAssertion`."""
+
+        def when_called_with(self, *some_args: object, **some_kwargs: object) -> _ExpectedWarningAssertion[_P_co]: ...
+        def is_equal_to(
+            self,
+            other: object,
+            *,
+            ignore: _KeySpecs | None = ...,
+            include: _KeySpecs | None = ...,
+            tolerance: float | None = ...,
+            rel: float | None = ...,
+            comparators: dict[Any, Callable[[Any, Any], Any]] | None = ...,
+            ignore_null: bool = ...,
+            strict_types: bool = ...,
+        ) -> _ExpectedWarningAssertion[_P_co]: ...
+        def is_not_equal_to(self, other: object) -> _ExpectedWarningAssertion[_P_co]: ...
+        def is_same_as(self, other: object) -> _ExpectedWarningAssertion[_P_co]: ...
+        def is_not_same_as(self, other: object) -> _ExpectedWarningAssertion[_P_co]: ...
+        def is_true(self) -> _ExpectedWarningAssertion[_P_co]: ...
+        def is_false(self) -> _ExpectedWarningAssertion[_P_co]: ...
+        def is_none(self) -> _ExpectedWarningAssertion[_P_co]: ...
+        def is_not_none(self) -> _ExpectedWarningAssertion[_P_co]: ...
+        def is_type_of(self, some_type: type) -> _ExpectedWarningAssertion[_P_co]: ...
+        def is_instance_of(self, some_class: ClassInfo) -> _ExpectedWarningAssertion[_P_co]: ...
+        def is_instance_of_any(self, *some_classes: ClassInfo) -> _ExpectedWarningAssertion[_P_co]: ...
+        def is_subclass_of(self, some_class: ClassInfo) -> _ExpectedWarningAssertion[_P_co]: ...
+        def is_length(self, length: SupportsIndex | Matcher[int]) -> _ExpectedWarningAssertion[_P_co]: ...
+        def is_length_between(self, low: SupportsIndex, high: SupportsIndex) -> _ExpectedWarningAssertion[_P_co]: ...
+        def is_callable(self) -> _ExpectedWarningAssertion[_P_co]: ...
+        def is_not_callable(self) -> _ExpectedWarningAssertion[_P_co]: ...
+        def is_iterable(self) -> _ExpectedWarningAssertion[_P_co]: ...
+        def is_not_iterable(self) -> _ExpectedWarningAssertion[_P_co]: ...
+        def satisfies(self, matcher: Matcher[Any] | Callable[[Any], object]) -> _ExpectedWarningAssertion[_P_co]: ...
+        def all_fields_satisfy(
+            self, matcher: Matcher[Any] | Callable[[Any], object], *, allow_empty: bool = ...
+        ) -> _ExpectedWarningAssertion[_P_co]: ...
+        def has_no_none_fields(self, *, allow_empty: bool = ...) -> _ExpectedWarningAssertion[_P_co]: ...
+        def is_in(self, *items: object) -> _ExpectedWarningAssertion[_P_co]: ...
+        def is_not_in(self, *items: object) -> _ExpectedWarningAssertion[_P_co]: ...
+        def snapshot(
+            self,
+            id: str | None = ...,
+            path: str = ...,
+            *,
+            ignore: _KeySpecs | None = ...,
+            include: _KeySpecs | None = ...,
+            tolerance: float | None = ...,
+            rel: float | None = ...,
+            comparators: dict[Any, Callable[[Any, Any], Any]] | None = ...,
+            placeholders: Mapping[Any, Matcher[Any] | Callable[[Any], object]] | None = ...,
+        ) -> _ExpectedWarningAssertion[_P_co]: ...
+        def matches_contract_snapshot(
+            self, id: str | None = ..., path: str = ...
+        ) -> _ExpectedWarningAssertion[_P_co]: ...
+        def matches_inline(
+            self,
+            expected: object = ...,
+            *,
+            ignore: _KeySpecs | None = ...,
+            include: _KeySpecs | None = ...,
+            tolerance: float | None = ...,
+            rel: float | None = ...,
+            comparators: dict[Any, Callable[[Any, Any], Any]] | None = ...,
+            placeholders: Mapping[Any, Matcher[Any] | Callable[[Any], object]] | None = ...,
+        ) -> _ExpectedWarningAssertion[_P_co]: ...
+
+    class _NegatedWarnedAssertion(Protocol[_P_co]):
+        """The negation twin of `_WarnedAssertion`."""
+
+        def satisfies(self, matcher: Matcher[str] | Callable[[str], object]) -> _WarnedAssertion[_P_co]: ...
+        def contains(self, *items: str | Matcher[str]) -> _WarnedAssertion[_P_co]: ...
+        def is_equal_to_ignoring_case(self, other: str) -> _WarnedAssertion[_P_co]: ...
+        def is_equal_to_ignoring_whitespace(self, other: str) -> _WarnedAssertion[_P_co]: ...
+        def contains_ignoring_case(self, *items: str) -> _WarnedAssertion[_P_co]: ...
+        def starts_with(self, prefix: str) -> _WarnedAssertion[_P_co]: ...
+        def starts_with_ignoring_case(self, prefix: str) -> _WarnedAssertion[_P_co]: ...
+        def ends_with(self, suffix: str) -> _WarnedAssertion[_P_co]: ...
+        def ends_with_ignoring_case(self, suffix: str) -> _WarnedAssertion[_P_co]: ...
+        def matches(self, pattern: str | re.Pattern[str]) -> _WarnedAssertion[_P_co]: ...
+        def does_not_match(self, pattern: str | re.Pattern[str]) -> _WarnedAssertion[_P_co]: ...
+        def is_alpha(self) -> _WarnedAssertion[_P_co]: ...
+        def is_digit(self) -> _WarnedAssertion[_P_co]: ...
+        def is_lower(self) -> _WarnedAssertion[_P_co]: ...
+        def is_upper(self) -> _WarnedAssertion[_P_co]: ...
+        def is_alphanumeric(self) -> _WarnedAssertion[_P_co]: ...
+        def is_whitespace(self) -> _WarnedAssertion[_P_co]: ...
+        def contains_any_of(self, *items: str) -> _WarnedAssertion[_P_co]: ...
+        def contains_none_of(self, *items: str) -> _WarnedAssertion[_P_co]: ...
+        def is_unicode(self) -> _WarnedAssertion[_P_co]: ...
+        def is_greater_than(self, other: str) -> _WarnedAssertion[_P_co]: ...
+        def is_greater_than_or_equal_to(self, other: str) -> _WarnedAssertion[_P_co]: ...
+        def is_less_than(self, other: str) -> _WarnedAssertion[_P_co]: ...
+        def is_less_than_or_equal_to(self, other: str) -> _WarnedAssertion[_P_co]: ...
+        def does_not_contain(self, *items: str | Matcher[str]) -> _WarnedAssertion[_P_co]: ...
+        def contains_only(self, *items: str | Matcher[str]) -> _WarnedAssertion[_P_co]: ...
+        def contains_sequence(self, *items: str | Matcher[str]) -> _WarnedAssertion[_P_co]: ...
+        def contains_exactly(self, *items: str | Matcher[str]) -> _WarnedAssertion[_P_co]: ...
+        def contains_exactly_in_any_order(self, *items: str | Matcher[str]) -> _WarnedAssertion[_P_co]: ...
+        def is_sorted(
+            self, key: Callable[[str], object] = ..., reverse: bool = ..., *, allow_empty: bool = ...
+        ) -> _WarnedAssertion[_P_co]: ...
+        def each(
+            self, matcher: Matcher[str] | Callable[[str], object], *, allow_empty: bool = ...
+        ) -> _WarnedAssertion[_P_co]: ...
+        def all_satisfy(
+            self, matcher: Matcher[str] | Callable[[str], object], *, allow_empty: bool = ...
+        ) -> _WarnedAssertion[_P_co]: ...
+        def any_satisfy(self, matcher: Matcher[str] | Callable[[str], object]) -> _WarnedAssertion[_P_co]: ...
+        def none_satisfy(self, matcher: Matcher[str] | Callable[[str], object]) -> _WarnedAssertion[_P_co]: ...
+        def satisfies_exactly(self, *matchers: Matcher[str] | Callable[[str], object]) -> _WarnedAssertion[_P_co]: ...
+        def satisfies_exactly_in_any_order(
+            self, *matchers: Matcher[str] | Callable[[str], object]
+        ) -> _WarnedAssertion[_P_co]: ...
+        def zip_satisfies(
+            self, other: Iterable[_Other], predicate: Callable[[str, _Other], object], *, allow_empty: bool = ...
+        ) -> _WarnedAssertion[_P_co]: ...
+        def extracting_group(
+            self, pattern: str | re.Pattern[str], group: int | str = ...
+        ) -> _WarnedAssertion[_P_co]: ...
+        def matches_with_groups(self, pattern: str | re.Pattern[str]) -> _WarnedAssertion[_P_co]: ...
+        def is_subset_of(self, *supersets: object, allow_empty: bool = ...) -> _WarnedAssertion[_P_co]: ...
+        def contains_duplicates(self) -> _WarnedAssertion[_P_co]: ...
+        def does_not_contain_duplicates(self) -> _WarnedAssertion[_P_co]: ...
+        def contains_only_once(self, *items: object) -> _WarnedAssertion[_P_co]: ...
+        def contains_in_order(self, *items: str | Matcher[str]) -> _WarnedAssertion[_P_co]: ...
+        def has_same_size_as(self, other: Sized) -> _WarnedAssertion[_P_co]: ...
+        def has_size_greater_than(self, size: SupportsIndex) -> _WarnedAssertion[_P_co]: ...
+        def has_size_less_than(self, size: SupportsIndex) -> _WarnedAssertion[_P_co]: ...
+        def has_size_between(self, low: SupportsIndex, high: SupportsIndex) -> _WarnedAssertion[_P_co]: ...
+        def is_empty(self) -> _WarnedAssertion[_P_co]: ...
+        def is_not_empty(self) -> _WarnedAssertion[_P_co]: ...
+        def is_equal_to(
+            self,
+            other: object,
+            *,
+            ignore: _KeySpecs | None = ...,
+            include: _KeySpecs | None = ...,
+            tolerance: float | None = ...,
+            rel: float | None = ...,
+            comparators: dict[Any, Callable[[Any, Any], Any]] | None = ...,
+            ignore_null: bool = ...,
+            strict_types: bool = ...,
+        ) -> _WarnedAssertion[_P_co]: ...
+        def is_not_equal_to(self, other: object) -> _WarnedAssertion[_P_co]: ...
+        def is_same_as(self, other: object) -> _WarnedAssertion[_P_co]: ...
+        def is_not_same_as(self, other: object) -> _WarnedAssertion[_P_co]: ...
+        def is_true(self) -> _WarnedAssertion[_P_co]: ...
+        def is_false(self) -> _WarnedAssertion[_P_co]: ...
+        def is_none(self) -> _WarnedAssertion[_P_co]: ...
+        def is_not_none(self) -> _WarnedAssertion[_P_co]: ...
+        def is_type_of(self, some_type: type) -> _WarnedAssertion[_P_co]: ...
+        def is_instance_of(self, some_class: ClassInfo) -> _WarnedAssertion[_P_co]: ...
+        def is_instance_of_any(self, *some_classes: ClassInfo) -> _WarnedAssertion[_P_co]: ...
+        def is_subclass_of(self, some_class: ClassInfo) -> _WarnedAssertion[_P_co]: ...
+        def is_length(self, length: SupportsIndex | Matcher[int]) -> _WarnedAssertion[_P_co]: ...
+        def is_length_between(self, low: SupportsIndex, high: SupportsIndex) -> _WarnedAssertion[_P_co]: ...
+        def is_callable(self) -> _WarnedAssertion[_P_co]: ...
+        def is_not_callable(self) -> _WarnedAssertion[_P_co]: ...
+        def is_iterable(self) -> _WarnedAssertion[_P_co]: ...
+        def is_not_iterable(self) -> _WarnedAssertion[_P_co]: ...
+        def all_fields_satisfy(
+            self, matcher: Matcher[Any] | Callable[[Any], object], *, allow_empty: bool = ...
+        ) -> _WarnedAssertion[_P_co]: ...
+        def has_no_none_fields(self, *, allow_empty: bool = ...) -> _WarnedAssertion[_P_co]: ...
+        def is_in(self, *items: object) -> _WarnedAssertion[_P_co]: ...
+        def is_not_in(self, *items: object) -> _WarnedAssertion[_P_co]: ...
+        def snapshot(
+            self,
+            id: str | None = ...,
+            path: str = ...,
+            *,
+            ignore: _KeySpecs | None = ...,
+            include: _KeySpecs | None = ...,
+            tolerance: float | None = ...,
+            rel: float | None = ...,
+            comparators: dict[Any, Callable[[Any, Any], Any]] | None = ...,
+            placeholders: Mapping[Any, Matcher[Any] | Callable[[Any], object]] | None = ...,
+        ) -> _WarnedAssertion[_P_co]: ...
+        def matches_contract_snapshot(self, id: str | None = ..., path: str = ...) -> _WarnedAssertion[_P_co]: ...
+        def matches_inline(
+            self,
+            expected: object = ...,
+            *,
+            ignore: _KeySpecs | None = ...,
+            include: _KeySpecs | None = ...,
+            tolerance: float | None = ...,
+            rel: float | None = ...,
+            comparators: dict[Any, Callable[[Any, Any], Any]] | None = ...,
+            placeholders: Mapping[Any, Matcher[Any] | Callable[[Any], object]] | None = ...,
+        ) -> _WarnedAssertion[_P_co]: ...
+
+    class _NegatedListAssertion(Protocol[_E]):
+        """The negation twin of `_ListAssertion`."""
+
+        def contains(self, *items: _E | Matcher[_E]) -> _ListAssertion[_E]: ...
+        def does_not_contain(self, *items: _E | Matcher[_E]) -> _ListAssertion[_E]: ...
+        def contains_only(self, *items: _E | Matcher[_E]) -> _ListAssertion[_E]: ...
+        def contains_sequence(self, *items: _E | Matcher[_E]) -> _ListAssertion[_E]: ...
+        def contains_exactly(self, *items: _E | Matcher[_E]) -> _ListAssertion[_E]: ...
+        def contains_exactly_in_any_order(self, *items: _E | Matcher[_E]) -> _ListAssertion[_E]: ...
+        def is_sorted(
+            self, key: Callable[[_E], object] = ..., reverse: bool = ..., *, allow_empty: bool = ...
+        ) -> _ListAssertion[_E]: ...
+        def starts_with(self, prefix: _E) -> _ListAssertion[_E]: ...
+        def ends_with(self, suffix: _E) -> _ListAssertion[_E]: ...
+        def each(
+            self, matcher: Matcher[_E] | Callable[[_E], object], *, allow_empty: bool = ...
+        ) -> _ListAssertion[_E]: ...
+        def all_satisfy(
+            self, matcher: Matcher[_E] | Callable[[_E], object], *, allow_empty: bool = ...
+        ) -> _ListAssertion[_E]: ...
+        def any_satisfy(self, matcher: Matcher[_E] | Callable[[_E], object]) -> _ListAssertion[_E]: ...
+        def none_satisfy(self, matcher: Matcher[_E] | Callable[[_E], object]) -> _ListAssertion[_E]: ...
+        def satisfies_exactly(self, *matchers: Matcher[_E] | Callable[[_E], object]) -> _ListAssertion[_E]: ...
+        def satisfies_exactly_in_any_order(
+            self, *matchers: Matcher[_E] | Callable[[_E], object]
+        ) -> _ListAssertion[_E]: ...
+        def zip_satisfies(
+            self, other: Iterable[_Other], predicate: Callable[[_E, _Other], object], *, allow_empty: bool = ...
+        ) -> _ListAssertion[_E]: ...
+        def is_subset_of(self, *supersets: object, allow_empty: bool = ...) -> _ListAssertion[_E]: ...
+        def contains_duplicates(self) -> _ListAssertion[_E]: ...
+        def does_not_contain_duplicates(self) -> _ListAssertion[_E]: ...
+        def contains_only_once(self, *items: object) -> _ListAssertion[_E]: ...
+        def contains_in_order(self, *items: _E | Matcher[_E]) -> _ListAssertion[_E]: ...
+        def has_same_size_as(self, other: Sized) -> _ListAssertion[_E]: ...
+        def has_size_greater_than(self, size: SupportsIndex) -> _ListAssertion[_E]: ...
+        def has_size_less_than(self, size: SupportsIndex) -> _ListAssertion[_E]: ...
+        def has_size_between(self, low: SupportsIndex, high: SupportsIndex) -> _ListAssertion[_E]: ...
+        def is_empty(self) -> _ListAssertion[_E]: ...
+        def is_not_empty(self) -> _ListAssertion[_E]: ...
+        def is_equal_to(
+            self,
+            other: object,
+            *,
+            ignore: _KeySpecs | None = ...,
+            include: _KeySpecs | None = ...,
+            tolerance: float | None = ...,
+            rel: float | None = ...,
+            comparators: dict[Any, Callable[[Any, Any], Any]] | None = ...,
+            ignore_null: bool = ...,
+            strict_types: bool = ...,
+        ) -> _ListAssertion[_E]: ...
+        def is_not_equal_to(self, other: object) -> _ListAssertion[_E]: ...
+        def is_same_as(self, other: object) -> _ListAssertion[_E]: ...
+        def is_not_same_as(self, other: object) -> _ListAssertion[_E]: ...
+        def is_true(self) -> _ListAssertion[_E]: ...
+        def is_false(self) -> _ListAssertion[_E]: ...
+        def is_none(self) -> _ListAssertion[_E]: ...
+        def is_not_none(self) -> _ListAssertion[_E]: ...
+        def is_type_of(self, some_type: type) -> _ListAssertion[_E]: ...
+        def is_instance_of(self, some_class: ClassInfo) -> _ListAssertion[_E]: ...
+        def is_instance_of_any(self, *some_classes: ClassInfo) -> _ListAssertion[_E]: ...
+        def is_subclass_of(self, some_class: ClassInfo) -> _ListAssertion[_E]: ...
+        def is_length(self, length: SupportsIndex | Matcher[int]) -> _ListAssertion[_E]: ...
+        def is_length_between(self, low: SupportsIndex, high: SupportsIndex) -> _ListAssertion[_E]: ...
+        def is_callable(self) -> _ListAssertion[_E]: ...
+        def is_not_callable(self) -> _ListAssertion[_E]: ...
+        def is_iterable(self) -> _ListAssertion[_E]: ...
+        def is_not_iterable(self) -> _ListAssertion[_E]: ...
+        def satisfies(self, matcher: Matcher[Any] | Callable[[Any], object]) -> _ListAssertion[_E]: ...
+        def all_fields_satisfy(
+            self, matcher: Matcher[Any] | Callable[[Any], object], *, allow_empty: bool = ...
+        ) -> _ListAssertion[_E]: ...
+        def has_no_none_fields(self, *, allow_empty: bool = ...) -> _ListAssertion[_E]: ...
+        def is_in(self, *items: object) -> _ListAssertion[_E]: ...
+        def is_not_in(self, *items: object) -> _ListAssertion[_E]: ...
+        def snapshot(
+            self,
+            id: str | None = ...,
+            path: str = ...,
+            *,
+            ignore: _KeySpecs | None = ...,
+            include: _KeySpecs | None = ...,
+            tolerance: float | None = ...,
+            rel: float | None = ...,
+            comparators: dict[Any, Callable[[Any, Any], Any]] | None = ...,
+            placeholders: Mapping[Any, Matcher[Any] | Callable[[Any], object]] | None = ...,
+        ) -> _ListAssertion[_E]: ...
+        def matches_contract_snapshot(self, id: str | None = ..., path: str = ...) -> _ListAssertion[_E]: ...
+        def matches_inline(
+            self,
+            expected: object = ...,
+            *,
+            ignore: _KeySpecs | None = ...,
+            include: _KeySpecs | None = ...,
+            tolerance: float | None = ...,
+            rel: float | None = ...,
+            comparators: dict[Any, Callable[[Any, Any], Any]] | None = ...,
+            placeholders: Mapping[Any, Matcher[Any] | Callable[[Any], object]] | None = ...,
+        ) -> _ListAssertion[_E]: ...
+        def has_json_path(self, path: str) -> _ListAssertion[_E]: ...
+        def does_not_have_json_path(self, path: str) -> _ListAssertion[_E]: ...
+        def matches_json_schema(self, schema: dict[str, Any]) -> _ListAssertion[_E]: ...
+        def matches_json_schema_from_file(self, path: str | Path) -> _ListAssertion[_E]: ...
+        def conforms_to_openapi(
+            self,
+            spec: dict[str, Any],
+            path: str,
+            method: str,
+            *,
+            status: str | int | None = ...,
+            content_type: str = ...,
+            strict_nullable: bool = ...,
+        ) -> _ListAssertion[_E]: ...
+
+    class _NegatedTextAssertion(Protocol):
+        """The negation twin of `_TextAssertion`."""
+
+        def satisfies(self, matcher: Matcher[str] | Callable[[str], object]) -> _TextAssertion: ...
+        def contains(self, *items: str | Matcher[str]) -> _TextAssertion: ...
+        def is_equal_to_ignoring_case(self, other: str) -> _TextAssertion: ...
+        def is_equal_to_ignoring_whitespace(self, other: str) -> _TextAssertion: ...
+        def contains_ignoring_case(self, *items: str) -> _TextAssertion: ...
+        def starts_with(self, prefix: str) -> _TextAssertion: ...
+        def starts_with_ignoring_case(self, prefix: str) -> _TextAssertion: ...
+        def ends_with(self, suffix: str) -> _TextAssertion: ...
+        def ends_with_ignoring_case(self, suffix: str) -> _TextAssertion: ...
+        def matches(self, pattern: str | re.Pattern[str]) -> _TextAssertion: ...
+        def does_not_match(self, pattern: str | re.Pattern[str]) -> _TextAssertion: ...
+        def is_alpha(self) -> _TextAssertion: ...
+        def is_digit(self) -> _TextAssertion: ...
+        def is_lower(self) -> _TextAssertion: ...
+        def is_upper(self) -> _TextAssertion: ...
+        def is_alphanumeric(self) -> _TextAssertion: ...
+        def is_whitespace(self) -> _TextAssertion: ...
+        def contains_any_of(self, *items: str) -> _TextAssertion: ...
+        def contains_none_of(self, *items: str) -> _TextAssertion: ...
+        def is_unicode(self) -> _TextAssertion: ...
+        def is_greater_than(self, other: str) -> _TextAssertion: ...
+        def is_greater_than_or_equal_to(self, other: str) -> _TextAssertion: ...
+        def is_less_than(self, other: str) -> _TextAssertion: ...
+        def is_less_than_or_equal_to(self, other: str) -> _TextAssertion: ...
+        def does_not_contain(self, *items: str | Matcher[str]) -> _TextAssertion: ...
+        def contains_only(self, *items: str | Matcher[str]) -> _TextAssertion: ...
+        def contains_sequence(self, *items: str | Matcher[str]) -> _TextAssertion: ...
+        def contains_exactly(self, *items: str | Matcher[str]) -> _TextAssertion: ...
+        def contains_exactly_in_any_order(self, *items: str | Matcher[str]) -> _TextAssertion: ...
+        def is_sorted(
+            self, key: Callable[[str], object] = ..., reverse: bool = ..., *, allow_empty: bool = ...
+        ) -> _TextAssertion: ...
+        def each(
+            self, matcher: Matcher[str] | Callable[[str], object], *, allow_empty: bool = ...
+        ) -> _TextAssertion: ...
+        def all_satisfy(
+            self, matcher: Matcher[str] | Callable[[str], object], *, allow_empty: bool = ...
+        ) -> _TextAssertion: ...
+        def any_satisfy(self, matcher: Matcher[str] | Callable[[str], object]) -> _TextAssertion: ...
+        def none_satisfy(self, matcher: Matcher[str] | Callable[[str], object]) -> _TextAssertion: ...
+        def satisfies_exactly(self, *matchers: Matcher[str] | Callable[[str], object]) -> _TextAssertion: ...
+        def satisfies_exactly_in_any_order(
+            self, *matchers: Matcher[str] | Callable[[str], object]
+        ) -> _TextAssertion: ...
+        def zip_satisfies(
+            self, other: Iterable[_Other], predicate: Callable[[str, _Other], object], *, allow_empty: bool = ...
+        ) -> _TextAssertion: ...
+        def extracting_group(self, pattern: str | re.Pattern[str], group: int | str = ...) -> _TextAssertion: ...
+        def matches_with_groups(self, pattern: str | re.Pattern[str]) -> _TextAssertion: ...
+        def is_subset_of(self, *supersets: object, allow_empty: bool = ...) -> _TextAssertion: ...
+        def contains_duplicates(self) -> _TextAssertion: ...
+        def does_not_contain_duplicates(self) -> _TextAssertion: ...
+        def contains_only_once(self, *items: object) -> _TextAssertion: ...
+        def contains_in_order(self, *items: str | Matcher[str]) -> _TextAssertion: ...
+        def has_same_size_as(self, other: Sized) -> _TextAssertion: ...
+        def has_size_greater_than(self, size: SupportsIndex) -> _TextAssertion: ...
+        def has_size_less_than(self, size: SupportsIndex) -> _TextAssertion: ...
+        def has_size_between(self, low: SupportsIndex, high: SupportsIndex) -> _TextAssertion: ...
+        def is_empty(self) -> _TextAssertion: ...
+        def is_not_empty(self) -> _TextAssertion: ...
+        def is_equal_to(
+            self,
+            other: object,
+            *,
+            ignore: _KeySpecs | None = ...,
+            include: _KeySpecs | None = ...,
+            tolerance: float | None = ...,
+            rel: float | None = ...,
+            comparators: dict[Any, Callable[[Any, Any], Any]] | None = ...,
+            ignore_null: bool = ...,
+            strict_types: bool = ...,
+        ) -> _TextAssertion: ...
+        def is_not_equal_to(self, other: object) -> _TextAssertion: ...
+        def is_same_as(self, other: object) -> _TextAssertion: ...
+        def is_not_same_as(self, other: object) -> _TextAssertion: ...
+        def is_true(self) -> _TextAssertion: ...
+        def is_false(self) -> _TextAssertion: ...
+        def is_none(self) -> _TextAssertion: ...
+        def is_not_none(self) -> _TextAssertion: ...
+        def is_type_of(self, some_type: type) -> _TextAssertion: ...
+        def is_instance_of(self, some_class: ClassInfo) -> _TextAssertion: ...
+        def is_instance_of_any(self, *some_classes: ClassInfo) -> _TextAssertion: ...
+        def is_subclass_of(self, some_class: ClassInfo) -> _TextAssertion: ...
+        def is_length(self, length: SupportsIndex | Matcher[int]) -> _TextAssertion: ...
+        def is_length_between(self, low: SupportsIndex, high: SupportsIndex) -> _TextAssertion: ...
+        def is_callable(self) -> _TextAssertion: ...
+        def is_not_callable(self) -> _TextAssertion: ...
+        def is_iterable(self) -> _TextAssertion: ...
+        def is_not_iterable(self) -> _TextAssertion: ...
+        def all_fields_satisfy(
+            self, matcher: Matcher[Any] | Callable[[Any], object], *, allow_empty: bool = ...
+        ) -> _TextAssertion: ...
+        def has_no_none_fields(self, *, allow_empty: bool = ...) -> _TextAssertion: ...
+        def is_in(self, *items: object) -> _TextAssertion: ...
+        def is_not_in(self, *items: object) -> _TextAssertion: ...
+        def snapshot(
+            self,
+            id: str | None = ...,
+            path: str = ...,
+            *,
+            ignore: _KeySpecs | None = ...,
+            include: _KeySpecs | None = ...,
+            tolerance: float | None = ...,
+            rel: float | None = ...,
+            comparators: dict[Any, Callable[[Any, Any], Any]] | None = ...,
+            placeholders: Mapping[Any, Matcher[Any] | Callable[[Any], object]] | None = ...,
+        ) -> _TextAssertion: ...
+        def matches_contract_snapshot(self, id: str | None = ..., path: str = ...) -> _TextAssertion: ...
+        def matches_inline(
+            self,
+            expected: object = ...,
+            *,
+            ignore: _KeySpecs | None = ...,
+            include: _KeySpecs | None = ...,
+            tolerance: float | None = ...,
+            rel: float | None = ...,
+            comparators: dict[Any, Callable[[Any, Any], Any]] | None = ...,
+            placeholders: Mapping[Any, Matcher[Any] | Callable[[Any], object]] | None = ...,
+        ) -> _TextAssertion: ...
+
+    class _NegatedCoreAssertion(Protocol):
+        """The negation twin of `_CoreAssertion`."""
+
+        def is_equal_to(
+            self,
+            other: object,
+            *,
+            ignore: _KeySpecs | None = ...,
+            include: _KeySpecs | None = ...,
+            tolerance: float | None = ...,
+            rel: float | None = ...,
+            comparators: dict[Any, Callable[[Any, Any], Any]] | None = ...,
+            ignore_null: bool = ...,
+            strict_types: bool = ...,
+        ) -> _CoreAssertion: ...
+        def is_not_equal_to(self, other: object) -> _CoreAssertion: ...
+        def is_same_as(self, other: object) -> _CoreAssertion: ...
+        def is_not_same_as(self, other: object) -> _CoreAssertion: ...
+        def is_true(self) -> _CoreAssertion: ...
+        def is_false(self) -> _CoreAssertion: ...
+        def is_none(self) -> _CoreAssertion: ...
+        def is_not_none(self) -> _CoreAssertion: ...
+        def is_type_of(self, some_type: type) -> _CoreAssertion: ...
+        def is_instance_of(self, some_class: ClassInfo) -> _CoreAssertion: ...
+        def is_instance_of_any(self, *some_classes: ClassInfo) -> _CoreAssertion: ...
+        def is_subclass_of(self, some_class: ClassInfo) -> _CoreAssertion: ...
+        def is_length(self, length: SupportsIndex | Matcher[int]) -> _CoreAssertion: ...
+        def is_length_between(self, low: SupportsIndex, high: SupportsIndex) -> _CoreAssertion: ...
+        def is_callable(self) -> _CoreAssertion: ...
+        def is_not_callable(self) -> _CoreAssertion: ...
+        def is_iterable(self) -> _CoreAssertion: ...
+        def is_not_iterable(self) -> _CoreAssertion: ...
+        def satisfies(self, matcher: Matcher[Any] | Callable[[Any], object]) -> _CoreAssertion: ...
+        def all_fields_satisfy(
+            self, matcher: Matcher[Any] | Callable[[Any], object], *, allow_empty: bool = ...
+        ) -> _CoreAssertion: ...
+        def has_no_none_fields(self, *, allow_empty: bool = ...) -> _CoreAssertion: ...
+        def is_in(self, *items: object) -> _CoreAssertion: ...
+        def is_not_in(self, *items: object) -> _CoreAssertion: ...
+        def snapshot(
+            self,
+            id: str | None = ...,
+            path: str = ...,
+            *,
+            ignore: _KeySpecs | None = ...,
+            include: _KeySpecs | None = ...,
+            tolerance: float | None = ...,
+            rel: float | None = ...,
+            comparators: dict[Any, Callable[[Any, Any], Any]] | None = ...,
+            placeholders: Mapping[Any, Matcher[Any] | Callable[[Any], object]] | None = ...,
+        ) -> _CoreAssertion: ...
+        def matches_contract_snapshot(self, id: str | None = ..., path: str = ...) -> _CoreAssertion: ...
+        def matches_inline(
+            self,
+            expected: object = ...,
+            *,
+            ignore: _KeySpecs | None = ...,
+            include: _KeySpecs | None = ...,
+            tolerance: float | None = ...,
+            rel: float | None = ...,
+            comparators: dict[Any, Callable[[Any, Any], Any]] | None = ...,
+            placeholders: Mapping[Any, Matcher[Any] | Callable[[Any], object]] | None = ...,
+        ) -> _CoreAssertion: ...
+
+    class _NegatedCompletedAssertion(Protocol[_P_co]):
+        """The negation twin of `_CompletedAssertion`."""
+
+        def is_equal_to(
+            self,
+            other: object,
+            *,
+            ignore: _KeySpecs | None = ...,
+            include: _KeySpecs | None = ...,
+            tolerance: float | None = ...,
+            rel: float | None = ...,
+            comparators: dict[Any, Callable[[Any, Any], Any]] | None = ...,
+            ignore_null: bool = ...,
+            strict_types: bool = ...,
+        ) -> _CompletedAssertion[_P_co]: ...
+        def is_not_equal_to(self, other: object) -> _CompletedAssertion[_P_co]: ...
+        def is_same_as(self, other: object) -> _CompletedAssertion[_P_co]: ...
+        def is_not_same_as(self, other: object) -> _CompletedAssertion[_P_co]: ...
+        def is_true(self) -> _CompletedAssertion[_P_co]: ...
+        def is_false(self) -> _CompletedAssertion[_P_co]: ...
+        def is_none(self) -> _CompletedAssertion[_P_co]: ...
+        def is_not_none(self) -> _CompletedAssertion[_P_co]: ...
+        def is_type_of(self, some_type: type) -> _CompletedAssertion[_P_co]: ...
+        def is_instance_of(self, some_class: ClassInfo) -> _CompletedAssertion[_P_co]: ...
+        def is_instance_of_any(self, *some_classes: ClassInfo) -> _CompletedAssertion[_P_co]: ...
+        def is_subclass_of(self, some_class: ClassInfo) -> _CompletedAssertion[_P_co]: ...
+        def is_length(self, length: SupportsIndex | Matcher[int]) -> _CompletedAssertion[_P_co]: ...
+        def is_length_between(self, low: SupportsIndex, high: SupportsIndex) -> _CompletedAssertion[_P_co]: ...
+        def is_callable(self) -> _CompletedAssertion[_P_co]: ...
+        def is_not_callable(self) -> _CompletedAssertion[_P_co]: ...
+        def is_iterable(self) -> _CompletedAssertion[_P_co]: ...
+        def is_not_iterable(self) -> _CompletedAssertion[_P_co]: ...
+        def satisfies(self, matcher: Matcher[Any] | Callable[[Any], object]) -> _CompletedAssertion[_P_co]: ...
+        def all_fields_satisfy(
+            self, matcher: Matcher[Any] | Callable[[Any], object], *, allow_empty: bool = ...
+        ) -> _CompletedAssertion[_P_co]: ...
+        def has_no_none_fields(self, *, allow_empty: bool = ...) -> _CompletedAssertion[_P_co]: ...
+        def is_in(self, *items: object) -> _CompletedAssertion[_P_co]: ...
+        def is_not_in(self, *items: object) -> _CompletedAssertion[_P_co]: ...
+        def snapshot(
+            self,
+            id: str | None = ...,
+            path: str = ...,
+            *,
+            ignore: _KeySpecs | None = ...,
+            include: _KeySpecs | None = ...,
+            tolerance: float | None = ...,
+            rel: float | None = ...,
+            comparators: dict[Any, Callable[[Any, Any], Any]] | None = ...,
+            placeholders: Mapping[Any, Matcher[Any] | Callable[[Any], object]] | None = ...,
+        ) -> _CompletedAssertion[_P_co]: ...
+        def matches_contract_snapshot(self, id: str | None = ..., path: str = ...) -> _CompletedAssertion[_P_co]: ...
+        def matches_inline(
+            self,
+            expected: object = ...,
+            *,
+            ignore: _KeySpecs | None = ...,
+            include: _KeySpecs | None = ...,
+            tolerance: float | None = ...,
+            rel: float | None = ...,
+            comparators: dict[Any, Callable[[Any, Any], Any]] | None = ...,
+            placeholders: Mapping[Any, Matcher[Any] | Callable[[Any], object]] | None = ...,
+        ) -> _CompletedAssertion[_P_co]: ...
+
+    class _NegatedInvokedAssertion(Protocol[_Exc]):
+        """The negation twin of `_InvokedAssertion`."""
+
+        @overload
+        def caused_by(self, ex: type[_Landed]) -> _InvokedAssertion[_Exc]: ...
+        @overload
+        def caused_by(self, ex: ClassInfo) -> _InvokedAssertion[_Exc]: ...
+        @overload
+        def error_of(self, ex: type[_Landed]) -> _InvokedAssertion[_Exc]: ...
+        @overload
+        def error_of(self, ex: type) -> _InvokedAssertion[_Exc]: ...
+        def does_not_contain_error(self, *ex_types: type | ExceptionInfo) -> _InvokedAssertion[_Exc]: ...
+        @overload
+        def has_root_cause(self, ex: type[_Landed]) -> _InvokedAssertion[_Exc]: ...
+        @overload
+        def has_root_cause(self, ex: ClassInfo) -> _InvokedAssertion[_Exc]: ...
+        def contains_error(self, *ex_types: type | ExceptionInfo) -> _InvokedAssertion[_Exc]: ...
+        def matches_error_tree(self, *expected: type | list[Any]) -> _InvokedAssertion[_Exc]: ...
+        def satisfies(self, matcher: Matcher[str] | Callable[[str], object]) -> _InvokedAssertion[_Exc]: ...
+        def contains(self, *items: str | Matcher[str]) -> _InvokedAssertion[_Exc]: ...
+        def is_equal_to_ignoring_case(self, other: str) -> _InvokedAssertion[_Exc]: ...
+        def is_equal_to_ignoring_whitespace(self, other: str) -> _InvokedAssertion[_Exc]: ...
+        def contains_ignoring_case(self, *items: str) -> _InvokedAssertion[_Exc]: ...
+        def starts_with(self, prefix: str) -> _InvokedAssertion[_Exc]: ...
+        def starts_with_ignoring_case(self, prefix: str) -> _InvokedAssertion[_Exc]: ...
+        def ends_with(self, suffix: str) -> _InvokedAssertion[_Exc]: ...
+        def ends_with_ignoring_case(self, suffix: str) -> _InvokedAssertion[_Exc]: ...
+        def matches(self, pattern: str | re.Pattern[str]) -> _InvokedAssertion[_Exc]: ...
+        def does_not_match(self, pattern: str | re.Pattern[str]) -> _InvokedAssertion[_Exc]: ...
+        def is_alpha(self) -> _InvokedAssertion[_Exc]: ...
+        def is_digit(self) -> _InvokedAssertion[_Exc]: ...
+        def is_lower(self) -> _InvokedAssertion[_Exc]: ...
+        def is_upper(self) -> _InvokedAssertion[_Exc]: ...
+        def is_alphanumeric(self) -> _InvokedAssertion[_Exc]: ...
+        def is_whitespace(self) -> _InvokedAssertion[_Exc]: ...
+        def contains_any_of(self, *items: str) -> _InvokedAssertion[_Exc]: ...
+        def contains_none_of(self, *items: str) -> _InvokedAssertion[_Exc]: ...
+        def is_unicode(self) -> _InvokedAssertion[_Exc]: ...
+        def is_greater_than(self, other: str) -> _InvokedAssertion[_Exc]: ...
+        def is_greater_than_or_equal_to(self, other: str) -> _InvokedAssertion[_Exc]: ...
+        def is_less_than(self, other: str) -> _InvokedAssertion[_Exc]: ...
+        def is_less_than_or_equal_to(self, other: str) -> _InvokedAssertion[_Exc]: ...
+        def does_not_contain(self, *items: str | Matcher[str]) -> _InvokedAssertion[_Exc]: ...
+        def contains_only(self, *items: str | Matcher[str]) -> _InvokedAssertion[_Exc]: ...
+        def contains_sequence(self, *items: str | Matcher[str]) -> _InvokedAssertion[_Exc]: ...
+        def contains_exactly(self, *items: str | Matcher[str]) -> _InvokedAssertion[_Exc]: ...
+        def contains_exactly_in_any_order(self, *items: str | Matcher[str]) -> _InvokedAssertion[_Exc]: ...
+        def is_sorted(
+            self, key: Callable[[str], object] = ..., reverse: bool = ..., *, allow_empty: bool = ...
+        ) -> _InvokedAssertion[_Exc]: ...
+        def each(
+            self, matcher: Matcher[str] | Callable[[str], object], *, allow_empty: bool = ...
+        ) -> _InvokedAssertion[_Exc]: ...
+        def all_satisfy(
+            self, matcher: Matcher[str] | Callable[[str], object], *, allow_empty: bool = ...
+        ) -> _InvokedAssertion[_Exc]: ...
+        def any_satisfy(self, matcher: Matcher[str] | Callable[[str], object]) -> _InvokedAssertion[_Exc]: ...
+        def none_satisfy(self, matcher: Matcher[str] | Callable[[str], object]) -> _InvokedAssertion[_Exc]: ...
+        def satisfies_exactly(self, *matchers: Matcher[str] | Callable[[str], object]) -> _InvokedAssertion[_Exc]: ...
+        def satisfies_exactly_in_any_order(
+            self, *matchers: Matcher[str] | Callable[[str], object]
+        ) -> _InvokedAssertion[_Exc]: ...
+        def zip_satisfies(
+            self, other: Iterable[_Other], predicate: Callable[[str, _Other], object], *, allow_empty: bool = ...
+        ) -> _InvokedAssertion[_Exc]: ...
+        def extracting_group(
+            self, pattern: str | re.Pattern[str], group: int | str = ...
+        ) -> _InvokedAssertion[_Exc]: ...
+        def matches_with_groups(self, pattern: str | re.Pattern[str]) -> _InvokedAssertion[_Exc]: ...
+        def is_subset_of(self, *supersets: object, allow_empty: bool = ...) -> _InvokedAssertion[_Exc]: ...
+        def contains_duplicates(self) -> _InvokedAssertion[_Exc]: ...
+        def does_not_contain_duplicates(self) -> _InvokedAssertion[_Exc]: ...
+        def contains_only_once(self, *items: object) -> _InvokedAssertion[_Exc]: ...
+        def contains_in_order(self, *items: str | Matcher[str]) -> _InvokedAssertion[_Exc]: ...
+        def has_same_size_as(self, other: Sized) -> _InvokedAssertion[_Exc]: ...
+        def has_size_greater_than(self, size: SupportsIndex) -> _InvokedAssertion[_Exc]: ...
+        def has_size_less_than(self, size: SupportsIndex) -> _InvokedAssertion[_Exc]: ...
+        def has_size_between(self, low: SupportsIndex, high: SupportsIndex) -> _InvokedAssertion[_Exc]: ...
+        def is_empty(self) -> _InvokedAssertion[_Exc]: ...
+        def is_not_empty(self) -> _InvokedAssertion[_Exc]: ...
+        def is_equal_to(
+            self,
+            other: object,
+            *,
+            ignore: _KeySpecs | None = ...,
+            include: _KeySpecs | None = ...,
+            tolerance: float | None = ...,
+            rel: float | None = ...,
+            comparators: dict[Any, Callable[[Any, Any], Any]] | None = ...,
+            ignore_null: bool = ...,
+            strict_types: bool = ...,
+        ) -> _InvokedAssertion[_Exc]: ...
+        def is_not_equal_to(self, other: object) -> _InvokedAssertion[_Exc]: ...
+        def is_same_as(self, other: object) -> _InvokedAssertion[_Exc]: ...
+        def is_not_same_as(self, other: object) -> _InvokedAssertion[_Exc]: ...
+        def is_true(self) -> _InvokedAssertion[_Exc]: ...
+        def is_false(self) -> _InvokedAssertion[_Exc]: ...
+        def is_none(self) -> _InvokedAssertion[_Exc]: ...
+        def is_not_none(self) -> _InvokedAssertion[_Exc]: ...
+        def is_type_of(self, some_type: type) -> _InvokedAssertion[_Exc]: ...
+        def is_instance_of(self, some_class: ClassInfo) -> _InvokedAssertion[_Exc]: ...
+        def is_instance_of_any(self, *some_classes: ClassInfo) -> _InvokedAssertion[_Exc]: ...
+        def is_subclass_of(self, some_class: ClassInfo) -> _InvokedAssertion[_Exc]: ...
+        def is_length(self, length: SupportsIndex | Matcher[int]) -> _InvokedAssertion[_Exc]: ...
+        def is_length_between(self, low: SupportsIndex, high: SupportsIndex) -> _InvokedAssertion[_Exc]: ...
+        def is_callable(self) -> _InvokedAssertion[_Exc]: ...
+        def is_not_callable(self) -> _InvokedAssertion[_Exc]: ...
+        def is_iterable(self) -> _InvokedAssertion[_Exc]: ...
+        def is_not_iterable(self) -> _InvokedAssertion[_Exc]: ...
+        def all_fields_satisfy(
+            self, matcher: Matcher[Any] | Callable[[Any], object], *, allow_empty: bool = ...
+        ) -> _InvokedAssertion[_Exc]: ...
+        def has_no_none_fields(self, *, allow_empty: bool = ...) -> _InvokedAssertion[_Exc]: ...
+        def is_in(self, *items: object) -> _InvokedAssertion[_Exc]: ...
+        def is_not_in(self, *items: object) -> _InvokedAssertion[_Exc]: ...
+        def snapshot(
+            self,
+            id: str | None = ...,
+            path: str = ...,
+            *,
+            ignore: _KeySpecs | None = ...,
+            include: _KeySpecs | None = ...,
+            tolerance: float | None = ...,
+            rel: float | None = ...,
+            comparators: dict[Any, Callable[[Any, Any], Any]] | None = ...,
+            placeholders: Mapping[Any, Matcher[Any] | Callable[[Any], object]] | None = ...,
+        ) -> _InvokedAssertion[_Exc]: ...
+        def matches_contract_snapshot(self, id: str | None = ..., path: str = ...) -> _InvokedAssertion[_Exc]: ...
+        def matches_inline(
+            self,
+            expected: object = ...,
+            *,
+            ignore: _KeySpecs | None = ...,
+            include: _KeySpecs | None = ...,
+            tolerance: float | None = ...,
+            rel: float | None = ...,
+            comparators: dict[Any, Callable[[Any, Any], Any]] | None = ...,
+            placeholders: Mapping[Any, Matcher[Any] | Callable[[Any], object]] | None = ...,
+        ) -> _InvokedAssertion[_Exc]: ...