disallowed-methods = [

{ path = "rand::thread_rng", reason = "Do not use rand::* directly. Instead, use functions from random.rs" },

# We still have `std::fs` references.

# { path = "std::fs", reason = "Do not use std::fs directly. Instead, use the FileStorageProvider." },

{ path = "vfs::PhysicalFS::new", reason = "Do not use vfs::PhysicalFS in tests. Instead, use the VirtualStorageProvider::new_overlay()." },

# NOTE: `allow-invalid` because this method is gated behind a feature.

{ path = "diskann_providers::storage::virtual_storage_provider::VirtualStorageProvider::new_physical", reason = "Do not use VirtualStorageProvider::new_physical() in tests. Instead, use VirtualStorageProvider::new_overlay().", allow-invalid = true },

# Disallowed methods for the rayon crate to enforce execution within a specified thread pool instead of the global thread pool.

{ path = "rayon::iter::ParallelIterator::for_each", reason = "Use `for_each_in_pool` from rayon_utils.rs instead to enforce execution within a specified thread pool."},

{ path = "rayon::iter::ParallelIterator::for_each_with", reason = "Use `for_each_with_in_pool` instead to enforce execution within a specified thread pool."},

{ path = "rayon::iter::ParallelIterator::for_each_init", reason = "Use `for_each_init_in_pool` instead to enforce execution within a specified thread pool."},

{ path = "rayon::iter::ParallelIterator::try_for_each", reason = "Use `try_for_each_in_pool` from rayon_utils.rs instead to enforce execution within a specified thread pool."},

{ path = "rayon::iter::ParallelIterator::try_for_each_with", reason = "Use `try_for_each_with_in_pool` instead to enforce execution within a specified thread pool."},

{ path = "rayon::iter::ParallelIterator::try_for_each_init", reason = "Use `try_for_each_init_in_pool` instead to enforce execution within a specified thread pool."},

{ path = "rayon::iter::ParallelIterator::count", reason = "Use `count_in_pool` instead to enforce execution within a specified thread pool."},

{ path = "rayon::iter::ParallelIterator::collect", reason = "Use `collect_in_pool` from rayon_utils.rs instead to enforce execution within a specified thread pool."},

{ path = "rayon::iter::ParallelIterator::sum", reason = "Use `sum_in_pool` from rayon_utils.rs instead to enforce execution within a specified thread pool."},

# Skip rayon::iter::ParallelIterator::map since it doesn’t execute immediately—it’s a lazy operation that only transforms each element when the iterator is ultimately consumed (e.g., by for_each, collect, etc.).

{ path = "rayon::iter::ParallelIterator::reduce", reason = "Implement `reduce_in_pool` similar to `for_each_in_pool` in rayon_util.rs to enforce execution within a specified thread pool."},

{ path = "rayon::iter::ParallelIterator::reduce_with", reason = "Implement `reduce_with_in_pool` similar to `for_each_in_pool` in rayon_util.rs to enforce execution within a specified thread pool."},

{ path = "rayon::iter::ParallelIterator::try_reduce", reason = "Implement `try_reduce_in_pool` similar to `for_each_in_pool` in rayon_util.rs to enforce execution within a specified thread pool."},

{ path = "rayon::iter::ParallelIterator::try_reduce_with", reason = "Implement `try_reduce_with_in_pool` similar to `for_each_in_pool` in rayon_util.rs to enforce execution within a specified thread pool."},

{ path = "rayon::iter::ParallelIterator::product", reason = "Implement `product_in_pool` similar to `for_each_in_pool` in rayon_util.rs to enforce execution within a specified thread pool."},

{ path = "rayon::iter::ParallelIterator::min", reason = "Implement `min_in_pool` similar to `for_each_in_pool` in rayon_util.rs to enforce execution within a specified thread pool."},

{ path = "rayon::iter::ParallelIterator::min_by", reason = "Implement `min_by_in_pool` similar to `for_each_in_pool` in rayon_util.rs to enforce execution within a specified thread pool."},

{ path = "rayon::iter::ParallelIterator::min_by_key", reason = "Implement `min_by_key_in_pool` similar to `for_each_in_pool` in rayon_util.rs to enforce execution within a specified thread pool."},

{ path = "rayon::iter::ParallelIterator::max", reason = "Implement `max_in_pool` similar to `for_each_in_pool` in rayon_util.rs to enforce execution within a specified thread pool."},

{ path = "rayon::iter::ParallelIterator::max_by", reason = "Implement `max_by_in_pool` similar to `for_each_in_pool` in rayon_util.rs to enforce execution within a specified thread pool."},

{ path = "rayon::iter::ParallelIterator::max_by_key", reason = "Implement `max_by_key_in_pool` similar to `for_each_in_pool` in rayon_util.rs to enforce execution within a specified thread pool."},

{ path = "rayon::iter::ParallelIterator::find_any", reason = "Implement `find_any_in_pool` similar to `for_each_in_pool` in rayon_util.rs to enforce execution within a specified thread pool."},

{ path = "rayon::iter::ParallelIterator::find_first", reason = "Implement `find_first_in_pool` similar to `for_each_in_pool` in rayon_util.rs to enforce execution within a specified thread pool."},

{ path = "rayon::iter::ParallelIterator::find_last", reason = "Implement `find_last_in_pool` similar to `for_each_in_pool` in rayon_util.rs to enforce execution within a specified thread pool."},

{ path = "rayon::iter::ParallelIterator::find_map_any", reason = "Implement `find_map_any_in_pool` similar to `for_each_in_pool` in rayon_util.rs to enforce execution within a specified thread pool."},

{ path = "rayon::iter::ParallelIterator::find_map_first", reason = "Implement `find_map_first_in_pool` similar to `for_each_in_pool` in rayon_util.rs to enforce execution within a specified thread pool."},

{ path = "rayon::iter::ParallelIterator::find_map_last", reason = "Implement `find_map_last_in_pool` similar to `for_each_in_pool` in rayon_util.rs to enforce execution within a specified thread pool."},

{ path = "rayon::iter::ParallelIterator::any", reason = "Implement `any_in_pool` similar to `for_each_in_pool` in rayon_util.rs to enforce execution within a specified thread pool."},

{ path = "rayon::iter::ParallelIterator::all", reason = "Implement `all_in_pool` similar to `for_each_in_pool` in rayon_util.rs to enforce execution within a specified thread pool."},

{ path = "rayon::iter::ParallelIterator::unzip", reason = "Implement `unzip_in_pool` similar to `for_each_in_pool` in rayon_util.rs to enforce execution within a specified thread pool."},

{ path = "rayon::iter::ParallelIterator::partition", reason = "Implement `partition_in_pool` similar to `for_each_in_pool` in rayon_util.rs to enforce execution within a specified thread pool."},

{ path = "rayon::iter::ParallelIterator::partition_map", reason = "Implement `partition_map_in_pool` similar to `for_each_in_pool` in rayon_util.rs to enforce execution within a specified thread pool."},

{ path = "rayon::iter::ParallelIterator::collect_vec_list", reason = "Implement `collect_vec_list_in_pool` similar to `for_each_in_pool` in rayon_util.rs to enforce execution within a specified thread pool."},

{ path = "rayon::iter::ParallelIterator::opt_len", reason = "Implement `opt_len_in_pool` similar to `for_each_in_pool` in rayon_util.rs to enforce execution within a specified thread pool."}

]