xberg 1.3.0 → 1.3.3

data/ext/xberg_rb/src/lib.rs

@@ -1,5 +1,5 @@
 // This file is auto-generated by alef. DO NOT EDIT.
-// alef:hash:7b7e0e3e79a8cf968d66bcaa7adae77d99bdb0dc86ad64a75c1e785c57a13371
+// alef:hash:3e862eca7b1250c4aa8d40b5563353572b94bd205d31f9f57c9efc950fcd26cb
 // 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};
@@ -1515,6 +1516,7 @@ pub struct CaptioningConfig {
     llm: LlmConfig,
     prompt: Option<String>,
     min_image_area: u32,
+    alt_text: CaptionAltTextMode,
 }
 
 unsafe impl IntoValueFromNative for CaptioningConfig {}
@@ -1559,6 +1561,7 @@ impl Default for CaptioningConfig {
             llm: LlmConfig::default(),
             prompt: None,
             min_image_area: 1000,
+            alt_text: CaptionAltTextMode::Preserve,
         }
     }
 }
@@ -1602,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,
+            },
         })
     }
 
@@ -1616,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)]
@@ -1724,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,
 }
@@ -1782,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| {
@@ -1798,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(
@@ -1808,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(
@@ -1847,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()
     }
@@ -4072,6 +4083,7 @@ pub struct ConversionOptions {
     strip_tags: Vec<String>,
     preserve_tags: Vec<String>,
     skip_images: bool,
+    inline_data_media: InlineDataMedia,
     url_escape_style: UrlEscapeStyle,
     link_style: LinkStyle,
     output_format: HtmlToMarkdownRsOutputFormat,
@@ -4415,6 +4427,15 @@ impl ConversionOptions {
                 })?,
                 None => false,
             },
+            inline_data_media: match kwargs.get(ruby.to_symbol("inline_data_media")) {
+                Some(v) => InlineDataMedia::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `inline_data_media`: {}", e),
+                    )
+                })?,
+                None => InlineDataMedia::Keep,
+            },
             url_escape_style: match kwargs.get(ruby.to_symbol("url_escape_style")) {
                 Some(v) => UrlEscapeStyle::try_convert(v).map_err(|e| {
                     magnus::Error::new(
@@ -4654,6 +4675,10 @@ impl ConversionOptions {
         self.skip_images
     }
 
+    fn inline_data_media(&self) -> InlineDataMedia {
+        self.inline_data_media.clone()
+    }
+
     fn url_escape_style(&self) -> UrlEscapeStyle {
         self.url_escape_style.clone()
     }
@@ -7804,12 +7829,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| {
@@ -10682,6 +10702,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")]
@@ -18774,7 +18923,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 {
@@ -18782,10 +18931,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) {
@@ -18810,10 +18959,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() };
@@ -18851,7 +19000,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 {
@@ -18865,10 +19014,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) {
@@ -18893,10 +19042,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() };
@@ -21338,7 +21487,6 @@ impl Metadata {
     }
 }
 
-#[cfg(feature = "paddle-ocr-types")]
 #[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
 #[magnus::wrap(class = "Xberg::ModelPaths")]
 pub struct ModelPaths {
@@ -21348,10 +21496,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) {
@@ -21376,10 +21522,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() };
@@ -21443,7 +21587,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 {
@@ -21452,10 +21596,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) {
@@ -21480,10 +21624,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() };
@@ -22093,6 +22237,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>,
@@ -22211,6 +22356,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(
@@ -22355,6 +22512,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()
     }
@@ -23065,6 +23226,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>,
 }
@@ -23113,6 +23275,7 @@ impl Default for OcrPipelineStage {
             language: None,
             tesseract_config: None,
             paddle_ocr_config: None,
+            paddle_ocr_settings: None,
             vlm_config: None,
             backend_options: None,
         }
@@ -23171,6 +23334,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(
@@ -23212,6 +23387,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()
     }
@@ -24095,7 +24274,6 @@ impl OrientationResult {
     }
 }
 
-#[cfg(feature = "paddle-ocr-types")]
 #[derive(Clone, Debug, serde::Serialize)]
 #[serde(default)]
 #[magnus::wrap(class = "Xberg::PaddleOcrConfig")]
@@ -24116,10 +24294,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) {
@@ -24144,9 +24320,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
@@ -24156,14 +24330,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() };
@@ -29681,6 +29853,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 {}
@@ -29786,6 +29962,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,
+            },
         })
     }
 
@@ -29813,6 +30025,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 {
@@ -29828,6 +30056,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| {
@@ -30313,7 +30549,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 {
@@ -30322,10 +30561,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) {
@@ -30350,10 +30595,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() };
@@ -31411,7 +31662,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 {
@@ -31419,10 +31670,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) {
@@ -31447,10 +31698,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() };
@@ -31648,7 +31899,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 {
@@ -31660,10 +31911,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) {
@@ -31688,10 +31939,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() };
@@ -36613,6 +36864,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")]
@@ -38940,6 +39244,58 @@ impl magnus::TryConvert for ImageType {
 unsafe impl IntoValueFromNative for ImageType {}
 unsafe impl TryConvertOwned for ImageType {}
 
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
+pub enum InlineDataMedia {
+    Keep,
+    AltTextOnly,
+    DropElement,
+}
+
+impl Default for InlineDataMedia {
+    fn default() -> Self {
+        Self::Keep
+    }
+}
+
+impl magnus::IntoValue for InlineDataMedia {
+    fn into_value_with(self, handle: &Ruby) -> magnus::Value {
+        let sym = match self {
+            InlineDataMedia::Keep => "Keep",
+            InlineDataMedia::AltTextOnly => "AltTextOnly",
+            InlineDataMedia::DropElement => "DropElement",
+        };
+        handle.to_symbol(sym).into_value_with(handle)
+    }
+}
+
+impl magnus::TryConvert for InlineDataMedia {
+    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() {
+            "Keep" | "keep" => Ok(InlineDataMedia::Keep),
+            "AltTextOnly" | "alt_text_only" => Ok(InlineDataMedia::AltTextOnly),
+            "DropElement" | "drop_element" => Ok(InlineDataMedia::DropElement),
+            other => Err(magnus::Error::new(
+                unsafe { Ruby::get_unchecked() }.exception_arg_error(),
+                format!("invalid InlineDataMedia value: {other}"),
+            )),
+        }
+    }
+}
+
+unsafe impl IntoValueFromNative for InlineDataMedia {}
+unsafe impl TryConvertOwned for InlineDataMedia {}
+
 #[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
 #[serde(rename_all = "snake_case")]
 pub enum InlineType {
@@ -41104,6 +41460,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 {
@@ -42701,6 +43110,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)
@@ -42997,6 +43530,114 @@ fn pdf_page_count(args: &[magnus::Value]) -> Result<usize, Error> {
     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)
@@ -47731,6 +48372,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(),
         }
     }
 }
@@ -47742,6 +48384,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(),
         }
     }
 }
@@ -47775,9 +48418,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(),
         }
@@ -47791,9 +48434,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(),
         }
@@ -48268,6 +48911,7 @@ impl From<ConversionOptions> for html_to_markdown_rs::ConversionOptions {
             strip_tags: val.strip_tags.into_iter().collect(),
             preserve_tags: val.preserve_tags.into_iter().collect(),
             skip_images: val.skip_images,
+            inline_data_media: val.inline_data_media.into(),
             url_escape_style: val.url_escape_style.into(),
             link_style: val.link_style.into(),
             output_format: val.output_format.into(),
@@ -48321,6 +48965,7 @@ impl From<html_to_markdown_rs::ConversionOptions> for ConversionOptions {
             strip_tags: val.strip_tags.into_iter().collect(),
             preserve_tags: val.preserve_tags.into_iter().collect(),
             skip_images: val.skip_images,
+            inline_data_media: val.inline_data_media.into(),
             url_escape_style: val.url_escape_style.into(),
             link_style: val.link_style.into(),
             output_format: val.output_format.into(),
@@ -49443,6 +50088,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 {
@@ -50930,7 +51602,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 {
@@ -50940,7 +51612,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 {
@@ -50950,7 +51622,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 {
@@ -51409,7 +52081,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 {
@@ -51421,7 +52092,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 {
@@ -51432,7 +52103,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 {
@@ -51579,6 +52250,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),
@@ -51609,6 +52281,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),
@@ -51773,6 +52446,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()),
         }
@@ -51788,6 +52462,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),
         }
@@ -51930,7 +52605,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 {
@@ -51955,7 +52629,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 {
@@ -52901,12 +53574,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 {
@@ -52916,6 +53593,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(),
         }
     }
 }
@@ -53006,7 +53687,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 {
@@ -53182,7 +53866,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 {
@@ -53192,7 +53876,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 {
@@ -53234,7 +53918,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 {
@@ -54289,6 +54973,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 {
@@ -55185,6 +55889,26 @@ impl From<xberg::ImageType> for ImageType {
     }
 }
 
+impl From<InlineDataMedia> for html_to_markdown_rs::InlineDataMedia {
+    fn from(val: InlineDataMedia) -> Self {
+        match val {
+            InlineDataMedia::Keep => Self::Keep,
+            InlineDataMedia::AltTextOnly => Self::AltTextOnly,
+            InlineDataMedia::DropElement => Self::DropElement,
+        }
+    }
+}
+
+impl From<html_to_markdown_rs::InlineDataMedia> for InlineDataMedia {
+    fn from(val: html_to_markdown_rs::InlineDataMedia) -> Self {
+        match val {
+            html_to_markdown_rs::InlineDataMedia::Keep => Self::Keep,
+            html_to_markdown_rs::InlineDataMedia::AltTextOnly => Self::AltTextOnly,
+            html_to_markdown_rs::InlineDataMedia::DropElement => Self::DropElement,
+        }
+    }
+}
+
 impl From<InlineType> for xberg::InlineType {
     fn from(val: InlineType) -> Self {
         match val {
@@ -55802,7 +56526,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 {
@@ -55812,7 +56535,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 {
@@ -55822,7 +56544,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 {
@@ -56100,6 +56821,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 {
@@ -56874,6 +57615,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))?;
@@ -56896,10 +57639,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))?;
@@ -57267,6 +58010,8 @@ fn ruby_init(ruby: &Ruby) -> Result<(), Error> {
 
     class.define_method("skip_images", method!(ConversionOptions::skip_images, 0))?;
 
+    class.define_method("inline_data_media", method!(ConversionOptions::inline_data_media, 0))?;
+
     class.define_method("url_escape_style", method!(ConversionOptions::url_escape_style, 0))?;
 
     class.define_method("link_style", method!(ConversionOptions::link_style, 0))?;
@@ -58096,6 +58841,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))?;
@@ -59252,42 +60011,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())?;
@@ -59573,36 +60332,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())?;
@@ -59690,6 +60444,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))?;
@@ -59802,6 +60558,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))?;
@@ -59987,100 +60745,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())?;
@@ -60755,6 +61486,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())?;
@@ -60821,16 +61563,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())?;
@@ -60987,13 +61741,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())?;
@@ -61022,25 +61776,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())?;
@@ -61643,6 +62397,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))?;
 
@@ -61702,6 +62462,9 @@ fn ruby_init(ruby: &Ruby) -> Result<(), Error> {
     #[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))?;