reasoninglayer 1.0.3

//! The top-level [`ReasoningLayerClient`].

use crate::config::ClientConfig;
use crate::error::Error;
use crate::http::HttpClient;
use crate::resources::{
    AdminClient, AnalysisClient, ContextClient, DiscoveryClient, ExtractClient, FunctionsClient,
    GenerationClient, HealthClient, ImageExtractionClient, InferenceClient, OntologyClient,
    OptimizeClient, OsfqlClient, PreferencesClient, QueryClient, RagClient, RlTrainingClient,
    RowClient, ScenariosClient, SortsClient, SourcesClient, SpacesClient, TermsClient, UiClient,
};

/// Main entry point for the Reasoning Layer API.
///
/// Construct with [`ClientConfig`], then access per-resource sub-clients via the
/// accessor methods. A few friendly aliases are provided for the most common resources:
///
/// | Canonical | Alias |
/// | --- | --- |
/// | [`sorts`](Self::sorts) | [`types`](Self::types) |
/// | [`terms`](Self::terms) | [`records`](Self::records) |
/// | [`inference`](Self::inference) | [`rules`](Self::rules) |
#[derive(Debug, Clone)]
pub struct ReasoningLayerClient {
    sorts: SortsClient,
    terms: TermsClient,
    inference: InferenceClient,
    query: QueryClient,
    fuzzy: crate::resources_phase2::FuzzyClient,
    constraints: crate::resources_phase2::ConstraintsClient,
    namespaces: crate::resources_phase2::NamespacesClient,
    collections: crate::resources_phase2::CollectionsClient,
    causal: crate::resources_phase2::CausalClient,
    statistical: crate::resources_phase2::StatisticalClient,
    communities: crate::resources_phase2::CommunitiesClient,
    visualization: crate::resources_phase2::VisualizationClient,
    reasoning: crate::resources_phase2::ReasoningClient,
    control: crate::resources_phase2::ControlClient,
    reviews: crate::resources_phase2::ReviewsClient,
    action_reviews: crate::resources_phase2::ActionReviewsClient,
    webhook_actions: crate::resources_phase2::WebhookActionsClient,
    ilp: crate::resources_phase2::IlpClient,
    cdl: crate::resources_phase2::CdlClient,
    synthetic: crate::resources_phase2::SyntheticClient,
    utilities: crate::resources_phase2::UtilitiesClient,
    ingestion: crate::resources_phase2::IngestionClient,
    execution: crate::resources_phase2::ExecutionClient,
    proof_engine: crate::resources_phase2::ProofEngineClient,
    conversation: crate::resources_phase2::ConversationClient,
    research: crate::resources_phase2::ResearchClient,
    cognitive: crate::resources_phase2::CognitiveClient,
    oversight: crate::resources_phase2::OversightClient,
    neuro_symbolic: crate::resources_phase2::NeuroSymbolicClient,
    health: HealthClient,
    admin: AdminClient,
    osfql: OsfqlClient,
    context: ContextClient,
    rl_training: RlTrainingClient,
    rag: RagClient,
    generation: GenerationClient,
    image_extraction: ImageExtractionClient,
    extract: ExtractClient,
    preferences: PreferencesClient,
    discovery: DiscoveryClient,
    functions: FunctionsClient,
    ontology: OntologyClient,
    analysis: AnalysisClient,
    scenarios: ScenariosClient,
    spaces: SpacesClient,
    row: RowClient,
    sources: SourcesClient,
    ui: UiClient,
    optimize: OptimizeClient,
}

impl ReasoningLayerClient {
    /// Build a client from a [`ClientConfig`].
    pub fn new(config: ClientConfig) -> Result<Self, Error> {
        let resolved = config.resolve()?;
        let http = HttpClient::new(resolved)?;
        let p2 = crate::resources_phase2::build_all(&http);
        Ok(Self {
            sorts: SortsClient::new(http.clone()),
            terms: TermsClient::new(http.clone()),
            inference: InferenceClient::new(http.clone()),
            query: QueryClient::new(http.clone()),
            fuzzy: p2.fuzzy,
            constraints: p2.constraints,
            namespaces: p2.namespaces,
            collections: p2.collections,
            causal: p2.causal,
            statistical: p2.statistical,
            communities: p2.communities,
            visualization: p2.visualization,
            reasoning: p2.reasoning,
            control: p2.control,
            reviews: p2.reviews,
            action_reviews: p2.action_reviews,
            webhook_actions: p2.webhook_actions,
            ilp: p2.ilp,
            cdl: p2.cdl,
            synthetic: p2.synthetic,
            utilities: p2.utilities,
            ingestion: p2.ingestion,
            execution: p2.execution,
            proof_engine: p2.proof_engine,
            conversation: p2.conversation,
            research: p2.research,
            cognitive: p2.cognitive,
            oversight: p2.oversight,
            neuro_symbolic: p2.neuro_symbolic,
            health: HealthClient::new(http.clone()),
            admin: AdminClient::new(http.clone()),
            osfql: OsfqlClient::new(http.clone()),
            context: ContextClient::new(http.clone()),
            rl_training: RlTrainingClient::new(http.clone()),
            rag: RagClient::new(http.clone()),
            generation: GenerationClient::new(http.clone()),
            image_extraction: ImageExtractionClient::new(http.clone()),
            extract: ExtractClient::new(http.clone()),
            preferences: PreferencesClient::new(http.clone()),
            discovery: DiscoveryClient::new(http.clone()),
            functions: FunctionsClient::new(http.clone()),
            ontology: OntologyClient::new(http.clone()),
            analysis: AnalysisClient::new(http.clone()),
            scenarios: ScenariosClient::new(http.clone()),
            spaces: SpacesClient::new(http.clone()),
            row: RowClient::new(http.clone()),
            sources: SourcesClient::new(http.clone()),
            ui: UiClient::new(http.clone()),
            optimize: OptimizeClient::new(http),
        })
    }

    /// Access the underlying HTTP client (used by SSE helpers).
    pub(crate) fn http(&self) -> &HttpClient {
        self.sorts.http()
    }

    // ─── Phase 1 resources ────────────────────────────────────────────────
    pub fn sorts(&self) -> &SortsClient {
        &self.sorts
    }
    pub fn terms(&self) -> &TermsClient {
        &self.terms
    }
    pub fn inference(&self) -> &InferenceClient {
        &self.inference
    }
    pub fn query(&self) -> &QueryClient {
        &self.query
    }

    // ─── Friendly aliases ─────────────────────────────────────────────────
    pub fn types(&self) -> &SortsClient {
        &self.sorts
    }
    pub fn records(&self) -> &TermsClient {
        &self.terms
    }
    pub fn rules(&self) -> &InferenceClient {
        &self.inference
    }
    pub fn agents(&self) -> &crate::resources_phase2::CognitiveClient {
        &self.cognitive
    }

    // ─── Phase 2 analysis / reasoning / data ops ──────────────────────────
    pub fn fuzzy(&self) -> &crate::resources_phase2::FuzzyClient {
        &self.fuzzy
    }
    pub fn constraints(&self) -> &crate::resources_phase2::ConstraintsClient {
        &self.constraints
    }
    pub fn namespaces(&self) -> &crate::resources_phase2::NamespacesClient {
        &self.namespaces
    }
    pub fn collections(&self) -> &crate::resources_phase2::CollectionsClient {
        &self.collections
    }
    pub fn causal(&self) -> &crate::resources_phase2::CausalClient {
        &self.causal
    }
    pub fn statistical(&self) -> &crate::resources_phase2::StatisticalClient {
        &self.statistical
    }
    pub fn communities(&self) -> &crate::resources_phase2::CommunitiesClient {
        &self.communities
    }
    pub fn visualization(&self) -> &crate::resources_phase2::VisualizationClient {
        &self.visualization
    }
    pub fn reasoning(&self) -> &crate::resources_phase2::ReasoningClient {
        &self.reasoning
    }
    pub fn control(&self) -> &crate::resources_phase2::ControlClient {
        &self.control
    }
    pub fn reviews(&self) -> &crate::resources_phase2::ReviewsClient {
        &self.reviews
    }
    pub fn action_reviews(&self) -> &crate::resources_phase2::ActionReviewsClient {
        &self.action_reviews
    }
    pub fn webhook_actions(&self) -> &crate::resources_phase2::WebhookActionsClient {
        &self.webhook_actions
    }
    pub fn ilp(&self) -> &crate::resources_phase2::IlpClient {
        &self.ilp
    }
    pub fn cdl(&self) -> &crate::resources_phase2::CdlClient {
        &self.cdl
    }
    pub fn synthetic(&self) -> &crate::resources_phase2::SyntheticClient {
        &self.synthetic
    }
    pub fn utilities(&self) -> &crate::resources_phase2::UtilitiesClient {
        &self.utilities
    }
    pub fn ingestion(&self) -> &crate::resources_phase2::IngestionClient {
        &self.ingestion
    }
    pub fn execution(&self) -> &crate::resources_phase2::ExecutionClient {
        &self.execution
    }
    pub fn proof_engine(&self) -> &crate::resources_phase2::ProofEngineClient {
        &self.proof_engine
    }
    pub fn conversation(&self) -> &crate::resources_phase2::ConversationClient {
        &self.conversation
    }
    pub fn research(&self) -> &crate::resources_phase2::ResearchClient {
        &self.research
    }
    pub fn cognitive(&self) -> &crate::resources_phase2::CognitiveClient {
        &self.cognitive
    }
    pub fn oversight(&self) -> &crate::resources_phase2::OversightClient {
        &self.oversight
    }
    pub fn neuro_symbolic(&self) -> &crate::resources_phase2::NeuroSymbolicClient {
        &self.neuro_symbolic
    }

    // ─── Phase 2a simple resources ────────────────────────────────────────
    pub fn health(&self) -> &HealthClient {
        &self.health
    }
    pub fn admin(&self) -> &AdminClient {
        &self.admin
    }
    pub fn osfql(&self) -> &OsfqlClient {
        &self.osfql
    }
    pub fn context(&self) -> &ContextClient {
        &self.context
    }
    pub fn rl_training(&self) -> &RlTrainingClient {
        &self.rl_training
    }
    pub fn rag(&self) -> &RagClient {
        &self.rag
    }
    pub fn generation(&self) -> &GenerationClient {
        &self.generation
    }
    pub fn image_extraction(&self) -> &ImageExtractionClient {
        &self.image_extraction
    }
    pub fn extract(&self) -> &ExtractClient {
        &self.extract
    }
    pub fn preferences(&self) -> &PreferencesClient {
        &self.preferences
    }
    pub fn discovery(&self) -> &DiscoveryClient {
        &self.discovery
    }
    pub fn functions(&self) -> &FunctionsClient {
        &self.functions
    }
    pub fn ontology(&self) -> &OntologyClient {
        &self.ontology
    }
    pub fn analysis(&self) -> &AnalysisClient {
        &self.analysis
    }
    pub fn scenarios(&self) -> &ScenariosClient {
        &self.scenarios
    }
    pub fn spaces(&self) -> &SpacesClient {
        &self.spaces
    }
    pub fn row(&self) -> &RowClient {
        &self.row
    }
    pub fn sources(&self) -> &SourcesClient {
        &self.sources
    }
    pub fn ui(&self) -> &UiClient {
        &self.ui
    }
    pub fn optimize(&self) -> &OptimizeClient {
        &self.optimize
    }
}