namespace kcenon::thread {

// Primary API: General-purpose adaptive queue
class adaptive_job_queue : public scheduler_interface {
public:
    explicit adaptive_job_queue(policy p = policy::balanced);
    
    // Optional: Type-safe submission
    template<typename JobType>
    auto enqueue(JobType&& job) -> common::VoidResult;
    
    // ...existing API...
};

// Secondary API: When blocking is required
class job_queue : public scheduler_interface {
public:
    explicit job_queue(std::optional<size_t> max_size = std::nullopt);
    
    // Optional: Type-safe submission  
    template<typename JobType>
    auto enqueue(JobType&& job) -> common::VoidResult;
    
    // ...existing API with optional bounds...
};

// Internal implementations (hidden)
namespace detail {
    template<typename T>
    class concurrent_queue { ... };  // MPMC
    
    class lockfree_job_queue { ... }; // Lock-free job queue
}

} // namespace kcenon::thread

// Recommended: Most use cases
auto queue = std::make_unique<adaptive_job_queue>();

// Only when blocking wait is required
auto blocking = std::make_shared<job_queue>();

// With size limit (optional)
auto bounded = std::make_shared<job_queue>(/*max_size=*/1000);

namespace detail {
    // Move these here
    class lockfree_job_queue { ... };
    template<typename T> class concurrent_queue { ... };
}

template<typename T>
class [[deprecated("Use adaptive_job_queue with template enqueue")]] 
    typed_job_queue_t { ... };

class job_queue {
public:
    explicit job_queue(std::optional<size_t> max_size = std::nullopt);
    // If max_size is set, behaves like bounded_job_queue
};