//! Handle resolution module for AT Protocol identity resolution.
//!
//! This module provides various implementations of handle-to-DID resolution
//! with different caching strategies.
//!
//! # Architecture
//!
//! The module is structured around the [`HandleResolver`] trait with multiple
//! implementations:
//!
//! - [`BaseHandleResolver`]: Core resolver that performs actual DNS/HTTP lookups
//! - [`RateLimitedHandleResolver`]: Rate limiting wrapper using semaphore-based concurrency control
//! - [`CachingHandleResolver`]: In-memory caching wrapper with configurable TTL
//! - [`RedisHandleResolver`]: Redis-backed persistent caching with binary serialization
//! - [`SqliteHandleResolver`]: SQLite-backed persistent caching for single-instance deployments
//!
//! # Example Usage
//!
//! ```no_run
//! use std::sync::Arc;
//! use quickdid::handle_resolver::{create_base_resolver, create_caching_resolver, HandleResolver};
//! use quickdid::metrics::NoOpMetricsPublisher;
//!
//! # async fn example() -> Result<(), Box<dyn std::error::Error>> {
//! # use atproto_identity::resolve::HickoryDnsResolver;
//! # use reqwest::Client;
//! # let dns_resolver = Arc::new(HickoryDnsResolver::create_resolver(&[]));
//! # let http_client = Client::new();
//! # let metrics = Arc::new(NoOpMetricsPublisher);
//! // Create base resolver using factory function
//! let base = create_base_resolver(
//!     dns_resolver,
//!     http_client,
//!     metrics.clone(),
//! );
//!
//! // Wrap with in-memory caching
//! let resolver = create_caching_resolver(base, 300, metrics);
//!
//! // Resolve a handle
//! let did = resolver.resolve("alice.bsky.social").await?;
//! # Ok(())
//! # }
//! ```

// Module structure
mod base;
mod errors;
mod memory;
mod proactive_refresh;
mod rate_limited;
mod redis;
mod sqlite;
mod traits;

// Re-export public API
pub use errors::HandleResolverError;
pub use traits::HandleResolver;

// Factory functions for creating resolvers
pub use base::create_base_resolver;
pub use memory::create_caching_resolver;
pub use proactive_refresh::{
    ProactiveRefreshResolver, create_proactive_refresh_resolver,
    create_proactive_refresh_resolver_dyn, create_proactive_refresh_resolver_with_metrics,
    create_proactive_refresh_resolver_with_threshold,
};
pub use rate_limited::{create_rate_limited_resolver, create_rate_limited_resolver_with_timeout};
pub use redis::{create_redis_resolver, create_redis_resolver_with_ttl};
pub use sqlite::{create_sqlite_resolver, create_sqlite_resolver_with_ttl};