[
  # unwrap_response and unwrap_stream_response return partial response maps (without telemetry).
  # The telemetry field is added by the caller via Map.put, which Dialyzer cannot track.
  {"lib/pyex/lambda.ex", :invalid_contract},
  # drain_streaming_chunks receives the response body as term(), pattern-matches
  # {:iterator, id}, and passes id to drain_generator_iter(non_neg_integer(), ...).
  # Dialyzer cannot narrow id from any() to non_neg_integer() through the pattern
  # match alone; at runtime id is always a non_neg_integer() as produced by the
  # iterator pool. This is a false positive.
  {"lib/pyex/lambda.ex", :call},
  # MapSet is an opaque type. Dialyzer complains when it appears in struct fields
  # because it cannot see through the opaque boundary. The capabilities MapSet is
  # used correctly via MapSet.member?/2 and MapSet.new/1 -- these are false positives.
  # The specific warning types and affected files differ between Elixir/OTP versions;
  # entries that don't trigger on a given version are silently ignored, so do NOT
  # prune these based on a `mix dialyzer --list-unused-filters` report from a
  # single version.
  {"lib/pyex/interpreter.ex", :call_without_opaque},
  {"lib/pyex/stdlib/jinja2.ex", :call_without_opaque},
  {"lib/pyex/stdlib/dataclasses.ex", :call_without_opaque},
  {"lib/pyex/stdlib/csv.ex", :call_without_opaque},
  {"lib/pyex/filesystem/memory.ex", :call_without_opaque},
  {"lib/pyex/filesystem/memory.ex", :contract_with_opaque},
  {"lib/pyex/interpreter/call_support.ex", :call_without_opaque},
  {"lib/pyex/methods.ex", :call_without_opaque},
  {"lib/pyex/parser/scope_resolve.ex", :call_without_opaque},
  # `@spec ... :: MapSet.t(String.t())` on the analyzer's helpers
  # surfaces `contract_with_opaque` on Elixir 1.19's older Dialyzer
  # but is silent on 1.20.  MapSet's parameterized type is opaque;
  # the analyzer never constructs MapSet values outside the module.
  {"lib/pyex/parser/scope_resolve.ex", :contract_with_opaque},
  # The with-statement eval clause calls eval/3 on the context manager expression,
  # but Dialyzer cannot narrow the union type through pattern matching on
  # {:with, _, [expr, as_name, body]} and thinks expr could be an atom.
  {"lib/pyex/interpreter.ex", :call},
  # defaultdict auto-insert returns a 5-tuple {:defaultdict_auto_insert, ...} from
  # eval_subscript. Dialyzer cannot trace this tagged tuple through the case match.
  {"lib/pyex/interpreter.ex", :pattern_match},
  # extract_exception_type_name/1 and with_update_cm/3 are called from the
  # {:with, ...} eval clause but Dialyzer's call graph analysis cannot trace
  # through the complex union-typed control flow. Both are genuinely reachable.
  {"lib/pyex/interpreter.ex", :unused_fun},
  # call_dunder/call_dunder_mut return {:exception, _} inside the {:ok, ...} tuple.
  # {:exception, _} is a control-flow signal, not a pyvalue(), so Dialyzer sees
  # the pattern match as impossible. These are reachable at runtime.
  {"lib/pyex/interpreter/builtin_results.ex", :pattern_match},
  # eval_param_defaults wraps evaluated defaults in {:__evaluated__, val}.
  # Parser.param() type does not include this wrapper, but it is valid at runtime.
  {"lib/pyex/interpreter/call_support.ex", :pattern_match},
  # resume_generator can return {:yielded, val, cont, gen_env, ctx} at runtime
  # (in defer mode). Dialyzer's type inference doesn't fully track this path.
  {"lib/pyex/interpreter/dunder.ex", :pattern_match},
  # Defensive fallback patterns in json encoding: format_decode_error's
  # catch-all and indent_at's non-integer indent branch are unreachable
  # given the current call sites, but kept as guards for future inputs.
  {"lib/pyex/stdlib/json.ex", :pattern_match_cov},
  # `decimal_round_with_mode/3` accepts `:round_05up` for CPython's
  # ROUND_05UP behaviour, but Dialyzer infers the mode argument as the
  # narrower `Decimal.rounding()` union (which excludes `:round_05up`)
  # because it traces through `Decimal.Context.get().rounding`. The
  # `:round_05up` clause IS reached at runtime via the user-supplied
  # rounding-mode string.
  {"lib/pyex/methods.ex", :guard_fail}
]
