html-to-markdown 3.1.0 → 3.2.0

data/ext/html_to_markdown_rb/src/lib.rs

@@ -0,0 +1,3941 @@
+// This file is auto-generated by alef. DO NOT EDIT.
+// Re-generate with: alef generate
+#![allow(dead_code)]
+
+use magnus::{Error, IntoValueFromNative, Ruby, function, method, prelude::*, try_convert::TryConvertOwned};
+use std::collections::HashMap;
+use std::sync::Arc;
+
+fn json_to_ruby(handle: &Ruby, val: serde_json::Value) -> magnus::Value {
+    use magnus::IntoValue;
+    match val {
+        serde_json::Value::Null => handle.qnil().into_value_with(handle),
+        serde_json::Value::Bool(b) => b.into_value_with(handle),
+        serde_json::Value::Number(n) => {
+            if let Some(i) = n.as_i64() {
+                i.into_value_with(handle)
+            } else if let Some(f) = n.as_f64() {
+                f.into_value_with(handle)
+            } else {
+                handle.qnil().into_value_with(handle)
+            }
+        }
+        serde_json::Value::String(s) => s.into_value_with(handle),
+        serde_json::Value::Array(arr) => {
+            let ruby_arr = handle.ary_new_capa(arr.len());
+            for item in arr {
+                let _ = ruby_arr.push(json_to_ruby(handle, item));
+            }
+            ruby_arr.into_value_with(handle)
+        }
+        serde_json::Value::Object(map) => {
+            let hash = handle.hash_new();
+            for (k, v) in map {
+                let key = handle.to_symbol(&k);
+                let val = json_to_ruby(handle, v);
+                let _ = hash.aset(key, val);
+            }
+            hash.into_value_with(handle)
+        }
+    }
+}
+
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
+#[magnus::wrap(class = "HtmlToMarkdownRs::MetadataConfig")]
+#[serde(default)]
+pub struct MetadataConfig {
+    pub extract_document: bool,
+    pub extract_headers: bool,
+    pub extract_links: bool,
+    pub extract_images: bool,
+    pub extract_structured_data: bool,
+    pub max_structured_data_size: usize,
+}
+
+unsafe impl IntoValueFromNative for MetadataConfig {}
+
+impl magnus::TryConvert for MetadataConfig {
+    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
+        let r: &MetadataConfig = magnus::TryConvert::try_convert(val)?;
+        Ok(r.clone())
+    }
+}
+unsafe impl TryConvertOwned for MetadataConfig {}
+
+impl Default for MetadataConfig {
+    fn default() -> Self {
+        Self {
+            extract_document: Default::default(),
+            extract_headers: Default::default(),
+            extract_links: Default::default(),
+            extract_images: Default::default(),
+            extract_structured_data: Default::default(),
+            max_structured_data_size: Default::default(),
+        }
+    }
+}
+
+impl MetadataConfig {
+    fn new(
+        extract_document: Option<bool>,
+        extract_headers: Option<bool>,
+        extract_links: Option<bool>,
+        extract_images: Option<bool>,
+        extract_structured_data: Option<bool>,
+        max_structured_data_size: Option<usize>,
+    ) -> Self {
+        Self {
+            extract_document: extract_document.unwrap_or(true),
+            extract_headers: extract_headers.unwrap_or(true),
+            extract_links: extract_links.unwrap_or(true),
+            extract_images: extract_images.unwrap_or(true),
+            extract_structured_data: extract_structured_data.unwrap_or(true),
+            max_structured_data_size: max_structured_data_size.unwrap_or_default(),
+        }
+    }
+
+    fn extract_document(&self) -> bool {
+        self.extract_document
+    }
+
+    fn extract_headers(&self) -> bool {
+        self.extract_headers
+    }
+
+    fn extract_links(&self) -> bool {
+        self.extract_links
+    }
+
+    fn extract_images(&self) -> bool {
+        self.extract_images
+    }
+
+    fn extract_structured_data(&self) -> bool {
+        self.extract_structured_data
+    }
+
+    fn max_structured_data_size(&self) -> usize {
+        self.max_structured_data_size
+    }
+
+    fn any_enabled(&self) -> bool {
+        let core_self = html_to_markdown_rs::metadata::MetadataConfig {
+            extract_document: self.extract_document,
+            extract_headers: self.extract_headers,
+            extract_links: self.extract_links,
+            extract_images: self.extract_images,
+            extract_structured_data: self.extract_structured_data,
+            max_structured_data_size: self.max_structured_data_size,
+        };
+        core_self.any_enabled()
+    }
+}
+
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
+#[magnus::wrap(class = "HtmlToMarkdownRs::MetadataConfigUpdate")]
+#[serde(default)]
+pub struct MetadataConfigUpdate {
+    pub extract_document: Option<bool>,
+    pub extract_headers: Option<bool>,
+    pub extract_links: Option<bool>,
+    pub extract_images: Option<bool>,
+    pub extract_structured_data: Option<bool>,
+    pub max_structured_data_size: Option<usize>,
+}
+
+unsafe impl IntoValueFromNative for MetadataConfigUpdate {}
+
+impl magnus::TryConvert for MetadataConfigUpdate {
+    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
+        let r: &MetadataConfigUpdate = magnus::TryConvert::try_convert(val)?;
+        Ok(r.clone())
+    }
+}
+unsafe impl TryConvertOwned for MetadataConfigUpdate {}
+
+impl Default for MetadataConfigUpdate {
+    fn default() -> Self {
+        Self {
+            extract_document: Default::default(),
+            extract_headers: Default::default(),
+            extract_links: Default::default(),
+            extract_images: Default::default(),
+            extract_structured_data: Default::default(),
+            max_structured_data_size: Default::default(),
+        }
+    }
+}
+
+impl MetadataConfigUpdate {
+    fn new(
+        extract_document: Option<bool>,
+        extract_headers: Option<bool>,
+        extract_links: Option<bool>,
+        extract_images: Option<bool>,
+        extract_structured_data: Option<bool>,
+        max_structured_data_size: Option<usize>,
+    ) -> Self {
+        Self {
+            extract_document,
+            extract_headers,
+            extract_links,
+            extract_images,
+            extract_structured_data,
+            max_structured_data_size,
+        }
+    }
+
+    fn extract_document(&self) -> Option<bool> {
+        self.extract_document
+    }
+
+    fn extract_headers(&self) -> Option<bool> {
+        self.extract_headers
+    }
+
+    fn extract_links(&self) -> Option<bool> {
+        self.extract_links
+    }
+
+    fn extract_images(&self) -> Option<bool> {
+        self.extract_images
+    }
+
+    fn extract_structured_data(&self) -> Option<bool> {
+        self.extract_structured_data
+    }
+
+    fn max_structured_data_size(&self) -> Option<usize> {
+        self.max_structured_data_size
+    }
+}
+
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
+#[magnus::wrap(class = "HtmlToMarkdownRs::DocumentMetadata")]
+#[serde(default)]
+pub struct DocumentMetadata {
+    pub title: Option<String>,
+    pub description: Option<String>,
+    pub keywords: Vec<String>,
+    pub author: Option<String>,
+    pub canonical_url: Option<String>,
+    pub base_href: Option<String>,
+    pub language: Option<String>,
+    pub text_direction: Option<TextDirection>,
+    pub open_graph: HashMap<String, String>,
+    pub twitter_card: HashMap<String, String>,
+    pub meta_tags: HashMap<String, String>,
+}
+
+unsafe impl IntoValueFromNative for DocumentMetadata {}
+
+impl magnus::TryConvert for DocumentMetadata {
+    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
+        let r: &DocumentMetadata = magnus::TryConvert::try_convert(val)?;
+        Ok(r.clone())
+    }
+}
+unsafe impl TryConvertOwned for DocumentMetadata {}
+
+impl Default for DocumentMetadata {
+    fn default() -> Self {
+        Self {
+            title: Default::default(),
+            description: Default::default(),
+            keywords: Default::default(),
+            author: Default::default(),
+            canonical_url: Default::default(),
+            base_href: Default::default(),
+            language: Default::default(),
+            text_direction: Default::default(),
+            open_graph: Default::default(),
+            twitter_card: Default::default(),
+            meta_tags: Default::default(),
+        }
+    }
+}
+
+impl DocumentMetadata {
+    fn new(
+        title: Option<String>,
+        description: Option<String>,
+        keywords: Option<Vec<String>>,
+        author: Option<String>,
+        canonical_url: Option<String>,
+        base_href: Option<String>,
+        language: Option<String>,
+        text_direction: Option<TextDirection>,
+        open_graph: Option<HashMap<String, String>>,
+        twitter_card: Option<HashMap<String, String>>,
+        meta_tags: Option<HashMap<String, String>>,
+    ) -> Self {
+        Self {
+            title,
+            description,
+            keywords: keywords.unwrap_or_default(),
+            author,
+            canonical_url,
+            base_href,
+            language,
+            text_direction,
+            open_graph: open_graph.unwrap_or_default(),
+            twitter_card: twitter_card.unwrap_or_default(),
+            meta_tags: meta_tags.unwrap_or_default(),
+        }
+    }
+
+    fn title(&self) -> Option<String> {
+        self.title.clone()
+    }
+
+    fn description(&self) -> Option<String> {
+        self.description.clone()
+    }
+
+    fn keywords(&self) -> Vec<String> {
+        self.keywords.clone()
+    }
+
+    fn author(&self) -> Option<String> {
+        self.author.clone()
+    }
+
+    fn canonical_url(&self) -> Option<String> {
+        self.canonical_url.clone()
+    }
+
+    fn base_href(&self) -> Option<String> {
+        self.base_href.clone()
+    }
+
+    fn language(&self) -> Option<String> {
+        self.language.clone()
+    }
+
+    fn text_direction(&self) -> Option<TextDirection> {
+        self.text_direction.clone()
+    }
+
+    fn open_graph(&self) -> HashMap<String, String> {
+        self.open_graph.clone()
+    }
+
+    fn twitter_card(&self) -> HashMap<String, String> {
+        self.twitter_card.clone()
+    }
+
+    fn meta_tags(&self) -> HashMap<String, String> {
+        self.meta_tags.clone()
+    }
+}
+
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
+#[magnus::wrap(class = "HtmlToMarkdownRs::HeaderMetadata")]
+pub struct HeaderMetadata {
+    pub level: u8,
+    pub text: String,
+    pub id: Option<String>,
+    pub depth: usize,
+    pub html_offset: usize,
+}
+
+unsafe impl IntoValueFromNative for HeaderMetadata {}
+
+impl magnus::TryConvert for HeaderMetadata {
+    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
+        let r: &HeaderMetadata = magnus::TryConvert::try_convert(val)?;
+        Ok(r.clone())
+    }
+}
+unsafe impl TryConvertOwned for HeaderMetadata {}
+
+impl HeaderMetadata {
+    fn new(level: u8, text: String, depth: usize, html_offset: usize, id: Option<String>) -> Self {
+        Self {
+            level,
+            text,
+            id,
+            depth,
+            html_offset,
+        }
+    }
+
+    fn level(&self) -> u8 {
+        self.level
+    }
+
+    fn text(&self) -> String {
+        self.text.clone()
+    }
+
+    fn id(&self) -> Option<String> {
+        self.id.clone()
+    }
+
+    fn depth(&self) -> usize {
+        self.depth
+    }
+
+    fn html_offset(&self) -> usize {
+        self.html_offset
+    }
+
+    fn is_valid(&self) -> bool {
+        let core_self = html_to_markdown_rs::metadata::HeaderMetadata {
+            level: self.level,
+            text: self.text.clone(),
+            id: self.id.clone(),
+            depth: self.depth,
+            html_offset: self.html_offset,
+        };
+        core_self.is_valid()
+    }
+}
+
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
+#[magnus::wrap(class = "HtmlToMarkdownRs::LinkMetadata")]
+pub struct LinkMetadata {
+    pub href: String,
+    pub text: String,
+    pub title: Option<String>,
+    pub link_type: LinkType,
+    pub rel: Vec<String>,
+    pub attributes: HashMap<String, String>,
+}
+
+unsafe impl IntoValueFromNative for LinkMetadata {}
+
+impl magnus::TryConvert for LinkMetadata {
+    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
+        let r: &LinkMetadata = magnus::TryConvert::try_convert(val)?;
+        Ok(r.clone())
+    }
+}
+unsafe impl TryConvertOwned for LinkMetadata {}
+
+impl LinkMetadata {
+    fn new(
+        href: String,
+        text: String,
+        link_type: LinkType,
+        rel: Vec<String>,
+        attributes: HashMap<String, String>,
+        title: Option<String>,
+    ) -> Self {
+        Self {
+            href,
+            text,
+            title,
+            link_type,
+            rel,
+            attributes,
+        }
+    }
+
+    fn href(&self) -> String {
+        self.href.clone()
+    }
+
+    fn text(&self) -> String {
+        self.text.clone()
+    }
+
+    fn title(&self) -> Option<String> {
+        self.title.clone()
+    }
+
+    fn link_type(&self) -> LinkType {
+        self.link_type.clone()
+    }
+
+    fn rel(&self) -> Vec<String> {
+        self.rel.clone()
+    }
+
+    fn attributes(&self) -> HashMap<String, String> {
+        self.attributes.clone()
+    }
+}
+
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
+#[magnus::wrap(class = "HtmlToMarkdownRs::ImageMetadata")]
+pub struct ImageMetadata {
+    pub src: String,
+    pub alt: Option<String>,
+    pub title: Option<String>,
+    pub dimensions: Option<String>,
+    pub image_type: ImageType,
+    pub attributes: HashMap<String, String>,
+}
+
+unsafe impl IntoValueFromNative for ImageMetadata {}
+
+impl magnus::TryConvert for ImageMetadata {
+    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
+        let r: &ImageMetadata = magnus::TryConvert::try_convert(val)?;
+        Ok(r.clone())
+    }
+}
+unsafe impl TryConvertOwned for ImageMetadata {}
+
+impl ImageMetadata {
+    fn new(
+        src: String,
+        image_type: ImageType,
+        attributes: HashMap<String, String>,
+        alt: Option<String>,
+        title: Option<String>,
+        dimensions: Option<String>,
+    ) -> Self {
+        Self {
+            src,
+            alt,
+            title,
+            dimensions,
+            image_type,
+            attributes,
+        }
+    }
+
+    fn src(&self) -> String {
+        self.src.clone()
+    }
+
+    fn alt(&self) -> Option<String> {
+        self.alt.clone()
+    }
+
+    fn title(&self) -> Option<String> {
+        self.title.clone()
+    }
+
+    fn dimensions(&self) -> Option<String> {
+        self.dimensions.clone()
+    }
+
+    fn image_type(&self) -> ImageType {
+        self.image_type.clone()
+    }
+
+    fn attributes(&self) -> HashMap<String, String> {
+        self.attributes.clone()
+    }
+}
+
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
+#[magnus::wrap(class = "HtmlToMarkdownRs::StructuredData")]
+pub struct StructuredData {
+    pub data_type: StructuredDataType,
+    pub raw_json: String,
+    pub schema_type: Option<String>,
+}
+
+unsafe impl IntoValueFromNative for StructuredData {}
+
+impl magnus::TryConvert for StructuredData {
+    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
+        let r: &StructuredData = magnus::TryConvert::try_convert(val)?;
+        Ok(r.clone())
+    }
+}
+unsafe impl TryConvertOwned for StructuredData {}
+
+impl StructuredData {
+    fn new(data_type: StructuredDataType, raw_json: String, schema_type: Option<String>) -> Self {
+        Self {
+            data_type,
+            raw_json,
+            schema_type,
+        }
+    }
+
+    fn data_type(&self) -> StructuredDataType {
+        self.data_type.clone()
+    }
+
+    fn raw_json(&self) -> String {
+        self.raw_json.clone()
+    }
+
+    fn schema_type(&self) -> Option<String> {
+        self.schema_type.clone()
+    }
+}
+
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
+#[magnus::wrap(class = "HtmlToMarkdownRs::HtmlMetadata")]
+#[serde(default)]
+pub struct HtmlMetadata {
+    pub document: DocumentMetadata,
+    pub headers: Vec<HeaderMetadata>,
+    pub links: Vec<LinkMetadata>,
+    pub images: Vec<ImageMetadata>,
+    pub structured_data: Vec<StructuredData>,
+}
+
+unsafe impl IntoValueFromNative for HtmlMetadata {}
+
+impl magnus::TryConvert for HtmlMetadata {
+    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
+        let r: &HtmlMetadata = magnus::TryConvert::try_convert(val)?;
+        Ok(r.clone())
+    }
+}
+unsafe impl TryConvertOwned for HtmlMetadata {}
+
+impl Default for HtmlMetadata {
+    fn default() -> Self {
+        Self {
+            document: Default::default(),
+            headers: Default::default(),
+            links: Default::default(),
+            images: Default::default(),
+            structured_data: Default::default(),
+        }
+    }
+}
+
+impl HtmlMetadata {
+    fn new(
+        document: Option<DocumentMetadata>,
+        headers: Option<Vec<HeaderMetadata>>,
+        links: Option<Vec<LinkMetadata>>,
+        images: Option<Vec<ImageMetadata>>,
+        structured_data: Option<Vec<StructuredData>>,
+    ) -> Self {
+        Self {
+            document: document.unwrap_or_default(),
+            headers: headers.unwrap_or_default(),
+            links: links.unwrap_or_default(),
+            images: images.unwrap_or_default(),
+            structured_data: structured_data.unwrap_or_default(),
+        }
+    }
+
+    fn document(&self) -> DocumentMetadata {
+        self.document.clone()
+    }
+
+    fn headers(&self) -> Vec<HeaderMetadata> {
+        self.headers.clone()
+    }
+
+    fn links(&self) -> Vec<LinkMetadata> {
+        self.links.clone()
+    }
+
+    fn images(&self) -> Vec<ImageMetadata> {
+        self.images.clone()
+    }
+
+    fn structured_data(&self) -> Vec<StructuredData> {
+        self.structured_data.clone()
+    }
+}
+
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
+#[magnus::wrap(class = "HtmlToMarkdownRs::ConversionOptions")]
+#[serde(default)]
+pub struct ConversionOptions {
+    pub heading_style: HeadingStyle,
+    pub list_indent_type: ListIndentType,
+    pub list_indent_width: usize,
+    pub bullets: String,
+    pub strong_em_symbol: String,
+    pub escape_asterisks: bool,
+    pub escape_underscores: bool,
+    pub escape_misc: bool,
+    pub escape_ascii: bool,
+    pub code_language: String,
+    pub autolinks: bool,
+    pub default_title: bool,
+    pub br_in_tables: bool,
+    pub highlight_style: HighlightStyle,
+    pub extract_metadata: bool,
+    pub whitespace_mode: WhitespaceMode,
+    pub strip_newlines: bool,
+    pub wrap: bool,
+    pub wrap_width: usize,
+    pub convert_as_inline: bool,
+    pub sub_symbol: String,
+    pub sup_symbol: String,
+    pub newline_style: NewlineStyle,
+    pub code_block_style: CodeBlockStyle,
+    pub keep_inline_images_in: Vec<String>,
+    pub preprocessing: PreprocessingOptions,
+    pub encoding: String,
+    pub debug: bool,
+    pub strip_tags: Vec<String>,
+    pub preserve_tags: Vec<String>,
+    pub skip_images: bool,
+    pub link_style: LinkStyle,
+    pub output_format: OutputFormat,
+    pub include_document_structure: bool,
+    pub extract_images: bool,
+    pub max_image_size: u64,
+    pub capture_svg: bool,
+    pub infer_dimensions: bool,
+}
+
+unsafe impl IntoValueFromNative for ConversionOptions {}
+
+impl magnus::TryConvert for ConversionOptions {
+    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
+        let r: &ConversionOptions = magnus::TryConvert::try_convert(val)?;
+        Ok(r.clone())
+    }
+}
+unsafe impl TryConvertOwned for ConversionOptions {}
+
+impl Default for ConversionOptions {
+    fn default() -> Self {
+        Self {
+            heading_style: Default::default(),
+            list_indent_type: Default::default(),
+            list_indent_width: Default::default(),
+            bullets: Default::default(),
+            strong_em_symbol: Default::default(),
+            escape_asterisks: Default::default(),
+            escape_underscores: Default::default(),
+            escape_misc: Default::default(),
+            escape_ascii: Default::default(),
+            code_language: Default::default(),
+            autolinks: Default::default(),
+            default_title: Default::default(),
+            br_in_tables: Default::default(),
+            highlight_style: Default::default(),
+            extract_metadata: Default::default(),
+            whitespace_mode: Default::default(),
+            strip_newlines: Default::default(),
+            wrap: Default::default(),
+            wrap_width: Default::default(),
+            convert_as_inline: Default::default(),
+            sub_symbol: Default::default(),
+            sup_symbol: Default::default(),
+            newline_style: Default::default(),
+            code_block_style: Default::default(),
+            keep_inline_images_in: Default::default(),
+            preprocessing: Default::default(),
+            encoding: Default::default(),
+            debug: Default::default(),
+            strip_tags: Default::default(),
+            preserve_tags: Default::default(),
+            skip_images: Default::default(),
+            link_style: Default::default(),
+            output_format: Default::default(),
+            include_document_structure: Default::default(),
+            extract_images: Default::default(),
+            max_image_size: Default::default(),
+            capture_svg: Default::default(),
+            infer_dimensions: Default::default(),
+        }
+    }
+}
+
+impl ConversionOptions {
+    fn new(kwargs: magnus::RHash) -> Result<Self, magnus::Error> {
+        let ruby = unsafe { magnus::Ruby::get_unchecked() };
+        Ok(Self {
+            heading_style: kwargs
+                .get(ruby.to_symbol("heading_style"))
+                .and_then(|v| HeadingStyle::try_convert(v).ok())
+                .unwrap_or_default(),
+            list_indent_type: kwargs
+                .get(ruby.to_symbol("list_indent_type"))
+                .and_then(|v| ListIndentType::try_convert(v).ok())
+                .unwrap_or_default(),
+            list_indent_width: kwargs
+                .get(ruby.to_symbol("list_indent_width"))
+                .and_then(|v| usize::try_convert(v).ok())
+                .unwrap_or(2),
+            bullets: kwargs
+                .get(ruby.to_symbol("bullets"))
+                .and_then(|v| String::try_convert(v).ok())
+                .unwrap_or("-*+".to_string()),
+            strong_em_symbol: kwargs
+                .get(ruby.to_symbol("strong_em_symbol"))
+                .and_then(|v| String::try_convert(v).ok())
+                .unwrap_or("*".to_string()),
+            escape_asterisks: kwargs
+                .get(ruby.to_symbol("escape_asterisks"))
+                .and_then(|v| bool::try_convert(v).ok())
+                .unwrap_or(false),
+            escape_underscores: kwargs
+                .get(ruby.to_symbol("escape_underscores"))
+                .and_then(|v| bool::try_convert(v).ok())
+                .unwrap_or(false),
+            escape_misc: kwargs
+                .get(ruby.to_symbol("escape_misc"))
+                .and_then(|v| bool::try_convert(v).ok())
+                .unwrap_or(false),
+            escape_ascii: kwargs
+                .get(ruby.to_symbol("escape_ascii"))
+                .and_then(|v| bool::try_convert(v).ok())
+                .unwrap_or(false),
+            code_language: kwargs
+                .get(ruby.to_symbol("code_language"))
+                .and_then(|v| String::try_convert(v).ok())
+                .unwrap_or("".to_string()),
+            autolinks: kwargs
+                .get(ruby.to_symbol("autolinks"))
+                .and_then(|v| bool::try_convert(v).ok())
+                .unwrap_or(true),
+            default_title: kwargs
+                .get(ruby.to_symbol("default_title"))
+                .and_then(|v| bool::try_convert(v).ok())
+                .unwrap_or(false),
+            br_in_tables: kwargs
+                .get(ruby.to_symbol("br_in_tables"))
+                .and_then(|v| bool::try_convert(v).ok())
+                .unwrap_or(false),
+            highlight_style: kwargs
+                .get(ruby.to_symbol("highlight_style"))
+                .and_then(|v| HighlightStyle::try_convert(v).ok())
+                .unwrap_or_default(),
+            extract_metadata: kwargs
+                .get(ruby.to_symbol("extract_metadata"))
+                .and_then(|v| bool::try_convert(v).ok())
+                .unwrap_or(true),
+            whitespace_mode: kwargs
+                .get(ruby.to_symbol("whitespace_mode"))
+                .and_then(|v| WhitespaceMode::try_convert(v).ok())
+                .unwrap_or_default(),
+            strip_newlines: kwargs
+                .get(ruby.to_symbol("strip_newlines"))
+                .and_then(|v| bool::try_convert(v).ok())
+                .unwrap_or(false),
+            wrap: kwargs
+                .get(ruby.to_symbol("wrap"))
+                .and_then(|v| bool::try_convert(v).ok())
+                .unwrap_or(false),
+            wrap_width: kwargs
+                .get(ruby.to_symbol("wrap_width"))
+                .and_then(|v| usize::try_convert(v).ok())
+                .unwrap_or(80),
+            convert_as_inline: kwargs
+                .get(ruby.to_symbol("convert_as_inline"))
+                .and_then(|v| bool::try_convert(v).ok())
+                .unwrap_or(false),
+            sub_symbol: kwargs
+                .get(ruby.to_symbol("sub_symbol"))
+                .and_then(|v| String::try_convert(v).ok())
+                .unwrap_or("".to_string()),
+            sup_symbol: kwargs
+                .get(ruby.to_symbol("sup_symbol"))
+                .and_then(|v| String::try_convert(v).ok())
+                .unwrap_or("".to_string()),
+            newline_style: kwargs
+                .get(ruby.to_symbol("newline_style"))
+                .and_then(|v| NewlineStyle::try_convert(v).ok())
+                .unwrap_or(NewlineStyle::Spaces),
+            code_block_style: kwargs
+                .get(ruby.to_symbol("code_block_style"))
+                .and_then(|v| CodeBlockStyle::try_convert(v).ok())
+                .unwrap_or_default(),
+            keep_inline_images_in: kwargs
+                .get(ruby.to_symbol("keep_inline_images_in"))
+                .and_then(|v| <Vec<String>>::try_convert(v).ok())
+                .unwrap_or_default(),
+            preprocessing: kwargs
+                .get(ruby.to_symbol("preprocessing"))
+                .and_then(|v| PreprocessingOptions::try_convert(v).ok())
+                .unwrap_or_default(),
+            encoding: kwargs
+                .get(ruby.to_symbol("encoding"))
+                .and_then(|v| String::try_convert(v).ok())
+                .unwrap_or("utf-8".to_string()),
+            debug: kwargs
+                .get(ruby.to_symbol("debug"))
+                .and_then(|v| bool::try_convert(v).ok())
+                .unwrap_or(false),
+            strip_tags: kwargs
+                .get(ruby.to_symbol("strip_tags"))
+                .and_then(|v| <Vec<String>>::try_convert(v).ok())
+                .unwrap_or_default(),
+            preserve_tags: kwargs
+                .get(ruby.to_symbol("preserve_tags"))
+                .and_then(|v| <Vec<String>>::try_convert(v).ok())
+                .unwrap_or_default(),
+            skip_images: kwargs
+                .get(ruby.to_symbol("skip_images"))
+                .and_then(|v| bool::try_convert(v).ok())
+                .unwrap_or(false),
+            link_style: kwargs
+                .get(ruby.to_symbol("link_style"))
+                .and_then(|v| LinkStyle::try_convert(v).ok())
+                .unwrap_or_default(),
+            output_format: kwargs
+                .get(ruby.to_symbol("output_format"))
+                .and_then(|v| OutputFormat::try_convert(v).ok())
+                .unwrap_or_default(),
+            include_document_structure: kwargs
+                .get(ruby.to_symbol("include_document_structure"))
+                .and_then(|v| bool::try_convert(v).ok())
+                .unwrap_or(false),
+            extract_images: kwargs
+                .get(ruby.to_symbol("extract_images"))
+                .and_then(|v| bool::try_convert(v).ok())
+                .unwrap_or(false),
+            max_image_size: kwargs
+                .get(ruby.to_symbol("max_image_size"))
+                .and_then(|v| u64::try_convert(v).ok())
+                .unwrap_or(5242880),
+            capture_svg: kwargs
+                .get(ruby.to_symbol("capture_svg"))
+                .and_then(|v| bool::try_convert(v).ok())
+                .unwrap_or(false),
+            infer_dimensions: kwargs
+                .get(ruby.to_symbol("infer_dimensions"))
+                .and_then(|v| bool::try_convert(v).ok())
+                .unwrap_or(true),
+        })
+    }
+
+    fn heading_style(&self) -> HeadingStyle {
+        self.heading_style.clone()
+    }
+
+    fn list_indent_type(&self) -> ListIndentType {
+        self.list_indent_type.clone()
+    }
+
+    fn list_indent_width(&self) -> usize {
+        self.list_indent_width
+    }
+
+    fn bullets(&self) -> String {
+        self.bullets.clone()
+    }
+
+    fn strong_em_symbol(&self) -> String {
+        self.strong_em_symbol.clone()
+    }
+
+    fn escape_asterisks(&self) -> bool {
+        self.escape_asterisks
+    }
+
+    fn escape_underscores(&self) -> bool {
+        self.escape_underscores
+    }
+
+    fn escape_misc(&self) -> bool {
+        self.escape_misc
+    }
+
+    fn escape_ascii(&self) -> bool {
+        self.escape_ascii
+    }
+
+    fn code_language(&self) -> String {
+        self.code_language.clone()
+    }
+
+    fn autolinks(&self) -> bool {
+        self.autolinks
+    }
+
+    fn default_title(&self) -> bool {
+        self.default_title
+    }
+
+    fn br_in_tables(&self) -> bool {
+        self.br_in_tables
+    }
+
+    fn highlight_style(&self) -> HighlightStyle {
+        self.highlight_style.clone()
+    }
+
+    fn extract_metadata(&self) -> bool {
+        self.extract_metadata
+    }
+
+    fn whitespace_mode(&self) -> WhitespaceMode {
+        self.whitespace_mode.clone()
+    }
+
+    fn strip_newlines(&self) -> bool {
+        self.strip_newlines
+    }
+
+    fn wrap(&self) -> bool {
+        self.wrap
+    }
+
+    fn wrap_width(&self) -> usize {
+        self.wrap_width
+    }
+
+    fn convert_as_inline(&self) -> bool {
+        self.convert_as_inline
+    }
+
+    fn sub_symbol(&self) -> String {
+        self.sub_symbol.clone()
+    }
+
+    fn sup_symbol(&self) -> String {
+        self.sup_symbol.clone()
+    }
+
+    fn newline_style(&self) -> NewlineStyle {
+        self.newline_style.clone()
+    }
+
+    fn code_block_style(&self) -> CodeBlockStyle {
+        self.code_block_style.clone()
+    }
+
+    fn keep_inline_images_in(&self) -> Vec<String> {
+        self.keep_inline_images_in.clone()
+    }
+
+    fn preprocessing(&self) -> PreprocessingOptions {
+        self.preprocessing.clone()
+    }
+
+    fn encoding(&self) -> String {
+        self.encoding.clone()
+    }
+
+    fn debug(&self) -> bool {
+        self.debug
+    }
+
+    fn strip_tags(&self) -> Vec<String> {
+        self.strip_tags.clone()
+    }
+
+    fn preserve_tags(&self) -> Vec<String> {
+        self.preserve_tags.clone()
+    }
+
+    fn skip_images(&self) -> bool {
+        self.skip_images
+    }
+
+    fn link_style(&self) -> LinkStyle {
+        self.link_style.clone()
+    }
+
+    fn output_format(&self) -> OutputFormat {
+        self.output_format.clone()
+    }
+
+    fn include_document_structure(&self) -> bool {
+        self.include_document_structure
+    }
+
+    fn extract_images(&self) -> bool {
+        self.extract_images
+    }
+
+    fn max_image_size(&self) -> u64 {
+        self.max_image_size
+    }
+
+    fn capture_svg(&self) -> bool {
+        self.capture_svg
+    }
+
+    fn infer_dimensions(&self) -> bool {
+        self.infer_dimensions
+    }
+}
+
+#[derive(Clone)]
+#[magnus::wrap(class = "HtmlToMarkdownRs::ConversionOptionsBuilder")]
+pub struct ConversionOptionsBuilder {
+    inner: Arc<html_to_markdown_rs::options::ConversionOptionsBuilder>,
+}
+
+unsafe impl IntoValueFromNative for ConversionOptionsBuilder {}
+
+impl magnus::TryConvert for ConversionOptionsBuilder {
+    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
+        let r: &ConversionOptionsBuilder = magnus::TryConvert::try_convert(val)?;
+        Ok(r.clone())
+    }
+}
+unsafe impl TryConvertOwned for ConversionOptionsBuilder {}
+
+impl ConversionOptionsBuilder {
+    fn strip_tags(&self, tags: Vec<String>) -> ConversionOptionsBuilder {
+        Self {
+            inner: Arc::new(self.inner.as_ref().clone().strip_tags(tags)),
+        }
+    }
+
+    fn preserve_tags(&self, tags: Vec<String>) -> ConversionOptionsBuilder {
+        Self {
+            inner: Arc::new(self.inner.as_ref().clone().preserve_tags(tags)),
+        }
+    }
+
+    fn keep_inline_images_in(&self, tags: Vec<String>) -> ConversionOptionsBuilder {
+        Self {
+            inner: Arc::new(self.inner.as_ref().clone().keep_inline_images_in(tags)),
+        }
+    }
+
+    fn preprocessing(&self, preprocessing: PreprocessingOptions) -> ConversionOptionsBuilder {
+        Self {
+            inner: Arc::new(self.inner.as_ref().clone().preprocessing(preprocessing.into())),
+        }
+    }
+
+    fn build(&self) -> ConversionOptions {
+        self.inner.as_ref().clone().build().into()
+    }
+}
+
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
+#[magnus::wrap(class = "HtmlToMarkdownRs::ConversionOptionsUpdate")]
+#[serde(default)]
+pub struct ConversionOptionsUpdate {
+    pub heading_style: Option<HeadingStyle>,
+    pub list_indent_type: Option<ListIndentType>,
+    pub list_indent_width: Option<usize>,
+    pub bullets: Option<String>,
+    pub strong_em_symbol: Option<String>,
+    pub escape_asterisks: Option<bool>,
+    pub escape_underscores: Option<bool>,
+    pub escape_misc: Option<bool>,
+    pub escape_ascii: Option<bool>,
+    pub code_language: Option<String>,
+    pub autolinks: Option<bool>,
+    pub default_title: Option<bool>,
+    pub br_in_tables: Option<bool>,
+    pub highlight_style: Option<HighlightStyle>,
+    pub extract_metadata: Option<bool>,
+    pub whitespace_mode: Option<WhitespaceMode>,
+    pub strip_newlines: Option<bool>,
+    pub wrap: Option<bool>,
+    pub wrap_width: Option<usize>,
+    pub convert_as_inline: Option<bool>,
+    pub sub_symbol: Option<String>,
+    pub sup_symbol: Option<String>,
+    pub newline_style: Option<NewlineStyle>,
+    pub code_block_style: Option<CodeBlockStyle>,
+    pub keep_inline_images_in: Option<Vec<String>>,
+    pub preprocessing: Option<PreprocessingOptionsUpdate>,
+    pub encoding: Option<String>,
+    pub debug: Option<bool>,
+    pub strip_tags: Option<Vec<String>>,
+    pub preserve_tags: Option<Vec<String>>,
+    pub skip_images: Option<bool>,
+    pub link_style: Option<LinkStyle>,
+    pub output_format: Option<OutputFormat>,
+    pub include_document_structure: Option<bool>,
+    pub extract_images: Option<bool>,
+    pub max_image_size: Option<u64>,
+    pub capture_svg: Option<bool>,
+    pub infer_dimensions: Option<bool>,
+}
+
+unsafe impl IntoValueFromNative for ConversionOptionsUpdate {}
+
+impl magnus::TryConvert for ConversionOptionsUpdate {
+    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
+        let r: &ConversionOptionsUpdate = magnus::TryConvert::try_convert(val)?;
+        Ok(r.clone())
+    }
+}
+unsafe impl TryConvertOwned for ConversionOptionsUpdate {}
+
+impl Default for ConversionOptionsUpdate {
+    fn default() -> Self {
+        Self {
+            heading_style: Default::default(),
+            list_indent_type: Default::default(),
+            list_indent_width: Default::default(),
+            bullets: Default::default(),
+            strong_em_symbol: Default::default(),
+            escape_asterisks: Default::default(),
+            escape_underscores: Default::default(),
+            escape_misc: Default::default(),
+            escape_ascii: Default::default(),
+            code_language: Default::default(),
+            autolinks: Default::default(),
+            default_title: Default::default(),
+            br_in_tables: Default::default(),
+            highlight_style: Default::default(),
+            extract_metadata: Default::default(),
+            whitespace_mode: Default::default(),
+            strip_newlines: Default::default(),
+            wrap: Default::default(),
+            wrap_width: Default::default(),
+            convert_as_inline: Default::default(),
+            sub_symbol: Default::default(),
+            sup_symbol: Default::default(),
+            newline_style: Default::default(),
+            code_block_style: Default::default(),
+            keep_inline_images_in: Default::default(),
+            preprocessing: Default::default(),
+            encoding: Default::default(),
+            debug: Default::default(),
+            strip_tags: Default::default(),
+            preserve_tags: Default::default(),
+            skip_images: Default::default(),
+            link_style: Default::default(),
+            output_format: Default::default(),
+            include_document_structure: Default::default(),
+            extract_images: Default::default(),
+            max_image_size: Default::default(),
+            capture_svg: Default::default(),
+            infer_dimensions: Default::default(),
+        }
+    }
+}
+
+impl ConversionOptionsUpdate {
+    fn new(kwargs: magnus::RHash) -> Result<Self, magnus::Error> {
+        let ruby = unsafe { magnus::Ruby::get_unchecked() };
+        Ok(Self {
+            heading_style: kwargs
+                .get(ruby.to_symbol("heading_style"))
+                .and_then(|v| HeadingStyle::try_convert(v).ok()),
+            list_indent_type: kwargs
+                .get(ruby.to_symbol("list_indent_type"))
+                .and_then(|v| ListIndentType::try_convert(v).ok()),
+            list_indent_width: kwargs
+                .get(ruby.to_symbol("list_indent_width"))
+                .and_then(|v| usize::try_convert(v).ok()),
+            bullets: kwargs
+                .get(ruby.to_symbol("bullets"))
+                .and_then(|v| String::try_convert(v).ok()),
+            strong_em_symbol: kwargs
+                .get(ruby.to_symbol("strong_em_symbol"))
+                .and_then(|v| String::try_convert(v).ok()),
+            escape_asterisks: kwargs
+                .get(ruby.to_symbol("escape_asterisks"))
+                .and_then(|v| bool::try_convert(v).ok()),
+            escape_underscores: kwargs
+                .get(ruby.to_symbol("escape_underscores"))
+                .and_then(|v| bool::try_convert(v).ok()),
+            escape_misc: kwargs
+                .get(ruby.to_symbol("escape_misc"))
+                .and_then(|v| bool::try_convert(v).ok()),
+            escape_ascii: kwargs
+                .get(ruby.to_symbol("escape_ascii"))
+                .and_then(|v| bool::try_convert(v).ok()),
+            code_language: kwargs
+                .get(ruby.to_symbol("code_language"))
+                .and_then(|v| String::try_convert(v).ok()),
+            autolinks: kwargs
+                .get(ruby.to_symbol("autolinks"))
+                .and_then(|v| bool::try_convert(v).ok()),
+            default_title: kwargs
+                .get(ruby.to_symbol("default_title"))
+                .and_then(|v| bool::try_convert(v).ok()),
+            br_in_tables: kwargs
+                .get(ruby.to_symbol("br_in_tables"))
+                .and_then(|v| bool::try_convert(v).ok()),
+            highlight_style: kwargs
+                .get(ruby.to_symbol("highlight_style"))
+                .and_then(|v| HighlightStyle::try_convert(v).ok()),
+            extract_metadata: kwargs
+                .get(ruby.to_symbol("extract_metadata"))
+                .and_then(|v| bool::try_convert(v).ok()),
+            whitespace_mode: kwargs
+                .get(ruby.to_symbol("whitespace_mode"))
+                .and_then(|v| WhitespaceMode::try_convert(v).ok()),
+            strip_newlines: kwargs
+                .get(ruby.to_symbol("strip_newlines"))
+                .and_then(|v| bool::try_convert(v).ok()),
+            wrap: kwargs
+                .get(ruby.to_symbol("wrap"))
+                .and_then(|v| bool::try_convert(v).ok()),
+            wrap_width: kwargs
+                .get(ruby.to_symbol("wrap_width"))
+                .and_then(|v| usize::try_convert(v).ok()),
+            convert_as_inline: kwargs
+                .get(ruby.to_symbol("convert_as_inline"))
+                .and_then(|v| bool::try_convert(v).ok()),
+            sub_symbol: kwargs
+                .get(ruby.to_symbol("sub_symbol"))
+                .and_then(|v| String::try_convert(v).ok()),
+            sup_symbol: kwargs
+                .get(ruby.to_symbol("sup_symbol"))
+                .and_then(|v| String::try_convert(v).ok()),
+            newline_style: kwargs
+                .get(ruby.to_symbol("newline_style"))
+                .and_then(|v| NewlineStyle::try_convert(v).ok()),
+            code_block_style: kwargs
+                .get(ruby.to_symbol("code_block_style"))
+                .and_then(|v| CodeBlockStyle::try_convert(v).ok()),
+            keep_inline_images_in: kwargs
+                .get(ruby.to_symbol("keep_inline_images_in"))
+                .and_then(|v| <Vec<String>>::try_convert(v).ok()),
+            preprocessing: kwargs
+                .get(ruby.to_symbol("preprocessing"))
+                .and_then(|v| PreprocessingOptionsUpdate::try_convert(v).ok()),
+            encoding: kwargs
+                .get(ruby.to_symbol("encoding"))
+                .and_then(|v| String::try_convert(v).ok()),
+            debug: kwargs
+                .get(ruby.to_symbol("debug"))
+                .and_then(|v| bool::try_convert(v).ok()),
+            strip_tags: kwargs
+                .get(ruby.to_symbol("strip_tags"))
+                .and_then(|v| <Vec<String>>::try_convert(v).ok()),
+            preserve_tags: kwargs
+                .get(ruby.to_symbol("preserve_tags"))
+                .and_then(|v| <Vec<String>>::try_convert(v).ok()),
+            skip_images: kwargs
+                .get(ruby.to_symbol("skip_images"))
+                .and_then(|v| bool::try_convert(v).ok()),
+            link_style: kwargs
+                .get(ruby.to_symbol("link_style"))
+                .and_then(|v| LinkStyle::try_convert(v).ok()),
+            output_format: kwargs
+                .get(ruby.to_symbol("output_format"))
+                .and_then(|v| OutputFormat::try_convert(v).ok()),
+            include_document_structure: kwargs
+                .get(ruby.to_symbol("include_document_structure"))
+                .and_then(|v| bool::try_convert(v).ok()),
+            extract_images: kwargs
+                .get(ruby.to_symbol("extract_images"))
+                .and_then(|v| bool::try_convert(v).ok()),
+            max_image_size: kwargs
+                .get(ruby.to_symbol("max_image_size"))
+                .and_then(|v| u64::try_convert(v).ok()),
+            capture_svg: kwargs
+                .get(ruby.to_symbol("capture_svg"))
+                .and_then(|v| bool::try_convert(v).ok()),
+            infer_dimensions: kwargs
+                .get(ruby.to_symbol("infer_dimensions"))
+                .and_then(|v| bool::try_convert(v).ok()),
+        })
+    }
+
+    fn heading_style(&self) -> Option<HeadingStyle> {
+        self.heading_style.clone()
+    }
+
+    fn list_indent_type(&self) -> Option<ListIndentType> {
+        self.list_indent_type.clone()
+    }
+
+    fn list_indent_width(&self) -> Option<usize> {
+        self.list_indent_width
+    }
+
+    fn bullets(&self) -> Option<String> {
+        self.bullets.clone()
+    }
+
+    fn strong_em_symbol(&self) -> Option<String> {
+        self.strong_em_symbol.clone()
+    }
+
+    fn escape_asterisks(&self) -> Option<bool> {
+        self.escape_asterisks
+    }
+
+    fn escape_underscores(&self) -> Option<bool> {
+        self.escape_underscores
+    }
+
+    fn escape_misc(&self) -> Option<bool> {
+        self.escape_misc
+    }
+
+    fn escape_ascii(&self) -> Option<bool> {
+        self.escape_ascii
+    }
+
+    fn code_language(&self) -> Option<String> {
+        self.code_language.clone()
+    }
+
+    fn autolinks(&self) -> Option<bool> {
+        self.autolinks
+    }
+
+    fn default_title(&self) -> Option<bool> {
+        self.default_title
+    }
+
+    fn br_in_tables(&self) -> Option<bool> {
+        self.br_in_tables
+    }
+
+    fn highlight_style(&self) -> Option<HighlightStyle> {
+        self.highlight_style.clone()
+    }
+
+    fn extract_metadata(&self) -> Option<bool> {
+        self.extract_metadata
+    }
+
+    fn whitespace_mode(&self) -> Option<WhitespaceMode> {
+        self.whitespace_mode.clone()
+    }
+
+    fn strip_newlines(&self) -> Option<bool> {
+        self.strip_newlines
+    }
+
+    fn wrap(&self) -> Option<bool> {
+        self.wrap
+    }
+
+    fn wrap_width(&self) -> Option<usize> {
+        self.wrap_width
+    }
+
+    fn convert_as_inline(&self) -> Option<bool> {
+        self.convert_as_inline
+    }
+
+    fn sub_symbol(&self) -> Option<String> {
+        self.sub_symbol.clone()
+    }
+
+    fn sup_symbol(&self) -> Option<String> {
+        self.sup_symbol.clone()
+    }
+
+    fn newline_style(&self) -> Option<NewlineStyle> {
+        self.newline_style.clone()
+    }
+
+    fn code_block_style(&self) -> Option<CodeBlockStyle> {
+        self.code_block_style.clone()
+    }
+
+    fn keep_inline_images_in(&self) -> Option<Vec<String>> {
+        self.keep_inline_images_in.clone()
+    }
+
+    fn preprocessing(&self) -> Option<PreprocessingOptionsUpdate> {
+        self.preprocessing.clone()
+    }
+
+    fn encoding(&self) -> Option<String> {
+        self.encoding.clone()
+    }
+
+    fn debug(&self) -> Option<bool> {
+        self.debug
+    }
+
+    fn strip_tags(&self) -> Option<Vec<String>> {
+        self.strip_tags.clone()
+    }
+
+    fn preserve_tags(&self) -> Option<Vec<String>> {
+        self.preserve_tags.clone()
+    }
+
+    fn skip_images(&self) -> Option<bool> {
+        self.skip_images
+    }
+
+    fn link_style(&self) -> Option<LinkStyle> {
+        self.link_style.clone()
+    }
+
+    fn output_format(&self) -> Option<OutputFormat> {
+        self.output_format.clone()
+    }
+
+    fn include_document_structure(&self) -> Option<bool> {
+        self.include_document_structure
+    }
+
+    fn extract_images(&self) -> Option<bool> {
+        self.extract_images
+    }
+
+    fn max_image_size(&self) -> Option<u64> {
+        self.max_image_size
+    }
+
+    fn capture_svg(&self) -> Option<bool> {
+        self.capture_svg
+    }
+
+    fn infer_dimensions(&self) -> Option<bool> {
+        self.infer_dimensions
+    }
+}
+
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
+#[magnus::wrap(class = "HtmlToMarkdownRs::PreprocessingOptions")]
+#[serde(default)]
+pub struct PreprocessingOptions {
+    pub enabled: bool,
+    pub preset: PreprocessingPreset,
+    pub remove_navigation: bool,
+    pub remove_forms: bool,
+}
+
+unsafe impl IntoValueFromNative for PreprocessingOptions {}
+
+impl magnus::TryConvert for PreprocessingOptions {
+    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
+        let r: &PreprocessingOptions = magnus::TryConvert::try_convert(val)?;
+        Ok(r.clone())
+    }
+}
+unsafe impl TryConvertOwned for PreprocessingOptions {}
+
+impl Default for PreprocessingOptions {
+    fn default() -> Self {
+        Self {
+            enabled: Default::default(),
+            preset: Default::default(),
+            remove_navigation: Default::default(),
+            remove_forms: Default::default(),
+        }
+    }
+}
+
+impl PreprocessingOptions {
+    fn new(
+        enabled: Option<bool>,
+        preset: Option<PreprocessingPreset>,
+        remove_navigation: Option<bool>,
+        remove_forms: Option<bool>,
+    ) -> Self {
+        Self {
+            enabled: enabled.unwrap_or(true),
+            preset: preset.unwrap_or_default(),
+            remove_navigation: remove_navigation.unwrap_or(true),
+            remove_forms: remove_forms.unwrap_or(true),
+        }
+    }
+
+    fn enabled(&self) -> bool {
+        self.enabled
+    }
+
+    fn preset(&self) -> PreprocessingPreset {
+        self.preset.clone()
+    }
+
+    fn remove_navigation(&self) -> bool {
+        self.remove_navigation
+    }
+
+    fn remove_forms(&self) -> bool {
+        self.remove_forms
+    }
+}
+
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
+#[magnus::wrap(class = "HtmlToMarkdownRs::PreprocessingOptionsUpdate")]
+#[serde(default)]
+pub struct PreprocessingOptionsUpdate {
+    pub enabled: Option<bool>,
+    pub preset: Option<PreprocessingPreset>,
+    pub remove_navigation: Option<bool>,
+    pub remove_forms: Option<bool>,
+}
+
+unsafe impl IntoValueFromNative for PreprocessingOptionsUpdate {}
+
+impl magnus::TryConvert for PreprocessingOptionsUpdate {
+    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
+        let r: &PreprocessingOptionsUpdate = magnus::TryConvert::try_convert(val)?;
+        Ok(r.clone())
+    }
+}
+unsafe impl TryConvertOwned for PreprocessingOptionsUpdate {}
+
+impl Default for PreprocessingOptionsUpdate {
+    fn default() -> Self {
+        Self {
+            enabled: Default::default(),
+            preset: Default::default(),
+            remove_navigation: Default::default(),
+            remove_forms: Default::default(),
+        }
+    }
+}
+
+impl PreprocessingOptionsUpdate {
+    fn new(
+        enabled: Option<bool>,
+        preset: Option<PreprocessingPreset>,
+        remove_navigation: Option<bool>,
+        remove_forms: Option<bool>,
+    ) -> Self {
+        Self {
+            enabled,
+            preset,
+            remove_navigation,
+            remove_forms,
+        }
+    }
+
+    fn enabled(&self) -> Option<bool> {
+        self.enabled
+    }
+
+    fn preset(&self) -> Option<PreprocessingPreset> {
+        self.preset.clone()
+    }
+
+    fn remove_navigation(&self) -> Option<bool> {
+        self.remove_navigation
+    }
+
+    fn remove_forms(&self) -> Option<bool> {
+        self.remove_forms
+    }
+}
+
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
+#[magnus::wrap(class = "HtmlToMarkdownRs::DocumentStructure")]
+pub struct DocumentStructure {
+    pub nodes: Vec<DocumentNode>,
+    pub source_format: Option<String>,
+}
+
+unsafe impl IntoValueFromNative for DocumentStructure {}
+
+impl magnus::TryConvert for DocumentStructure {
+    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
+        let r: &DocumentStructure = magnus::TryConvert::try_convert(val)?;
+        Ok(r.clone())
+    }
+}
+unsafe impl TryConvertOwned for DocumentStructure {}
+
+impl DocumentStructure {
+    fn new(nodes: Vec<DocumentNode>, source_format: Option<String>) -> Self {
+        Self { nodes, source_format }
+    }
+
+    fn nodes(&self) -> Vec<DocumentNode> {
+        self.nodes.clone()
+    }
+
+    fn source_format(&self) -> Option<String> {
+        self.source_format.clone()
+    }
+}
+
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
+#[magnus::wrap(class = "HtmlToMarkdownRs::DocumentNode")]
+pub struct DocumentNode {
+    pub id: String,
+    pub content: NodeContent,
+    pub parent: Option<u32>,
+    pub children: Vec<u32>,
+    pub annotations: Vec<TextAnnotation>,
+    pub attributes: Option<HashMap<String, String>>,
+}
+
+unsafe impl IntoValueFromNative for DocumentNode {}
+
+impl magnus::TryConvert for DocumentNode {
+    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
+        let r: &DocumentNode = magnus::TryConvert::try_convert(val)?;
+        Ok(r.clone())
+    }
+}
+unsafe impl TryConvertOwned for DocumentNode {}
+
+impl DocumentNode {
+    fn new(
+        id: String,
+        content: NodeContent,
+        children: Vec<u32>,
+        annotations: Vec<TextAnnotation>,
+        parent: Option<u32>,
+        attributes: Option<HashMap<String, String>>,
+    ) -> Self {
+        Self {
+            id,
+            content,
+            parent,
+            children,
+            annotations,
+            attributes,
+        }
+    }
+
+    fn id(&self) -> String {
+        self.id.clone()
+    }
+
+    fn content(&self) -> NodeContent {
+        self.content.clone()
+    }
+
+    fn parent(&self) -> Option<u32> {
+        self.parent
+    }
+
+    fn children(&self) -> Vec<u32> {
+        self.children.clone()
+    }
+
+    fn annotations(&self) -> Vec<TextAnnotation> {
+        self.annotations.clone()
+    }
+
+    fn attributes(&self) -> Option<HashMap<String, String>> {
+        self.attributes.clone()
+    }
+}
+
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
+#[magnus::wrap(class = "HtmlToMarkdownRs::TextAnnotation")]
+pub struct TextAnnotation {
+    pub start: u32,
+    pub end: u32,
+    pub kind: AnnotationKind,
+}
+
+unsafe impl IntoValueFromNative for TextAnnotation {}
+
+impl magnus::TryConvert for TextAnnotation {
+    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
+        let r: &TextAnnotation = magnus::TryConvert::try_convert(val)?;
+        Ok(r.clone())
+    }
+}
+unsafe impl TryConvertOwned for TextAnnotation {}
+
+impl TextAnnotation {
+    fn new(start: u32, end: u32, kind: AnnotationKind) -> Self {
+        Self { start, end, kind }
+    }
+
+    fn start(&self) -> u32 {
+        self.start
+    }
+
+    fn end(&self) -> u32 {
+        self.end
+    }
+
+    fn kind(&self) -> AnnotationKind {
+        self.kind.clone()
+    }
+}
+
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
+#[magnus::wrap(class = "HtmlToMarkdownRs::ConversionResult")]
+#[serde(default)]
+pub struct ConversionResult {
+    pub content: Option<String>,
+    pub document: Option<DocumentStructure>,
+    pub metadata: HtmlMetadata,
+    pub tables: Vec<TableData>,
+    pub images: Vec<String>,
+    pub warnings: Vec<ProcessingWarning>,
+}
+
+unsafe impl IntoValueFromNative for ConversionResult {}
+
+impl magnus::TryConvert for ConversionResult {
+    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
+        let r: &ConversionResult = magnus::TryConvert::try_convert(val)?;
+        Ok(r.clone())
+    }
+}
+unsafe impl TryConvertOwned for ConversionResult {}
+
+impl Default for ConversionResult {
+    fn default() -> Self {
+        Self {
+            content: Default::default(),
+            document: Default::default(),
+            metadata: Default::default(),
+            tables: Default::default(),
+            images: Default::default(),
+            warnings: Default::default(),
+        }
+    }
+}
+
+impl ConversionResult {
+    fn new(
+        content: Option<String>,
+        document: Option<DocumentStructure>,
+        metadata: Option<HtmlMetadata>,
+        tables: Option<Vec<TableData>>,
+        images: Option<Vec<String>>,
+        warnings: Option<Vec<ProcessingWarning>>,
+    ) -> Self {
+        Self {
+            content,
+            document,
+            metadata: metadata.unwrap_or_default(),
+            tables: tables.unwrap_or_default(),
+            images: images.unwrap_or_default(),
+            warnings: warnings.unwrap_or_default(),
+        }
+    }
+
+    fn content(&self) -> Option<String> {
+        self.content.clone()
+    }
+
+    fn document(&self) -> Option<DocumentStructure> {
+        self.document.clone()
+    }
+
+    fn metadata(&self) -> HtmlMetadata {
+        self.metadata.clone()
+    }
+
+    fn tables(&self) -> Vec<TableData> {
+        self.tables.clone()
+    }
+
+    fn images(&self) -> Vec<String> {
+        self.images.clone()
+    }
+
+    fn warnings(&self) -> Vec<ProcessingWarning> {
+        self.warnings.clone()
+    }
+}
+
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
+#[magnus::wrap(class = "HtmlToMarkdownRs::TableGrid")]
+#[serde(default)]
+pub struct TableGrid {
+    pub rows: u32,
+    pub cols: u32,
+    pub cells: Vec<GridCell>,
+}
+
+unsafe impl IntoValueFromNative for TableGrid {}
+
+impl magnus::TryConvert for TableGrid {
+    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
+        let r: &TableGrid = magnus::TryConvert::try_convert(val)?;
+        Ok(r.clone())
+    }
+}
+unsafe impl TryConvertOwned for TableGrid {}
+
+impl Default for TableGrid {
+    fn default() -> Self {
+        Self {
+            rows: Default::default(),
+            cols: Default::default(),
+            cells: Default::default(),
+        }
+    }
+}
+
+impl TableGrid {
+    fn new(rows: Option<u32>, cols: Option<u32>, cells: Option<Vec<GridCell>>) -> Self {
+        Self {
+            rows: rows.unwrap_or_default(),
+            cols: cols.unwrap_or_default(),
+            cells: cells.unwrap_or_default(),
+        }
+    }
+
+    fn rows(&self) -> u32 {
+        self.rows
+    }
+
+    fn cols(&self) -> u32 {
+        self.cols
+    }
+
+    fn cells(&self) -> Vec<GridCell> {
+        self.cells.clone()
+    }
+}
+
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
+#[magnus::wrap(class = "HtmlToMarkdownRs::GridCell")]
+pub struct GridCell {
+    pub content: String,
+    pub row: u32,
+    pub col: u32,
+    pub row_span: u32,
+    pub col_span: u32,
+    pub is_header: bool,
+}
+
+unsafe impl IntoValueFromNative for GridCell {}
+
+impl magnus::TryConvert for GridCell {
+    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
+        let r: &GridCell = magnus::TryConvert::try_convert(val)?;
+        Ok(r.clone())
+    }
+}
+unsafe impl TryConvertOwned for GridCell {}
+
+impl GridCell {
+    fn new(content: String, row: u32, col: u32, row_span: u32, col_span: u32, is_header: bool) -> Self {
+        Self {
+            content,
+            row,
+            col,
+            row_span,
+            col_span,
+            is_header,
+        }
+    }
+
+    fn content(&self) -> String {
+        self.content.clone()
+    }
+
+    fn row(&self) -> u32 {
+        self.row
+    }
+
+    fn col(&self) -> u32 {
+        self.col
+    }
+
+    fn row_span(&self) -> u32 {
+        self.row_span
+    }
+
+    fn col_span(&self) -> u32 {
+        self.col_span
+    }
+
+    fn is_header(&self) -> bool {
+        self.is_header
+    }
+}
+
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
+#[magnus::wrap(class = "HtmlToMarkdownRs::TableData")]
+pub struct TableData {
+    pub grid: TableGrid,
+    pub markdown: String,
+}
+
+unsafe impl IntoValueFromNative for TableData {}
+
+impl magnus::TryConvert for TableData {
+    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
+        let r: &TableData = magnus::TryConvert::try_convert(val)?;
+        Ok(r.clone())
+    }
+}
+unsafe impl TryConvertOwned for TableData {}
+
+impl TableData {
+    fn new(grid: TableGrid, markdown: String) -> Self {
+        Self { grid, markdown }
+    }
+
+    fn grid(&self) -> TableGrid {
+        self.grid.clone()
+    }
+
+    fn markdown(&self) -> String {
+        self.markdown.clone()
+    }
+}
+
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
+#[magnus::wrap(class = "HtmlToMarkdownRs::ProcessingWarning")]
+pub struct ProcessingWarning {
+    pub message: String,
+    pub kind: WarningKind,
+}
+
+unsafe impl IntoValueFromNative for ProcessingWarning {}
+
+impl magnus::TryConvert for ProcessingWarning {
+    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
+        let r: &ProcessingWarning = magnus::TryConvert::try_convert(val)?;
+        Ok(r.clone())
+    }
+}
+unsafe impl TryConvertOwned for ProcessingWarning {}
+
+impl ProcessingWarning {
+    fn new(message: String, kind: WarningKind) -> Self {
+        Self { message, kind }
+    }
+
+    fn message(&self) -> String {
+        self.message.clone()
+    }
+
+    fn kind(&self) -> WarningKind {
+        self.kind.clone()
+    }
+}
+
+#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+pub enum TextDirection {
+    #[serde(rename = "ltr")]
+    LeftToRight,
+    #[serde(rename = "rtl")]
+    RightToLeft,
+    #[serde(rename = "auto")]
+    Auto,
+}
+
+impl Default for TextDirection {
+    fn default() -> Self {
+        Self::LeftToRight
+    }
+}
+
+impl magnus::IntoValue for TextDirection {
+    fn into_value_with(self, handle: &Ruby) -> magnus::Value {
+        let sym = match self {
+            TextDirection::LeftToRight => "left_to_right",
+            TextDirection::RightToLeft => "right_to_left",
+            TextDirection::Auto => "auto",
+        };
+        handle.to_symbol(sym).into_value_with(handle)
+    }
+}
+
+impl magnus::TryConvert for TextDirection {
+    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
+        let s: String = magnus::TryConvert::try_convert(val)?;
+        match s.as_str() {
+            "left_to_right" => Ok(TextDirection::LeftToRight),
+            "right_to_left" => Ok(TextDirection::RightToLeft),
+            "auto" => Ok(TextDirection::Auto),
+            other => Err(magnus::Error::new(
+                unsafe { Ruby::get_unchecked() }.exception_arg_error(),
+                format!("invalid TextDirection value: {other}"),
+            )),
+        }
+    }
+}
+
+unsafe impl IntoValueFromNative for TextDirection {}
+unsafe impl TryConvertOwned for TextDirection {}
+
+#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+pub enum LinkType {
+    Anchor,
+    Internal,
+    External,
+    Email,
+    Phone,
+    Other,
+}
+
+impl Default for LinkType {
+    fn default() -> Self {
+        Self::Anchor
+    }
+}
+
+impl magnus::IntoValue for LinkType {
+    fn into_value_with(self, handle: &Ruby) -> magnus::Value {
+        let sym = match self {
+            LinkType::Anchor => "anchor",
+            LinkType::Internal => "internal",
+            LinkType::External => "external",
+            LinkType::Email => "email",
+            LinkType::Phone => "phone",
+            LinkType::Other => "other",
+        };
+        handle.to_symbol(sym).into_value_with(handle)
+    }
+}
+
+impl magnus::TryConvert for LinkType {
+    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
+        let s: String = magnus::TryConvert::try_convert(val)?;
+        match s.as_str() {
+            "anchor" => Ok(LinkType::Anchor),
+            "internal" => Ok(LinkType::Internal),
+            "external" => Ok(LinkType::External),
+            "email" => Ok(LinkType::Email),
+            "phone" => Ok(LinkType::Phone),
+            "other" => Ok(LinkType::Other),
+            other => Err(magnus::Error::new(
+                unsafe { Ruby::get_unchecked() }.exception_arg_error(),
+                format!("invalid LinkType value: {other}"),
+            )),
+        }
+    }
+}
+
+unsafe impl IntoValueFromNative for LinkType {}
+unsafe impl TryConvertOwned for LinkType {}
+
+#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+pub enum ImageType {
+    DataUri,
+    InlineSvg,
+    External,
+    Relative,
+}
+
+impl Default for ImageType {
+    fn default() -> Self {
+        Self::DataUri
+    }
+}
+
+impl magnus::IntoValue for ImageType {
+    fn into_value_with(self, handle: &Ruby) -> magnus::Value {
+        let sym = match self {
+            ImageType::DataUri => "data_uri",
+            ImageType::InlineSvg => "inline_svg",
+            ImageType::External => "external",
+            ImageType::Relative => "relative",
+        };
+        handle.to_symbol(sym).into_value_with(handle)
+    }
+}
+
+impl magnus::TryConvert for ImageType {
+    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
+        let s: String = magnus::TryConvert::try_convert(val)?;
+        match s.as_str() {
+            "data_uri" => Ok(ImageType::DataUri),
+            "inline_svg" => Ok(ImageType::InlineSvg),
+            "external" => Ok(ImageType::External),
+            "relative" => Ok(ImageType::Relative),
+            other => Err(magnus::Error::new(
+                unsafe { Ruby::get_unchecked() }.exception_arg_error(),
+                format!("invalid ImageType value: {other}"),
+            )),
+        }
+    }
+}
+
+unsafe impl IntoValueFromNative for ImageType {}
+unsafe impl TryConvertOwned for ImageType {}
+
+#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+pub enum StructuredDataType {
+    #[serde(rename = "json_ld")]
+    JsonLd,
+    Microdata,
+    #[serde(rename = "rdfa")]
+    RDFa,
+}
+
+impl Default for StructuredDataType {
+    fn default() -> Self {
+        Self::JsonLd
+    }
+}
+
+impl magnus::IntoValue for StructuredDataType {
+    fn into_value_with(self, handle: &Ruby) -> magnus::Value {
+        let sym = match self {
+            StructuredDataType::JsonLd => "json_ld",
+            StructuredDataType::Microdata => "microdata",
+            StructuredDataType::RDFa => "r_d_fa",
+        };
+        handle.to_symbol(sym).into_value_with(handle)
+    }
+}
+
+impl magnus::TryConvert for StructuredDataType {
+    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
+        let s: String = magnus::TryConvert::try_convert(val)?;
+        match s.as_str() {
+            "json_ld" => Ok(StructuredDataType::JsonLd),
+            "microdata" => Ok(StructuredDataType::Microdata),
+            "r_d_fa" => Ok(StructuredDataType::RDFa),
+            other => Err(magnus::Error::new(
+                unsafe { Ruby::get_unchecked() }.exception_arg_error(),
+                format!("invalid StructuredDataType value: {other}"),
+            )),
+        }
+    }
+}
+
+unsafe impl IntoValueFromNative for StructuredDataType {}
+unsafe impl TryConvertOwned for StructuredDataType {}
+
+#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+pub enum PreprocessingPreset {
+    Minimal,
+    Standard,
+    Aggressive,
+}
+
+impl Default for PreprocessingPreset {
+    fn default() -> Self {
+        Self::Minimal
+    }
+}
+
+impl magnus::IntoValue for PreprocessingPreset {
+    fn into_value_with(self, handle: &Ruby) -> magnus::Value {
+        let sym = match self {
+            PreprocessingPreset::Minimal => "minimal",
+            PreprocessingPreset::Standard => "standard",
+            PreprocessingPreset::Aggressive => "aggressive",
+        };
+        handle.to_symbol(sym).into_value_with(handle)
+    }
+}
+
+impl magnus::TryConvert for PreprocessingPreset {
+    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
+        let s: String = magnus::TryConvert::try_convert(val)?;
+        match s.as_str() {
+            "minimal" => Ok(PreprocessingPreset::Minimal),
+            "standard" => Ok(PreprocessingPreset::Standard),
+            "aggressive" => Ok(PreprocessingPreset::Aggressive),
+            other => Err(magnus::Error::new(
+                unsafe { Ruby::get_unchecked() }.exception_arg_error(),
+                format!("invalid PreprocessingPreset value: {other}"),
+            )),
+        }
+    }
+}
+
+unsafe impl IntoValueFromNative for PreprocessingPreset {}
+unsafe impl TryConvertOwned for PreprocessingPreset {}
+
+#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+pub enum HeadingStyle {
+    Underlined,
+    Atx,
+    AtxClosed,
+}
+
+impl Default for HeadingStyle {
+    fn default() -> Self {
+        Self::Underlined
+    }
+}
+
+impl magnus::IntoValue for HeadingStyle {
+    fn into_value_with(self, handle: &Ruby) -> magnus::Value {
+        let sym = match self {
+            HeadingStyle::Underlined => "underlined",
+            HeadingStyle::Atx => "atx",
+            HeadingStyle::AtxClosed => "atx_closed",
+        };
+        handle.to_symbol(sym).into_value_with(handle)
+    }
+}
+
+impl magnus::TryConvert for HeadingStyle {
+    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
+        let s: String = magnus::TryConvert::try_convert(val)?;
+        match s.as_str() {
+            "underlined" => Ok(HeadingStyle::Underlined),
+            "atx" => Ok(HeadingStyle::Atx),
+            "atx_closed" => Ok(HeadingStyle::AtxClosed),
+            other => Err(magnus::Error::new(
+                unsafe { Ruby::get_unchecked() }.exception_arg_error(),
+                format!("invalid HeadingStyle value: {other}"),
+            )),
+        }
+    }
+}
+
+unsafe impl IntoValueFromNative for HeadingStyle {}
+unsafe impl TryConvertOwned for HeadingStyle {}
+
+#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+pub enum ListIndentType {
+    Spaces,
+    Tabs,
+}
+
+impl Default for ListIndentType {
+    fn default() -> Self {
+        Self::Spaces
+    }
+}
+
+impl magnus::IntoValue for ListIndentType {
+    fn into_value_with(self, handle: &Ruby) -> magnus::Value {
+        let sym = match self {
+            ListIndentType::Spaces => "spaces",
+            ListIndentType::Tabs => "tabs",
+        };
+        handle.to_symbol(sym).into_value_with(handle)
+    }
+}
+
+impl magnus::TryConvert for ListIndentType {
+    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
+        let s: String = magnus::TryConvert::try_convert(val)?;
+        match s.as_str() {
+            "spaces" => Ok(ListIndentType::Spaces),
+            "tabs" => Ok(ListIndentType::Tabs),
+            other => Err(magnus::Error::new(
+                unsafe { Ruby::get_unchecked() }.exception_arg_error(),
+                format!("invalid ListIndentType value: {other}"),
+            )),
+        }
+    }
+}
+
+unsafe impl IntoValueFromNative for ListIndentType {}
+unsafe impl TryConvertOwned for ListIndentType {}
+
+#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+pub enum WhitespaceMode {
+    Normalized,
+    Strict,
+}
+
+impl Default for WhitespaceMode {
+    fn default() -> Self {
+        Self::Normalized
+    }
+}
+
+impl magnus::IntoValue for WhitespaceMode {
+    fn into_value_with(self, handle: &Ruby) -> magnus::Value {
+        let sym = match self {
+            WhitespaceMode::Normalized => "normalized",
+            WhitespaceMode::Strict => "strict",
+        };
+        handle.to_symbol(sym).into_value_with(handle)
+    }
+}
+
+impl magnus::TryConvert for WhitespaceMode {
+    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
+        let s: String = magnus::TryConvert::try_convert(val)?;
+        match s.as_str() {
+            "normalized" => Ok(WhitespaceMode::Normalized),
+            "strict" => Ok(WhitespaceMode::Strict),
+            other => Err(magnus::Error::new(
+                unsafe { Ruby::get_unchecked() }.exception_arg_error(),
+                format!("invalid WhitespaceMode value: {other}"),
+            )),
+        }
+    }
+}
+
+unsafe impl IntoValueFromNative for WhitespaceMode {}
+unsafe impl TryConvertOwned for WhitespaceMode {}
+
+#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+pub enum NewlineStyle {
+    Spaces,
+    Backslash,
+}
+
+impl Default for NewlineStyle {
+    fn default() -> Self {
+        Self::Spaces
+    }
+}
+
+impl magnus::IntoValue for NewlineStyle {
+    fn into_value_with(self, handle: &Ruby) -> magnus::Value {
+        let sym = match self {
+            NewlineStyle::Spaces => "spaces",
+            NewlineStyle::Backslash => "backslash",
+        };
+        handle.to_symbol(sym).into_value_with(handle)
+    }
+}
+
+impl magnus::TryConvert for NewlineStyle {
+    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
+        let s: String = magnus::TryConvert::try_convert(val)?;
+        match s.as_str() {
+            "spaces" => Ok(NewlineStyle::Spaces),
+            "backslash" => Ok(NewlineStyle::Backslash),
+            other => Err(magnus::Error::new(
+                unsafe { Ruby::get_unchecked() }.exception_arg_error(),
+                format!("invalid NewlineStyle value: {other}"),
+            )),
+        }
+    }
+}
+
+unsafe impl IntoValueFromNative for NewlineStyle {}
+unsafe impl TryConvertOwned for NewlineStyle {}
+
+#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+pub enum CodeBlockStyle {
+    Indented,
+    Backticks,
+    Tildes,
+}
+
+impl Default for CodeBlockStyle {
+    fn default() -> Self {
+        Self::Indented
+    }
+}
+
+impl magnus::IntoValue for CodeBlockStyle {
+    fn into_value_with(self, handle: &Ruby) -> magnus::Value {
+        let sym = match self {
+            CodeBlockStyle::Indented => "indented",
+            CodeBlockStyle::Backticks => "backticks",
+            CodeBlockStyle::Tildes => "tildes",
+        };
+        handle.to_symbol(sym).into_value_with(handle)
+    }
+}
+
+impl magnus::TryConvert for CodeBlockStyle {
+    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
+        let s: String = magnus::TryConvert::try_convert(val)?;
+        match s.as_str() {
+            "indented" => Ok(CodeBlockStyle::Indented),
+            "backticks" => Ok(CodeBlockStyle::Backticks),
+            "tildes" => Ok(CodeBlockStyle::Tildes),
+            other => Err(magnus::Error::new(
+                unsafe { Ruby::get_unchecked() }.exception_arg_error(),
+                format!("invalid CodeBlockStyle value: {other}"),
+            )),
+        }
+    }
+}
+
+unsafe impl IntoValueFromNative for CodeBlockStyle {}
+unsafe impl TryConvertOwned for CodeBlockStyle {}
+
+#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+pub enum HighlightStyle {
+    DoubleEqual,
+    Html,
+    Bold,
+    None,
+}
+
+impl Default for HighlightStyle {
+    fn default() -> Self {
+        Self::DoubleEqual
+    }
+}
+
+impl magnus::IntoValue for HighlightStyle {
+    fn into_value_with(self, handle: &Ruby) -> magnus::Value {
+        let sym = match self {
+            HighlightStyle::DoubleEqual => "double_equal",
+            HighlightStyle::Html => "html",
+            HighlightStyle::Bold => "bold",
+            HighlightStyle::None => "none",
+        };
+        handle.to_symbol(sym).into_value_with(handle)
+    }
+}
+
+impl magnus::TryConvert for HighlightStyle {
+    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
+        let s: String = magnus::TryConvert::try_convert(val)?;
+        match s.as_str() {
+            "double_equal" => Ok(HighlightStyle::DoubleEqual),
+            "html" => Ok(HighlightStyle::Html),
+            "bold" => Ok(HighlightStyle::Bold),
+            "none" => Ok(HighlightStyle::None),
+            other => Err(magnus::Error::new(
+                unsafe { Ruby::get_unchecked() }.exception_arg_error(),
+                format!("invalid HighlightStyle value: {other}"),
+            )),
+        }
+    }
+}
+
+unsafe impl IntoValueFromNative for HighlightStyle {}
+unsafe impl TryConvertOwned for HighlightStyle {}
+
+#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+pub enum LinkStyle {
+    Inline,
+    Reference,
+}
+
+impl Default for LinkStyle {
+    fn default() -> Self {
+        Self::Inline
+    }
+}
+
+impl magnus::IntoValue for LinkStyle {
+    fn into_value_with(self, handle: &Ruby) -> magnus::Value {
+        let sym = match self {
+            LinkStyle::Inline => "inline",
+            LinkStyle::Reference => "reference",
+        };
+        handle.to_symbol(sym).into_value_with(handle)
+    }
+}
+
+impl magnus::TryConvert for LinkStyle {
+    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
+        let s: String = magnus::TryConvert::try_convert(val)?;
+        match s.as_str() {
+            "inline" => Ok(LinkStyle::Inline),
+            "reference" => Ok(LinkStyle::Reference),
+            other => Err(magnus::Error::new(
+                unsafe { Ruby::get_unchecked() }.exception_arg_error(),
+                format!("invalid LinkStyle value: {other}"),
+            )),
+        }
+    }
+}
+
+unsafe impl IntoValueFromNative for LinkStyle {}
+unsafe impl TryConvertOwned for LinkStyle {}
+
+#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+pub enum OutputFormat {
+    Markdown,
+    Djot,
+    Plain,
+}
+
+impl Default for OutputFormat {
+    fn default() -> Self {
+        Self::Markdown
+    }
+}
+
+impl magnus::IntoValue for OutputFormat {
+    fn into_value_with(self, handle: &Ruby) -> magnus::Value {
+        let sym = match self {
+            OutputFormat::Markdown => "markdown",
+            OutputFormat::Djot => "djot",
+            OutputFormat::Plain => "plain",
+        };
+        handle.to_symbol(sym).into_value_with(handle)
+    }
+}
+
+impl magnus::TryConvert for OutputFormat {
+    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
+        let s: String = magnus::TryConvert::try_convert(val)?;
+        match s.as_str() {
+            "markdown" => Ok(OutputFormat::Markdown),
+            "djot" => Ok(OutputFormat::Djot),
+            "plain" => Ok(OutputFormat::Plain),
+            other => Err(magnus::Error::new(
+                unsafe { Ruby::get_unchecked() }.exception_arg_error(),
+                format!("invalid OutputFormat value: {other}"),
+            )),
+        }
+    }
+}
+
+unsafe impl IntoValueFromNative for OutputFormat {}
+unsafe impl TryConvertOwned for OutputFormat {}
+
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
+#[serde(tag = "node_type")]
+pub enum NodeContent {
+    Heading {
+        level: u8,
+        text: String,
+    },
+    Paragraph {
+        text: String,
+    },
+    List {
+        ordered: bool,
+    },
+    ListItem {
+        text: String,
+    },
+    Table {
+        grid: TableGrid,
+    },
+    Image {
+        description: Option<String>,
+        src: Option<String>,
+        image_index: Option<u32>,
+    },
+    Code {
+        text: String,
+        language: Option<String>,
+    },
+    Quote,
+    DefinitionList,
+    DefinitionItem {
+        term: String,
+        definition: String,
+    },
+    RawBlock {
+        format: String,
+        content: String,
+    },
+    MetadataBlock {
+        entries: String,
+    },
+    Group {
+        label: Option<String>,
+        heading_level: Option<u8>,
+        heading_text: Option<String>,
+    },
+}
+
+impl Default for NodeContent {
+    fn default() -> Self {
+        Self::Heading {
+            level: Default::default(),
+            text: Default::default(),
+        }
+    }
+}
+
+impl magnus::IntoValue for NodeContent {
+    fn into_value_with(self, handle: &Ruby) -> magnus::Value {
+        match serde_json::to_value(&self) {
+            Ok(v) => json_to_ruby(handle, v),
+            Err(_) => handle.qnil().into_value_with(handle),
+        }
+    }
+}
+
+impl magnus::TryConvert for NodeContent {
+    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
+        let s: String = magnus::TryConvert::try_convert(val)?;
+        serde_json::from_str(&s).map_err(|e| magnus::Error::new(magnus::exception::type_error(), e.to_string()))
+    }
+}
+
+unsafe impl IntoValueFromNative for NodeContent {}
+unsafe impl TryConvertOwned for NodeContent {}
+
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
+#[serde(tag = "annotation_type")]
+pub enum AnnotationKind {
+    Bold,
+    Italic,
+    Underline,
+    Strikethrough,
+    Code,
+    Subscript,
+    Superscript,
+    Highlight,
+    Link { url: String, title: Option<String> },
+}
+
+impl Default for AnnotationKind {
+    fn default() -> Self {
+        Self::Bold
+    }
+}
+
+impl magnus::IntoValue for AnnotationKind {
+    fn into_value_with(self, handle: &Ruby) -> magnus::Value {
+        match serde_json::to_value(&self) {
+            Ok(v) => json_to_ruby(handle, v),
+            Err(_) => handle.qnil().into_value_with(handle),
+        }
+    }
+}
+
+impl magnus::TryConvert for AnnotationKind {
+    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
+        let s: String = magnus::TryConvert::try_convert(val)?;
+        serde_json::from_str(&s).map_err(|e| magnus::Error::new(magnus::exception::type_error(), e.to_string()))
+    }
+}
+
+unsafe impl IntoValueFromNative for AnnotationKind {}
+unsafe impl TryConvertOwned for AnnotationKind {}
+
+#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+pub enum WarningKind {
+    ImageExtractionFailed,
+    EncodingFallback,
+    TruncatedInput,
+    MalformedHtml,
+    SanitizationApplied,
+}
+
+impl Default for WarningKind {
+    fn default() -> Self {
+        Self::ImageExtractionFailed
+    }
+}
+
+impl magnus::IntoValue for WarningKind {
+    fn into_value_with(self, handle: &Ruby) -> magnus::Value {
+        let sym = match self {
+            WarningKind::ImageExtractionFailed => "image_extraction_failed",
+            WarningKind::EncodingFallback => "encoding_fallback",
+            WarningKind::TruncatedInput => "truncated_input",
+            WarningKind::MalformedHtml => "malformed_html",
+            WarningKind::SanitizationApplied => "sanitization_applied",
+        };
+        handle.to_symbol(sym).into_value_with(handle)
+    }
+}
+
+impl magnus::TryConvert for WarningKind {
+    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
+        let s: String = magnus::TryConvert::try_convert(val)?;
+        match s.as_str() {
+            "image_extraction_failed" => Ok(WarningKind::ImageExtractionFailed),
+            "encoding_fallback" => Ok(WarningKind::EncodingFallback),
+            "truncated_input" => Ok(WarningKind::TruncatedInput),
+            "malformed_html" => Ok(WarningKind::MalformedHtml),
+            "sanitization_applied" => Ok(WarningKind::SanitizationApplied),
+            other => Err(magnus::Error::new(
+                unsafe { Ruby::get_unchecked() }.exception_arg_error(),
+                format!("invalid WarningKind value: {other}"),
+            )),
+        }
+    }
+}
+
+unsafe impl IntoValueFromNative for WarningKind {}
+unsafe impl TryConvertOwned for WarningKind {}
+
+fn convert(html: String, options: Option<String>) -> Result<ConversionResult, Error> {
+    let options: Option<ConversionOptions> = options
+        .as_deref()
+        .filter(|s| *s != "nil")
+        .map(|s| {
+            let core: html_to_markdown_rs::ConversionOptions = serde_json::from_str(s)
+                .map_err(|e| magnus::Error::new(magnus::exception::type_error(), e.to_string()))?;
+            Ok::<_, magnus::Error>(core.into())
+        })
+        .transpose()?;
+    let result = html_to_markdown_rs::convert(&html, options.map(Into::into))
+        .map_err(|e| magnus::Error::new(magnus::exception::runtime_error(), e.to_string()))?;
+    Ok(result.into())
+}
+
+impl From<MetadataConfig> for html_to_markdown_rs::metadata::MetadataConfig {
+    fn from(val: MetadataConfig) -> Self {
+        Self {
+            extract_document: val.extract_document,
+            extract_headers: val.extract_headers,
+            extract_links: val.extract_links,
+            extract_images: val.extract_images,
+            extract_structured_data: val.extract_structured_data,
+            max_structured_data_size: val.max_structured_data_size,
+        }
+    }
+}
+
+impl From<html_to_markdown_rs::metadata::MetadataConfig> for MetadataConfig {
+    fn from(val: html_to_markdown_rs::metadata::MetadataConfig) -> Self {
+        Self {
+            extract_document: val.extract_document,
+            extract_headers: val.extract_headers,
+            extract_links: val.extract_links,
+            extract_images: val.extract_images,
+            extract_structured_data: val.extract_structured_data,
+            max_structured_data_size: val.max_structured_data_size,
+        }
+    }
+}
+
+impl From<html_to_markdown_rs::metadata::MetadataConfigUpdate> for MetadataConfigUpdate {
+    fn from(val: html_to_markdown_rs::metadata::MetadataConfigUpdate) -> Self {
+        Self {
+            extract_document: val.extract_document,
+            extract_headers: val.extract_headers,
+            extract_links: val.extract_links,
+            extract_images: val.extract_images,
+            extract_structured_data: val.extract_structured_data,
+            max_structured_data_size: val.max_structured_data_size,
+        }
+    }
+}
+
+impl From<DocumentMetadata> for html_to_markdown_rs::metadata::DocumentMetadata {
+    fn from(val: DocumentMetadata) -> Self {
+        Self {
+            title: val.title,
+            description: val.description,
+            keywords: val.keywords,
+            author: val.author,
+            canonical_url: val.canonical_url,
+            base_href: val.base_href,
+            language: val.language,
+            text_direction: val.text_direction.map(Into::into),
+            open_graph: val.open_graph.into_iter().collect(),
+            twitter_card: val.twitter_card.into_iter().collect(),
+            meta_tags: val.meta_tags.into_iter().collect(),
+        }
+    }
+}
+
+impl From<html_to_markdown_rs::metadata::DocumentMetadata> for DocumentMetadata {
+    fn from(val: html_to_markdown_rs::metadata::DocumentMetadata) -> Self {
+        Self {
+            title: val.title,
+            description: val.description,
+            keywords: val.keywords,
+            author: val.author,
+            canonical_url: val.canonical_url,
+            base_href: val.base_href,
+            language: val.language,
+            text_direction: val.text_direction.map(Into::into),
+            open_graph: val.open_graph.into_iter().collect(),
+            twitter_card: val.twitter_card.into_iter().collect(),
+            meta_tags: val.meta_tags.into_iter().collect(),
+        }
+    }
+}
+
+impl From<HeaderMetadata> for html_to_markdown_rs::metadata::HeaderMetadata {
+    fn from(val: HeaderMetadata) -> Self {
+        Self {
+            level: val.level,
+            text: val.text,
+            id: val.id,
+            depth: val.depth,
+            html_offset: val.html_offset,
+        }
+    }
+}
+
+impl From<html_to_markdown_rs::metadata::HeaderMetadata> for HeaderMetadata {
+    fn from(val: html_to_markdown_rs::metadata::HeaderMetadata) -> Self {
+        Self {
+            level: val.level,
+            text: val.text,
+            id: val.id,
+            depth: val.depth,
+            html_offset: val.html_offset,
+        }
+    }
+}
+
+impl From<LinkMetadata> for html_to_markdown_rs::metadata::LinkMetadata {
+    fn from(val: LinkMetadata) -> Self {
+        Self {
+            href: val.href,
+            text: val.text,
+            title: val.title,
+            link_type: val.link_type.into(),
+            rel: val.rel,
+            attributes: val.attributes.into_iter().collect(),
+        }
+    }
+}
+
+impl From<html_to_markdown_rs::metadata::LinkMetadata> for LinkMetadata {
+    fn from(val: html_to_markdown_rs::metadata::LinkMetadata) -> Self {
+        Self {
+            href: val.href,
+            text: val.text,
+            title: val.title,
+            link_type: val.link_type.into(),
+            rel: val.rel,
+            attributes: val.attributes.into_iter().collect(),
+        }
+    }
+}
+
+impl From<ImageMetadata> for html_to_markdown_rs::metadata::ImageMetadata {
+    fn from(val: ImageMetadata) -> Self {
+        Self {
+            src: val.src,
+            alt: val.alt,
+            title: val.title,
+            dimensions: Default::default(),
+            image_type: val.image_type.into(),
+            attributes: val.attributes.into_iter().collect(),
+        }
+    }
+}
+
+impl From<html_to_markdown_rs::metadata::ImageMetadata> for ImageMetadata {
+    fn from(val: html_to_markdown_rs::metadata::ImageMetadata) -> Self {
+        Self {
+            src: val.src,
+            alt: val.alt,
+            title: val.title,
+            dimensions: val.dimensions.as_ref().map(|v| format!("{:?}", v)),
+            image_type: val.image_type.into(),
+            attributes: val.attributes.into_iter().collect(),
+        }
+    }
+}
+
+impl From<StructuredData> for html_to_markdown_rs::metadata::StructuredData {
+    fn from(val: StructuredData) -> Self {
+        Self {
+            data_type: val.data_type.into(),
+            raw_json: val.raw_json,
+            schema_type: val.schema_type,
+        }
+    }
+}
+
+impl From<html_to_markdown_rs::metadata::StructuredData> for StructuredData {
+    fn from(val: html_to_markdown_rs::metadata::StructuredData) -> Self {
+        Self {
+            data_type: val.data_type.into(),
+            raw_json: val.raw_json,
+            schema_type: val.schema_type,
+        }
+    }
+}
+
+impl From<HtmlMetadata> for html_to_markdown_rs::metadata::HtmlMetadata {
+    fn from(val: HtmlMetadata) -> Self {
+        Self {
+            document: val.document.into(),
+            headers: val.headers.into_iter().map(Into::into).collect(),
+            links: val.links.into_iter().map(Into::into).collect(),
+            images: val.images.into_iter().map(Into::into).collect(),
+            structured_data: val.structured_data.into_iter().map(Into::into).collect(),
+        }
+    }
+}
+
+impl From<html_to_markdown_rs::metadata::HtmlMetadata> for HtmlMetadata {
+    fn from(val: html_to_markdown_rs::metadata::HtmlMetadata) -> Self {
+        Self {
+            document: val.document.into(),
+            headers: val.headers.into_iter().map(Into::into).collect(),
+            links: val.links.into_iter().map(Into::into).collect(),
+            images: val.images.into_iter().map(Into::into).collect(),
+            structured_data: val.structured_data.into_iter().map(Into::into).collect(),
+        }
+    }
+}
+
+impl From<ConversionOptions> for html_to_markdown_rs::options::ConversionOptions {
+    fn from(val: ConversionOptions) -> Self {
+        Self {
+            heading_style: val.heading_style.into(),
+            list_indent_type: val.list_indent_type.into(),
+            list_indent_width: val.list_indent_width,
+            bullets: val.bullets,
+            strong_em_symbol: val.strong_em_symbol.chars().next().unwrap_or('*'),
+            escape_asterisks: val.escape_asterisks,
+            escape_underscores: val.escape_underscores,
+            escape_misc: val.escape_misc,
+            escape_ascii: val.escape_ascii,
+            code_language: val.code_language,
+            autolinks: val.autolinks,
+            default_title: val.default_title,
+            br_in_tables: val.br_in_tables,
+            highlight_style: val.highlight_style.into(),
+            extract_metadata: val.extract_metadata,
+            whitespace_mode: val.whitespace_mode.into(),
+            strip_newlines: val.strip_newlines,
+            wrap: val.wrap,
+            wrap_width: val.wrap_width,
+            convert_as_inline: val.convert_as_inline,
+            sub_symbol: val.sub_symbol,
+            sup_symbol: val.sup_symbol,
+            newline_style: val.newline_style.into(),
+            code_block_style: val.code_block_style.into(),
+            keep_inline_images_in: val.keep_inline_images_in,
+            preprocessing: val.preprocessing.into(),
+            encoding: val.encoding,
+            debug: val.debug,
+            strip_tags: val.strip_tags,
+            preserve_tags: val.preserve_tags,
+            skip_images: val.skip_images,
+            link_style: val.link_style.into(),
+            output_format: val.output_format.into(),
+            include_document_structure: val.include_document_structure,
+            extract_images: val.extract_images,
+            max_image_size: val.max_image_size,
+            capture_svg: val.capture_svg,
+            infer_dimensions: val.infer_dimensions,
+        }
+    }
+}
+
+impl From<html_to_markdown_rs::options::ConversionOptions> for ConversionOptions {
+    fn from(val: html_to_markdown_rs::options::ConversionOptions) -> Self {
+        Self {
+            heading_style: val.heading_style.into(),
+            list_indent_type: val.list_indent_type.into(),
+            list_indent_width: val.list_indent_width,
+            bullets: val.bullets,
+            strong_em_symbol: val.strong_em_symbol.to_string(),
+            escape_asterisks: val.escape_asterisks,
+            escape_underscores: val.escape_underscores,
+            escape_misc: val.escape_misc,
+            escape_ascii: val.escape_ascii,
+            code_language: val.code_language,
+            autolinks: val.autolinks,
+            default_title: val.default_title,
+            br_in_tables: val.br_in_tables,
+            highlight_style: val.highlight_style.into(),
+            extract_metadata: val.extract_metadata,
+            whitespace_mode: val.whitespace_mode.into(),
+            strip_newlines: val.strip_newlines,
+            wrap: val.wrap,
+            wrap_width: val.wrap_width,
+            convert_as_inline: val.convert_as_inline,
+            sub_symbol: val.sub_symbol,
+            sup_symbol: val.sup_symbol,
+            newline_style: val.newline_style.into(),
+            code_block_style: val.code_block_style.into(),
+            keep_inline_images_in: val.keep_inline_images_in,
+            preprocessing: val.preprocessing.into(),
+            encoding: val.encoding,
+            debug: val.debug,
+            strip_tags: val.strip_tags,
+            preserve_tags: val.preserve_tags,
+            skip_images: val.skip_images,
+            link_style: val.link_style.into(),
+            output_format: val.output_format.into(),
+            include_document_structure: val.include_document_structure,
+            extract_images: val.extract_images,
+            max_image_size: val.max_image_size,
+            capture_svg: val.capture_svg,
+            infer_dimensions: val.infer_dimensions,
+        }
+    }
+}
+
+impl From<html_to_markdown_rs::options::ConversionOptionsUpdate> for ConversionOptionsUpdate {
+    fn from(val: html_to_markdown_rs::options::ConversionOptionsUpdate) -> Self {
+        Self {
+            heading_style: val.heading_style.map(Into::into),
+            list_indent_type: val.list_indent_type.map(Into::into),
+            list_indent_width: val.list_indent_width,
+            bullets: val.bullets,
+            strong_em_symbol: val.strong_em_symbol.map(|c| c.to_string()),
+            escape_asterisks: val.escape_asterisks,
+            escape_underscores: val.escape_underscores,
+            escape_misc: val.escape_misc,
+            escape_ascii: val.escape_ascii,
+            code_language: val.code_language,
+            autolinks: val.autolinks,
+            default_title: val.default_title,
+            br_in_tables: val.br_in_tables,
+            highlight_style: val.highlight_style.map(Into::into),
+            extract_metadata: val.extract_metadata,
+            whitespace_mode: val.whitespace_mode.map(Into::into),
+            strip_newlines: val.strip_newlines,
+            wrap: val.wrap,
+            wrap_width: val.wrap_width,
+            convert_as_inline: val.convert_as_inline,
+            sub_symbol: val.sub_symbol,
+            sup_symbol: val.sup_symbol,
+            newline_style: val.newline_style.map(Into::into),
+            code_block_style: val.code_block_style.map(Into::into),
+            keep_inline_images_in: val.keep_inline_images_in,
+            preprocessing: val.preprocessing.map(Into::into),
+            encoding: val.encoding,
+            debug: val.debug,
+            strip_tags: val.strip_tags,
+            preserve_tags: val.preserve_tags,
+            skip_images: val.skip_images,
+            link_style: val.link_style.map(Into::into),
+            output_format: val.output_format.map(Into::into),
+            include_document_structure: val.include_document_structure,
+            extract_images: val.extract_images,
+            max_image_size: val.max_image_size,
+            capture_svg: val.capture_svg,
+            infer_dimensions: val.infer_dimensions,
+        }
+    }
+}
+
+impl From<PreprocessingOptions> for html_to_markdown_rs::options::PreprocessingOptions {
+    fn from(val: PreprocessingOptions) -> Self {
+        Self {
+            enabled: val.enabled,
+            preset: val.preset.into(),
+            remove_navigation: val.remove_navigation,
+            remove_forms: val.remove_forms,
+        }
+    }
+}
+
+impl From<html_to_markdown_rs::options::PreprocessingOptions> for PreprocessingOptions {
+    fn from(val: html_to_markdown_rs::options::PreprocessingOptions) -> Self {
+        Self {
+            enabled: val.enabled,
+            preset: val.preset.into(),
+            remove_navigation: val.remove_navigation,
+            remove_forms: val.remove_forms,
+        }
+    }
+}
+
+impl From<html_to_markdown_rs::options::PreprocessingOptionsUpdate> for PreprocessingOptionsUpdate {
+    fn from(val: html_to_markdown_rs::options::PreprocessingOptionsUpdate) -> Self {
+        Self {
+            enabled: val.enabled,
+            preset: val.preset.map(Into::into),
+            remove_navigation: val.remove_navigation,
+            remove_forms: val.remove_forms,
+        }
+    }
+}
+
+impl From<DocumentStructure> for html_to_markdown_rs::DocumentStructure {
+    fn from(val: DocumentStructure) -> Self {
+        Self {
+            nodes: val.nodes.into_iter().map(Into::into).collect(),
+            source_format: val.source_format,
+        }
+    }
+}
+
+impl From<html_to_markdown_rs::DocumentStructure> for DocumentStructure {
+    fn from(val: html_to_markdown_rs::DocumentStructure) -> Self {
+        Self {
+            nodes: val.nodes.into_iter().map(Into::into).collect(),
+            source_format: val.source_format,
+        }
+    }
+}
+
+impl From<DocumentNode> for html_to_markdown_rs::DocumentNode {
+    fn from(val: DocumentNode) -> Self {
+        Self {
+            id: val.id,
+            content: val.content.into(),
+            parent: val.parent,
+            children: val.children,
+            annotations: val.annotations.into_iter().map(Into::into).collect(),
+            attributes: val.attributes.map(|m| m.into_iter().collect()),
+        }
+    }
+}
+
+impl From<html_to_markdown_rs::DocumentNode> for DocumentNode {
+    fn from(val: html_to_markdown_rs::DocumentNode) -> Self {
+        Self {
+            id: val.id,
+            content: val.content.into(),
+            parent: val.parent,
+            children: val.children,
+            annotations: val.annotations.into_iter().map(Into::into).collect(),
+            attributes: val.attributes.map(|m| m.into_iter().collect()),
+        }
+    }
+}
+
+impl From<TextAnnotation> for html_to_markdown_rs::TextAnnotation {
+    fn from(val: TextAnnotation) -> Self {
+        Self {
+            start: val.start,
+            end: val.end,
+            kind: val.kind.into(),
+        }
+    }
+}
+
+impl From<html_to_markdown_rs::TextAnnotation> for TextAnnotation {
+    fn from(val: html_to_markdown_rs::TextAnnotation) -> Self {
+        Self {
+            start: val.start,
+            end: val.end,
+            kind: val.kind.into(),
+        }
+    }
+}
+
+#[allow(clippy::needless_update)]
+impl From<ConversionResult> for html_to_markdown_rs::ConversionResult {
+    fn from(val: ConversionResult) -> Self {
+        Self {
+            content: val.content,
+            document: val.document.map(Into::into),
+            metadata: val.metadata.into(),
+            tables: val.tables.into_iter().map(Into::into).collect(),
+            images: Default::default(),
+            warnings: val.warnings.into_iter().map(Into::into).collect(),
+            ..Default::default()
+        }
+    }
+}
+
+impl From<html_to_markdown_rs::ConversionResult> for ConversionResult {
+    fn from(val: html_to_markdown_rs::ConversionResult) -> Self {
+        Self {
+            content: val.content,
+            document: val.document.map(Into::into),
+            metadata: val.metadata.into(),
+            tables: val.tables.into_iter().map(Into::into).collect(),
+            images: val.images.iter().map(|i| format!("{:?}", i)).collect(),
+            warnings: val.warnings.into_iter().map(Into::into).collect(),
+        }
+    }
+}
+
+impl From<TableGrid> for html_to_markdown_rs::TableGrid {
+    fn from(val: TableGrid) -> Self {
+        Self {
+            rows: val.rows,
+            cols: val.cols,
+            cells: val.cells.into_iter().map(Into::into).collect(),
+        }
+    }
+}
+
+impl From<html_to_markdown_rs::TableGrid> for TableGrid {
+    fn from(val: html_to_markdown_rs::TableGrid) -> Self {
+        Self {
+            rows: val.rows,
+            cols: val.cols,
+            cells: val.cells.into_iter().map(Into::into).collect(),
+        }
+    }
+}
+
+impl From<GridCell> for html_to_markdown_rs::GridCell {
+    fn from(val: GridCell) -> Self {
+        Self {
+            content: val.content,
+            row: val.row,
+            col: val.col,
+            row_span: val.row_span,
+            col_span: val.col_span,
+            is_header: val.is_header,
+        }
+    }
+}
+
+impl From<html_to_markdown_rs::GridCell> for GridCell {
+    fn from(val: html_to_markdown_rs::GridCell) -> Self {
+        Self {
+            content: val.content,
+            row: val.row,
+            col: val.col,
+            row_span: val.row_span,
+            col_span: val.col_span,
+            is_header: val.is_header,
+        }
+    }
+}
+
+impl From<TableData> for html_to_markdown_rs::TableData {
+    fn from(val: TableData) -> Self {
+        Self {
+            grid: val.grid.into(),
+            markdown: val.markdown,
+        }
+    }
+}
+
+impl From<html_to_markdown_rs::TableData> for TableData {
+    fn from(val: html_to_markdown_rs::TableData) -> Self {
+        Self {
+            grid: val.grid.into(),
+            markdown: val.markdown,
+        }
+    }
+}
+
+impl From<ProcessingWarning> for html_to_markdown_rs::ProcessingWarning {
+    fn from(val: ProcessingWarning) -> Self {
+        Self {
+            message: val.message,
+            kind: val.kind.into(),
+        }
+    }
+}
+
+impl From<html_to_markdown_rs::ProcessingWarning> for ProcessingWarning {
+    fn from(val: html_to_markdown_rs::ProcessingWarning) -> Self {
+        Self {
+            message: val.message,
+            kind: val.kind.into(),
+        }
+    }
+}
+
+impl From<TextDirection> for html_to_markdown_rs::metadata::TextDirection {
+    fn from(val: TextDirection) -> Self {
+        match val {
+            TextDirection::LeftToRight => Self::LeftToRight,
+            TextDirection::RightToLeft => Self::RightToLeft,
+            TextDirection::Auto => Self::Auto,
+        }
+    }
+}
+
+impl From<html_to_markdown_rs::metadata::TextDirection> for TextDirection {
+    fn from(val: html_to_markdown_rs::metadata::TextDirection) -> Self {
+        match val {
+            html_to_markdown_rs::metadata::TextDirection::LeftToRight => Self::LeftToRight,
+            html_to_markdown_rs::metadata::TextDirection::RightToLeft => Self::RightToLeft,
+            html_to_markdown_rs::metadata::TextDirection::Auto => Self::Auto,
+        }
+    }
+}
+
+impl From<LinkType> for html_to_markdown_rs::metadata::LinkType {
+    fn from(val: LinkType) -> Self {
+        match val {
+            LinkType::Anchor => Self::Anchor,
+            LinkType::Internal => Self::Internal,
+            LinkType::External => Self::External,
+            LinkType::Email => Self::Email,
+            LinkType::Phone => Self::Phone,
+            LinkType::Other => Self::Other,
+        }
+    }
+}
+
+impl From<html_to_markdown_rs::metadata::LinkType> for LinkType {
+    fn from(val: html_to_markdown_rs::metadata::LinkType) -> Self {
+        match val {
+            html_to_markdown_rs::metadata::LinkType::Anchor => Self::Anchor,
+            html_to_markdown_rs::metadata::LinkType::Internal => Self::Internal,
+            html_to_markdown_rs::metadata::LinkType::External => Self::External,
+            html_to_markdown_rs::metadata::LinkType::Email => Self::Email,
+            html_to_markdown_rs::metadata::LinkType::Phone => Self::Phone,
+            html_to_markdown_rs::metadata::LinkType::Other => Self::Other,
+        }
+    }
+}
+
+impl From<ImageType> for html_to_markdown_rs::metadata::ImageType {
+    fn from(val: ImageType) -> Self {
+        match val {
+            ImageType::DataUri => Self::DataUri,
+            ImageType::InlineSvg => Self::InlineSvg,
+            ImageType::External => Self::External,
+            ImageType::Relative => Self::Relative,
+        }
+    }
+}
+
+impl From<html_to_markdown_rs::metadata::ImageType> for ImageType {
+    fn from(val: html_to_markdown_rs::metadata::ImageType) -> Self {
+        match val {
+            html_to_markdown_rs::metadata::ImageType::DataUri => Self::DataUri,
+            html_to_markdown_rs::metadata::ImageType::InlineSvg => Self::InlineSvg,
+            html_to_markdown_rs::metadata::ImageType::External => Self::External,
+            html_to_markdown_rs::metadata::ImageType::Relative => Self::Relative,
+        }
+    }
+}
+
+impl From<StructuredDataType> for html_to_markdown_rs::metadata::StructuredDataType {
+    fn from(val: StructuredDataType) -> Self {
+        match val {
+            StructuredDataType::JsonLd => Self::JsonLd,
+            StructuredDataType::Microdata => Self::Microdata,
+            StructuredDataType::RDFa => Self::RDFa,
+        }
+    }
+}
+
+impl From<html_to_markdown_rs::metadata::StructuredDataType> for StructuredDataType {
+    fn from(val: html_to_markdown_rs::metadata::StructuredDataType) -> Self {
+        match val {
+            html_to_markdown_rs::metadata::StructuredDataType::JsonLd => Self::JsonLd,
+            html_to_markdown_rs::metadata::StructuredDataType::Microdata => Self::Microdata,
+            html_to_markdown_rs::metadata::StructuredDataType::RDFa => Self::RDFa,
+        }
+    }
+}
+
+impl From<PreprocessingPreset> for html_to_markdown_rs::options::PreprocessingPreset {
+    fn from(val: PreprocessingPreset) -> Self {
+        match val {
+            PreprocessingPreset::Minimal => Self::Minimal,
+            PreprocessingPreset::Standard => Self::Standard,
+            PreprocessingPreset::Aggressive => Self::Aggressive,
+        }
+    }
+}
+
+impl From<html_to_markdown_rs::options::PreprocessingPreset> for PreprocessingPreset {
+    fn from(val: html_to_markdown_rs::options::PreprocessingPreset) -> Self {
+        match val {
+            html_to_markdown_rs::options::PreprocessingPreset::Minimal => Self::Minimal,
+            html_to_markdown_rs::options::PreprocessingPreset::Standard => Self::Standard,
+            html_to_markdown_rs::options::PreprocessingPreset::Aggressive => Self::Aggressive,
+        }
+    }
+}
+
+impl From<HeadingStyle> for html_to_markdown_rs::options::HeadingStyle {
+    fn from(val: HeadingStyle) -> Self {
+        match val {
+            HeadingStyle::Underlined => Self::Underlined,
+            HeadingStyle::Atx => Self::Atx,
+            HeadingStyle::AtxClosed => Self::AtxClosed,
+        }
+    }
+}
+
+impl From<html_to_markdown_rs::options::HeadingStyle> for HeadingStyle {
+    fn from(val: html_to_markdown_rs::options::HeadingStyle) -> Self {
+        match val {
+            html_to_markdown_rs::options::HeadingStyle::Underlined => Self::Underlined,
+            html_to_markdown_rs::options::HeadingStyle::Atx => Self::Atx,
+            html_to_markdown_rs::options::HeadingStyle::AtxClosed => Self::AtxClosed,
+        }
+    }
+}
+
+impl From<ListIndentType> for html_to_markdown_rs::options::ListIndentType {
+    fn from(val: ListIndentType) -> Self {
+        match val {
+            ListIndentType::Spaces => Self::Spaces,
+            ListIndentType::Tabs => Self::Tabs,
+        }
+    }
+}
+
+impl From<html_to_markdown_rs::options::ListIndentType> for ListIndentType {
+    fn from(val: html_to_markdown_rs::options::ListIndentType) -> Self {
+        match val {
+            html_to_markdown_rs::options::ListIndentType::Spaces => Self::Spaces,
+            html_to_markdown_rs::options::ListIndentType::Tabs => Self::Tabs,
+        }
+    }
+}
+
+impl From<WhitespaceMode> for html_to_markdown_rs::options::WhitespaceMode {
+    fn from(val: WhitespaceMode) -> Self {
+        match val {
+            WhitespaceMode::Normalized => Self::Normalized,
+            WhitespaceMode::Strict => Self::Strict,
+        }
+    }
+}
+
+impl From<html_to_markdown_rs::options::WhitespaceMode> for WhitespaceMode {
+    fn from(val: html_to_markdown_rs::options::WhitespaceMode) -> Self {
+        match val {
+            html_to_markdown_rs::options::WhitespaceMode::Normalized => Self::Normalized,
+            html_to_markdown_rs::options::WhitespaceMode::Strict => Self::Strict,
+        }
+    }
+}
+
+impl From<NewlineStyle> for html_to_markdown_rs::options::NewlineStyle {
+    fn from(val: NewlineStyle) -> Self {
+        match val {
+            NewlineStyle::Spaces => Self::Spaces,
+            NewlineStyle::Backslash => Self::Backslash,
+        }
+    }
+}
+
+impl From<html_to_markdown_rs::options::NewlineStyle> for NewlineStyle {
+    fn from(val: html_to_markdown_rs::options::NewlineStyle) -> Self {
+        match val {
+            html_to_markdown_rs::options::NewlineStyle::Spaces => Self::Spaces,
+            html_to_markdown_rs::options::NewlineStyle::Backslash => Self::Backslash,
+        }
+    }
+}
+
+impl From<CodeBlockStyle> for html_to_markdown_rs::options::CodeBlockStyle {
+    fn from(val: CodeBlockStyle) -> Self {
+        match val {
+            CodeBlockStyle::Indented => Self::Indented,
+            CodeBlockStyle::Backticks => Self::Backticks,
+            CodeBlockStyle::Tildes => Self::Tildes,
+        }
+    }
+}
+
+impl From<html_to_markdown_rs::options::CodeBlockStyle> for CodeBlockStyle {
+    fn from(val: html_to_markdown_rs::options::CodeBlockStyle) -> Self {
+        match val {
+            html_to_markdown_rs::options::CodeBlockStyle::Indented => Self::Indented,
+            html_to_markdown_rs::options::CodeBlockStyle::Backticks => Self::Backticks,
+            html_to_markdown_rs::options::CodeBlockStyle::Tildes => Self::Tildes,
+        }
+    }
+}
+
+impl From<HighlightStyle> for html_to_markdown_rs::options::HighlightStyle {
+    fn from(val: HighlightStyle) -> Self {
+        match val {
+            HighlightStyle::DoubleEqual => Self::DoubleEqual,
+            HighlightStyle::Html => Self::Html,
+            HighlightStyle::Bold => Self::Bold,
+            HighlightStyle::None => Self::None,
+        }
+    }
+}
+
+impl From<html_to_markdown_rs::options::HighlightStyle> for HighlightStyle {
+    fn from(val: html_to_markdown_rs::options::HighlightStyle) -> Self {
+        match val {
+            html_to_markdown_rs::options::HighlightStyle::DoubleEqual => Self::DoubleEqual,
+            html_to_markdown_rs::options::HighlightStyle::Html => Self::Html,
+            html_to_markdown_rs::options::HighlightStyle::Bold => Self::Bold,
+            html_to_markdown_rs::options::HighlightStyle::None => Self::None,
+        }
+    }
+}
+
+impl From<LinkStyle> for html_to_markdown_rs::options::LinkStyle {
+    fn from(val: LinkStyle) -> Self {
+        match val {
+            LinkStyle::Inline => Self::Inline,
+            LinkStyle::Reference => Self::Reference,
+        }
+    }
+}
+
+impl From<html_to_markdown_rs::options::LinkStyle> for LinkStyle {
+    fn from(val: html_to_markdown_rs::options::LinkStyle) -> Self {
+        match val {
+            html_to_markdown_rs::options::LinkStyle::Inline => Self::Inline,
+            html_to_markdown_rs::options::LinkStyle::Reference => Self::Reference,
+        }
+    }
+}
+
+impl From<OutputFormat> for html_to_markdown_rs::options::OutputFormat {
+    fn from(val: OutputFormat) -> Self {
+        match val {
+            OutputFormat::Markdown => Self::Markdown,
+            OutputFormat::Djot => Self::Djot,
+            OutputFormat::Plain => Self::Plain,
+        }
+    }
+}
+
+impl From<html_to_markdown_rs::options::OutputFormat> for OutputFormat {
+    fn from(val: html_to_markdown_rs::options::OutputFormat) -> Self {
+        match val {
+            html_to_markdown_rs::options::OutputFormat::Markdown => Self::Markdown,
+            html_to_markdown_rs::options::OutputFormat::Djot => Self::Djot,
+            html_to_markdown_rs::options::OutputFormat::Plain => Self::Plain,
+        }
+    }
+}
+
+impl From<NodeContent> for html_to_markdown_rs::NodeContent {
+    fn from(val: NodeContent) -> Self {
+        match val {
+            NodeContent::Heading { level, text } => Self::Heading { level, text },
+            NodeContent::Paragraph { text } => Self::Paragraph { text },
+            NodeContent::List { ordered } => Self::List { ordered },
+            NodeContent::ListItem { text } => Self::ListItem { text },
+            NodeContent::Table { grid } => Self::Table { grid: grid.into() },
+            NodeContent::Image {
+                description,
+                src,
+                image_index,
+            } => Self::Image {
+                description,
+                src,
+                image_index,
+            },
+            NodeContent::Code { text, language } => Self::Code { text, language },
+            NodeContent::Quote => Self::Quote,
+            NodeContent::DefinitionList => Self::DefinitionList,
+            NodeContent::DefinitionItem { term, definition } => Self::DefinitionItem { term, definition },
+            NodeContent::RawBlock { format, content } => Self::RawBlock { format, content },
+            NodeContent::MetadataBlock { entries } => Self::MetadataBlock {
+                entries: serde_json::from_str(&entries).unwrap_or_default(),
+            },
+            NodeContent::Group {
+                label,
+                heading_level,
+                heading_text,
+            } => Self::Group {
+                label,
+                heading_level,
+                heading_text,
+            },
+        }
+    }
+}
+
+impl From<html_to_markdown_rs::NodeContent> for NodeContent {
+    fn from(val: html_to_markdown_rs::NodeContent) -> Self {
+        match val {
+            html_to_markdown_rs::NodeContent::Heading { level, text } => Self::Heading { level, text },
+            html_to_markdown_rs::NodeContent::Paragraph { text } => Self::Paragraph { text },
+            html_to_markdown_rs::NodeContent::List { ordered } => Self::List { ordered },
+            html_to_markdown_rs::NodeContent::ListItem { text } => Self::ListItem { text },
+            html_to_markdown_rs::NodeContent::Table { grid } => Self::Table { grid: grid.into() },
+            html_to_markdown_rs::NodeContent::Image {
+                description,
+                src,
+                image_index,
+            } => Self::Image {
+                description,
+                src,
+                image_index,
+            },
+            html_to_markdown_rs::NodeContent::Code { text, language } => Self::Code { text, language },
+            html_to_markdown_rs::NodeContent::Quote => Self::Quote,
+            html_to_markdown_rs::NodeContent::DefinitionList => Self::DefinitionList,
+            html_to_markdown_rs::NodeContent::DefinitionItem { term, definition } => {
+                Self::DefinitionItem { term, definition }
+            }
+            html_to_markdown_rs::NodeContent::RawBlock { format, content } => Self::RawBlock { format, content },
+            html_to_markdown_rs::NodeContent::MetadataBlock { entries } => Self::MetadataBlock {
+                entries: serde_json::to_string(&entries).unwrap_or_default(),
+            },
+            html_to_markdown_rs::NodeContent::Group {
+                label,
+                heading_level,
+                heading_text,
+            } => Self::Group {
+                label,
+                heading_level,
+                heading_text,
+            },
+        }
+    }
+}
+
+impl From<AnnotationKind> for html_to_markdown_rs::AnnotationKind {
+    fn from(val: AnnotationKind) -> Self {
+        match val {
+            AnnotationKind::Bold => Self::Bold,
+            AnnotationKind::Italic => Self::Italic,
+            AnnotationKind::Underline => Self::Underline,
+            AnnotationKind::Strikethrough => Self::Strikethrough,
+            AnnotationKind::Code => Self::Code,
+            AnnotationKind::Subscript => Self::Subscript,
+            AnnotationKind::Superscript => Self::Superscript,
+            AnnotationKind::Highlight => Self::Highlight,
+            AnnotationKind::Link { url, title } => Self::Link { url, title },
+        }
+    }
+}
+
+impl From<html_to_markdown_rs::AnnotationKind> for AnnotationKind {
+    fn from(val: html_to_markdown_rs::AnnotationKind) -> Self {
+        match val {
+            html_to_markdown_rs::AnnotationKind::Bold => Self::Bold,
+            html_to_markdown_rs::AnnotationKind::Italic => Self::Italic,
+            html_to_markdown_rs::AnnotationKind::Underline => Self::Underline,
+            html_to_markdown_rs::AnnotationKind::Strikethrough => Self::Strikethrough,
+            html_to_markdown_rs::AnnotationKind::Code => Self::Code,
+            html_to_markdown_rs::AnnotationKind::Subscript => Self::Subscript,
+            html_to_markdown_rs::AnnotationKind::Superscript => Self::Superscript,
+            html_to_markdown_rs::AnnotationKind::Highlight => Self::Highlight,
+            html_to_markdown_rs::AnnotationKind::Link { url, title } => Self::Link { url, title },
+        }
+    }
+}
+
+impl From<WarningKind> for html_to_markdown_rs::WarningKind {
+    fn from(val: WarningKind) -> Self {
+        match val {
+            WarningKind::ImageExtractionFailed => Self::ImageExtractionFailed,
+            WarningKind::EncodingFallback => Self::EncodingFallback,
+            WarningKind::TruncatedInput => Self::TruncatedInput,
+            WarningKind::MalformedHtml => Self::MalformedHtml,
+            WarningKind::SanitizationApplied => Self::SanitizationApplied,
+        }
+    }
+}
+
+impl From<html_to_markdown_rs::WarningKind> for WarningKind {
+    fn from(val: html_to_markdown_rs::WarningKind) -> Self {
+        match val {
+            html_to_markdown_rs::WarningKind::ImageExtractionFailed => Self::ImageExtractionFailed,
+            html_to_markdown_rs::WarningKind::EncodingFallback => Self::EncodingFallback,
+            html_to_markdown_rs::WarningKind::TruncatedInput => Self::TruncatedInput,
+            html_to_markdown_rs::WarningKind::MalformedHtml => Self::MalformedHtml,
+            html_to_markdown_rs::WarningKind::SanitizationApplied => Self::SanitizationApplied,
+        }
+    }
+}
+
+/// Convert a `html_to_markdown_rs::error::ConversionError` error to a Magnus runtime error.
+#[allow(dead_code)]
+fn conversion_error_to_magnus_err(e: html_to_markdown_rs::error::ConversionError) -> magnus::Error {
+    let msg = e.to_string();
+    magnus::Error::new(magnus::exception::runtime_error(), msg)
+}
+
+#[magnus::init]
+fn init(ruby: &Ruby) -> Result<(), Error> {
+    let module = ruby.define_module("HtmlToMarkdownRs")?;
+
+    let class = module.define_class("MetadataConfig", ruby.class_object())?;
+    class.define_singleton_method("new", function!(MetadataConfig::new, 6))?;
+    class.define_method("extract_document", method!(MetadataConfig::extract_document, 0))?;
+    class.define_method("extract_headers", method!(MetadataConfig::extract_headers, 0))?;
+    class.define_method("extract_links", method!(MetadataConfig::extract_links, 0))?;
+    class.define_method("extract_images", method!(MetadataConfig::extract_images, 0))?;
+    class.define_method(
+        "extract_structured_data",
+        method!(MetadataConfig::extract_structured_data, 0),
+    )?;
+    class.define_method(
+        "max_structured_data_size",
+        method!(MetadataConfig::max_structured_data_size, 0),
+    )?;
+    class.define_method("any_enabled", method!(MetadataConfig::any_enabled, 0))?;
+
+    let class = module.define_class("MetadataConfigUpdate", ruby.class_object())?;
+    class.define_singleton_method("new", function!(MetadataConfigUpdate::new, 6))?;
+    class.define_method("extract_document", method!(MetadataConfigUpdate::extract_document, 0))?;
+    class.define_method("extract_headers", method!(MetadataConfigUpdate::extract_headers, 0))?;
+    class.define_method("extract_links", method!(MetadataConfigUpdate::extract_links, 0))?;
+    class.define_method("extract_images", method!(MetadataConfigUpdate::extract_images, 0))?;
+    class.define_method(
+        "extract_structured_data",
+        method!(MetadataConfigUpdate::extract_structured_data, 0),
+    )?;
+    class.define_method(
+        "max_structured_data_size",
+        method!(MetadataConfigUpdate::max_structured_data_size, 0),
+    )?;
+
+    let class = module.define_class("DocumentMetadata", ruby.class_object())?;
+    class.define_singleton_method("new", function!(DocumentMetadata::new, 11))?;
+    class.define_method("title", method!(DocumentMetadata::title, 0))?;
+    class.define_method("description", method!(DocumentMetadata::description, 0))?;
+    class.define_method("keywords", method!(DocumentMetadata::keywords, 0))?;
+    class.define_method("author", method!(DocumentMetadata::author, 0))?;
+    class.define_method("canonical_url", method!(DocumentMetadata::canonical_url, 0))?;
+    class.define_method("base_href", method!(DocumentMetadata::base_href, 0))?;
+    class.define_method("language", method!(DocumentMetadata::language, 0))?;
+    class.define_method("text_direction", method!(DocumentMetadata::text_direction, 0))?;
+    class.define_method("open_graph", method!(DocumentMetadata::open_graph, 0))?;
+    class.define_method("twitter_card", method!(DocumentMetadata::twitter_card, 0))?;
+    class.define_method("meta_tags", method!(DocumentMetadata::meta_tags, 0))?;
+
+    let class = module.define_class("HeaderMetadata", ruby.class_object())?;
+    class.define_singleton_method("new", function!(HeaderMetadata::new, 5))?;
+    class.define_method("level", method!(HeaderMetadata::level, 0))?;
+    class.define_method("text", method!(HeaderMetadata::text, 0))?;
+    class.define_method("id", method!(HeaderMetadata::id, 0))?;
+    class.define_method("depth", method!(HeaderMetadata::depth, 0))?;
+    class.define_method("html_offset", method!(HeaderMetadata::html_offset, 0))?;
+    class.define_method("is_valid", method!(HeaderMetadata::is_valid, 0))?;
+
+    let class = module.define_class("LinkMetadata", ruby.class_object())?;
+    class.define_singleton_method("new", function!(LinkMetadata::new, 6))?;
+    class.define_method("href", method!(LinkMetadata::href, 0))?;
+    class.define_method("text", method!(LinkMetadata::text, 0))?;
+    class.define_method("title", method!(LinkMetadata::title, 0))?;
+    class.define_method("link_type", method!(LinkMetadata::link_type, 0))?;
+    class.define_method("rel", method!(LinkMetadata::rel, 0))?;
+    class.define_method("attributes", method!(LinkMetadata::attributes, 0))?;
+
+    let class = module.define_class("ImageMetadata", ruby.class_object())?;
+    class.define_singleton_method("new", function!(ImageMetadata::new, 6))?;
+    class.define_method("src", method!(ImageMetadata::src, 0))?;
+    class.define_method("alt", method!(ImageMetadata::alt, 0))?;
+    class.define_method("title", method!(ImageMetadata::title, 0))?;
+    class.define_method("dimensions", method!(ImageMetadata::dimensions, 0))?;
+    class.define_method("image_type", method!(ImageMetadata::image_type, 0))?;
+    class.define_method("attributes", method!(ImageMetadata::attributes, 0))?;
+
+    let class = module.define_class("StructuredData", ruby.class_object())?;
+    class.define_singleton_method("new", function!(StructuredData::new, 3))?;
+    class.define_method("data_type", method!(StructuredData::data_type, 0))?;
+    class.define_method("raw_json", method!(StructuredData::raw_json, 0))?;
+    class.define_method("schema_type", method!(StructuredData::schema_type, 0))?;
+
+    let class = module.define_class("HtmlMetadata", ruby.class_object())?;
+    class.define_singleton_method("new", function!(HtmlMetadata::new, 5))?;
+    class.define_method("document", method!(HtmlMetadata::document, 0))?;
+    class.define_method("headers", method!(HtmlMetadata::headers, 0))?;
+    class.define_method("links", method!(HtmlMetadata::links, 0))?;
+    class.define_method("images", method!(HtmlMetadata::images, 0))?;
+    class.define_method("structured_data", method!(HtmlMetadata::structured_data, 0))?;
+
+    let class = module.define_class("ConversionOptions", ruby.class_object())?;
+    class.define_singleton_method("new", function!(ConversionOptions::new, 1))?;
+    class.define_method("heading_style", method!(ConversionOptions::heading_style, 0))?;
+    class.define_method("list_indent_type", method!(ConversionOptions::list_indent_type, 0))?;
+    class.define_method("list_indent_width", method!(ConversionOptions::list_indent_width, 0))?;
+    class.define_method("bullets", method!(ConversionOptions::bullets, 0))?;
+    class.define_method("strong_em_symbol", method!(ConversionOptions::strong_em_symbol, 0))?;
+    class.define_method("escape_asterisks", method!(ConversionOptions::escape_asterisks, 0))?;
+    class.define_method("escape_underscores", method!(ConversionOptions::escape_underscores, 0))?;
+    class.define_method("escape_misc", method!(ConversionOptions::escape_misc, 0))?;
+    class.define_method("escape_ascii", method!(ConversionOptions::escape_ascii, 0))?;
+    class.define_method("code_language", method!(ConversionOptions::code_language, 0))?;
+    class.define_method("autolinks", method!(ConversionOptions::autolinks, 0))?;
+    class.define_method("default_title", method!(ConversionOptions::default_title, 0))?;
+    class.define_method("br_in_tables", method!(ConversionOptions::br_in_tables, 0))?;
+    class.define_method("highlight_style", method!(ConversionOptions::highlight_style, 0))?;
+    class.define_method("extract_metadata", method!(ConversionOptions::extract_metadata, 0))?;
+    class.define_method("whitespace_mode", method!(ConversionOptions::whitespace_mode, 0))?;
+    class.define_method("strip_newlines", method!(ConversionOptions::strip_newlines, 0))?;
+    class.define_method("wrap", method!(ConversionOptions::wrap, 0))?;
+    class.define_method("wrap_width", method!(ConversionOptions::wrap_width, 0))?;
+    class.define_method("convert_as_inline", method!(ConversionOptions::convert_as_inline, 0))?;
+    class.define_method("sub_symbol", method!(ConversionOptions::sub_symbol, 0))?;
+    class.define_method("sup_symbol", method!(ConversionOptions::sup_symbol, 0))?;
+    class.define_method("newline_style", method!(ConversionOptions::newline_style, 0))?;
+    class.define_method("code_block_style", method!(ConversionOptions::code_block_style, 0))?;
+    class.define_method(
+        "keep_inline_images_in",
+        method!(ConversionOptions::keep_inline_images_in, 0),
+    )?;
+    class.define_method("preprocessing", method!(ConversionOptions::preprocessing, 0))?;
+    class.define_method("encoding", method!(ConversionOptions::encoding, 0))?;
+    class.define_method("debug", method!(ConversionOptions::debug, 0))?;
+    class.define_method("strip_tags", method!(ConversionOptions::strip_tags, 0))?;
+    class.define_method("preserve_tags", method!(ConversionOptions::preserve_tags, 0))?;
+    class.define_method("skip_images", method!(ConversionOptions::skip_images, 0))?;
+    class.define_method("link_style", method!(ConversionOptions::link_style, 0))?;
+    class.define_method("output_format", method!(ConversionOptions::output_format, 0))?;
+    class.define_method(
+        "include_document_structure",
+        method!(ConversionOptions::include_document_structure, 0),
+    )?;
+    class.define_method("extract_images", method!(ConversionOptions::extract_images, 0))?;
+    class.define_method("max_image_size", method!(ConversionOptions::max_image_size, 0))?;
+    class.define_method("capture_svg", method!(ConversionOptions::capture_svg, 0))?;
+    class.define_method("infer_dimensions", method!(ConversionOptions::infer_dimensions, 0))?;
+
+    let class = module.define_class("ConversionOptionsBuilder", ruby.class_object())?;
+    class.define_method("strip_tags", method!(ConversionOptionsBuilder::strip_tags, 1))?;
+    class.define_method("preserve_tags", method!(ConversionOptionsBuilder::preserve_tags, 1))?;
+    class.define_method(
+        "keep_inline_images_in",
+        method!(ConversionOptionsBuilder::keep_inline_images_in, 1),
+    )?;
+    class.define_method("preprocessing", method!(ConversionOptionsBuilder::preprocessing, 1))?;
+    class.define_method("build", method!(ConversionOptionsBuilder::build, 0))?;
+
+    let class = module.define_class("ConversionOptionsUpdate", ruby.class_object())?;
+    class.define_singleton_method("new", function!(ConversionOptionsUpdate::new, 1))?;
+    class.define_method("heading_style", method!(ConversionOptionsUpdate::heading_style, 0))?;
+    class.define_method(
+        "list_indent_type",
+        method!(ConversionOptionsUpdate::list_indent_type, 0),
+    )?;
+    class.define_method(
+        "list_indent_width",
+        method!(ConversionOptionsUpdate::list_indent_width, 0),
+    )?;
+    class.define_method("bullets", method!(ConversionOptionsUpdate::bullets, 0))?;
+    class.define_method(
+        "strong_em_symbol",
+        method!(ConversionOptionsUpdate::strong_em_symbol, 0),
+    )?;
+    class.define_method(
+        "escape_asterisks",
+        method!(ConversionOptionsUpdate::escape_asterisks, 0),
+    )?;
+    class.define_method(
+        "escape_underscores",
+        method!(ConversionOptionsUpdate::escape_underscores, 0),
+    )?;
+    class.define_method("escape_misc", method!(ConversionOptionsUpdate::escape_misc, 0))?;
+    class.define_method("escape_ascii", method!(ConversionOptionsUpdate::escape_ascii, 0))?;
+    class.define_method("code_language", method!(ConversionOptionsUpdate::code_language, 0))?;
+    class.define_method("autolinks", method!(ConversionOptionsUpdate::autolinks, 0))?;
+    class.define_method("default_title", method!(ConversionOptionsUpdate::default_title, 0))?;
+    class.define_method("br_in_tables", method!(ConversionOptionsUpdate::br_in_tables, 0))?;
+    class.define_method("highlight_style", method!(ConversionOptionsUpdate::highlight_style, 0))?;
+    class.define_method(
+        "extract_metadata",
+        method!(ConversionOptionsUpdate::extract_metadata, 0),
+    )?;
+    class.define_method("whitespace_mode", method!(ConversionOptionsUpdate::whitespace_mode, 0))?;
+    class.define_method("strip_newlines", method!(ConversionOptionsUpdate::strip_newlines, 0))?;
+    class.define_method("wrap", method!(ConversionOptionsUpdate::wrap, 0))?;
+    class.define_method("wrap_width", method!(ConversionOptionsUpdate::wrap_width, 0))?;
+    class.define_method(
+        "convert_as_inline",
+        method!(ConversionOptionsUpdate::convert_as_inline, 0),
+    )?;
+    class.define_method("sub_symbol", method!(ConversionOptionsUpdate::sub_symbol, 0))?;
+    class.define_method("sup_symbol", method!(ConversionOptionsUpdate::sup_symbol, 0))?;
+    class.define_method("newline_style", method!(ConversionOptionsUpdate::newline_style, 0))?;
+    class.define_method(
+        "code_block_style",
+        method!(ConversionOptionsUpdate::code_block_style, 0),
+    )?;
+    class.define_method(
+        "keep_inline_images_in",
+        method!(ConversionOptionsUpdate::keep_inline_images_in, 0),
+    )?;
+    class.define_method("preprocessing", method!(ConversionOptionsUpdate::preprocessing, 0))?;
+    class.define_method("encoding", method!(ConversionOptionsUpdate::encoding, 0))?;
+    class.define_method("debug", method!(ConversionOptionsUpdate::debug, 0))?;
+    class.define_method("strip_tags", method!(ConversionOptionsUpdate::strip_tags, 0))?;
+    class.define_method("preserve_tags", method!(ConversionOptionsUpdate::preserve_tags, 0))?;
+    class.define_method("skip_images", method!(ConversionOptionsUpdate::skip_images, 0))?;
+    class.define_method("link_style", method!(ConversionOptionsUpdate::link_style, 0))?;
+    class.define_method("output_format", method!(ConversionOptionsUpdate::output_format, 0))?;
+    class.define_method(
+        "include_document_structure",
+        method!(ConversionOptionsUpdate::include_document_structure, 0),
+    )?;
+    class.define_method("extract_images", method!(ConversionOptionsUpdate::extract_images, 0))?;
+    class.define_method("max_image_size", method!(ConversionOptionsUpdate::max_image_size, 0))?;
+    class.define_method("capture_svg", method!(ConversionOptionsUpdate::capture_svg, 0))?;
+    class.define_method(
+        "infer_dimensions",
+        method!(ConversionOptionsUpdate::infer_dimensions, 0),
+    )?;
+
+    let class = module.define_class("PreprocessingOptions", ruby.class_object())?;
+    class.define_singleton_method("new", function!(PreprocessingOptions::new, 4))?;
+    class.define_method("enabled", method!(PreprocessingOptions::enabled, 0))?;
+    class.define_method("preset", method!(PreprocessingOptions::preset, 0))?;
+    class.define_method("remove_navigation", method!(PreprocessingOptions::remove_navigation, 0))?;
+    class.define_method("remove_forms", method!(PreprocessingOptions::remove_forms, 0))?;
+
+    let class = module.define_class("PreprocessingOptionsUpdate", ruby.class_object())?;
+    class.define_singleton_method("new", function!(PreprocessingOptionsUpdate::new, 4))?;
+    class.define_method("enabled", method!(PreprocessingOptionsUpdate::enabled, 0))?;
+    class.define_method("preset", method!(PreprocessingOptionsUpdate::preset, 0))?;
+    class.define_method(
+        "remove_navigation",
+        method!(PreprocessingOptionsUpdate::remove_navigation, 0),
+    )?;
+    class.define_method("remove_forms", method!(PreprocessingOptionsUpdate::remove_forms, 0))?;
+
+    let class = module.define_class("DocumentStructure", ruby.class_object())?;
+    class.define_singleton_method("new", function!(DocumentStructure::new, 2))?;
+    class.define_method("nodes", method!(DocumentStructure::nodes, 0))?;
+    class.define_method("source_format", method!(DocumentStructure::source_format, 0))?;
+
+    let class = module.define_class("DocumentNode", ruby.class_object())?;
+    class.define_singleton_method("new", function!(DocumentNode::new, 6))?;
+    class.define_method("id", method!(DocumentNode::id, 0))?;
+    class.define_method("content", method!(DocumentNode::content, 0))?;
+    class.define_method("parent", method!(DocumentNode::parent, 0))?;
+    class.define_method("children", method!(DocumentNode::children, 0))?;
+    class.define_method("annotations", method!(DocumentNode::annotations, 0))?;
+    class.define_method("attributes", method!(DocumentNode::attributes, 0))?;
+
+    let class = module.define_class("TextAnnotation", ruby.class_object())?;
+    class.define_singleton_method("new", function!(TextAnnotation::new, 3))?;
+    class.define_method("start", method!(TextAnnotation::start, 0))?;
+    class.define_method("end", method!(TextAnnotation::end, 0))?;
+    class.define_method("kind", method!(TextAnnotation::kind, 0))?;
+
+    let class = module.define_class("ConversionResult", ruby.class_object())?;
+    class.define_singleton_method("new", function!(ConversionResult::new, 6))?;
+    class.define_method("content", method!(ConversionResult::content, 0))?;
+    class.define_method("document", method!(ConversionResult::document, 0))?;
+    class.define_method("metadata", method!(ConversionResult::metadata, 0))?;
+    class.define_method("tables", method!(ConversionResult::tables, 0))?;
+    class.define_method("images", method!(ConversionResult::images, 0))?;
+    class.define_method("warnings", method!(ConversionResult::warnings, 0))?;
+
+    let class = module.define_class("TableGrid", ruby.class_object())?;
+    class.define_singleton_method("new", function!(TableGrid::new, 3))?;
+    class.define_method("rows", method!(TableGrid::rows, 0))?;
+    class.define_method("cols", method!(TableGrid::cols, 0))?;
+    class.define_method("cells", method!(TableGrid::cells, 0))?;
+
+    let class = module.define_class("GridCell", ruby.class_object())?;
+    class.define_singleton_method("new", function!(GridCell::new, 6))?;
+    class.define_method("content", method!(GridCell::content, 0))?;
+    class.define_method("row", method!(GridCell::row, 0))?;
+    class.define_method("col", method!(GridCell::col, 0))?;
+    class.define_method("row_span", method!(GridCell::row_span, 0))?;
+    class.define_method("col_span", method!(GridCell::col_span, 0))?;
+    class.define_method("is_header", method!(GridCell::is_header, 0))?;
+
+    let class = module.define_class("TableData", ruby.class_object())?;
+    class.define_singleton_method("new", function!(TableData::new, 2))?;
+    class.define_method("grid", method!(TableData::grid, 0))?;
+    class.define_method("markdown", method!(TableData::markdown, 0))?;
+
+    let class = module.define_class("ProcessingWarning", ruby.class_object())?;
+    class.define_singleton_method("new", function!(ProcessingWarning::new, 2))?;
+    class.define_method("message", method!(ProcessingWarning::message, 0))?;
+    class.define_method("kind", method!(ProcessingWarning::kind, 0))?;
+
+    module.define_module_function("convert", function!(convert, 2))?;
+
+    Ok(())
+}