spikard-ffi 0.15.2

// This file is auto-generated by alef. DO NOT EDIT.
// alef:hash:58ff6957569f8eb716f5897d3a69fe75d59bb5a71d34f5e38295001c8c1855b5
// Re-generate with: alef generate
#![allow(dead_code, unused_imports, unused_variables, unused_mut, noop_method_call)]
#![allow(
    clippy::too_many_arguments,
    clippy::let_unit_value,
    clippy::needless_borrow,
    clippy::redundant_locals,
    dropping_references,
    clippy::unnecessary_cast,
    clippy::unused_unit,
    clippy::unwrap_or_default,
    clippy::derivable_impls,
    clippy::needless_borrows_for_generic_args,
    clippy::unnecessary_fallible_conversions,
    clippy::useless_conversion,
    clippy::type_complexity,
    clippy::clone_on_copy
)]
#![allow(
    clippy::missing_safety_doc,
    clippy::doc_lazy_continuation,
    clippy::doc_overindented_list_items
)]

use std::cell::RefCell;
use std::ffi::{c_char, CStr, CString};

thread_local! {
    static LAST_ERROR_CODE: RefCell<i32> = const { RefCell::new(0) };
    static LAST_ERROR_CONTEXT: RefCell<Option<CString>> = const { RefCell::new(None) };
}

fn set_last_error(code: i32, message: &str) {
    LAST_ERROR_CODE.with_borrow_mut(|c| *c = code);
    LAST_ERROR_CONTEXT.with_borrow_mut(|c| *c = CString::new(message).ok());
}

fn clear_last_error() {
    LAST_ERROR_CODE.with_borrow_mut(|c| *c = 0);
    LAST_ERROR_CONTEXT.with_borrow_mut(|c| *c = None);
}

/// Return the last error code (0 means no error).
/// # Safety
/// Caller must ensure all pointer arguments are valid or null.
/// Returned pointers must be freed with the appropriate free function.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_last_error_code() -> i32 {
    LAST_ERROR_CODE.with_borrow(|c| *c)
}

/// Return the last error message. The pointer is valid until the next FFI call on this thread.
/// # Safety
/// Caller must ensure all pointer arguments are valid or null.
/// Returned pointers must be freed with the appropriate free function.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_last_error_context() -> *const c_char {
    LAST_ERROR_CONTEXT.with_borrow(|ctx| ctx.as_ref().map_or(std::ptr::null(), |c| c.as_ptr()))
}

/// Free a string previously returned by this library.
/// # Safety
/// Pointer must have been returned by this library, or be null.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_free_string(ptr: *mut c_char) {
    if !ptr.is_null() {
        // SAFETY: ptr was allocated by CString::into_raw; caller ensures no aliases.
        unsafe {
            drop(CString::from_raw(ptr));
        }
    }
}

/// Free a byte buffer previously returned by this library via out-params.
/// `ptr`, `len`, and `cap` must match the values written by the library function,
/// or the call must pass `ptr = null` (in which case it is a no-op).
/// # Safety
/// Pointer must have been returned by this library (via out_ptr / out_len / out_cap
/// out-params), or be null. The len and cap values must be unchanged since the call.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_free_bytes(ptr: *mut u8, len: usize, cap: usize) {
    if !ptr.is_null() {
        // SAFETY: ptr/len/cap were produced by Vec::into_raw_parts (or equivalent)
        // by this library; caller must not have mutated them.
        unsafe {
            drop(Vec::from_raw_parts(ptr, len, cap));
        }
    }
}

/// Return the library version string. The pointer is static and must NOT be freed.
/// # Safety
/// Caller must ensure all pointer arguments are valid or null.
/// Returned pointers must be freed with the appropriate free function.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_version() -> *const c_char {
    static VERSION: &str = concat!(env!("CARGO_PKG_VERSION"), "\0");
    VERSION.as_ptr() as *const c_char
}

/// Create a `UploadFile` from a JSON string. Returns null on failure.
/// # Safety
/// JSON string must be valid UTF-8 and null-terminated.
/// Returned handle must be freed with `spikard_upload_file_free`.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_upload_file_from_json(json: *const c_char) -> *mut spikard::UploadFile {
    clear_last_error();
    if json.is_null() {
        set_last_error(1, "Null pointer passed for JSON string");
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees json is a valid pointer; string is valid UTF-8 from caller.
    let c_str = match unsafe { CStr::from_ptr(json) }.to_str() {
        Ok(s) => s,
        Err(_) => {
            set_last_error(1, "Invalid UTF-8 in JSON string");
            return std::ptr::null_mut();
        }
    };
    match serde_json::from_str::<spikard::UploadFile>(c_str) {
        Ok(val) => Box::into_raw(Box::new(val)),
        Err(e) => {
            set_last_error(2, &e.to_string());
            std::ptr::null_mut()
        }
    }
}

/// Serialize a `UploadFile` to a JSON string. Returns null on failure.
/// # Safety
/// `ptr` must be a valid, non-null pointer returned by a `spikard` function.
/// The returned string must be freed with `spikard_free_string`.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_upload_file_to_json(ptr: *const spikard::UploadFile) -> *mut c_char {
    clear_last_error();
    if ptr.is_null() {
        set_last_error(1, "Null pointer passed to to_json");
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let val = unsafe { &*ptr };
    match serde_json::to_string(val) {
        Ok(s) => match CString::new(s) {
            Ok(cs) => cs.into_raw(),
            Err(e) => {
                set_last_error(2, &e.to_string());
                std::ptr::null_mut()
            }
        },
        Err(e) => {
            set_last_error(2, &e.to_string());
            std::ptr::null_mut()
        }
    }
}

/// Free a `UploadFile` handle.
/// # Safety
/// Pointer must have been returned by this library, or be null.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_upload_file_free(ptr: *mut spikard::UploadFile) {
    if !ptr.is_null() {
        // SAFETY: ptr was allocated by Box::into_raw; caller ensures no aliases.
        unsafe {
            drop(Box::from_raw(ptr));
        }
    }
}

/// Get the `filename` field from a `UploadFile`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_upload_file_filename(ptr: *const spikard::UploadFile) -> *mut std::ffi::c_char {
    if ptr.is_null() {
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    match CString::new(obj.filename.to_string()) {
        Ok(cs) => cs.into_raw(),
        Err(_) => std::ptr::null_mut(),
    }
}

/// Get the `content_type` field from a `UploadFile`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_upload_file_content_type(ptr: *const spikard::UploadFile) -> *mut std::ffi::c_char {
    if ptr.is_null() {
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    match &obj.content_type {
        Some(val) => match CString::new(val.to_string()) {
            Ok(cs) => cs.into_raw(),
            Err(_) => std::ptr::null_mut(),
        },
        None => std::ptr::null_mut(),
    }
}

/// Get the `size` field from a `UploadFile`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_upload_file_size(ptr: *const spikard::UploadFile) -> usize {
    if ptr.is_null() {
        return 0;
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    match &obj.size {
        Some(val) => *val,
        None => 0,
    }
}

/// Get the `content` field from a `UploadFile`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_upload_file_content(ptr: *const spikard::UploadFile, out_len: *mut usize) -> *mut u8 {
    if ptr.is_null() {
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    let data = &obj.content;
    if !out_len.is_null() {
        // SAFETY: null check above guarantees out_len is a valid pointer.
        unsafe {
            *out_len = data.len();
        }
    }
    data.as_ptr() as *mut u8
}

/// Get the `content_encoding` field from a `UploadFile`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_upload_file_content_encoding(
    ptr: *const spikard::UploadFile,
) -> *mut std::ffi::c_char {
    if ptr.is_null() {
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    match &obj.content_encoding {
        Some(val) => match CString::new(val.to_string()) {
            Ok(cs) => cs.into_raw(),
            Err(_) => std::ptr::null_mut(),
        },
        None => std::ptr::null_mut(),
    }
}

/// Get the raw file content as bytes.
///
/// This provides zero-copy access to the underlying buffer.
/// \note SAFETY: Caller must ensure all pointer arguments are valid or null. Returned pointers must be
/// freed with the appropriate free function.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_upload_file_as_bytes(this: *const spikard::UploadFile) -> *mut u8 {
    clear_last_error();
    if this.is_null() {
        set_last_error(1, "Null pointer passed for self");
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees this is a valid pointer.
    let obj = unsafe { &*this };

    let result = obj.as_bytes();
    result.as_ptr() as *mut u8
}

/// Read the file content as a UTF-8 string.
/// \note Returns an error if the content is not valid UTF-8.
/// \note SAFETY: Caller must ensure all pointer arguments are valid or null. Returned pointers must be
/// freed with the appropriate free function.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_upload_file_read_to_string(this: *const spikard::UploadFile) -> *mut std::ffi::c_char {
    clear_last_error();
    if this.is_null() {
        set_last_error(1, "Null pointer passed for self");
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees this is a valid pointer.
    let obj = unsafe { &*this };

    let result = obj.read_to_string();
    match result {
        Ok(val) => match CString::new(val.to_string()) {
            Ok(cs) => cs.into_raw(),
            Err(_) => std::ptr::null_mut(),
        },
        Err(e) => {
            set_last_error(2, &e.to_string());
            std::ptr::null_mut()
        }
    }
}

/// Get the content type, defaulting to "application/octet-stream".
/// \note SAFETY: Caller must ensure all pointer arguments are valid or null. Returned pointers must be
/// freed with the appropriate free function.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_upload_file_content_type_or_default(
    this: *const spikard::UploadFile,
) -> *mut std::ffi::c_char {
    clear_last_error();
    if this.is_null() {
        set_last_error(1, "Null pointer passed for self");
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees this is a valid pointer.
    let obj = unsafe { &*this };

    let result = obj.content_type_or_default();
    let result = result.to_owned();
    match CString::new(result.to_string()) {
        Ok(cs) => cs.into_raw(),
        Err(_) => std::ptr::null_mut(),
    }
}

/// Create a `CorsConfig` from a JSON string. Returns null on failure.
/// # Safety
/// JSON string must be valid UTF-8 and null-terminated.
/// Returned handle must be freed with `spikard_cors_config_free`.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_cors_config_from_json(json: *const c_char) -> *mut spikard_core::CorsConfig {
    clear_last_error();
    if json.is_null() {
        set_last_error(1, "Null pointer passed for JSON string");
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees json is a valid pointer; string is valid UTF-8 from caller.
    let c_str = match unsafe { CStr::from_ptr(json) }.to_str() {
        Ok(s) => s,
        Err(_) => {
            set_last_error(1, "Invalid UTF-8 in JSON string");
            return std::ptr::null_mut();
        }
    };
    match serde_json::from_str::<spikard_core::CorsConfig>(c_str) {
        Ok(val) => Box::into_raw(Box::new(val)),
        Err(e) => {
            set_last_error(2, &e.to_string());
            std::ptr::null_mut()
        }
    }
}

/// Serialize a `CorsConfig` to a JSON string. Returns null on failure.
/// # Safety
/// `ptr` must be a valid, non-null pointer returned by a `spikard` function.
/// The returned string must be freed with `spikard_free_string`.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_cors_config_to_json(ptr: *const spikard_core::CorsConfig) -> *mut c_char {
    clear_last_error();
    if ptr.is_null() {
        set_last_error(1, "Null pointer passed to to_json");
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let val = unsafe { &*ptr };
    match serde_json::to_string(val) {
        Ok(s) => match CString::new(s) {
            Ok(cs) => cs.into_raw(),
            Err(e) => {
                set_last_error(2, &e.to_string());
                std::ptr::null_mut()
            }
        },
        Err(e) => {
            set_last_error(2, &e.to_string());
            std::ptr::null_mut()
        }
    }
}

/// Free a `CorsConfig` handle.
/// # Safety
/// Pointer must have been returned by this library, or be null.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_cors_config_free(ptr: *mut spikard_core::CorsConfig) {
    if !ptr.is_null() {
        // SAFETY: ptr was allocated by Box::into_raw; caller ensures no aliases.
        unsafe {
            drop(Box::from_raw(ptr));
        }
    }
}

/// Get the `allowed_origins` field from a `CorsConfig`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_cors_config_allowed_origins(
    ptr: *const spikard_core::CorsConfig,
) -> *mut std::ffi::c_char {
    if ptr.is_null() {
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    match serde_json::to_string(&obj.allowed_origins) {
        Ok(s) => match CString::new(s) {
            Ok(cs) => cs.into_raw(),
            Err(_) => std::ptr::null_mut(),
        },
        Err(_) => std::ptr::null_mut(),
    }
}

/// Get the `allowed_methods` field from a `CorsConfig`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_cors_config_allowed_methods(
    ptr: *const spikard_core::CorsConfig,
) -> *mut std::ffi::c_char {
    if ptr.is_null() {
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    match serde_json::to_string(&obj.allowed_methods) {
        Ok(s) => match CString::new(s) {
            Ok(cs) => cs.into_raw(),
            Err(_) => std::ptr::null_mut(),
        },
        Err(_) => std::ptr::null_mut(),
    }
}

/// Get the `allowed_headers` field from a `CorsConfig`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_cors_config_allowed_headers(
    ptr: *const spikard_core::CorsConfig,
) -> *mut std::ffi::c_char {
    if ptr.is_null() {
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    match serde_json::to_string(&obj.allowed_headers) {
        Ok(s) => match CString::new(s) {
            Ok(cs) => cs.into_raw(),
            Err(_) => std::ptr::null_mut(),
        },
        Err(_) => std::ptr::null_mut(),
    }
}

/// Get the `expose_headers` field from a `CorsConfig`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_cors_config_expose_headers(
    ptr: *const spikard_core::CorsConfig,
) -> *mut std::ffi::c_char {
    if ptr.is_null() {
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    match &obj.expose_headers {
        Some(val) => match serde_json::to_string(&val) {
            Ok(s) => match CString::new(s) {
                Ok(cs) => cs.into_raw(),
                Err(_) => std::ptr::null_mut(),
            },
            Err(_) => std::ptr::null_mut(),
        },
        None => std::ptr::null_mut(),
    }
}

/// Get the `max_age` field from a `CorsConfig`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_cors_config_max_age(ptr: *const spikard_core::CorsConfig) -> u32 {
    if ptr.is_null() {
        return 0;
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    match &obj.max_age {
        Some(val) => *val,
        None => 0,
    }
}

/// Get the `allow_credentials` field from a `CorsConfig`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_cors_config_allow_credentials(ptr: *const spikard_core::CorsConfig) -> i32 {
    if ptr.is_null() {
        return 0;
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    match &obj.allow_credentials {
        Some(val) => *val as i32,
        None => 0,
    }
}

/// Get the cached joined methods string for preflight responses
/// \note SAFETY: Caller must ensure all pointer arguments are valid or null. Returned pointers must be
/// freed with the appropriate free function.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_cors_config_allowed_methods_joined(
    this: *const spikard_core::CorsConfig,
) -> *mut std::ffi::c_char {
    clear_last_error();
    if this.is_null() {
        set_last_error(1, "Null pointer passed for self");
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees this is a valid pointer.
    let obj = unsafe { &*this };

    let result = obj.allowed_methods_joined();
    let result = result.to_owned();
    match CString::new(result.to_string()) {
        Ok(cs) => cs.into_raw(),
        Err(_) => std::ptr::null_mut(),
    }
}

/// Get the cached joined headers string for preflight responses
/// \note SAFETY: Caller must ensure all pointer arguments are valid or null. Returned pointers must be
/// freed with the appropriate free function.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_cors_config_allowed_headers_joined(
    this: *const spikard_core::CorsConfig,
) -> *mut std::ffi::c_char {
    clear_last_error();
    if this.is_null() {
        set_last_error(1, "Null pointer passed for self");
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees this is a valid pointer.
    let obj = unsafe { &*this };

    let result = obj.allowed_headers_joined();
    let result = result.to_owned();
    match CString::new(result.to_string()) {
        Ok(cs) => cs.into_raw(),
        Err(_) => std::ptr::null_mut(),
    }
}

/// Check if an origin is allowed (O(1) with wildcard, O(n) for exact match)
/// \note SAFETY: Caller must ensure all pointer arguments are valid or null. Returned pointers must be
/// freed with the appropriate free function.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_cors_config_is_origin_allowed(
    this: *const spikard_core::CorsConfig,
    origin: *const std::ffi::c_char,
) -> i32 {
    clear_last_error();
    if this.is_null() {
        set_last_error(1, "Null pointer passed for self");
        return 0;
    }
    // SAFETY: null check above guarantees this is a valid pointer.
    let obj = unsafe { &*this };

    if origin.is_null() {
        set_last_error(1, "Null pointer passed for parameter 'origin'");
        return 0;
    }
    // SAFETY: null check above guarantees origin is a valid pointer; string is valid UTF-8 from caller.
    let origin_rs = match unsafe { CStr::from_ptr(origin) }.to_str() {
        Ok(s) => s.to_string(),
        Err(_) => {
            set_last_error(1, "Invalid UTF-8 in parameter 'origin'");
            return 0;
        }
    };
    let result = obj.is_origin_allowed(&origin_rs);
    if result {
        1
    } else {
        0
    }
}

/// Check if a method is allowed (O(1) with wildcard, O(n) for exact match)
/// \note SAFETY: Caller must ensure all pointer arguments are valid or null. Returned pointers must be
/// freed with the appropriate free function.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_cors_config_is_method_allowed(
    this: *const spikard_core::CorsConfig,
    method: *const std::ffi::c_char,
) -> i32 {
    clear_last_error();
    if this.is_null() {
        set_last_error(1, "Null pointer passed for self");
        return 0;
    }
    // SAFETY: null check above guarantees this is a valid pointer.
    let obj = unsafe { &*this };

    if method.is_null() {
        set_last_error(1, "Null pointer passed for parameter 'method'");
        return 0;
    }
    // SAFETY: null check above guarantees method is a valid pointer; string is valid UTF-8 from caller.
    let method_rs = match unsafe { CStr::from_ptr(method) }.to_str() {
        Ok(s) => s.to_string(),
        Err(_) => {
            set_last_error(1, "Invalid UTF-8 in parameter 'method'");
            return 0;
        }
    };
    let result = obj.is_method_allowed(&method_rs);
    if result {
        1
    } else {
        0
    }
}

/// Check if all requested headers are allowed (O(n) where n = num requested headers)
/// \note SAFETY: Caller must ensure all pointer arguments are valid or null. Returned pointers must be
/// freed with the appropriate free function.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_cors_config_are_headers_allowed(
    this: *const spikard_core::CorsConfig,
    requested: *const std::ffi::c_char,
) -> i32 {
    clear_last_error();
    if this.is_null() {
        set_last_error(1, "Null pointer passed for self");
        return 0;
    }
    // SAFETY: null check above guarantees this is a valid pointer.
    let obj = unsafe { &*this };

    if requested.is_null() {
        set_last_error(1, "Null pointer passed for parameter 'requested'");
        return 0;
    }
    // SAFETY: null check above guarantees requested is a valid pointer; string is valid UTF-8 from caller.
    let requested_rs_str = match unsafe { CStr::from_ptr(requested) }.to_str() {
        Ok(s) => s,
        Err(_) => {
            set_last_error(1, "Invalid UTF-8 in parameter 'requested'");
            return 0;
        }
    };
    let requested_rs = match serde_json::from_str::<Vec<String>>(requested_rs_str) {
        Ok(v) => v,
        Err(e) => {
            set_last_error(2, &e.to_string());
            return 0;
        }
    };
    let requested_rs_refs: Vec<&str> = requested_rs.iter().map(|s| s.as_str()).collect();
    let result = obj.are_headers_allowed(&requested_rs_refs);
    if result {
        1
    } else {
        0
    }
}

/// \note SAFETY: Caller must ensure all pointer arguments are valid or null. Returned pointers must be
/// freed with the appropriate free function.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_cors_config_default() -> *mut spikard_core::CorsConfig {
    clear_last_error();
    let result = spikard_core::CorsConfig::default();
    Box::into_raw(Box::new(result))
}

/// Create a `CompressionConfig` from a JSON string. Returns null on failure.
/// # Safety
/// JSON string must be valid UTF-8 and null-terminated.
/// Returned handle must be freed with `spikard_compression_config_free`.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_compression_config_from_json(
    json: *const c_char,
) -> *mut spikard_core::CompressionConfig {
    clear_last_error();
    if json.is_null() {
        set_last_error(1, "Null pointer passed for JSON string");
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees json is a valid pointer; string is valid UTF-8 from caller.
    let c_str = match unsafe { CStr::from_ptr(json) }.to_str() {
        Ok(s) => s,
        Err(_) => {
            set_last_error(1, "Invalid UTF-8 in JSON string");
            return std::ptr::null_mut();
        }
    };
    match serde_json::from_str::<spikard_core::CompressionConfig>(c_str) {
        Ok(val) => Box::into_raw(Box::new(val)),
        Err(e) => {
            set_last_error(2, &e.to_string());
            std::ptr::null_mut()
        }
    }
}

/// Serialize a `CompressionConfig` to a JSON string. Returns null on failure.
/// # Safety
/// `ptr` must be a valid, non-null pointer returned by a `spikard` function.
/// The returned string must be freed with `spikard_free_string`.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_compression_config_to_json(
    ptr: *const spikard_core::CompressionConfig,
) -> *mut c_char {
    clear_last_error();
    if ptr.is_null() {
        set_last_error(1, "Null pointer passed to to_json");
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let val = unsafe { &*ptr };
    match serde_json::to_string(val) {
        Ok(s) => match CString::new(s) {
            Ok(cs) => cs.into_raw(),
            Err(e) => {
                set_last_error(2, &e.to_string());
                std::ptr::null_mut()
            }
        },
        Err(e) => {
            set_last_error(2, &e.to_string());
            std::ptr::null_mut()
        }
    }
}

/// Free a `CompressionConfig` handle.
/// # Safety
/// Pointer must have been returned by this library, or be null.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_compression_config_free(ptr: *mut spikard_core::CompressionConfig) {
    if !ptr.is_null() {
        // SAFETY: ptr was allocated by Box::into_raw; caller ensures no aliases.
        unsafe {
            drop(Box::from_raw(ptr));
        }
    }
}

/// Get the `gzip` field from a `CompressionConfig`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_compression_config_gzip(ptr: *const spikard_core::CompressionConfig) -> i32 {
    if ptr.is_null() {
        return 0;
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    obj.gzip as i32
}

/// Get the `brotli` field from a `CompressionConfig`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_compression_config_brotli(ptr: *const spikard_core::CompressionConfig) -> i32 {
    if ptr.is_null() {
        return 0;
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    obj.brotli as i32
}

/// Get the `min_size` field from a `CompressionConfig`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_compression_config_min_size(ptr: *const spikard_core::CompressionConfig) -> usize {
    if ptr.is_null() {
        return 0;
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    obj.min_size
}

/// Get the `quality` field from a `CompressionConfig`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_compression_config_quality(ptr: *const spikard_core::CompressionConfig) -> u32 {
    if ptr.is_null() {
        return 0;
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    obj.quality
}

/// \note SAFETY: Caller must ensure all pointer arguments are valid or null. Returned pointers must be
/// freed with the appropriate free function.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_compression_config_default() -> *mut spikard_core::CompressionConfig {
    clear_last_error();
    let result = spikard_core::CompressionConfig::default();
    Box::into_raw(Box::new(result))
}

/// Create a `RateLimitConfig` from a JSON string. Returns null on failure.
/// # Safety
/// JSON string must be valid UTF-8 and null-terminated.
/// Returned handle must be freed with `spikard_rate_limit_config_free`.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_rate_limit_config_from_json(
    json: *const c_char,
) -> *mut spikard_core::RateLimitConfig {
    clear_last_error();
    if json.is_null() {
        set_last_error(1, "Null pointer passed for JSON string");
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees json is a valid pointer; string is valid UTF-8 from caller.
    let c_str = match unsafe { CStr::from_ptr(json) }.to_str() {
        Ok(s) => s,
        Err(_) => {
            set_last_error(1, "Invalid UTF-8 in JSON string");
            return std::ptr::null_mut();
        }
    };
    match serde_json::from_str::<spikard_core::RateLimitConfig>(c_str) {
        Ok(val) => Box::into_raw(Box::new(val)),
        Err(e) => {
            set_last_error(2, &e.to_string());
            std::ptr::null_mut()
        }
    }
}

/// Serialize a `RateLimitConfig` to a JSON string. Returns null on failure.
/// # Safety
/// `ptr` must be a valid, non-null pointer returned by a `spikard` function.
/// The returned string must be freed with `spikard_free_string`.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_rate_limit_config_to_json(ptr: *const spikard_core::RateLimitConfig) -> *mut c_char {
    clear_last_error();
    if ptr.is_null() {
        set_last_error(1, "Null pointer passed to to_json");
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let val = unsafe { &*ptr };
    match serde_json::to_string(val) {
        Ok(s) => match CString::new(s) {
            Ok(cs) => cs.into_raw(),
            Err(e) => {
                set_last_error(2, &e.to_string());
                std::ptr::null_mut()
            }
        },
        Err(e) => {
            set_last_error(2, &e.to_string());
            std::ptr::null_mut()
        }
    }
}

/// Free a `RateLimitConfig` handle.
/// # Safety
/// Pointer must have been returned by this library, or be null.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_rate_limit_config_free(ptr: *mut spikard_core::RateLimitConfig) {
    if !ptr.is_null() {
        // SAFETY: ptr was allocated by Box::into_raw; caller ensures no aliases.
        unsafe {
            drop(Box::from_raw(ptr));
        }
    }
}

/// Get the `per_second` field from a `RateLimitConfig`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_rate_limit_config_per_second(ptr: *const spikard_core::RateLimitConfig) -> u64 {
    if ptr.is_null() {
        return 0;
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    obj.per_second
}

/// Get the `burst` field from a `RateLimitConfig`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_rate_limit_config_burst(ptr: *const spikard_core::RateLimitConfig) -> u32 {
    if ptr.is_null() {
        return 0;
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    obj.burst
}

/// Get the `ip_based` field from a `RateLimitConfig`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_rate_limit_config_ip_based(ptr: *const spikard_core::RateLimitConfig) -> i32 {
    if ptr.is_null() {
        return 0;
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    obj.ip_based as i32
}

/// \note SAFETY: Caller must ensure all pointer arguments are valid or null. Returned pointers must be
/// freed with the appropriate free function.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_rate_limit_config_default() -> *mut spikard_core::RateLimitConfig {
    clear_last_error();
    let result = spikard_core::RateLimitConfig::default();
    Box::into_raw(Box::new(result))
}

/// Create a `JsonRpcMethodInfo` from a JSON string. Returns null on failure.
/// # Safety
/// JSON string must be valid UTF-8 and null-terminated.
/// Returned handle must be freed with `spikard_json_rpc_method_info_free`.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_json_rpc_method_info_from_json(
    json: *const c_char,
) -> *mut spikard_core::JsonRpcMethodInfo {
    clear_last_error();
    if json.is_null() {
        set_last_error(1, "Null pointer passed for JSON string");
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees json is a valid pointer; string is valid UTF-8 from caller.
    let c_str = match unsafe { CStr::from_ptr(json) }.to_str() {
        Ok(s) => s,
        Err(_) => {
            set_last_error(1, "Invalid UTF-8 in JSON string");
            return std::ptr::null_mut();
        }
    };
    match serde_json::from_str::<spikard_core::JsonRpcMethodInfo>(c_str) {
        Ok(val) => Box::into_raw(Box::new(val)),
        Err(e) => {
            set_last_error(2, &e.to_string());
            std::ptr::null_mut()
        }
    }
}

/// Serialize a `JsonRpcMethodInfo` to a JSON string. Returns null on failure.
/// # Safety
/// `ptr` must be a valid, non-null pointer returned by a `spikard` function.
/// The returned string must be freed with `spikard_free_string`.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_json_rpc_method_info_to_json(
    ptr: *const spikard_core::JsonRpcMethodInfo,
) -> *mut c_char {
    clear_last_error();
    if ptr.is_null() {
        set_last_error(1, "Null pointer passed to to_json");
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let val = unsafe { &*ptr };
    match serde_json::to_string(val) {
        Ok(s) => match CString::new(s) {
            Ok(cs) => cs.into_raw(),
            Err(e) => {
                set_last_error(2, &e.to_string());
                std::ptr::null_mut()
            }
        },
        Err(e) => {
            set_last_error(2, &e.to_string());
            std::ptr::null_mut()
        }
    }
}

/// Free a `JsonRpcMethodInfo` handle.
/// # Safety
/// Pointer must have been returned by this library, or be null.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_json_rpc_method_info_free(ptr: *mut spikard_core::JsonRpcMethodInfo) {
    if !ptr.is_null() {
        // SAFETY: ptr was allocated by Box::into_raw; caller ensures no aliases.
        unsafe {
            drop(Box::from_raw(ptr));
        }
    }
}

/// Get the `method_name` field from a `JsonRpcMethodInfo`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_json_rpc_method_info_method_name(
    ptr: *const spikard_core::JsonRpcMethodInfo,
) -> *mut std::ffi::c_char {
    if ptr.is_null() {
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    match CString::new(obj.method_name.to_string()) {
        Ok(cs) => cs.into_raw(),
        Err(_) => std::ptr::null_mut(),
    }
}

/// Get the `description` field from a `JsonRpcMethodInfo`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_json_rpc_method_info_description(
    ptr: *const spikard_core::JsonRpcMethodInfo,
) -> *mut std::ffi::c_char {
    if ptr.is_null() {
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    match &obj.description {
        Some(val) => match CString::new(val.to_string()) {
            Ok(cs) => cs.into_raw(),
            Err(_) => std::ptr::null_mut(),
        },
        None => std::ptr::null_mut(),
    }
}

/// Get the `params_schema` field from a `JsonRpcMethodInfo`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_json_rpc_method_info_params_schema(
    ptr: *const spikard_core::JsonRpcMethodInfo,
) -> *mut std::ffi::c_char {
    if ptr.is_null() {
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    match &obj.params_schema {
        Some(val) => match serde_json::to_string(&val) {
            Ok(s) => match CString::new(s) {
                Ok(cs) => cs.into_raw(),
                Err(_) => std::ptr::null_mut(),
            },
            Err(_) => std::ptr::null_mut(),
        },
        None => std::ptr::null_mut(),
    }
}

/// Get the `result_schema` field from a `JsonRpcMethodInfo`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_json_rpc_method_info_result_schema(
    ptr: *const spikard_core::JsonRpcMethodInfo,
) -> *mut std::ffi::c_char {
    if ptr.is_null() {
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    match &obj.result_schema {
        Some(val) => match serde_json::to_string(&val) {
            Ok(s) => match CString::new(s) {
                Ok(cs) => cs.into_raw(),
                Err(_) => std::ptr::null_mut(),
            },
            Err(_) => std::ptr::null_mut(),
        },
        None => std::ptr::null_mut(),
    }
}

/// Get the `deprecated` field from a `JsonRpcMethodInfo`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_json_rpc_method_info_deprecated(ptr: *const spikard_core::JsonRpcMethodInfo) -> i32 {
    if ptr.is_null() {
        return 0;
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    obj.deprecated as i32
}

/// Get the `tags` field from a `JsonRpcMethodInfo`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_json_rpc_method_info_tags(
    ptr: *const spikard_core::JsonRpcMethodInfo,
) -> *mut std::ffi::c_char {
    if ptr.is_null() {
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    match serde_json::to_string(&obj.tags) {
        Ok(s) => match CString::new(s) {
            Ok(cs) => cs.into_raw(),
            Err(_) => std::ptr::null_mut(),
        },
        Err(_) => std::ptr::null_mut(),
    }
}

/// Create a `ProblemDetails` from a JSON string. Returns null on failure.
/// # Safety
/// JSON string must be valid UTF-8 and null-terminated.
/// Returned handle must be freed with `spikard_problem_details_free`.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_problem_details_from_json(json: *const c_char) -> *mut spikard_core::ProblemDetails {
    clear_last_error();
    if json.is_null() {
        set_last_error(1, "Null pointer passed for JSON string");
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees json is a valid pointer; string is valid UTF-8 from caller.
    let c_str = match unsafe { CStr::from_ptr(json) }.to_str() {
        Ok(s) => s,
        Err(_) => {
            set_last_error(1, "Invalid UTF-8 in JSON string");
            return std::ptr::null_mut();
        }
    };
    match serde_json::from_str::<spikard_core::ProblemDetails>(c_str) {
        Ok(val) => Box::into_raw(Box::new(val)),
        Err(e) => {
            set_last_error(2, &e.to_string());
            std::ptr::null_mut()
        }
    }
}

/// Free a `ProblemDetails` handle.
/// # Safety
/// Pointer must have been returned by this library, or be null.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_problem_details_free(ptr: *mut spikard_core::ProblemDetails) {
    if !ptr.is_null() {
        // SAFETY: ptr was allocated by Box::into_raw; caller ensures no aliases.
        unsafe {
            drop(Box::from_raw(ptr));
        }
    }
}

/// Get the `type_uri` field from a `ProblemDetails`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_problem_details_type_uri(
    ptr: *const spikard_core::ProblemDetails,
) -> *mut std::ffi::c_char {
    if ptr.is_null() {
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    match CString::new(obj.type_uri.to_string()) {
        Ok(cs) => cs.into_raw(),
        Err(_) => std::ptr::null_mut(),
    }
}

/// Get the `title` field from a `ProblemDetails`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_problem_details_title(
    ptr: *const spikard_core::ProblemDetails,
) -> *mut std::ffi::c_char {
    if ptr.is_null() {
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    match CString::new(obj.title.to_string()) {
        Ok(cs) => cs.into_raw(),
        Err(_) => std::ptr::null_mut(),
    }
}

/// Get the `status` field from a `ProblemDetails`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_problem_details_status(ptr: *const spikard_core::ProblemDetails) -> u16 {
    if ptr.is_null() {
        return 0;
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    obj.status
}

/// Get the `detail` field from a `ProblemDetails`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_problem_details_detail(
    ptr: *const spikard_core::ProblemDetails,
) -> *mut std::ffi::c_char {
    if ptr.is_null() {
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    match &obj.detail {
        Some(val) => match CString::new(val.to_string()) {
            Ok(cs) => cs.into_raw(),
            Err(_) => std::ptr::null_mut(),
        },
        None => std::ptr::null_mut(),
    }
}

/// Get the `instance` field from a `ProblemDetails`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_problem_details_instance(
    ptr: *const spikard_core::ProblemDetails,
) -> *mut std::ffi::c_char {
    if ptr.is_null() {
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    match &obj.instance {
        Some(val) => match CString::new(val.to_string()) {
            Ok(cs) => cs.into_raw(),
            Err(_) => std::ptr::null_mut(),
        },
        None => std::ptr::null_mut(),
    }
}

/// Get the `extensions` field from a `ProblemDetails`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_problem_details_extensions(
    ptr: *const spikard_core::ProblemDetails,
) -> *mut std::ffi::c_char {
    if ptr.is_null() {
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    match serde_json::to_string(&obj.extensions) {
        Ok(s) => match CString::new(s) {
            Ok(cs) => cs.into_raw(),
            Err(_) => std::ptr::null_mut(),
        },
        Err(_) => std::ptr::null_mut(),
    }
}

/// Set the detail field
/// \note SAFETY: Caller must ensure all pointer arguments are valid or null. Returned pointers must be
/// freed with the appropriate free function.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_problem_details_with_detail(
    this: *mut spikard_core::ProblemDetails,
    detail: *const std::ffi::c_char,
) -> *mut spikard_core::ProblemDetails {
    clear_last_error();
    if this.is_null() {
        set_last_error(1, "Null pointer passed for self");
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees this is a valid pointer originally from Box::into_raw.
    let obj = unsafe { *Box::from_raw(this) };

    if detail.is_null() {
        set_last_error(1, "Null pointer passed for parameter 'detail'");
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees detail is a valid pointer; string is valid UTF-8 from caller.
    let detail_rs = match unsafe { CStr::from_ptr(detail) }.to_str() {
        Ok(s) => s.to_string(),
        Err(_) => {
            set_last_error(1, "Invalid UTF-8 in parameter 'detail'");
            return std::ptr::null_mut();
        }
    };
    let result = obj.with_detail(detail_rs);
    Box::into_raw(Box::new(result))
}

/// Set the instance field
/// \note SAFETY: Caller must ensure all pointer arguments are valid or null. Returned pointers must be
/// freed with the appropriate free function.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_problem_details_with_instance(
    this: *mut spikard_core::ProblemDetails,
    instance: *const std::ffi::c_char,
) -> *mut spikard_core::ProblemDetails {
    clear_last_error();
    if this.is_null() {
        set_last_error(1, "Null pointer passed for self");
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees this is a valid pointer originally from Box::into_raw.
    let obj = unsafe { *Box::from_raw(this) };

    if instance.is_null() {
        set_last_error(1, "Null pointer passed for parameter 'instance'");
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees instance is a valid pointer; string is valid UTF-8 from caller.
    let instance_rs = match unsafe { CStr::from_ptr(instance) }.to_str() {
        Ok(s) => s.to_string(),
        Err(_) => {
            set_last_error(1, "Invalid UTF-8 in parameter 'instance'");
            return std::ptr::null_mut();
        }
    };
    let result = obj.with_instance(instance_rs);
    Box::into_raw(Box::new(result))
}

/// Create a not found error
/// \note SAFETY: Caller must ensure all pointer arguments are valid or null. Returned pointers must be
/// freed with the appropriate free function.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_problem_details_not_found(
    detail: *const std::ffi::c_char,
) -> *mut spikard_core::ProblemDetails {
    clear_last_error();
    if detail.is_null() {
        set_last_error(1, "Null pointer passed for parameter 'detail'");
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees detail is a valid pointer; string is valid UTF-8 from caller.
    let detail_rs = match unsafe { CStr::from_ptr(detail) }.to_str() {
        Ok(s) => s.to_string(),
        Err(_) => {
            set_last_error(1, "Invalid UTF-8 in parameter 'detail'");
            return std::ptr::null_mut();
        }
    };
    let result = spikard_core::ProblemDetails::not_found(detail_rs);
    Box::into_raw(Box::new(result))
}

/// Create a method not allowed error
/// \note SAFETY: Caller must ensure all pointer arguments are valid or null. Returned pointers must be
/// freed with the appropriate free function.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_problem_details_method_not_allowed(
    detail: *const std::ffi::c_char,
) -> *mut spikard_core::ProblemDetails {
    clear_last_error();
    if detail.is_null() {
        set_last_error(1, "Null pointer passed for parameter 'detail'");
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees detail is a valid pointer; string is valid UTF-8 from caller.
    let detail_rs = match unsafe { CStr::from_ptr(detail) }.to_str() {
        Ok(s) => s.to_string(),
        Err(_) => {
            set_last_error(1, "Invalid UTF-8 in parameter 'detail'");
            return std::ptr::null_mut();
        }
    };
    let result = spikard_core::ProblemDetails::method_not_allowed(detail_rs);
    Box::into_raw(Box::new(result))
}

/// Create an internal server error
/// \note SAFETY: Caller must ensure all pointer arguments are valid or null. Returned pointers must be
/// freed with the appropriate free function.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_problem_details_internal_server_error(
    detail: *const std::ffi::c_char,
) -> *mut spikard_core::ProblemDetails {
    clear_last_error();
    if detail.is_null() {
        set_last_error(1, "Null pointer passed for parameter 'detail'");
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees detail is a valid pointer; string is valid UTF-8 from caller.
    let detail_rs = match unsafe { CStr::from_ptr(detail) }.to_str() {
        Ok(s) => s.to_string(),
        Err(_) => {
            set_last_error(1, "Invalid UTF-8 in parameter 'detail'");
            return std::ptr::null_mut();
        }
    };
    let result = spikard_core::ProblemDetails::internal_server_error(detail_rs);
    Box::into_raw(Box::new(result))
}

/// Create a bad request error
/// \note SAFETY: Caller must ensure all pointer arguments are valid or null. Returned pointers must be
/// freed with the appropriate free function.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_problem_details_bad_request(
    detail: *const std::ffi::c_char,
) -> *mut spikard_core::ProblemDetails {
    clear_last_error();
    if detail.is_null() {
        set_last_error(1, "Null pointer passed for parameter 'detail'");
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees detail is a valid pointer; string is valid UTF-8 from caller.
    let detail_rs = match unsafe { CStr::from_ptr(detail) }.to_str() {
        Ok(s) => s.to_string(),
        Err(_) => {
            set_last_error(1, "Invalid UTF-8 in parameter 'detail'");
            return std::ptr::null_mut();
        }
    };
    let result = spikard_core::ProblemDetails::bad_request(detail_rs);
    Box::into_raw(Box::new(result))
}

/// Serialize to JSON string
/// \note Returns an error if the serialization fails.
/// \note SAFETY: Caller must ensure all pointer arguments are valid or null. Returned pointers must be
/// freed with the appropriate free function.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_problem_details_to_json(
    this: *const spikard_core::ProblemDetails,
) -> *mut std::ffi::c_char {
    clear_last_error();
    if this.is_null() {
        set_last_error(1, "Null pointer passed for self");
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees this is a valid pointer.
    let obj = unsafe { &*this };

    let result = obj.to_json();
    match result {
        Ok(val) => match CString::new(val.to_string()) {
            Ok(cs) => cs.into_raw(),
            Err(_) => std::ptr::null_mut(),
        },
        Err(e) => {
            set_last_error(2, &e.to_string());
            std::ptr::null_mut()
        }
    }
}

/// Serialize to pretty JSON string
/// \note Returns an error if the serialization fails.
/// \note SAFETY: Caller must ensure all pointer arguments are valid or null. Returned pointers must be
/// freed with the appropriate free function.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_problem_details_to_json_pretty(
    this: *const spikard_core::ProblemDetails,
) -> *mut std::ffi::c_char {
    clear_last_error();
    if this.is_null() {
        set_last_error(1, "Null pointer passed for self");
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees this is a valid pointer.
    let obj = unsafe { &*this };

    let result = obj.to_json_pretty();
    match result {
        Ok(val) => match CString::new(val.to_string()) {
            Ok(cs) => cs.into_raw(),
            Err(_) => std::ptr::null_mut(),
        },
        Err(e) => {
            set_last_error(2, &e.to_string());
            std::ptr::null_mut()
        }
    }
}

/// Free a `GraphQLRouteConfig` handle.
/// # Safety
/// Pointer must have been returned by this library, or be null.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_graph_ql_route_config_free(ptr: *mut spikard_graphql::GraphQLRouteConfig) {
    if !ptr.is_null() {
        // SAFETY: ptr was allocated by Box::into_raw; caller ensures no aliases.
        unsafe {
            drop(Box::from_raw(ptr));
        }
    }
}

/// Set the HTTP path for the GraphQL endpoint
/// \param path The URL path (e.g., "/graphql", "/api/graphql")
/// \note SAFETY: Caller must ensure all pointer arguments are valid or null. Returned pointers must be
/// freed with the appropriate free function.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_graph_ql_route_config_path(
    this: *mut spikard_graphql::GraphQLRouteConfig,
    path: *const std::ffi::c_char,
) -> *mut spikard_graphql::GraphQLRouteConfig {
    clear_last_error();
    if this.is_null() {
        set_last_error(1, "Null pointer passed for self");
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees this is a valid pointer originally from Box::into_raw.
    let obj = unsafe { *Box::from_raw(this) };

    if path.is_null() {
        set_last_error(1, "Null pointer passed for parameter 'path'");
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees path is a valid pointer; string is valid UTF-8 from caller.
    let path_rs = match unsafe { CStr::from_ptr(path) }.to_str() {
        Ok(s) => s.to_string(),
        Err(_) => {
            set_last_error(1, "Invalid UTF-8 in parameter 'path'");
            return std::ptr::null_mut();
        }
    };
    let result = obj.path(path_rs);
    Box::into_raw(Box::new(result))
}

/// Set the HTTP method for the GraphQL endpoint
/// \param method The HTTP method (typically "POST")
/// \note SAFETY: Caller must ensure all pointer arguments are valid or null. Returned pointers must be
/// freed with the appropriate free function.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_graph_ql_route_config_method(
    this: *mut spikard_graphql::GraphQLRouteConfig,
    method: *const std::ffi::c_char,
) -> *mut spikard_graphql::GraphQLRouteConfig {
    clear_last_error();
    if this.is_null() {
        set_last_error(1, "Null pointer passed for self");
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees this is a valid pointer originally from Box::into_raw.
    let obj = unsafe { *Box::from_raw(this) };

    if method.is_null() {
        set_last_error(1, "Null pointer passed for parameter 'method'");
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees method is a valid pointer; string is valid UTF-8 from caller.
    let method_rs = match unsafe { CStr::from_ptr(method) }.to_str() {
        Ok(s) => s.to_string(),
        Err(_) => {
            set_last_error(1, "Invalid UTF-8 in parameter 'method'");
            return std::ptr::null_mut();
        }
    };
    let result = obj.method(method_rs);
    Box::into_raw(Box::new(result))
}

/// Enable or disable the GraphQL Playground UI
/// \param enable Whether to enable playground
/// \note SAFETY: Caller must ensure all pointer arguments are valid or null. Returned pointers must be
/// freed with the appropriate free function.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_graph_ql_route_config_enable_playground(
    this: *mut spikard_graphql::GraphQLRouteConfig,
    enable: i32,
) -> *mut spikard_graphql::GraphQLRouteConfig {
    clear_last_error();
    if this.is_null() {
        set_last_error(1, "Null pointer passed for self");
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees this is a valid pointer originally from Box::into_raw.
    let obj = unsafe { *Box::from_raw(this) };

    let enable_rs = enable != 0;
    let result = obj.enable_playground(enable_rs);
    Box::into_raw(Box::new(result))
}

/// Set a custom description for documentation
/// \param description Documentation string
/// \note SAFETY: Caller must ensure all pointer arguments are valid or null. Returned pointers must be
/// freed with the appropriate free function.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_graph_ql_route_config_description(
    this: *mut spikard_graphql::GraphQLRouteConfig,
    description: *const std::ffi::c_char,
) -> *mut spikard_graphql::GraphQLRouteConfig {
    clear_last_error();
    if this.is_null() {
        set_last_error(1, "Null pointer passed for self");
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees this is a valid pointer originally from Box::into_raw.
    let obj = unsafe { *Box::from_raw(this) };

    if description.is_null() {
        set_last_error(1, "Null pointer passed for parameter 'description'");
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees description is a valid pointer; string is valid UTF-8 from caller.
    let description_rs = match unsafe { CStr::from_ptr(description) }.to_str() {
        Ok(s) => s.to_string(),
        Err(_) => {
            set_last_error(1, "Invalid UTF-8 in parameter 'description'");
            return std::ptr::null_mut();
        }
    };
    let result = obj.description(description_rs);
    Box::into_raw(Box::new(result))
}

/// Get the configured path
/// \note SAFETY: Caller must ensure all pointer arguments are valid or null. Returned pointers must be
/// freed with the appropriate free function.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_graph_ql_route_config_get_path(
    this: *const spikard_graphql::GraphQLRouteConfig,
) -> *mut std::ffi::c_char {
    clear_last_error();
    if this.is_null() {
        set_last_error(1, "Null pointer passed for self");
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees this is a valid pointer.
    let obj = unsafe { &*this };

    let result = obj.get_path();
    let result = result.to_owned();
    match CString::new(result.to_string()) {
        Ok(cs) => cs.into_raw(),
        Err(_) => std::ptr::null_mut(),
    }
}

/// Get the configured method
/// \note SAFETY: Caller must ensure all pointer arguments are valid or null. Returned pointers must be
/// freed with the appropriate free function.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_graph_ql_route_config_get_method(
    this: *const spikard_graphql::GraphQLRouteConfig,
) -> *mut std::ffi::c_char {
    clear_last_error();
    if this.is_null() {
        set_last_error(1, "Null pointer passed for self");
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees this is a valid pointer.
    let obj = unsafe { &*this };

    let result = obj.get_method();
    let result = result.to_owned();
    match CString::new(result.to_string()) {
        Ok(cs) => cs.into_raw(),
        Err(_) => std::ptr::null_mut(),
    }
}

/// Check if playground is enabled
/// \note SAFETY: Caller must ensure all pointer arguments are valid or null. Returned pointers must be
/// freed with the appropriate free function.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_graph_ql_route_config_is_playground_enabled(
    this: *const spikard_graphql::GraphQLRouteConfig,
) -> i32 {
    clear_last_error();
    if this.is_null() {
        set_last_error(1, "Null pointer passed for self");
        return 0;
    }
    // SAFETY: null check above guarantees this is a valid pointer.
    let obj = unsafe { &*this };

    let result = obj.is_playground_enabled();
    if result {
        1
    } else {
        0
    }
}

/// Get the description if set
/// \note SAFETY: Caller must ensure all pointer arguments are valid or null. Returned pointers must be
/// freed with the appropriate free function.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_graph_ql_route_config_get_description(
    this: *const spikard_graphql::GraphQLRouteConfig,
) -> *mut std::ffi::c_char {
    clear_last_error();
    if this.is_null() {
        set_last_error(1, "Null pointer passed for self");
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees this is a valid pointer.
    let obj = unsafe { &*this };

    let result = obj.get_description();
    let result = result.map(str::to_owned);
    match result {
        Some(val) => match CString::new(val.to_string()) {
            Ok(cs) => cs.into_raw(),
            Err(_) => std::ptr::null_mut(),
        },
        None => std::ptr::null_mut(),
    }
}

/// \note SAFETY: Caller must ensure all pointer arguments are valid or null. Returned pointers must be
/// freed with the appropriate free function.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_graph_ql_route_config_default() -> *mut spikard_graphql::GraphQLRouteConfig {
    clear_last_error();
    let result = spikard_graphql::GraphQLRouteConfig::default();
    Box::into_raw(Box::new(result))
}

/// Create a `SchemaConfig` from a JSON string. Returns null on failure.
/// # Safety
/// JSON string must be valid UTF-8 and null-terminated.
/// Returned handle must be freed with `spikard_schema_config_free`.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_schema_config_from_json(json: *const c_char) -> *mut spikard_graphql::SchemaConfig {
    clear_last_error();
    if json.is_null() {
        set_last_error(1, "Null pointer passed for JSON string");
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees json is a valid pointer; string is valid UTF-8 from caller.
    let c_str = match unsafe { CStr::from_ptr(json) }.to_str() {
        Ok(s) => s,
        Err(_) => {
            set_last_error(1, "Invalid UTF-8 in JSON string");
            return std::ptr::null_mut();
        }
    };
    match serde_json::from_str::<spikard_graphql::SchemaConfig>(c_str) {
        Ok(val) => Box::into_raw(Box::new(val)),
        Err(e) => {
            set_last_error(2, &e.to_string());
            std::ptr::null_mut()
        }
    }
}

/// Serialize a `SchemaConfig` to a JSON string. Returns null on failure.
/// # Safety
/// `ptr` must be a valid, non-null pointer returned by a `spikard` function.
/// The returned string must be freed with `spikard_free_string`.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_schema_config_to_json(ptr: *const spikard_graphql::SchemaConfig) -> *mut c_char {
    clear_last_error();
    if ptr.is_null() {
        set_last_error(1, "Null pointer passed to to_json");
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let val = unsafe { &*ptr };
    match serde_json::to_string(val) {
        Ok(s) => match CString::new(s) {
            Ok(cs) => cs.into_raw(),
            Err(e) => {
                set_last_error(2, &e.to_string());
                std::ptr::null_mut()
            }
        },
        Err(e) => {
            set_last_error(2, &e.to_string());
            std::ptr::null_mut()
        }
    }
}

/// Free a `SchemaConfig` handle.
/// # Safety
/// Pointer must have been returned by this library, or be null.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_schema_config_free(ptr: *mut spikard_graphql::SchemaConfig) {
    if !ptr.is_null() {
        // SAFETY: ptr was allocated by Box::into_raw; caller ensures no aliases.
        unsafe {
            drop(Box::from_raw(ptr));
        }
    }
}

/// Get the `introspection_enabled` field from a `SchemaConfig`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_schema_config_introspection_enabled(ptr: *const spikard_graphql::SchemaConfig) -> i32 {
    if ptr.is_null() {
        return 0;
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    obj.introspection_enabled as i32
}

/// Get the `complexity_limit` field from a `SchemaConfig`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_schema_config_complexity_limit(ptr: *const spikard_graphql::SchemaConfig) -> usize {
    if ptr.is_null() {
        return 0;
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    match &obj.complexity_limit {
        Some(val) => *val,
        None => 0,
    }
}

/// Get the `depth_limit` field from a `SchemaConfig`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_schema_config_depth_limit(ptr: *const spikard_graphql::SchemaConfig) -> usize {
    if ptr.is_null() {
        return 0;
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    match &obj.depth_limit {
        Some(val) => *val,
        None => 0,
    }
}

/// \note SAFETY: Caller must ensure all pointer arguments are valid or null. Returned pointers must be
/// freed with the appropriate free function.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_schema_config_default() -> *mut spikard_graphql::SchemaConfig {
    clear_last_error();
    let result = spikard_graphql::SchemaConfig::default();
    Box::into_raw(Box::new(result))
}

/// Create a `QueryOnlyConfig` from a JSON string. Returns null on failure.
/// # Safety
/// JSON string must be valid UTF-8 and null-terminated.
/// Returned handle must be freed with `spikard_query_only_config_free`.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_query_only_config_from_json(
    json: *const c_char,
) -> *mut spikard_graphql::QueryOnlyConfig {
    clear_last_error();
    if json.is_null() {
        set_last_error(1, "Null pointer passed for JSON string");
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees json is a valid pointer; string is valid UTF-8 from caller.
    let c_str = match unsafe { CStr::from_ptr(json) }.to_str() {
        Ok(s) => s,
        Err(_) => {
            set_last_error(1, "Invalid UTF-8 in JSON string");
            return std::ptr::null_mut();
        }
    };
    match serde_json::from_str::<spikard_graphql::QueryOnlyConfig>(c_str) {
        Ok(val) => Box::into_raw(Box::new(val)),
        Err(e) => {
            set_last_error(2, &e.to_string());
            std::ptr::null_mut()
        }
    }
}

/// Serialize a `QueryOnlyConfig` to a JSON string. Returns null on failure.
/// # Safety
/// `ptr` must be a valid, non-null pointer returned by a `spikard` function.
/// The returned string must be freed with `spikard_free_string`.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_query_only_config_to_json(
    ptr: *const spikard_graphql::QueryOnlyConfig,
) -> *mut c_char {
    clear_last_error();
    if ptr.is_null() {
        set_last_error(1, "Null pointer passed to to_json");
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let val = unsafe { &*ptr };
    match serde_json::to_string(val) {
        Ok(s) => match CString::new(s) {
            Ok(cs) => cs.into_raw(),
            Err(e) => {
                set_last_error(2, &e.to_string());
                std::ptr::null_mut()
            }
        },
        Err(e) => {
            set_last_error(2, &e.to_string());
            std::ptr::null_mut()
        }
    }
}

/// Free a `QueryOnlyConfig` handle.
/// # Safety
/// Pointer must have been returned by this library, or be null.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_query_only_config_free(ptr: *mut spikard_graphql::QueryOnlyConfig) {
    if !ptr.is_null() {
        // SAFETY: ptr was allocated by Box::into_raw; caller ensures no aliases.
        unsafe {
            drop(Box::from_raw(ptr));
        }
    }
}

/// Get the `introspection_enabled` field from a `QueryOnlyConfig`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_query_only_config_introspection_enabled(
    ptr: *const spikard_graphql::QueryOnlyConfig,
) -> i32 {
    if ptr.is_null() {
        return 0;
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    obj.introspection_enabled as i32
}

/// Get the `complexity_limit` field from a `QueryOnlyConfig`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_query_only_config_complexity_limit(
    ptr: *const spikard_graphql::QueryOnlyConfig,
) -> usize {
    if ptr.is_null() {
        return 0;
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    match &obj.complexity_limit {
        Some(val) => *val,
        None => 0,
    }
}

/// Get the `depth_limit` field from a `QueryOnlyConfig`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_query_only_config_depth_limit(ptr: *const spikard_graphql::QueryOnlyConfig) -> usize {
    if ptr.is_null() {
        return 0;
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    match &obj.depth_limit {
        Some(val) => *val,
        None => 0,
    }
}

/// \note SAFETY: Caller must ensure all pointer arguments are valid or null. Returned pointers must be
/// freed with the appropriate free function.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_query_only_config_default() -> *mut spikard_graphql::QueryOnlyConfig {
    clear_last_error();
    let result = spikard_graphql::QueryOnlyConfig::default();
    Box::into_raw(Box::new(result))
}

/// Create a `QueryMutationConfig` from a JSON string. Returns null on failure.
/// # Safety
/// JSON string must be valid UTF-8 and null-terminated.
/// Returned handle must be freed with `spikard_query_mutation_config_free`.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_query_mutation_config_from_json(
    json: *const c_char,
) -> *mut spikard_graphql::QueryMutationConfig {
    clear_last_error();
    if json.is_null() {
        set_last_error(1, "Null pointer passed for JSON string");
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees json is a valid pointer; string is valid UTF-8 from caller.
    let c_str = match unsafe { CStr::from_ptr(json) }.to_str() {
        Ok(s) => s,
        Err(_) => {
            set_last_error(1, "Invalid UTF-8 in JSON string");
            return std::ptr::null_mut();
        }
    };
    match serde_json::from_str::<spikard_graphql::QueryMutationConfig>(c_str) {
        Ok(val) => Box::into_raw(Box::new(val)),
        Err(e) => {
            set_last_error(2, &e.to_string());
            std::ptr::null_mut()
        }
    }
}

/// Serialize a `QueryMutationConfig` to a JSON string. Returns null on failure.
/// # Safety
/// `ptr` must be a valid, non-null pointer returned by a `spikard` function.
/// The returned string must be freed with `spikard_free_string`.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_query_mutation_config_to_json(
    ptr: *const spikard_graphql::QueryMutationConfig,
) -> *mut c_char {
    clear_last_error();
    if ptr.is_null() {
        set_last_error(1, "Null pointer passed to to_json");
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let val = unsafe { &*ptr };
    match serde_json::to_string(val) {
        Ok(s) => match CString::new(s) {
            Ok(cs) => cs.into_raw(),
            Err(e) => {
                set_last_error(2, &e.to_string());
                std::ptr::null_mut()
            }
        },
        Err(e) => {
            set_last_error(2, &e.to_string());
            std::ptr::null_mut()
        }
    }
}

/// Free a `QueryMutationConfig` handle.
/// # Safety
/// Pointer must have been returned by this library, or be null.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_query_mutation_config_free(ptr: *mut spikard_graphql::QueryMutationConfig) {
    if !ptr.is_null() {
        // SAFETY: ptr was allocated by Box::into_raw; caller ensures no aliases.
        unsafe {
            drop(Box::from_raw(ptr));
        }
    }
}

/// Get the `introspection_enabled` field from a `QueryMutationConfig`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_query_mutation_config_introspection_enabled(
    ptr: *const spikard_graphql::QueryMutationConfig,
) -> i32 {
    if ptr.is_null() {
        return 0;
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    obj.introspection_enabled as i32
}

/// Get the `complexity_limit` field from a `QueryMutationConfig`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_query_mutation_config_complexity_limit(
    ptr: *const spikard_graphql::QueryMutationConfig,
) -> usize {
    if ptr.is_null() {
        return 0;
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    match &obj.complexity_limit {
        Some(val) => *val,
        None => 0,
    }
}

/// Get the `depth_limit` field from a `QueryMutationConfig`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_query_mutation_config_depth_limit(
    ptr: *const spikard_graphql::QueryMutationConfig,
) -> usize {
    if ptr.is_null() {
        return 0;
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    match &obj.depth_limit {
        Some(val) => *val,
        None => 0,
    }
}

/// \note SAFETY: Caller must ensure all pointer arguments are valid or null. Returned pointers must be
/// freed with the appropriate free function.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_query_mutation_config_default() -> *mut spikard_graphql::QueryMutationConfig {
    clear_last_error();
    let result = spikard_graphql::QueryMutationConfig::default();
    Box::into_raw(Box::new(result))
}

/// Create a `FullSchemaConfig` from a JSON string. Returns null on failure.
/// # Safety
/// JSON string must be valid UTF-8 and null-terminated.
/// Returned handle must be freed with `spikard_full_schema_config_free`.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_full_schema_config_from_json(
    json: *const c_char,
) -> *mut spikard_graphql::FullSchemaConfig {
    clear_last_error();
    if json.is_null() {
        set_last_error(1, "Null pointer passed for JSON string");
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees json is a valid pointer; string is valid UTF-8 from caller.
    let c_str = match unsafe { CStr::from_ptr(json) }.to_str() {
        Ok(s) => s,
        Err(_) => {
            set_last_error(1, "Invalid UTF-8 in JSON string");
            return std::ptr::null_mut();
        }
    };
    match serde_json::from_str::<spikard_graphql::FullSchemaConfig>(c_str) {
        Ok(val) => Box::into_raw(Box::new(val)),
        Err(e) => {
            set_last_error(2, &e.to_string());
            std::ptr::null_mut()
        }
    }
}

/// Serialize a `FullSchemaConfig` to a JSON string. Returns null on failure.
/// # Safety
/// `ptr` must be a valid, non-null pointer returned by a `spikard` function.
/// The returned string must be freed with `spikard_free_string`.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_full_schema_config_to_json(
    ptr: *const spikard_graphql::FullSchemaConfig,
) -> *mut c_char {
    clear_last_error();
    if ptr.is_null() {
        set_last_error(1, "Null pointer passed to to_json");
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let val = unsafe { &*ptr };
    match serde_json::to_string(val) {
        Ok(s) => match CString::new(s) {
            Ok(cs) => cs.into_raw(),
            Err(e) => {
                set_last_error(2, &e.to_string());
                std::ptr::null_mut()
            }
        },
        Err(e) => {
            set_last_error(2, &e.to_string());
            std::ptr::null_mut()
        }
    }
}

/// Free a `FullSchemaConfig` handle.
/// # Safety
/// Pointer must have been returned by this library, or be null.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_full_schema_config_free(ptr: *mut spikard_graphql::FullSchemaConfig) {
    if !ptr.is_null() {
        // SAFETY: ptr was allocated by Box::into_raw; caller ensures no aliases.
        unsafe {
            drop(Box::from_raw(ptr));
        }
    }
}

/// Get the `introspection_enabled` field from a `FullSchemaConfig`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_full_schema_config_introspection_enabled(
    ptr: *const spikard_graphql::FullSchemaConfig,
) -> i32 {
    if ptr.is_null() {
        return 0;
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    obj.introspection_enabled as i32
}

/// Get the `complexity_limit` field from a `FullSchemaConfig`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_full_schema_config_complexity_limit(
    ptr: *const spikard_graphql::FullSchemaConfig,
) -> usize {
    if ptr.is_null() {
        return 0;
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    match &obj.complexity_limit {
        Some(val) => *val,
        None => 0,
    }
}

/// Get the `depth_limit` field from a `FullSchemaConfig`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_full_schema_config_depth_limit(
    ptr: *const spikard_graphql::FullSchemaConfig,
) -> usize {
    if ptr.is_null() {
        return 0;
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    match &obj.depth_limit {
        Some(val) => *val,
        None => 0,
    }
}

/// \note SAFETY: Caller must ensure all pointer arguments are valid or null. Returned pointers must be
/// freed with the appropriate free function.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_full_schema_config_default() -> *mut spikard_graphql::FullSchemaConfig {
    clear_last_error();
    let result = spikard_graphql::FullSchemaConfig::default();
    Box::into_raw(Box::new(result))
}

/// Create a `AsyncApiConfig` from a JSON string. Returns null on failure.
/// # Safety
/// JSON string must be valid UTF-8 and null-terminated.
/// Returned handle must be freed with `spikard_async_api_config_free`.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_async_api_config_from_json(json: *const c_char) -> *mut spikard_http::AsyncApiConfig {
    clear_last_error();
    if json.is_null() {
        set_last_error(1, "Null pointer passed for JSON string");
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees json is a valid pointer; string is valid UTF-8 from caller.
    let c_str = match unsafe { CStr::from_ptr(json) }.to_str() {
        Ok(s) => s,
        Err(_) => {
            set_last_error(1, "Invalid UTF-8 in JSON string");
            return std::ptr::null_mut();
        }
    };
    match serde_json::from_str::<spikard_http::AsyncApiConfig>(c_str) {
        Ok(val) => Box::into_raw(Box::new(val)),
        Err(e) => {
            set_last_error(2, &e.to_string());
            std::ptr::null_mut()
        }
    }
}

/// Serialize a `AsyncApiConfig` to a JSON string. Returns null on failure.
/// # Safety
/// `ptr` must be a valid, non-null pointer returned by a `spikard` function.
/// The returned string must be freed with `spikard_free_string`.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_async_api_config_to_json(ptr: *const spikard_http::AsyncApiConfig) -> *mut c_char {
    clear_last_error();
    if ptr.is_null() {
        set_last_error(1, "Null pointer passed to to_json");
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let val = unsafe { &*ptr };
    match serde_json::to_string(val) {
        Ok(s) => match CString::new(s) {
            Ok(cs) => cs.into_raw(),
            Err(e) => {
                set_last_error(2, &e.to_string());
                std::ptr::null_mut()
            }
        },
        Err(e) => {
            set_last_error(2, &e.to_string());
            std::ptr::null_mut()
        }
    }
}

/// Free a `AsyncApiConfig` handle.
/// # Safety
/// Pointer must have been returned by this library, or be null.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_async_api_config_free(ptr: *mut spikard_http::AsyncApiConfig) {
    if !ptr.is_null() {
        // SAFETY: ptr was allocated by Box::into_raw; caller ensures no aliases.
        unsafe {
            drop(Box::from_raw(ptr));
        }
    }
}

/// Get the `enabled` field from a `AsyncApiConfig`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_async_api_config_enabled(ptr: *const spikard_http::AsyncApiConfig) -> i32 {
    if ptr.is_null() {
        return 0;
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    obj.enabled as i32
}

/// Get the `spec` field from a `AsyncApiConfig`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_async_api_config_spec(
    ptr: *const spikard_http::AsyncApiConfig,
) -> *mut std::ffi::c_char {
    if ptr.is_null() {
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    match &obj.spec {
        Some(val) => match serde_json::to_string(&val) {
            Ok(s) => match CString::new(s) {
                Ok(cs) => cs.into_raw(),
                Err(_) => std::ptr::null_mut(),
            },
            Err(_) => std::ptr::null_mut(),
        },
        None => std::ptr::null_mut(),
    }
}

/// Create a `ParsedChannel` from a JSON string. Returns null on failure.
/// # Safety
/// JSON string must be valid UTF-8 and null-terminated.
/// Returned handle must be freed with `spikard_parsed_channel_free`.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_parsed_channel_from_json(json: *const c_char) -> *mut spikard_http::ParsedChannel {
    clear_last_error();
    if json.is_null() {
        set_last_error(1, "Null pointer passed for JSON string");
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees json is a valid pointer; string is valid UTF-8 from caller.
    let c_str = match unsafe { CStr::from_ptr(json) }.to_str() {
        Ok(s) => s,
        Err(_) => {
            set_last_error(1, "Invalid UTF-8 in JSON string");
            return std::ptr::null_mut();
        }
    };
    match serde_json::from_str::<spikard_http::ParsedChannel>(c_str) {
        Ok(val) => Box::into_raw(Box::new(val)),
        Err(e) => {
            set_last_error(2, &e.to_string());
            std::ptr::null_mut()
        }
    }
}

/// Serialize a `ParsedChannel` to a JSON string. Returns null on failure.
/// # Safety
/// `ptr` must be a valid, non-null pointer returned by a `spikard` function.
/// The returned string must be freed with `spikard_free_string`.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_parsed_channel_to_json(ptr: *const spikard_http::ParsedChannel) -> *mut c_char {
    clear_last_error();
    if ptr.is_null() {
        set_last_error(1, "Null pointer passed to to_json");
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let val = unsafe { &*ptr };
    match serde_json::to_string(val) {
        Ok(s) => match CString::new(s) {
            Ok(cs) => cs.into_raw(),
            Err(e) => {
                set_last_error(2, &e.to_string());
                std::ptr::null_mut()
            }
        },
        Err(e) => {
            set_last_error(2, &e.to_string());
            std::ptr::null_mut()
        }
    }
}

/// Free a `ParsedChannel` handle.
/// # Safety
/// Pointer must have been returned by this library, or be null.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_parsed_channel_free(ptr: *mut spikard_http::ParsedChannel) {
    if !ptr.is_null() {
        // SAFETY: ptr was allocated by Box::into_raw; caller ensures no aliases.
        unsafe {
            drop(Box::from_raw(ptr));
        }
    }
}

/// Get the `name` field from a `ParsedChannel`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_parsed_channel_name(ptr: *const spikard_http::ParsedChannel) -> *mut std::ffi::c_char {
    if ptr.is_null() {
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    match CString::new(obj.name.to_string()) {
        Ok(cs) => cs.into_raw(),
        Err(_) => std::ptr::null_mut(),
    }
}

/// Get the `address` field from a `ParsedChannel`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_parsed_channel_address(
    ptr: *const spikard_http::ParsedChannel,
) -> *mut std::ffi::c_char {
    if ptr.is_null() {
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    match CString::new(obj.address.to_string()) {
        Ok(cs) => cs.into_raw(),
        Err(_) => std::ptr::null_mut(),
    }
}

/// Get the `messages` field from a `ParsedChannel`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_parsed_channel_messages(
    ptr: *const spikard_http::ParsedChannel,
) -> *mut std::ffi::c_char {
    if ptr.is_null() {
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    match serde_json::to_string(&obj.messages) {
        Ok(s) => match CString::new(s) {
            Ok(cs) => cs.into_raw(),
            Err(_) => std::ptr::null_mut(),
        },
        Err(_) => std::ptr::null_mut(),
    }
}

/// Get the `bindings` field from a `ParsedChannel`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_parsed_channel_bindings(
    ptr: *const spikard_http::ParsedChannel,
) -> *mut std::ffi::c_char {
    if ptr.is_null() {
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    match &obj.bindings {
        Some(val) => match serde_json::to_string(&val) {
            Ok(s) => match CString::new(s) {
                Ok(cs) => cs.into_raw(),
                Err(_) => std::ptr::null_mut(),
            },
            Err(_) => std::ptr::null_mut(),
        },
        None => std::ptr::null_mut(),
    }
}

/// Create a `ParsedOperation` from a JSON string. Returns null on failure.
/// # Safety
/// JSON string must be valid UTF-8 and null-terminated.
/// Returned handle must be freed with `spikard_parsed_operation_free`.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_parsed_operation_from_json(json: *const c_char) -> *mut spikard_http::ParsedOperation {
    clear_last_error();
    if json.is_null() {
        set_last_error(1, "Null pointer passed for JSON string");
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees json is a valid pointer; string is valid UTF-8 from caller.
    let c_str = match unsafe { CStr::from_ptr(json) }.to_str() {
        Ok(s) => s,
        Err(_) => {
            set_last_error(1, "Invalid UTF-8 in JSON string");
            return std::ptr::null_mut();
        }
    };
    match serde_json::from_str::<spikard_http::ParsedOperation>(c_str) {
        Ok(val) => Box::into_raw(Box::new(val)),
        Err(e) => {
            set_last_error(2, &e.to_string());
            std::ptr::null_mut()
        }
    }
}

/// Serialize a `ParsedOperation` to a JSON string. Returns null on failure.
/// # Safety
/// `ptr` must be a valid, non-null pointer returned by a `spikard` function.
/// The returned string must be freed with `spikard_free_string`.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_parsed_operation_to_json(ptr: *const spikard_http::ParsedOperation) -> *mut c_char {
    clear_last_error();
    if ptr.is_null() {
        set_last_error(1, "Null pointer passed to to_json");
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let val = unsafe { &*ptr };
    match serde_json::to_string(val) {
        Ok(s) => match CString::new(s) {
            Ok(cs) => cs.into_raw(),
            Err(e) => {
                set_last_error(2, &e.to_string());
                std::ptr::null_mut()
            }
        },
        Err(e) => {
            set_last_error(2, &e.to_string());
            std::ptr::null_mut()
        }
    }
}

/// Free a `ParsedOperation` handle.
/// # Safety
/// Pointer must have been returned by this library, or be null.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_parsed_operation_free(ptr: *mut spikard_http::ParsedOperation) {
    if !ptr.is_null() {
        // SAFETY: ptr was allocated by Box::into_raw; caller ensures no aliases.
        unsafe {
            drop(Box::from_raw(ptr));
        }
    }
}

/// Get the `name` field from a `ParsedOperation`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_parsed_operation_name(
    ptr: *const spikard_http::ParsedOperation,
) -> *mut std::ffi::c_char {
    if ptr.is_null() {
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    match CString::new(obj.name.to_string()) {
        Ok(cs) => cs.into_raw(),
        Err(_) => std::ptr::null_mut(),
    }
}

/// Get the `action` field from a `ParsedOperation`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_parsed_operation_action(
    ptr: *const spikard_http::ParsedOperation,
) -> *mut std::ffi::c_char {
    if ptr.is_null() {
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    match CString::new(obj.action.to_string()) {
        Ok(cs) => cs.into_raw(),
        Err(_) => std::ptr::null_mut(),
    }
}

/// Get the `channel` field from a `ParsedOperation`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_parsed_operation_channel(
    ptr: *const spikard_http::ParsedOperation,
) -> *mut std::ffi::c_char {
    if ptr.is_null() {
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    match CString::new(obj.channel.to_string()) {
        Ok(cs) => cs.into_raw(),
        Err(_) => std::ptr::null_mut(),
    }
}

/// Create a `ParsedMessage` from a JSON string. Returns null on failure.
/// # Safety
/// JSON string must be valid UTF-8 and null-terminated.
/// Returned handle must be freed with `spikard_parsed_message_free`.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_parsed_message_from_json(json: *const c_char) -> *mut spikard_http::ParsedMessage {
    clear_last_error();
    if json.is_null() {
        set_last_error(1, "Null pointer passed for JSON string");
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees json is a valid pointer; string is valid UTF-8 from caller.
    let c_str = match unsafe { CStr::from_ptr(json) }.to_str() {
        Ok(s) => s,
        Err(_) => {
            set_last_error(1, "Invalid UTF-8 in JSON string");
            return std::ptr::null_mut();
        }
    };
    match serde_json::from_str::<spikard_http::ParsedMessage>(c_str) {
        Ok(val) => Box::into_raw(Box::new(val)),
        Err(e) => {
            set_last_error(2, &e.to_string());
            std::ptr::null_mut()
        }
    }
}

/// Serialize a `ParsedMessage` to a JSON string. Returns null on failure.
/// # Safety
/// `ptr` must be a valid, non-null pointer returned by a `spikard` function.
/// The returned string must be freed with `spikard_free_string`.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_parsed_message_to_json(ptr: *const spikard_http::ParsedMessage) -> *mut c_char {
    clear_last_error();
    if ptr.is_null() {
        set_last_error(1, "Null pointer passed to to_json");
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let val = unsafe { &*ptr };
    match serde_json::to_string(val) {
        Ok(s) => match CString::new(s) {
            Ok(cs) => cs.into_raw(),
            Err(e) => {
                set_last_error(2, &e.to_string());
                std::ptr::null_mut()
            }
        },
        Err(e) => {
            set_last_error(2, &e.to_string());
            std::ptr::null_mut()
        }
    }
}

/// Free a `ParsedMessage` handle.
/// # Safety
/// Pointer must have been returned by this library, or be null.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_parsed_message_free(ptr: *mut spikard_http::ParsedMessage) {
    if !ptr.is_null() {
        // SAFETY: ptr was allocated by Box::into_raw; caller ensures no aliases.
        unsafe {
            drop(Box::from_raw(ptr));
        }
    }
}

/// Get the `name` field from a `ParsedMessage`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_parsed_message_name(ptr: *const spikard_http::ParsedMessage) -> *mut std::ffi::c_char {
    if ptr.is_null() {
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    match CString::new(obj.name.to_string()) {
        Ok(cs) => cs.into_raw(),
        Err(_) => std::ptr::null_mut(),
    }
}

/// Get the `schema` field from a `ParsedMessage`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_parsed_message_schema(
    ptr: *const spikard_http::ParsedMessage,
) -> *mut std::ffi::c_char {
    if ptr.is_null() {
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    match &obj.schema {
        Some(val) => match serde_json::to_string(&val) {
            Ok(s) => match CString::new(s) {
                Ok(cs) => cs.into_raw(),
                Err(_) => std::ptr::null_mut(),
            },
            Err(_) => std::ptr::null_mut(),
        },
        None => std::ptr::null_mut(),
    }
}

/// Create a `ParseResult` from a JSON string. Returns null on failure.
/// # Safety
/// JSON string must be valid UTF-8 and null-terminated.
/// Returned handle must be freed with `spikard_parse_result_free`.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_parse_result_from_json(json: *const c_char) -> *mut spikard_http::ParseResult {
    clear_last_error();
    if json.is_null() {
        set_last_error(1, "Null pointer passed for JSON string");
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees json is a valid pointer; string is valid UTF-8 from caller.
    let c_str = match unsafe { CStr::from_ptr(json) }.to_str() {
        Ok(s) => s,
        Err(_) => {
            set_last_error(1, "Invalid UTF-8 in JSON string");
            return std::ptr::null_mut();
        }
    };
    match serde_json::from_str::<spikard_http::ParseResult>(c_str) {
        Ok(val) => Box::into_raw(Box::new(val)),
        Err(e) => {
            set_last_error(2, &e.to_string());
            std::ptr::null_mut()
        }
    }
}

/// Serialize a `ParseResult` to a JSON string. Returns null on failure.
/// # Safety
/// `ptr` must be a valid, non-null pointer returned by a `spikard` function.
/// The returned string must be freed with `spikard_free_string`.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_parse_result_to_json(ptr: *const spikard_http::ParseResult) -> *mut c_char {
    clear_last_error();
    if ptr.is_null() {
        set_last_error(1, "Null pointer passed to to_json");
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let val = unsafe { &*ptr };
    match serde_json::to_string(val) {
        Ok(s) => match CString::new(s) {
            Ok(cs) => cs.into_raw(),
            Err(e) => {
                set_last_error(2, &e.to_string());
                std::ptr::null_mut()
            }
        },
        Err(e) => {
            set_last_error(2, &e.to_string());
            std::ptr::null_mut()
        }
    }
}

/// Free a `ParseResult` handle.
/// # Safety
/// Pointer must have been returned by this library, or be null.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_parse_result_free(ptr: *mut spikard_http::ParseResult) {
    if !ptr.is_null() {
        // SAFETY: ptr was allocated by Box::into_raw; caller ensures no aliases.
        unsafe {
            drop(Box::from_raw(ptr));
        }
    }
}

/// Get the `spec_version` field from a `ParseResult`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_parse_result_spec_version(
    ptr: *const spikard_http::ParseResult,
) -> *mut std::ffi::c_char {
    if ptr.is_null() {
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    match CString::new(obj.spec_version.to_string()) {
        Ok(cs) => cs.into_raw(),
        Err(_) => std::ptr::null_mut(),
    }
}

/// Get the `title` field from a `ParseResult`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_parse_result_title(ptr: *const spikard_http::ParseResult) -> *mut std::ffi::c_char {
    if ptr.is_null() {
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    match CString::new(obj.title.to_string()) {
        Ok(cs) => cs.into_raw(),
        Err(_) => std::ptr::null_mut(),
    }
}

/// Get the `api_version` field from a `ParseResult`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_parse_result_api_version(
    ptr: *const spikard_http::ParseResult,
) -> *mut std::ffi::c_char {
    if ptr.is_null() {
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    match CString::new(obj.api_version.to_string()) {
        Ok(cs) => cs.into_raw(),
        Err(_) => std::ptr::null_mut(),
    }
}

/// Get the `channels` field from a `ParseResult`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_parse_result_channels(ptr: *const spikard_http::ParseResult) -> *mut std::ffi::c_char {
    if ptr.is_null() {
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    match serde_json::to_string(&obj.channels) {
        Ok(s) => match CString::new(s) {
            Ok(cs) => cs.into_raw(),
            Err(_) => std::ptr::null_mut(),
        },
        Err(_) => std::ptr::null_mut(),
    }
}

/// Get the `operations` field from a `ParseResult`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_parse_result_operations(
    ptr: *const spikard_http::ParseResult,
) -> *mut std::ffi::c_char {
    if ptr.is_null() {
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    match serde_json::to_string(&obj.operations) {
        Ok(s) => match CString::new(s) {
            Ok(cs) => cs.into_raw(),
            Err(_) => std::ptr::null_mut(),
        },
        Err(_) => std::ptr::null_mut(),
    }
}

/// Get the `messages` field from a `ParseResult`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_parse_result_messages(ptr: *const spikard_http::ParseResult) -> *mut std::ffi::c_char {
    if ptr.is_null() {
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    match serde_json::to_string(&obj.messages) {
        Ok(s) => match CString::new(s) {
            Ok(cs) => cs.into_raw(),
            Err(_) => std::ptr::null_mut(),
        },
        Err(_) => std::ptr::null_mut(),
    }
}

/// Free a `ParseRequest` handle.
/// # Safety
/// Pointer must have been returned by this library, or be null.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_parse_request_free(ptr: *mut spikard_http::asyncapi::ParseRequest) {
    if !ptr.is_null() {
        // SAFETY: ptr was allocated by Box::into_raw; caller ensures no aliases.
        unsafe {
            drop(Box::from_raw(ptr));
        }
    }
}

/// Get the `spec` field from a `ParseRequest`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_parse_request_spec(
    ptr: *const spikard_http::asyncapi::ParseRequest,
) -> *mut std::ffi::c_char {
    if ptr.is_null() {
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    match serde_json::to_string(&obj.spec) {
        Ok(s) => match CString::new(s) {
            Ok(cs) => cs.into_raw(),
            Err(_) => std::ptr::null_mut(),
        },
        Err(_) => std::ptr::null_mut(),
    }
}

/// Free a `ValidationResponse` handle.
/// # Safety
/// Pointer must have been returned by this library, or be null.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_validation_response_free(ptr: *mut spikard_http::ValidationResponse) {
    if !ptr.is_null() {
        // SAFETY: ptr was allocated by Box::into_raw; caller ensures no aliases.
        unsafe {
            drop(Box::from_raw(ptr));
        }
    }
}

/// Get the `valid` field from a `ValidationResponse`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_validation_response_valid(ptr: *const spikard_http::ValidationResponse) -> i32 {
    if ptr.is_null() {
        return 0;
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    obj.valid as i32
}

/// Get the `errors` field from a `ValidationResponse`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_validation_response_errors(
    ptr: *const spikard_http::ValidationResponse,
) -> *mut std::ffi::c_char {
    if ptr.is_null() {
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    match serde_json::to_string(&obj.errors) {
        Ok(s) => match CString::new(s) {
            Ok(cs) => cs.into_raw(),
            Err(_) => std::ptr::null_mut(),
        },
        Err(_) => std::ptr::null_mut(),
    }
}

/// Free a `ValidateRequest` handle.
/// # Safety
/// Pointer must have been returned by this library, or be null.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_validate_request_free(ptr: *mut spikard_http::ValidateRequest) {
    if !ptr.is_null() {
        // SAFETY: ptr was allocated by Box::into_raw; caller ensures no aliases.
        unsafe {
            drop(Box::from_raw(ptr));
        }
    }
}

/// Get the `spec` field from a `ValidateRequest`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_validate_request_spec(
    ptr: *const spikard_http::ValidateRequest,
) -> *mut std::ffi::c_char {
    if ptr.is_null() {
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    match serde_json::to_string(&obj.spec) {
        Ok(s) => match CString::new(s) {
            Ok(cs) => cs.into_raw(),
            Err(_) => std::ptr::null_mut(),
        },
        Err(_) => std::ptr::null_mut(),
    }
}

/// Get the `channel` field from a `ValidateRequest`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_validate_request_channel(
    ptr: *const spikard_http::ValidateRequest,
) -> *mut std::ffi::c_char {
    if ptr.is_null() {
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    match CString::new(obj.channel.to_string()) {
        Ok(cs) => cs.into_raw(),
        Err(_) => std::ptr::null_mut(),
    }
}

/// Get the `message` field from a `ValidateRequest`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_validate_request_message(
    ptr: *const spikard_http::ValidateRequest,
) -> *mut std::ffi::c_char {
    if ptr.is_null() {
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    match CString::new(obj.message.to_string()) {
        Ok(cs) => cs.into_raw(),
        Err(_) => std::ptr::null_mut(),
    }
}

/// Get the `payload` field from a `ValidateRequest`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_validate_request_payload(
    ptr: *const spikard_http::ValidateRequest,
) -> *mut std::ffi::c_char {
    if ptr.is_null() {
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    match serde_json::to_string(&obj.payload) {
        Ok(s) => match CString::new(s) {
            Ok(cs) => cs.into_raw(),
            Err(_) => std::ptr::null_mut(),
        },
        Err(_) => std::ptr::null_mut(),
    }
}

/// Create a `BackgroundTaskConfig` from a JSON string. Returns null on failure.
/// # Safety
/// JSON string must be valid UTF-8 and null-terminated.
/// Returned handle must be freed with `spikard_background_task_config_free`.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_background_task_config_from_json(
    json: *const c_char,
) -> *mut spikard_http::BackgroundTaskConfig {
    clear_last_error();
    if json.is_null() {
        set_last_error(1, "Null pointer passed for JSON string");
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees json is a valid pointer; string is valid UTF-8 from caller.
    let c_str = match unsafe { CStr::from_ptr(json) }.to_str() {
        Ok(s) => s,
        Err(_) => {
            set_last_error(1, "Invalid UTF-8 in JSON string");
            return std::ptr::null_mut();
        }
    };
    match serde_json::from_str::<spikard_http::BackgroundTaskConfig>(c_str) {
        Ok(val) => Box::into_raw(Box::new(val)),
        Err(e) => {
            set_last_error(2, &e.to_string());
            std::ptr::null_mut()
        }
    }
}

/// Serialize a `BackgroundTaskConfig` to a JSON string. Returns null on failure.
/// # Safety
/// `ptr` must be a valid, non-null pointer returned by a `spikard` function.
/// The returned string must be freed with `spikard_free_string`.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_background_task_config_to_json(
    ptr: *const spikard_http::BackgroundTaskConfig,
) -> *mut c_char {
    clear_last_error();
    if ptr.is_null() {
        set_last_error(1, "Null pointer passed to to_json");
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let val = unsafe { &*ptr };
    match serde_json::to_string(val) {
        Ok(s) => match CString::new(s) {
            Ok(cs) => cs.into_raw(),
            Err(e) => {
                set_last_error(2, &e.to_string());
                std::ptr::null_mut()
            }
        },
        Err(e) => {
            set_last_error(2, &e.to_string());
            std::ptr::null_mut()
        }
    }
}

/// Free a `BackgroundTaskConfig` handle.
/// # Safety
/// Pointer must have been returned by this library, or be null.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_background_task_config_free(ptr: *mut spikard_http::BackgroundTaskConfig) {
    if !ptr.is_null() {
        // SAFETY: ptr was allocated by Box::into_raw; caller ensures no aliases.
        unsafe {
            drop(Box::from_raw(ptr));
        }
    }
}

/// Get the `max_queue_size` field from a `BackgroundTaskConfig`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_background_task_config_max_queue_size(
    ptr: *const spikard_http::BackgroundTaskConfig,
) -> usize {
    if ptr.is_null() {
        return 0;
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    obj.max_queue_size
}

/// Get the `max_concurrent_tasks` field from a `BackgroundTaskConfig`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_background_task_config_max_concurrent_tasks(
    ptr: *const spikard_http::BackgroundTaskConfig,
) -> usize {
    if ptr.is_null() {
        return 0;
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    obj.max_concurrent_tasks
}

/// Get the `drain_timeout_secs` field from a `BackgroundTaskConfig`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_background_task_config_drain_timeout_secs(
    ptr: *const spikard_http::BackgroundTaskConfig,
) -> u64 {
    if ptr.is_null() {
        return 0;
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    obj.drain_timeout_secs
}

/// \note SAFETY: Caller must ensure all pointer arguments are valid or null. Returned pointers must be
/// freed with the appropriate free function.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_background_task_config_default() -> *mut spikard_http::BackgroundTaskConfig {
    clear_last_error();
    let result = spikard_http::BackgroundTaskConfig::default();
    Box::into_raw(Box::new(result))
}

/// Create a `BackgroundJobMetadata` from a JSON string. Returns null on failure.
/// # Safety
/// JSON string must be valid UTF-8 and null-terminated.
/// Returned handle must be freed with `spikard_background_job_metadata_free`.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_background_job_metadata_from_json(
    json: *const c_char,
) -> *mut spikard_http::BackgroundJobMetadata {
    clear_last_error();
    if json.is_null() {
        set_last_error(1, "Null pointer passed for JSON string");
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees json is a valid pointer; string is valid UTF-8 from caller.
    let c_str = match unsafe { CStr::from_ptr(json) }.to_str() {
        Ok(s) => s,
        Err(_) => {
            set_last_error(1, "Invalid UTF-8 in JSON string");
            return std::ptr::null_mut();
        }
    };
    match serde_json::from_str::<spikard_http::BackgroundJobMetadata>(c_str) {
        Ok(val) => Box::into_raw(Box::new(val)),
        Err(e) => {
            set_last_error(2, &e.to_string());
            std::ptr::null_mut()
        }
    }
}

/// Serialize a `BackgroundJobMetadata` to a JSON string. Returns null on failure.
/// # Safety
/// `ptr` must be a valid, non-null pointer returned by a `spikard` function.
/// The returned string must be freed with `spikard_free_string`.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_background_job_metadata_to_json(
    ptr: *const spikard_http::BackgroundJobMetadata,
) -> *mut c_char {
    clear_last_error();
    if ptr.is_null() {
        set_last_error(1, "Null pointer passed to to_json");
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let val = unsafe { &*ptr };
    match serde_json::to_string(val) {
        Ok(s) => match CString::new(s) {
            Ok(cs) => cs.into_raw(),
            Err(e) => {
                set_last_error(2, &e.to_string());
                std::ptr::null_mut()
            }
        },
        Err(e) => {
            set_last_error(2, &e.to_string());
            std::ptr::null_mut()
        }
    }
}

/// Free a `BackgroundJobMetadata` handle.
/// # Safety
/// Pointer must have been returned by this library, or be null.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_background_job_metadata_free(ptr: *mut spikard_http::BackgroundJobMetadata) {
    if !ptr.is_null() {
        // SAFETY: ptr was allocated by Box::into_raw; caller ensures no aliases.
        unsafe {
            drop(Box::from_raw(ptr));
        }
    }
}

/// Get the `request_id` field from a `BackgroundJobMetadata`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_background_job_metadata_request_id(
    ptr: *const spikard_http::BackgroundJobMetadata,
) -> *mut std::ffi::c_char {
    if ptr.is_null() {
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    match &obj.request_id {
        Some(val) => match CString::new(val.to_string()) {
            Ok(cs) => cs.into_raw(),
            Err(_) => std::ptr::null_mut(),
        },
        None => std::ptr::null_mut(),
    }
}

/// \note SAFETY: Caller must ensure all pointer arguments are valid or null. Returned pointers must be
/// freed with the appropriate free function.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_background_job_metadata_default() -> *mut spikard_http::BackgroundJobMetadata {
    clear_last_error();
    let result = spikard_http::BackgroundJobMetadata::default();
    Box::into_raw(Box::new(result))
}

/// Create a `GrpcConfig` from a JSON string. Returns null on failure.
/// # Safety
/// JSON string must be valid UTF-8 and null-terminated.
/// Returned handle must be freed with `spikard_grpc_config_free`.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_grpc_config_from_json(json: *const c_char) -> *mut spikard_http::GrpcConfig {
    clear_last_error();
    if json.is_null() {
        set_last_error(1, "Null pointer passed for JSON string");
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees json is a valid pointer; string is valid UTF-8 from caller.
    let c_str = match unsafe { CStr::from_ptr(json) }.to_str() {
        Ok(s) => s,
        Err(_) => {
            set_last_error(1, "Invalid UTF-8 in JSON string");
            return std::ptr::null_mut();
        }
    };
    match serde_json::from_str::<spikard_http::GrpcConfig>(c_str) {
        Ok(val) => Box::into_raw(Box::new(val)),
        Err(e) => {
            set_last_error(2, &e.to_string());
            std::ptr::null_mut()
        }
    }
}

/// Serialize a `GrpcConfig` to a JSON string. Returns null on failure.
/// # Safety
/// `ptr` must be a valid, non-null pointer returned by a `spikard` function.
/// The returned string must be freed with `spikard_free_string`.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_grpc_config_to_json(ptr: *const spikard_http::GrpcConfig) -> *mut c_char {
    clear_last_error();
    if ptr.is_null() {
        set_last_error(1, "Null pointer passed to to_json");
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let val = unsafe { &*ptr };
    match serde_json::to_string(val) {
        Ok(s) => match CString::new(s) {
            Ok(cs) => cs.into_raw(),
            Err(e) => {
                set_last_error(2, &e.to_string());
                std::ptr::null_mut()
            }
        },
        Err(e) => {
            set_last_error(2, &e.to_string());
            std::ptr::null_mut()
        }
    }
}

/// Free a `GrpcConfig` handle.
/// # Safety
/// Pointer must have been returned by this library, or be null.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_grpc_config_free(ptr: *mut spikard_http::GrpcConfig) {
    if !ptr.is_null() {
        // SAFETY: ptr was allocated by Box::into_raw; caller ensures no aliases.
        unsafe {
            drop(Box::from_raw(ptr));
        }
    }
}

/// Get the `enabled` field from a `GrpcConfig`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_grpc_config_enabled(ptr: *const spikard_http::GrpcConfig) -> i32 {
    if ptr.is_null() {
        return 0;
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    obj.enabled as i32
}

/// Get the `max_message_size` field from a `GrpcConfig`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_grpc_config_max_message_size(ptr: *const spikard_http::GrpcConfig) -> usize {
    if ptr.is_null() {
        return 0;
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    obj.max_message_size
}

/// Get the `enable_compression` field from a `GrpcConfig`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_grpc_config_enable_compression(ptr: *const spikard_http::GrpcConfig) -> i32 {
    if ptr.is_null() {
        return 0;
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    obj.enable_compression as i32
}

/// Get the `request_timeout` field from a `GrpcConfig`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_grpc_config_request_timeout(ptr: *const spikard_http::GrpcConfig) -> u64 {
    if ptr.is_null() {
        return 0;
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    match &obj.request_timeout {
        Some(val) => *val,
        None => 0,
    }
}

/// Get the `max_concurrent_streams` field from a `GrpcConfig`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_grpc_config_max_concurrent_streams(ptr: *const spikard_http::GrpcConfig) -> u32 {
    if ptr.is_null() {
        return 0;
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    obj.max_concurrent_streams
}

/// Get the `enable_keepalive` field from a `GrpcConfig`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_grpc_config_enable_keepalive(ptr: *const spikard_http::GrpcConfig) -> i32 {
    if ptr.is_null() {
        return 0;
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    obj.enable_keepalive as i32
}

/// Get the `keepalive_interval` field from a `GrpcConfig`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_grpc_config_keepalive_interval(ptr: *const spikard_http::GrpcConfig) -> u64 {
    if ptr.is_null() {
        return 0;
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    obj.keepalive_interval
}

/// Get the `keepalive_timeout` field from a `GrpcConfig`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_grpc_config_keepalive_timeout(ptr: *const spikard_http::GrpcConfig) -> u64 {
    if ptr.is_null() {
        return 0;
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    obj.keepalive_timeout
}

/// Get the `max_stream_response_bytes` field from a `GrpcConfig`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_grpc_config_max_stream_response_bytes(ptr: *const spikard_http::GrpcConfig) -> usize {
    if ptr.is_null() {
        return 0;
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    match &obj.max_stream_response_bytes {
        Some(val) => *val,
        None => 0,
    }
}

/// \note SAFETY: Caller must ensure all pointer arguments are valid or null. Returned pointers must be
/// freed with the appropriate free function.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_grpc_config_default() -> *mut spikard_http::GrpcConfig {
    clear_last_error();
    let result = spikard_http::GrpcConfig::default();
    Box::into_raw(Box::new(result))
}

/// Create a `JsonRpcConfig` from a JSON string. Returns null on failure.
/// # Safety
/// JSON string must be valid UTF-8 and null-terminated.
/// Returned handle must be freed with `spikard_json_rpc_config_free`.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_json_rpc_config_from_json(json: *const c_char) -> *mut spikard_http::JsonRpcConfig {
    clear_last_error();
    if json.is_null() {
        set_last_error(1, "Null pointer passed for JSON string");
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees json is a valid pointer; string is valid UTF-8 from caller.
    let c_str = match unsafe { CStr::from_ptr(json) }.to_str() {
        Ok(s) => s,
        Err(_) => {
            set_last_error(1, "Invalid UTF-8 in JSON string");
            return std::ptr::null_mut();
        }
    };
    match serde_json::from_str::<spikard_http::JsonRpcConfig>(c_str) {
        Ok(val) => Box::into_raw(Box::new(val)),
        Err(e) => {
            set_last_error(2, &e.to_string());
            std::ptr::null_mut()
        }
    }
}

/// Serialize a `JsonRpcConfig` to a JSON string. Returns null on failure.
/// # Safety
/// `ptr` must be a valid, non-null pointer returned by a `spikard` function.
/// The returned string must be freed with `spikard_free_string`.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_json_rpc_config_to_json(ptr: *const spikard_http::JsonRpcConfig) -> *mut c_char {
    clear_last_error();
    if ptr.is_null() {
        set_last_error(1, "Null pointer passed to to_json");
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let val = unsafe { &*ptr };
    match serde_json::to_string(val) {
        Ok(s) => match CString::new(s) {
            Ok(cs) => cs.into_raw(),
            Err(e) => {
                set_last_error(2, &e.to_string());
                std::ptr::null_mut()
            }
        },
        Err(e) => {
            set_last_error(2, &e.to_string());
            std::ptr::null_mut()
        }
    }
}

/// Free a `JsonRpcConfig` handle.
/// # Safety
/// Pointer must have been returned by this library, or be null.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_json_rpc_config_free(ptr: *mut spikard_http::JsonRpcConfig) {
    if !ptr.is_null() {
        // SAFETY: ptr was allocated by Box::into_raw; caller ensures no aliases.
        unsafe {
            drop(Box::from_raw(ptr));
        }
    }
}

/// Get the `enabled` field from a `JsonRpcConfig`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_json_rpc_config_enabled(ptr: *const spikard_http::JsonRpcConfig) -> i32 {
    if ptr.is_null() {
        return 0;
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    obj.enabled as i32
}

/// Get the `endpoint_path` field from a `JsonRpcConfig`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_json_rpc_config_endpoint_path(
    ptr: *const spikard_http::JsonRpcConfig,
) -> *mut std::ffi::c_char {
    if ptr.is_null() {
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    match CString::new(obj.endpoint_path.to_string()) {
        Ok(cs) => cs.into_raw(),
        Err(_) => std::ptr::null_mut(),
    }
}

/// Get the `enable_batch` field from a `JsonRpcConfig`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_json_rpc_config_enable_batch(ptr: *const spikard_http::JsonRpcConfig) -> i32 {
    if ptr.is_null() {
        return 0;
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    obj.enable_batch as i32
}

/// Get the `max_batch_size` field from a `JsonRpcConfig`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_json_rpc_config_max_batch_size(ptr: *const spikard_http::JsonRpcConfig) -> usize {
    if ptr.is_null() {
        return 0;
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    obj.max_batch_size
}

/// \note SAFETY: Caller must ensure all pointer arguments are valid or null. Returned pointers must be
/// freed with the appropriate free function.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_json_rpc_config_default() -> *mut spikard_http::JsonRpcConfig {
    clear_last_error();
    let result = spikard_http::JsonRpcConfig::default();
    Box::into_raw(Box::new(result))
}

/// Create a `OpenApiConfig` from a JSON string. Returns null on failure.
/// # Safety
/// JSON string must be valid UTF-8 and null-terminated.
/// Returned handle must be freed with `spikard_open_api_config_free`.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_open_api_config_from_json(json: *const c_char) -> *mut spikard_http::OpenApiConfig {
    clear_last_error();
    if json.is_null() {
        set_last_error(1, "Null pointer passed for JSON string");
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees json is a valid pointer; string is valid UTF-8 from caller.
    let c_str = match unsafe { CStr::from_ptr(json) }.to_str() {
        Ok(s) => s,
        Err(_) => {
            set_last_error(1, "Invalid UTF-8 in JSON string");
            return std::ptr::null_mut();
        }
    };
    match serde_json::from_str::<spikard_http::OpenApiConfig>(c_str) {
        Ok(val) => Box::into_raw(Box::new(val)),
        Err(e) => {
            set_last_error(2, &e.to_string());
            std::ptr::null_mut()
        }
    }
}

/// Serialize a `OpenApiConfig` to a JSON string. Returns null on failure.
/// # Safety
/// `ptr` must be a valid, non-null pointer returned by a `spikard` function.
/// The returned string must be freed with `spikard_free_string`.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_open_api_config_to_json(ptr: *const spikard_http::OpenApiConfig) -> *mut c_char {
    clear_last_error();
    if ptr.is_null() {
        set_last_error(1, "Null pointer passed to to_json");
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let val = unsafe { &*ptr };
    match serde_json::to_string(val) {
        Ok(s) => match CString::new(s) {
            Ok(cs) => cs.into_raw(),
            Err(e) => {
                set_last_error(2, &e.to_string());
                std::ptr::null_mut()
            }
        },
        Err(e) => {
            set_last_error(2, &e.to_string());
            std::ptr::null_mut()
        }
    }
}

/// Free a `OpenApiConfig` handle.
/// # Safety
/// Pointer must have been returned by this library, or be null.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_open_api_config_free(ptr: *mut spikard_http::OpenApiConfig) {
    if !ptr.is_null() {
        // SAFETY: ptr was allocated by Box::into_raw; caller ensures no aliases.
        unsafe {
            drop(Box::from_raw(ptr));
        }
    }
}

/// Get the `enabled` field from a `OpenApiConfig`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_open_api_config_enabled(ptr: *const spikard_http::OpenApiConfig) -> i32 {
    if ptr.is_null() {
        return 0;
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    obj.enabled as i32
}

/// Get the `title` field from a `OpenApiConfig`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_open_api_config_title(
    ptr: *const spikard_http::OpenApiConfig,
) -> *mut std::ffi::c_char {
    if ptr.is_null() {
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    match CString::new(obj.title.to_string()) {
        Ok(cs) => cs.into_raw(),
        Err(_) => std::ptr::null_mut(),
    }
}

/// Get the `version` field from a `OpenApiConfig`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_open_api_config_version(
    ptr: *const spikard_http::OpenApiConfig,
) -> *mut std::ffi::c_char {
    if ptr.is_null() {
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    match CString::new(obj.version.to_string()) {
        Ok(cs) => cs.into_raw(),
        Err(_) => std::ptr::null_mut(),
    }
}

/// Get the `description` field from a `OpenApiConfig`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_open_api_config_description(
    ptr: *const spikard_http::OpenApiConfig,
) -> *mut std::ffi::c_char {
    if ptr.is_null() {
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    match &obj.description {
        Some(val) => match CString::new(val.to_string()) {
            Ok(cs) => cs.into_raw(),
            Err(_) => std::ptr::null_mut(),
        },
        None => std::ptr::null_mut(),
    }
}

/// Get the `swagger_ui_path` field from a `OpenApiConfig`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_open_api_config_swagger_ui_path(
    ptr: *const spikard_http::OpenApiConfig,
) -> *mut std::ffi::c_char {
    if ptr.is_null() {
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    match CString::new(obj.swagger_ui_path.to_string()) {
        Ok(cs) => cs.into_raw(),
        Err(_) => std::ptr::null_mut(),
    }
}

/// Get the `redoc_path` field from a `OpenApiConfig`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_open_api_config_redoc_path(
    ptr: *const spikard_http::OpenApiConfig,
) -> *mut std::ffi::c_char {
    if ptr.is_null() {
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    match CString::new(obj.redoc_path.to_string()) {
        Ok(cs) => cs.into_raw(),
        Err(_) => std::ptr::null_mut(),
    }
}

/// Get the `openapi_json_path` field from a `OpenApiConfig`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_open_api_config_openapi_json_path(
    ptr: *const spikard_http::OpenApiConfig,
) -> *mut std::ffi::c_char {
    if ptr.is_null() {
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    match CString::new(obj.openapi_json_path.to_string()) {
        Ok(cs) => cs.into_raw(),
        Err(_) => std::ptr::null_mut(),
    }
}

/// Get the `contact` field from a `OpenApiConfig`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_open_api_config_contact(
    ptr: *const spikard_http::OpenApiConfig,
) -> *mut spikard_http::ContactInfo {
    if ptr.is_null() {
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    match &obj.contact {
        Some(val) => Box::into_raw(Box::new(val.clone())),
        None => std::ptr::null_mut(),
    }
}

/// Get the `license` field from a `OpenApiConfig`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_open_api_config_license(
    ptr: *const spikard_http::OpenApiConfig,
) -> *mut spikard_http::LicenseInfo {
    if ptr.is_null() {
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    match &obj.license {
        Some(val) => Box::into_raw(Box::new(val.clone())),
        None => std::ptr::null_mut(),
    }
}

/// Get the `servers` field from a `OpenApiConfig`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_open_api_config_servers(
    ptr: *const spikard_http::OpenApiConfig,
) -> *mut std::ffi::c_char {
    if ptr.is_null() {
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    match serde_json::to_string(&obj.servers) {
        Ok(s) => match CString::new(s) {
            Ok(cs) => cs.into_raw(),
            Err(_) => std::ptr::null_mut(),
        },
        Err(_) => std::ptr::null_mut(),
    }
}

/// Get the `security_schemes` field from a `OpenApiConfig`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_open_api_config_security_schemes(
    ptr: *const spikard_http::OpenApiConfig,
) -> *mut std::ffi::c_char {
    if ptr.is_null() {
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    match serde_json::to_string(&obj.security_schemes) {
        Ok(s) => match CString::new(s) {
            Ok(cs) => cs.into_raw(),
            Err(_) => std::ptr::null_mut(),
        },
        Err(_) => std::ptr::null_mut(),
    }
}

/// \note SAFETY: Caller must ensure all pointer arguments are valid or null. Returned pointers must be
/// freed with the appropriate free function.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_open_api_config_default() -> *mut spikard_http::OpenApiConfig {
    clear_last_error();
    let result = spikard_http::OpenApiConfig::default();
    Box::into_raw(Box::new(result))
}

/// Create a `ContactInfo` from a JSON string. Returns null on failure.
/// # Safety
/// JSON string must be valid UTF-8 and null-terminated.
/// Returned handle must be freed with `spikard_contact_info_free`.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_contact_info_from_json(json: *const c_char) -> *mut spikard_http::ContactInfo {
    clear_last_error();
    if json.is_null() {
        set_last_error(1, "Null pointer passed for JSON string");
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees json is a valid pointer; string is valid UTF-8 from caller.
    let c_str = match unsafe { CStr::from_ptr(json) }.to_str() {
        Ok(s) => s,
        Err(_) => {
            set_last_error(1, "Invalid UTF-8 in JSON string");
            return std::ptr::null_mut();
        }
    };
    match serde_json::from_str::<spikard_http::ContactInfo>(c_str) {
        Ok(val) => Box::into_raw(Box::new(val)),
        Err(e) => {
            set_last_error(2, &e.to_string());
            std::ptr::null_mut()
        }
    }
}

/// Serialize a `ContactInfo` to a JSON string. Returns null on failure.
/// # Safety
/// `ptr` must be a valid, non-null pointer returned by a `spikard` function.
/// The returned string must be freed with `spikard_free_string`.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_contact_info_to_json(ptr: *const spikard_http::ContactInfo) -> *mut c_char {
    clear_last_error();
    if ptr.is_null() {
        set_last_error(1, "Null pointer passed to to_json");
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let val = unsafe { &*ptr };
    match serde_json::to_string(val) {
        Ok(s) => match CString::new(s) {
            Ok(cs) => cs.into_raw(),
            Err(e) => {
                set_last_error(2, &e.to_string());
                std::ptr::null_mut()
            }
        },
        Err(e) => {
            set_last_error(2, &e.to_string());
            std::ptr::null_mut()
        }
    }
}

/// Free a `ContactInfo` handle.
/// # Safety
/// Pointer must have been returned by this library, or be null.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_contact_info_free(ptr: *mut spikard_http::ContactInfo) {
    if !ptr.is_null() {
        // SAFETY: ptr was allocated by Box::into_raw; caller ensures no aliases.
        unsafe {
            drop(Box::from_raw(ptr));
        }
    }
}

/// Get the `name` field from a `ContactInfo`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_contact_info_name(ptr: *const spikard_http::ContactInfo) -> *mut std::ffi::c_char {
    if ptr.is_null() {
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    match &obj.name {
        Some(val) => match CString::new(val.to_string()) {
            Ok(cs) => cs.into_raw(),
            Err(_) => std::ptr::null_mut(),
        },
        None => std::ptr::null_mut(),
    }
}

/// Get the `email` field from a `ContactInfo`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_contact_info_email(ptr: *const spikard_http::ContactInfo) -> *mut std::ffi::c_char {
    if ptr.is_null() {
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    match &obj.email {
        Some(val) => match CString::new(val.to_string()) {
            Ok(cs) => cs.into_raw(),
            Err(_) => std::ptr::null_mut(),
        },
        None => std::ptr::null_mut(),
    }
}

/// Get the `url` field from a `ContactInfo`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_contact_info_url(ptr: *const spikard_http::ContactInfo) -> *mut std::ffi::c_char {
    if ptr.is_null() {
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    match &obj.url {
        Some(val) => match CString::new(val.to_string()) {
            Ok(cs) => cs.into_raw(),
            Err(_) => std::ptr::null_mut(),
        },
        None => std::ptr::null_mut(),
    }
}

/// Create a `LicenseInfo` from a JSON string. Returns null on failure.
/// # Safety
/// JSON string must be valid UTF-8 and null-terminated.
/// Returned handle must be freed with `spikard_license_info_free`.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_license_info_from_json(json: *const c_char) -> *mut spikard_http::LicenseInfo {
    clear_last_error();
    if json.is_null() {
        set_last_error(1, "Null pointer passed for JSON string");
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees json is a valid pointer; string is valid UTF-8 from caller.
    let c_str = match unsafe { CStr::from_ptr(json) }.to_str() {
        Ok(s) => s,
        Err(_) => {
            set_last_error(1, "Invalid UTF-8 in JSON string");
            return std::ptr::null_mut();
        }
    };
    match serde_json::from_str::<spikard_http::LicenseInfo>(c_str) {
        Ok(val) => Box::into_raw(Box::new(val)),
        Err(e) => {
            set_last_error(2, &e.to_string());
            std::ptr::null_mut()
        }
    }
}

/// Serialize a `LicenseInfo` to a JSON string. Returns null on failure.
/// # Safety
/// `ptr` must be a valid, non-null pointer returned by a `spikard` function.
/// The returned string must be freed with `spikard_free_string`.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_license_info_to_json(ptr: *const spikard_http::LicenseInfo) -> *mut c_char {
    clear_last_error();
    if ptr.is_null() {
        set_last_error(1, "Null pointer passed to to_json");
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let val = unsafe { &*ptr };
    match serde_json::to_string(val) {
        Ok(s) => match CString::new(s) {
            Ok(cs) => cs.into_raw(),
            Err(e) => {
                set_last_error(2, &e.to_string());
                std::ptr::null_mut()
            }
        },
        Err(e) => {
            set_last_error(2, &e.to_string());
            std::ptr::null_mut()
        }
    }
}

/// Free a `LicenseInfo` handle.
/// # Safety
/// Pointer must have been returned by this library, or be null.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_license_info_free(ptr: *mut spikard_http::LicenseInfo) {
    if !ptr.is_null() {
        // SAFETY: ptr was allocated by Box::into_raw; caller ensures no aliases.
        unsafe {
            drop(Box::from_raw(ptr));
        }
    }
}

/// Get the `name` field from a `LicenseInfo`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_license_info_name(ptr: *const spikard_http::LicenseInfo) -> *mut std::ffi::c_char {
    if ptr.is_null() {
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    match CString::new(obj.name.to_string()) {
        Ok(cs) => cs.into_raw(),
        Err(_) => std::ptr::null_mut(),
    }
}

/// Get the `url` field from a `LicenseInfo`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_license_info_url(ptr: *const spikard_http::LicenseInfo) -> *mut std::ffi::c_char {
    if ptr.is_null() {
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    match &obj.url {
        Some(val) => match CString::new(val.to_string()) {
            Ok(cs) => cs.into_raw(),
            Err(_) => std::ptr::null_mut(),
        },
        None => std::ptr::null_mut(),
    }
}

/// Create a `ServerInfo` from a JSON string. Returns null on failure.
/// # Safety
/// JSON string must be valid UTF-8 and null-terminated.
/// Returned handle must be freed with `spikard_server_info_free`.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_server_info_from_json(json: *const c_char) -> *mut spikard_http::ServerInfo {
    clear_last_error();
    if json.is_null() {
        set_last_error(1, "Null pointer passed for JSON string");
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees json is a valid pointer; string is valid UTF-8 from caller.
    let c_str = match unsafe { CStr::from_ptr(json) }.to_str() {
        Ok(s) => s,
        Err(_) => {
            set_last_error(1, "Invalid UTF-8 in JSON string");
            return std::ptr::null_mut();
        }
    };
    match serde_json::from_str::<spikard_http::ServerInfo>(c_str) {
        Ok(val) => Box::into_raw(Box::new(val)),
        Err(e) => {
            set_last_error(2, &e.to_string());
            std::ptr::null_mut()
        }
    }
}

/// Serialize a `ServerInfo` to a JSON string. Returns null on failure.
/// # Safety
/// `ptr` must be a valid, non-null pointer returned by a `spikard` function.
/// The returned string must be freed with `spikard_free_string`.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_server_info_to_json(ptr: *const spikard_http::ServerInfo) -> *mut c_char {
    clear_last_error();
    if ptr.is_null() {
        set_last_error(1, "Null pointer passed to to_json");
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let val = unsafe { &*ptr };
    match serde_json::to_string(val) {
        Ok(s) => match CString::new(s) {
            Ok(cs) => cs.into_raw(),
            Err(e) => {
                set_last_error(2, &e.to_string());
                std::ptr::null_mut()
            }
        },
        Err(e) => {
            set_last_error(2, &e.to_string());
            std::ptr::null_mut()
        }
    }
}

/// Free a `ServerInfo` handle.
/// # Safety
/// Pointer must have been returned by this library, or be null.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_server_info_free(ptr: *mut spikard_http::ServerInfo) {
    if !ptr.is_null() {
        // SAFETY: ptr was allocated by Box::into_raw; caller ensures no aliases.
        unsafe {
            drop(Box::from_raw(ptr));
        }
    }
}

/// Get the `url` field from a `ServerInfo`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_server_info_url(ptr: *const spikard_http::ServerInfo) -> *mut std::ffi::c_char {
    if ptr.is_null() {
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    match CString::new(obj.url.to_string()) {
        Ok(cs) => cs.into_raw(),
        Err(_) => std::ptr::null_mut(),
    }
}

/// Get the `description` field from a `ServerInfo`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_server_info_description(
    ptr: *const spikard_http::ServerInfo,
) -> *mut std::ffi::c_char {
    if ptr.is_null() {
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    match &obj.description {
        Some(val) => match CString::new(val.to_string()) {
            Ok(cs) => cs.into_raw(),
            Err(_) => std::ptr::null_mut(),
        },
        None => std::ptr::null_mut(),
    }
}

/// Create a `Response` from a JSON string. Returns null on failure.
/// # Safety
/// JSON string must be valid UTF-8 and null-terminated.
/// Returned handle must be freed with `spikard_response_free`.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_response_from_json(json: *const c_char) -> *mut spikard_http::Response {
    clear_last_error();
    if json.is_null() {
        set_last_error(1, "Null pointer passed for JSON string");
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees json is a valid pointer; string is valid UTF-8 from caller.
    let c_str = match unsafe { CStr::from_ptr(json) }.to_str() {
        Ok(s) => s,
        Err(_) => {
            set_last_error(1, "Invalid UTF-8 in JSON string");
            return std::ptr::null_mut();
        }
    };
    match serde_json::from_str::<spikard_http::Response>(c_str) {
        Ok(val) => Box::into_raw(Box::new(val)),
        Err(e) => {
            set_last_error(2, &e.to_string());
            std::ptr::null_mut()
        }
    }
}

/// Serialize a `Response` to a JSON string. Returns null on failure.
/// # Safety
/// `ptr` must be a valid, non-null pointer returned by a `spikard` function.
/// The returned string must be freed with `spikard_free_string`.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_response_to_json(ptr: *const spikard_http::Response) -> *mut c_char {
    clear_last_error();
    if ptr.is_null() {
        set_last_error(1, "Null pointer passed to to_json");
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let val = unsafe { &*ptr };
    match serde_json::to_string(val) {
        Ok(s) => match CString::new(s) {
            Ok(cs) => cs.into_raw(),
            Err(e) => {
                set_last_error(2, &e.to_string());
                std::ptr::null_mut()
            }
        },
        Err(e) => {
            set_last_error(2, &e.to_string());
            std::ptr::null_mut()
        }
    }
}

/// Free a `Response` handle.
/// # Safety
/// Pointer must have been returned by this library, or be null.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_response_free(ptr: *mut spikard_http::Response) {
    if !ptr.is_null() {
        // SAFETY: ptr was allocated by Box::into_raw; caller ensures no aliases.
        unsafe {
            drop(Box::from_raw(ptr));
        }
    }
}

/// Get the `content` field from a `Response`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_response_content(ptr: *const spikard_http::Response) -> *mut std::ffi::c_char {
    if ptr.is_null() {
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    match &obj.content {
        Some(val) => match serde_json::to_string(&val) {
            Ok(s) => match CString::new(s) {
                Ok(cs) => cs.into_raw(),
                Err(_) => std::ptr::null_mut(),
            },
            Err(_) => std::ptr::null_mut(),
        },
        None => std::ptr::null_mut(),
    }
}

/// Get the `status_code` field from a `Response`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_response_status_code(ptr: *const spikard_http::Response) -> u16 {
    if ptr.is_null() {
        return 0;
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    obj.status_code
}

/// Get the `headers` field from a `Response`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_response_headers(ptr: *const spikard_http::Response) -> *mut std::ffi::c_char {
    if ptr.is_null() {
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    match serde_json::to_string(&obj.headers) {
        Ok(s) => match CString::new(s) {
            Ok(cs) => cs.into_raw(),
            Err(_) => std::ptr::null_mut(),
        },
        Err(_) => std::ptr::null_mut(),
    }
}

/// Set a header
/// \note SAFETY: Caller must ensure all pointer arguments are valid or null. Returned pointers must be
/// freed with the appropriate free function.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_response_set_header(
    this: *mut spikard_http::Response,
    key: *const std::ffi::c_char,
    value: *const std::ffi::c_char,
) {
    clear_last_error();
    if this.is_null() {
        set_last_error(1, "Null pointer passed for self");
        return;
    }
    // SAFETY: null check above guarantees this is a valid pointer; caller ensures exclusive access.
    let obj = unsafe { &mut *this };

    if key.is_null() {
        set_last_error(1, "Null pointer passed for parameter 'key'");
        return;
    }
    // SAFETY: null check above guarantees key is a valid pointer; string is valid UTF-8 from caller.
    let key_rs = match unsafe { CStr::from_ptr(key) }.to_str() {
        Ok(s) => s.to_string(),
        Err(_) => {
            set_last_error(1, "Invalid UTF-8 in parameter 'key'");
            return;
        }
    };
    if value.is_null() {
        set_last_error(1, "Null pointer passed for parameter 'value'");
        return;
    }
    // SAFETY: null check above guarantees value is a valid pointer; string is valid UTF-8 from caller.
    let value_rs = match unsafe { CStr::from_ptr(value) }.to_str() {
        Ok(s) => s.to_string(),
        Err(_) => {
            set_last_error(1, "Invalid UTF-8 in parameter 'value'");
            return;
        }
    };
    let result = obj.set_header(key_rs, value_rs);
}

/// Set a cookie in the response
/// \note SAFETY: Caller must ensure all pointer arguments are valid or null. Returned pointers must be
/// freed with the appropriate free function.
#[allow(clippy::too_many_arguments)]
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_response_set_cookie(
    this: *mut spikard_http::Response,
    key: *const std::ffi::c_char,
    value: *const std::ffi::c_char,
    secure: i32,
    http_only: i32,
    max_age: i64,
    domain: *const std::ffi::c_char,
    path: *const std::ffi::c_char,
    same_site: *const std::ffi::c_char,
) {
    clear_last_error();
    if this.is_null() {
        set_last_error(1, "Null pointer passed for self");
        return;
    }
    // SAFETY: null check above guarantees this is a valid pointer; caller ensures exclusive access.
    let obj = unsafe { &mut *this };

    if key.is_null() {
        set_last_error(1, "Null pointer passed for parameter 'key'");
        return;
    }
    // SAFETY: null check above guarantees key is a valid pointer; string is valid UTF-8 from caller.
    let key_rs = match unsafe { CStr::from_ptr(key) }.to_str() {
        Ok(s) => s.to_string(),
        Err(_) => {
            set_last_error(1, "Invalid UTF-8 in parameter 'key'");
            return;
        }
    };
    if value.is_null() {
        set_last_error(1, "Null pointer passed for parameter 'value'");
        return;
    }
    // SAFETY: null check above guarantees value is a valid pointer; string is valid UTF-8 from caller.
    let value_rs = match unsafe { CStr::from_ptr(value) }.to_str() {
        Ok(s) => s.to_string(),
        Err(_) => {
            set_last_error(1, "Invalid UTF-8 in parameter 'value'");
            return;
        }
    };
    let secure_rs = secure != 0;
    let http_only_rs = http_only != 0;
    // Optional numeric primitive: max value of type = None
    let max_age_rs = if max_age == i64::MAX { None } else { Some(max_age) };
    let domain_rs = if domain.is_null() {
        None
    } else {
        // SAFETY: null check above guarantees domain is a valid pointer; string is valid UTF-8 from caller.
        match unsafe { CStr::from_ptr(domain) }.to_str() {
            Ok(s) => Some(s.to_string()),
            Err(_) => {
                set_last_error(1, "Invalid UTF-8 in parameter 'domain'");
                return;
            }
        }
    };
    let path_rs = if path.is_null() {
        None
    } else {
        // SAFETY: null check above guarantees path is a valid pointer; string is valid UTF-8 from caller.
        match unsafe { CStr::from_ptr(path) }.to_str() {
            Ok(s) => Some(s.to_string()),
            Err(_) => {
                set_last_error(1, "Invalid UTF-8 in parameter 'path'");
                return;
            }
        }
    };
    let same_site_rs = if same_site.is_null() {
        None
    } else {
        // SAFETY: null check above guarantees same_site is a valid pointer; string is valid UTF-8 from caller.
        match unsafe { CStr::from_ptr(same_site) }.to_str() {
            Ok(s) => Some(s.to_string()),
            Err(_) => {
                set_last_error(1, "Invalid UTF-8 in parameter 'same_site'");
                return;
            }
        }
    };
    let result = obj.set_cookie(
        key_rs,
        value_rs,
        secure_rs,
        http_only_rs,
        max_age_rs,
        domain_rs,
        path_rs,
        same_site_rs,
    );
}

/// \note SAFETY: Caller must ensure all pointer arguments are valid or null. Returned pointers must be
/// freed with the appropriate free function.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_response_default() -> *mut spikard_http::Response {
    clear_last_error();
    let result = spikard_http::Response::default();
    Box::into_raw(Box::new(result))
}

/// Create a `SseEvent` from a JSON string. Returns null on failure.
/// # Safety
/// JSON string must be valid UTF-8 and null-terminated.
/// Returned handle must be freed with `spikard_sse_event_free`.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_sse_event_from_json(json: *const c_char) -> *mut spikard_http::SseEvent {
    clear_last_error();
    if json.is_null() {
        set_last_error(1, "Null pointer passed for JSON string");
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees json is a valid pointer; string is valid UTF-8 from caller.
    let c_str = match unsafe { CStr::from_ptr(json) }.to_str() {
        Ok(s) => s,
        Err(_) => {
            set_last_error(1, "Invalid UTF-8 in JSON string");
            return std::ptr::null_mut();
        }
    };
    match serde_json::from_str::<spikard_http::SseEvent>(c_str) {
        Ok(val) => Box::into_raw(Box::new(val)),
        Err(e) => {
            set_last_error(2, &e.to_string());
            std::ptr::null_mut()
        }
    }
}

/// Serialize a `SseEvent` to a JSON string. Returns null on failure.
/// # Safety
/// `ptr` must be a valid, non-null pointer returned by a `spikard` function.
/// The returned string must be freed with `spikard_free_string`.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_sse_event_to_json(ptr: *const spikard_http::SseEvent) -> *mut c_char {
    clear_last_error();
    if ptr.is_null() {
        set_last_error(1, "Null pointer passed to to_json");
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let val = unsafe { &*ptr };
    match serde_json::to_string(val) {
        Ok(s) => match CString::new(s) {
            Ok(cs) => cs.into_raw(),
            Err(e) => {
                set_last_error(2, &e.to_string());
                std::ptr::null_mut()
            }
        },
        Err(e) => {
            set_last_error(2, &e.to_string());
            std::ptr::null_mut()
        }
    }
}

/// Free a `SseEvent` handle.
/// # Safety
/// Pointer must have been returned by this library, or be null.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_sse_event_free(ptr: *mut spikard_http::SseEvent) {
    if !ptr.is_null() {
        // SAFETY: ptr was allocated by Box::into_raw; caller ensures no aliases.
        unsafe {
            drop(Box::from_raw(ptr));
        }
    }
}

/// Get the `event_type` field from a `SseEvent`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_sse_event_event_type(ptr: *const spikard_http::SseEvent) -> *mut std::ffi::c_char {
    if ptr.is_null() {
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    match &obj.event_type {
        Some(val) => match CString::new(val.to_string()) {
            Ok(cs) => cs.into_raw(),
            Err(_) => std::ptr::null_mut(),
        },
        None => std::ptr::null_mut(),
    }
}

/// Get the `data` field from a `SseEvent`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_sse_event_data(ptr: *const spikard_http::SseEvent) -> *mut std::ffi::c_char {
    if ptr.is_null() {
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    match serde_json::to_string(&obj.data) {
        Ok(s) => match CString::new(s) {
            Ok(cs) => cs.into_raw(),
            Err(_) => std::ptr::null_mut(),
        },
        Err(_) => std::ptr::null_mut(),
    }
}

/// Get the `id` field from a `SseEvent`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_sse_event_id(ptr: *const spikard_http::SseEvent) -> *mut std::ffi::c_char {
    if ptr.is_null() {
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    match &obj.id {
        Some(val) => match CString::new(val.to_string()) {
            Ok(cs) => cs.into_raw(),
            Err(_) => std::ptr::null_mut(),
        },
        None => std::ptr::null_mut(),
    }
}

/// Get the `retry` field from a `SseEvent`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_sse_event_retry(ptr: *const spikard_http::SseEvent) -> u64 {
    if ptr.is_null() {
        return 0;
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    match &obj.retry {
        Some(val) => *val,
        None => 0,
    }
}

/// Set the event ID for client-side reconnection support
///
/// Sets an ID that clients can use to resume from this point if they disconnect.
/// The client sends this ID back in the `Last-Event-ID` header when reconnecting.
/// \param id Unique identifier for this event
/// \note SAFETY: Caller must ensure all pointer arguments are valid or null. Returned pointers must be
/// freed with the appropriate free function.
/// \code
/// use serde_json::json;
/// use spikard_http::sse::SseEvent;
///
/// let event = SseEvent::new(json!({"count": 1}))
///     .with_id("event-1");
/// \endcode
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_sse_event_with_id(
    this: *mut spikard_http::SseEvent,
    id: *const std::ffi::c_char,
) -> *mut spikard_http::SseEvent {
    clear_last_error();
    if this.is_null() {
        set_last_error(1, "Null pointer passed for self");
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees this is a valid pointer originally from Box::into_raw.
    let obj = unsafe { *Box::from_raw(this) };

    if id.is_null() {
        set_last_error(1, "Null pointer passed for parameter 'id'");
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees id is a valid pointer; string is valid UTF-8 from caller.
    let id_rs = match unsafe { CStr::from_ptr(id) }.to_str() {
        Ok(s) => s.to_string(),
        Err(_) => {
            set_last_error(1, "Invalid UTF-8 in parameter 'id'");
            return std::ptr::null_mut();
        }
    };
    let result = obj.with_id(id_rs);
    Box::into_raw(Box::new(result))
}

/// Set the retry timeout for client reconnection
///
/// Sets the time in milliseconds clients should wait before attempting to reconnect
/// if the connection is lost. The client browser will automatically handle reconnection.
/// \param retry_ms Retry timeout in milliseconds
/// \note SAFETY: Caller must ensure all pointer arguments are valid or null. Returned pointers must be
/// freed with the appropriate free function.
/// \code
/// use serde_json::json;
/// use spikard_http::sse::SseEvent;
///
/// let event = SseEvent::new(json!({"data": "value"}))
///     .with_retry(5000); // Reconnect after 5 seconds
/// \endcode
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_sse_event_with_retry(
    this: *mut spikard_http::SseEvent,
    retry_ms: u64,
) -> *mut spikard_http::SseEvent {
    clear_last_error();
    if this.is_null() {
        set_last_error(1, "Null pointer passed for self");
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees this is a valid pointer originally from Box::into_raw.
    let obj = unsafe { *Box::from_raw(this) };

    let retry_ms_rs = retry_ms;
    let result = obj.with_retry(retry_ms_rs);
    Box::into_raw(Box::new(result))
}

/// Free a `TestingSseEvent` handle.
/// # Safety
/// Pointer must have been returned by this library, or be null.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_testing_sse_event_free(ptr: *mut spikard_http::testing::SseEvent) {
    if !ptr.is_null() {
        // SAFETY: ptr was allocated by Box::into_raw; caller ensures no aliases.
        unsafe {
            drop(Box::from_raw(ptr));
        }
    }
}

/// Get the `data` field from a `TestingSseEvent`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_testing_sse_event_data(
    ptr: *const spikard_http::testing::SseEvent,
) -> *mut std::ffi::c_char {
    if ptr.is_null() {
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    match CString::new(obj.data.to_string()) {
        Ok(cs) => cs.into_raw(),
        Err(_) => std::ptr::null_mut(),
    }
}

/// Create a `JwtConfig` from a JSON string. Returns null on failure.
/// # Safety
/// JSON string must be valid UTF-8 and null-terminated.
/// Returned handle must be freed with `spikard_jwt_config_free`.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_jwt_config_from_json(json: *const c_char) -> *mut spikard_http::JwtConfig {
    clear_last_error();
    if json.is_null() {
        set_last_error(1, "Null pointer passed for JSON string");
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees json is a valid pointer; string is valid UTF-8 from caller.
    let c_str = match unsafe { CStr::from_ptr(json) }.to_str() {
        Ok(s) => s,
        Err(_) => {
            set_last_error(1, "Invalid UTF-8 in JSON string");
            return std::ptr::null_mut();
        }
    };
    match serde_json::from_str::<spikard_http::JwtConfig>(c_str) {
        Ok(val) => Box::into_raw(Box::new(val)),
        Err(e) => {
            set_last_error(2, &e.to_string());
            std::ptr::null_mut()
        }
    }
}

/// Serialize a `JwtConfig` to a JSON string. Returns null on failure.
/// # Safety
/// `ptr` must be a valid, non-null pointer returned by a `spikard` function.
/// The returned string must be freed with `spikard_free_string`.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_jwt_config_to_json(ptr: *const spikard_http::JwtConfig) -> *mut c_char {
    clear_last_error();
    if ptr.is_null() {
        set_last_error(1, "Null pointer passed to to_json");
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let val = unsafe { &*ptr };
    match serde_json::to_string(val) {
        Ok(s) => match CString::new(s) {
            Ok(cs) => cs.into_raw(),
            Err(e) => {
                set_last_error(2, &e.to_string());
                std::ptr::null_mut()
            }
        },
        Err(e) => {
            set_last_error(2, &e.to_string());
            std::ptr::null_mut()
        }
    }
}

/// Free a `JwtConfig` handle.
/// # Safety
/// Pointer must have been returned by this library, or be null.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_jwt_config_free(ptr: *mut spikard_http::JwtConfig) {
    if !ptr.is_null() {
        // SAFETY: ptr was allocated by Box::into_raw; caller ensures no aliases.
        unsafe {
            drop(Box::from_raw(ptr));
        }
    }
}

/// Get the `secret` field from a `JwtConfig`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_jwt_config_secret(ptr: *const spikard_http::JwtConfig) -> *mut std::ffi::c_char {
    if ptr.is_null() {
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    match CString::new(obj.secret.to_string()) {
        Ok(cs) => cs.into_raw(),
        Err(_) => std::ptr::null_mut(),
    }
}

/// Get the `algorithm` field from a `JwtConfig`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_jwt_config_algorithm(ptr: *const spikard_http::JwtConfig) -> *mut std::ffi::c_char {
    if ptr.is_null() {
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    match CString::new(obj.algorithm.to_string()) {
        Ok(cs) => cs.into_raw(),
        Err(_) => std::ptr::null_mut(),
    }
}

/// Get the `audience` field from a `JwtConfig`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_jwt_config_audience(ptr: *const spikard_http::JwtConfig) -> *mut std::ffi::c_char {
    if ptr.is_null() {
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    match &obj.audience {
        Some(val) => match serde_json::to_string(&val) {
            Ok(s) => match CString::new(s) {
                Ok(cs) => cs.into_raw(),
                Err(_) => std::ptr::null_mut(),
            },
            Err(_) => std::ptr::null_mut(),
        },
        None => std::ptr::null_mut(),
    }
}

/// Get the `issuer` field from a `JwtConfig`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_jwt_config_issuer(ptr: *const spikard_http::JwtConfig) -> *mut std::ffi::c_char {
    if ptr.is_null() {
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    match &obj.issuer {
        Some(val) => match CString::new(val.to_string()) {
            Ok(cs) => cs.into_raw(),
            Err(_) => std::ptr::null_mut(),
        },
        None => std::ptr::null_mut(),
    }
}

/// Get the `leeway` field from a `JwtConfig`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_jwt_config_leeway(ptr: *const spikard_http::JwtConfig) -> u64 {
    if ptr.is_null() {
        return 0;
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    obj.leeway
}

/// Create a `ApiKeyConfig` from a JSON string. Returns null on failure.
/// # Safety
/// JSON string must be valid UTF-8 and null-terminated.
/// Returned handle must be freed with `spikard_api_key_config_free`.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_api_key_config_from_json(json: *const c_char) -> *mut spikard_http::ApiKeyConfig {
    clear_last_error();
    if json.is_null() {
        set_last_error(1, "Null pointer passed for JSON string");
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees json is a valid pointer; string is valid UTF-8 from caller.
    let c_str = match unsafe { CStr::from_ptr(json) }.to_str() {
        Ok(s) => s,
        Err(_) => {
            set_last_error(1, "Invalid UTF-8 in JSON string");
            return std::ptr::null_mut();
        }
    };
    match serde_json::from_str::<spikard_http::ApiKeyConfig>(c_str) {
        Ok(val) => Box::into_raw(Box::new(val)),
        Err(e) => {
            set_last_error(2, &e.to_string());
            std::ptr::null_mut()
        }
    }
}

/// Serialize a `ApiKeyConfig` to a JSON string. Returns null on failure.
/// # Safety
/// `ptr` must be a valid, non-null pointer returned by a `spikard` function.
/// The returned string must be freed with `spikard_free_string`.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_api_key_config_to_json(ptr: *const spikard_http::ApiKeyConfig) -> *mut c_char {
    clear_last_error();
    if ptr.is_null() {
        set_last_error(1, "Null pointer passed to to_json");
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let val = unsafe { &*ptr };
    match serde_json::to_string(val) {
        Ok(s) => match CString::new(s) {
            Ok(cs) => cs.into_raw(),
            Err(e) => {
                set_last_error(2, &e.to_string());
                std::ptr::null_mut()
            }
        },
        Err(e) => {
            set_last_error(2, &e.to_string());
            std::ptr::null_mut()
        }
    }
}

/// Free a `ApiKeyConfig` handle.
/// # Safety
/// Pointer must have been returned by this library, or be null.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_api_key_config_free(ptr: *mut spikard_http::ApiKeyConfig) {
    if !ptr.is_null() {
        // SAFETY: ptr was allocated by Box::into_raw; caller ensures no aliases.
        unsafe {
            drop(Box::from_raw(ptr));
        }
    }
}

/// Get the `keys` field from a `ApiKeyConfig`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_api_key_config_keys(ptr: *const spikard_http::ApiKeyConfig) -> *mut std::ffi::c_char {
    if ptr.is_null() {
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    match serde_json::to_string(&obj.keys) {
        Ok(s) => match CString::new(s) {
            Ok(cs) => cs.into_raw(),
            Err(_) => std::ptr::null_mut(),
        },
        Err(_) => std::ptr::null_mut(),
    }
}

/// Get the `header_name` field from a `ApiKeyConfig`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_api_key_config_header_name(
    ptr: *const spikard_http::ApiKeyConfig,
) -> *mut std::ffi::c_char {
    if ptr.is_null() {
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    match CString::new(obj.header_name.to_string()) {
        Ok(cs) => cs.into_raw(),
        Err(_) => std::ptr::null_mut(),
    }
}

/// Create a `StaticFilesConfig` from a JSON string. Returns null on failure.
/// # Safety
/// JSON string must be valid UTF-8 and null-terminated.
/// Returned handle must be freed with `spikard_static_files_config_free`.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_static_files_config_from_json(
    json: *const c_char,
) -> *mut spikard_http::StaticFilesConfig {
    clear_last_error();
    if json.is_null() {
        set_last_error(1, "Null pointer passed for JSON string");
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees json is a valid pointer; string is valid UTF-8 from caller.
    let c_str = match unsafe { CStr::from_ptr(json) }.to_str() {
        Ok(s) => s,
        Err(_) => {
            set_last_error(1, "Invalid UTF-8 in JSON string");
            return std::ptr::null_mut();
        }
    };
    match serde_json::from_str::<spikard_http::StaticFilesConfig>(c_str) {
        Ok(val) => Box::into_raw(Box::new(val)),
        Err(e) => {
            set_last_error(2, &e.to_string());
            std::ptr::null_mut()
        }
    }
}

/// Serialize a `StaticFilesConfig` to a JSON string. Returns null on failure.
/// # Safety
/// `ptr` must be a valid, non-null pointer returned by a `spikard` function.
/// The returned string must be freed with `spikard_free_string`.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_static_files_config_to_json(
    ptr: *const spikard_http::StaticFilesConfig,
) -> *mut c_char {
    clear_last_error();
    if ptr.is_null() {
        set_last_error(1, "Null pointer passed to to_json");
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let val = unsafe { &*ptr };
    match serde_json::to_string(val) {
        Ok(s) => match CString::new(s) {
            Ok(cs) => cs.into_raw(),
            Err(e) => {
                set_last_error(2, &e.to_string());
                std::ptr::null_mut()
            }
        },
        Err(e) => {
            set_last_error(2, &e.to_string());
            std::ptr::null_mut()
        }
    }
}

/// Free a `StaticFilesConfig` handle.
/// # Safety
/// Pointer must have been returned by this library, or be null.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_static_files_config_free(ptr: *mut spikard_http::StaticFilesConfig) {
    if !ptr.is_null() {
        // SAFETY: ptr was allocated by Box::into_raw; caller ensures no aliases.
        unsafe {
            drop(Box::from_raw(ptr));
        }
    }
}

/// Get the `directory` field from a `StaticFilesConfig`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_static_files_config_directory(
    ptr: *const spikard_http::StaticFilesConfig,
) -> *mut std::ffi::c_char {
    if ptr.is_null() {
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    match CString::new(obj.directory.to_string()) {
        Ok(cs) => cs.into_raw(),
        Err(_) => std::ptr::null_mut(),
    }
}

/// Get the `route_prefix` field from a `StaticFilesConfig`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_static_files_config_route_prefix(
    ptr: *const spikard_http::StaticFilesConfig,
) -> *mut std::ffi::c_char {
    if ptr.is_null() {
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    match CString::new(obj.route_prefix.to_string()) {
        Ok(cs) => cs.into_raw(),
        Err(_) => std::ptr::null_mut(),
    }
}

/// Get the `index_file` field from a `StaticFilesConfig`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_static_files_config_index_file(ptr: *const spikard_http::StaticFilesConfig) -> i32 {
    if ptr.is_null() {
        return 0;
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    obj.index_file as i32
}

/// Get the `cache_control` field from a `StaticFilesConfig`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_static_files_config_cache_control(
    ptr: *const spikard_http::StaticFilesConfig,
) -> *mut std::ffi::c_char {
    if ptr.is_null() {
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    match &obj.cache_control {
        Some(val) => match CString::new(val.to_string()) {
            Ok(cs) => cs.into_raw(),
            Err(_) => std::ptr::null_mut(),
        },
        None => std::ptr::null_mut(),
    }
}

/// Create a `ServerConfig` from a JSON string. Returns null on failure.
/// # Safety
/// JSON string must be valid UTF-8 and null-terminated.
/// Returned handle must be freed with `spikard_server_config_free`.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_server_config_from_json(json: *const c_char) -> *mut spikard_http::ServerConfig {
    clear_last_error();
    if json.is_null() {
        set_last_error(1, "Null pointer passed for JSON string");
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees json is a valid pointer; string is valid UTF-8 from caller.
    let c_str = match unsafe { CStr::from_ptr(json) }.to_str() {
        Ok(s) => s,
        Err(_) => {
            set_last_error(1, "Invalid UTF-8 in JSON string");
            return std::ptr::null_mut();
        }
    };
    match serde_json::from_str::<spikard_http::ServerConfig>(c_str) {
        Ok(val) => Box::into_raw(Box::new(val)),
        Err(e) => {
            set_last_error(2, &e.to_string());
            std::ptr::null_mut()
        }
    }
}

/// Serialize a `ServerConfig` to a JSON string. Returns null on failure.
/// # Safety
/// `ptr` must be a valid, non-null pointer returned by a `spikard` function.
/// The returned string must be freed with `spikard_free_string`.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_server_config_to_json(ptr: *const spikard_http::ServerConfig) -> *mut c_char {
    clear_last_error();
    if ptr.is_null() {
        set_last_error(1, "Null pointer passed to to_json");
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let val = unsafe { &*ptr };
    match serde_json::to_string(val) {
        Ok(s) => match CString::new(s) {
            Ok(cs) => cs.into_raw(),
            Err(e) => {
                set_last_error(2, &e.to_string());
                std::ptr::null_mut()
            }
        },
        Err(e) => {
            set_last_error(2, &e.to_string());
            std::ptr::null_mut()
        }
    }
}

/// Free a `ServerConfig` handle.
/// # Safety
/// Pointer must have been returned by this library, or be null.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_server_config_free(ptr: *mut spikard_http::ServerConfig) {
    if !ptr.is_null() {
        // SAFETY: ptr was allocated by Box::into_raw; caller ensures no aliases.
        unsafe {
            drop(Box::from_raw(ptr));
        }
    }
}

/// Get the `host` field from a `ServerConfig`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_server_config_host(ptr: *const spikard_http::ServerConfig) -> *mut std::ffi::c_char {
    if ptr.is_null() {
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    match CString::new(obj.host.to_string()) {
        Ok(cs) => cs.into_raw(),
        Err(_) => std::ptr::null_mut(),
    }
}

/// Get the `port` field from a `ServerConfig`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_server_config_port(ptr: *const spikard_http::ServerConfig) -> u16 {
    if ptr.is_null() {
        return 0;
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    obj.port
}

/// Get the `workers` field from a `ServerConfig`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_server_config_workers(ptr: *const spikard_http::ServerConfig) -> usize {
    if ptr.is_null() {
        return 0;
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    obj.workers
}

/// Get the `enable_request_id` field from a `ServerConfig`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_server_config_enable_request_id(ptr: *const spikard_http::ServerConfig) -> i32 {
    if ptr.is_null() {
        return 0;
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    obj.enable_request_id as i32
}

/// Get the `max_body_size` field from a `ServerConfig`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_server_config_max_body_size(ptr: *const spikard_http::ServerConfig) -> usize {
    if ptr.is_null() {
        return 0;
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    match &obj.max_body_size {
        Some(val) => *val,
        None => 0,
    }
}

/// Get the `request_timeout` field from a `ServerConfig`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_server_config_request_timeout(ptr: *const spikard_http::ServerConfig) -> u64 {
    if ptr.is_null() {
        return 0;
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    match &obj.request_timeout {
        Some(val) => *val,
        None => 0,
    }
}

/// Get the `compression` field from a `ServerConfig`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_server_config_compression(
    ptr: *const spikard_http::ServerConfig,
) -> *mut spikard_core::CompressionConfig {
    if ptr.is_null() {
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    match &obj.compression {
        Some(val) => Box::into_raw(Box::new(val.clone())),
        None => std::ptr::null_mut(),
    }
}

/// Get the `rate_limit` field from a `ServerConfig`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_server_config_rate_limit(
    ptr: *const spikard_http::ServerConfig,
) -> *mut spikard_core::RateLimitConfig {
    if ptr.is_null() {
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    match &obj.rate_limit {
        Some(val) => Box::into_raw(Box::new(val.clone())),
        None => std::ptr::null_mut(),
    }
}

/// Get the `jwt_auth` field from a `ServerConfig`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_server_config_jwt_auth(
    ptr: *const spikard_http::ServerConfig,
) -> *mut spikard_http::JwtConfig {
    if ptr.is_null() {
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    match &obj.jwt_auth {
        Some(val) => Box::into_raw(Box::new(val.clone())),
        None => std::ptr::null_mut(),
    }
}

/// Get the `api_key_auth` field from a `ServerConfig`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_server_config_api_key_auth(
    ptr: *const spikard_http::ServerConfig,
) -> *mut spikard_http::ApiKeyConfig {
    if ptr.is_null() {
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    match &obj.api_key_auth {
        Some(val) => Box::into_raw(Box::new(val.clone())),
        None => std::ptr::null_mut(),
    }
}

/// Get the `static_files` field from a `ServerConfig`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_server_config_static_files(
    ptr: *const spikard_http::ServerConfig,
) -> *mut std::ffi::c_char {
    if ptr.is_null() {
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    match serde_json::to_string(&obj.static_files) {
        Ok(s) => match CString::new(s) {
            Ok(cs) => cs.into_raw(),
            Err(_) => std::ptr::null_mut(),
        },
        Err(_) => std::ptr::null_mut(),
    }
}

/// Get the `graceful_shutdown` field from a `ServerConfig`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_server_config_graceful_shutdown(ptr: *const spikard_http::ServerConfig) -> i32 {
    if ptr.is_null() {
        return 0;
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    obj.graceful_shutdown as i32
}

/// Get the `shutdown_timeout` field from a `ServerConfig`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_server_config_shutdown_timeout(ptr: *const spikard_http::ServerConfig) -> u64 {
    if ptr.is_null() {
        return 0;
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    obj.shutdown_timeout
}

/// Get the `asyncapi` field from a `ServerConfig`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_server_config_asyncapi(
    ptr: *const spikard_http::ServerConfig,
) -> *mut spikard_http::AsyncApiConfig {
    if ptr.is_null() {
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    match &obj.asyncapi {
        Some(val) => Box::into_raw(Box::new(val.clone())),
        None => std::ptr::null_mut(),
    }
}

/// Get the `openapi` field from a `ServerConfig`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_server_config_openapi(
    ptr: *const spikard_http::ServerConfig,
) -> *mut spikard_http::OpenApiConfig {
    if ptr.is_null() {
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    match &obj.openapi {
        Some(val) => Box::into_raw(Box::new(val.clone())),
        None => std::ptr::null_mut(),
    }
}

/// Get the `jsonrpc` field from a `ServerConfig`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_server_config_jsonrpc(
    ptr: *const spikard_http::ServerConfig,
) -> *mut spikard_http::JsonRpcConfig {
    if ptr.is_null() {
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    match &obj.jsonrpc {
        Some(val) => Box::into_raw(Box::new(val.clone())),
        None => std::ptr::null_mut(),
    }
}

/// Get the `grpc` field from a `ServerConfig`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_server_config_grpc(
    ptr: *const spikard_http::ServerConfig,
) -> *mut spikard_http::GrpcConfig {
    if ptr.is_null() {
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    match &obj.grpc {
        Some(val) => Box::into_raw(Box::new(val.clone())),
        None => std::ptr::null_mut(),
    }
}

/// Get the `background_tasks` field from a `ServerConfig`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_server_config_background_tasks(
    ptr: *const spikard_http::ServerConfig,
) -> *mut spikard_http::BackgroundTaskConfig {
    if ptr.is_null() {
        return std::ptr::null_mut();
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    Box::into_raw(Box::new(obj.background_tasks.clone()))
}

/// Get the `enable_http_trace` field from a `ServerConfig`.
/// # Safety
/// Pointer must be a valid handle returned by this library.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_server_config_enable_http_trace(ptr: *const spikard_http::ServerConfig) -> i32 {
    if ptr.is_null() {
        return 0;
    }
    // SAFETY: null check above guarantees ptr is a valid pointer.
    let obj = unsafe { &*ptr };
    obj.enable_http_trace as i32
}

/// \note SAFETY: Caller must ensure all pointer arguments are valid or null. Returned pointers must be
/// freed with the appropriate free function.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_server_config_default() -> *mut spikard_http::ServerConfig {
    clear_last_error();
    let result = spikard_http::ServerConfig::default();
    Box::into_raw(Box::new(result))
}

/// Convert an integer to a `SnapshotError` variant. Returns -1 on invalid input.
/// # Safety
/// Caller must ensure all pointer arguments are valid or null.
/// Returned pointers must be freed with the appropriate free function.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_snapshot_error_from_i32(value: i32) -> i32 {
    match value {
        0 => 0, // InvalidHeader
        1 => 1, // Decompression
        _ => {
            set_last_error(1, "Invalid SnapshotError variant");
            -1
        }
    }
}

/// Convert a `SnapshotError` variant name (C string) to its integer value. Returns -1 on invalid input.
/// # Safety
/// Caller must ensure `ptr` is a valid pointer to a `c_char` or null.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_snapshot_error_from_str(name: *const c_char) -> i32 {
    if name.is_null() {
        set_last_error(1, "Null pointer passed for enum name");
        return -1;
    }
    // SAFETY: null check above guarantees name is a valid pointer; string is valid UTF-8 from caller.
    let s = match unsafe { CStr::from_ptr(name) }.to_str() {
        Ok(s) => s,
        Err(_) => {
            set_last_error(1, "Invalid UTF-8 in enum name");
            return -1;
        }
    };
    match s {
        "InvalidHeader" => 0,
        "Decompression" => 1,
        _ => {
            set_last_error(1, "Unknown SnapshotError variant");
            -1
        }
    }
}

/// Convert an integer to a `WebSocketMessage` variant. Returns -1 on invalid input.
/// # Safety
/// Caller must ensure all pointer arguments are valid or null.
/// Returned pointers must be freed with the appropriate free function.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_web_socket_message_from_i32(value: i32) -> i32 {
    match value {
        0 => 0, // Text
        1 => 1, // Binary
        2 => 2, // Close
        3 => 3, // Ping
        4 => 4, // Pong
        _ => {
            set_last_error(1, "Invalid WebSocketMessage variant");
            -1
        }
    }
}

/// Convert a `WebSocketMessage` variant name (C string) to its integer value. Returns -1 on invalid input.
/// # Safety
/// Caller must ensure `ptr` is a valid pointer to a `c_char` or null.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_web_socket_message_from_str(name: *const c_char) -> i32 {
    if name.is_null() {
        set_last_error(1, "Null pointer passed for enum name");
        return -1;
    }
    // SAFETY: null check above guarantees name is a valid pointer; string is valid UTF-8 from caller.
    let s = match unsafe { CStr::from_ptr(name) }.to_str() {
        Ok(s) => s,
        Err(_) => {
            set_last_error(1, "Invalid UTF-8 in enum name");
            return -1;
        }
    };
    match s {
        "Text" => 0,
        "Binary" => 1,
        "Close" => 2,
        "Ping" => 3,
        "Pong" => 4,
        _ => {
            set_last_error(1, "Unknown WebSocketMessage variant");
            -1
        }
    }
}

/// Convert an integer to a `Method` variant. Returns -1 on invalid input.
/// # Safety
/// Caller must ensure all pointer arguments are valid or null.
/// Returned pointers must be freed with the appropriate free function.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_method_from_i32(value: i32) -> i32 {
    match value {
        0 => 0, // Get
        1 => 1, // Post
        2 => 2, // Put
        3 => 3, // Patch
        4 => 4, // Delete
        5 => 5, // Head
        6 => 6, // Options
        7 => 7, // Trace
        _ => {
            set_last_error(1, "Invalid Method variant");
            -1
        }
    }
}

/// Convert a `Method` variant name (C string) to its integer value. Returns -1 on invalid input.
/// # Safety
/// Caller must ensure `ptr` is a valid pointer to a `c_char` or null.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_method_from_str(name: *const c_char) -> i32 {
    if name.is_null() {
        set_last_error(1, "Null pointer passed for enum name");
        return -1;
    }
    // SAFETY: null check above guarantees name is a valid pointer; string is valid UTF-8 from caller.
    let s = match unsafe { CStr::from_ptr(name) }.to_str() {
        Ok(s) => s,
        Err(_) => {
            set_last_error(1, "Invalid UTF-8 in enum name");
            return -1;
        }
    };
    match s {
        "Get" => 0,
        "Post" => 1,
        "Put" => 2,
        "Patch" => 3,
        "Delete" => 4,
        "Head" => 5,
        "Options" => 6,
        "Trace" => 7,
        _ => {
            set_last_error(1, "Unknown Method variant");
            -1
        }
    }
}

/// Convert an integer to a `SecuritySchemeInfo` variant. Returns -1 on invalid input.
/// # Safety
/// Caller must ensure all pointer arguments are valid or null.
/// Returned pointers must be freed with the appropriate free function.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_security_scheme_info_from_i32(value: i32) -> i32 {
    match value {
        0 => 0, // Http
        1 => 1, // ApiKey
        _ => {
            set_last_error(1, "Invalid SecuritySchemeInfo variant");
            -1
        }
    }
}

/// Convert a `SecuritySchemeInfo` variant name (C string) to its integer value. Returns -1 on invalid input.
/// # Safety
/// Caller must ensure `ptr` is a valid pointer to a `c_char` or null.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_security_scheme_info_from_str(name: *const c_char) -> i32 {
    if name.is_null() {
        set_last_error(1, "Null pointer passed for enum name");
        return -1;
    }
    // SAFETY: null check above guarantees name is a valid pointer; string is valid UTF-8 from caller.
    let s = match unsafe { CStr::from_ptr(name) }.to_str() {
        Ok(s) => s,
        Err(_) => {
            set_last_error(1, "Invalid UTF-8 in enum name");
            return -1;
        }
    };
    match s {
        "Http" => 0,
        "ApiKey" => 1,
        _ => {
            set_last_error(1, "Unknown SecuritySchemeInfo variant");
            -1
        }
    }
}

fn get_ffi_runtime() -> &'static tokio::runtime::Runtime {
    use std::sync::OnceLock;
    static RUNTIME: OnceLock<tokio::runtime::Runtime> = OnceLock::new();
    RUNTIME.get_or_init(|| tokio::runtime::Runtime::new().expect("Failed to create tokio runtime"))
}

/// Create a simple schema configuration with only Query type.
///
/// This is a convenience function for schemas that only have queries.
/// \return A `QueryOnlyConfig` with default settings
/// \note SAFETY: Caller must ensure all pointer arguments are valid or null. Returned pointers must be
/// freed with the appropriate free function.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_schema_query_only() -> *mut spikard_graphql::QueryOnlyConfig {
    clear_last_error();
    let result = spikard_graphql::schema_query_only();
    Box::into_raw(Box::new(result))
}

/// Create a schema configuration with Query and Mutation types.
///
/// This is a convenience function for schemas with queries and mutations but no subscriptions.
/// \return A `QueryMutationConfig` with default settings
/// \note SAFETY: Caller must ensure all pointer arguments are valid or null. Returned pointers must be
/// freed with the appropriate free function.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_schema_query_mutation() -> *mut spikard_graphql::QueryMutationConfig {
    clear_last_error();
    let result = spikard_graphql::schema_query_mutation();
    Box::into_raw(Box::new(result))
}

/// Create a schema configuration with all three root types.
///
/// This is a convenience function for fully-featured schemas.
/// \return A `FullSchemaConfig` with default settings
/// \note SAFETY: Caller must ensure all pointer arguments are valid or null. Returned pointers must be
/// freed with the appropriate free function.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn spikard_schema_full() -> *mut spikard_graphql::FullSchemaConfig {
    clear_last_error();
    let result = spikard_graphql::schema_full();
    Box::into_raw(Box::new(result))
}

/// Return the HTTP status code for the error pointed to by `err`.
/// Returns `0` if `err` is null.
#[no_mangle]
pub unsafe extern "C" fn spikard_graph_q_l_error_status_code(err: *const spikard_graphql::error::GraphQLError) -> u16 {
    // SAFETY: caller guarantees `err` points to a live `spikard_graphql::error::GraphQLError` value
    // allocated by this library, or is null.
    if err.is_null() {
        return 0;
    }
    (*err).status_code()
}

/// Return whether the error pointed to by `err` is transient.
/// Returns `false` if `err` is null.
#[no_mangle]
pub unsafe extern "C" fn spikard_graph_q_l_error_is_transient(
    err: *const spikard_graphql::error::GraphQLError,
) -> bool {
    // SAFETY: caller guarantees `err` points to a live `spikard_graphql::error::GraphQLError` value
    // allocated by this library, or is null.
    if err.is_null() {
        return false;
    }
    (*err).is_transient()
}

/// Return the machine-readable error category string for the error pointed
/// to by `err` as a heap-allocated, NUL-terminated C string.
/// The caller must free the returned pointer with `spikard_graph_q_l_error_error_type_free`.
/// Returns a null pointer if `err` is null.
#[no_mangle]
pub unsafe extern "C" fn spikard_graph_q_l_error_error_type(
    err: *const spikard_graphql::error::GraphQLError,
) -> *mut std::ffi::c_char {
    // SAFETY: caller guarantees `err` points to a live `spikard_graphql::error::GraphQLError` value
    // allocated by this library, or is null.
    if err.is_null() {
        return std::ptr::null_mut();
    }
    let s = (*err).error_type();
    // SAFETY: `error_type()` returns a `'static str` containing no NUL bytes.
    std::ffi::CString::new(s)
        .map(|c| c.into_raw())
        .unwrap_or(std::ptr::null_mut())
}

/// Free a string previously returned by `spikard_graph_q_l_error_error_type`.
/// Passing a null pointer is a no-op.
#[no_mangle]
pub unsafe extern "C" fn spikard_graph_q_l_error_error_type_free(ptr: *mut std::ffi::c_char) {
    // SAFETY: `ptr` was allocated by `CString::into_raw` inside
    // `spikard_graph_q_l_error_error_type` and is now being reclaimed by the matching
    // `CString::from_raw`.  Passing null is explicitly allowed.
    if !ptr.is_null() {
        drop(std::ffi::CString::from_raw(ptr));
    }
}