Release v3.2.0: reports, pipelines, saved searches, predictive risk, comparative AI, sanctions browse, PDF profiles

Adds 21 new endpoints (8 high-priority + 13 medium-priority):

High priority:
- ai.comparative — AI comparative dossier for 2-5 companies
- ai.predictive_risk — dissolution probability + credit risk scoring
- companies.pdf — structured profile data for PDF rendering
- reports.industries / reports.get / reports.generate — industry reports
- screening.browse_sanctions — browse SECO/OpenSanctions/FINMA databases
- changes.review — mark changes as reviewed (compliance workflow)

Medium priority:
- pipelines (new resource) — CRUD for sales/prospect tracking pipelines
  with entries, stages, and statistics
- saved_searches (new resource) — persist and schedule search queries

Also fixes BenchmarkDimension nullable fields (industryMedian, percentile)
and adds peersWithData field.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: mivertowski

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "vynco"
-version = "2.3.0"
+version = "2.4.0"
 edition = "2021"
 rust-version = "1.83"
 license = "Apache-2.0"

Cargo.toml

@@ -161,6 +161,18 @@ impl Client {
     pub fn graph(&self) -> Graph<'_> {
         Graph { client: self }
     }
+
+    pub fn reports(&self) -> Reports<'_> {
+        Reports { client: self }
+    }
+
+    pub fn pipelines(&self) -> Pipelines<'_> {
+        Pipelines { client: self }
+    }
+
+    pub fn saved_searches(&self) -> SavedSearches<'_> {
+        SavedSearches { client: self }
+    }
 }
 
 // ---------------------------------------------------------------------------
@@ -305,6 +317,10 @@ impl Companies<'_> {
             .block_on(self.client.inner.companies().all_tags())
     }
 
+    pub fn pdf(&self, uid: &str) -> Result<Response<PdfProfileResponse>> {
+        self.client.block_on(self.client.inner.companies().pdf(uid))
+    }
+
     pub fn export_csv(&self, req: &ExcelExportRequest) -> Result<ExportFile> {
         self.client
             .block_on(self.client.inner.companies().export_csv(req))
@@ -354,6 +370,19 @@ impl Screening<'_> {
         self.client
             .block_on(self.client.inner.screening().screen(req))
     }
+
+    pub fn batch(&self, req: &BatchScreeningRequest) -> Result<Response<BatchScreeningResponse>> {
+        self.client
+            .block_on(self.client.inner.screening().batch(req))
+    }
+
+    pub fn browse_sanctions(
+        &self,
+        params: &SanctionsSearchParams,
+    ) -> Result<Response<SanctionsListResponse>> {
+        self.client
+            .block_on(self.client.inner.screening().browse_sanctions(params))
+    }
 }
 
 pub struct Watchlists<'a> {
@@ -478,6 +507,28 @@ impl Ai<'_> {
     pub fn risk_score(&self, req: &RiskScoreRequest) -> Result<Response<RiskScoreResponse>> {
         self.client.block_on(self.client.inner.ai().risk_score(req))
     }
+
+    pub fn risk_score_batch(
+        &self,
+        req: &BatchRiskScoreRequest,
+    ) -> Result<Response<BatchRiskScoreResponse>> {
+        self.client
+            .block_on(self.client.inner.ai().risk_score_batch(req))
+    }
+
+    pub fn comparative(&self, req: &ComparativeRequest) -> Result<Response<ComparativeResponse>> {
+        self.client
+            .block_on(self.client.inner.ai().comparative(req))
+    }
+
+    pub fn predictive_risk(
+        &self,
+        uid: &str,
+        req: &PredictiveRiskRequest,
+    ) -> Result<Response<PredictiveRiskResponse>> {
+        self.client
+            .block_on(self.client.inner.ai().predictive_risk(uid, req))
+    }
 }
 
 // ---------------------------------------------------------------------------
@@ -612,6 +663,10 @@ impl Changes<'_> {
         self.client
             .block_on(self.client.inner.changes().statistics())
     }
+
+    pub fn review(&self, id: &str) -> Result<ResponseMeta> {
+        self.client.block_on(self.client.inner.changes().review(id))
+    }
 }
 
 pub struct Persons<'a> {
@@ -732,3 +787,112 @@ impl Graph<'_> {
         self.client.block_on(self.client.inner.graph().analyze(req))
     }
 }
+
+pub struct Reports<'a> {
+    client: &'a Client,
+}
+
+impl Reports<'_> {
+    pub fn industries(&self) -> Result<Response<IndustryListResponse>> {
+        self.client
+            .block_on(self.client.inner.reports().industries())
+    }
+
+    pub fn get(&self, industry: &str) -> Result<Response<IndustryReportResponse>> {
+        self.client
+            .block_on(self.client.inner.reports().get(industry))
+    }
+
+    pub fn generate(&self, industry: &str) -> Result<Response<GeneratedIndustryReport>> {
+        self.client
+            .block_on(self.client.inner.reports().generate(industry))
+    }
+}
+
+pub struct Pipelines<'a> {
+    client: &'a Client,
+}
+
+impl Pipelines<'_> {
+    pub fn list(&self) -> Result<Response<Vec<Pipeline>>> {
+        self.client.block_on(self.client.inner.pipelines().list())
+    }
+
+    pub fn create(&self, req: &CreatePipelineRequest) -> Result<Response<Pipeline>> {
+        self.client
+            .block_on(self.client.inner.pipelines().create(req))
+    }
+
+    pub fn get(&self, id: &str) -> Result<Response<PipelineWithEntries>> {
+        self.client.block_on(self.client.inner.pipelines().get(id))
+    }
+
+    pub fn delete(&self, id: &str) -> Result<ResponseMeta> {
+        self.client
+            .block_on(self.client.inner.pipelines().delete(id))
+    }
+
+    pub fn add_entry(&self, id: &str, req: &AddEntryRequest) -> Result<Response<PipelineEntry>> {
+        self.client
+            .block_on(self.client.inner.pipelines().add_entry(id, req))
+    }
+
+    pub fn update_entry(
+        &self,
+        id: &str,
+        entry_id: &str,
+        req: &UpdateEntryRequest,
+    ) -> Result<Response<PipelineEntry>> {
+        self.client.block_on(
+            self.client
+                .inner
+                .pipelines()
+                .update_entry(id, entry_id, req),
+        )
+    }
+
+    pub fn remove_entry(&self, id: &str, entry_id: &str) -> Result<ResponseMeta> {
+        self.client
+            .block_on(self.client.inner.pipelines().remove_entry(id, entry_id))
+    }
+
+    pub fn stats(&self, id: &str) -> Result<Response<PipelineStats>> {
+        self.client
+            .block_on(self.client.inner.pipelines().stats(id))
+    }
+}
+
+pub struct SavedSearches<'a> {
+    client: &'a Client,
+}
+
+impl SavedSearches<'_> {
+    pub fn list(&self) -> Result<Response<Vec<SavedSearch>>> {
+        self.client
+            .block_on(self.client.inner.saved_searches().list())
+    }
+
+    pub fn create(&self, req: &CreateSavedSearchRequest) -> Result<Response<SavedSearch>> {
+        self.client
+            .block_on(self.client.inner.saved_searches().create(req))
+    }
+
+    pub fn get(&self, id: &str) -> Result<Response<SavedSearch>> {
+        self.client
+            .block_on(self.client.inner.saved_searches().get(id))
+    }
+
+    pub fn update(
+        &self,
+        id: &str,
+        req: &UpdateSavedSearchRequest,
+    ) -> Result<Response<SavedSearch>> {
+        self.client
+            .block_on(self.client.inner.saved_searches().update(id, req))
+    }
+
+    pub fn delete(&self, id: &str) -> Result<ResponseMeta> {
+        self.client
+            .block_on(self.client.inner.saved_searches().delete(id))
+    }
+}

src/blocking.rs

@@ -175,6 +175,18 @@ impl Client {
         Ownership::new(self)
     }
 
+    pub fn reports(&self) -> Reports<'_> {
+        Reports::new(self)
+    }
+
+    pub fn pipelines(&self) -> Pipelines<'_> {
+        Pipelines::new(self)
+    }
+
+    pub fn saved_searches(&self) -> SavedSearches<'_> {
+        SavedSearches::new(self)
+    }
+
     // -- Internal request methods --------------------------------------------
 
     pub(crate) fn url(&self, path: &str) -> String {

src/client.rs

@@ -12,8 +12,8 @@ pub use client::{Client, ClientBuilder};
 pub use error::{ErrorBody, VyncoError};
 pub use resources::{
     Ai, Alerts, Analytics, ApiKeys, Auditors, Billing, Changes, Companies, Credits, Dashboard,
-    Dossiers, ExportFile, Exports, Graph, Health, Ownership, Persons, Screening, Teams, Watchlists,
-    Webhooks,
+    Dossiers, ExportFile, Exports, Graph, Health, Ownership, Persons, Pipelines, Reports,
+    SavedSearches, Screening, Teams, Watchlists, Webhooks,
 };
 pub use response::{Response, ResponseMeta};
 pub use types::*;

src/lib.rs

@@ -41,6 +41,29 @@ impl<'a> Ai<'a> {
             .request_with_body(Method::POST, "/v1/ai/risk-score/batch", req)
             .await
     }
+
+    /// Generate an AI comparative dossier for 2-5 companies.
+    ///
+    /// `focus` is one of `governance`, `financial`, `risk`, or `all` (default).
+    pub async fn comparative(
+        &self,
+        req: &ComparativeRequest,
+    ) -> Result<Response<ComparativeResponse>> {
+        self.client
+            .request_with_body(Method::POST, "/v1/ai/comparative", req)
+            .await
+    }
+
+    /// Get predictive risk scoring with dissolution probability.
+    pub async fn predictive_risk(
+        &self,
+        uid: &str,
+        req: &PredictiveRiskRequest,
+    ) -> Result<Response<PredictiveRiskResponse>> {
+        self.client
+            .request_with_body(Method::POST, &format!("/v1/risk/predictive/{uid}"), req)
+            .await
+    }
 }
 
 #[cfg(test)]

src/resources/ai.rs

@@ -2,7 +2,7 @@ use reqwest::Method;
 
 use crate::client::Client;
 use crate::error::Result;
-use crate::response::Response;
+use crate::response::{Response, ResponseMeta};
 use crate::types::*;
 
 pub struct Changes<'a> {
@@ -57,6 +57,13 @@ impl<'a> Changes<'a> {
             .request(Method::GET, "/v1/changes/statistics")
             .await
     }
+
+    /// Mark a change as reviewed (compliance workflow).
+    pub async fn review(&self, id: &str) -> Result<ResponseMeta> {
+        self.client
+            .request_empty(Method::PUT, &format!("/v1/changes/{id}/review"))
+            .await
+    }
 }
 
 #[cfg(test)]

src/resources/changes.rs

@@ -372,6 +372,15 @@ impl<'a> Companies<'a> {
             .await
     }
 
+    // -- PDF profile --
+
+    /// Get structured company profile data suitable for PDF rendering.
+    pub async fn pdf(&self, uid: &str) -> Result<Response<PdfProfileResponse>> {
+        self.client
+            .request(Method::GET, &format!("/v1/companies/{uid}/pdf"))
+            .await
+    }
+
     // -- CSV / Excel export --
 
     /// Export companies as CSV.

src/resources/companies.rs

@@ -14,6 +14,9 @@ mod graph;
 mod health;
 mod ownership;
 mod persons;
+mod pipelines;
+mod reports;
+mod saved_searches;
 mod screening;
 mod teams;
 mod watchlists;
@@ -35,6 +38,9 @@ pub use graph::Graph;
 pub use health::Health;
 pub use ownership::Ownership;
 pub use persons::Persons;
+pub use pipelines::Pipelines;
+pub use reports::Reports;
+pub use saved_searches::SavedSearches;
 pub use screening::Screening;
 pub use teams::Teams;
 pub use watchlists::Watchlists;