xberg 1.2.9 → 1.3.2

data/ext/xberg_rb/src/lib.rs

@@ -1,5 +1,5 @@
 // This file is auto-generated by alef. DO NOT EDIT.
-// alef:hash:9fd93c9044f1bedf7b944452cf36003a6468e2f40f9fe5a1d4e78bea797a60a3
+// alef:hash:e004b1d953b206d06d83d0462afc0689784b447478a1e0085a43e79980b1fd22
 // Re-generate with: alef generate
 #![allow(dead_code, unused_imports, unused_variables)]
 #![allow(
@@ -18,6 +18,7 @@
     clippy::useless_conversion,
     clippy::clone_on_copy
 )]
+#![allow(deprecated)]
 
 use async_trait::async_trait;
 use magnus::{Error, IntoValueFromNative, Ruby, function, method, prelude::*, try_convert::TryConvertOwned};
@@ -1134,6 +1135,8 @@ pub struct BrowserConfig {
     endpoint: Option<String>,
     #[serde(default = "default_timeout")]
     timeout: u64,
+    overall_timeout: u64,
+    shutdown_timeout: u64,
     wait: BrowserWait,
     wait_selector: Option<String>,
     extra_wait: Option<u64>,
@@ -1230,6 +1233,24 @@ impl BrowserConfig {
                 })?,
                 None => 30000,
             },
+            overall_timeout: match kwargs.get(ruby.to_symbol("overall_timeout")) {
+                Some(v) => u64::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `overall_timeout`: {}", e),
+                    )
+                })?,
+                None => 60000,
+            },
+            shutdown_timeout: match kwargs.get(ruby.to_symbol("shutdown_timeout")) {
+                Some(v) => u64::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `shutdown_timeout`: {}", e),
+                    )
+                })?,
+                None => 5000,
+            },
             wait: match kwargs.get(ruby.to_symbol("wait")) {
                 Some(v) => BrowserWait::try_convert(v).map_err(|e| {
                     magnus::Error::new(
@@ -1330,6 +1351,14 @@ impl BrowserConfig {
         self.timeout.clone()
     }
 
+    fn overall_timeout(&self) -> u64 {
+        self.overall_timeout.clone()
+    }
+
+    fn shutdown_timeout(&self) -> u64 {
+        self.shutdown_timeout.clone()
+    }
+
     fn wait(&self) -> BrowserWait {
         self.wait.clone()
     }
@@ -1487,6 +1516,7 @@ pub struct CaptioningConfig {
     llm: LlmConfig,
     prompt: Option<String>,
     min_image_area: u32,
+    alt_text: CaptionAltTextMode,
 }
 
 unsafe impl IntoValueFromNative for CaptioningConfig {}
@@ -1531,6 +1561,7 @@ impl Default for CaptioningConfig {
             llm: LlmConfig::default(),
             prompt: None,
             min_image_area: 1000,
+            alt_text: CaptionAltTextMode::Preserve,
         }
     }
 }
@@ -1574,6 +1605,15 @@ impl CaptioningConfig {
                 })?,
                 None => 1000,
             },
+            alt_text: match kwargs.get(ruby.to_symbol("alt_text")) {
+                Some(v) => CaptionAltTextMode::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `alt_text`: {}", e),
+                    )
+                })?,
+                None => CaptionAltTextMode::Preserve,
+            },
         })
     }
 
@@ -1588,6 +1628,10 @@ impl CaptioningConfig {
     fn min_image_area(&self) -> u32 {
         self.min_image_area
     }
+
+    fn alt_text(&self) -> CaptionAltTextMode {
+        self.alt_text.clone()
+    }
 }
 
 #[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
@@ -1696,9 +1740,9 @@ pub struct Chunk {
     content: String,
     chunk_type: ChunkType,
     embedding: Option<Vec<f32>>,
-    #[cfg(feature = "sparse-embedding-presets")]
+    #[cfg(any(feature = "sparse-embedding-presets", not(feature = "sparse-embedding-presets")))]
     sparse_embedding: Option<SparseEmbedding>,
-    #[cfg(feature = "late-interaction-presets")]
+    #[cfg(any(feature = "late-interaction-presets", not(feature = "late-interaction-presets")))]
     late_interaction: Option<MultiVectorEmbedding>,
     metadata: ChunkMetadata,
 }
@@ -1754,12 +1798,7 @@ impl Chunk {
                         format!("invalid value for `chunk_type`: {}", e),
                     )
                 })?,
-                None => {
-                    return Err(magnus::Error::new(
-                        unsafe { magnus::Ruby::get_unchecked() }.exception_arg_error(),
-                        "missing required field: chunk_type",
-                    ));
-                }
+                None => ChunkType::Unknown,
             },
             embedding: match kwargs.get(ruby.to_symbol("embedding")).filter(|v| !v.is_nil()) {
                 Some(v) => Some(<Vec<f32>>::try_convert(v).map_err(|e| {
@@ -1770,7 +1809,7 @@ impl Chunk {
                 })?),
                 None => None,
             },
-            #[cfg(feature = "sparse-embedding-presets")]
+            #[cfg(any(feature = "sparse-embedding-presets", not(feature = "sparse-embedding-presets")))]
             sparse_embedding: match kwargs.get(ruby.to_symbol("sparse_embedding")).filter(|v| !v.is_nil()) {
                 Some(v) => Some(SparseEmbedding::try_convert(v).map_err(|e| {
                     magnus::Error::new(
@@ -1780,7 +1819,7 @@ impl Chunk {
                 })?),
                 None => None,
             },
-            #[cfg(feature = "late-interaction-presets")]
+            #[cfg(any(feature = "late-interaction-presets", not(feature = "late-interaction-presets")))]
             late_interaction: match kwargs.get(ruby.to_symbol("late_interaction")).filter(|v| !v.is_nil()) {
                 Some(v) => Some(MultiVectorEmbedding::try_convert(v).map_err(|e| {
                     magnus::Error::new(
@@ -1819,12 +1858,12 @@ impl Chunk {
         self.embedding.clone()
     }
 
-    #[cfg(feature = "sparse-embedding-presets")]
+    #[cfg(any(feature = "sparse-embedding-presets", not(feature = "sparse-embedding-presets")))]
     fn sparse_embedding(&self) -> Option<SparseEmbedding> {
         self.sparse_embedding.clone()
     }
 
-    #[cfg(feature = "late-interaction-presets")]
+    #[cfg(any(feature = "late-interaction-presets", not(feature = "late-interaction-presets")))]
     fn late_interaction(&self) -> Option<MultiVectorEmbedding> {
         self.late_interaction.clone()
     }
@@ -3582,6 +3621,7 @@ pub struct ContentConfig {
     wrap: bool,
     wrap_width: usize,
     include_document_structure: bool,
+    extract_metadata: bool,
 }
 
 unsafe impl IntoValueFromNative for ContentConfig {}
@@ -3741,6 +3781,15 @@ impl ContentConfig {
                 })?,
                 None => true,
             },
+            extract_metadata: match kwargs.get(ruby.to_symbol("extract_metadata")) {
+                Some(v) => bool::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `extract_metadata`: {}", e),
+                    )
+                })?,
+                None => true,
+            },
         })
     }
 
@@ -3791,6 +3840,10 @@ impl ContentConfig {
     fn include_document_structure(&self) -> bool {
         self.include_document_structure
     }
+
+    fn extract_metadata(&self) -> bool {
+        self.extract_metadata
+    }
 }
 
 #[derive(Clone, Debug, serde::Serialize)]
@@ -4041,6 +4094,7 @@ pub struct ConversionOptions {
     max_depth: Option<usize>,
     exclude_selectors: Vec<String>,
     tier_strategy: TierStrategy,
+    base_url: Option<String>,
 }
 
 unsafe impl IntoValueFromNative for ConversionOptions {}
@@ -4471,6 +4525,15 @@ impl ConversionOptions {
                 })?,
                 None => TierStrategy::Auto,
             },
+            base_url: match kwargs.get(ruby.to_symbol("base_url")).filter(|v| !v.is_nil()) {
+                Some(v) => Some(String::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `base_url`: {}", e),
+                    )
+                })?),
+                None => None,
+            },
         })
     }
 
@@ -4645,6 +4708,10 @@ impl ConversionOptions {
     fn tier_strategy(&self) -> TierStrategy {
         self.tier_strategy.clone()
     }
+
+    fn base_url(&self) -> Option<String> {
+        self.base_url.clone()
+    }
 }
 
 #[cfg(feature = "office")]
@@ -4933,6 +5000,10 @@ pub struct CrawlConfig {
     allow_subdomains: bool,
     include_paths: Vec<String>,
     exclude_paths: Vec<String>,
+    path_patterns_match_query: bool,
+    dedup_include_query: bool,
+    strip_tracking_params: bool,
+    tracking_params: Vec<String>,
     custom_headers: HashMap<String, String>,
     #[serde(default = "default_timeout")]
     request_timeout: u64,
@@ -4940,6 +5011,9 @@ pub struct CrawlConfig {
     max_redirects: usize,
     retry_count: usize,
     retry_codes: Vec<u16>,
+    retry_initial_delay_ms: u64,
+    retry_max_delay_ms: u64,
+    rate_limit_jitter_ratio: f64,
     cookies_enabled: bool,
     auth: Option<AuthConfig>,
     max_body_size: Option<usize>,
@@ -5144,6 +5218,47 @@ impl CrawlConfig {
                 })?,
                 None => Default::default(),
             },
+            path_patterns_match_query: match kwargs.get(ruby.to_symbol("path_patterns_match_query")) {
+                Some(v) => bool::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `path_patterns_match_query`: {}", e),
+                    )
+                })?,
+                None => false,
+            },
+            dedup_include_query: match kwargs.get(ruby.to_symbol("dedup_include_query")) {
+                Some(v) => bool::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `dedup_include_query`: {}", e),
+                    )
+                })?,
+                None => false,
+            },
+            strip_tracking_params: match kwargs.get(ruby.to_symbol("strip_tracking_params")) {
+                Some(v) => bool::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `strip_tracking_params`: {}", e),
+                    )
+                })?,
+                None => false,
+            },
+            tracking_params: match kwargs.get(ruby.to_symbol("tracking_params")) {
+                Some(v) => <Vec<String>>::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `tracking_params`: {}", e),
+                    )
+                })?,
+                None => vec![
+                    "utm_*".to_string(),
+                    "fbclid".to_string(),
+                    "gclid".to_string(),
+                    "ref".to_string(),
+                ],
+            },
             custom_headers: match kwargs.get(ruby.to_symbol("custom_headers")) {
                 Some(v) => <HashMap<String, String>>::try_convert(v).map_err(|e| {
                     magnus::Error::new(
@@ -5198,6 +5313,33 @@ impl CrawlConfig {
                 })?,
                 None => Default::default(),
             },
+            retry_initial_delay_ms: match kwargs.get(ruby.to_symbol("retry_initial_delay_ms")) {
+                Some(v) => u64::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `retry_initial_delay_ms`: {}", e),
+                    )
+                })?,
+                None => 100,
+            },
+            retry_max_delay_ms: match kwargs.get(ruby.to_symbol("retry_max_delay_ms")) {
+                Some(v) => u64::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `retry_max_delay_ms`: {}", e),
+                    )
+                })?,
+                None => 60000,
+            },
+            rate_limit_jitter_ratio: match kwargs.get(ruby.to_symbol("rate_limit_jitter_ratio")) {
+                Some(v) => f64::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `rate_limit_jitter_ratio`: {}", e),
+                    )
+                })?,
+                None => 0.0,
+            },
             cookies_enabled: match kwargs.get(ruby.to_symbol("cookies_enabled")) {
                 Some(v) => bool::try_convert(v).map_err(|e| {
                     magnus::Error::new(
@@ -5504,6 +5646,22 @@ impl CrawlConfig {
         self.exclude_paths.clone()
     }
 
+    fn path_patterns_match_query(&self) -> bool {
+        self.path_patterns_match_query
+    }
+
+    fn dedup_include_query(&self) -> bool {
+        self.dedup_include_query
+    }
+
+    fn strip_tracking_params(&self) -> bool {
+        self.strip_tracking_params
+    }
+
+    fn tracking_params(&self) -> Vec<String> {
+        self.tracking_params.clone()
+    }
+
     fn custom_headers(&self) -> HashMap<String, String> {
         self.custom_headers.clone()
     }
@@ -5528,6 +5686,18 @@ impl CrawlConfig {
         self.retry_codes.clone()
     }
 
+    fn retry_initial_delay_ms(&self) -> u64 {
+        self.retry_initial_delay_ms
+    }
+
+    fn retry_max_delay_ms(&self) -> u64 {
+        self.retry_max_delay_ms
+    }
+
+    fn rate_limit_jitter_ratio(&self) -> f64 {
+        self.rate_limit_jitter_ratio
+    }
+
     fn cookies_enabled(&self) -> bool {
         self.cookies_enabled
     }
@@ -7645,12 +7815,7 @@ impl DocumentNode {
                         format!("invalid value for `content_layer`: {}", e),
                     )
                 })?,
-                None => {
-                    return Err(magnus::Error::new(
-                        unsafe { magnus::Ruby::get_unchecked() }.exception_arg_error(),
-                        "missing required field: content_layer",
-                    ));
-                }
+                None => ContentLayer::Body,
             },
             page: match kwargs.get(ruby.to_symbol("page")).filter(|v| !v.is_nil()) {
                 Some(v) => Some(u32::try_convert(v).map_err(|e| {
@@ -10523,6 +10688,135 @@ impl ExcelWorkbook {
     }
 }
 
+#[derive(Clone, Debug, serde::Serialize)]
+#[serde(default)]
+#[magnus::wrap(class = "Xberg::ExternalRedactionFinding")]
+pub struct ExternalRedactionFinding {
+    label: String,
+    text: Option<String>,
+    start: Option<u32>,
+    end: Option<u32>,
+    score: Option<f32>,
+}
+
+unsafe impl IntoValueFromNative for ExternalRedactionFinding {}
+
+impl magnus::TryConvert for ExternalRedactionFinding {
+    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
+        if let Ok(r) = <&ExternalRedactionFinding as magnus::TryConvert>::try_convert(val) {
+            return Ok(r.clone());
+        }
+        let json_str: String = if let Ok(s) = <String as magnus::TryConvert>::try_convert(val) {
+            s
+        } else {
+            val.funcall::<_, _, String>("to_json", ()).map_err(|e| {
+                magnus::Error::new(
+                    unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                    format!("no implicit conversion into ExternalRedactionFinding: {}", e),
+                )
+            })?
+        };
+        serde_json::from_str::<ExternalRedactionFinding>(&json_str).map_err(|e| {
+            magnus::Error::new(
+                unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                format!("failed to deserialize ExternalRedactionFinding: {}", e),
+            )
+        })
+    }
+}
+
+unsafe impl TryConvertOwned for ExternalRedactionFinding {}
+impl<'de> serde::Deserialize<'de> for ExternalRedactionFinding {
+    fn deserialize<D>(deserializer: D) -> ::core::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        <xberg::ExternalRedactionFinding as serde::Deserialize>::deserialize(deserializer).map(Into::into)
+    }
+}
+
+impl Default for ExternalRedactionFinding {
+    fn default() -> Self {
+        xberg::ExternalRedactionFinding::default().into()
+    }
+}
+
+impl ExternalRedactionFinding {
+    fn new(args: &[magnus::Value]) -> Result<Self, magnus::Error> {
+        let ruby = unsafe { magnus::Ruby::get_unchecked() };
+        let args = magnus::scan_args::scan_args::<(), (Option<magnus::RHash>,), (), (), (), ()>(args)?;
+        let (kwargs_opt,) = args.optional;
+        let kwargs = kwargs_opt.unwrap_or_else(|| ruby.hash_new());
+        Ok(Self {
+            label: match kwargs.get(ruby.to_symbol("label")) {
+                Some(v) => String::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `label`: {}", e),
+                    )
+                })?,
+                None => Default::default(),
+            },
+            text: match kwargs.get(ruby.to_symbol("text")).filter(|v| !v.is_nil()) {
+                Some(v) => Some(String::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `text`: {}", e),
+                    )
+                })?),
+                None => None,
+            },
+            start: match kwargs.get(ruby.to_symbol("start")).filter(|v| !v.is_nil()) {
+                Some(v) => Some(u32::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `start`: {}", e),
+                    )
+                })?),
+                None => None,
+            },
+            end: match kwargs.get(ruby.to_symbol("end")).filter(|v| !v.is_nil()) {
+                Some(v) => Some(u32::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `end`: {}", e),
+                    )
+                })?),
+                None => None,
+            },
+            score: match kwargs.get(ruby.to_symbol("score")).filter(|v| !v.is_nil()) {
+                Some(v) => Some(f32::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `score`: {}", e),
+                    )
+                })?),
+                None => None,
+            },
+        })
+    }
+
+    fn label(&self) -> String {
+        self.label.clone()
+    }
+
+    fn text(&self) -> Option<String> {
+        self.text.clone()
+    }
+
+    fn start(&self) -> Option<u32> {
+        self.start
+    }
+
+    fn end(&self) -> Option<u32> {
+        self.end
+    }
+
+    fn score(&self) -> Option<f32> {
+        self.score
+    }
+}
+
 #[derive(Clone, Debug, serde::Serialize)]
 #[serde(default)]
 #[magnus::wrap(class = "Xberg::ExtractInput")]
@@ -17266,6 +17560,7 @@ pub struct ImagePreprocessingConfig {
     contrast_enhance: bool,
     binarization_method: String,
     invert_colors: bool,
+    normalize_shaded_rows: bool,
 }
 
 unsafe impl IntoValueFromNative for ImagePreprocessingConfig {}
@@ -17380,6 +17675,15 @@ impl ImagePreprocessingConfig {
                 })?,
                 None => false,
             },
+            normalize_shaded_rows: match kwargs.get(ruby.to_symbol("normalize_shaded_rows")) {
+                Some(v) => bool::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `normalize_shaded_rows`: {}", e),
+                    )
+                })?,
+                None => false,
+            },
         })
     }
 
@@ -17410,6 +17714,10 @@ impl ImagePreprocessingConfig {
     fn invert_colors(&self) -> bool {
         self.invert_colors
     }
+
+    fn normalize_shaded_rows(&self) -> bool {
+        self.normalize_shaded_rows
+    }
 }
 
 #[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
@@ -18601,7 +18909,7 @@ impl LateInteractionConfig {
     }
 }
 
-#[cfg(feature = "late-interaction-presets")]
+#[cfg(any(feature = "late-interaction-presets", not(feature = "late-interaction-presets")))]
 #[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
 #[magnus::wrap(class = "Xberg::LateInteractionMatch")]
 pub struct LateInteractionMatch {
@@ -18609,10 +18917,10 @@ pub struct LateInteractionMatch {
     score: f32,
 }
 
-#[cfg(feature = "late-interaction-presets")]
+#[cfg(any(feature = "late-interaction-presets", not(feature = "late-interaction-presets")))]
 unsafe impl IntoValueFromNative for LateInteractionMatch {}
 
-#[cfg(feature = "late-interaction-presets")]
+#[cfg(any(feature = "late-interaction-presets", not(feature = "late-interaction-presets")))]
 impl magnus::TryConvert for LateInteractionMatch {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
         if let Ok(r) = <&LateInteractionMatch as magnus::TryConvert>::try_convert(val) {
@@ -18637,10 +18945,10 @@ impl magnus::TryConvert for LateInteractionMatch {
     }
 }
 
-#[cfg(feature = "late-interaction-presets")]
+#[cfg(any(feature = "late-interaction-presets", not(feature = "late-interaction-presets")))]
 unsafe impl TryConvertOwned for LateInteractionMatch {}
 
-#[cfg(feature = "late-interaction-presets")]
+#[cfg(any(feature = "late-interaction-presets", not(feature = "late-interaction-presets")))]
 impl LateInteractionMatch {
     fn new(args: &[magnus::Value]) -> Result<Self, magnus::Error> {
         let ruby = unsafe { magnus::Ruby::get_unchecked() };
@@ -18678,7 +18986,7 @@ impl LateInteractionMatch {
     }
 }
 
-#[cfg(feature = "late-interaction-presets")]
+#[cfg(any(feature = "late-interaction-presets", not(feature = "late-interaction-presets")))]
 #[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
 #[magnus::wrap(class = "Xberg::LateInteractionPreset")]
 pub struct LateInteractionPreset {
@@ -18692,10 +19000,10 @@ pub struct LateInteractionPreset {
     description: String,
 }
 
-#[cfg(feature = "late-interaction-presets")]
+#[cfg(any(feature = "late-interaction-presets", not(feature = "late-interaction-presets")))]
 unsafe impl IntoValueFromNative for LateInteractionPreset {}
 
-#[cfg(feature = "late-interaction-presets")]
+#[cfg(any(feature = "late-interaction-presets", not(feature = "late-interaction-presets")))]
 impl magnus::TryConvert for LateInteractionPreset {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
         if let Ok(r) = <&LateInteractionPreset as magnus::TryConvert>::try_convert(val) {
@@ -18720,10 +19028,10 @@ impl magnus::TryConvert for LateInteractionPreset {
     }
 }
 
-#[cfg(feature = "late-interaction-presets")]
+#[cfg(any(feature = "late-interaction-presets", not(feature = "late-interaction-presets")))]
 unsafe impl TryConvertOwned for LateInteractionPreset {}
 
-#[cfg(feature = "late-interaction-presets")]
+#[cfg(any(feature = "late-interaction-presets", not(feature = "late-interaction-presets")))]
 impl LateInteractionPreset {
     fn new(args: &[magnus::Value]) -> Result<Self, magnus::Error> {
         let ruby = unsafe { magnus::Ruby::get_unchecked() };
@@ -21165,7 +21473,6 @@ impl Metadata {
     }
 }
 
-#[cfg(feature = "paddle-ocr-types")]
 #[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
 #[magnus::wrap(class = "Xberg::ModelPaths")]
 pub struct ModelPaths {
@@ -21175,10 +21482,8 @@ pub struct ModelPaths {
     dict_file: String,
 }
 
-#[cfg(feature = "paddle-ocr-types")]
 unsafe impl IntoValueFromNative for ModelPaths {}
 
-#[cfg(feature = "paddle-ocr-types")]
 impl magnus::TryConvert for ModelPaths {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
         if let Ok(r) = <&ModelPaths as magnus::TryConvert>::try_convert(val) {
@@ -21203,10 +21508,8 @@ impl magnus::TryConvert for ModelPaths {
     }
 }
 
-#[cfg(feature = "paddle-ocr-types")]
 unsafe impl TryConvertOwned for ModelPaths {}
 
-#[cfg(feature = "paddle-ocr-types")]
 impl ModelPaths {
     fn new(args: &[magnus::Value]) -> Result<Self, magnus::Error> {
         let ruby = unsafe { magnus::Ruby::get_unchecked() };
@@ -21270,7 +21573,7 @@ impl ModelPaths {
     }
 }
 
-#[cfg(feature = "late-interaction-presets")]
+#[cfg(any(feature = "late-interaction-presets", not(feature = "late-interaction-presets")))]
 #[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
 #[magnus::wrap(class = "Xberg::MultiVectorEmbedding")]
 pub struct MultiVectorEmbedding {
@@ -21279,10 +21582,10 @@ pub struct MultiVectorEmbedding {
     data: Vec<f32>,
 }
 
-#[cfg(feature = "late-interaction-presets")]
+#[cfg(any(feature = "late-interaction-presets", not(feature = "late-interaction-presets")))]
 unsafe impl IntoValueFromNative for MultiVectorEmbedding {}
 
-#[cfg(feature = "late-interaction-presets")]
+#[cfg(any(feature = "late-interaction-presets", not(feature = "late-interaction-presets")))]
 impl magnus::TryConvert for MultiVectorEmbedding {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
         if let Ok(r) = <&MultiVectorEmbedding as magnus::TryConvert>::try_convert(val) {
@@ -21307,10 +21610,10 @@ impl magnus::TryConvert for MultiVectorEmbedding {
     }
 }
 
-#[cfg(feature = "late-interaction-presets")]
+#[cfg(any(feature = "late-interaction-presets", not(feature = "late-interaction-presets")))]
 unsafe impl TryConvertOwned for MultiVectorEmbedding {}
 
-#[cfg(feature = "late-interaction-presets")]
+#[cfg(any(feature = "late-interaction-presets", not(feature = "late-interaction-presets")))]
 impl MultiVectorEmbedding {
     fn new(args: &[magnus::Value]) -> Result<Self, magnus::Error> {
         let ruby = unsafe { magnus::Ruby::get_unchecked() };
@@ -21920,6 +22223,7 @@ pub struct OcrConfig {
     tesseract_config: Option<TesseractConfig>,
     output_format: Option<OutputFormat>,
     paddle_ocr_config: Option<String>,
+    paddle_ocr_settings: Option<PaddleOcrConfig>,
     backend_options: Option<String>,
     element_config: Option<OcrElementConfig>,
     quality_thresholds: Option<OcrQualityThresholds>,
@@ -21932,6 +22236,7 @@ pub struct OcrConfig {
     security_limits: Option<SecurityLimits>,
     tessdata_bytes: Option<HashMap<String, Vec<u8>>>,
     tessdata_path: Option<String>,
+    numeric_repair: bool,
 }
 
 unsafe impl IntoValueFromNative for OcrConfig {}
@@ -22037,6 +22342,18 @@ impl OcrConfig {
                 })?),
                 None => None,
             },
+            paddle_ocr_settings: match kwargs
+                .get(ruby.to_symbol("paddle_ocr_settings"))
+                .filter(|v| !v.is_nil())
+            {
+                Some(v) => Some(PaddleOcrConfig::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `paddle_ocr_settings`: {}", e),
+                    )
+                })?),
+                None => None,
+            },
             backend_options: match kwargs.get(ruby.to_symbol("backend_options")).filter(|v| !v.is_nil()) {
                 Some(v) => Some(String::try_convert(v).map_err(|e| {
                     magnus::Error::new(
@@ -22145,6 +22462,15 @@ impl OcrConfig {
                 })?),
                 None => None,
             },
+            numeric_repair: match kwargs.get(ruby.to_symbol("numeric_repair")) {
+                Some(v) => bool::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `numeric_repair`: {}", e),
+                    )
+                })?,
+                None => false,
+            },
         })
     }
 
@@ -22172,6 +22498,10 @@ impl OcrConfig {
         self.paddle_ocr_config.clone()
     }
 
+    fn paddle_ocr_settings(&self) -> Option<PaddleOcrConfig> {
+        self.paddle_ocr_settings.clone()
+    }
+
     fn backend_options(&self) -> Option<String> {
         self.backend_options.clone()
     }
@@ -22219,6 +22549,10 @@ impl OcrConfig {
     fn tessdata_path(&self) -> Option<String> {
         self.tessdata_path.clone()
     }
+
+    fn numeric_repair(&self) -> bool {
+        self.numeric_repair
+    }
 }
 
 #[derive(Clone, Debug, serde::Serialize)]
@@ -22878,6 +23212,7 @@ pub struct OcrPipelineStage {
     language: Option<Vec<String>>,
     tesseract_config: Option<TesseractConfig>,
     paddle_ocr_config: Option<String>,
+    paddle_ocr_settings: Option<PaddleOcrConfig>,
     vlm_config: Option<LlmConfig>,
     backend_options: Option<String>,
 }
@@ -22926,6 +23261,7 @@ impl Default for OcrPipelineStage {
             language: None,
             tesseract_config: None,
             paddle_ocr_config: None,
+            paddle_ocr_settings: None,
             vlm_config: None,
             backend_options: None,
         }
@@ -22984,6 +23320,18 @@ impl OcrPipelineStage {
                 })?),
                 None => None,
             },
+            paddle_ocr_settings: match kwargs
+                .get(ruby.to_symbol("paddle_ocr_settings"))
+                .filter(|v| !v.is_nil())
+            {
+                Some(v) => Some(PaddleOcrConfig::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `paddle_ocr_settings`: {}", e),
+                    )
+                })?),
+                None => None,
+            },
             vlm_config: match kwargs.get(ruby.to_symbol("vlm_config")).filter(|v| !v.is_nil()) {
                 Some(v) => Some(LlmConfig::try_convert(v).map_err(|e| {
                     magnus::Error::new(
@@ -23025,6 +23373,10 @@ impl OcrPipelineStage {
         self.paddle_ocr_config.clone()
     }
 
+    fn paddle_ocr_settings(&self) -> Option<PaddleOcrConfig> {
+        self.paddle_ocr_settings.clone()
+    }
+
     fn vlm_config(&self) -> Option<LlmConfig> {
         self.vlm_config.clone()
     }
@@ -23908,7 +24260,6 @@ impl OrientationResult {
     }
 }
 
-#[cfg(feature = "paddle-ocr-types")]
 #[derive(Clone, Debug, serde::Serialize)]
 #[serde(default)]
 #[magnus::wrap(class = "Xberg::PaddleOcrConfig")]
@@ -23929,10 +24280,8 @@ pub struct PaddleOcrConfig {
     inference_backend: Option<PaddleInferenceBackend>,
 }
 
-#[cfg(feature = "paddle-ocr-types")]
 unsafe impl IntoValueFromNative for PaddleOcrConfig {}
 
-#[cfg(feature = "paddle-ocr-types")]
 impl magnus::TryConvert for PaddleOcrConfig {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
         if let Ok(r) = <&PaddleOcrConfig as magnus::TryConvert>::try_convert(val) {
@@ -23957,9 +24306,7 @@ impl magnus::TryConvert for PaddleOcrConfig {
     }
 }
 
-#[cfg(feature = "paddle-ocr-types")]
 unsafe impl TryConvertOwned for PaddleOcrConfig {}
-#[cfg(feature = "paddle-ocr-types")]
 impl<'de> serde::Deserialize<'de> for PaddleOcrConfig {
     fn deserialize<D>(deserializer: D) -> ::core::result::Result<Self, D::Error>
     where
@@ -23969,14 +24316,12 @@ impl<'de> serde::Deserialize<'de> for PaddleOcrConfig {
     }
 }
 
-#[cfg(feature = "paddle-ocr-types")]
 impl Default for PaddleOcrConfig {
     fn default() -> Self {
         xberg::PaddleOcrConfig::default().into()
     }
 }
 
-#[cfg(feature = "paddle-ocr-types")]
 impl PaddleOcrConfig {
     fn new(args: &[magnus::Value]) -> Result<Self, magnus::Error> {
         let ruby = unsafe { magnus::Ruby::get_unchecked() };
@@ -29494,6 +29839,10 @@ pub struct RedactionConfig {
     preserve_offsets: bool,
     custom_terms: Vec<RedactionTerm>,
     custom_patterns: Vec<RedactionPattern>,
+    findings: Vec<ExternalRedactionFinding>,
+    min_score: Option<f32>,
+    findings_path: Option<String>,
+    findings_offset_encoding: RedactionOffsetEncoding,
 }
 
 unsafe impl IntoValueFromNative for RedactionConfig {}
@@ -29599,6 +29948,42 @@ impl RedactionConfig {
                 })?,
                 None => Default::default(),
             },
+            findings: match kwargs.get(ruby.to_symbol("findings")) {
+                Some(v) => <Vec<ExternalRedactionFinding>>::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `findings`: {}", e),
+                    )
+                })?,
+                None => Default::default(),
+            },
+            min_score: match kwargs.get(ruby.to_symbol("min_score")).filter(|v| !v.is_nil()) {
+                Some(v) => Some(f32::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `min_score`: {}", e),
+                    )
+                })?),
+                None => None,
+            },
+            findings_path: match kwargs.get(ruby.to_symbol("findings_path")).filter(|v| !v.is_nil()) {
+                Some(v) => Some(String::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `findings_path`: {}", e),
+                    )
+                })?),
+                None => None,
+            },
+            findings_offset_encoding: match kwargs.get(ruby.to_symbol("findings_offset_encoding")) {
+                Some(v) => RedactionOffsetEncoding::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `findings_offset_encoding`: {}", e),
+                    )
+                })?,
+                None => RedactionOffsetEncoding::UnicodeCodePoints,
+            },
         })
     }
 
@@ -29626,6 +30011,22 @@ impl RedactionConfig {
         self.custom_patterns.clone()
     }
 
+    fn findings(&self) -> Vec<ExternalRedactionFinding> {
+        self.findings.clone()
+    }
+
+    fn min_score(&self) -> Option<f32> {
+        self.min_score
+    }
+
+    fn findings_path(&self) -> Option<String> {
+        self.findings_path.clone()
+    }
+
+    fn findings_offset_encoding(&self) -> RedactionOffsetEncoding {
+        self.findings_offset_encoding.clone()
+    }
+
     fn validate(&self) -> Result<(), Error> {
         #[allow(clippy::needless_update)]
         let core_self = xberg::RedactionConfig {
@@ -29641,6 +30042,14 @@ impl RedactionConfig {
 
             custom_patterns: self.custom_patterns.clone().into_iter().map(Into::into).collect(),
 
+            findings: self.findings.clone().into_iter().map(Into::into).collect(),
+
+            min_score: self.min_score,
+
+            findings_path: self.findings_path.clone().map(Into::into),
+
+            findings_offset_encoding: self.findings_offset_encoding.clone().into(),
+
             ..Default::default()
         };
         let result = core_self.validate().map_err(|e| {
@@ -30126,7 +30535,10 @@ impl Registry {
     }
 }
 
-#[cfg(any(feature = "reranker-presets", feature = "reranker"))]
+#[cfg(any(
+    any(feature = "reranker-presets", feature = "reranker"),
+    not(feature = "reranker-presets")
+))]
 #[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
 #[magnus::wrap(class = "Xberg::RerankedDocument")]
 pub struct RerankedDocument {
@@ -30135,10 +30547,16 @@ pub struct RerankedDocument {
     document: String,
 }
 
-#[cfg(any(feature = "reranker-presets", feature = "reranker"))]
+#[cfg(any(
+    any(feature = "reranker-presets", feature = "reranker"),
+    not(feature = "reranker-presets")
+))]
 unsafe impl IntoValueFromNative for RerankedDocument {}
 
-#[cfg(any(feature = "reranker-presets", feature = "reranker"))]
+#[cfg(any(
+    any(feature = "reranker-presets", feature = "reranker"),
+    not(feature = "reranker-presets")
+))]
 impl magnus::TryConvert for RerankedDocument {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
         if let Ok(r) = <&RerankedDocument as magnus::TryConvert>::try_convert(val) {
@@ -30163,10 +30581,16 @@ impl magnus::TryConvert for RerankedDocument {
     }
 }
 
-#[cfg(any(feature = "reranker-presets", feature = "reranker"))]
+#[cfg(any(
+    any(feature = "reranker-presets", feature = "reranker"),
+    not(feature = "reranker-presets")
+))]
 unsafe impl TryConvertOwned for RerankedDocument {}
 
-#[cfg(any(feature = "reranker-presets", feature = "reranker"))]
+#[cfg(any(
+    any(feature = "reranker-presets", feature = "reranker"),
+    not(feature = "reranker-presets")
+))]
 impl RerankedDocument {
     fn new(args: &[magnus::Value]) -> Result<Self, magnus::Error> {
         let ruby = unsafe { magnus::Ruby::get_unchecked() };
@@ -31224,7 +31648,7 @@ impl SitemapUrl {
     }
 }
 
-#[cfg(feature = "sparse-embedding-presets")]
+#[cfg(any(feature = "sparse-embedding-presets", not(feature = "sparse-embedding-presets")))]
 #[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
 #[magnus::wrap(class = "Xberg::SparseEmbedding")]
 pub struct SparseEmbedding {
@@ -31232,10 +31656,10 @@ pub struct SparseEmbedding {
     values: Vec<f32>,
 }
 
-#[cfg(feature = "sparse-embedding-presets")]
+#[cfg(any(feature = "sparse-embedding-presets", not(feature = "sparse-embedding-presets")))]
 unsafe impl IntoValueFromNative for SparseEmbedding {}
 
-#[cfg(feature = "sparse-embedding-presets")]
+#[cfg(any(feature = "sparse-embedding-presets", not(feature = "sparse-embedding-presets")))]
 impl magnus::TryConvert for SparseEmbedding {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
         if let Ok(r) = <&SparseEmbedding as magnus::TryConvert>::try_convert(val) {
@@ -31260,10 +31684,10 @@ impl magnus::TryConvert for SparseEmbedding {
     }
 }
 
-#[cfg(feature = "sparse-embedding-presets")]
+#[cfg(any(feature = "sparse-embedding-presets", not(feature = "sparse-embedding-presets")))]
 unsafe impl TryConvertOwned for SparseEmbedding {}
 
-#[cfg(feature = "sparse-embedding-presets")]
+#[cfg(any(feature = "sparse-embedding-presets", not(feature = "sparse-embedding-presets")))]
 impl SparseEmbedding {
     fn new(args: &[magnus::Value]) -> Result<Self, magnus::Error> {
         let ruby = unsafe { magnus::Ruby::get_unchecked() };
@@ -31461,7 +31885,7 @@ impl SparseEmbeddingConfig {
     }
 }
 
-#[cfg(feature = "sparse-embedding-presets")]
+#[cfg(any(feature = "sparse-embedding-presets", not(feature = "sparse-embedding-presets")))]
 #[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
 #[magnus::wrap(class = "Xberg::SparseEmbeddingPreset")]
 pub struct SparseEmbeddingPreset {
@@ -31473,10 +31897,10 @@ pub struct SparseEmbeddingPreset {
     description: String,
 }
 
-#[cfg(feature = "sparse-embedding-presets")]
+#[cfg(any(feature = "sparse-embedding-presets", not(feature = "sparse-embedding-presets")))]
 unsafe impl IntoValueFromNative for SparseEmbeddingPreset {}
 
-#[cfg(feature = "sparse-embedding-presets")]
+#[cfg(any(feature = "sparse-embedding-presets", not(feature = "sparse-embedding-presets")))]
 impl magnus::TryConvert for SparseEmbeddingPreset {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
         if let Ok(r) = <&SparseEmbeddingPreset as magnus::TryConvert>::try_convert(val) {
@@ -31501,10 +31925,10 @@ impl magnus::TryConvert for SparseEmbeddingPreset {
     }
 }
 
-#[cfg(feature = "sparse-embedding-presets")]
+#[cfg(any(feature = "sparse-embedding-presets", not(feature = "sparse-embedding-presets")))]
 unsafe impl TryConvertOwned for SparseEmbeddingPreset {}
 
-#[cfg(feature = "sparse-embedding-presets")]
+#[cfg(any(feature = "sparse-embedding-presets", not(feature = "sparse-embedding-presets")))]
 impl SparseEmbeddingPreset {
     fn new(args: &[magnus::Value]) -> Result<Self, magnus::Error> {
         let ruby = unsafe { magnus::Ruby::get_unchecked() };
@@ -32956,7 +33380,7 @@ pub struct TesseractConfig {
     tessedit_char_blacklist: String,
     tessedit_use_primary_params_model: bool,
     textord_space_size_is_variable: bool,
-    thresholding_method: bool,
+    thresholding_method: i32,
 }
 
 unsafe impl IntoValueFromNative for TesseractConfig {}
@@ -33189,13 +33613,13 @@ impl TesseractConfig {
                 None => true,
             },
             thresholding_method: match kwargs.get(ruby.to_symbol("thresholding_method")) {
-                Some(v) => bool::try_convert(v).map_err(|e| {
+                Some(v) => i32::try_convert(v).map_err(|e| {
                     magnus::Error::new(
                         unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
                         format!("invalid value for `thresholding_method`: {}", e),
                     )
                 })?,
-                None => false,
+                None => 0,
             },
         })
     }
@@ -33280,7 +33704,7 @@ impl TesseractConfig {
         self.textord_space_size_is_variable
     }
 
-    fn thresholding_method(&self) -> bool {
+    fn thresholding_method(&self) -> i32 {
         self.thresholding_method
     }
 }
@@ -36426,6 +36850,59 @@ impl magnus::TryConvert for CandleTrocrVariant {
 unsafe impl IntoValueFromNative for CandleTrocrVariant {}
 unsafe impl TryConvertOwned for CandleTrocrVariant {}
 
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum CaptionAltTextMode {
+    Preserve,
+    Combine,
+    Replace,
+}
+
+impl Default for CaptionAltTextMode {
+    fn default() -> Self {
+        Self::Preserve
+    }
+}
+
+impl magnus::IntoValue for CaptionAltTextMode {
+    fn into_value_with(self, handle: &Ruby) -> magnus::Value {
+        let sym = match self {
+            CaptionAltTextMode::Preserve => "preserve",
+            CaptionAltTextMode::Combine => "combine",
+            CaptionAltTextMode::Replace => "replace",
+        };
+        handle.to_symbol(sym).into_value_with(handle)
+    }
+}
+
+impl magnus::TryConvert for CaptionAltTextMode {
+    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
+        // IntoValue emits Symbols, including when this enum is a Hash key.
+        // Accept that exact representation as well as String inputs; do not
+        // coerce arbitrary objects through to_s.
+        let s: String = if let Some(symbol) = magnus::Symbol::from_value(val) {
+            symbol.name()?.into_owned()
+        } else {
+            magnus::TryConvert::try_convert(val)?
+        };
+        // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
+        // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
+        // existing consumer code written in any of those styles keep working.
+        match s.as_str() {
+            "preserve" | "Preserve" => Ok(CaptionAltTextMode::Preserve),
+            "combine" | "Combine" => Ok(CaptionAltTextMode::Combine),
+            "replace" | "Replace" => Ok(CaptionAltTextMode::Replace),
+            other => Err(magnus::Error::new(
+                unsafe { Ruby::get_unchecked() }.exception_arg_error(),
+                format!("invalid CaptionAltTextMode value: {other}"),
+            )),
+        }
+    }
+}
+
+unsafe impl IntoValueFromNative for CaptionAltTextMode {}
+unsafe impl TryConvertOwned for CaptionAltTextMode {}
+
 #[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
 #[serde(tag = "type")]
 #[serde(rename_all = "snake_case")]
@@ -40917,6 +41394,59 @@ impl magnus::TryConvert for ProcessingStage {
 unsafe impl IntoValueFromNative for ProcessingStage {}
 unsafe impl TryConvertOwned for ProcessingStage {}
 
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum RedactionOffsetEncoding {
+    Utf8Bytes,
+    UnicodeCodePoints,
+    Utf16CodeUnits,
+}
+
+impl Default for RedactionOffsetEncoding {
+    fn default() -> Self {
+        Self::UnicodeCodePoints
+    }
+}
+
+impl magnus::IntoValue for RedactionOffsetEncoding {
+    fn into_value_with(self, handle: &Ruby) -> magnus::Value {
+        let sym = match self {
+            RedactionOffsetEncoding::Utf8Bytes => "utf8_bytes",
+            RedactionOffsetEncoding::UnicodeCodePoints => "unicode_code_points",
+            RedactionOffsetEncoding::Utf16CodeUnits => "utf16_code_units",
+        };
+        handle.to_symbol(sym).into_value_with(handle)
+    }
+}
+
+impl magnus::TryConvert for RedactionOffsetEncoding {
+    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
+        // IntoValue emits Symbols, including when this enum is a Hash key.
+        // Accept that exact representation as well as String inputs; do not
+        // coerce arbitrary objects through to_s.
+        let s: String = if let Some(symbol) = magnus::Symbol::from_value(val) {
+            symbol.name()?.into_owned()
+        } else {
+            magnus::TryConvert::try_convert(val)?
+        };
+        // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
+        // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
+        // existing consumer code written in any of those styles keep working.
+        match s.as_str() {
+            "utf8_bytes" | "Utf8Bytes" => Ok(RedactionOffsetEncoding::Utf8Bytes),
+            "unicode_code_points" | "UnicodeCodePoints" => Ok(RedactionOffsetEncoding::UnicodeCodePoints),
+            "utf16_code_units" | "Utf16CodeUnits" => Ok(RedactionOffsetEncoding::Utf16CodeUnits),
+            other => Err(magnus::Error::new(
+                unsafe { Ruby::get_unchecked() }.exception_arg_error(),
+                format!("invalid RedactionOffsetEncoding value: {other}"),
+            )),
+        }
+    }
+}
+
+unsafe impl IntoValueFromNative for RedactionOffsetEncoding {}
+unsafe impl TryConvertOwned for RedactionOffsetEncoding {}
+
 #[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
 #[serde(rename_all = "snake_case")]
 pub enum RedactionStrategy {
@@ -42514,6 +43044,130 @@ fn extract_batch_async(args: &[magnus::Value]) -> Result<ExtractionResult, Error
     Ok(result.into())
 }
 
+#[cfg(feature = "redaction")]
+fn extract_with_external_redaction(args: &[magnus::Value]) -> Result<ExtractionResult, Error> {
+    let args = magnus::scan_args::scan_args::<
+        (magnus::Value, magnus::Value, String),
+        (Option<magnus::Value>, Option<u32>),
+        (),
+        (),
+        (),
+        (),
+    >(args)?;
+    let (input, config, findings_json) = args.required;
+
+    let (offset_encoding, max_findings) = args.optional;
+
+    let offset_encoding: Option<String> = offset_encoding.and_then(|v| {
+        if v.is_nil() {
+            None
+        } else {
+            Some(String::try_convert(v).unwrap_or_default())
+        }
+    });
+
+    let input_core: xberg::ExtractInput = {
+        let binding_val: ExtractInput = ExtractInput::try_convert(input).map_err(|e| {
+            magnus::Error::new(
+                unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
+                e.to_string(),
+            )
+        })?;
+        binding_val.into()
+    };
+    let config_core: xberg::ExtractionConfig = {
+        let binding_val: ExtractionConfig = ExtractionConfig::try_convert(config).map_err(|e| {
+            magnus::Error::new(
+                unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
+                e.to_string(),
+            )
+        })?;
+        binding_val.into()
+    };
+    let async_result = alef_magnus_run_without_gvl(move || -> Result<_, String> {
+        let rt = tokio::runtime::Builder::new_current_thread()
+            .enable_all()
+            .build()
+            .map_err(|e| e.to_string())?;
+        rt.block_on(async {
+            xberg::extract_with_external_redaction(
+                input_core,
+                &config_core,
+                &findings_json,
+                offset_encoding.as_deref(),
+                max_findings,
+            )
+            .await
+        })
+        .map_err(|e| e.to_string())
+    });
+    let result = async_result
+        .map_err(|message| magnus::Error::new(unsafe { Ruby::get_unchecked() }.exception_runtime_error(), message))?;
+    Ok(result.into())
+}
+
+#[cfg(feature = "redaction")]
+fn extract_with_external_redaction_async(args: &[magnus::Value]) -> Result<ExtractionResult, Error> {
+    let args = magnus::scan_args::scan_args::<
+        (magnus::Value, magnus::Value, String),
+        (Option<magnus::Value>, Option<u32>),
+        (),
+        (),
+        (),
+        (),
+    >(args)?;
+    let (input, config, findings_json) = args.required;
+
+    let (offset_encoding, max_findings) = args.optional;
+
+    let offset_encoding: Option<String> = offset_encoding.and_then(|v| {
+        if v.is_nil() {
+            None
+        } else {
+            Some(String::try_convert(v).unwrap_or_default())
+        }
+    });
+
+    let input_core: xberg::ExtractInput = {
+        let binding_val: ExtractInput = ExtractInput::try_convert(input).map_err(|e| {
+            magnus::Error::new(
+                unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
+                e.to_string(),
+            )
+        })?;
+        binding_val.into()
+    };
+    let config_core: xberg::ExtractionConfig = {
+        let binding_val: ExtractionConfig = ExtractionConfig::try_convert(config).map_err(|e| {
+            magnus::Error::new(
+                unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
+                e.to_string(),
+            )
+        })?;
+        binding_val.into()
+    };
+    let async_result = alef_magnus_run_without_gvl(move || -> Result<_, String> {
+        let rt = tokio::runtime::Builder::new_current_thread()
+            .enable_all()
+            .build()
+            .map_err(|e| e.to_string())?;
+        rt.block_on(async {
+            xberg::extract_with_external_redaction(
+                input_core,
+                &config_core,
+                &findings_json,
+                offset_encoding.as_deref(),
+                max_findings,
+            )
+            .await
+        })
+        .map_err(|e| e.to_string())
+    });
+    let result = async_result
+        .map_err(|message| magnus::Error::new(unsafe { Ruby::get_unchecked() }.exception_runtime_error(), message))?;
+    Ok(result.into())
+}
+
 #[cfg(feature = "markdown-footnotes")]
 fn find_unmarked_claims(markdown: String) -> Vec<String> {
     xberg::find_unmarked_claims(&markdown)
@@ -42549,6 +43203,31 @@ fn list_ocr_backend_capabilities() -> Result<Vec<OcrBackendCapabilities>, Error>
     Ok(result.into_iter().map(Into::into).collect())
 }
 
+fn list_ocr_backend_capabilities_for(args: &[magnus::Value]) -> Result<Vec<OcrBackendCapabilities>, Error> {
+    let args = magnus::scan_args::scan_args::<(), (Option<magnus::Value>,), (), (), (), ()>(args)?;
+    let (config,) = args.optional;
+
+    let config_core: xberg::OcrConfig = match config {
+        Some(_v) if !_v.is_nil() => {
+            let binding_val: OcrConfig = OcrConfig::try_convert(_v).map_err(|e| {
+                magnus::Error::new(
+                    unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
+                    e.to_string(),
+                )
+            })?;
+            binding_val.into()
+        }
+        _ => Default::default(),
+    };
+    let result = xberg::list_ocr_backend_capabilities_for(&config_core).map_err(|e| {
+        magnus::Error::new(
+            unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
+            e.to_string(),
+        )
+    })?;
+    Ok(result.into_iter().map(Into::into).collect())
+}
+
 fn list_ocr_backends() -> Result<Vec<String>, Error> {
     let result = xberg::list_ocr_backends().map_err(|e| {
         magnus::Error::new(
@@ -42734,6 +43413,165 @@ fn ocr_backend_supports_language(backend: String, language: String) -> Result<bo
     Ok(result)
 }
 
+fn ocr_backend_supports_language_for(args: &[magnus::Value]) -> Result<bool, Error> {
+    let args = magnus::scan_args::scan_args::<(String, String), (Option<magnus::Value>,), (), (), (), ()>(args)?;
+    let (backend, language) = args.required;
+
+    let (config,) = args.optional;
+
+    let config_core: xberg::OcrConfig = match config {
+        Some(_v) if !_v.is_nil() => {
+            let binding_val: OcrConfig = OcrConfig::try_convert(_v).map_err(|e| {
+                magnus::Error::new(
+                    unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
+                    e.to_string(),
+                )
+            })?;
+            binding_val.into()
+        }
+        _ => Default::default(),
+    };
+    let result = xberg::ocr_backend_supports_language_for(&backend, &language, &config_core).map_err(|e| {
+        magnus::Error::new(
+            unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
+            e.to_string(),
+        )
+    })?;
+    Ok(result)
+}
+
+#[cfg(feature = "pdf")]
+fn pdf_page_count(args: &[magnus::Value]) -> Result<usize, Error> {
+    let args = magnus::scan_args::scan_args::<(Vec<u8>,), (Option<magnus::Value>,), (), (), (), ()>(args)?;
+    let (pdf_bytes,) = args.required;
+
+    let (password,) = args.optional;
+
+    let password: Option<String> = password.and_then(|v| {
+        if v.is_nil() {
+            None
+        } else {
+            Some(String::try_convert(v).unwrap_or_default())
+        }
+    });
+
+    let result = xberg::pdf_page_count(&pdf_bytes, password.as_deref()).map_err(|e| {
+        magnus::Error::new(
+            unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
+            e.to_string(),
+        )
+    })?;
+    Ok(result)
+}
+
+#[cfg(feature = "redaction")]
+fn redact_external(args: &[magnus::Value]) -> Result<ExtractedDocument, Error> {
+    let args = magnus::scan_args::scan_args::<
+        (magnus::Value, magnus::Value, String),
+        (Option<magnus::Value>, Option<u32>),
+        (),
+        (),
+        (),
+        (),
+    >(args)?;
+    let (document, config, findings_json) = args.required;
+
+    let (offset_encoding, max_findings) = args.optional;
+
+    let offset_encoding: Option<String> = offset_encoding.and_then(|v| {
+        if v.is_nil() {
+            None
+        } else {
+            Some(String::try_convert(v).unwrap_or_default())
+        }
+    });
+
+    let document: xberg::ExtractedDocument = {
+        let binding_val: ExtractedDocument = ExtractedDocument::try_convert(document)
+            .map_err(|e| magnus::Error::new(unsafe { Ruby::get_unchecked() }.exception_type_error(), e.to_string()))?;
+        binding_val.into()
+    };
+    let config: xberg::RedactionConfig = {
+        let binding_val: RedactionConfig = RedactionConfig::try_convert(config)
+            .map_err(|e| magnus::Error::new(unsafe { Ruby::get_unchecked() }.exception_type_error(), e.to_string()))?;
+        binding_val.into()
+    };
+    let async_result = alef_magnus_run_without_gvl(move || -> Result<_, String> {
+        let rt = tokio::runtime::Builder::new_current_thread()
+            .enable_all()
+            .build()
+            .map_err(|e| e.to_string())?;
+        rt.block_on(async {
+            xberg::redact_external(
+                document.into(),
+                config.into(),
+                &findings_json,
+                offset_encoding.as_deref(),
+                max_findings,
+            )
+            .await
+        })
+        .map_err(|e| e.to_string())
+    });
+    let result = async_result
+        .map_err(|message| magnus::Error::new(unsafe { Ruby::get_unchecked() }.exception_runtime_error(), message))?;
+    Ok(result.into())
+}
+
+#[cfg(feature = "redaction")]
+fn redact_external_async(args: &[magnus::Value]) -> Result<ExtractedDocument, Error> {
+    let args = magnus::scan_args::scan_args::<
+        (magnus::Value, magnus::Value, String),
+        (Option<magnus::Value>, Option<u32>),
+        (),
+        (),
+        (),
+        (),
+    >(args)?;
+    let (document, config, findings_json) = args.required;
+
+    let (offset_encoding, max_findings) = args.optional;
+
+    let offset_encoding: Option<String> = offset_encoding.and_then(|v| {
+        if v.is_nil() {
+            None
+        } else {
+            Some(String::try_convert(v).unwrap_or_default())
+        }
+    });
+
+    let document: xberg::ExtractedDocument = {
+        let binding_val: ExtractedDocument = ExtractedDocument::try_convert(document)
+            .map_err(|e| magnus::Error::new(unsafe { Ruby::get_unchecked() }.exception_type_error(), e.to_string()))?;
+        binding_val.into()
+    };
+    let config: xberg::RedactionConfig = {
+        let binding_val: RedactionConfig = RedactionConfig::try_convert(config)
+            .map_err(|e| magnus::Error::new(unsafe { Ruby::get_unchecked() }.exception_type_error(), e.to_string()))?;
+        binding_val.into()
+    };
+    let async_result = alef_magnus_run_without_gvl(move || -> Result<_, String> {
+        let rt = tokio::runtime::Builder::new_current_thread()
+            .enable_all()
+            .build()
+            .map_err(|e| e.to_string())?;
+        rt.block_on(async {
+            xberg::redact_external(
+                document.into(),
+                config.into(),
+                &findings_json,
+                offset_encoding.as_deref(),
+                max_findings,
+            )
+            .await
+        })
+        .map_err(|e| e.to_string())
+    });
+    let result = async_result
+        .map_err(|message| magnus::Error::new(unsafe { Ruby::get_unchecked() }.exception_runtime_error(), message))?;
+    Ok(result.into())
+}
+
 #[cfg(feature = "markdown-footnotes")]
 fn verify_excerpt(excerpt: String, source_text: String) -> bool {
     xberg::verify_excerpt(&excerpt, &source_text)
@@ -42842,6 +43680,8 @@ pub struct RbOcrBackendBridge {
     cached_name: String,
     has_process_image_file: bool,
     has_supported_languages: bool,
+    has_supported_languages_for: bool,
+    has_supports_language_for: bool,
     has_supports_table_detection: bool,
     has_supports_document_processing: bool,
     has_emits_structured_markdown: bool,
@@ -42894,6 +43734,8 @@ impl RbOcrBackendBridge {
             runtime_dispatcher,
             has_process_image_file: rb_obj.respond_to("process_image_file", false).unwrap_or(false),
             has_supported_languages: rb_obj.respond_to("supported_languages", false).unwrap_or(false),
+            has_supported_languages_for: rb_obj.respond_to("supported_languages_for", false).unwrap_or(false),
+            has_supports_language_for: rb_obj.respond_to("supports_language_for", false).unwrap_or(false),
             has_supports_table_detection: rb_obj.respond_to("supports_table_detection", false).unwrap_or(false),
             has_supports_document_processing: rb_obj
                 .respond_to("supports_document_processing", false)
@@ -43220,6 +44062,88 @@ impl xberg::OcrBackend for RbOcrBackendBridge {
         }
     }
 
+    fn supported_languages_for(&self, config: &xberg::OcrConfig) -> Vec<String> {
+        if !(self.has_supported_languages_for) {
+            return RbOcrBackendBridgeDefaultSupportedLanguagesFor(self).supported_languages_for(config);
+        }
+        let config = config.clone();
+        let callback = move |ruby: &magnus::Ruby, value: magnus::Value| -> Vec<String> {
+            let val: magnus::Value = match value.funcall::<_, _, magnus::Value>(
+                "supported_languages_for",
+                ({
+                    use magnus::IntoValue;
+                    OcrConfig::from(config.clone()).into_value_with(&ruby)
+                },),
+            ) {
+                Ok(v) => v,
+                Err(e) => {
+                    // This method's Rust signature is infallible, so a Ruby exception cannot
+                    // propagate. Log before substituting the default — a silent default is
+                    // indistinguishable from a real result to the caller.
+                    tracing::warn!(wrapper = "RbOcrBackendBridge", method = "supported_languages_for", error = %e, "host callback raised; returning default");
+                    return Default::default();
+                }
+            };
+            <Vec<String> as magnus::TryConvert>::try_convert(val).unwrap_or_else(|e| {
+                tracing::warn!(wrapper = "RbOcrBackendBridge", method = "supported_languages_for", error = %e, "host returned an unconvertible value; returning default");
+                Default::default()
+            })
+        };
+        match magnus::Ruby::get() {
+            Ok(ruby) => callback(&ruby, self.inner.get_inner_with(&ruby)),
+            Err(_) => match self.runtime_dispatcher.dispatch(callback) {
+                Ok(result) => result,
+                Err(error) => {
+                    tracing::warn!(wrapper = "RbOcrBackendBridge", method = "supported_languages_for", %error, "Ruby runtime dispatcher failed; returning default");
+                    Default::default()
+                }
+            },
+        }
+    }
+
+    fn supports_language_for(&self, config: &xberg::OcrConfig, language: &str) -> bool {
+        if !(self.has_supports_language_for) {
+            return RbOcrBackendBridgeDefaultSupportsLanguageFor(self).supports_language_for(config, language);
+        }
+        let config = config.clone();
+        let language = language.to_string();
+        let callback = move |ruby: &magnus::Ruby, value: magnus::Value| -> bool {
+            let val: magnus::Value = match value.funcall::<_, _, magnus::Value>(
+                "supports_language_for",
+                (
+                    {
+                        use magnus::IntoValue;
+                        OcrConfig::from(config.clone()).into_value_with(&ruby)
+                    },
+                    ruby.str_new(AsRef::<str>::as_ref(&language)).as_value(),
+                ),
+            ) {
+                Ok(v) => v,
+                Err(e) => {
+                    // This method's Rust signature is infallible, so a Ruby exception cannot
+                    // propagate. Log before substituting the default — a silent default is
+                    // indistinguishable from a real result to the caller.
+                    tracing::warn!(wrapper = "RbOcrBackendBridge", method = "supports_language_for", error = %e, "host callback raised; returning default");
+                    return Default::default();
+                }
+            };
+            <bool as magnus::TryConvert>::try_convert(val).unwrap_or_else(|e| {
+                tracing::warn!(wrapper = "RbOcrBackendBridge", method = "supports_language_for", error = %e, "host returned an unconvertible value; returning default");
+                Default::default()
+            })
+        };
+        match magnus::Ruby::get() {
+            Ok(ruby) => callback(&ruby, self.inner.get_inner_with(&ruby)),
+            Err(_) => match self.runtime_dispatcher.dispatch(callback) {
+                Ok(result) => result,
+                Err(error) => {
+                    tracing::warn!(wrapper = "RbOcrBackendBridge", method = "supports_language_for", %error, "Ruby runtime dispatcher failed; returning default");
+                    Default::default()
+                }
+            },
+        }
+    }
+
     fn supports_table_detection(&self) -> bool {
         if !(self.has_supports_table_detection) {
             return RbOcrBackendBridgeDefaultSupportsTableDetection(self).supports_table_detection();
@@ -43502,6 +44426,12 @@ impl xberg::OcrBackend for RbOcrBackendBridgeDefaultProcessImageFile<'_> {
     fn supported_languages(&self) -> Vec<String> {
         xberg::OcrBackend::supported_languages(self.0)
     }
+    fn supported_languages_for(&self, config: &xberg::OcrConfig) -> Vec<String> {
+        xberg::OcrBackend::supported_languages_for(self.0, config)
+    }
+    fn supports_language_for(&self, config: &xberg::OcrConfig, language: &str) -> bool {
+        xberg::OcrBackend::supports_language_for(self.0, config, language)
+    }
     fn supports_table_detection(&self) -> bool {
         xberg::OcrBackend::supports_table_detection(self.0)
     }
@@ -43570,6 +44500,160 @@ impl xberg::OcrBackend for RbOcrBackendBridgeDefaultSupportedLanguages<'_> {
     fn backend_type(&self) -> xberg::OcrBackendType {
         xberg::OcrBackend::backend_type(self.0)
     }
+    fn supported_languages_for(&self, config: &xberg::OcrConfig) -> Vec<String> {
+        xberg::OcrBackend::supported_languages_for(self.0, config)
+    }
+    fn supports_language_for(&self, config: &xberg::OcrConfig, language: &str) -> bool {
+        xberg::OcrBackend::supports_language_for(self.0, config, language)
+    }
+    fn supports_table_detection(&self) -> bool {
+        xberg::OcrBackend::supports_table_detection(self.0)
+    }
+    fn supports_document_processing(&self) -> bool {
+        xberg::OcrBackend::supports_document_processing(self.0)
+    }
+    fn emits_structured_markdown(&self) -> bool {
+        xberg::OcrBackend::emits_structured_markdown(self.0)
+    }
+    fn confidence_semantics(&self) -> xberg::ConfidenceSemantics {
+        xberg::OcrBackend::confidence_semantics(self.0)
+    }
+    fn page_orientation_handling(&self) -> xberg::PageOrientationHandling {
+        xberg::OcrBackend::page_orientation_handling(self.0)
+    }
+    async fn process_document(
+        &self,
+        _path: &std::path::Path,
+        _config: &xberg::OcrConfig,
+    ) -> std::result::Result<xberg::ExtractedDocument, xberg::XbergError> {
+        xberg::OcrBackend::process_document(self.0, _path, _config).await
+    }
+}
+
+/// Runs `supported_languages_for`'s Rust default body for [`RbOcrBackendBridge`] while routing
+/// every other trait method back through the bridge, so the default body's `self.*`
+/// calls still reach host overrides.
+#[derive(Debug)]
+struct RbOcrBackendBridgeDefaultSupportedLanguagesFor<'a>(&'a RbOcrBackendBridge);
+impl xberg::plugins::Plugin for RbOcrBackendBridgeDefaultSupportedLanguagesFor<'_> {
+    fn name(&self) -> &str {
+        xberg::plugins::Plugin::name(self.0)
+    }
+
+    fn version(&self) -> String {
+        xberg::plugins::Plugin::version(self.0)
+    }
+
+    fn initialize(&self) -> std::result::Result<(), xberg::XbergError> {
+        xberg::plugins::Plugin::initialize(self.0)
+    }
+
+    fn shutdown(&self) -> std::result::Result<(), xberg::XbergError> {
+        xberg::plugins::Plugin::shutdown(self.0)
+    }
+}
+#[async_trait::async_trait]
+impl xberg::OcrBackend for RbOcrBackendBridgeDefaultSupportedLanguagesFor<'_> {
+    async fn process_image(
+        &self,
+        image_bytes: &[u8],
+        config: &xberg::OcrConfig,
+    ) -> std::result::Result<xberg::ExtractedDocument, xberg::XbergError> {
+        xberg::OcrBackend::process_image(self.0, image_bytes, config).await
+    }
+    async fn process_image_file(
+        &self,
+        path: &std::path::Path,
+        config: &xberg::OcrConfig,
+    ) -> std::result::Result<xberg::ExtractedDocument, xberg::XbergError> {
+        xberg::OcrBackend::process_image_file(self.0, path, config).await
+    }
+    fn supports_language(&self, lang: &str) -> bool {
+        xberg::OcrBackend::supports_language(self.0, lang)
+    }
+    fn backend_type(&self) -> xberg::OcrBackendType {
+        xberg::OcrBackend::backend_type(self.0)
+    }
+    fn supported_languages(&self) -> Vec<String> {
+        xberg::OcrBackend::supported_languages(self.0)
+    }
+    fn supports_language_for(&self, config: &xberg::OcrConfig, language: &str) -> bool {
+        xberg::OcrBackend::supports_language_for(self.0, config, language)
+    }
+    fn supports_table_detection(&self) -> bool {
+        xberg::OcrBackend::supports_table_detection(self.0)
+    }
+    fn supports_document_processing(&self) -> bool {
+        xberg::OcrBackend::supports_document_processing(self.0)
+    }
+    fn emits_structured_markdown(&self) -> bool {
+        xberg::OcrBackend::emits_structured_markdown(self.0)
+    }
+    fn confidence_semantics(&self) -> xberg::ConfidenceSemantics {
+        xberg::OcrBackend::confidence_semantics(self.0)
+    }
+    fn page_orientation_handling(&self) -> xberg::PageOrientationHandling {
+        xberg::OcrBackend::page_orientation_handling(self.0)
+    }
+    async fn process_document(
+        &self,
+        _path: &std::path::Path,
+        _config: &xberg::OcrConfig,
+    ) -> std::result::Result<xberg::ExtractedDocument, xberg::XbergError> {
+        xberg::OcrBackend::process_document(self.0, _path, _config).await
+    }
+}
+
+/// Runs `supports_language_for`'s Rust default body for [`RbOcrBackendBridge`] while routing
+/// every other trait method back through the bridge, so the default body's `self.*`
+/// calls still reach host overrides.
+#[derive(Debug)]
+struct RbOcrBackendBridgeDefaultSupportsLanguageFor<'a>(&'a RbOcrBackendBridge);
+impl xberg::plugins::Plugin for RbOcrBackendBridgeDefaultSupportsLanguageFor<'_> {
+    fn name(&self) -> &str {
+        xberg::plugins::Plugin::name(self.0)
+    }
+
+    fn version(&self) -> String {
+        xberg::plugins::Plugin::version(self.0)
+    }
+
+    fn initialize(&self) -> std::result::Result<(), xberg::XbergError> {
+        xberg::plugins::Plugin::initialize(self.0)
+    }
+
+    fn shutdown(&self) -> std::result::Result<(), xberg::XbergError> {
+        xberg::plugins::Plugin::shutdown(self.0)
+    }
+}
+#[async_trait::async_trait]
+impl xberg::OcrBackend for RbOcrBackendBridgeDefaultSupportsLanguageFor<'_> {
+    async fn process_image(
+        &self,
+        image_bytes: &[u8],
+        config: &xberg::OcrConfig,
+    ) -> std::result::Result<xberg::ExtractedDocument, xberg::XbergError> {
+        xberg::OcrBackend::process_image(self.0, image_bytes, config).await
+    }
+    async fn process_image_file(
+        &self,
+        path: &std::path::Path,
+        config: &xberg::OcrConfig,
+    ) -> std::result::Result<xberg::ExtractedDocument, xberg::XbergError> {
+        xberg::OcrBackend::process_image_file(self.0, path, config).await
+    }
+    fn supports_language(&self, lang: &str) -> bool {
+        xberg::OcrBackend::supports_language(self.0, lang)
+    }
+    fn backend_type(&self) -> xberg::OcrBackendType {
+        xberg::OcrBackend::backend_type(self.0)
+    }
+    fn supported_languages(&self) -> Vec<String> {
+        xberg::OcrBackend::supported_languages(self.0)
+    }
+    fn supported_languages_for(&self, config: &xberg::OcrConfig) -> Vec<String> {
+        xberg::OcrBackend::supported_languages_for(self.0, config)
+    }
     fn supports_table_detection(&self) -> bool {
         xberg::OcrBackend::supports_table_detection(self.0)
     }
@@ -43641,6 +44725,12 @@ impl xberg::OcrBackend for RbOcrBackendBridgeDefaultSupportsTableDetection<'_> {
     fn supported_languages(&self) -> Vec<String> {
         xberg::OcrBackend::supported_languages(self.0)
     }
+    fn supported_languages_for(&self, config: &xberg::OcrConfig) -> Vec<String> {
+        xberg::OcrBackend::supported_languages_for(self.0, config)
+    }
+    fn supports_language_for(&self, config: &xberg::OcrConfig, language: &str) -> bool {
+        xberg::OcrBackend::supports_language_for(self.0, config, language)
+    }
     fn supports_document_processing(&self) -> bool {
         xberg::OcrBackend::supports_document_processing(self.0)
     }
@@ -43709,6 +44799,12 @@ impl xberg::OcrBackend for RbOcrBackendBridgeDefaultSupportsDocumentProcessing<'
     fn supported_languages(&self) -> Vec<String> {
         xberg::OcrBackend::supported_languages(self.0)
     }
+    fn supported_languages_for(&self, config: &xberg::OcrConfig) -> Vec<String> {
+        xberg::OcrBackend::supported_languages_for(self.0, config)
+    }
+    fn supports_language_for(&self, config: &xberg::OcrConfig, language: &str) -> bool {
+        xberg::OcrBackend::supports_language_for(self.0, config, language)
+    }
     fn supports_table_detection(&self) -> bool {
         xberg::OcrBackend::supports_table_detection(self.0)
     }
@@ -43777,6 +44873,12 @@ impl xberg::OcrBackend for RbOcrBackendBridgeDefaultEmitsStructuredMarkdown<'_>
     fn supported_languages(&self) -> Vec<String> {
         xberg::OcrBackend::supported_languages(self.0)
     }
+    fn supported_languages_for(&self, config: &xberg::OcrConfig) -> Vec<String> {
+        xberg::OcrBackend::supported_languages_for(self.0, config)
+    }
+    fn supports_language_for(&self, config: &xberg::OcrConfig, language: &str) -> bool {
+        xberg::OcrBackend::supports_language_for(self.0, config, language)
+    }
     fn supports_table_detection(&self) -> bool {
         xberg::OcrBackend::supports_table_detection(self.0)
     }
@@ -43845,6 +44947,12 @@ impl xberg::OcrBackend for RbOcrBackendBridgeDefaultConfidenceSemantics<'_> {
     fn supported_languages(&self) -> Vec<String> {
         xberg::OcrBackend::supported_languages(self.0)
     }
+    fn supported_languages_for(&self, config: &xberg::OcrConfig) -> Vec<String> {
+        xberg::OcrBackend::supported_languages_for(self.0, config)
+    }
+    fn supports_language_for(&self, config: &xberg::OcrConfig, language: &str) -> bool {
+        xberg::OcrBackend::supports_language_for(self.0, config, language)
+    }
     fn supports_table_detection(&self) -> bool {
         xberg::OcrBackend::supports_table_detection(self.0)
     }
@@ -43913,6 +45021,12 @@ impl xberg::OcrBackend for RbOcrBackendBridgeDefaultPageOrientationHandling<'_>
     fn supported_languages(&self) -> Vec<String> {
         xberg::OcrBackend::supported_languages(self.0)
     }
+    fn supported_languages_for(&self, config: &xberg::OcrConfig) -> Vec<String> {
+        xberg::OcrBackend::supported_languages_for(self.0, config)
+    }
+    fn supports_language_for(&self, config: &xberg::OcrConfig, language: &str) -> bool {
+        xberg::OcrBackend::supports_language_for(self.0, config, language)
+    }
     fn supports_table_detection(&self) -> bool {
         xberg::OcrBackend::supports_table_detection(self.0)
     }
@@ -43981,6 +45095,12 @@ impl xberg::OcrBackend for RbOcrBackendBridgeDefaultProcessDocument<'_> {
     fn supported_languages(&self) -> Vec<String> {
         xberg::OcrBackend::supported_languages(self.0)
     }
+    fn supported_languages_for(&self, config: &xberg::OcrConfig) -> Vec<String> {
+        xberg::OcrBackend::supported_languages_for(self.0, config)
+    }
+    fn supports_language_for(&self, config: &xberg::OcrConfig, language: &str) -> bool {
+        xberg::OcrBackend::supports_language_for(self.0, config, language)
+    }
     fn supports_table_detection(&self) -> bool {
         xberg::OcrBackend::supports_table_detection(self.0)
     }
@@ -47128,6 +48248,8 @@ impl From<BrowserConfig> for crawlberg::BrowserConfig {
             backend: val.backend.into(),
             endpoint: val.endpoint,
             timeout: std::time::Duration::from_millis(val.timeout),
+            overall_timeout: std::time::Duration::from_millis(val.overall_timeout),
+            shutdown_timeout: std::time::Duration::from_millis(val.shutdown_timeout),
             wait: val.wait.into(),
             wait_selector: val.wait_selector,
             extra_wait: val.extra_wait.map(std::time::Duration::from_millis),
@@ -47150,6 +48272,8 @@ impl From<crawlberg::BrowserConfig> for BrowserConfig {
             backend: val.backend.into(),
             endpoint: val.endpoint.map(|v| v.to_string()),
             timeout: val.timeout.as_millis() as u64,
+            overall_timeout: val.overall_timeout.as_millis() as u64,
+            shutdown_timeout: val.shutdown_timeout.as_millis() as u64,
             wait: val.wait.into(),
             wait_selector: val.wait_selector.map(|v| v.to_string()),
             extra_wait: val.extra_wait.map(|d| d.as_millis() as u64),
@@ -47182,6 +48306,7 @@ impl From<CaptioningConfig> for xberg::CaptioningConfig {
             llm: val.llm.into(),
             prompt: val.prompt,
             min_image_area: val.min_image_area,
+            alt_text: val.alt_text.into(),
         }
     }
 }
@@ -47193,6 +48318,7 @@ impl From<xberg::CaptioningConfig> for CaptioningConfig {
             llm: val.llm.into(),
             prompt: val.prompt.map(|v| v.to_string()),
             min_image_area: val.min_image_area,
+            alt_text: val.alt_text.into(),
         }
     }
 }
@@ -47226,9 +48352,9 @@ impl From<Chunk> for xberg::Chunk {
             content: val.content,
             chunk_type: val.chunk_type.into(),
             embedding: val.embedding.map(|v| v.into_iter().collect()),
-            #[cfg(feature = "sparse-embedding-presets")]
+            #[cfg(any(feature = "sparse-embedding-presets", not(feature = "sparse-embedding-presets")))]
             sparse_embedding: val.sparse_embedding.map(Into::into),
-            #[cfg(feature = "late-interaction-presets")]
+            #[cfg(any(feature = "late-interaction-presets", not(feature = "late-interaction-presets")))]
             late_interaction: val.late_interaction.map(Into::into),
             metadata: val.metadata.into(),
         }
@@ -47242,9 +48368,9 @@ impl From<xberg::Chunk> for Chunk {
             content: val.content.to_string(),
             chunk_type: val.chunk_type.into(),
             embedding: val.embedding.map(|v| v.into_iter().collect()),
-            #[cfg(feature = "sparse-embedding-presets")]
+            #[cfg(any(feature = "sparse-embedding-presets", not(feature = "sparse-embedding-presets")))]
             sparse_embedding: val.sparse_embedding.map(Into::into),
-            #[cfg(feature = "late-interaction-presets")]
+            #[cfg(any(feature = "late-interaction-presets", not(feature = "late-interaction-presets")))]
             late_interaction: val.late_interaction.map(Into::into),
             metadata: val.metadata.into(),
         }
@@ -47611,6 +48737,7 @@ impl From<ContentConfig> for crawlberg::ContentConfig {
             wrap: val.wrap,
             wrap_width: val.wrap_width,
             include_document_structure: val.include_document_structure,
+            extract_metadata: val.extract_metadata,
             ..Default::default()
         }
     }
@@ -47631,6 +48758,7 @@ impl From<crawlberg::ContentConfig> for ContentConfig {
             wrap: val.wrap,
             wrap_width: val.wrap_width,
             include_document_structure: val.include_document_structure,
+            extract_metadata: val.extract_metadata,
         }
     }
 }
@@ -47728,12 +48856,13 @@ impl From<ConversionOptions> for html_to_markdown_rs::ConversionOptions {
             max_depth: val.max_depth,
             exclude_selectors: val.exclude_selectors.into_iter().collect(),
             tier_strategy: val.tier_strategy.into(),
+            base_url: val.base_url,
             ..Default::default()
         }
     }
 }
 
-#[allow(clippy::useless_conversion)]
+#[allow(clippy::redundant_closure, clippy::useless_conversion)]
 impl From<html_to_markdown_rs::ConversionOptions> for ConversionOptions {
     fn from(val: html_to_markdown_rs::ConversionOptions) -> Self {
         Self {
@@ -47780,6 +48909,7 @@ impl From<html_to_markdown_rs::ConversionOptions> for ConversionOptions {
             max_depth: val.max_depth,
             exclude_selectors: val.exclude_selectors.into_iter().collect(),
             tier_strategy: val.tier_strategy.into(),
+            base_url: val.base_url.map(|v| v.to_string()),
         }
     }
 }
@@ -47853,6 +48983,10 @@ impl From<CrawlConfig> for crawlberg::CrawlConfig {
             allow_subdomains: val.allow_subdomains,
             include_paths: val.include_paths.into_iter().collect(),
             exclude_paths: val.exclude_paths.into_iter().collect(),
+            path_patterns_match_query: val.path_patterns_match_query,
+            dedup_include_query: val.dedup_include_query,
+            strip_tracking_params: val.strip_tracking_params,
+            tracking_params: val.tracking_params.into_iter().collect(),
             custom_headers: val
                 .custom_headers
                 .into_iter()
@@ -47863,6 +48997,9 @@ impl From<CrawlConfig> for crawlberg::CrawlConfig {
             max_redirects: val.max_redirects,
             retry_count: val.retry_count,
             retry_codes: val.retry_codes.into_iter().collect(),
+            retry_initial_delay_ms: val.retry_initial_delay_ms,
+            retry_max_delay_ms: val.retry_max_delay_ms,
+            rate_limit_jitter_ratio: val.rate_limit_jitter_ratio,
             cookies_enabled: val.cookies_enabled,
             auth: val.auth.map(Into::into),
             max_body_size: val.max_body_size,
@@ -47913,6 +49050,10 @@ impl From<crawlberg::CrawlConfig> for CrawlConfig {
             allow_subdomains: val.allow_subdomains,
             include_paths: val.include_paths.into_iter().collect(),
             exclude_paths: val.exclude_paths.into_iter().collect(),
+            path_patterns_match_query: val.path_patterns_match_query,
+            dedup_include_query: val.dedup_include_query,
+            strip_tracking_params: val.strip_tracking_params,
+            tracking_params: val.tracking_params.into_iter().collect(),
             custom_headers: val
                 .custom_headers
                 .into_iter()
@@ -47923,6 +49064,9 @@ impl From<crawlberg::CrawlConfig> for CrawlConfig {
             max_redirects: val.max_redirects,
             retry_count: val.retry_count,
             retry_codes: val.retry_codes.into_iter().collect(),
+            retry_initial_delay_ms: val.retry_initial_delay_ms,
+            retry_max_delay_ms: val.retry_max_delay_ms,
+            rate_limit_jitter_ratio: val.rate_limit_jitter_ratio,
             cookies_enabled: val.cookies_enabled,
             auth: val.auth.map(Into::into),
             max_body_size: val.max_body_size,
@@ -48876,6 +50020,33 @@ impl From<xberg::ExcelWorkbook> for ExcelWorkbook {
     }
 }
 
+#[allow(clippy::needless_update)]
+impl From<ExternalRedactionFinding> for xberg::ExternalRedactionFinding {
+    fn from(val: ExternalRedactionFinding) -> Self {
+        Self {
+            label: val.label,
+            text: val.text,
+            start: val.start,
+            end: val.end,
+            score: val.score,
+            ..Default::default()
+        }
+    }
+}
+
+#[allow(clippy::redundant_closure)]
+impl From<xberg::ExternalRedactionFinding> for ExternalRedactionFinding {
+    fn from(val: xberg::ExternalRedactionFinding) -> Self {
+        Self {
+            label: val.label.to_string(),
+            text: val.text.map(|v| v.to_string()),
+            start: val.start,
+            end: val.end,
+            score: val.score,
+        }
+    }
+}
+
 #[allow(clippy::needless_update)]
 #[allow(clippy::redundant_closure, clippy::useless_conversion)]
 impl From<ExtractInput> for xberg::ExtractInput {
@@ -50074,6 +51245,7 @@ impl From<ImagePreprocessingConfig> for xberg::ImagePreprocessingConfig {
             contrast_enhance: val.contrast_enhance,
             binarization_method: val.binarization_method,
             invert_colors: val.invert_colors,
+            normalize_shaded_rows: val.normalize_shaded_rows,
             ..Default::default()
         }
     }
@@ -50089,6 +51261,7 @@ impl From<xberg::ImagePreprocessingConfig> for ImagePreprocessingConfig {
             contrast_enhance: val.contrast_enhance,
             binarization_method: val.binarization_method.to_string(),
             invert_colors: val.invert_colors,
+            normalize_shaded_rows: val.normalize_shaded_rows,
         }
     }
 }
@@ -50361,7 +51534,7 @@ impl From<xberg::LateInteractionConfig> for LateInteractionConfig {
     }
 }
 
-#[cfg(feature = "late-interaction-presets")]
+#[cfg(any(feature = "late-interaction-presets", not(feature = "late-interaction-presets")))]
 impl From<LateInteractionMatch> for xberg::LateInteractionMatch {
     fn from(val: LateInteractionMatch) -> Self {
         Self {
@@ -50371,7 +51544,7 @@ impl From<LateInteractionMatch> for xberg::LateInteractionMatch {
     }
 }
 
-#[cfg(feature = "late-interaction-presets")]
+#[cfg(any(feature = "late-interaction-presets", not(feature = "late-interaction-presets")))]
 impl From<xberg::LateInteractionMatch> for LateInteractionMatch {
     fn from(val: xberg::LateInteractionMatch) -> Self {
         Self {
@@ -50381,7 +51554,7 @@ impl From<xberg::LateInteractionMatch> for LateInteractionMatch {
     }
 }
 
-#[cfg(feature = "late-interaction-presets")]
+#[cfg(any(feature = "late-interaction-presets", not(feature = "late-interaction-presets")))]
 impl From<xberg::LateInteractionPreset> for LateInteractionPreset {
     fn from(val: xberg::LateInteractionPreset) -> Self {
         Self {
@@ -50840,7 +52013,6 @@ impl From<xberg::Metadata> for Metadata {
     }
 }
 
-#[cfg(feature = "paddle-ocr-types")]
 impl From<xberg::ModelPaths> for ModelPaths {
     fn from(val: xberg::ModelPaths) -> Self {
         Self {
@@ -50852,7 +52024,7 @@ impl From<xberg::ModelPaths> for ModelPaths {
     }
 }
 
-#[cfg(feature = "late-interaction-presets")]
+#[cfg(any(feature = "late-interaction-presets", not(feature = "late-interaction-presets")))]
 impl From<MultiVectorEmbedding> for xberg::MultiVectorEmbedding {
     fn from(val: MultiVectorEmbedding) -> Self {
         Self {
@@ -50863,7 +52035,7 @@ impl From<MultiVectorEmbedding> for xberg::MultiVectorEmbedding {
     }
 }
 
-#[cfg(feature = "late-interaction-presets")]
+#[cfg(any(feature = "late-interaction-presets", not(feature = "late-interaction-presets")))]
 impl From<xberg::MultiVectorEmbedding> for MultiVectorEmbedding {
     fn from(val: xberg::MultiVectorEmbedding) -> Self {
         Self {
@@ -51010,6 +52182,7 @@ impl From<OcrConfig> for xberg::OcrConfig {
                 .paddle_ocr_config
                 .as_ref()
                 .and_then(|s| serde_json::from_str(s).ok()),
+            paddle_ocr_settings: val.paddle_ocr_settings.map(Into::into),
             backend_options: val.backend_options.as_ref().and_then(|s| serde_json::from_str(s).ok()),
             element_config: val.element_config.map(Into::into),
             quality_thresholds: val.quality_thresholds.map(Into::into),
@@ -51024,6 +52197,7 @@ impl From<OcrConfig> for xberg::OcrConfig {
                 .tessdata_bytes
                 .map(|m| m.into_iter().map(|(k, v)| (k, v.to_vec().into())).collect()),
             tessdata_path: val.tessdata_path.map(Into::into),
+            numeric_repair: val.numeric_repair,
             ..Default::default()
         }
     }
@@ -51039,6 +52213,7 @@ impl From<xberg::OcrConfig> for OcrConfig {
             tesseract_config: val.tesseract_config.map(Into::into),
             output_format: val.output_format.map(Into::into),
             paddle_ocr_config: val.paddle_ocr_config.as_ref().map(ToString::to_string),
+            paddle_ocr_settings: val.paddle_ocr_settings.map(Into::into),
             backend_options: val.backend_options.as_ref().map(ToString::to_string),
             element_config: val.element_config.map(Into::into),
             quality_thresholds: val.quality_thresholds.map(Into::into),
@@ -51053,6 +52228,7 @@ impl From<xberg::OcrConfig> for OcrConfig {
                 .tessdata_bytes
                 .map(|m| m.into_iter().map(|(k, v)| (k, v.to_vec().into())).collect()),
             tessdata_path: val.tessdata_path.map(|p| p.to_string_lossy().to_string()),
+            numeric_repair: val.numeric_repair,
         }
     }
 }
@@ -51202,6 +52378,7 @@ impl From<OcrPipelineStage> for xberg::OcrPipelineStage {
                 .paddle_ocr_config
                 .as_ref()
                 .and_then(|s| serde_json::from_str(s).ok()),
+            paddle_ocr_settings: val.paddle_ocr_settings.map(Into::into),
             vlm_config: val.vlm_config.map(Into::into),
             backend_options: val.backend_options.as_ref().and_then(|s| serde_json::from_str(s).ok()),
         }
@@ -51217,6 +52394,7 @@ impl From<xberg::OcrPipelineStage> for OcrPipelineStage {
             language: val.language.map(|v| v.into_iter().collect()),
             tesseract_config: val.tesseract_config.map(Into::into),
             paddle_ocr_config: val.paddle_ocr_config.as_ref().map(ToString::to_string),
+            paddle_ocr_settings: val.paddle_ocr_settings.map(Into::into),
             vlm_config: val.vlm_config.map(Into::into),
             backend_options: val.backend_options.as_ref().map(ToString::to_string),
         }
@@ -51359,7 +52537,6 @@ impl From<xberg::OrientationResult> for OrientationResult {
     }
 }
 
-#[cfg(feature = "paddle-ocr-types")]
 #[allow(clippy::needless_update)]
 #[allow(clippy::useless_conversion)]
 impl From<PaddleOcrConfig> for xberg::PaddleOcrConfig {
@@ -51384,7 +52561,6 @@ impl From<PaddleOcrConfig> for xberg::PaddleOcrConfig {
     }
 }
 
-#[cfg(feature = "paddle-ocr-types")]
 #[allow(clippy::redundant_closure, clippy::useless_conversion)]
 impl From<xberg::PaddleOcrConfig> for PaddleOcrConfig {
     fn from(val: xberg::PaddleOcrConfig) -> Self {
@@ -52330,12 +53506,16 @@ impl From<RedactionConfig> for xberg::RedactionConfig {
             preserve_offsets: val.preserve_offsets,
             custom_terms: val.custom_terms.into_iter().map(Into::into).collect(),
             custom_patterns: val.custom_patterns.into_iter().map(Into::into).collect(),
+            findings: val.findings.into_iter().map(Into::into).collect(),
+            min_score: val.min_score,
+            findings_path: val.findings_path.map(Into::into),
+            findings_offset_encoding: val.findings_offset_encoding.into(),
             ..Default::default()
         }
     }
 }
 
-#[allow(clippy::useless_conversion)]
+#[allow(clippy::redundant_closure, clippy::useless_conversion)]
 impl From<xberg::RedactionConfig> for RedactionConfig {
     fn from(val: xberg::RedactionConfig) -> Self {
         Self {
@@ -52345,6 +53525,10 @@ impl From<xberg::RedactionConfig> for RedactionConfig {
             preserve_offsets: val.preserve_offsets,
             custom_terms: val.custom_terms.into_iter().map(Into::into).collect(),
             custom_patterns: val.custom_patterns.into_iter().map(Into::into).collect(),
+            findings: val.findings.into_iter().map(Into::into).collect(),
+            min_score: val.min_score,
+            findings_path: val.findings_path.map(|p| p.to_string_lossy().to_string()),
+            findings_offset_encoding: val.findings_offset_encoding.into(),
         }
     }
 }
@@ -52435,7 +53619,10 @@ impl From<xberg::RedactionTerm> for RedactionTerm {
     }
 }
 
-#[cfg(any(feature = "reranker-presets", feature = "reranker"))]
+#[cfg(any(
+    any(feature = "reranker-presets", feature = "reranker"),
+    not(feature = "reranker-presets")
+))]
 impl From<xberg::RerankedDocument> for RerankedDocument {
     fn from(val: xberg::RerankedDocument) -> Self {
         Self {
@@ -52611,7 +53798,7 @@ impl From<crawlberg::SitemapUrl> for SitemapUrl {
     }
 }
 
-#[cfg(feature = "sparse-embedding-presets")]
+#[cfg(any(feature = "sparse-embedding-presets", not(feature = "sparse-embedding-presets")))]
 impl From<SparseEmbedding> for xberg::SparseEmbedding {
     fn from(val: SparseEmbedding) -> Self {
         Self {
@@ -52621,7 +53808,7 @@ impl From<SparseEmbedding> for xberg::SparseEmbedding {
     }
 }
 
-#[cfg(feature = "sparse-embedding-presets")]
+#[cfg(any(feature = "sparse-embedding-presets", not(feature = "sparse-embedding-presets")))]
 impl From<xberg::SparseEmbedding> for SparseEmbedding {
     fn from(val: xberg::SparseEmbedding) -> Self {
         Self {
@@ -52663,7 +53850,7 @@ impl From<xberg::SparseEmbeddingConfig> for SparseEmbeddingConfig {
     }
 }
 
-#[cfg(feature = "sparse-embedding-presets")]
+#[cfg(any(feature = "sparse-embedding-presets", not(feature = "sparse-embedding-presets")))]
 impl From<xberg::SparseEmbeddingPreset> for SparseEmbeddingPreset {
     fn from(val: xberg::SparseEmbeddingPreset) -> Self {
         Self {
@@ -53718,6 +54905,26 @@ impl From<xberg::candle_ocr::CandleTrocrVariant> for CandleTrocrVariant {
     }
 }
 
+impl From<CaptionAltTextMode> for xberg::CaptionAltTextMode {
+    fn from(val: CaptionAltTextMode) -> Self {
+        match val {
+            CaptionAltTextMode::Preserve => Self::Preserve,
+            CaptionAltTextMode::Combine => Self::Combine,
+            CaptionAltTextMode::Replace => Self::Replace,
+        }
+    }
+}
+
+impl From<xberg::CaptionAltTextMode> for CaptionAltTextMode {
+    fn from(val: xberg::CaptionAltTextMode) -> Self {
+        match val {
+            xberg::CaptionAltTextMode::Preserve => Self::Preserve,
+            xberg::CaptionAltTextMode::Combine => Self::Combine,
+            xberg::CaptionAltTextMode::Replace => Self::Replace,
+        }
+    }
+}
+
 impl From<ChunkSizing> for xberg::ChunkSizing {
     fn from(val: ChunkSizing) -> Self {
         match val {
@@ -55231,7 +56438,6 @@ impl From<xberg::PSMMode> for PSMMode {
     }
 }
 
-#[cfg(feature = "paddle-ocr-types")]
 impl From<PaddleInferenceBackend> for xberg::PaddleInferenceBackend {
     fn from(val: PaddleInferenceBackend) -> Self {
         match val {
@@ -55241,7 +56447,6 @@ impl From<PaddleInferenceBackend> for xberg::PaddleInferenceBackend {
     }
 }
 
-#[cfg(feature = "paddle-ocr-types")]
 impl From<xberg::PaddleInferenceBackend> for PaddleInferenceBackend {
     fn from(val: xberg::PaddleInferenceBackend) -> Self {
         match val {
@@ -55251,7 +56456,6 @@ impl From<xberg::PaddleInferenceBackend> for PaddleInferenceBackend {
     }
 }
 
-#[cfg(feature = "paddle-ocr-types")]
 impl From<xberg::PaddleLanguage> for PaddleLanguage {
     fn from(val: xberg::PaddleLanguage) -> Self {
         match val {
@@ -55529,6 +56733,26 @@ impl From<xberg::ProcessingStage> for ProcessingStage {
     }
 }
 
+impl From<RedactionOffsetEncoding> for xberg::RedactionOffsetEncoding {
+    fn from(val: RedactionOffsetEncoding) -> Self {
+        match val {
+            RedactionOffsetEncoding::Utf8Bytes => Self::Utf8Bytes,
+            RedactionOffsetEncoding::UnicodeCodePoints => Self::UnicodeCodePoints,
+            RedactionOffsetEncoding::Utf16CodeUnits => Self::Utf16CodeUnits,
+        }
+    }
+}
+
+impl From<xberg::RedactionOffsetEncoding> for RedactionOffsetEncoding {
+    fn from(val: xberg::RedactionOffsetEncoding) -> Self {
+        match val {
+            xberg::RedactionOffsetEncoding::Utf8Bytes => Self::Utf8Bytes,
+            xberg::RedactionOffsetEncoding::UnicodeCodePoints => Self::UnicodeCodePoints,
+            xberg::RedactionOffsetEncoding::Utf16CodeUnits => Self::Utf16CodeUnits,
+        }
+    }
+}
+
 impl From<RedactionStrategy> for xberg::RedactionStrategy {
     fn from(val: RedactionStrategy) -> Self {
         match val {
@@ -56254,6 +57478,10 @@ fn ruby_init(ruby: &Ruby) -> Result<(), Error> {
 
     class.define_method("timeout", method!(BrowserConfig::timeout, 0))?;
 
+    class.define_method("overall_timeout", method!(BrowserConfig::overall_timeout, 0))?;
+
+    class.define_method("shutdown_timeout", method!(BrowserConfig::shutdown_timeout, 0))?;
+
     class.define_method("wait", method!(BrowserConfig::wait, 0))?;
 
     class.define_method("wait_selector", method!(BrowserConfig::wait_selector, 0))?;
@@ -56299,6 +57527,8 @@ fn ruby_init(ruby: &Ruby) -> Result<(), Error> {
 
     class.define_method("min_image_area", method!(CaptioningConfig::min_image_area, 0))?;
 
+    class.define_method("alt_text", method!(CaptioningConfig::alt_text, 0))?;
+
     let class = module.define_class("CellChange", ruby.class_object())?;
 
     class.define_singleton_method("new", function!(CellChange::new, -1))?;
@@ -56321,10 +57551,10 @@ fn ruby_init(ruby: &Ruby) -> Result<(), Error> {
 
     class.define_method("embedding", method!(Chunk::embedding, 0))?;
 
-    #[cfg(feature = "sparse-embedding-presets")]
+    #[cfg(any(feature = "sparse-embedding-presets", not(feature = "sparse-embedding-presets")))]
     class.define_method("sparse_embedding", method!(Chunk::sparse_embedding, 0))?;
 
-    #[cfg(feature = "late-interaction-presets")]
+    #[cfg(any(feature = "late-interaction-presets", not(feature = "late-interaction-presets")))]
     class.define_method("late_interaction", method!(Chunk::late_interaction, 0))?;
 
     class.define_method("metadata", method!(Chunk::metadata, 0))?;
@@ -56591,6 +57821,8 @@ fn ruby_init(ruby: &Ruby) -> Result<(), Error> {
         method!(ContentConfig::include_document_structure, 0),
     )?;
 
+    class.define_method("extract_metadata", method!(ContentConfig::extract_metadata, 0))?;
+
     let class = module.define_class("ContentFilterConfig", ruby.class_object())?;
 
     class.define_singleton_method("new", function!(ContentFilterConfig::new, -1))?;
@@ -56715,6 +57947,8 @@ fn ruby_init(ruby: &Ruby) -> Result<(), Error> {
 
     class.define_method("tier_strategy", method!(ConversionOptions::tier_strategy, 0))?;
 
+    class.define_method("base_url", method!(ConversionOptions::base_url, 0))?;
+
     let class = module.define_class("CoreProperties", ruby.class_object())?;
 
     #[cfg(feature = "office")]
@@ -56799,6 +58033,17 @@ fn ruby_init(ruby: &Ruby) -> Result<(), Error> {
 
     class.define_method("exclude_paths", method!(CrawlConfig::exclude_paths, 0))?;
 
+    class.define_method(
+        "path_patterns_match_query",
+        method!(CrawlConfig::path_patterns_match_query, 0),
+    )?;
+
+    class.define_method("dedup_include_query", method!(CrawlConfig::dedup_include_query, 0))?;
+
+    class.define_method("strip_tracking_params", method!(CrawlConfig::strip_tracking_params, 0))?;
+
+    class.define_method("tracking_params", method!(CrawlConfig::tracking_params, 0))?;
+
     class.define_method("custom_headers", method!(CrawlConfig::custom_headers, 0))?;
 
     class.define_method("request_timeout", method!(CrawlConfig::request_timeout, 0))?;
@@ -56811,6 +58056,18 @@ fn ruby_init(ruby: &Ruby) -> Result<(), Error> {
 
     class.define_method("retry_codes", method!(CrawlConfig::retry_codes, 0))?;
 
+    class.define_method(
+        "retry_initial_delay_ms",
+        method!(CrawlConfig::retry_initial_delay_ms, 0),
+    )?;
+
+    class.define_method("retry_max_delay_ms", method!(CrawlConfig::retry_max_delay_ms, 0))?;
+
+    class.define_method(
+        "rate_limit_jitter_ratio",
+        method!(CrawlConfig::rate_limit_jitter_ratio, 0),
+    )?;
+
     class.define_method("cookies_enabled", method!(CrawlConfig::cookies_enabled, 0))?;
 
     class.define_method("auth", method!(CrawlConfig::auth, 0))?;
@@ -57494,6 +58751,20 @@ fn ruby_init(ruby: &Ruby) -> Result<(), Error> {
 
     class.define_method("revisions", method!(ExcelWorkbook::revisions, 0))?;
 
+    let class = module.define_class("ExternalRedactionFinding", ruby.class_object())?;
+
+    class.define_singleton_method("new", function!(ExternalRedactionFinding::new, -1))?;
+
+    class.define_method("label", method!(ExternalRedactionFinding::label, 0))?;
+
+    class.define_method("text", method!(ExternalRedactionFinding::text, 0))?;
+
+    class.define_method("start", method!(ExternalRedactionFinding::start, 0))?;
+
+    class.define_method("end", method!(ExternalRedactionFinding::end, 0))?;
+
+    class.define_method("score", method!(ExternalRedactionFinding::score, 0))?;
+
     let class = module.define_class("ExtractInput", ruby.class_object())?;
 
     class.define_singleton_method("new", function!(ExtractInput::new, -1))?;
@@ -58479,6 +59750,11 @@ fn ruby_init(ruby: &Ruby) -> Result<(), Error> {
 
     class.define_method("invert_colors", method!(ImagePreprocessingConfig::invert_colors, 0))?;
 
+    class.define_method(
+        "normalize_shaded_rows",
+        method!(ImagePreprocessingConfig::normalize_shaded_rows, 0),
+    )?;
+
     let class = module.define_class("ImagePreprocessingMetadata", ruby.class_object())?;
 
     class.define_singleton_method("new", function!(ImagePreprocessingMetadata::new, -1))?;
@@ -58645,42 +59921,42 @@ fn ruby_init(ruby: &Ruby) -> Result<(), Error> {
 
     let class = module.define_class("LateInteractionMatch", ruby.class_object())?;
 
-    #[cfg(feature = "late-interaction-presets")]
+    #[cfg(any(feature = "late-interaction-presets", not(feature = "late-interaction-presets")))]
     class.define_singleton_method("new", function!(LateInteractionMatch::new, -1))?;
 
-    #[cfg(feature = "late-interaction-presets")]
+    #[cfg(any(feature = "late-interaction-presets", not(feature = "late-interaction-presets")))]
     class.define_method("index", method!(LateInteractionMatch::index, 0))?;
 
-    #[cfg(feature = "late-interaction-presets")]
+    #[cfg(any(feature = "late-interaction-presets", not(feature = "late-interaction-presets")))]
     class.define_method("score", method!(LateInteractionMatch::score, 0))?;
 
     let class = module.define_class("LateInteractionPreset", ruby.class_object())?;
 
-    #[cfg(feature = "late-interaction-presets")]
+    #[cfg(any(feature = "late-interaction-presets", not(feature = "late-interaction-presets")))]
     class.define_singleton_method("new", function!(LateInteractionPreset::new, -1))?;
 
-    #[cfg(feature = "late-interaction-presets")]
+    #[cfg(any(feature = "late-interaction-presets", not(feature = "late-interaction-presets")))]
     class.define_method("name", method!(LateInteractionPreset::name, 0))?;
 
-    #[cfg(feature = "late-interaction-presets")]
+    #[cfg(any(feature = "late-interaction-presets", not(feature = "late-interaction-presets")))]
     class.define_method("model_repo", method!(LateInteractionPreset::model_repo, 0))?;
 
-    #[cfg(feature = "late-interaction-presets")]
+    #[cfg(any(feature = "late-interaction-presets", not(feature = "late-interaction-presets")))]
     class.define_method("model_file", method!(LateInteractionPreset::model_file, 0))?;
 
-    #[cfg(feature = "late-interaction-presets")]
+    #[cfg(any(feature = "late-interaction-presets", not(feature = "late-interaction-presets")))]
     class.define_method("additional_files", method!(LateInteractionPreset::additional_files, 0))?;
 
-    #[cfg(feature = "late-interaction-presets")]
+    #[cfg(any(feature = "late-interaction-presets", not(feature = "late-interaction-presets")))]
     class.define_method("max_length", method!(LateInteractionPreset::max_length, 0))?;
 
-    #[cfg(feature = "late-interaction-presets")]
+    #[cfg(any(feature = "late-interaction-presets", not(feature = "late-interaction-presets")))]
     class.define_method("query_max_length", method!(LateInteractionPreset::query_max_length, 0))?;
 
-    #[cfg(feature = "late-interaction-presets")]
+    #[cfg(any(feature = "late-interaction-presets", not(feature = "late-interaction-presets")))]
     class.define_method("dim", method!(LateInteractionPreset::dim, 0))?;
 
-    #[cfg(feature = "late-interaction-presets")]
+    #[cfg(any(feature = "late-interaction-presets", not(feature = "late-interaction-presets")))]
     class.define_method("description", method!(LateInteractionPreset::description, 0))?;
 
     let class = module.define_class("LayoutDetection", ruby.class_object())?;
@@ -58966,36 +60242,31 @@ fn ruby_init(ruby: &Ruby) -> Result<(), Error> {
 
     let class = module.define_class("ModelPaths", ruby.class_object())?;
 
-    #[cfg(feature = "paddle-ocr-types")]
     class.define_singleton_method("new", function!(ModelPaths::new, -1))?;
 
-    #[cfg(feature = "paddle-ocr-types")]
     class.define_method("det_model", method!(ModelPaths::det_model, 0))?;
 
-    #[cfg(feature = "paddle-ocr-types")]
     class.define_method("cls_model", method!(ModelPaths::cls_model, 0))?;
 
-    #[cfg(feature = "paddle-ocr-types")]
     class.define_method("rec_model", method!(ModelPaths::rec_model, 0))?;
 
-    #[cfg(feature = "paddle-ocr-types")]
     class.define_method("dict_file", method!(ModelPaths::dict_file, 0))?;
 
     let class = module.define_class("MultiVectorEmbedding", ruby.class_object())?;
 
-    #[cfg(feature = "late-interaction-presets")]
+    #[cfg(any(feature = "late-interaction-presets", not(feature = "late-interaction-presets")))]
     class.define_singleton_method("new", function!(MultiVectorEmbedding::new, -1))?;
 
-    #[cfg(feature = "late-interaction-presets")]
+    #[cfg(any(feature = "late-interaction-presets", not(feature = "late-interaction-presets")))]
     class.define_method("num_tokens", method!(MultiVectorEmbedding::num_tokens, 0))?;
 
-    #[cfg(feature = "late-interaction-presets")]
+    #[cfg(any(feature = "late-interaction-presets", not(feature = "late-interaction-presets")))]
     class.define_method("dim", method!(MultiVectorEmbedding::dim, 0))?;
 
-    #[cfg(feature = "late-interaction-presets")]
+    #[cfg(any(feature = "late-interaction-presets", not(feature = "late-interaction-presets")))]
     class.define_method("data", method!(MultiVectorEmbedding::data, 0))?;
 
-    #[cfg(feature = "late-interaction-presets")]
+    #[cfg(any(feature = "late-interaction-presets", not(feature = "late-interaction-presets")))]
     class.define_method("is_well_formed", method!(MultiVectorEmbedding::is_well_formed, 0))?;
 
     let class = module.define_class("MultidocInput", ruby.class_object())?;
@@ -59083,6 +60354,8 @@ fn ruby_init(ruby: &Ruby) -> Result<(), Error> {
 
     class.define_method("paddle_ocr_config", method!(OcrConfig::paddle_ocr_config, 0))?;
 
+    class.define_method("paddle_ocr_settings", method!(OcrConfig::paddle_ocr_settings, 0))?;
+
     class.define_method("backend_options", method!(OcrConfig::backend_options, 0))?;
 
     class.define_method("element_config", method!(OcrConfig::element_config, 0))?;
@@ -59107,6 +60380,8 @@ fn ruby_init(ruby: &Ruby) -> Result<(), Error> {
 
     class.define_method("tessdata_path", method!(OcrConfig::tessdata_path, 0))?;
 
+    class.define_method("numeric_repair", method!(OcrConfig::numeric_repair, 0))?;
+
     let class = module.define_class("OcrElement", ruby.class_object())?;
 
     class.define_singleton_method("new", function!(OcrElement::new, -1))?;
@@ -59193,6 +60468,8 @@ fn ruby_init(ruby: &Ruby) -> Result<(), Error> {
 
     class.define_method("paddle_ocr_config", method!(OcrPipelineStage::paddle_ocr_config, 0))?;
 
+    class.define_method("paddle_ocr_settings", method!(OcrPipelineStage::paddle_ocr_settings, 0))?;
+
     class.define_method("vlm_config", method!(OcrPipelineStage::vlm_config, 0))?;
 
     class.define_method("backend_options", method!(OcrPipelineStage::backend_options, 0))?;
@@ -59378,100 +60655,73 @@ fn ruby_init(ruby: &Ruby) -> Result<(), Error> {
 
     let class = module.define_class("PaddleOcrConfig", ruby.class_object())?;
 
-    #[cfg(feature = "paddle-ocr-types")]
     class.define_singleton_method("new", function!(PaddleOcrConfig::new, -1))?;
 
-    #[cfg(feature = "paddle-ocr-types")]
     class.define_method("language", method!(PaddleOcrConfig::language, 0))?;
 
-    #[cfg(feature = "paddle-ocr-types")]
     class.define_method("cache_dir", method!(PaddleOcrConfig::cache_dir, 0))?;
 
-    #[cfg(feature = "paddle-ocr-types")]
     class.define_method("use_angle_cls", method!(PaddleOcrConfig::use_angle_cls, 0))?;
 
-    #[cfg(feature = "paddle-ocr-types")]
     class.define_method(
         "enable_table_detection",
         method!(PaddleOcrConfig::enable_table_detection, 0),
     )?;
 
-    #[cfg(feature = "paddle-ocr-types")]
     class.define_method("det_db_thresh", method!(PaddleOcrConfig::det_db_thresh, 0))?;
 
-    #[cfg(feature = "paddle-ocr-types")]
     class.define_method("det_db_box_thresh", method!(PaddleOcrConfig::det_db_box_thresh, 0))?;
 
-    #[cfg(feature = "paddle-ocr-types")]
     class.define_method("det_db_unclip_ratio", method!(PaddleOcrConfig::det_db_unclip_ratio, 0))?;
 
-    #[cfg(feature = "paddle-ocr-types")]
     class.define_method("det_limit_side_len", method!(PaddleOcrConfig::det_limit_side_len, 0))?;
 
-    #[cfg(feature = "paddle-ocr-types")]
     class.define_method("rec_batch_num", method!(PaddleOcrConfig::rec_batch_num, 0))?;
 
-    #[cfg(feature = "paddle-ocr-types")]
     class.define_method("padding", method!(PaddleOcrConfig::padding, 0))?;
 
-    #[cfg(feature = "paddle-ocr-types")]
     class.define_method("drop_score", method!(PaddleOcrConfig::drop_score, 0))?;
 
-    #[cfg(feature = "paddle-ocr-types")]
     class.define_method("model_tier", method!(PaddleOcrConfig::model_tier, 0))?;
 
-    #[cfg(feature = "paddle-ocr-types")]
     class.define_method("model_version", method!(PaddleOcrConfig::model_version, 0))?;
 
-    #[cfg(feature = "paddle-ocr-types")]
     class.define_method("inference_backend", method!(PaddleOcrConfig::inference_backend, 0))?;
 
-    #[cfg(feature = "paddle-ocr-types")]
     class.define_method("with_cache_dir", method!(PaddleOcrConfig::with_cache_dir, 1))?;
 
-    #[cfg(feature = "paddle-ocr-types")]
     class.define_method(
         "with_table_detection",
         method!(PaddleOcrConfig::with_table_detection, 1),
     )?;
 
-    #[cfg(feature = "paddle-ocr-types")]
     class.define_method("with_angle_cls", method!(PaddleOcrConfig::with_angle_cls, 1))?;
 
-    #[cfg(feature = "paddle-ocr-types")]
     class.define_method("with_det_db_thresh", method!(PaddleOcrConfig::with_det_db_thresh, 1))?;
 
-    #[cfg(feature = "paddle-ocr-types")]
     class.define_method(
         "with_det_db_box_thresh",
         method!(PaddleOcrConfig::with_det_db_box_thresh, 1),
     )?;
 
-    #[cfg(feature = "paddle-ocr-types")]
     class.define_method(
         "with_det_db_unclip_ratio",
         method!(PaddleOcrConfig::with_det_db_unclip_ratio, 1),
     )?;
 
-    #[cfg(feature = "paddle-ocr-types")]
     class.define_method(
         "with_det_limit_side_len",
         method!(PaddleOcrConfig::with_det_limit_side_len, 1),
     )?;
 
-    #[cfg(feature = "paddle-ocr-types")]
     class.define_method("with_rec_batch_num", method!(PaddleOcrConfig::with_rec_batch_num, 1))?;
 
-    #[cfg(feature = "paddle-ocr-types")]
     class.define_method("with_drop_score", method!(PaddleOcrConfig::with_drop_score, 1))?;
 
-    #[cfg(feature = "paddle-ocr-types")]
     class.define_method("with_padding", method!(PaddleOcrConfig::with_padding, 1))?;
 
-    #[cfg(feature = "paddle-ocr-types")]
     class.define_method("with_model_tier", method!(PaddleOcrConfig::with_model_tier, 1))?;
 
-    #[cfg(feature = "paddle-ocr-types")]
     class.define_method("with_model_version", method!(PaddleOcrConfig::with_model_version, 1))?;
 
     let class = module.define_class("PaddleOcrVlBackendOptions", ruby.class_object())?;
@@ -60146,6 +61396,17 @@ fn ruby_init(ruby: &Ruby) -> Result<(), Error> {
 
     class.define_method("custom_patterns", method!(RedactionConfig::custom_patterns, 0))?;
 
+    class.define_method("findings", method!(RedactionConfig::findings, 0))?;
+
+    class.define_method("min_score", method!(RedactionConfig::min_score, 0))?;
+
+    class.define_method("findings_path", method!(RedactionConfig::findings_path, 0))?;
+
+    class.define_method(
+        "findings_offset_encoding",
+        method!(RedactionConfig::findings_offset_encoding, 0),
+    )?;
+
     class.define_method("validate", method!(RedactionConfig::validate, 0))?;
 
     let class = module.define_class("RedactionFinding", ruby.class_object())?;
@@ -60212,16 +61473,28 @@ fn ruby_init(ruby: &Ruby) -> Result<(), Error> {
 
     let class = module.define_class("RerankedDocument", ruby.class_object())?;
 
-    #[cfg(any(feature = "reranker-presets", feature = "reranker"))]
+    #[cfg(any(
+        any(feature = "reranker-presets", feature = "reranker"),
+        not(feature = "reranker-presets")
+    ))]
     class.define_singleton_method("new", function!(RerankedDocument::new, -1))?;
 
-    #[cfg(any(feature = "reranker-presets", feature = "reranker"))]
+    #[cfg(any(
+        any(feature = "reranker-presets", feature = "reranker"),
+        not(feature = "reranker-presets")
+    ))]
     class.define_method("index", method!(RerankedDocument::index, 0))?;
 
-    #[cfg(any(feature = "reranker-presets", feature = "reranker"))]
+    #[cfg(any(
+        any(feature = "reranker-presets", feature = "reranker"),
+        not(feature = "reranker-presets")
+    ))]
     class.define_method("score", method!(RerankedDocument::score, 0))?;
 
-    #[cfg(any(feature = "reranker-presets", feature = "reranker"))]
+    #[cfg(any(
+        any(feature = "reranker-presets", feature = "reranker"),
+        not(feature = "reranker-presets")
+    ))]
     class.define_method("document", method!(RerankedDocument::document, 0))?;
 
     let class = module.define_class("RerankerConfig", ruby.class_object())?;
@@ -60378,13 +61651,13 @@ fn ruby_init(ruby: &Ruby) -> Result<(), Error> {
 
     let class = module.define_class("SparseEmbedding", ruby.class_object())?;
 
-    #[cfg(feature = "sparse-embedding-presets")]
+    #[cfg(any(feature = "sparse-embedding-presets", not(feature = "sparse-embedding-presets")))]
     class.define_singleton_method("new", function!(SparseEmbedding::new, -1))?;
 
-    #[cfg(feature = "sparse-embedding-presets")]
+    #[cfg(any(feature = "sparse-embedding-presets", not(feature = "sparse-embedding-presets")))]
     class.define_method("indices", method!(SparseEmbedding::indices, 0))?;
 
-    #[cfg(feature = "sparse-embedding-presets")]
+    #[cfg(any(feature = "sparse-embedding-presets", not(feature = "sparse-embedding-presets")))]
     class.define_method("values", method!(SparseEmbedding::values, 0))?;
 
     let class = module.define_class("SparseEmbeddingConfig", ruby.class_object())?;
@@ -60413,25 +61686,25 @@ fn ruby_init(ruby: &Ruby) -> Result<(), Error> {
 
     let class = module.define_class("SparseEmbeddingPreset", ruby.class_object())?;
 
-    #[cfg(feature = "sparse-embedding-presets")]
+    #[cfg(any(feature = "sparse-embedding-presets", not(feature = "sparse-embedding-presets")))]
     class.define_singleton_method("new", function!(SparseEmbeddingPreset::new, -1))?;
 
-    #[cfg(feature = "sparse-embedding-presets")]
+    #[cfg(any(feature = "sparse-embedding-presets", not(feature = "sparse-embedding-presets")))]
     class.define_method("name", method!(SparseEmbeddingPreset::name, 0))?;
 
-    #[cfg(feature = "sparse-embedding-presets")]
+    #[cfg(any(feature = "sparse-embedding-presets", not(feature = "sparse-embedding-presets")))]
     class.define_method("model_repo", method!(SparseEmbeddingPreset::model_repo, 0))?;
 
-    #[cfg(feature = "sparse-embedding-presets")]
+    #[cfg(any(feature = "sparse-embedding-presets", not(feature = "sparse-embedding-presets")))]
     class.define_method("model_file", method!(SparseEmbeddingPreset::model_file, 0))?;
 
-    #[cfg(feature = "sparse-embedding-presets")]
+    #[cfg(any(feature = "sparse-embedding-presets", not(feature = "sparse-embedding-presets")))]
     class.define_method("additional_files", method!(SparseEmbeddingPreset::additional_files, 0))?;
 
-    #[cfg(feature = "sparse-embedding-presets")]
+    #[cfg(any(feature = "sparse-embedding-presets", not(feature = "sparse-embedding-presets")))]
     class.define_method("max_length", method!(SparseEmbeddingPreset::max_length, 0))?;
 
-    #[cfg(feature = "sparse-embedding-presets")]
+    #[cfg(any(feature = "sparse-embedding-presets", not(feature = "sparse-embedding-presets")))]
     class.define_method("description", method!(SparseEmbeddingPreset::description, 0))?;
 
     let class = module.define_class("SsrfPolicy", ruby.class_object())?;
@@ -61034,6 +62307,12 @@ fn ruby_init(ruby: &Ruby) -> Result<(), Error> {
 
     module.define_module_function("extract_batch", function!(extract_batch_async, -1))?;
 
+    #[cfg(feature = "redaction")]
+    module.define_module_function(
+        "extract_with_external_redaction",
+        function!(extract_with_external_redaction_async, -1),
+    )?;
+
     #[cfg(feature = "markdown-footnotes")]
     module.define_module_function("find_unmarked_claims", function!(find_unmarked_claims, 1))?;
 
@@ -61046,6 +62325,11 @@ fn ruby_init(ruby: &Ruby) -> Result<(), Error> {
         function!(list_ocr_backend_capabilities, 0),
     )?;
 
+    module.define_module_function(
+        "list_ocr_backend_capabilities_for",
+        function!(list_ocr_backend_capabilities_for, -1),
+    )?;
+
     module.define_module_function("list_ocr_backends", function!(list_ocr_backends, 0))?;
 
     module.define_module_function("list_post_processors", function!(list_post_processors, 0))?;
@@ -61080,6 +62364,17 @@ fn ruby_init(ruby: &Ruby) -> Result<(), Error> {
         function!(ocr_backend_supports_language, 2),
     )?;
 
+    module.define_module_function(
+        "ocr_backend_supports_language_for",
+        function!(ocr_backend_supports_language_for, -1),
+    )?;
+
+    #[cfg(feature = "pdf")]
+    module.define_module_function("pdf_page_count", function!(pdf_page_count, -1))?;
+
+    #[cfg(feature = "redaction")]
+    module.define_module_function("redact_external", function!(redact_external_async, -1))?;
+
     #[cfg(feature = "markdown-footnotes")]
     module.define_module_function("verify_excerpt", function!(verify_excerpt, 2))?;