kreuzcrawl 0.1.0.pre.rc.2

data/ext/kreuzcrawl_rb/src/lib.rs

@@ -0,0 +1,4835 @@
+// 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 = "Kreuzcrawl::ExtractionMeta")]
+#[serde(default)]
+pub struct ExtractionMeta {
+    pub cost: Option<f64>,
+    pub prompt_tokens: Option<u64>,
+    pub completion_tokens: Option<u64>,
+    pub model: Option<String>,
+    pub chunks_processed: usize,
+}
+
+unsafe impl IntoValueFromNative for ExtractionMeta {}
+
+impl magnus::TryConvert for ExtractionMeta {
+    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
+        let r: &ExtractionMeta = magnus::TryConvert::try_convert(val)?;
+        Ok(r.clone())
+    }
+}
+unsafe impl TryConvertOwned for ExtractionMeta {}
+
+impl Default for ExtractionMeta {
+    fn default() -> Self {
+        Self {
+            cost: Default::default(),
+            prompt_tokens: Default::default(),
+            completion_tokens: Default::default(),
+            model: Default::default(),
+            chunks_processed: Default::default(),
+        }
+    }
+}
+
+impl ExtractionMeta {
+    fn new(
+        cost: Option<f64>,
+        prompt_tokens: Option<u64>,
+        completion_tokens: Option<u64>,
+        model: Option<String>,
+        chunks_processed: Option<usize>,
+    ) -> Self {
+        Self {
+            cost,
+            prompt_tokens,
+            completion_tokens,
+            model,
+            chunks_processed: chunks_processed.unwrap_or_default(),
+        }
+    }
+
+    fn cost(&self) -> Option<f64> {
+        self.cost
+    }
+
+    fn prompt_tokens(&self) -> Option<u64> {
+        self.prompt_tokens
+    }
+
+    fn completion_tokens(&self) -> Option<u64> {
+        self.completion_tokens
+    }
+
+    fn model(&self) -> Option<String> {
+        self.model.clone()
+    }
+
+    fn chunks_processed(&self) -> usize {
+        self.chunks_processed
+    }
+}
+
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
+#[magnus::wrap(class = "Kreuzcrawl::ProxyConfig")]
+#[serde(default)]
+pub struct ProxyConfig {
+    pub url: String,
+    pub username: Option<String>,
+    pub password: Option<String>,
+}
+
+unsafe impl IntoValueFromNative for ProxyConfig {}
+
+impl magnus::TryConvert for ProxyConfig {
+    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
+        let r: &ProxyConfig = magnus::TryConvert::try_convert(val)?;
+        Ok(r.clone())
+    }
+}
+unsafe impl TryConvertOwned for ProxyConfig {}
+
+impl Default for ProxyConfig {
+    fn default() -> Self {
+        Self {
+            url: Default::default(),
+            username: Default::default(),
+            password: Default::default(),
+        }
+    }
+}
+
+impl ProxyConfig {
+    fn new(url: Option<String>, username: Option<String>, password: Option<String>) -> Self {
+        Self {
+            url: url.unwrap_or_default(),
+            username,
+            password,
+        }
+    }
+
+    fn url(&self) -> String {
+        self.url.clone()
+    }
+
+    fn username(&self) -> Option<String> {
+        self.username.clone()
+    }
+
+    fn password(&self) -> Option<String> {
+        self.password.clone()
+    }
+}
+
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize, Default)]
+#[magnus::wrap(class = "Kreuzcrawl::BrowserConfig")]
+#[serde(default)]
+pub struct BrowserConfig {
+    pub mode: BrowserMode,
+    pub endpoint: Option<String>,
+    pub timeout: u64,
+    pub wait: BrowserWait,
+    pub wait_selector: Option<String>,
+    pub extra_wait: Option<u64>,
+}
+
+unsafe impl IntoValueFromNative for BrowserConfig {}
+
+impl magnus::TryConvert for BrowserConfig {
+    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
+        let r: &BrowserConfig = magnus::TryConvert::try_convert(val)?;
+        Ok(r.clone())
+    }
+}
+unsafe impl TryConvertOwned for BrowserConfig {}
+
+impl BrowserConfig {
+    fn new(
+        mode: Option<BrowserMode>,
+        endpoint: Option<String>,
+        timeout: Option<u64>,
+        wait: Option<BrowserWait>,
+        wait_selector: Option<String>,
+        extra_wait: Option<u64>,
+    ) -> Self {
+        Self {
+            mode: mode.unwrap_or(BrowserMode::Auto),
+            endpoint,
+            timeout: timeout.unwrap_or(30000),
+            wait: wait.unwrap_or_default(),
+            wait_selector,
+            extra_wait,
+        }
+    }
+
+    fn mode(&self) -> BrowserMode {
+        self.mode.clone()
+    }
+
+    fn endpoint(&self) -> Option<String> {
+        self.endpoint.clone()
+    }
+
+    fn timeout(&self) -> u64 {
+        self.timeout.clone()
+    }
+
+    fn wait(&self) -> BrowserWait {
+        self.wait.clone()
+    }
+
+    fn wait_selector(&self) -> Option<String> {
+        self.wait_selector.clone()
+    }
+
+    fn extra_wait(&self) -> Option<u64> {
+        self.extra_wait.clone()
+    }
+}
+
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize, Default)]
+#[magnus::wrap(class = "Kreuzcrawl::CrawlConfig")]
+#[serde(default)]
+pub struct CrawlConfig {
+    pub max_depth: Option<usize>,
+    pub max_pages: Option<usize>,
+    pub max_concurrent: Option<usize>,
+    pub respect_robots_txt: bool,
+    pub user_agent: Option<String>,
+    pub stay_on_domain: bool,
+    pub allow_subdomains: bool,
+    pub include_paths: Vec<String>,
+    pub exclude_paths: Vec<String>,
+    pub custom_headers: HashMap<String, String>,
+    pub request_timeout: u64,
+    pub max_redirects: usize,
+    pub retry_count: usize,
+    pub retry_codes: Vec<u16>,
+    pub cookies_enabled: bool,
+    pub auth: Option<AuthConfig>,
+    pub max_body_size: Option<usize>,
+    pub main_content_only: bool,
+    pub remove_tags: Vec<String>,
+    pub map_limit: Option<usize>,
+    pub map_search: Option<String>,
+    pub download_assets: bool,
+    pub asset_types: Vec<AssetCategory>,
+    pub max_asset_size: Option<usize>,
+    pub browser: BrowserConfig,
+    pub proxy: Option<ProxyConfig>,
+    pub user_agents: Vec<String>,
+    pub capture_screenshot: bool,
+    pub download_documents: bool,
+    pub document_max_size: Option<usize>,
+    pub document_mime_types: Vec<String>,
+    pub warc_output: Option<String>,
+    pub browser_profile: Option<String>,
+    pub save_browser_profile: bool,
+}
+
+unsafe impl IntoValueFromNative for CrawlConfig {}
+
+impl magnus::TryConvert for CrawlConfig {
+    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
+        let r: &CrawlConfig = magnus::TryConvert::try_convert(val)?;
+        Ok(r.clone())
+    }
+}
+unsafe impl TryConvertOwned for CrawlConfig {}
+
+impl CrawlConfig {
+    fn new(kwargs: magnus::RHash) -> Result<Self, magnus::Error> {
+        let ruby = unsafe { magnus::Ruby::get_unchecked() };
+        Ok(Self {
+            max_depth: kwargs
+                .get(ruby.to_symbol("max_depth"))
+                .and_then(|v| usize::try_convert(v).ok()),
+            max_pages: kwargs
+                .get(ruby.to_symbol("max_pages"))
+                .and_then(|v| usize::try_convert(v).ok()),
+            max_concurrent: kwargs
+                .get(ruby.to_symbol("max_concurrent"))
+                .and_then(|v| usize::try_convert(v).ok()),
+            respect_robots_txt: kwargs
+                .get(ruby.to_symbol("respect_robots_txt"))
+                .and_then(|v| bool::try_convert(v).ok())
+                .unwrap_or(false),
+            user_agent: kwargs
+                .get(ruby.to_symbol("user_agent"))
+                .and_then(|v| String::try_convert(v).ok()),
+            stay_on_domain: kwargs
+                .get(ruby.to_symbol("stay_on_domain"))
+                .and_then(|v| bool::try_convert(v).ok())
+                .unwrap_or(false),
+            allow_subdomains: kwargs
+                .get(ruby.to_symbol("allow_subdomains"))
+                .and_then(|v| bool::try_convert(v).ok())
+                .unwrap_or(false),
+            include_paths: kwargs
+                .get(ruby.to_symbol("include_paths"))
+                .and_then(|v| <Vec<String>>::try_convert(v).ok())
+                .unwrap_or_default(),
+            exclude_paths: kwargs
+                .get(ruby.to_symbol("exclude_paths"))
+                .and_then(|v| <Vec<String>>::try_convert(v).ok())
+                .unwrap_or_default(),
+            custom_headers: kwargs
+                .get(ruby.to_symbol("custom_headers"))
+                .and_then(|v| <HashMap<String, String>>::try_convert(v).ok())
+                .unwrap_or_default(),
+            request_timeout: kwargs
+                .get(ruby.to_symbol("request_timeout"))
+                .and_then(|v| u64::try_convert(v).ok())
+                .unwrap_or(30000),
+            max_redirects: kwargs
+                .get(ruby.to_symbol("max_redirects"))
+                .and_then(|v| usize::try_convert(v).ok())
+                .unwrap_or(10),
+            retry_count: kwargs
+                .get(ruby.to_symbol("retry_count"))
+                .and_then(|v| usize::try_convert(v).ok())
+                .unwrap_or(0),
+            retry_codes: kwargs
+                .get(ruby.to_symbol("retry_codes"))
+                .and_then(|v| <Vec<u16>>::try_convert(v).ok())
+                .unwrap_or_default(),
+            cookies_enabled: kwargs
+                .get(ruby.to_symbol("cookies_enabled"))
+                .and_then(|v| bool::try_convert(v).ok())
+                .unwrap_or(false),
+            auth: kwargs
+                .get(ruby.to_symbol("auth"))
+                .and_then(|v| AuthConfig::try_convert(v).ok()),
+            max_body_size: kwargs
+                .get(ruby.to_symbol("max_body_size"))
+                .and_then(|v| usize::try_convert(v).ok()),
+            main_content_only: kwargs
+                .get(ruby.to_symbol("main_content_only"))
+                .and_then(|v| bool::try_convert(v).ok())
+                .unwrap_or(false),
+            remove_tags: kwargs
+                .get(ruby.to_symbol("remove_tags"))
+                .and_then(|v| <Vec<String>>::try_convert(v).ok())
+                .unwrap_or_default(),
+            map_limit: kwargs
+                .get(ruby.to_symbol("map_limit"))
+                .and_then(|v| usize::try_convert(v).ok()),
+            map_search: kwargs
+                .get(ruby.to_symbol("map_search"))
+                .and_then(|v| String::try_convert(v).ok()),
+            download_assets: kwargs
+                .get(ruby.to_symbol("download_assets"))
+                .and_then(|v| bool::try_convert(v).ok())
+                .unwrap_or(false),
+            asset_types: kwargs
+                .get(ruby.to_symbol("asset_types"))
+                .and_then(|v| <Vec<AssetCategory>>::try_convert(v).ok())
+                .unwrap_or_default(),
+            max_asset_size: kwargs
+                .get(ruby.to_symbol("max_asset_size"))
+                .and_then(|v| usize::try_convert(v).ok()),
+            browser: kwargs
+                .get(ruby.to_symbol("browser"))
+                .and_then(|v| BrowserConfig::try_convert(v).ok())
+                .unwrap_or_default(),
+            proxy: kwargs
+                .get(ruby.to_symbol("proxy"))
+                .and_then(|v| ProxyConfig::try_convert(v).ok()),
+            user_agents: kwargs
+                .get(ruby.to_symbol("user_agents"))
+                .and_then(|v| <Vec<String>>::try_convert(v).ok())
+                .unwrap_or_default(),
+            capture_screenshot: kwargs
+                .get(ruby.to_symbol("capture_screenshot"))
+                .and_then(|v| bool::try_convert(v).ok())
+                .unwrap_or(false),
+            download_documents: kwargs
+                .get(ruby.to_symbol("download_documents"))
+                .and_then(|v| bool::try_convert(v).ok())
+                .unwrap_or(true),
+            document_max_size: kwargs
+                .get(ruby.to_symbol("document_max_size"))
+                .and_then(|v| usize::try_convert(v).ok()),
+            document_mime_types: kwargs
+                .get(ruby.to_symbol("document_mime_types"))
+                .and_then(|v| <Vec<String>>::try_convert(v).ok())
+                .unwrap_or_default(),
+            warc_output: kwargs
+                .get(ruby.to_symbol("warc_output"))
+                .and_then(|v| String::try_convert(v).ok()),
+            browser_profile: kwargs
+                .get(ruby.to_symbol("browser_profile"))
+                .and_then(|v| String::try_convert(v).ok()),
+            save_browser_profile: kwargs
+                .get(ruby.to_symbol("save_browser_profile"))
+                .and_then(|v| bool::try_convert(v).ok())
+                .unwrap_or(false),
+        })
+    }
+
+    fn max_depth(&self) -> Option<usize> {
+        self.max_depth
+    }
+
+    fn max_pages(&self) -> Option<usize> {
+        self.max_pages
+    }
+
+    fn max_concurrent(&self) -> Option<usize> {
+        self.max_concurrent
+    }
+
+    fn respect_robots_txt(&self) -> bool {
+        self.respect_robots_txt
+    }
+
+    fn user_agent(&self) -> Option<String> {
+        self.user_agent.clone()
+    }
+
+    fn stay_on_domain(&self) -> bool {
+        self.stay_on_domain
+    }
+
+    fn allow_subdomains(&self) -> bool {
+        self.allow_subdomains
+    }
+
+    fn include_paths(&self) -> Vec<String> {
+        self.include_paths.clone()
+    }
+
+    fn exclude_paths(&self) -> Vec<String> {
+        self.exclude_paths.clone()
+    }
+
+    fn custom_headers(&self) -> HashMap<String, String> {
+        self.custom_headers.clone()
+    }
+
+    fn request_timeout(&self) -> u64 {
+        self.request_timeout.clone()
+    }
+
+    fn max_redirects(&self) -> usize {
+        self.max_redirects
+    }
+
+    fn retry_count(&self) -> usize {
+        self.retry_count
+    }
+
+    fn retry_codes(&self) -> Vec<u16> {
+        self.retry_codes.clone()
+    }
+
+    fn cookies_enabled(&self) -> bool {
+        self.cookies_enabled
+    }
+
+    fn auth(&self) -> Option<AuthConfig> {
+        self.auth.clone()
+    }
+
+    fn max_body_size(&self) -> Option<usize> {
+        self.max_body_size
+    }
+
+    fn main_content_only(&self) -> bool {
+        self.main_content_only
+    }
+
+    fn remove_tags(&self) -> Vec<String> {
+        self.remove_tags.clone()
+    }
+
+    fn map_limit(&self) -> Option<usize> {
+        self.map_limit
+    }
+
+    fn map_search(&self) -> Option<String> {
+        self.map_search.clone()
+    }
+
+    fn download_assets(&self) -> bool {
+        self.download_assets
+    }
+
+    fn asset_types(&self) -> Vec<AssetCategory> {
+        self.asset_types.clone()
+    }
+
+    fn max_asset_size(&self) -> Option<usize> {
+        self.max_asset_size
+    }
+
+    fn browser(&self) -> BrowserConfig {
+        self.browser.clone()
+    }
+
+    fn proxy(&self) -> Option<ProxyConfig> {
+        self.proxy.clone()
+    }
+
+    fn user_agents(&self) -> Vec<String> {
+        self.user_agents.clone()
+    }
+
+    fn capture_screenshot(&self) -> bool {
+        self.capture_screenshot
+    }
+
+    fn download_documents(&self) -> bool {
+        self.download_documents
+    }
+
+    fn document_max_size(&self) -> Option<usize> {
+        self.document_max_size
+    }
+
+    fn document_mime_types(&self) -> Vec<String> {
+        self.document_mime_types.clone()
+    }
+
+    fn warc_output(&self) -> Option<String> {
+        self.warc_output.clone()
+    }
+
+    fn browser_profile(&self) -> Option<String> {
+        self.browser_profile.clone()
+    }
+
+    fn save_browser_profile(&self) -> bool {
+        self.save_browser_profile
+    }
+}
+
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
+#[magnus::wrap(class = "Kreuzcrawl::DownloadedDocument")]
+#[serde(default)]
+pub struct DownloadedDocument {
+    pub url: String,
+    pub mime_type: String,
+    pub content: Vec<u8>,
+    pub size: usize,
+    pub filename: Option<String>,
+    pub content_hash: String,
+    pub headers: HashMap<String, String>,
+}
+
+unsafe impl IntoValueFromNative for DownloadedDocument {}
+
+impl magnus::TryConvert for DownloadedDocument {
+    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
+        let r: &DownloadedDocument = magnus::TryConvert::try_convert(val)?;
+        Ok(r.clone())
+    }
+}
+unsafe impl TryConvertOwned for DownloadedDocument {}
+
+impl Default for DownloadedDocument {
+    fn default() -> Self {
+        Self {
+            url: Default::default(),
+            mime_type: Default::default(),
+            content: Default::default(),
+            size: Default::default(),
+            filename: Default::default(),
+            content_hash: Default::default(),
+            headers: Default::default(),
+        }
+    }
+}
+
+impl DownloadedDocument {
+    fn new(
+        url: Option<String>,
+        mime_type: Option<String>,
+        content: Option<Vec<u8>>,
+        size: Option<usize>,
+        filename: Option<String>,
+        content_hash: Option<String>,
+        headers: Option<HashMap<String, String>>,
+    ) -> Self {
+        Self {
+            url: url.unwrap_or_default(),
+            mime_type: mime_type.unwrap_or_default(),
+            content: content.unwrap_or_default(),
+            size: size.unwrap_or_default(),
+            filename,
+            content_hash: content_hash.unwrap_or_default(),
+            headers: headers.unwrap_or_default(),
+        }
+    }
+
+    fn url(&self) -> String {
+        self.url.clone()
+    }
+
+    fn mime_type(&self) -> String {
+        self.mime_type.clone()
+    }
+
+    fn content(&self) -> Vec<u8> {
+        self.content.clone()
+    }
+
+    fn size(&self) -> usize {
+        self.size
+    }
+
+    fn filename(&self) -> Option<String> {
+        self.filename.clone()
+    }
+
+    fn content_hash(&self) -> String {
+        self.content_hash.clone()
+    }
+
+    fn headers(&self) -> HashMap<String, String> {
+        self.headers.clone()
+    }
+}
+
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
+#[magnus::wrap(class = "Kreuzcrawl::InteractionResult")]
+#[serde(default)]
+pub struct InteractionResult {
+    pub action_results: Vec<ActionResult>,
+    pub final_html: String,
+    pub final_url: String,
+    pub screenshot: Option<Vec<u8>>,
+}
+
+unsafe impl IntoValueFromNative for InteractionResult {}
+
+impl magnus::TryConvert for InteractionResult {
+    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
+        let r: &InteractionResult = magnus::TryConvert::try_convert(val)?;
+        Ok(r.clone())
+    }
+}
+unsafe impl TryConvertOwned for InteractionResult {}
+
+impl Default for InteractionResult {
+    fn default() -> Self {
+        Self {
+            action_results: Default::default(),
+            final_html: Default::default(),
+            final_url: Default::default(),
+            screenshot: Default::default(),
+        }
+    }
+}
+
+impl InteractionResult {
+    fn new(
+        action_results: Option<Vec<ActionResult>>,
+        final_html: Option<String>,
+        final_url: Option<String>,
+        screenshot: Option<Vec<u8>>,
+    ) -> Self {
+        Self {
+            action_results: action_results.unwrap_or_default(),
+            final_html: final_html.unwrap_or_default(),
+            final_url: final_url.unwrap_or_default(),
+            screenshot,
+        }
+    }
+
+    fn action_results(&self) -> Vec<ActionResult> {
+        self.action_results.clone()
+    }
+
+    fn final_html(&self) -> String {
+        self.final_html.clone()
+    }
+
+    fn final_url(&self) -> String {
+        self.final_url.clone()
+    }
+
+    fn screenshot(&self) -> Option<Vec<u8>> {
+        self.screenshot.clone()
+    }
+}
+
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
+#[magnus::wrap(class = "Kreuzcrawl::ActionResult")]
+#[serde(default)]
+pub struct ActionResult {
+    pub action_index: usize,
+    pub action_type: String,
+    pub success: bool,
+    pub data: Option<String>,
+    pub error: Option<String>,
+}
+
+unsafe impl IntoValueFromNative for ActionResult {}
+
+impl magnus::TryConvert for ActionResult {
+    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
+        let r: &ActionResult = magnus::TryConvert::try_convert(val)?;
+        Ok(r.clone())
+    }
+}
+unsafe impl TryConvertOwned for ActionResult {}
+
+impl Default for ActionResult {
+    fn default() -> Self {
+        Self {
+            action_index: Default::default(),
+            action_type: Default::default(),
+            success: Default::default(),
+            data: Default::default(),
+            error: Default::default(),
+        }
+    }
+}
+
+impl ActionResult {
+    fn new(
+        action_index: Option<usize>,
+        action_type: Option<String>,
+        success: Option<bool>,
+        data: Option<String>,
+        error: Option<String>,
+    ) -> Self {
+        Self {
+            action_index: action_index.unwrap_or_default(),
+            action_type: action_type.unwrap_or_default(),
+            success: success.unwrap_or_default(),
+            data,
+            error,
+        }
+    }
+
+    fn action_index(&self) -> usize {
+        self.action_index
+    }
+
+    fn action_type(&self) -> String {
+        self.action_type.clone()
+    }
+
+    fn success(&self) -> bool {
+        self.success
+    }
+
+    fn data(&self) -> Option<String> {
+        self.data.clone()
+    }
+
+    fn error(&self) -> Option<String> {
+        self.error.clone()
+    }
+}
+
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
+#[magnus::wrap(class = "Kreuzcrawl::ScrapeResult")]
+#[serde(default)]
+pub struct ScrapeResult {
+    pub status_code: u16,
+    pub content_type: String,
+    pub html: String,
+    pub body_size: usize,
+    pub metadata: PageMetadata,
+    pub links: Vec<LinkInfo>,
+    pub images: Vec<ImageInfo>,
+    pub feeds: Vec<FeedInfo>,
+    pub json_ld: Vec<JsonLdEntry>,
+    pub is_allowed: bool,
+    pub crawl_delay: Option<u64>,
+    pub noindex_detected: bool,
+    pub nofollow_detected: bool,
+    pub x_robots_tag: Option<String>,
+    pub is_pdf: bool,
+    pub was_skipped: bool,
+    pub detected_charset: Option<String>,
+    pub main_content_only: bool,
+    pub auth_header_sent: bool,
+    pub response_meta: Option<ResponseMeta>,
+    pub assets: Vec<DownloadedAsset>,
+    pub js_render_hint: bool,
+    pub browser_used: bool,
+    pub markdown: Option<MarkdownResult>,
+    pub extracted_data: Option<String>,
+    pub extraction_meta: Option<ExtractionMeta>,
+    pub screenshot: Option<Vec<u8>>,
+    pub downloaded_document: Option<DownloadedDocument>,
+}
+
+unsafe impl IntoValueFromNative for ScrapeResult {}
+
+impl magnus::TryConvert for ScrapeResult {
+    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
+        let r: &ScrapeResult = magnus::TryConvert::try_convert(val)?;
+        Ok(r.clone())
+    }
+}
+unsafe impl TryConvertOwned for ScrapeResult {}
+
+impl Default for ScrapeResult {
+    fn default() -> Self {
+        Self {
+            status_code: Default::default(),
+            content_type: Default::default(),
+            html: Default::default(),
+            body_size: Default::default(),
+            metadata: Default::default(),
+            links: Default::default(),
+            images: Default::default(),
+            feeds: Default::default(),
+            json_ld: Default::default(),
+            is_allowed: Default::default(),
+            crawl_delay: Default::default(),
+            noindex_detected: Default::default(),
+            nofollow_detected: Default::default(),
+            x_robots_tag: Default::default(),
+            is_pdf: Default::default(),
+            was_skipped: Default::default(),
+            detected_charset: Default::default(),
+            main_content_only: Default::default(),
+            auth_header_sent: Default::default(),
+            response_meta: Default::default(),
+            assets: Default::default(),
+            js_render_hint: Default::default(),
+            browser_used: Default::default(),
+            markdown: Default::default(),
+            extracted_data: Default::default(),
+            extraction_meta: Default::default(),
+            screenshot: Default::default(),
+            downloaded_document: Default::default(),
+        }
+    }
+}
+
+impl ScrapeResult {
+    fn new(kwargs: magnus::RHash) -> Result<Self, magnus::Error> {
+        let ruby = unsafe { magnus::Ruby::get_unchecked() };
+        Ok(Self {
+            status_code: kwargs
+                .get(ruby.to_symbol("status_code"))
+                .and_then(|v| u16::try_convert(v).ok())
+                .unwrap_or_default(),
+            content_type: kwargs
+                .get(ruby.to_symbol("content_type"))
+                .and_then(|v| String::try_convert(v).ok())
+                .unwrap_or_default(),
+            html: kwargs
+                .get(ruby.to_symbol("html"))
+                .and_then(|v| String::try_convert(v).ok())
+                .unwrap_or_default(),
+            body_size: kwargs
+                .get(ruby.to_symbol("body_size"))
+                .and_then(|v| usize::try_convert(v).ok())
+                .unwrap_or_default(),
+            metadata: kwargs
+                .get(ruby.to_symbol("metadata"))
+                .and_then(|v| PageMetadata::try_convert(v).ok())
+                .unwrap_or_default(),
+            links: kwargs
+                .get(ruby.to_symbol("links"))
+                .and_then(|v| <Vec<LinkInfo>>::try_convert(v).ok())
+                .unwrap_or_default(),
+            images: kwargs
+                .get(ruby.to_symbol("images"))
+                .and_then(|v| <Vec<ImageInfo>>::try_convert(v).ok())
+                .unwrap_or_default(),
+            feeds: kwargs
+                .get(ruby.to_symbol("feeds"))
+                .and_then(|v| <Vec<FeedInfo>>::try_convert(v).ok())
+                .unwrap_or_default(),
+            json_ld: kwargs
+                .get(ruby.to_symbol("json_ld"))
+                .and_then(|v| <Vec<JsonLdEntry>>::try_convert(v).ok())
+                .unwrap_or_default(),
+            is_allowed: kwargs
+                .get(ruby.to_symbol("is_allowed"))
+                .and_then(|v| bool::try_convert(v).ok())
+                .unwrap_or_default(),
+            crawl_delay: kwargs
+                .get(ruby.to_symbol("crawl_delay"))
+                .and_then(|v| u64::try_convert(v).ok()),
+            noindex_detected: kwargs
+                .get(ruby.to_symbol("noindex_detected"))
+                .and_then(|v| bool::try_convert(v).ok())
+                .unwrap_or_default(),
+            nofollow_detected: kwargs
+                .get(ruby.to_symbol("nofollow_detected"))
+                .and_then(|v| bool::try_convert(v).ok())
+                .unwrap_or_default(),
+            x_robots_tag: kwargs
+                .get(ruby.to_symbol("x_robots_tag"))
+                .and_then(|v| String::try_convert(v).ok()),
+            is_pdf: kwargs
+                .get(ruby.to_symbol("is_pdf"))
+                .and_then(|v| bool::try_convert(v).ok())
+                .unwrap_or_default(),
+            was_skipped: kwargs
+                .get(ruby.to_symbol("was_skipped"))
+                .and_then(|v| bool::try_convert(v).ok())
+                .unwrap_or_default(),
+            detected_charset: kwargs
+                .get(ruby.to_symbol("detected_charset"))
+                .and_then(|v| String::try_convert(v).ok()),
+            main_content_only: kwargs
+                .get(ruby.to_symbol("main_content_only"))
+                .and_then(|v| bool::try_convert(v).ok())
+                .unwrap_or_default(),
+            auth_header_sent: kwargs
+                .get(ruby.to_symbol("auth_header_sent"))
+                .and_then(|v| bool::try_convert(v).ok())
+                .unwrap_or_default(),
+            response_meta: kwargs
+                .get(ruby.to_symbol("response_meta"))
+                .and_then(|v| ResponseMeta::try_convert(v).ok()),
+            assets: kwargs
+                .get(ruby.to_symbol("assets"))
+                .and_then(|v| <Vec<DownloadedAsset>>::try_convert(v).ok())
+                .unwrap_or_default(),
+            js_render_hint: kwargs
+                .get(ruby.to_symbol("js_render_hint"))
+                .and_then(|v| bool::try_convert(v).ok())
+                .unwrap_or_default(),
+            browser_used: kwargs
+                .get(ruby.to_symbol("browser_used"))
+                .and_then(|v| bool::try_convert(v).ok())
+                .unwrap_or_default(),
+            markdown: kwargs
+                .get(ruby.to_symbol("markdown"))
+                .and_then(|v| MarkdownResult::try_convert(v).ok()),
+            extracted_data: kwargs
+                .get(ruby.to_symbol("extracted_data"))
+                .and_then(|v| String::try_convert(v).ok()),
+            extraction_meta: kwargs
+                .get(ruby.to_symbol("extraction_meta"))
+                .and_then(|v| ExtractionMeta::try_convert(v).ok()),
+            screenshot: kwargs
+                .get(ruby.to_symbol("screenshot"))
+                .and_then(|v| <Vec<u8>>::try_convert(v).ok()),
+            downloaded_document: kwargs
+                .get(ruby.to_symbol("downloaded_document"))
+                .and_then(|v| DownloadedDocument::try_convert(v).ok()),
+        })
+    }
+
+    fn status_code(&self) -> u16 {
+        self.status_code
+    }
+
+    fn content_type(&self) -> String {
+        self.content_type.clone()
+    }
+
+    fn html(&self) -> String {
+        self.html.clone()
+    }
+
+    fn body_size(&self) -> usize {
+        self.body_size
+    }
+
+    fn metadata(&self) -> PageMetadata {
+        self.metadata.clone()
+    }
+
+    fn links(&self) -> Vec<LinkInfo> {
+        self.links.clone()
+    }
+
+    fn images(&self) -> Vec<ImageInfo> {
+        self.images.clone()
+    }
+
+    fn feeds(&self) -> Vec<FeedInfo> {
+        self.feeds.clone()
+    }
+
+    fn json_ld(&self) -> Vec<JsonLdEntry> {
+        self.json_ld.clone()
+    }
+
+    fn is_allowed(&self) -> bool {
+        self.is_allowed
+    }
+
+    fn crawl_delay(&self) -> Option<u64> {
+        self.crawl_delay
+    }
+
+    fn noindex_detected(&self) -> bool {
+        self.noindex_detected
+    }
+
+    fn nofollow_detected(&self) -> bool {
+        self.nofollow_detected
+    }
+
+    fn x_robots_tag(&self) -> Option<String> {
+        self.x_robots_tag.clone()
+    }
+
+    fn is_pdf(&self) -> bool {
+        self.is_pdf
+    }
+
+    fn was_skipped(&self) -> bool {
+        self.was_skipped
+    }
+
+    fn detected_charset(&self) -> Option<String> {
+        self.detected_charset.clone()
+    }
+
+    fn main_content_only(&self) -> bool {
+        self.main_content_only
+    }
+
+    fn auth_header_sent(&self) -> bool {
+        self.auth_header_sent
+    }
+
+    fn response_meta(&self) -> Option<ResponseMeta> {
+        self.response_meta.clone()
+    }
+
+    fn assets(&self) -> Vec<DownloadedAsset> {
+        self.assets.clone()
+    }
+
+    fn js_render_hint(&self) -> bool {
+        self.js_render_hint
+    }
+
+    fn browser_used(&self) -> bool {
+        self.browser_used
+    }
+
+    fn markdown(&self) -> Option<MarkdownResult> {
+        self.markdown.clone()
+    }
+
+    fn extracted_data(&self) -> Option<String> {
+        self.extracted_data.clone()
+    }
+
+    fn extraction_meta(&self) -> Option<ExtractionMeta> {
+        self.extraction_meta.clone()
+    }
+
+    fn screenshot(&self) -> Option<Vec<u8>> {
+        self.screenshot.clone()
+    }
+
+    fn downloaded_document(&self) -> Option<DownloadedDocument> {
+        self.downloaded_document.clone()
+    }
+}
+
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
+#[magnus::wrap(class = "Kreuzcrawl::CrawlPageResult")]
+#[serde(default)]
+pub struct CrawlPageResult {
+    pub url: String,
+    pub normalized_url: String,
+    pub status_code: u16,
+    pub content_type: String,
+    pub html: String,
+    pub body_size: usize,
+    pub metadata: PageMetadata,
+    pub links: Vec<LinkInfo>,
+    pub images: Vec<ImageInfo>,
+    pub feeds: Vec<FeedInfo>,
+    pub json_ld: Vec<JsonLdEntry>,
+    pub depth: usize,
+    pub stayed_on_domain: bool,
+    pub was_skipped: bool,
+    pub is_pdf: bool,
+    pub detected_charset: Option<String>,
+    pub markdown: Option<MarkdownResult>,
+    pub extracted_data: Option<String>,
+    pub extraction_meta: Option<ExtractionMeta>,
+    pub downloaded_document: Option<DownloadedDocument>,
+}
+
+unsafe impl IntoValueFromNative for CrawlPageResult {}
+
+impl magnus::TryConvert for CrawlPageResult {
+    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
+        let r: &CrawlPageResult = magnus::TryConvert::try_convert(val)?;
+        Ok(r.clone())
+    }
+}
+unsafe impl TryConvertOwned for CrawlPageResult {}
+
+impl Default for CrawlPageResult {
+    fn default() -> Self {
+        Self {
+            url: Default::default(),
+            normalized_url: Default::default(),
+            status_code: Default::default(),
+            content_type: Default::default(),
+            html: Default::default(),
+            body_size: Default::default(),
+            metadata: Default::default(),
+            links: Default::default(),
+            images: Default::default(),
+            feeds: Default::default(),
+            json_ld: Default::default(),
+            depth: Default::default(),
+            stayed_on_domain: Default::default(),
+            was_skipped: Default::default(),
+            is_pdf: Default::default(),
+            detected_charset: Default::default(),
+            markdown: Default::default(),
+            extracted_data: Default::default(),
+            extraction_meta: Default::default(),
+            downloaded_document: Default::default(),
+        }
+    }
+}
+
+impl CrawlPageResult {
+    fn new(kwargs: magnus::RHash) -> Result<Self, magnus::Error> {
+        let ruby = unsafe { magnus::Ruby::get_unchecked() };
+        Ok(Self {
+            url: kwargs
+                .get(ruby.to_symbol("url"))
+                .and_then(|v| String::try_convert(v).ok())
+                .unwrap_or_default(),
+            normalized_url: kwargs
+                .get(ruby.to_symbol("normalized_url"))
+                .and_then(|v| String::try_convert(v).ok())
+                .unwrap_or_default(),
+            status_code: kwargs
+                .get(ruby.to_symbol("status_code"))
+                .and_then(|v| u16::try_convert(v).ok())
+                .unwrap_or_default(),
+            content_type: kwargs
+                .get(ruby.to_symbol("content_type"))
+                .and_then(|v| String::try_convert(v).ok())
+                .unwrap_or_default(),
+            html: kwargs
+                .get(ruby.to_symbol("html"))
+                .and_then(|v| String::try_convert(v).ok())
+                .unwrap_or_default(),
+            body_size: kwargs
+                .get(ruby.to_symbol("body_size"))
+                .and_then(|v| usize::try_convert(v).ok())
+                .unwrap_or_default(),
+            metadata: kwargs
+                .get(ruby.to_symbol("metadata"))
+                .and_then(|v| PageMetadata::try_convert(v).ok())
+                .unwrap_or_default(),
+            links: kwargs
+                .get(ruby.to_symbol("links"))
+                .and_then(|v| <Vec<LinkInfo>>::try_convert(v).ok())
+                .unwrap_or_default(),
+            images: kwargs
+                .get(ruby.to_symbol("images"))
+                .and_then(|v| <Vec<ImageInfo>>::try_convert(v).ok())
+                .unwrap_or_default(),
+            feeds: kwargs
+                .get(ruby.to_symbol("feeds"))
+                .and_then(|v| <Vec<FeedInfo>>::try_convert(v).ok())
+                .unwrap_or_default(),
+            json_ld: kwargs
+                .get(ruby.to_symbol("json_ld"))
+                .and_then(|v| <Vec<JsonLdEntry>>::try_convert(v).ok())
+                .unwrap_or_default(),
+            depth: kwargs
+                .get(ruby.to_symbol("depth"))
+                .and_then(|v| usize::try_convert(v).ok())
+                .unwrap_or_default(),
+            stayed_on_domain: kwargs
+                .get(ruby.to_symbol("stayed_on_domain"))
+                .and_then(|v| bool::try_convert(v).ok())
+                .unwrap_or_default(),
+            was_skipped: kwargs
+                .get(ruby.to_symbol("was_skipped"))
+                .and_then(|v| bool::try_convert(v).ok())
+                .unwrap_or_default(),
+            is_pdf: kwargs
+                .get(ruby.to_symbol("is_pdf"))
+                .and_then(|v| bool::try_convert(v).ok())
+                .unwrap_or_default(),
+            detected_charset: kwargs
+                .get(ruby.to_symbol("detected_charset"))
+                .and_then(|v| String::try_convert(v).ok()),
+            markdown: kwargs
+                .get(ruby.to_symbol("markdown"))
+                .and_then(|v| MarkdownResult::try_convert(v).ok()),
+            extracted_data: kwargs
+                .get(ruby.to_symbol("extracted_data"))
+                .and_then(|v| String::try_convert(v).ok()),
+            extraction_meta: kwargs
+                .get(ruby.to_symbol("extraction_meta"))
+                .and_then(|v| ExtractionMeta::try_convert(v).ok()),
+            downloaded_document: kwargs
+                .get(ruby.to_symbol("downloaded_document"))
+                .and_then(|v| DownloadedDocument::try_convert(v).ok()),
+        })
+    }
+
+    fn url(&self) -> String {
+        self.url.clone()
+    }
+
+    fn normalized_url(&self) -> String {
+        self.normalized_url.clone()
+    }
+
+    fn status_code(&self) -> u16 {
+        self.status_code
+    }
+
+    fn content_type(&self) -> String {
+        self.content_type.clone()
+    }
+
+    fn html(&self) -> String {
+        self.html.clone()
+    }
+
+    fn body_size(&self) -> usize {
+        self.body_size
+    }
+
+    fn metadata(&self) -> PageMetadata {
+        self.metadata.clone()
+    }
+
+    fn links(&self) -> Vec<LinkInfo> {
+        self.links.clone()
+    }
+
+    fn images(&self) -> Vec<ImageInfo> {
+        self.images.clone()
+    }
+
+    fn feeds(&self) -> Vec<FeedInfo> {
+        self.feeds.clone()
+    }
+
+    fn json_ld(&self) -> Vec<JsonLdEntry> {
+        self.json_ld.clone()
+    }
+
+    fn depth(&self) -> usize {
+        self.depth
+    }
+
+    fn stayed_on_domain(&self) -> bool {
+        self.stayed_on_domain
+    }
+
+    fn was_skipped(&self) -> bool {
+        self.was_skipped
+    }
+
+    fn is_pdf(&self) -> bool {
+        self.is_pdf
+    }
+
+    fn detected_charset(&self) -> Option<String> {
+        self.detected_charset.clone()
+    }
+
+    fn markdown(&self) -> Option<MarkdownResult> {
+        self.markdown.clone()
+    }
+
+    fn extracted_data(&self) -> Option<String> {
+        self.extracted_data.clone()
+    }
+
+    fn extraction_meta(&self) -> Option<ExtractionMeta> {
+        self.extraction_meta.clone()
+    }
+
+    fn downloaded_document(&self) -> Option<DownloadedDocument> {
+        self.downloaded_document.clone()
+    }
+}
+
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
+#[magnus::wrap(class = "Kreuzcrawl::CrawlResult")]
+#[serde(default)]
+pub struct CrawlResult {
+    pub pages: Vec<CrawlPageResult>,
+    pub final_url: String,
+    pub redirect_count: usize,
+    pub was_skipped: bool,
+    pub error: Option<String>,
+    pub cookies: Vec<CookieInfo>,
+    pub normalized_urls: Vec<String>,
+}
+
+unsafe impl IntoValueFromNative for CrawlResult {}
+
+impl magnus::TryConvert for CrawlResult {
+    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
+        let r: &CrawlResult = magnus::TryConvert::try_convert(val)?;
+        Ok(r.clone())
+    }
+}
+unsafe impl TryConvertOwned for CrawlResult {}
+
+impl Default for CrawlResult {
+    fn default() -> Self {
+        Self {
+            pages: Default::default(),
+            final_url: Default::default(),
+            redirect_count: Default::default(),
+            was_skipped: Default::default(),
+            error: Default::default(),
+            cookies: Default::default(),
+            normalized_urls: Default::default(),
+        }
+    }
+}
+
+impl CrawlResult {
+    fn new(
+        pages: Option<Vec<CrawlPageResult>>,
+        final_url: Option<String>,
+        redirect_count: Option<usize>,
+        was_skipped: Option<bool>,
+        error: Option<String>,
+        cookies: Option<Vec<CookieInfo>>,
+        normalized_urls: Option<Vec<String>>,
+    ) -> Self {
+        Self {
+            pages: pages.unwrap_or_default(),
+            final_url: final_url.unwrap_or_default(),
+            redirect_count: redirect_count.unwrap_or_default(),
+            was_skipped: was_skipped.unwrap_or_default(),
+            error,
+            cookies: cookies.unwrap_or_default(),
+            normalized_urls: normalized_urls.unwrap_or_default(),
+        }
+    }
+
+    fn pages(&self) -> Vec<CrawlPageResult> {
+        self.pages.clone()
+    }
+
+    fn final_url(&self) -> String {
+        self.final_url.clone()
+    }
+
+    fn redirect_count(&self) -> usize {
+        self.redirect_count
+    }
+
+    fn was_skipped(&self) -> bool {
+        self.was_skipped
+    }
+
+    fn error(&self) -> Option<String> {
+        self.error.clone()
+    }
+
+    fn cookies(&self) -> Vec<CookieInfo> {
+        self.cookies.clone()
+    }
+
+    fn normalized_urls(&self) -> Vec<String> {
+        self.normalized_urls.clone()
+    }
+}
+
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
+#[magnus::wrap(class = "Kreuzcrawl::SitemapUrl")]
+#[serde(default)]
+pub struct SitemapUrl {
+    pub url: String,
+    pub lastmod: Option<String>,
+    pub changefreq: Option<String>,
+    pub priority: Option<String>,
+}
+
+unsafe impl IntoValueFromNative for SitemapUrl {}
+
+impl magnus::TryConvert for SitemapUrl {
+    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
+        let r: &SitemapUrl = magnus::TryConvert::try_convert(val)?;
+        Ok(r.clone())
+    }
+}
+unsafe impl TryConvertOwned for SitemapUrl {}
+
+impl Default for SitemapUrl {
+    fn default() -> Self {
+        Self {
+            url: Default::default(),
+            lastmod: Default::default(),
+            changefreq: Default::default(),
+            priority: Default::default(),
+        }
+    }
+}
+
+impl SitemapUrl {
+    fn new(url: Option<String>, lastmod: Option<String>, changefreq: Option<String>, priority: Option<String>) -> Self {
+        Self {
+            url: url.unwrap_or_default(),
+            lastmod,
+            changefreq,
+            priority,
+        }
+    }
+
+    fn url(&self) -> String {
+        self.url.clone()
+    }
+
+    fn lastmod(&self) -> Option<String> {
+        self.lastmod.clone()
+    }
+
+    fn changefreq(&self) -> Option<String> {
+        self.changefreq.clone()
+    }
+
+    fn priority(&self) -> Option<String> {
+        self.priority.clone()
+    }
+}
+
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
+#[magnus::wrap(class = "Kreuzcrawl::MapResult")]
+#[serde(default)]
+pub struct MapResult {
+    pub urls: Vec<SitemapUrl>,
+}
+
+unsafe impl IntoValueFromNative for MapResult {}
+
+impl magnus::TryConvert for MapResult {
+    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
+        let r: &MapResult = magnus::TryConvert::try_convert(val)?;
+        Ok(r.clone())
+    }
+}
+unsafe impl TryConvertOwned for MapResult {}
+
+impl Default for MapResult {
+    fn default() -> Self {
+        Self {
+            urls: Default::default(),
+        }
+    }
+}
+
+impl MapResult {
+    fn new(urls: Option<Vec<SitemapUrl>>) -> Self {
+        Self {
+            urls: urls.unwrap_or_default(),
+        }
+    }
+
+    fn urls(&self) -> Vec<SitemapUrl> {
+        self.urls.clone()
+    }
+}
+
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
+#[magnus::wrap(class = "Kreuzcrawl::MarkdownResult")]
+#[serde(default)]
+pub struct MarkdownResult {
+    pub content: String,
+    pub document_structure: Option<String>,
+    pub tables: Vec<String>,
+    pub warnings: Vec<String>,
+    pub citations: Option<CitationResult>,
+    pub fit_content: Option<String>,
+}
+
+unsafe impl IntoValueFromNative for MarkdownResult {}
+
+impl magnus::TryConvert for MarkdownResult {
+    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
+        let r: &MarkdownResult = magnus::TryConvert::try_convert(val)?;
+        Ok(r.clone())
+    }
+}
+unsafe impl TryConvertOwned for MarkdownResult {}
+
+impl Default for MarkdownResult {
+    fn default() -> Self {
+        Self {
+            content: Default::default(),
+            document_structure: Default::default(),
+            tables: Default::default(),
+            warnings: Default::default(),
+            citations: Default::default(),
+            fit_content: Default::default(),
+        }
+    }
+}
+
+impl MarkdownResult {
+    fn new(
+        content: Option<String>,
+        document_structure: Option<String>,
+        tables: Option<Vec<String>>,
+        warnings: Option<Vec<String>>,
+        citations: Option<CitationResult>,
+        fit_content: Option<String>,
+    ) -> Self {
+        Self {
+            content: content.unwrap_or_default(),
+            document_structure,
+            tables: tables.unwrap_or_default(),
+            warnings: warnings.unwrap_or_default(),
+            citations,
+            fit_content,
+        }
+    }
+
+    fn content(&self) -> String {
+        self.content.clone()
+    }
+
+    fn document_structure(&self) -> Option<String> {
+        self.document_structure.clone()
+    }
+
+    fn tables(&self) -> Vec<String> {
+        self.tables.clone()
+    }
+
+    fn warnings(&self) -> Vec<String> {
+        self.warnings.clone()
+    }
+
+    fn citations(&self) -> Option<CitationResult> {
+        self.citations.clone()
+    }
+
+    fn fit_content(&self) -> Option<String> {
+        self.fit_content.clone()
+    }
+}
+
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
+#[magnus::wrap(class = "Kreuzcrawl::CachedPage")]
+#[serde(default)]
+pub struct CachedPage {
+    pub url: String,
+    pub status_code: u16,
+    pub content_type: String,
+    pub body: String,
+    pub etag: Option<String>,
+    pub last_modified: Option<String>,
+    pub cached_at: u64,
+}
+
+unsafe impl IntoValueFromNative for CachedPage {}
+
+impl magnus::TryConvert for CachedPage {
+    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
+        let r: &CachedPage = magnus::TryConvert::try_convert(val)?;
+        Ok(r.clone())
+    }
+}
+unsafe impl TryConvertOwned for CachedPage {}
+
+impl Default for CachedPage {
+    fn default() -> Self {
+        Self {
+            url: Default::default(),
+            status_code: Default::default(),
+            content_type: Default::default(),
+            body: Default::default(),
+            etag: Default::default(),
+            last_modified: Default::default(),
+            cached_at: Default::default(),
+        }
+    }
+}
+
+impl CachedPage {
+    fn new(
+        url: Option<String>,
+        status_code: Option<u16>,
+        content_type: Option<String>,
+        body: Option<String>,
+        etag: Option<String>,
+        last_modified: Option<String>,
+        cached_at: Option<u64>,
+    ) -> Self {
+        Self {
+            url: url.unwrap_or_default(),
+            status_code: status_code.unwrap_or_default(),
+            content_type: content_type.unwrap_or_default(),
+            body: body.unwrap_or_default(),
+            etag,
+            last_modified,
+            cached_at: cached_at.unwrap_or_default(),
+        }
+    }
+
+    fn url(&self) -> String {
+        self.url.clone()
+    }
+
+    fn status_code(&self) -> u16 {
+        self.status_code
+    }
+
+    fn content_type(&self) -> String {
+        self.content_type.clone()
+    }
+
+    fn body(&self) -> String {
+        self.body.clone()
+    }
+
+    fn etag(&self) -> Option<String> {
+        self.etag.clone()
+    }
+
+    fn last_modified(&self) -> Option<String> {
+        self.last_modified.clone()
+    }
+
+    fn cached_at(&self) -> u64 {
+        self.cached_at
+    }
+}
+
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize, Default)]
+#[magnus::wrap(class = "Kreuzcrawl::LinkInfo")]
+#[serde(default)]
+pub struct LinkInfo {
+    pub url: String,
+    pub text: String,
+    pub link_type: LinkType,
+    pub rel: Option<String>,
+    pub nofollow: bool,
+}
+
+unsafe impl IntoValueFromNative for LinkInfo {}
+
+impl magnus::TryConvert for LinkInfo {
+    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
+        let r: &LinkInfo = magnus::TryConvert::try_convert(val)?;
+        Ok(r.clone())
+    }
+}
+unsafe impl TryConvertOwned for LinkInfo {}
+
+impl LinkInfo {
+    fn new(
+        url: Option<String>,
+        text: Option<String>,
+        link_type: Option<LinkType>,
+        rel: Option<String>,
+        nofollow: Option<bool>,
+    ) -> Self {
+        Self {
+            url: url.unwrap_or_default(),
+            text: text.unwrap_or_default(),
+            link_type: link_type.unwrap_or_default(),
+            rel,
+            nofollow: nofollow.unwrap_or_default(),
+        }
+    }
+
+    fn url(&self) -> String {
+        self.url.clone()
+    }
+
+    fn text(&self) -> String {
+        self.text.clone()
+    }
+
+    fn link_type(&self) -> LinkType {
+        self.link_type.clone()
+    }
+
+    fn rel(&self) -> Option<String> {
+        self.rel.clone()
+    }
+
+    fn nofollow(&self) -> bool {
+        self.nofollow
+    }
+}
+
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize, Default)]
+#[magnus::wrap(class = "Kreuzcrawl::ImageInfo")]
+#[serde(default)]
+pub struct ImageInfo {
+    pub url: String,
+    pub alt: Option<String>,
+    pub width: Option<u32>,
+    pub height: Option<u32>,
+    pub source: ImageSource,
+}
+
+unsafe impl IntoValueFromNative for ImageInfo {}
+
+impl magnus::TryConvert for ImageInfo {
+    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
+        let r: &ImageInfo = magnus::TryConvert::try_convert(val)?;
+        Ok(r.clone())
+    }
+}
+unsafe impl TryConvertOwned for ImageInfo {}
+
+impl ImageInfo {
+    fn new(
+        url: Option<String>,
+        alt: Option<String>,
+        width: Option<u32>,
+        height: Option<u32>,
+        source: Option<ImageSource>,
+    ) -> Self {
+        Self {
+            url: url.unwrap_or_default(),
+            alt,
+            width,
+            height,
+            source: source.unwrap_or_default(),
+        }
+    }
+
+    fn url(&self) -> String {
+        self.url.clone()
+    }
+
+    fn alt(&self) -> Option<String> {
+        self.alt.clone()
+    }
+
+    fn width(&self) -> Option<u32> {
+        self.width
+    }
+
+    fn height(&self) -> Option<u32> {
+        self.height
+    }
+
+    fn source(&self) -> ImageSource {
+        self.source.clone()
+    }
+}
+
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize, Default)]
+#[magnus::wrap(class = "Kreuzcrawl::FeedInfo")]
+#[serde(default)]
+pub struct FeedInfo {
+    pub url: String,
+    pub title: Option<String>,
+    pub feed_type: FeedType,
+}
+
+unsafe impl IntoValueFromNative for FeedInfo {}
+
+impl magnus::TryConvert for FeedInfo {
+    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
+        let r: &FeedInfo = magnus::TryConvert::try_convert(val)?;
+        Ok(r.clone())
+    }
+}
+unsafe impl TryConvertOwned for FeedInfo {}
+
+impl FeedInfo {
+    fn new(url: Option<String>, title: Option<String>, feed_type: Option<FeedType>) -> Self {
+        Self {
+            url: url.unwrap_or_default(),
+            title,
+            feed_type: feed_type.unwrap_or_default(),
+        }
+    }
+
+    fn url(&self) -> String {
+        self.url.clone()
+    }
+
+    fn title(&self) -> Option<String> {
+        self.title.clone()
+    }
+
+    fn feed_type(&self) -> FeedType {
+        self.feed_type.clone()
+    }
+}
+
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
+#[magnus::wrap(class = "Kreuzcrawl::JsonLdEntry")]
+#[serde(default)]
+pub struct JsonLdEntry {
+    pub schema_type: String,
+    pub name: Option<String>,
+    pub raw: String,
+}
+
+unsafe impl IntoValueFromNative for JsonLdEntry {}
+
+impl magnus::TryConvert for JsonLdEntry {
+    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
+        let r: &JsonLdEntry = magnus::TryConvert::try_convert(val)?;
+        Ok(r.clone())
+    }
+}
+unsafe impl TryConvertOwned for JsonLdEntry {}
+
+impl Default for JsonLdEntry {
+    fn default() -> Self {
+        Self {
+            schema_type: Default::default(),
+            name: Default::default(),
+            raw: Default::default(),
+        }
+    }
+}
+
+impl JsonLdEntry {
+    fn new(schema_type: Option<String>, name: Option<String>, raw: Option<String>) -> Self {
+        Self {
+            schema_type: schema_type.unwrap_or_default(),
+            name,
+            raw: raw.unwrap_or_default(),
+        }
+    }
+
+    fn schema_type(&self) -> String {
+        self.schema_type.clone()
+    }
+
+    fn name(&self) -> Option<String> {
+        self.name.clone()
+    }
+
+    fn raw(&self) -> String {
+        self.raw.clone()
+    }
+}
+
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
+#[magnus::wrap(class = "Kreuzcrawl::CookieInfo")]
+#[serde(default)]
+pub struct CookieInfo {
+    pub name: String,
+    pub value: String,
+    pub domain: Option<String>,
+    pub path: Option<String>,
+}
+
+unsafe impl IntoValueFromNative for CookieInfo {}
+
+impl magnus::TryConvert for CookieInfo {
+    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
+        let r: &CookieInfo = magnus::TryConvert::try_convert(val)?;
+        Ok(r.clone())
+    }
+}
+unsafe impl TryConvertOwned for CookieInfo {}
+
+impl Default for CookieInfo {
+    fn default() -> Self {
+        Self {
+            name: Default::default(),
+            value: Default::default(),
+            domain: Default::default(),
+            path: Default::default(),
+        }
+    }
+}
+
+impl CookieInfo {
+    fn new(name: Option<String>, value: Option<String>, domain: Option<String>, path: Option<String>) -> Self {
+        Self {
+            name: name.unwrap_or_default(),
+            value: value.unwrap_or_default(),
+            domain,
+            path,
+        }
+    }
+
+    fn name(&self) -> String {
+        self.name.clone()
+    }
+
+    fn value(&self) -> String {
+        self.value.clone()
+    }
+
+    fn domain(&self) -> Option<String> {
+        self.domain.clone()
+    }
+
+    fn path(&self) -> Option<String> {
+        self.path.clone()
+    }
+}
+
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize, Default)]
+#[magnus::wrap(class = "Kreuzcrawl::DownloadedAsset")]
+#[serde(default)]
+pub struct DownloadedAsset {
+    pub url: String,
+    pub content_hash: String,
+    pub mime_type: Option<String>,
+    pub size: usize,
+    pub asset_category: AssetCategory,
+    pub html_tag: Option<String>,
+}
+
+unsafe impl IntoValueFromNative for DownloadedAsset {}
+
+impl magnus::TryConvert for DownloadedAsset {
+    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
+        let r: &DownloadedAsset = magnus::TryConvert::try_convert(val)?;
+        Ok(r.clone())
+    }
+}
+unsafe impl TryConvertOwned for DownloadedAsset {}
+
+impl DownloadedAsset {
+    fn new(
+        url: Option<String>,
+        content_hash: Option<String>,
+        mime_type: Option<String>,
+        size: Option<usize>,
+        asset_category: Option<AssetCategory>,
+        html_tag: Option<String>,
+    ) -> Self {
+        Self {
+            url: url.unwrap_or_default(),
+            content_hash: content_hash.unwrap_or_default(),
+            mime_type,
+            size: size.unwrap_or_default(),
+            asset_category: asset_category.unwrap_or_default(),
+            html_tag,
+        }
+    }
+
+    fn url(&self) -> String {
+        self.url.clone()
+    }
+
+    fn content_hash(&self) -> String {
+        self.content_hash.clone()
+    }
+
+    fn mime_type(&self) -> Option<String> {
+        self.mime_type.clone()
+    }
+
+    fn size(&self) -> usize {
+        self.size
+    }
+
+    fn asset_category(&self) -> AssetCategory {
+        self.asset_category.clone()
+    }
+
+    fn html_tag(&self) -> Option<String> {
+        self.html_tag.clone()
+    }
+}
+
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
+#[magnus::wrap(class = "Kreuzcrawl::ArticleMetadata")]
+#[serde(default)]
+pub struct ArticleMetadata {
+    pub published_time: Option<String>,
+    pub modified_time: Option<String>,
+    pub author: Option<String>,
+    pub section: Option<String>,
+    pub tags: Vec<String>,
+}
+
+unsafe impl IntoValueFromNative for ArticleMetadata {}
+
+impl magnus::TryConvert for ArticleMetadata {
+    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
+        let r: &ArticleMetadata = magnus::TryConvert::try_convert(val)?;
+        Ok(r.clone())
+    }
+}
+unsafe impl TryConvertOwned for ArticleMetadata {}
+
+impl Default for ArticleMetadata {
+    fn default() -> Self {
+        Self {
+            published_time: Default::default(),
+            modified_time: Default::default(),
+            author: Default::default(),
+            section: Default::default(),
+            tags: Default::default(),
+        }
+    }
+}
+
+impl ArticleMetadata {
+    fn new(
+        published_time: Option<String>,
+        modified_time: Option<String>,
+        author: Option<String>,
+        section: Option<String>,
+        tags: Option<Vec<String>>,
+    ) -> Self {
+        Self {
+            published_time,
+            modified_time,
+            author,
+            section,
+            tags: tags.unwrap_or_default(),
+        }
+    }
+
+    fn published_time(&self) -> Option<String> {
+        self.published_time.clone()
+    }
+
+    fn modified_time(&self) -> Option<String> {
+        self.modified_time.clone()
+    }
+
+    fn author(&self) -> Option<String> {
+        self.author.clone()
+    }
+
+    fn section(&self) -> Option<String> {
+        self.section.clone()
+    }
+
+    fn tags(&self) -> Vec<String> {
+        self.tags.clone()
+    }
+}
+
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
+#[magnus::wrap(class = "Kreuzcrawl::HreflangEntry")]
+#[serde(default)]
+pub struct HreflangEntry {
+    pub lang: String,
+    pub url: String,
+}
+
+unsafe impl IntoValueFromNative for HreflangEntry {}
+
+impl magnus::TryConvert for HreflangEntry {
+    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
+        let r: &HreflangEntry = magnus::TryConvert::try_convert(val)?;
+        Ok(r.clone())
+    }
+}
+unsafe impl TryConvertOwned for HreflangEntry {}
+
+impl Default for HreflangEntry {
+    fn default() -> Self {
+        Self {
+            lang: Default::default(),
+            url: Default::default(),
+        }
+    }
+}
+
+impl HreflangEntry {
+    fn new(lang: Option<String>, url: Option<String>) -> Self {
+        Self {
+            lang: lang.unwrap_or_default(),
+            url: url.unwrap_or_default(),
+        }
+    }
+
+    fn lang(&self) -> String {
+        self.lang.clone()
+    }
+
+    fn url(&self) -> String {
+        self.url.clone()
+    }
+}
+
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
+#[magnus::wrap(class = "Kreuzcrawl::FaviconInfo")]
+#[serde(default)]
+pub struct FaviconInfo {
+    pub url: String,
+    pub rel: String,
+    pub sizes: Option<String>,
+    pub mime_type: Option<String>,
+}
+
+unsafe impl IntoValueFromNative for FaviconInfo {}
+
+impl magnus::TryConvert for FaviconInfo {
+    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
+        let r: &FaviconInfo = magnus::TryConvert::try_convert(val)?;
+        Ok(r.clone())
+    }
+}
+unsafe impl TryConvertOwned for FaviconInfo {}
+
+impl Default for FaviconInfo {
+    fn default() -> Self {
+        Self {
+            url: Default::default(),
+            rel: Default::default(),
+            sizes: Default::default(),
+            mime_type: Default::default(),
+        }
+    }
+}
+
+impl FaviconInfo {
+    fn new(url: Option<String>, rel: Option<String>, sizes: Option<String>, mime_type: Option<String>) -> Self {
+        Self {
+            url: url.unwrap_or_default(),
+            rel: rel.unwrap_or_default(),
+            sizes,
+            mime_type,
+        }
+    }
+
+    fn url(&self) -> String {
+        self.url.clone()
+    }
+
+    fn rel(&self) -> String {
+        self.rel.clone()
+    }
+
+    fn sizes(&self) -> Option<String> {
+        self.sizes.clone()
+    }
+
+    fn mime_type(&self) -> Option<String> {
+        self.mime_type.clone()
+    }
+}
+
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
+#[magnus::wrap(class = "Kreuzcrawl::HeadingInfo")]
+#[serde(default)]
+pub struct HeadingInfo {
+    pub level: u8,
+    pub text: String,
+}
+
+unsafe impl IntoValueFromNative for HeadingInfo {}
+
+impl magnus::TryConvert for HeadingInfo {
+    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
+        let r: &HeadingInfo = magnus::TryConvert::try_convert(val)?;
+        Ok(r.clone())
+    }
+}
+unsafe impl TryConvertOwned for HeadingInfo {}
+
+impl Default for HeadingInfo {
+    fn default() -> Self {
+        Self {
+            level: Default::default(),
+            text: Default::default(),
+        }
+    }
+}
+
+impl HeadingInfo {
+    fn new(level: Option<u8>, text: Option<String>) -> Self {
+        Self {
+            level: level.unwrap_or_default(),
+            text: text.unwrap_or_default(),
+        }
+    }
+
+    fn level(&self) -> u8 {
+        self.level
+    }
+
+    fn text(&self) -> String {
+        self.text.clone()
+    }
+}
+
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
+#[magnus::wrap(class = "Kreuzcrawl::ResponseMeta")]
+#[serde(default)]
+pub struct ResponseMeta {
+    pub etag: Option<String>,
+    pub last_modified: Option<String>,
+    pub cache_control: Option<String>,
+    pub server: Option<String>,
+    pub x_powered_by: Option<String>,
+    pub content_language: Option<String>,
+    pub content_encoding: Option<String>,
+}
+
+unsafe impl IntoValueFromNative for ResponseMeta {}
+
+impl magnus::TryConvert for ResponseMeta {
+    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
+        let r: &ResponseMeta = magnus::TryConvert::try_convert(val)?;
+        Ok(r.clone())
+    }
+}
+unsafe impl TryConvertOwned for ResponseMeta {}
+
+impl Default for ResponseMeta {
+    fn default() -> Self {
+        Self {
+            etag: Default::default(),
+            last_modified: Default::default(),
+            cache_control: Default::default(),
+            server: Default::default(),
+            x_powered_by: Default::default(),
+            content_language: Default::default(),
+            content_encoding: Default::default(),
+        }
+    }
+}
+
+impl ResponseMeta {
+    fn new(
+        etag: Option<String>,
+        last_modified: Option<String>,
+        cache_control: Option<String>,
+        server: Option<String>,
+        x_powered_by: Option<String>,
+        content_language: Option<String>,
+        content_encoding: Option<String>,
+    ) -> Self {
+        Self {
+            etag,
+            last_modified,
+            cache_control,
+            server,
+            x_powered_by,
+            content_language,
+            content_encoding,
+        }
+    }
+
+    fn etag(&self) -> Option<String> {
+        self.etag.clone()
+    }
+
+    fn last_modified(&self) -> Option<String> {
+        self.last_modified.clone()
+    }
+
+    fn cache_control(&self) -> Option<String> {
+        self.cache_control.clone()
+    }
+
+    fn server(&self) -> Option<String> {
+        self.server.clone()
+    }
+
+    fn x_powered_by(&self) -> Option<String> {
+        self.x_powered_by.clone()
+    }
+
+    fn content_language(&self) -> Option<String> {
+        self.content_language.clone()
+    }
+
+    fn content_encoding(&self) -> Option<String> {
+        self.content_encoding.clone()
+    }
+}
+
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
+#[magnus::wrap(class = "Kreuzcrawl::PageMetadata")]
+#[serde(default)]
+pub struct PageMetadata {
+    pub title: Option<String>,
+    pub description: Option<String>,
+    pub canonical_url: Option<String>,
+    pub keywords: Option<String>,
+    pub author: Option<String>,
+    pub viewport: Option<String>,
+    pub theme_color: Option<String>,
+    pub generator: Option<String>,
+    pub robots: Option<String>,
+    pub html_lang: Option<String>,
+    pub html_dir: Option<String>,
+    pub og_title: Option<String>,
+    pub og_type: Option<String>,
+    pub og_image: Option<String>,
+    pub og_description: Option<String>,
+    pub og_url: Option<String>,
+    pub og_site_name: Option<String>,
+    pub og_locale: Option<String>,
+    pub og_video: Option<String>,
+    pub og_audio: Option<String>,
+    pub og_locale_alternates: Option<Vec<String>>,
+    pub twitter_card: Option<String>,
+    pub twitter_title: Option<String>,
+    pub twitter_description: Option<String>,
+    pub twitter_image: Option<String>,
+    pub twitter_site: Option<String>,
+    pub twitter_creator: Option<String>,
+    pub dc_title: Option<String>,
+    pub dc_creator: Option<String>,
+    pub dc_subject: Option<String>,
+    pub dc_description: Option<String>,
+    pub dc_publisher: Option<String>,
+    pub dc_date: Option<String>,
+    pub dc_type: Option<String>,
+    pub dc_format: Option<String>,
+    pub dc_identifier: Option<String>,
+    pub dc_language: Option<String>,
+    pub dc_rights: Option<String>,
+    pub article: Option<ArticleMetadata>,
+    pub hreflangs: Option<Vec<HreflangEntry>>,
+    pub favicons: Option<Vec<FaviconInfo>>,
+    pub headings: Option<Vec<HeadingInfo>>,
+    pub word_count: Option<usize>,
+}
+
+unsafe impl IntoValueFromNative for PageMetadata {}
+
+impl magnus::TryConvert for PageMetadata {
+    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
+        let r: &PageMetadata = magnus::TryConvert::try_convert(val)?;
+        Ok(r.clone())
+    }
+}
+unsafe impl TryConvertOwned for PageMetadata {}
+
+impl Default for PageMetadata {
+    fn default() -> Self {
+        Self {
+            title: Default::default(),
+            description: Default::default(),
+            canonical_url: Default::default(),
+            keywords: Default::default(),
+            author: Default::default(),
+            viewport: Default::default(),
+            theme_color: Default::default(),
+            generator: Default::default(),
+            robots: Default::default(),
+            html_lang: Default::default(),
+            html_dir: Default::default(),
+            og_title: Default::default(),
+            og_type: Default::default(),
+            og_image: Default::default(),
+            og_description: Default::default(),
+            og_url: Default::default(),
+            og_site_name: Default::default(),
+            og_locale: Default::default(),
+            og_video: Default::default(),
+            og_audio: Default::default(),
+            og_locale_alternates: Default::default(),
+            twitter_card: Default::default(),
+            twitter_title: Default::default(),
+            twitter_description: Default::default(),
+            twitter_image: Default::default(),
+            twitter_site: Default::default(),
+            twitter_creator: Default::default(),
+            dc_title: Default::default(),
+            dc_creator: Default::default(),
+            dc_subject: Default::default(),
+            dc_description: Default::default(),
+            dc_publisher: Default::default(),
+            dc_date: Default::default(),
+            dc_type: Default::default(),
+            dc_format: Default::default(),
+            dc_identifier: Default::default(),
+            dc_language: Default::default(),
+            dc_rights: Default::default(),
+            article: Default::default(),
+            hreflangs: Default::default(),
+            favicons: Default::default(),
+            headings: Default::default(),
+            word_count: Default::default(),
+        }
+    }
+}
+
+impl PageMetadata {
+    fn new(kwargs: magnus::RHash) -> Result<Self, magnus::Error> {
+        let ruby = unsafe { magnus::Ruby::get_unchecked() };
+        Ok(Self {
+            title: kwargs
+                .get(ruby.to_symbol("title"))
+                .and_then(|v| String::try_convert(v).ok()),
+            description: kwargs
+                .get(ruby.to_symbol("description"))
+                .and_then(|v| String::try_convert(v).ok()),
+            canonical_url: kwargs
+                .get(ruby.to_symbol("canonical_url"))
+                .and_then(|v| String::try_convert(v).ok()),
+            keywords: kwargs
+                .get(ruby.to_symbol("keywords"))
+                .and_then(|v| String::try_convert(v).ok()),
+            author: kwargs
+                .get(ruby.to_symbol("author"))
+                .and_then(|v| String::try_convert(v).ok()),
+            viewport: kwargs
+                .get(ruby.to_symbol("viewport"))
+                .and_then(|v| String::try_convert(v).ok()),
+            theme_color: kwargs
+                .get(ruby.to_symbol("theme_color"))
+                .and_then(|v| String::try_convert(v).ok()),
+            generator: kwargs
+                .get(ruby.to_symbol("generator"))
+                .and_then(|v| String::try_convert(v).ok()),
+            robots: kwargs
+                .get(ruby.to_symbol("robots"))
+                .and_then(|v| String::try_convert(v).ok()),
+            html_lang: kwargs
+                .get(ruby.to_symbol("html_lang"))
+                .and_then(|v| String::try_convert(v).ok()),
+            html_dir: kwargs
+                .get(ruby.to_symbol("html_dir"))
+                .and_then(|v| String::try_convert(v).ok()),
+            og_title: kwargs
+                .get(ruby.to_symbol("og_title"))
+                .and_then(|v| String::try_convert(v).ok()),
+            og_type: kwargs
+                .get(ruby.to_symbol("og_type"))
+                .and_then(|v| String::try_convert(v).ok()),
+            og_image: kwargs
+                .get(ruby.to_symbol("og_image"))
+                .and_then(|v| String::try_convert(v).ok()),
+            og_description: kwargs
+                .get(ruby.to_symbol("og_description"))
+                .and_then(|v| String::try_convert(v).ok()),
+            og_url: kwargs
+                .get(ruby.to_symbol("og_url"))
+                .and_then(|v| String::try_convert(v).ok()),
+            og_site_name: kwargs
+                .get(ruby.to_symbol("og_site_name"))
+                .and_then(|v| String::try_convert(v).ok()),
+            og_locale: kwargs
+                .get(ruby.to_symbol("og_locale"))
+                .and_then(|v| String::try_convert(v).ok()),
+            og_video: kwargs
+                .get(ruby.to_symbol("og_video"))
+                .and_then(|v| String::try_convert(v).ok()),
+            og_audio: kwargs
+                .get(ruby.to_symbol("og_audio"))
+                .and_then(|v| String::try_convert(v).ok()),
+            og_locale_alternates: kwargs
+                .get(ruby.to_symbol("og_locale_alternates"))
+                .and_then(|v| <Vec<String>>::try_convert(v).ok()),
+            twitter_card: kwargs
+                .get(ruby.to_symbol("twitter_card"))
+                .and_then(|v| String::try_convert(v).ok()),
+            twitter_title: kwargs
+                .get(ruby.to_symbol("twitter_title"))
+                .and_then(|v| String::try_convert(v).ok()),
+            twitter_description: kwargs
+                .get(ruby.to_symbol("twitter_description"))
+                .and_then(|v| String::try_convert(v).ok()),
+            twitter_image: kwargs
+                .get(ruby.to_symbol("twitter_image"))
+                .and_then(|v| String::try_convert(v).ok()),
+            twitter_site: kwargs
+                .get(ruby.to_symbol("twitter_site"))
+                .and_then(|v| String::try_convert(v).ok()),
+            twitter_creator: kwargs
+                .get(ruby.to_symbol("twitter_creator"))
+                .and_then(|v| String::try_convert(v).ok()),
+            dc_title: kwargs
+                .get(ruby.to_symbol("dc_title"))
+                .and_then(|v| String::try_convert(v).ok()),
+            dc_creator: kwargs
+                .get(ruby.to_symbol("dc_creator"))
+                .and_then(|v| String::try_convert(v).ok()),
+            dc_subject: kwargs
+                .get(ruby.to_symbol("dc_subject"))
+                .and_then(|v| String::try_convert(v).ok()),
+            dc_description: kwargs
+                .get(ruby.to_symbol("dc_description"))
+                .and_then(|v| String::try_convert(v).ok()),
+            dc_publisher: kwargs
+                .get(ruby.to_symbol("dc_publisher"))
+                .and_then(|v| String::try_convert(v).ok()),
+            dc_date: kwargs
+                .get(ruby.to_symbol("dc_date"))
+                .and_then(|v| String::try_convert(v).ok()),
+            dc_type: kwargs
+                .get(ruby.to_symbol("dc_type"))
+                .and_then(|v| String::try_convert(v).ok()),
+            dc_format: kwargs
+                .get(ruby.to_symbol("dc_format"))
+                .and_then(|v| String::try_convert(v).ok()),
+            dc_identifier: kwargs
+                .get(ruby.to_symbol("dc_identifier"))
+                .and_then(|v| String::try_convert(v).ok()),
+            dc_language: kwargs
+                .get(ruby.to_symbol("dc_language"))
+                .and_then(|v| String::try_convert(v).ok()),
+            dc_rights: kwargs
+                .get(ruby.to_symbol("dc_rights"))
+                .and_then(|v| String::try_convert(v).ok()),
+            article: kwargs
+                .get(ruby.to_symbol("article"))
+                .and_then(|v| ArticleMetadata::try_convert(v).ok()),
+            hreflangs: kwargs
+                .get(ruby.to_symbol("hreflangs"))
+                .and_then(|v| <Vec<HreflangEntry>>::try_convert(v).ok()),
+            favicons: kwargs
+                .get(ruby.to_symbol("favicons"))
+                .and_then(|v| <Vec<FaviconInfo>>::try_convert(v).ok()),
+            headings: kwargs
+                .get(ruby.to_symbol("headings"))
+                .and_then(|v| <Vec<HeadingInfo>>::try_convert(v).ok()),
+            word_count: kwargs
+                .get(ruby.to_symbol("word_count"))
+                .and_then(|v| usize::try_convert(v).ok()),
+        })
+    }
+
+    fn title(&self) -> Option<String> {
+        self.title.clone()
+    }
+
+    fn description(&self) -> Option<String> {
+        self.description.clone()
+    }
+
+    fn canonical_url(&self) -> Option<String> {
+        self.canonical_url.clone()
+    }
+
+    fn keywords(&self) -> Option<String> {
+        self.keywords.clone()
+    }
+
+    fn author(&self) -> Option<String> {
+        self.author.clone()
+    }
+
+    fn viewport(&self) -> Option<String> {
+        self.viewport.clone()
+    }
+
+    fn theme_color(&self) -> Option<String> {
+        self.theme_color.clone()
+    }
+
+    fn generator(&self) -> Option<String> {
+        self.generator.clone()
+    }
+
+    fn robots(&self) -> Option<String> {
+        self.robots.clone()
+    }
+
+    fn html_lang(&self) -> Option<String> {
+        self.html_lang.clone()
+    }
+
+    fn html_dir(&self) -> Option<String> {
+        self.html_dir.clone()
+    }
+
+    fn og_title(&self) -> Option<String> {
+        self.og_title.clone()
+    }
+
+    fn og_type(&self) -> Option<String> {
+        self.og_type.clone()
+    }
+
+    fn og_image(&self) -> Option<String> {
+        self.og_image.clone()
+    }
+
+    fn og_description(&self) -> Option<String> {
+        self.og_description.clone()
+    }
+
+    fn og_url(&self) -> Option<String> {
+        self.og_url.clone()
+    }
+
+    fn og_site_name(&self) -> Option<String> {
+        self.og_site_name.clone()
+    }
+
+    fn og_locale(&self) -> Option<String> {
+        self.og_locale.clone()
+    }
+
+    fn og_video(&self) -> Option<String> {
+        self.og_video.clone()
+    }
+
+    fn og_audio(&self) -> Option<String> {
+        self.og_audio.clone()
+    }
+
+    fn og_locale_alternates(&self) -> Option<Vec<String>> {
+        self.og_locale_alternates.clone()
+    }
+
+    fn twitter_card(&self) -> Option<String> {
+        self.twitter_card.clone()
+    }
+
+    fn twitter_title(&self) -> Option<String> {
+        self.twitter_title.clone()
+    }
+
+    fn twitter_description(&self) -> Option<String> {
+        self.twitter_description.clone()
+    }
+
+    fn twitter_image(&self) -> Option<String> {
+        self.twitter_image.clone()
+    }
+
+    fn twitter_site(&self) -> Option<String> {
+        self.twitter_site.clone()
+    }
+
+    fn twitter_creator(&self) -> Option<String> {
+        self.twitter_creator.clone()
+    }
+
+    fn dc_title(&self) -> Option<String> {
+        self.dc_title.clone()
+    }
+
+    fn dc_creator(&self) -> Option<String> {
+        self.dc_creator.clone()
+    }
+
+    fn dc_subject(&self) -> Option<String> {
+        self.dc_subject.clone()
+    }
+
+    fn dc_description(&self) -> Option<String> {
+        self.dc_description.clone()
+    }
+
+    fn dc_publisher(&self) -> Option<String> {
+        self.dc_publisher.clone()
+    }
+
+    fn dc_date(&self) -> Option<String> {
+        self.dc_date.clone()
+    }
+
+    fn dc_type(&self) -> Option<String> {
+        self.dc_type.clone()
+    }
+
+    fn dc_format(&self) -> Option<String> {
+        self.dc_format.clone()
+    }
+
+    fn dc_identifier(&self) -> Option<String> {
+        self.dc_identifier.clone()
+    }
+
+    fn dc_language(&self) -> Option<String> {
+        self.dc_language.clone()
+    }
+
+    fn dc_rights(&self) -> Option<String> {
+        self.dc_rights.clone()
+    }
+
+    fn article(&self) -> Option<ArticleMetadata> {
+        self.article.clone()
+    }
+
+    fn hreflangs(&self) -> Option<Vec<HreflangEntry>> {
+        self.hreflangs.clone()
+    }
+
+    fn favicons(&self) -> Option<Vec<FaviconInfo>> {
+        self.favicons.clone()
+    }
+
+    fn headings(&self) -> Option<Vec<HeadingInfo>> {
+        self.headings.clone()
+    }
+
+    fn word_count(&self) -> Option<usize> {
+        self.word_count
+    }
+}
+
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
+#[magnus::wrap(class = "Kreuzcrawl::CitationResult")]
+#[serde(default)]
+pub struct CitationResult {
+    pub content: String,
+    pub references: Vec<CitationReference>,
+}
+
+unsafe impl IntoValueFromNative for CitationResult {}
+
+impl magnus::TryConvert for CitationResult {
+    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
+        let r: &CitationResult = magnus::TryConvert::try_convert(val)?;
+        Ok(r.clone())
+    }
+}
+unsafe impl TryConvertOwned for CitationResult {}
+
+impl Default for CitationResult {
+    fn default() -> Self {
+        Self {
+            content: Default::default(),
+            references: Default::default(),
+        }
+    }
+}
+
+impl CitationResult {
+    fn new(content: Option<String>, references: Option<Vec<CitationReference>>) -> Self {
+        Self {
+            content: content.unwrap_or_default(),
+            references: references.unwrap_or_default(),
+        }
+    }
+
+    fn content(&self) -> String {
+        self.content.clone()
+    }
+
+    fn references(&self) -> Vec<CitationReference> {
+        self.references.clone()
+    }
+}
+
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
+#[magnus::wrap(class = "Kreuzcrawl::CitationReference")]
+#[serde(default)]
+pub struct CitationReference {
+    pub index: usize,
+    pub url: String,
+    pub text: String,
+}
+
+unsafe impl IntoValueFromNative for CitationReference {}
+
+impl magnus::TryConvert for CitationReference {
+    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
+        let r: &CitationReference = magnus::TryConvert::try_convert(val)?;
+        Ok(r.clone())
+    }
+}
+unsafe impl TryConvertOwned for CitationReference {}
+
+impl Default for CitationReference {
+    fn default() -> Self {
+        Self {
+            index: Default::default(),
+            url: Default::default(),
+            text: Default::default(),
+        }
+    }
+}
+
+impl CitationReference {
+    fn new(index: Option<usize>, url: Option<String>, text: Option<String>) -> Self {
+        Self {
+            index: index.unwrap_or_default(),
+            url: url.unwrap_or_default(),
+            text: text.unwrap_or_default(),
+        }
+    }
+
+    fn index(&self) -> usize {
+        self.index
+    }
+
+    fn url(&self) -> String {
+        self.url.clone()
+    }
+
+    fn text(&self) -> String {
+        self.text.clone()
+    }
+}
+
+#[derive(Clone)]
+#[magnus::wrap(class = "Kreuzcrawl::CrawlEngineHandle")]
+pub struct CrawlEngineHandle {
+    inner: Arc<kreuzcrawl::CrawlEngineHandle>,
+}
+
+unsafe impl IntoValueFromNative for CrawlEngineHandle {}
+
+impl magnus::TryConvert for CrawlEngineHandle {
+    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
+        let r: &CrawlEngineHandle = magnus::TryConvert::try_convert(val)?;
+        Ok(r.clone())
+    }
+}
+unsafe impl TryConvertOwned for CrawlEngineHandle {}
+
+impl CrawlEngineHandle {}
+
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
+#[magnus::wrap(class = "Kreuzcrawl::BatchScrapeResult")]
+#[serde(default)]
+pub struct BatchScrapeResult {
+    pub url: String,
+    pub result: Option<ScrapeResult>,
+    pub error: Option<String>,
+}
+
+unsafe impl IntoValueFromNative for BatchScrapeResult {}
+
+impl magnus::TryConvert for BatchScrapeResult {
+    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
+        let r: &BatchScrapeResult = magnus::TryConvert::try_convert(val)?;
+        Ok(r.clone())
+    }
+}
+unsafe impl TryConvertOwned for BatchScrapeResult {}
+
+impl Default for BatchScrapeResult {
+    fn default() -> Self {
+        Self {
+            url: Default::default(),
+            result: Default::default(),
+            error: Default::default(),
+        }
+    }
+}
+
+impl BatchScrapeResult {
+    fn new(url: Option<String>, result: Option<ScrapeResult>, error: Option<String>) -> Self {
+        Self {
+            url: url.unwrap_or_default(),
+            result,
+            error,
+        }
+    }
+
+    fn url(&self) -> String {
+        self.url.clone()
+    }
+
+    fn result(&self) -> Option<ScrapeResult> {
+        self.result.clone()
+    }
+
+    fn error(&self) -> Option<String> {
+        self.error.clone()
+    }
+}
+
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
+#[magnus::wrap(class = "Kreuzcrawl::BatchCrawlResult")]
+#[serde(default)]
+pub struct BatchCrawlResult {
+    pub url: String,
+    pub result: Option<CrawlResult>,
+    pub error: Option<String>,
+}
+
+unsafe impl IntoValueFromNative for BatchCrawlResult {}
+
+impl magnus::TryConvert for BatchCrawlResult {
+    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
+        let r: &BatchCrawlResult = magnus::TryConvert::try_convert(val)?;
+        Ok(r.clone())
+    }
+}
+unsafe impl TryConvertOwned for BatchCrawlResult {}
+
+impl Default for BatchCrawlResult {
+    fn default() -> Self {
+        Self {
+            url: Default::default(),
+            result: Default::default(),
+            error: Default::default(),
+        }
+    }
+}
+
+impl BatchCrawlResult {
+    fn new(url: Option<String>, result: Option<CrawlResult>, error: Option<String>) -> Self {
+        Self {
+            url: url.unwrap_or_default(),
+            result,
+            error,
+        }
+    }
+
+    fn url(&self) -> String {
+        self.url.clone()
+    }
+
+    fn result(&self) -> Option<CrawlResult> {
+        self.result.clone()
+    }
+
+    fn error(&self) -> Option<String> {
+        self.error.clone()
+    }
+}
+
+#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+pub enum BrowserMode {
+    Auto,
+    Always,
+    Never,
+}
+
+impl Default for BrowserMode {
+    fn default() -> Self {
+        Self::Auto
+    }
+}
+
+impl magnus::IntoValue for BrowserMode {
+    fn into_value_with(self, handle: &Ruby) -> magnus::Value {
+        let sym = match self {
+            BrowserMode::Auto => "auto",
+            BrowserMode::Always => "always",
+            BrowserMode::Never => "never",
+        };
+        handle.to_symbol(sym).into_value_with(handle)
+    }
+}
+
+impl magnus::TryConvert for BrowserMode {
+    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
+        let s: String = magnus::TryConvert::try_convert(val)?;
+        match s.as_str() {
+            "auto" => Ok(BrowserMode::Auto),
+            "always" => Ok(BrowserMode::Always),
+            "never" => Ok(BrowserMode::Never),
+            other => Err(magnus::Error::new(
+                unsafe { Ruby::get_unchecked() }.exception_arg_error(),
+                format!("invalid BrowserMode value: {other}"),
+            )),
+        }
+    }
+}
+
+unsafe impl IntoValueFromNative for BrowserMode {}
+unsafe impl TryConvertOwned for BrowserMode {}
+
+#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+pub enum BrowserWait {
+    NetworkIdle,
+    Selector,
+    Fixed,
+}
+
+impl Default for BrowserWait {
+    fn default() -> Self {
+        Self::NetworkIdle
+    }
+}
+
+impl magnus::IntoValue for BrowserWait {
+    fn into_value_with(self, handle: &Ruby) -> magnus::Value {
+        let sym = match self {
+            BrowserWait::NetworkIdle => "network_idle",
+            BrowserWait::Selector => "selector",
+            BrowserWait::Fixed => "fixed",
+        };
+        handle.to_symbol(sym).into_value_with(handle)
+    }
+}
+
+impl magnus::TryConvert for BrowserWait {
+    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
+        let s: String = magnus::TryConvert::try_convert(val)?;
+        match s.as_str() {
+            "network_idle" => Ok(BrowserWait::NetworkIdle),
+            "selector" => Ok(BrowserWait::Selector),
+            "fixed" => Ok(BrowserWait::Fixed),
+            other => Err(magnus::Error::new(
+                unsafe { Ruby::get_unchecked() }.exception_arg_error(),
+                format!("invalid BrowserWait value: {other}"),
+            )),
+        }
+    }
+}
+
+unsafe impl IntoValueFromNative for BrowserWait {}
+unsafe impl TryConvertOwned for BrowserWait {}
+
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
+#[serde(tag = "type")]
+pub enum AuthConfig {
+    #[serde(rename = "basic")]
+    Basic { username: String, password: String },
+    #[serde(rename = "bearer")]
+    Bearer { token: String },
+    #[serde(rename = "header")]
+    Header { name: String, value: String },
+}
+
+impl Default for AuthConfig {
+    fn default() -> Self {
+        Self::Basic {
+            username: Default::default(),
+            password: Default::default(),
+        }
+    }
+}
+
+impl magnus::IntoValue for AuthConfig {
+    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 AuthConfig {
+    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(unsafe { Ruby::get_unchecked() }.exception_type_error(), e.to_string()))
+    }
+}
+
+unsafe impl IntoValueFromNative for AuthConfig {}
+unsafe impl TryConvertOwned for AuthConfig {}
+
+#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+pub enum LinkType {
+    Internal,
+    External,
+    Anchor,
+    Document,
+}
+
+impl Default for LinkType {
+    fn default() -> Self {
+        Self::Internal
+    }
+}
+
+impl magnus::IntoValue for LinkType {
+    fn into_value_with(self, handle: &Ruby) -> magnus::Value {
+        let sym = match self {
+            LinkType::Internal => "internal",
+            LinkType::External => "external",
+            LinkType::Anchor => "anchor",
+            LinkType::Document => "document",
+        };
+        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() {
+            "internal" => Ok(LinkType::Internal),
+            "external" => Ok(LinkType::External),
+            "anchor" => Ok(LinkType::Anchor),
+            "document" => Ok(LinkType::Document),
+            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 ImageSource {
+    Img,
+    PictureSource,
+    #[serde(rename = "og:image")]
+    OgImage,
+    #[serde(rename = "twitter:image")]
+    TwitterImage,
+}
+
+impl Default for ImageSource {
+    fn default() -> Self {
+        Self::Img
+    }
+}
+
+impl magnus::IntoValue for ImageSource {
+    fn into_value_with(self, handle: &Ruby) -> magnus::Value {
+        let sym = match self {
+            ImageSource::Img => "img",
+            ImageSource::PictureSource => "picture_source",
+            ImageSource::OgImage => "og_image",
+            ImageSource::TwitterImage => "twitter_image",
+        };
+        handle.to_symbol(sym).into_value_with(handle)
+    }
+}
+
+impl magnus::TryConvert for ImageSource {
+    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
+        let s: String = magnus::TryConvert::try_convert(val)?;
+        match s.as_str() {
+            "img" => Ok(ImageSource::Img),
+            "picture_source" => Ok(ImageSource::PictureSource),
+            "og_image" => Ok(ImageSource::OgImage),
+            "twitter_image" => Ok(ImageSource::TwitterImage),
+            other => Err(magnus::Error::new(
+                unsafe { Ruby::get_unchecked() }.exception_arg_error(),
+                format!("invalid ImageSource value: {other}"),
+            )),
+        }
+    }
+}
+
+unsafe impl IntoValueFromNative for ImageSource {}
+unsafe impl TryConvertOwned for ImageSource {}
+
+#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+pub enum FeedType {
+    Rss,
+    Atom,
+    JsonFeed,
+}
+
+impl Default for FeedType {
+    fn default() -> Self {
+        Self::Rss
+    }
+}
+
+impl magnus::IntoValue for FeedType {
+    fn into_value_with(self, handle: &Ruby) -> magnus::Value {
+        let sym = match self {
+            FeedType::Rss => "rss",
+            FeedType::Atom => "atom",
+            FeedType::JsonFeed => "json_feed",
+        };
+        handle.to_symbol(sym).into_value_with(handle)
+    }
+}
+
+impl magnus::TryConvert for FeedType {
+    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
+        let s: String = magnus::TryConvert::try_convert(val)?;
+        match s.as_str() {
+            "rss" => Ok(FeedType::Rss),
+            "atom" => Ok(FeedType::Atom),
+            "json_feed" => Ok(FeedType::JsonFeed),
+            other => Err(magnus::Error::new(
+                unsafe { Ruby::get_unchecked() }.exception_arg_error(),
+                format!("invalid FeedType value: {other}"),
+            )),
+        }
+    }
+}
+
+unsafe impl IntoValueFromNative for FeedType {}
+unsafe impl TryConvertOwned for FeedType {}
+
+#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+pub enum AssetCategory {
+    Document,
+    Image,
+    Audio,
+    Video,
+    Font,
+    Stylesheet,
+    Script,
+    Archive,
+    Data,
+    Other,
+}
+
+impl Default for AssetCategory {
+    fn default() -> Self {
+        Self::Document
+    }
+}
+
+impl magnus::IntoValue for AssetCategory {
+    fn into_value_with(self, handle: &Ruby) -> magnus::Value {
+        let sym = match self {
+            AssetCategory::Document => "document",
+            AssetCategory::Image => "image",
+            AssetCategory::Audio => "audio",
+            AssetCategory::Video => "video",
+            AssetCategory::Font => "font",
+            AssetCategory::Stylesheet => "stylesheet",
+            AssetCategory::Script => "script",
+            AssetCategory::Archive => "archive",
+            AssetCategory::Data => "data",
+            AssetCategory::Other => "other",
+        };
+        handle.to_symbol(sym).into_value_with(handle)
+    }
+}
+
+impl magnus::TryConvert for AssetCategory {
+    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
+        let s: String = magnus::TryConvert::try_convert(val)?;
+        match s.as_str() {
+            "document" => Ok(AssetCategory::Document),
+            "image" => Ok(AssetCategory::Image),
+            "audio" => Ok(AssetCategory::Audio),
+            "video" => Ok(AssetCategory::Video),
+            "font" => Ok(AssetCategory::Font),
+            "stylesheet" => Ok(AssetCategory::Stylesheet),
+            "script" => Ok(AssetCategory::Script),
+            "archive" => Ok(AssetCategory::Archive),
+            "data" => Ok(AssetCategory::Data),
+            "other" => Ok(AssetCategory::Other),
+            other => Err(magnus::Error::new(
+                unsafe { Ruby::get_unchecked() }.exception_arg_error(),
+                format!("invalid AssetCategory value: {other}"),
+            )),
+        }
+    }
+}
+
+unsafe impl IntoValueFromNative for AssetCategory {}
+unsafe impl TryConvertOwned for AssetCategory {}
+
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
+pub enum CrawlEvent {
+    Page { _0: CrawlPageResult },
+    Error { url: String, error: String },
+    Complete { pages_crawled: usize },
+}
+
+impl Default for CrawlEvent {
+    fn default() -> Self {
+        Self::Page { _0: Default::default() }
+    }
+}
+
+impl magnus::IntoValue for CrawlEvent {
+    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 CrawlEvent {
+    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(unsafe { Ruby::get_unchecked() }.exception_type_error(), e.to_string()))
+    }
+}
+
+unsafe impl IntoValueFromNative for CrawlEvent {}
+unsafe impl TryConvertOwned for CrawlEvent {}
+
+fn create_engine(config: Option<String>) -> Result<CrawlEngineHandle, Error> {
+    let config: Option<CrawlConfig> = config
+        .as_deref()
+        .filter(|s| *s != "nil")
+        .map(|s| {
+            let core: kreuzcrawl::CrawlConfig = serde_json::from_str(s).map_err(|e| {
+                magnus::Error::new(unsafe { Ruby::get_unchecked() }.exception_type_error(), e.to_string())
+            })?;
+            Ok::<_, magnus::Error>(core.into())
+        })
+        .transpose()?;
+    let result = kreuzcrawl::create_engine(config.map(Into::into)).map_err(|e| {
+        magnus::Error::new(
+            unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
+            e.to_string(),
+        )
+    })?;
+    Ok(CrawlEngineHandle {
+        inner: Arc::new(result),
+    })
+}
+
+fn scrape(engine: CrawlEngineHandle, url: String) -> Result<ScrapeResult, Error> {
+    let rt = tokio::runtime::Runtime::new().map_err(|e| {
+        magnus::Error::new(
+            unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
+            e.to_string(),
+        )
+    })?;
+    let result = rt
+        .block_on(async { kreuzcrawl::scrape(&engine.inner, &url).await })
+        .map_err(|e| {
+            magnus::Error::new(
+                unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
+                e.to_string(),
+            )
+        })?;
+    Ok(result.into())
+}
+
+fn scrape_async(engine: CrawlEngineHandle, url: String) -> Result<ScrapeResult, Error> {
+    let rt = tokio::runtime::Runtime::new().map_err(|e| {
+        magnus::Error::new(
+            unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
+            e.to_string(),
+        )
+    })?;
+    let result = rt
+        .block_on(async { kreuzcrawl::scrape(&engine.inner, &url).await })
+        .map_err(|e| {
+            magnus::Error::new(
+                unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
+                e.to_string(),
+            )
+        })?;
+    Ok(result.into())
+}
+
+fn crawl(engine: CrawlEngineHandle, url: String) -> Result<CrawlResult, Error> {
+    let rt = tokio::runtime::Runtime::new().map_err(|e| {
+        magnus::Error::new(
+            unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
+            e.to_string(),
+        )
+    })?;
+    let result = rt
+        .block_on(async { kreuzcrawl::crawl(&engine.inner, &url).await })
+        .map_err(|e| {
+            magnus::Error::new(
+                unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
+                e.to_string(),
+            )
+        })?;
+    Ok(result.into())
+}
+
+fn crawl_async(engine: CrawlEngineHandle, url: String) -> Result<CrawlResult, Error> {
+    let rt = tokio::runtime::Runtime::new().map_err(|e| {
+        magnus::Error::new(
+            unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
+            e.to_string(),
+        )
+    })?;
+    let result = rt
+        .block_on(async { kreuzcrawl::crawl(&engine.inner, &url).await })
+        .map_err(|e| {
+            magnus::Error::new(
+                unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
+                e.to_string(),
+            )
+        })?;
+    Ok(result.into())
+}
+
+fn map_urls(engine: CrawlEngineHandle, url: String) -> Result<MapResult, Error> {
+    let rt = tokio::runtime::Runtime::new().map_err(|e| {
+        magnus::Error::new(
+            unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
+            e.to_string(),
+        )
+    })?;
+    let result = rt
+        .block_on(async { kreuzcrawl::map_urls(&engine.inner, &url).await })
+        .map_err(|e| {
+            magnus::Error::new(
+                unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
+                e.to_string(),
+            )
+        })?;
+    Ok(result.into())
+}
+
+fn map_urls_async(engine: CrawlEngineHandle, url: String) -> Result<MapResult, Error> {
+    let rt = tokio::runtime::Runtime::new().map_err(|e| {
+        magnus::Error::new(
+            unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
+            e.to_string(),
+        )
+    })?;
+    let result = rt
+        .block_on(async { kreuzcrawl::map_urls(&engine.inner, &url).await })
+        .map_err(|e| {
+            magnus::Error::new(
+                unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
+                e.to_string(),
+            )
+        })?;
+    Ok(result.into())
+}
+
+fn batch_scrape(engine: CrawlEngineHandle, urls: Vec<String>) -> Result<Vec<BatchScrapeResult>, Error> {
+    let rt = tokio::runtime::Runtime::new().map_err(|e| {
+        magnus::Error::new(
+            unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
+            e.to_string(),
+        )
+    })?;
+    let result = rt.block_on(async { kreuzcrawl::batch_scrape(&engine.inner, urls).await });
+    Ok(result.into_iter().map(Into::into).collect())
+}
+
+fn batch_scrape_async(engine: CrawlEngineHandle, urls: Vec<String>) -> Result<Vec<BatchScrapeResult>, Error> {
+    let rt = tokio::runtime::Runtime::new().map_err(|e| {
+        magnus::Error::new(
+            unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
+            e.to_string(),
+        )
+    })?;
+    let result = rt.block_on(async { kreuzcrawl::batch_scrape(&engine.inner, urls).await });
+    Ok(result.into_iter().map(Into::into).collect())
+}
+
+fn batch_crawl(engine: CrawlEngineHandle, urls: Vec<String>) -> Result<Vec<BatchCrawlResult>, Error> {
+    let rt = tokio::runtime::Runtime::new().map_err(|e| {
+        magnus::Error::new(
+            unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
+            e.to_string(),
+        )
+    })?;
+    let result = rt.block_on(async { kreuzcrawl::batch_crawl(&engine.inner, urls).await });
+    Ok(result.into_iter().map(Into::into).collect())
+}
+
+fn batch_crawl_async(engine: CrawlEngineHandle, urls: Vec<String>) -> Result<Vec<BatchCrawlResult>, Error> {
+    let rt = tokio::runtime::Runtime::new().map_err(|e| {
+        magnus::Error::new(
+            unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
+            e.to_string(),
+        )
+    })?;
+    let result = rt.block_on(async { kreuzcrawl::batch_crawl(&engine.inner, urls).await });
+    Ok(result.into_iter().map(Into::into).collect())
+}
+
+impl From<ExtractionMeta> for kreuzcrawl::ExtractionMeta {
+    fn from(val: ExtractionMeta) -> Self {
+        Self {
+            cost: val.cost,
+            prompt_tokens: val.prompt_tokens,
+            completion_tokens: val.completion_tokens,
+            model: val.model,
+            chunks_processed: val.chunks_processed,
+        }
+    }
+}
+
+impl From<kreuzcrawl::ExtractionMeta> for ExtractionMeta {
+    fn from(val: kreuzcrawl::ExtractionMeta) -> Self {
+        Self {
+            cost: val.cost,
+            prompt_tokens: val.prompt_tokens,
+            completion_tokens: val.completion_tokens,
+            model: val.model,
+            chunks_processed: val.chunks_processed,
+        }
+    }
+}
+
+impl From<ProxyConfig> for kreuzcrawl::ProxyConfig {
+    fn from(val: ProxyConfig) -> Self {
+        Self {
+            url: val.url,
+            username: val.username,
+            password: val.password,
+        }
+    }
+}
+
+impl From<kreuzcrawl::ProxyConfig> for ProxyConfig {
+    fn from(val: kreuzcrawl::ProxyConfig) -> Self {
+        Self {
+            url: val.url,
+            username: val.username,
+            password: val.password,
+        }
+    }
+}
+
+impl From<BrowserConfig> for kreuzcrawl::BrowserConfig {
+    fn from(val: BrowserConfig) -> Self {
+        Self {
+            mode: val.mode.into(),
+            endpoint: val.endpoint,
+            timeout: std::time::Duration::from_millis(val.timeout),
+            wait: val.wait.into(),
+            wait_selector: val.wait_selector,
+            extra_wait: val.extra_wait.map(std::time::Duration::from_millis),
+        }
+    }
+}
+
+impl From<kreuzcrawl::BrowserConfig> for BrowserConfig {
+    fn from(val: kreuzcrawl::BrowserConfig) -> Self {
+        Self {
+            mode: val.mode.into(),
+            endpoint: val.endpoint,
+            timeout: val.timeout.as_millis() as u64,
+            wait: val.wait.into(),
+            wait_selector: val.wait_selector,
+            extra_wait: val.extra_wait.map(|d| d.as_millis() as u64),
+        }
+    }
+}
+
+#[allow(clippy::needless_update)]
+impl From<CrawlConfig> for kreuzcrawl::CrawlConfig {
+    fn from(val: CrawlConfig) -> Self {
+        Self {
+            max_depth: val.max_depth,
+            max_pages: val.max_pages,
+            max_concurrent: val.max_concurrent,
+            respect_robots_txt: val.respect_robots_txt,
+            user_agent: val.user_agent,
+            stay_on_domain: val.stay_on_domain,
+            allow_subdomains: val.allow_subdomains,
+            include_paths: val.include_paths,
+            exclude_paths: val.exclude_paths,
+            custom_headers: val.custom_headers.into_iter().collect(),
+            request_timeout: std::time::Duration::from_millis(val.request_timeout),
+            max_redirects: val.max_redirects,
+            retry_count: val.retry_count,
+            retry_codes: val.retry_codes,
+            cookies_enabled: val.cookies_enabled,
+            auth: val.auth.map(Into::into),
+            max_body_size: val.max_body_size,
+            main_content_only: val.main_content_only,
+            remove_tags: val.remove_tags,
+            map_limit: val.map_limit,
+            map_search: val.map_search,
+            download_assets: val.download_assets,
+            asset_types: val.asset_types.into_iter().map(Into::into).collect(),
+            max_asset_size: val.max_asset_size,
+            browser: val.browser.into(),
+            proxy: val.proxy.map(Into::into),
+            user_agents: val.user_agents,
+            capture_screenshot: val.capture_screenshot,
+            download_documents: val.download_documents,
+            document_max_size: val.document_max_size,
+            document_mime_types: val.document_mime_types,
+            warc_output: val.warc_output.map(Into::into),
+            browser_profile: val.browser_profile,
+            save_browser_profile: val.save_browser_profile,
+            ..Default::default()
+        }
+    }
+}
+
+impl From<kreuzcrawl::CrawlConfig> for CrawlConfig {
+    fn from(val: kreuzcrawl::CrawlConfig) -> Self {
+        Self {
+            max_depth: val.max_depth,
+            max_pages: val.max_pages,
+            max_concurrent: val.max_concurrent,
+            respect_robots_txt: val.respect_robots_txt,
+            user_agent: val.user_agent,
+            stay_on_domain: val.stay_on_domain,
+            allow_subdomains: val.allow_subdomains,
+            include_paths: val.include_paths,
+            exclude_paths: val.exclude_paths,
+            custom_headers: val.custom_headers.into_iter().collect(),
+            request_timeout: val.request_timeout.as_millis() as u64,
+            max_redirects: val.max_redirects,
+            retry_count: val.retry_count,
+            retry_codes: val.retry_codes,
+            cookies_enabled: val.cookies_enabled,
+            auth: val.auth.map(Into::into),
+            max_body_size: val.max_body_size,
+            main_content_only: val.main_content_only,
+            remove_tags: val.remove_tags,
+            map_limit: val.map_limit,
+            map_search: val.map_search,
+            download_assets: val.download_assets,
+            asset_types: val.asset_types.into_iter().map(Into::into).collect(),
+            max_asset_size: val.max_asset_size,
+            browser: val.browser.into(),
+            proxy: val.proxy.map(Into::into),
+            user_agents: val.user_agents,
+            capture_screenshot: val.capture_screenshot,
+            download_documents: val.download_documents,
+            document_max_size: val.document_max_size,
+            document_mime_types: val.document_mime_types,
+            warc_output: val.warc_output.map(|p| p.to_string_lossy().to_string()),
+            browser_profile: val.browser_profile,
+            save_browser_profile: val.save_browser_profile,
+        }
+    }
+}
+
+impl From<DownloadedDocument> for kreuzcrawl::DownloadedDocument {
+    fn from(val: DownloadedDocument) -> Self {
+        Self {
+            url: val.url,
+            mime_type: Default::default(),
+            content: val.content,
+            size: val.size,
+            filename: Default::default(),
+            content_hash: Default::default(),
+            headers: Default::default(),
+        }
+    }
+}
+
+impl From<kreuzcrawl::DownloadedDocument> for DownloadedDocument {
+    fn from(val: kreuzcrawl::DownloadedDocument) -> Self {
+        Self {
+            url: val.url,
+            mime_type: format!("{:?}", val.mime_type),
+            content: val.content.to_vec(),
+            size: val.size,
+            filename: val.filename.as_ref().map(|v| format!("{:?}", v)),
+            content_hash: format!("{:?}", val.content_hash),
+            headers: val
+                .headers
+                .into_iter()
+                .map(|(k, v)| (format!("{:?}", k), format!("{:?}", v)))
+                .collect(),
+        }
+    }
+}
+
+impl From<kreuzcrawl::InteractionResult> for InteractionResult {
+    fn from(val: kreuzcrawl::InteractionResult) -> Self {
+        Self {
+            action_results: val.action_results.into_iter().map(Into::into).collect(),
+            final_html: val.final_html,
+            final_url: val.final_url,
+            screenshot: val.screenshot.map(|v| v.to_vec()),
+        }
+    }
+}
+
+impl From<kreuzcrawl::ActionResult> for ActionResult {
+    fn from(val: kreuzcrawl::ActionResult) -> Self {
+        Self {
+            action_index: val.action_index,
+            action_type: format!("{:?}", val.action_type),
+            success: val.success,
+            data: val.data.as_ref().map(ToString::to_string),
+            error: val.error,
+        }
+    }
+}
+
+impl From<ScrapeResult> for kreuzcrawl::ScrapeResult {
+    fn from(val: ScrapeResult) -> Self {
+        Self {
+            status_code: val.status_code,
+            content_type: val.content_type,
+            html: val.html,
+            body_size: val.body_size,
+            metadata: val.metadata.into(),
+            links: val.links.into_iter().map(Into::into).collect(),
+            images: val.images.into_iter().map(Into::into).collect(),
+            feeds: val.feeds.into_iter().map(Into::into).collect(),
+            json_ld: val.json_ld.into_iter().map(Into::into).collect(),
+            is_allowed: val.is_allowed,
+            crawl_delay: val.crawl_delay,
+            noindex_detected: val.noindex_detected,
+            nofollow_detected: val.nofollow_detected,
+            x_robots_tag: val.x_robots_tag,
+            is_pdf: val.is_pdf,
+            was_skipped: val.was_skipped,
+            detected_charset: val.detected_charset,
+            main_content_only: val.main_content_only,
+            auth_header_sent: val.auth_header_sent,
+            response_meta: val.response_meta.map(Into::into),
+            assets: val.assets.into_iter().map(Into::into).collect(),
+            js_render_hint: val.js_render_hint,
+            browser_used: val.browser_used,
+            markdown: val.markdown.map(Into::into),
+            extracted_data: val.extracted_data.as_ref().and_then(|s| serde_json::from_str(s).ok()),
+            extraction_meta: val.extraction_meta.map(Into::into),
+            screenshot: val.screenshot,
+            downloaded_document: val.downloaded_document.map(Into::into),
+        }
+    }
+}
+
+impl From<kreuzcrawl::ScrapeResult> for ScrapeResult {
+    fn from(val: kreuzcrawl::ScrapeResult) -> Self {
+        Self {
+            status_code: val.status_code,
+            content_type: val.content_type,
+            html: val.html,
+            body_size: val.body_size,
+            metadata: val.metadata.into(),
+            links: val.links.into_iter().map(Into::into).collect(),
+            images: val.images.into_iter().map(Into::into).collect(),
+            feeds: val.feeds.into_iter().map(Into::into).collect(),
+            json_ld: val.json_ld.into_iter().map(Into::into).collect(),
+            is_allowed: val.is_allowed,
+            crawl_delay: val.crawl_delay,
+            noindex_detected: val.noindex_detected,
+            nofollow_detected: val.nofollow_detected,
+            x_robots_tag: val.x_robots_tag,
+            is_pdf: val.is_pdf,
+            was_skipped: val.was_skipped,
+            detected_charset: val.detected_charset,
+            main_content_only: val.main_content_only,
+            auth_header_sent: val.auth_header_sent,
+            response_meta: val.response_meta.map(Into::into),
+            assets: val.assets.into_iter().map(Into::into).collect(),
+            js_render_hint: val.js_render_hint,
+            browser_used: val.browser_used,
+            markdown: val.markdown.map(Into::into),
+            extracted_data: val.extracted_data.as_ref().map(ToString::to_string),
+            extraction_meta: val.extraction_meta.map(Into::into),
+            screenshot: val.screenshot.map(|v| v.to_vec()),
+            downloaded_document: val.downloaded_document.map(Into::into),
+        }
+    }
+}
+
+impl From<CrawlPageResult> for kreuzcrawl::CrawlPageResult {
+    fn from(val: CrawlPageResult) -> Self {
+        Self {
+            url: val.url,
+            normalized_url: val.normalized_url,
+            status_code: val.status_code,
+            content_type: val.content_type,
+            html: val.html,
+            body_size: val.body_size,
+            metadata: val.metadata.into(),
+            links: val.links.into_iter().map(Into::into).collect(),
+            images: val.images.into_iter().map(Into::into).collect(),
+            feeds: val.feeds.into_iter().map(Into::into).collect(),
+            json_ld: val.json_ld.into_iter().map(Into::into).collect(),
+            depth: val.depth,
+            stayed_on_domain: val.stayed_on_domain,
+            was_skipped: val.was_skipped,
+            is_pdf: val.is_pdf,
+            detected_charset: val.detected_charset,
+            markdown: val.markdown.map(Into::into),
+            extracted_data: val.extracted_data.as_ref().and_then(|s| serde_json::from_str(s).ok()),
+            extraction_meta: val.extraction_meta.map(Into::into),
+            downloaded_document: val.downloaded_document.map(Into::into),
+        }
+    }
+}
+
+impl From<kreuzcrawl::CrawlPageResult> for CrawlPageResult {
+    fn from(val: kreuzcrawl::CrawlPageResult) -> Self {
+        Self {
+            url: val.url,
+            normalized_url: val.normalized_url,
+            status_code: val.status_code,
+            content_type: val.content_type,
+            html: val.html,
+            body_size: val.body_size,
+            metadata: val.metadata.into(),
+            links: val.links.into_iter().map(Into::into).collect(),
+            images: val.images.into_iter().map(Into::into).collect(),
+            feeds: val.feeds.into_iter().map(Into::into).collect(),
+            json_ld: val.json_ld.into_iter().map(Into::into).collect(),
+            depth: val.depth,
+            stayed_on_domain: val.stayed_on_domain,
+            was_skipped: val.was_skipped,
+            is_pdf: val.is_pdf,
+            detected_charset: val.detected_charset,
+            markdown: val.markdown.map(Into::into),
+            extracted_data: val.extracted_data.as_ref().map(ToString::to_string),
+            extraction_meta: val.extraction_meta.map(Into::into),
+            downloaded_document: val.downloaded_document.map(Into::into),
+        }
+    }
+}
+
+impl From<CrawlResult> for kreuzcrawl::CrawlResult {
+    fn from(val: CrawlResult) -> Self {
+        Self {
+            pages: val.pages.into_iter().map(Into::into).collect(),
+            final_url: val.final_url,
+            redirect_count: val.redirect_count,
+            was_skipped: val.was_skipped,
+            error: val.error,
+            cookies: val.cookies.into_iter().map(Into::into).collect(),
+            normalized_urls: val.normalized_urls,
+        }
+    }
+}
+
+impl From<kreuzcrawl::CrawlResult> for CrawlResult {
+    fn from(val: kreuzcrawl::CrawlResult) -> Self {
+        Self {
+            pages: val.pages.into_iter().map(Into::into).collect(),
+            final_url: val.final_url,
+            redirect_count: val.redirect_count,
+            was_skipped: val.was_skipped,
+            error: val.error,
+            cookies: val.cookies.into_iter().map(Into::into).collect(),
+            normalized_urls: val.normalized_urls,
+        }
+    }
+}
+
+impl From<SitemapUrl> for kreuzcrawl::SitemapUrl {
+    fn from(val: SitemapUrl) -> Self {
+        Self {
+            url: val.url,
+            lastmod: val.lastmod,
+            changefreq: val.changefreq,
+            priority: val.priority,
+        }
+    }
+}
+
+impl From<kreuzcrawl::SitemapUrl> for SitemapUrl {
+    fn from(val: kreuzcrawl::SitemapUrl) -> Self {
+        Self {
+            url: val.url,
+            lastmod: val.lastmod,
+            changefreq: val.changefreq,
+            priority: val.priority,
+        }
+    }
+}
+
+impl From<MapResult> for kreuzcrawl::MapResult {
+    fn from(val: MapResult) -> Self {
+        Self {
+            urls: val.urls.into_iter().map(Into::into).collect(),
+        }
+    }
+}
+
+impl From<kreuzcrawl::MapResult> for MapResult {
+    fn from(val: kreuzcrawl::MapResult) -> Self {
+        Self {
+            urls: val.urls.into_iter().map(Into::into).collect(),
+        }
+    }
+}
+
+impl From<MarkdownResult> for kreuzcrawl::MarkdownResult {
+    fn from(val: MarkdownResult) -> Self {
+        Self {
+            content: val.content,
+            document_structure: val
+                .document_structure
+                .as_ref()
+                .and_then(|s| serde_json::from_str(s).ok()),
+            tables: val
+                .tables
+                .into_iter()
+                .filter_map(|s| serde_json::from_str(&s).ok())
+                .collect(),
+            warnings: val.warnings,
+            citations: val.citations.map(Into::into),
+            fit_content: val.fit_content,
+        }
+    }
+}
+
+impl From<kreuzcrawl::MarkdownResult> for MarkdownResult {
+    fn from(val: kreuzcrawl::MarkdownResult) -> Self {
+        Self {
+            content: val.content,
+            document_structure: val.document_structure.as_ref().map(ToString::to_string),
+            tables: val.tables.iter().map(ToString::to_string).collect(),
+            warnings: val.warnings,
+            citations: val.citations.map(Into::into),
+            fit_content: val.fit_content,
+        }
+    }
+}
+
+impl From<kreuzcrawl::CachedPage> for CachedPage {
+    fn from(val: kreuzcrawl::CachedPage) -> Self {
+        Self {
+            url: val.url,
+            status_code: val.status_code,
+            content_type: val.content_type,
+            body: val.body,
+            etag: val.etag,
+            last_modified: val.last_modified,
+            cached_at: val.cached_at,
+        }
+    }
+}
+
+impl From<LinkInfo> for kreuzcrawl::LinkInfo {
+    fn from(val: LinkInfo) -> Self {
+        Self {
+            url: val.url,
+            text: val.text,
+            link_type: val.link_type.into(),
+            rel: val.rel,
+            nofollow: val.nofollow,
+        }
+    }
+}
+
+impl From<kreuzcrawl::LinkInfo> for LinkInfo {
+    fn from(val: kreuzcrawl::LinkInfo) -> Self {
+        Self {
+            url: val.url,
+            text: val.text,
+            link_type: val.link_type.into(),
+            rel: val.rel,
+            nofollow: val.nofollow,
+        }
+    }
+}
+
+impl From<ImageInfo> for kreuzcrawl::ImageInfo {
+    fn from(val: ImageInfo) -> Self {
+        Self {
+            url: val.url,
+            alt: val.alt,
+            width: val.width,
+            height: val.height,
+            source: val.source.into(),
+        }
+    }
+}
+
+impl From<kreuzcrawl::ImageInfo> for ImageInfo {
+    fn from(val: kreuzcrawl::ImageInfo) -> Self {
+        Self {
+            url: val.url,
+            alt: val.alt,
+            width: val.width,
+            height: val.height,
+            source: val.source.into(),
+        }
+    }
+}
+
+impl From<FeedInfo> for kreuzcrawl::FeedInfo {
+    fn from(val: FeedInfo) -> Self {
+        Self {
+            url: val.url,
+            title: val.title,
+            feed_type: val.feed_type.into(),
+        }
+    }
+}
+
+impl From<kreuzcrawl::FeedInfo> for FeedInfo {
+    fn from(val: kreuzcrawl::FeedInfo) -> Self {
+        Self {
+            url: val.url,
+            title: val.title,
+            feed_type: val.feed_type.into(),
+        }
+    }
+}
+
+impl From<JsonLdEntry> for kreuzcrawl::JsonLdEntry {
+    fn from(val: JsonLdEntry) -> Self {
+        Self {
+            schema_type: val.schema_type,
+            name: val.name,
+            raw: val.raw,
+        }
+    }
+}
+
+impl From<kreuzcrawl::JsonLdEntry> for JsonLdEntry {
+    fn from(val: kreuzcrawl::JsonLdEntry) -> Self {
+        Self {
+            schema_type: val.schema_type,
+            name: val.name,
+            raw: val.raw,
+        }
+    }
+}
+
+impl From<CookieInfo> for kreuzcrawl::CookieInfo {
+    fn from(val: CookieInfo) -> Self {
+        Self {
+            name: val.name,
+            value: val.value,
+            domain: val.domain,
+            path: val.path,
+        }
+    }
+}
+
+impl From<kreuzcrawl::CookieInfo> for CookieInfo {
+    fn from(val: kreuzcrawl::CookieInfo) -> Self {
+        Self {
+            name: val.name,
+            value: val.value,
+            domain: val.domain,
+            path: val.path,
+        }
+    }
+}
+
+impl From<DownloadedAsset> for kreuzcrawl::DownloadedAsset {
+    fn from(val: DownloadedAsset) -> Self {
+        Self {
+            url: val.url,
+            content_hash: val.content_hash,
+            mime_type: val.mime_type,
+            size: val.size,
+            asset_category: val.asset_category.into(),
+            html_tag: val.html_tag,
+        }
+    }
+}
+
+impl From<kreuzcrawl::DownloadedAsset> for DownloadedAsset {
+    fn from(val: kreuzcrawl::DownloadedAsset) -> Self {
+        Self {
+            url: val.url,
+            content_hash: val.content_hash,
+            mime_type: val.mime_type,
+            size: val.size,
+            asset_category: val.asset_category.into(),
+            html_tag: val.html_tag,
+        }
+    }
+}
+
+impl From<ArticleMetadata> for kreuzcrawl::ArticleMetadata {
+    fn from(val: ArticleMetadata) -> Self {
+        Self {
+            published_time: val.published_time,
+            modified_time: val.modified_time,
+            author: val.author,
+            section: val.section,
+            tags: val.tags,
+        }
+    }
+}
+
+impl From<kreuzcrawl::ArticleMetadata> for ArticleMetadata {
+    fn from(val: kreuzcrawl::ArticleMetadata) -> Self {
+        Self {
+            published_time: val.published_time,
+            modified_time: val.modified_time,
+            author: val.author,
+            section: val.section,
+            tags: val.tags,
+        }
+    }
+}
+
+impl From<HreflangEntry> for kreuzcrawl::HreflangEntry {
+    fn from(val: HreflangEntry) -> Self {
+        Self {
+            lang: val.lang,
+            url: val.url,
+        }
+    }
+}
+
+impl From<kreuzcrawl::HreflangEntry> for HreflangEntry {
+    fn from(val: kreuzcrawl::HreflangEntry) -> Self {
+        Self {
+            lang: val.lang,
+            url: val.url,
+        }
+    }
+}
+
+impl From<FaviconInfo> for kreuzcrawl::FaviconInfo {
+    fn from(val: FaviconInfo) -> Self {
+        Self {
+            url: val.url,
+            rel: val.rel,
+            sizes: val.sizes,
+            mime_type: val.mime_type,
+        }
+    }
+}
+
+impl From<kreuzcrawl::FaviconInfo> for FaviconInfo {
+    fn from(val: kreuzcrawl::FaviconInfo) -> Self {
+        Self {
+            url: val.url,
+            rel: val.rel,
+            sizes: val.sizes,
+            mime_type: val.mime_type,
+        }
+    }
+}
+
+impl From<HeadingInfo> for kreuzcrawl::HeadingInfo {
+    fn from(val: HeadingInfo) -> Self {
+        Self {
+            level: val.level,
+            text: val.text,
+        }
+    }
+}
+
+impl From<kreuzcrawl::HeadingInfo> for HeadingInfo {
+    fn from(val: kreuzcrawl::HeadingInfo) -> Self {
+        Self {
+            level: val.level,
+            text: val.text,
+        }
+    }
+}
+
+impl From<ResponseMeta> for kreuzcrawl::ResponseMeta {
+    fn from(val: ResponseMeta) -> Self {
+        Self {
+            etag: val.etag,
+            last_modified: val.last_modified,
+            cache_control: val.cache_control,
+            server: val.server,
+            x_powered_by: val.x_powered_by,
+            content_language: val.content_language,
+            content_encoding: val.content_encoding,
+        }
+    }
+}
+
+impl From<kreuzcrawl::ResponseMeta> for ResponseMeta {
+    fn from(val: kreuzcrawl::ResponseMeta) -> Self {
+        Self {
+            etag: val.etag,
+            last_modified: val.last_modified,
+            cache_control: val.cache_control,
+            server: val.server,
+            x_powered_by: val.x_powered_by,
+            content_language: val.content_language,
+            content_encoding: val.content_encoding,
+        }
+    }
+}
+
+impl From<PageMetadata> for kreuzcrawl::PageMetadata {
+    fn from(val: PageMetadata) -> Self {
+        Self {
+            title: val.title,
+            description: val.description,
+            canonical_url: val.canonical_url,
+            keywords: val.keywords,
+            author: val.author,
+            viewport: val.viewport,
+            theme_color: val.theme_color,
+            generator: val.generator,
+            robots: val.robots,
+            html_lang: val.html_lang,
+            html_dir: val.html_dir,
+            og_title: val.og_title,
+            og_type: val.og_type,
+            og_image: val.og_image,
+            og_description: val.og_description,
+            og_url: val.og_url,
+            og_site_name: val.og_site_name,
+            og_locale: val.og_locale,
+            og_video: val.og_video,
+            og_audio: val.og_audio,
+            og_locale_alternates: val.og_locale_alternates,
+            twitter_card: val.twitter_card,
+            twitter_title: val.twitter_title,
+            twitter_description: val.twitter_description,
+            twitter_image: val.twitter_image,
+            twitter_site: val.twitter_site,
+            twitter_creator: val.twitter_creator,
+            dc_title: val.dc_title,
+            dc_creator: val.dc_creator,
+            dc_subject: val.dc_subject,
+            dc_description: val.dc_description,
+            dc_publisher: val.dc_publisher,
+            dc_date: val.dc_date,
+            dc_type: val.dc_type,
+            dc_format: val.dc_format,
+            dc_identifier: val.dc_identifier,
+            dc_language: val.dc_language,
+            dc_rights: val.dc_rights,
+            article: val.article.map(Into::into),
+            hreflangs: val.hreflangs.map(|v| v.into_iter().map(Into::into).collect()),
+            favicons: val.favicons.map(|v| v.into_iter().map(Into::into).collect()),
+            headings: val.headings.map(|v| v.into_iter().map(Into::into).collect()),
+            word_count: val.word_count,
+        }
+    }
+}
+
+impl From<kreuzcrawl::PageMetadata> for PageMetadata {
+    fn from(val: kreuzcrawl::PageMetadata) -> Self {
+        Self {
+            title: val.title,
+            description: val.description,
+            canonical_url: val.canonical_url,
+            keywords: val.keywords,
+            author: val.author,
+            viewport: val.viewport,
+            theme_color: val.theme_color,
+            generator: val.generator,
+            robots: val.robots,
+            html_lang: val.html_lang,
+            html_dir: val.html_dir,
+            og_title: val.og_title,
+            og_type: val.og_type,
+            og_image: val.og_image,
+            og_description: val.og_description,
+            og_url: val.og_url,
+            og_site_name: val.og_site_name,
+            og_locale: val.og_locale,
+            og_video: val.og_video,
+            og_audio: val.og_audio,
+            og_locale_alternates: val.og_locale_alternates,
+            twitter_card: val.twitter_card,
+            twitter_title: val.twitter_title,
+            twitter_description: val.twitter_description,
+            twitter_image: val.twitter_image,
+            twitter_site: val.twitter_site,
+            twitter_creator: val.twitter_creator,
+            dc_title: val.dc_title,
+            dc_creator: val.dc_creator,
+            dc_subject: val.dc_subject,
+            dc_description: val.dc_description,
+            dc_publisher: val.dc_publisher,
+            dc_date: val.dc_date,
+            dc_type: val.dc_type,
+            dc_format: val.dc_format,
+            dc_identifier: val.dc_identifier,
+            dc_language: val.dc_language,
+            dc_rights: val.dc_rights,
+            article: val.article.map(Into::into),
+            hreflangs: val.hreflangs.map(|v| v.into_iter().map(Into::into).collect()),
+            favicons: val.favicons.map(|v| v.into_iter().map(Into::into).collect()),
+            headings: val.headings.map(|v| v.into_iter().map(Into::into).collect()),
+            word_count: val.word_count,
+        }
+    }
+}
+
+impl From<CitationResult> for kreuzcrawl::CitationResult {
+    fn from(val: CitationResult) -> Self {
+        Self {
+            content: val.content,
+            references: val.references.into_iter().map(Into::into).collect(),
+        }
+    }
+}
+
+impl From<kreuzcrawl::CitationResult> for CitationResult {
+    fn from(val: kreuzcrawl::CitationResult) -> Self {
+        Self {
+            content: val.content,
+            references: val.references.into_iter().map(Into::into).collect(),
+        }
+    }
+}
+
+impl From<CitationReference> for kreuzcrawl::CitationReference {
+    fn from(val: CitationReference) -> Self {
+        Self {
+            index: val.index,
+            url: val.url,
+            text: val.text,
+        }
+    }
+}
+
+impl From<kreuzcrawl::CitationReference> for CitationReference {
+    fn from(val: kreuzcrawl::CitationReference) -> Self {
+        Self {
+            index: val.index,
+            url: val.url,
+            text: val.text,
+        }
+    }
+}
+
+impl From<BatchScrapeResult> for kreuzcrawl::BatchScrapeResult {
+    fn from(val: BatchScrapeResult) -> Self {
+        Self {
+            url: val.url,
+            result: val.result.map(Into::into),
+            error: val.error,
+        }
+    }
+}
+
+impl From<kreuzcrawl::BatchScrapeResult> for BatchScrapeResult {
+    fn from(val: kreuzcrawl::BatchScrapeResult) -> Self {
+        Self {
+            url: val.url,
+            result: val.result.map(Into::into),
+            error: val.error,
+        }
+    }
+}
+
+impl From<BatchCrawlResult> for kreuzcrawl::BatchCrawlResult {
+    fn from(val: BatchCrawlResult) -> Self {
+        Self {
+            url: val.url,
+            result: val.result.map(Into::into),
+            error: val.error,
+        }
+    }
+}
+
+impl From<kreuzcrawl::BatchCrawlResult> for BatchCrawlResult {
+    fn from(val: kreuzcrawl::BatchCrawlResult) -> Self {
+        Self {
+            url: val.url,
+            result: val.result.map(Into::into),
+            error: val.error,
+        }
+    }
+}
+
+impl From<BrowserMode> for kreuzcrawl::BrowserMode {
+    fn from(val: BrowserMode) -> Self {
+        match val {
+            BrowserMode::Auto => Self::Auto,
+            BrowserMode::Always => Self::Always,
+            BrowserMode::Never => Self::Never,
+        }
+    }
+}
+
+impl From<kreuzcrawl::BrowserMode> for BrowserMode {
+    fn from(val: kreuzcrawl::BrowserMode) -> Self {
+        match val {
+            kreuzcrawl::BrowserMode::Auto => Self::Auto,
+            kreuzcrawl::BrowserMode::Always => Self::Always,
+            kreuzcrawl::BrowserMode::Never => Self::Never,
+        }
+    }
+}
+
+impl From<BrowserWait> for kreuzcrawl::BrowserWait {
+    fn from(val: BrowserWait) -> Self {
+        match val {
+            BrowserWait::NetworkIdle => Self::NetworkIdle,
+            BrowserWait::Selector => Self::Selector,
+            BrowserWait::Fixed => Self::Fixed,
+        }
+    }
+}
+
+impl From<kreuzcrawl::BrowserWait> for BrowserWait {
+    fn from(val: kreuzcrawl::BrowserWait) -> Self {
+        match val {
+            kreuzcrawl::BrowserWait::NetworkIdle => Self::NetworkIdle,
+            kreuzcrawl::BrowserWait::Selector => Self::Selector,
+            kreuzcrawl::BrowserWait::Fixed => Self::Fixed,
+        }
+    }
+}
+
+impl From<AuthConfig> for kreuzcrawl::AuthConfig {
+    fn from(val: AuthConfig) -> Self {
+        match val {
+            AuthConfig::Basic { username, password } => Self::Basic { username, password },
+            AuthConfig::Bearer { token } => Self::Bearer { token },
+            AuthConfig::Header { name, value } => Self::Header { name, value },
+        }
+    }
+}
+
+impl From<kreuzcrawl::AuthConfig> for AuthConfig {
+    fn from(val: kreuzcrawl::AuthConfig) -> Self {
+        match val {
+            kreuzcrawl::AuthConfig::Basic { username, password } => Self::Basic { username, password },
+            kreuzcrawl::AuthConfig::Bearer { token } => Self::Bearer { token },
+            kreuzcrawl::AuthConfig::Header { name, value } => Self::Header { name, value },
+        }
+    }
+}
+
+impl From<LinkType> for kreuzcrawl::LinkType {
+    fn from(val: LinkType) -> Self {
+        match val {
+            LinkType::Internal => Self::Internal,
+            LinkType::External => Self::External,
+            LinkType::Anchor => Self::Anchor,
+            LinkType::Document => Self::Document,
+        }
+    }
+}
+
+impl From<kreuzcrawl::LinkType> for LinkType {
+    fn from(val: kreuzcrawl::LinkType) -> Self {
+        match val {
+            kreuzcrawl::LinkType::Internal => Self::Internal,
+            kreuzcrawl::LinkType::External => Self::External,
+            kreuzcrawl::LinkType::Anchor => Self::Anchor,
+            kreuzcrawl::LinkType::Document => Self::Document,
+        }
+    }
+}
+
+impl From<ImageSource> for kreuzcrawl::ImageSource {
+    fn from(val: ImageSource) -> Self {
+        match val {
+            ImageSource::Img => Self::Img,
+            ImageSource::PictureSource => Self::PictureSource,
+            ImageSource::OgImage => Self::OgImage,
+            ImageSource::TwitterImage => Self::TwitterImage,
+        }
+    }
+}
+
+impl From<kreuzcrawl::ImageSource> for ImageSource {
+    fn from(val: kreuzcrawl::ImageSource) -> Self {
+        match val {
+            kreuzcrawl::ImageSource::Img => Self::Img,
+            kreuzcrawl::ImageSource::PictureSource => Self::PictureSource,
+            kreuzcrawl::ImageSource::OgImage => Self::OgImage,
+            kreuzcrawl::ImageSource::TwitterImage => Self::TwitterImage,
+        }
+    }
+}
+
+impl From<FeedType> for kreuzcrawl::FeedType {
+    fn from(val: FeedType) -> Self {
+        match val {
+            FeedType::Rss => Self::Rss,
+            FeedType::Atom => Self::Atom,
+            FeedType::JsonFeed => Self::JsonFeed,
+        }
+    }
+}
+
+impl From<kreuzcrawl::FeedType> for FeedType {
+    fn from(val: kreuzcrawl::FeedType) -> Self {
+        match val {
+            kreuzcrawl::FeedType::Rss => Self::Rss,
+            kreuzcrawl::FeedType::Atom => Self::Atom,
+            kreuzcrawl::FeedType::JsonFeed => Self::JsonFeed,
+        }
+    }
+}
+
+impl From<AssetCategory> for kreuzcrawl::AssetCategory {
+    fn from(val: AssetCategory) -> Self {
+        match val {
+            AssetCategory::Document => Self::Document,
+            AssetCategory::Image => Self::Image,
+            AssetCategory::Audio => Self::Audio,
+            AssetCategory::Video => Self::Video,
+            AssetCategory::Font => Self::Font,
+            AssetCategory::Stylesheet => Self::Stylesheet,
+            AssetCategory::Script => Self::Script,
+            AssetCategory::Archive => Self::Archive,
+            AssetCategory::Data => Self::Data,
+            AssetCategory::Other => Self::Other,
+        }
+    }
+}
+
+impl From<kreuzcrawl::AssetCategory> for AssetCategory {
+    fn from(val: kreuzcrawl::AssetCategory) -> Self {
+        match val {
+            kreuzcrawl::AssetCategory::Document => Self::Document,
+            kreuzcrawl::AssetCategory::Image => Self::Image,
+            kreuzcrawl::AssetCategory::Audio => Self::Audio,
+            kreuzcrawl::AssetCategory::Video => Self::Video,
+            kreuzcrawl::AssetCategory::Font => Self::Font,
+            kreuzcrawl::AssetCategory::Stylesheet => Self::Stylesheet,
+            kreuzcrawl::AssetCategory::Script => Self::Script,
+            kreuzcrawl::AssetCategory::Archive => Self::Archive,
+            kreuzcrawl::AssetCategory::Data => Self::Data,
+            kreuzcrawl::AssetCategory::Other => Self::Other,
+        }
+    }
+}
+
+impl From<kreuzcrawl::CrawlEvent> for CrawlEvent {
+    fn from(val: kreuzcrawl::CrawlEvent) -> Self {
+        match val {
+            kreuzcrawl::CrawlEvent::Page(_0) => Self::Page { _0: (*_0).into() },
+            kreuzcrawl::CrawlEvent::Error { url, error } => Self::Error { url, error },
+            kreuzcrawl::CrawlEvent::Complete { pages_crawled } => Self::Complete { pages_crawled },
+        }
+    }
+}
+
+/// Convert a `kreuzcrawl::CrawlError` error to a Magnus runtime error.
+#[allow(dead_code)]
+fn crawl_error_to_magnus_err(e: kreuzcrawl::CrawlError) -> magnus::Error {
+    let msg = e.to_string();
+    magnus::Error::new(unsafe { magnus::Ruby::get_unchecked() }.exception_runtime_error(), msg)
+}
+
+#[magnus::init]
+fn init(ruby: &Ruby) -> Result<(), Error> {
+    let module = ruby.define_module("Kreuzcrawl")?;
+
+    let class = module.define_class("ExtractionMeta", ruby.class_object())?;
+    class.define_singleton_method("new", function!(ExtractionMeta::new, 5))?;
+    class.define_method("cost", method!(ExtractionMeta::cost, 0))?;
+    class.define_method("prompt_tokens", method!(ExtractionMeta::prompt_tokens, 0))?;
+    class.define_method("completion_tokens", method!(ExtractionMeta::completion_tokens, 0))?;
+    class.define_method("model", method!(ExtractionMeta::model, 0))?;
+    class.define_method("chunks_processed", method!(ExtractionMeta::chunks_processed, 0))?;
+
+    let class = module.define_class("ProxyConfig", ruby.class_object())?;
+    class.define_singleton_method("new", function!(ProxyConfig::new, 3))?;
+    class.define_method("url", method!(ProxyConfig::url, 0))?;
+    class.define_method("username", method!(ProxyConfig::username, 0))?;
+    class.define_method("password", method!(ProxyConfig::password, 0))?;
+
+    let class = module.define_class("BrowserConfig", ruby.class_object())?;
+    class.define_singleton_method("new", function!(BrowserConfig::new, 6))?;
+    class.define_method("mode", method!(BrowserConfig::mode, 0))?;
+    class.define_method("endpoint", method!(BrowserConfig::endpoint, 0))?;
+    class.define_method("timeout", method!(BrowserConfig::timeout, 0))?;
+    class.define_method("wait", method!(BrowserConfig::wait, 0))?;
+    class.define_method("wait_selector", method!(BrowserConfig::wait_selector, 0))?;
+    class.define_method("extra_wait", method!(BrowserConfig::extra_wait, 0))?;
+
+    let class = module.define_class("CrawlConfig", ruby.class_object())?;
+    class.define_singleton_method("new", function!(CrawlConfig::new, 1))?;
+    class.define_method("max_depth", method!(CrawlConfig::max_depth, 0))?;
+    class.define_method("max_pages", method!(CrawlConfig::max_pages, 0))?;
+    class.define_method("max_concurrent", method!(CrawlConfig::max_concurrent, 0))?;
+    class.define_method("respect_robots_txt", method!(CrawlConfig::respect_robots_txt, 0))?;
+    class.define_method("user_agent", method!(CrawlConfig::user_agent, 0))?;
+    class.define_method("stay_on_domain", method!(CrawlConfig::stay_on_domain, 0))?;
+    class.define_method("allow_subdomains", method!(CrawlConfig::allow_subdomains, 0))?;
+    class.define_method("include_paths", method!(CrawlConfig::include_paths, 0))?;
+    class.define_method("exclude_paths", method!(CrawlConfig::exclude_paths, 0))?;
+    class.define_method("custom_headers", method!(CrawlConfig::custom_headers, 0))?;
+    class.define_method("request_timeout", method!(CrawlConfig::request_timeout, 0))?;
+    class.define_method("max_redirects", method!(CrawlConfig::max_redirects, 0))?;
+    class.define_method("retry_count", method!(CrawlConfig::retry_count, 0))?;
+    class.define_method("retry_codes", method!(CrawlConfig::retry_codes, 0))?;
+    class.define_method("cookies_enabled", method!(CrawlConfig::cookies_enabled, 0))?;
+    class.define_method("auth", method!(CrawlConfig::auth, 0))?;
+    class.define_method("max_body_size", method!(CrawlConfig::max_body_size, 0))?;
+    class.define_method("main_content_only", method!(CrawlConfig::main_content_only, 0))?;
+    class.define_method("remove_tags", method!(CrawlConfig::remove_tags, 0))?;
+    class.define_method("map_limit", method!(CrawlConfig::map_limit, 0))?;
+    class.define_method("map_search", method!(CrawlConfig::map_search, 0))?;
+    class.define_method("download_assets", method!(CrawlConfig::download_assets, 0))?;
+    class.define_method("asset_types", method!(CrawlConfig::asset_types, 0))?;
+    class.define_method("max_asset_size", method!(CrawlConfig::max_asset_size, 0))?;
+    class.define_method("browser", method!(CrawlConfig::browser, 0))?;
+    class.define_method("proxy", method!(CrawlConfig::proxy, 0))?;
+    class.define_method("user_agents", method!(CrawlConfig::user_agents, 0))?;
+    class.define_method("capture_screenshot", method!(CrawlConfig::capture_screenshot, 0))?;
+    class.define_method("download_documents", method!(CrawlConfig::download_documents, 0))?;
+    class.define_method("document_max_size", method!(CrawlConfig::document_max_size, 0))?;
+    class.define_method("document_mime_types", method!(CrawlConfig::document_mime_types, 0))?;
+    class.define_method("warc_output", method!(CrawlConfig::warc_output, 0))?;
+    class.define_method("browser_profile", method!(CrawlConfig::browser_profile, 0))?;
+    class.define_method("save_browser_profile", method!(CrawlConfig::save_browser_profile, 0))?;
+
+    let class = module.define_class("DownloadedDocument", ruby.class_object())?;
+    class.define_singleton_method("new", function!(DownloadedDocument::new, 7))?;
+    class.define_method("url", method!(DownloadedDocument::url, 0))?;
+    class.define_method("mime_type", method!(DownloadedDocument::mime_type, 0))?;
+    class.define_method("content", method!(DownloadedDocument::content, 0))?;
+    class.define_method("size", method!(DownloadedDocument::size, 0))?;
+    class.define_method("filename", method!(DownloadedDocument::filename, 0))?;
+    class.define_method("content_hash", method!(DownloadedDocument::content_hash, 0))?;
+    class.define_method("headers", method!(DownloadedDocument::headers, 0))?;
+
+    let class = module.define_class("InteractionResult", ruby.class_object())?;
+    class.define_singleton_method("new", function!(InteractionResult::new, 4))?;
+    class.define_method("action_results", method!(InteractionResult::action_results, 0))?;
+    class.define_method("final_html", method!(InteractionResult::final_html, 0))?;
+    class.define_method("final_url", method!(InteractionResult::final_url, 0))?;
+    class.define_method("screenshot", method!(InteractionResult::screenshot, 0))?;
+
+    let class = module.define_class("ActionResult", ruby.class_object())?;
+    class.define_singleton_method("new", function!(ActionResult::new, 5))?;
+    class.define_method("action_index", method!(ActionResult::action_index, 0))?;
+    class.define_method("action_type", method!(ActionResult::action_type, 0))?;
+    class.define_method("success", method!(ActionResult::success, 0))?;
+    class.define_method("data", method!(ActionResult::data, 0))?;
+    class.define_method("error", method!(ActionResult::error, 0))?;
+
+    let class = module.define_class("ScrapeResult", ruby.class_object())?;
+    class.define_singleton_method("new", function!(ScrapeResult::new, 1))?;
+    class.define_method("status_code", method!(ScrapeResult::status_code, 0))?;
+    class.define_method("content_type", method!(ScrapeResult::content_type, 0))?;
+    class.define_method("html", method!(ScrapeResult::html, 0))?;
+    class.define_method("body_size", method!(ScrapeResult::body_size, 0))?;
+    class.define_method("metadata", method!(ScrapeResult::metadata, 0))?;
+    class.define_method("links", method!(ScrapeResult::links, 0))?;
+    class.define_method("images", method!(ScrapeResult::images, 0))?;
+    class.define_method("feeds", method!(ScrapeResult::feeds, 0))?;
+    class.define_method("json_ld", method!(ScrapeResult::json_ld, 0))?;
+    class.define_method("is_allowed", method!(ScrapeResult::is_allowed, 0))?;
+    class.define_method("crawl_delay", method!(ScrapeResult::crawl_delay, 0))?;
+    class.define_method("noindex_detected", method!(ScrapeResult::noindex_detected, 0))?;
+    class.define_method("nofollow_detected", method!(ScrapeResult::nofollow_detected, 0))?;
+    class.define_method("x_robots_tag", method!(ScrapeResult::x_robots_tag, 0))?;
+    class.define_method("is_pdf", method!(ScrapeResult::is_pdf, 0))?;
+    class.define_method("was_skipped", method!(ScrapeResult::was_skipped, 0))?;
+    class.define_method("detected_charset", method!(ScrapeResult::detected_charset, 0))?;
+    class.define_method("main_content_only", method!(ScrapeResult::main_content_only, 0))?;
+    class.define_method("auth_header_sent", method!(ScrapeResult::auth_header_sent, 0))?;
+    class.define_method("response_meta", method!(ScrapeResult::response_meta, 0))?;
+    class.define_method("assets", method!(ScrapeResult::assets, 0))?;
+    class.define_method("js_render_hint", method!(ScrapeResult::js_render_hint, 0))?;
+    class.define_method("browser_used", method!(ScrapeResult::browser_used, 0))?;
+    class.define_method("markdown", method!(ScrapeResult::markdown, 0))?;
+    class.define_method("extracted_data", method!(ScrapeResult::extracted_data, 0))?;
+    class.define_method("extraction_meta", method!(ScrapeResult::extraction_meta, 0))?;
+    class.define_method("screenshot", method!(ScrapeResult::screenshot, 0))?;
+    class.define_method("downloaded_document", method!(ScrapeResult::downloaded_document, 0))?;
+
+    let class = module.define_class("CrawlPageResult", ruby.class_object())?;
+    class.define_singleton_method("new", function!(CrawlPageResult::new, 1))?;
+    class.define_method("url", method!(CrawlPageResult::url, 0))?;
+    class.define_method("normalized_url", method!(CrawlPageResult::normalized_url, 0))?;
+    class.define_method("status_code", method!(CrawlPageResult::status_code, 0))?;
+    class.define_method("content_type", method!(CrawlPageResult::content_type, 0))?;
+    class.define_method("html", method!(CrawlPageResult::html, 0))?;
+    class.define_method("body_size", method!(CrawlPageResult::body_size, 0))?;
+    class.define_method("metadata", method!(CrawlPageResult::metadata, 0))?;
+    class.define_method("links", method!(CrawlPageResult::links, 0))?;
+    class.define_method("images", method!(CrawlPageResult::images, 0))?;
+    class.define_method("feeds", method!(CrawlPageResult::feeds, 0))?;
+    class.define_method("json_ld", method!(CrawlPageResult::json_ld, 0))?;
+    class.define_method("depth", method!(CrawlPageResult::depth, 0))?;
+    class.define_method("stayed_on_domain", method!(CrawlPageResult::stayed_on_domain, 0))?;
+    class.define_method("was_skipped", method!(CrawlPageResult::was_skipped, 0))?;
+    class.define_method("is_pdf", method!(CrawlPageResult::is_pdf, 0))?;
+    class.define_method("detected_charset", method!(CrawlPageResult::detected_charset, 0))?;
+    class.define_method("markdown", method!(CrawlPageResult::markdown, 0))?;
+    class.define_method("extracted_data", method!(CrawlPageResult::extracted_data, 0))?;
+    class.define_method("extraction_meta", method!(CrawlPageResult::extraction_meta, 0))?;
+    class.define_method("downloaded_document", method!(CrawlPageResult::downloaded_document, 0))?;
+
+    let class = module.define_class("CrawlResult", ruby.class_object())?;
+    class.define_singleton_method("new", function!(CrawlResult::new, 7))?;
+    class.define_method("pages", method!(CrawlResult::pages, 0))?;
+    class.define_method("final_url", method!(CrawlResult::final_url, 0))?;
+    class.define_method("redirect_count", method!(CrawlResult::redirect_count, 0))?;
+    class.define_method("was_skipped", method!(CrawlResult::was_skipped, 0))?;
+    class.define_method("error", method!(CrawlResult::error, 0))?;
+    class.define_method("cookies", method!(CrawlResult::cookies, 0))?;
+    class.define_method("normalized_urls", method!(CrawlResult::normalized_urls, 0))?;
+
+    let class = module.define_class("SitemapUrl", ruby.class_object())?;
+    class.define_singleton_method("new", function!(SitemapUrl::new, 4))?;
+    class.define_method("url", method!(SitemapUrl::url, 0))?;
+    class.define_method("lastmod", method!(SitemapUrl::lastmod, 0))?;
+    class.define_method("changefreq", method!(SitemapUrl::changefreq, 0))?;
+    class.define_method("priority", method!(SitemapUrl::priority, 0))?;
+
+    let class = module.define_class("MapResult", ruby.class_object())?;
+    class.define_singleton_method("new", function!(MapResult::new, 1))?;
+    class.define_method("urls", method!(MapResult::urls, 0))?;
+
+    let class = module.define_class("MarkdownResult", ruby.class_object())?;
+    class.define_singleton_method("new", function!(MarkdownResult::new, 6))?;
+    class.define_method("content", method!(MarkdownResult::content, 0))?;
+    class.define_method("document_structure", method!(MarkdownResult::document_structure, 0))?;
+    class.define_method("tables", method!(MarkdownResult::tables, 0))?;
+    class.define_method("warnings", method!(MarkdownResult::warnings, 0))?;
+    class.define_method("citations", method!(MarkdownResult::citations, 0))?;
+    class.define_method("fit_content", method!(MarkdownResult::fit_content, 0))?;
+
+    let class = module.define_class("CachedPage", ruby.class_object())?;
+    class.define_singleton_method("new", function!(CachedPage::new, 7))?;
+    class.define_method("url", method!(CachedPage::url, 0))?;
+    class.define_method("status_code", method!(CachedPage::status_code, 0))?;
+    class.define_method("content_type", method!(CachedPage::content_type, 0))?;
+    class.define_method("body", method!(CachedPage::body, 0))?;
+    class.define_method("etag", method!(CachedPage::etag, 0))?;
+    class.define_method("last_modified", method!(CachedPage::last_modified, 0))?;
+    class.define_method("cached_at", method!(CachedPage::cached_at, 0))?;
+
+    let class = module.define_class("LinkInfo", ruby.class_object())?;
+    class.define_singleton_method("new", function!(LinkInfo::new, 5))?;
+    class.define_method("url", method!(LinkInfo::url, 0))?;
+    class.define_method("text", method!(LinkInfo::text, 0))?;
+    class.define_method("link_type", method!(LinkInfo::link_type, 0))?;
+    class.define_method("rel", method!(LinkInfo::rel, 0))?;
+    class.define_method("nofollow", method!(LinkInfo::nofollow, 0))?;
+
+    let class = module.define_class("ImageInfo", ruby.class_object())?;
+    class.define_singleton_method("new", function!(ImageInfo::new, 5))?;
+    class.define_method("url", method!(ImageInfo::url, 0))?;
+    class.define_method("alt", method!(ImageInfo::alt, 0))?;
+    class.define_method("width", method!(ImageInfo::width, 0))?;
+    class.define_method("height", method!(ImageInfo::height, 0))?;
+    class.define_method("source", method!(ImageInfo::source, 0))?;
+
+    let class = module.define_class("FeedInfo", ruby.class_object())?;
+    class.define_singleton_method("new", function!(FeedInfo::new, 3))?;
+    class.define_method("url", method!(FeedInfo::url, 0))?;
+    class.define_method("title", method!(FeedInfo::title, 0))?;
+    class.define_method("feed_type", method!(FeedInfo::feed_type, 0))?;
+
+    let class = module.define_class("JsonLdEntry", ruby.class_object())?;
+    class.define_singleton_method("new", function!(JsonLdEntry::new, 3))?;
+    class.define_method("schema_type", method!(JsonLdEntry::schema_type, 0))?;
+    class.define_method("name", method!(JsonLdEntry::name, 0))?;
+    class.define_method("raw", method!(JsonLdEntry::raw, 0))?;
+
+    let class = module.define_class("CookieInfo", ruby.class_object())?;
+    class.define_singleton_method("new", function!(CookieInfo::new, 4))?;
+    class.define_method("name", method!(CookieInfo::name, 0))?;
+    class.define_method("value", method!(CookieInfo::value, 0))?;
+    class.define_method("domain", method!(CookieInfo::domain, 0))?;
+    class.define_method("path", method!(CookieInfo::path, 0))?;
+
+    let class = module.define_class("DownloadedAsset", ruby.class_object())?;
+    class.define_singleton_method("new", function!(DownloadedAsset::new, 6))?;
+    class.define_method("url", method!(DownloadedAsset::url, 0))?;
+    class.define_method("content_hash", method!(DownloadedAsset::content_hash, 0))?;
+    class.define_method("mime_type", method!(DownloadedAsset::mime_type, 0))?;
+    class.define_method("size", method!(DownloadedAsset::size, 0))?;
+    class.define_method("asset_category", method!(DownloadedAsset::asset_category, 0))?;
+    class.define_method("html_tag", method!(DownloadedAsset::html_tag, 0))?;
+
+    let class = module.define_class("ArticleMetadata", ruby.class_object())?;
+    class.define_singleton_method("new", function!(ArticleMetadata::new, 5))?;
+    class.define_method("published_time", method!(ArticleMetadata::published_time, 0))?;
+    class.define_method("modified_time", method!(ArticleMetadata::modified_time, 0))?;
+    class.define_method("author", method!(ArticleMetadata::author, 0))?;
+    class.define_method("section", method!(ArticleMetadata::section, 0))?;
+    class.define_method("tags", method!(ArticleMetadata::tags, 0))?;
+
+    let class = module.define_class("HreflangEntry", ruby.class_object())?;
+    class.define_singleton_method("new", function!(HreflangEntry::new, 2))?;
+    class.define_method("lang", method!(HreflangEntry::lang, 0))?;
+    class.define_method("url", method!(HreflangEntry::url, 0))?;
+
+    let class = module.define_class("FaviconInfo", ruby.class_object())?;
+    class.define_singleton_method("new", function!(FaviconInfo::new, 4))?;
+    class.define_method("url", method!(FaviconInfo::url, 0))?;
+    class.define_method("rel", method!(FaviconInfo::rel, 0))?;
+    class.define_method("sizes", method!(FaviconInfo::sizes, 0))?;
+    class.define_method("mime_type", method!(FaviconInfo::mime_type, 0))?;
+
+    let class = module.define_class("HeadingInfo", ruby.class_object())?;
+    class.define_singleton_method("new", function!(HeadingInfo::new, 2))?;
+    class.define_method("level", method!(HeadingInfo::level, 0))?;
+    class.define_method("text", method!(HeadingInfo::text, 0))?;
+
+    let class = module.define_class("ResponseMeta", ruby.class_object())?;
+    class.define_singleton_method("new", function!(ResponseMeta::new, 7))?;
+    class.define_method("etag", method!(ResponseMeta::etag, 0))?;
+    class.define_method("last_modified", method!(ResponseMeta::last_modified, 0))?;
+    class.define_method("cache_control", method!(ResponseMeta::cache_control, 0))?;
+    class.define_method("server", method!(ResponseMeta::server, 0))?;
+    class.define_method("x_powered_by", method!(ResponseMeta::x_powered_by, 0))?;
+    class.define_method("content_language", method!(ResponseMeta::content_language, 0))?;
+    class.define_method("content_encoding", method!(ResponseMeta::content_encoding, 0))?;
+
+    let class = module.define_class("PageMetadata", ruby.class_object())?;
+    class.define_singleton_method("new", function!(PageMetadata::new, 1))?;
+    class.define_method("title", method!(PageMetadata::title, 0))?;
+    class.define_method("description", method!(PageMetadata::description, 0))?;
+    class.define_method("canonical_url", method!(PageMetadata::canonical_url, 0))?;
+    class.define_method("keywords", method!(PageMetadata::keywords, 0))?;
+    class.define_method("author", method!(PageMetadata::author, 0))?;
+    class.define_method("viewport", method!(PageMetadata::viewport, 0))?;
+    class.define_method("theme_color", method!(PageMetadata::theme_color, 0))?;
+    class.define_method("generator", method!(PageMetadata::generator, 0))?;
+    class.define_method("robots", method!(PageMetadata::robots, 0))?;
+    class.define_method("html_lang", method!(PageMetadata::html_lang, 0))?;
+    class.define_method("html_dir", method!(PageMetadata::html_dir, 0))?;
+    class.define_method("og_title", method!(PageMetadata::og_title, 0))?;
+    class.define_method("og_type", method!(PageMetadata::og_type, 0))?;
+    class.define_method("og_image", method!(PageMetadata::og_image, 0))?;
+    class.define_method("og_description", method!(PageMetadata::og_description, 0))?;
+    class.define_method("og_url", method!(PageMetadata::og_url, 0))?;
+    class.define_method("og_site_name", method!(PageMetadata::og_site_name, 0))?;
+    class.define_method("og_locale", method!(PageMetadata::og_locale, 0))?;
+    class.define_method("og_video", method!(PageMetadata::og_video, 0))?;
+    class.define_method("og_audio", method!(PageMetadata::og_audio, 0))?;
+    class.define_method("og_locale_alternates", method!(PageMetadata::og_locale_alternates, 0))?;
+    class.define_method("twitter_card", method!(PageMetadata::twitter_card, 0))?;
+    class.define_method("twitter_title", method!(PageMetadata::twitter_title, 0))?;
+    class.define_method("twitter_description", method!(PageMetadata::twitter_description, 0))?;
+    class.define_method("twitter_image", method!(PageMetadata::twitter_image, 0))?;
+    class.define_method("twitter_site", method!(PageMetadata::twitter_site, 0))?;
+    class.define_method("twitter_creator", method!(PageMetadata::twitter_creator, 0))?;
+    class.define_method("dc_title", method!(PageMetadata::dc_title, 0))?;
+    class.define_method("dc_creator", method!(PageMetadata::dc_creator, 0))?;
+    class.define_method("dc_subject", method!(PageMetadata::dc_subject, 0))?;
+    class.define_method("dc_description", method!(PageMetadata::dc_description, 0))?;
+    class.define_method("dc_publisher", method!(PageMetadata::dc_publisher, 0))?;
+    class.define_method("dc_date", method!(PageMetadata::dc_date, 0))?;
+    class.define_method("dc_type", method!(PageMetadata::dc_type, 0))?;
+    class.define_method("dc_format", method!(PageMetadata::dc_format, 0))?;
+    class.define_method("dc_identifier", method!(PageMetadata::dc_identifier, 0))?;
+    class.define_method("dc_language", method!(PageMetadata::dc_language, 0))?;
+    class.define_method("dc_rights", method!(PageMetadata::dc_rights, 0))?;
+    class.define_method("article", method!(PageMetadata::article, 0))?;
+    class.define_method("hreflangs", method!(PageMetadata::hreflangs, 0))?;
+    class.define_method("favicons", method!(PageMetadata::favicons, 0))?;
+    class.define_method("headings", method!(PageMetadata::headings, 0))?;
+    class.define_method("word_count", method!(PageMetadata::word_count, 0))?;
+
+    let class = module.define_class("CitationResult", ruby.class_object())?;
+    class.define_singleton_method("new", function!(CitationResult::new, 2))?;
+    class.define_method("content", method!(CitationResult::content, 0))?;
+    class.define_method("references", method!(CitationResult::references, 0))?;
+
+    let class = module.define_class("CitationReference", ruby.class_object())?;
+    class.define_singleton_method("new", function!(CitationReference::new, 3))?;
+    class.define_method("index", method!(CitationReference::index, 0))?;
+    class.define_method("url", method!(CitationReference::url, 0))?;
+    class.define_method("text", method!(CitationReference::text, 0))?;
+
+    let _class = module.define_class("CrawlEngineHandle", ruby.class_object())?;
+
+    let class = module.define_class("BatchScrapeResult", ruby.class_object())?;
+    class.define_singleton_method("new", function!(BatchScrapeResult::new, 3))?;
+    class.define_method("url", method!(BatchScrapeResult::url, 0))?;
+    class.define_method("result", method!(BatchScrapeResult::result, 0))?;
+    class.define_method("error", method!(BatchScrapeResult::error, 0))?;
+
+    let class = module.define_class("BatchCrawlResult", ruby.class_object())?;
+    class.define_singleton_method("new", function!(BatchCrawlResult::new, 3))?;
+    class.define_method("url", method!(BatchCrawlResult::url, 0))?;
+    class.define_method("result", method!(BatchCrawlResult::result, 0))?;
+    class.define_method("error", method!(BatchCrawlResult::error, 0))?;
+
+    module.define_module_function("create_engine", function!(create_engine, 1))?;
+    module.define_module_function("scrape", function!(scrape, 2))?;
+    module.define_module_function("scrape_async", function!(scrape_async, 2))?;
+    module.define_module_function("crawl", function!(crawl, 2))?;
+    module.define_module_function("crawl_async", function!(crawl_async, 2))?;
+    module.define_module_function("map_urls", function!(map_urls, 2))?;
+    module.define_module_function("map_urls_async", function!(map_urls_async, 2))?;
+    module.define_module_function("batch_scrape", function!(batch_scrape, 2))?;
+    module.define_module_function("batch_scrape_async", function!(batch_scrape_async, 2))?;
+    module.define_module_function("batch_crawl", function!(batch_crawl, 2))?;
+    module.define_module_function("batch_crawl_async", function!(batch_crawl_async, 2))?;
+
+    Ok(())
+}