---
source: tests/backends_swift_snapshot_test.rs
expression: "&file.content"
---
// Generated by alef. Do not edit by hand.

#![allow(unused_variables, unreachable_code, unreachable_patterns, missing_docs)]
#![allow(
    clippy::collapsible_if,
    clippy::collapsible_match,
    clippy::needless_borrows_for_generic_args,
    clippy::field_reassign_with_default,
    clippy::too_many_arguments,
    clippy::clone_on_copy,
    clippy::unnecessary_cast,
    clippy::manual_flatten,
    clippy::match_single_binding,
    clippy::redundant_closure,
    clippy::useless_conversion,
    clippy::inherent_to_string,
    clippy::new_without_default,
)]


/// Process-wide tokio runtime shared across every swift-bridge async wrapper.
///
/// alef-emitted; see shims.rs for the rationale (orphaned reqwest connection
/// pools when each call creates and drops its own current-thread runtime).
fn __alef_tokio_runtime() -> &'static ::tokio::runtime::Runtime {
    use std::sync::OnceLock;
    static RT: OnceLock<::tokio::runtime::Runtime> = OnceLock::new();
    RT.get_or_init(|| {
        ::tokio::runtime::Builder::new_multi_thread()
            .enable_all()
            .build()
            .expect("build process-wide alef tokio runtime")
    })
}

#[swift_bridge::bridge]
mod ffi {
    extern "Rust" {
        type Chunk;
        #[swift_bridge(init)]
        fn new(text: String) -> Chunk;
        fn text(&self) -> String;
    }

    extern "Rust" {
        type StreamEvent;
        fn to_string(&self) -> String;
    }

    extern "Rust" {
        #[swift_bridge(swift_name = "chunkFromJson")]
        fn chunk_from_json(json: String) -> Result<Chunk, String>;
    }
    extern "Rust" {
        #[swift_bridge(swift_name = "streamEventFromJson")]
        fn stream_event_from_json(json: String) -> Result<StreamEvent, String>;
    }
    extern "Rust" {
        // Phantom Vec<T> functions: swift-bridge-build must emit the full Vec support
        // C ABI symbols (__swift_bridge__$Vec_T$new, drop, push, pop, get, get_mut, as_ptr, len)
        // which the auto-generated Swift Vec<T> conformances reference.
        //
        // swift-bridge 0.1.59 only emits these when Vec<T> appears as a return type
        // in an extern block. Without these phantom functions, Swift linker fails when
        // trying to construct or manipulate Vec<T> of opaque types.
        //
        // These declarations are paired with phantom_impl functions below the bridge module.
        fn __alef_phantom_vec_chunk() -> Vec<Chunk>;
        fn __alef_phantom_vec_stream_event() -> Vec<StreamEvent>;
    }

}

#[doc(hidden)]
pub fn __alef_phantom_vec_chunk() -> Vec<Chunk> { Vec::new() }
#[doc(hidden)]
pub fn __alef_phantom_vec_stream_event() -> Vec<StreamEvent> { Vec::new() }

pub struct Chunk(pub demo::Chunk);
impl Chunk {
    pub fn new(text: String) -> Chunk {
        let mut __target: demo::Chunk = ::std::default::Default::default();
        {
            // Try JSON parse first (handles enum/object values); on parse failure
            // treat the raw input as a JSON string scalar so plain `String` /
            // string-like enum fields don't end up empty for inputs that aren't
            // valid JSON tokens (e.g. `tts-1`).
            let __v = ::serde_json::from_str::<::serde_json::Value>(&text)
                .unwrap_or(::serde_json::Value::String(text.clone()));
            if let Ok(t) = ::serde_json::from_value(__v) { __target.text = t; }
        }
        Chunk(__target)
    }
    pub fn text(&self) -> String {
        self.0.text.clone()
    }
}

pub enum StreamEvent {
    Data,
    Error,
    Done,
}

impl From<demo::StreamEvent> for StreamEvent {
    fn from(val: demo::StreamEvent) -> Self {
        match val {
            demo::StreamEvent::Data { .. } => Self::Data,
            demo::StreamEvent::Error { .. } => Self::Error,
            demo::StreamEvent::Done { .. } => Self::Done,
        }
    }
}

impl StreamEvent {
    pub fn to_string(&self) -> String {
        match self {
            Self::Data => "Data".to_string(),
            Self::Error => "Error".to_string(),
            Self::Done => "Done".to_string(),
        }
    }
}

pub fn chunk_from_json(json: String) -> Result<Chunk, String> {
    serde_json::from_str::<demo::Chunk>(&json)
        .map(Chunk)
        .map_err(|e| e.to_string())
}
pub fn stream_event_from_json(json: String) -> Result<StreamEvent, String> {
    serde_json::from_str::<demo::StreamEvent>(&json)
        .map(StreamEvent::from)
        .map_err(|e| e.to_string())
}
