medea-jason 0.12.0

// This file is automatically generated, so please do not edit it.
// @generated by `flutter_rust_bridge`@ 2.11.1.

#![allow(
    non_camel_case_types,
    unused,
    non_snake_case,
    clippy::needless_return,
    clippy::redundant_closure_call,
    clippy::redundant_closure,
    clippy::useless_conversion,
    clippy::unit_arg,
    clippy::unused_unit,
    clippy::double_parens,
    clippy::let_and_return,
    clippy::too_many_arguments,
    clippy::match_single_binding,
    clippy::clone_on_copy,
    clippy::let_unit_value,
    clippy::deref_addrof,
    clippy::explicit_auto_deref,
    clippy::borrow_deref_ref,
    clippy::needless_borrow
)]

// Section: imports

use crate::api::dart::api::connection_handle::*;
use crate::api::dart::api::jason::*;
use crate::api::dart::api::local_media_track::*;
use crate::api::dart::api::media_manager::*;
use crate::api::dart::api::reconnect_handle::*;
use crate::api::dart::api::remote_media_track::*;
use crate::api::dart::api::room::*;
use crate::api::dart::api::ForeignClass;
use flutter_rust_bridge::for_generated::byteorder::{
    NativeEndian, ReadBytesExt, WriteBytesExt,
};
use flutter_rust_bridge::for_generated::{
    transform_result_dco, Lifetimeable, Lockable,
};
use flutter_rust_bridge::{Handler, IntoIntoDart};

// Section: boilerplate

flutter_rust_bridge::frb_generated_boilerplate!(
    default_stream_sink_codec = SseCodec,
    default_rust_opaque = RustOpaqueMoi,
    default_rust_auto_opaque = RustAutoOpaqueMoi,
);
pub(crate) const FLUTTER_RUST_BRIDGE_CODEGEN_VERSION: &str = "2.11.1";
pub(crate) const FLUTTER_RUST_BRIDGE_CODEGEN_CONTENT_HASH: i32 = -320558178;

// Section: executor

pub use crate::api::dart::api::FLUTTER_RUST_BRIDGE_HANDLER;

// Section: wire_funcs

fn wire__crate__api__dart__api__connection_handle__ConnectionHandle_disable_remote_audio_impl(
    ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
    rust_vec_len_: i32,
    data_len_: i32,
) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec,_>(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "ConnectionHandle_disable_remote_audio", port: None, mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync }, move || { 
            let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) };
            let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message);
            let api_that = <RustOpaqueMoi<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<ConnectionHandle>>>::sse_decode(&mut deserializer);deserializer.end();
                transform_result_sse::<_, ()>((move || {
                    let mut api_that_guard = None;
let decode_indices_ = flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(&api_that, 0, false)]);
        for i in decode_indices_ {
            match i {
                0 => api_that_guard = Some(api_that.lockable_decode_sync_ref()),
                _ => unreachable!(),
            }
        }
        let api_that_guard = api_that_guard.unwrap();
 let output_ok = Result::<_,()>::Ok(crate::api::dart::api::connection_handle::ConnectionHandle::disable_remote_audio(&*api_that_guard))?;   Ok(output_ok)
                })()) })
}
fn wire__crate__api__dart__api__connection_handle__ConnectionHandle_disable_remote_video_impl(
    ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
    rust_vec_len_: i32,
    data_len_: i32,
) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec,_>(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "ConnectionHandle_disable_remote_video", port: None, mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync }, move || { 
            let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) };
            let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message);
            let api_that = <RustOpaqueMoi<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<ConnectionHandle>>>::sse_decode(&mut deserializer);
let api_source_kind = <Option<crate::media::track::MediaSourceKind>>::sse_decode(&mut deserializer);deserializer.end();
                transform_result_sse::<_, ()>((move || {
                    let mut api_that_guard = None;
let decode_indices_ = flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(&api_that, 0, false)]);
        for i in decode_indices_ {
            match i {
                0 => api_that_guard = Some(api_that.lockable_decode_sync_ref()),
                _ => unreachable!(),
            }
        }
        let api_that_guard = api_that_guard.unwrap();
 let output_ok = Result::<_,()>::Ok(crate::api::dart::api::connection_handle::ConnectionHandle::disable_remote_video(&*api_that_guard, api_source_kind))?;   Ok(output_ok)
                })()) })
}
fn wire__crate__api__dart__api__connection_handle__ConnectionHandle_enable_remote_audio_impl(
    ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
    rust_vec_len_: i32,
    data_len_: i32,
) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec,_>(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "ConnectionHandle_enable_remote_audio", port: None, mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync }, move || { 
            let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) };
            let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message);
            let api_that = <RustOpaqueMoi<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<ConnectionHandle>>>::sse_decode(&mut deserializer);deserializer.end();
                transform_result_sse::<_, ()>((move || {
                    let mut api_that_guard = None;
let decode_indices_ = flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(&api_that, 0, false)]);
        for i in decode_indices_ {
            match i {
                0 => api_that_guard = Some(api_that.lockable_decode_sync_ref()),
                _ => unreachable!(),
            }
        }
        let api_that_guard = api_that_guard.unwrap();
 let output_ok = Result::<_,()>::Ok(crate::api::dart::api::connection_handle::ConnectionHandle::enable_remote_audio(&*api_that_guard))?;   Ok(output_ok)
                })()) })
}
fn wire__crate__api__dart__api__connection_handle__ConnectionHandle_enable_remote_video_impl(
    ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
    rust_vec_len_: i32,
    data_len_: i32,
) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec,_>(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "ConnectionHandle_enable_remote_video", port: None, mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync }, move || { 
            let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) };
            let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message);
            let api_that = <RustOpaqueMoi<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<ConnectionHandle>>>::sse_decode(&mut deserializer);
let api_source_kind = <Option<crate::media::track::MediaSourceKind>>::sse_decode(&mut deserializer);deserializer.end();
                transform_result_sse::<_, ()>((move || {
                    let mut api_that_guard = None;
let decode_indices_ = flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(&api_that, 0, false)]);
        for i in decode_indices_ {
            match i {
                0 => api_that_guard = Some(api_that.lockable_decode_sync_ref()),
                _ => unreachable!(),
            }
        }
        let api_that_guard = api_that_guard.unwrap();
 let output_ok = Result::<_,()>::Ok(crate::api::dart::api::connection_handle::ConnectionHandle::enable_remote_video(&*api_that_guard, api_source_kind))?;   Ok(output_ok)
                })()) })
}
fn wire__crate__api__dart__api__connection_handle__ConnectionHandle_from_ptr_impl(
    ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
    rust_vec_len_: i32,
    data_len_: i32,
) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec,_>(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "ConnectionHandle_from_ptr", port: None, mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync }, move || { 
            let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) };
            let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message);
            let api_ptr = <usize>::sse_decode(&mut deserializer);deserializer.end();
                transform_result_sse::<_, ()>((move || {
                     let output_ok = Result::<_,()>::Ok(crate::api::dart::api::connection_handle::ConnectionHandle::from_ptr(api_ptr))?;   Ok(output_ok)
                })()) })
}
fn wire__crate__api__dart__api__connection_handle__ConnectionHandle_get_remote_member_id_impl(
    ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
    rust_vec_len_: i32,
    data_len_: i32,
) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec,_>(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "ConnectionHandle_get_remote_member_id", port: None, mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync }, move || { 
            let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) };
            let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message);
            let api_that = <RustOpaqueMoi<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<ConnectionHandle>>>::sse_decode(&mut deserializer);deserializer.end();
                transform_result_sse::<_, flutter_rust_bridge::DartOpaque>((move || {
                    let mut api_that_guard = None;
let decode_indices_ = flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(&api_that, 0, false)]);
        for i in decode_indices_ {
            match i {
                0 => api_that_guard = Some(api_that.lockable_decode_sync_ref()),
                _ => unreachable!(),
            }
        }
        let api_that_guard = api_that_guard.unwrap();
 let output_ok = crate::api::dart::api::connection_handle::ConnectionHandle::get_remote_member_id(&*api_that_guard)?;   Ok(output_ok)
                })()) })
}
fn wire__crate__api__dart__api__connection_handle__ConnectionHandle_get_state_impl(
    ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
    rust_vec_len_: i32,
    data_len_: i32,
) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec,_>(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "ConnectionHandle_get_state", port: None, mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync }, move || { 
            let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) };
            let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message);
            let api_that = <RustOpaqueMoi<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<ConnectionHandle>>>::sse_decode(&mut deserializer);deserializer.end();
                transform_result_sse::<_, flutter_rust_bridge::DartOpaque>((move || {
                    let mut api_that_guard = None;
let decode_indices_ = flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(&api_that, 0, false)]);
        for i in decode_indices_ {
            match i {
                0 => api_that_guard = Some(api_that.lockable_decode_sync_ref()),
                _ => unreachable!(),
            }
        }
        let api_that_guard = api_that_guard.unwrap();
 let output_ok = crate::api::dart::api::connection_handle::ConnectionHandle::get_state(&*api_that_guard)?;   Ok(output_ok)
                })()) })
}
fn wire__crate__api__dart__api__connection_handle__ConnectionHandle_on_close_impl(
    ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
    rust_vec_len_: i32,
    data_len_: i32,
) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec,_>(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "ConnectionHandle_on_close", port: None, mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync }, move || { 
            let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) };
            let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message);
            let api_that = <RustOpaqueMoi<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<ConnectionHandle>>>::sse_decode(&mut deserializer);
let api_f = <flutter_rust_bridge::DartOpaque>::sse_decode(&mut deserializer);deserializer.end();
                transform_result_sse::<_, flutter_rust_bridge::DartOpaque>((move || {
                    let mut api_that_guard = None;
let decode_indices_ = flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(&api_that, 0, false)]);
        for i in decode_indices_ {
            match i {
                0 => api_that_guard = Some(api_that.lockable_decode_sync_ref()),
                _ => unreachable!(),
            }
        }
        let api_that_guard = api_that_guard.unwrap();
 let output_ok = crate::api::dart::api::connection_handle::ConnectionHandle::on_close(&*api_that_guard, api_f)?;   Ok(output_ok)
                })()) })
}
fn wire__crate__api__dart__api__connection_handle__ConnectionHandle_on_quality_score_update_impl(
    ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
    rust_vec_len_: i32,
    data_len_: i32,
) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec,_>(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "ConnectionHandle_on_quality_score_update", port: None, mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync }, move || { 
            let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) };
            let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message);
            let api_that = <RustOpaqueMoi<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<ConnectionHandle>>>::sse_decode(&mut deserializer);
let api_f = <flutter_rust_bridge::DartOpaque>::sse_decode(&mut deserializer);deserializer.end();
                transform_result_sse::<_, flutter_rust_bridge::DartOpaque>((move || {
                    let mut api_that_guard = None;
let decode_indices_ = flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(&api_that, 0, false)]);
        for i in decode_indices_ {
            match i {
                0 => api_that_guard = Some(api_that.lockable_decode_sync_ref()),
                _ => unreachable!(),
            }
        }
        let api_that_guard = api_that_guard.unwrap();
 let output_ok = crate::api::dart::api::connection_handle::ConnectionHandle::on_quality_score_update(&*api_that_guard, api_f)?;   Ok(output_ok)
                })()) })
}
fn wire__crate__api__dart__api__connection_handle__ConnectionHandle_on_remote_track_added_impl(
    ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
    rust_vec_len_: i32,
    data_len_: i32,
) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec,_>(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "ConnectionHandle_on_remote_track_added", port: None, mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync }, move || { 
            let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) };
            let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message);
            let api_that = <RustOpaqueMoi<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<ConnectionHandle>>>::sse_decode(&mut deserializer);
let api_f = <flutter_rust_bridge::DartOpaque>::sse_decode(&mut deserializer);deserializer.end();
                transform_result_sse::<_, flutter_rust_bridge::DartOpaque>((move || {
                    let mut api_that_guard = None;
let decode_indices_ = flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(&api_that, 0, false)]);
        for i in decode_indices_ {
            match i {
                0 => api_that_guard = Some(api_that.lockable_decode_sync_ref()),
                _ => unreachable!(),
            }
        }
        let api_that_guard = api_that_guard.unwrap();
 let output_ok = crate::api::dart::api::connection_handle::ConnectionHandle::on_remote_track_added(&*api_that_guard, api_f)?;   Ok(output_ok)
                })()) })
}
fn wire__crate__api__dart__api__connection_handle__ConnectionHandle_on_state_change_impl(
    ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
    rust_vec_len_: i32,
    data_len_: i32,
) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec,_>(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "ConnectionHandle_on_state_change", port: None, mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync }, move || { 
            let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) };
            let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message);
            let api_that = <RustOpaqueMoi<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<ConnectionHandle>>>::sse_decode(&mut deserializer);
let api_f = <flutter_rust_bridge::DartOpaque>::sse_decode(&mut deserializer);deserializer.end();
                transform_result_sse::<_, flutter_rust_bridge::DartOpaque>((move || {
                    let mut api_that_guard = None;
let decode_indices_ = flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(&api_that, 0, false)]);
        for i in decode_indices_ {
            match i {
                0 => api_that_guard = Some(api_that.lockable_decode_sync_ref()),
                _ => unreachable!(),
            }
        }
        let api_that_guard = api_that_guard.unwrap();
 let output_ok = crate::api::dart::api::connection_handle::ConnectionHandle::on_state_change(&*api_that_guard, api_f)?;   Ok(output_ok)
                })()) })
}
fn wire__crate__api__dart__api__jason__Jason_jason_close_room_impl(
    ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
    rust_vec_len_: i32,
    data_len_: i32,
) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec,_>(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "Jason_jason_close_room", port: None, mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync }, move || { 
            let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) };
            let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message);
            let api_that = <RustOpaqueMoi<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<Jason>>>::sse_decode(&mut deserializer);
let api_room_to_delete = <RoomHandle>::sse_decode(&mut deserializer);deserializer.end();
                transform_result_sse::<_, ()>((move || {
                    let mut api_that_guard = None;
let decode_indices_ = flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(&api_that, 0, false)]);
        for i in decode_indices_ {
            match i {
                0 => api_that_guard = Some(api_that.lockable_decode_sync_ref()),
                _ => unreachable!(),
            }
        }
        let api_that_guard = api_that_guard.unwrap();
 let output_ok = Result::<_,()>::Ok({ crate::api::dart::api::jason::Jason::jason_close_room(&*api_that_guard, api_room_to_delete); })?;   Ok(output_ok)
                })()) })
}
fn wire__crate__api__dart__api__jason__Jason_jason_dispose_impl(
    ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
    rust_vec_len_: i32,
    data_len_: i32,
) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec,_>(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "Jason_jason_dispose", port: None, mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync }, move || { 
            let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) };
            let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message);
            let api_that = <Jason>::sse_decode(&mut deserializer);deserializer.end();
                transform_result_sse::<_, ()>((move || {
                     let output_ok = Result::<_,()>::Ok({ crate::api::dart::api::jason::Jason::jason_dispose(api_that); })?;   Ok(output_ok)
                })()) })
}
fn wire__crate__api__dart__api__jason__Jason_jason_init_room_impl(
    ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
    rust_vec_len_: i32,
    data_len_: i32,
) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec,_>(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "Jason_jason_init_room", port: None, mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync }, move || { 
            let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) };
            let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message);
            let api_that = <RustOpaqueMoi<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<Jason>>>::sse_decode(&mut deserializer);deserializer.end();
                transform_result_sse::<_, ()>((move || {
                    let mut api_that_guard = None;
let decode_indices_ = flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(&api_that, 0, false)]);
        for i in decode_indices_ {
            match i {
                0 => api_that_guard = Some(api_that.lockable_decode_sync_ref()),
                _ => unreachable!(),
            }
        }
        let api_that_guard = api_that_guard.unwrap();
 let output_ok = Result::<_,()>::Ok(crate::api::dart::api::jason::Jason::jason_init_room(&*api_that_guard))?;   Ok(output_ok)
                })()) })
}
fn wire__crate__api__dart__api__jason__Jason_jason_media_manager_impl(
    ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
    rust_vec_len_: i32,
    data_len_: i32,
) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec,_>(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "Jason_jason_media_manager", port: None, mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync }, move || { 
            let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) };
            let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message);
            let api_that = <RustOpaqueMoi<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<Jason>>>::sse_decode(&mut deserializer);deserializer.end();
                transform_result_sse::<_, ()>((move || {
                    let mut api_that_guard = None;
let decode_indices_ = flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(&api_that, 0, false)]);
        for i in decode_indices_ {
            match i {
                0 => api_that_guard = Some(api_that.lockable_decode_sync_ref()),
                _ => unreachable!(),
            }
        }
        let api_that_guard = api_that_guard.unwrap();
 let output_ok = Result::<_,()>::Ok(crate::api::dart::api::jason::Jason::jason_media_manager(&*api_that_guard))?;   Ok(output_ok)
                })()) })
}
fn wire__crate__api__dart__api__jason__Jason_jason_network_changed_impl(
    ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
    rust_vec_len_: i32,
    data_len_: i32,
) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec,_>(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "Jason_jason_network_changed", port: None, mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync }, move || { 
            let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) };
            let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message);
            let api_that = <RustOpaqueMoi<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<Jason>>>::sse_decode(&mut deserializer);deserializer.end();
                transform_result_sse::<_, ()>((move || {
                    let mut api_that_guard = None;
let decode_indices_ = flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(&api_that, 0, false)]);
        for i in decode_indices_ {
            match i {
                0 => api_that_guard = Some(api_that.lockable_decode_sync_ref()),
                _ => unreachable!(),
            }
        }
        let api_that_guard = api_that_guard.unwrap();
 let output_ok = Result::<_,()>::Ok(crate::api::dart::api::jason::Jason::jason_network_changed(&*api_that_guard))?;   Ok(output_ok)
                })()) })
}
fn wire__crate__api__dart__api__jason__Jason_new_impl(
    ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
    rust_vec_len_: i32,
    data_len_: i32,
) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec,_>(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "Jason_new", port: None, mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync }, move || { 
            let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) };
            let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message);
            deserializer.end();
                transform_result_sse::<_, ()>((move || {
                     let output_ok = Result::<_,()>::Ok(crate::api::dart::api::jason::Jason::new())?;   Ok(output_ok)
                })()) })
}
fn wire__crate__api__dart__api__local_media_track__LocalMediaTrack_free_impl(
    ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
    rust_vec_len_: i32,
    data_len_: i32,
) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec,_>(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "LocalMediaTrack_free", port: None, mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync }, move || { 
            let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) };
            let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message);
            let api_that = <LocalMediaTrack>::sse_decode(&mut deserializer);deserializer.end();
                transform_result_sse::<_, ()>((move || {
                     let output_ok = Result::<_,()>::Ok(crate::api::dart::api::local_media_track::LocalMediaTrack::free(api_that))?;   Ok(output_ok)
                })()) })
}
fn wire__crate__api__dart__api__local_media_track__LocalMediaTrack_from_ptr_impl(
    ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
    rust_vec_len_: i32,
    data_len_: i32,
) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec,_>(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "LocalMediaTrack_from_ptr", port: None, mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync }, move || { 
            let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) };
            let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message);
            let api_ptr = <usize>::sse_decode(&mut deserializer);deserializer.end();
                transform_result_sse::<_, ()>((move || {
                     let output_ok = Result::<_,()>::Ok(crate::api::dart::api::local_media_track::LocalMediaTrack::from_ptr(api_ptr))?;   Ok(output_ok)
                })()) })
}
fn wire__crate__api__dart__api__local_media_track__LocalMediaTrack_get_noise_suppression_level_impl(
    ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
    rust_vec_len_: i32,
    data_len_: i32,
) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec,_>(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "LocalMediaTrack_get_noise_suppression_level", port: None, mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync }, move || { 
            let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) };
            let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message);
            let api_that = <RustOpaqueMoi<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<LocalMediaTrack>>>::sse_decode(&mut deserializer);deserializer.end();
                transform_result_sse::<_, ()>((move || {
                    let mut api_that_guard = None;
let decode_indices_ = flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(&api_that, 0, false)]);
        for i in decode_indices_ {
            match i {
                0 => api_that_guard = Some(api_that.lockable_decode_sync_ref()),
                _ => unreachable!(),
            }
        }
        let api_that_guard = api_that_guard.unwrap();
 let output_ok = Result::<_,()>::Ok(crate::api::dart::api::local_media_track::LocalMediaTrack::get_noise_suppression_level(&*api_that_guard))?;   Ok(output_ok)
                })()) })
}
fn wire__crate__api__dart__api__local_media_track__LocalMediaTrack_get_track_impl(
    ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
    rust_vec_len_: i32,
    data_len_: i32,
) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec,_>(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "LocalMediaTrack_get_track", port: None, mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync }, move || { 
            let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) };
            let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message);
            let api_that = <RustOpaqueMoi<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<LocalMediaTrack>>>::sse_decode(&mut deserializer);deserializer.end();
                transform_result_sse::<_, ()>((move || {
                    let mut api_that_guard = None;
let decode_indices_ = flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(&api_that, 0, false)]);
        for i in decode_indices_ {
            match i {
                0 => api_that_guard = Some(api_that.lockable_decode_sync_ref()),
                _ => unreachable!(),
            }
        }
        let api_that_guard = api_that_guard.unwrap();
 let output_ok = Result::<_,()>::Ok(crate::api::dart::api::local_media_track::LocalMediaTrack::get_track(&*api_that_guard))?;   Ok(output_ok)
                })()) })
}
fn wire__crate__api__dart__api__local_media_track__LocalMediaTrack_is_audio_processing_available_impl(
    ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
    rust_vec_len_: i32,
    data_len_: i32,
) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec,_>(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "LocalMediaTrack_is_audio_processing_available", port: None, mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync }, move || { 
            let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) };
            let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message);
            let api_that = <RustOpaqueMoi<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<LocalMediaTrack>>>::sse_decode(&mut deserializer);deserializer.end();
                transform_result_sse::<_, ()>((move || {
                    let mut api_that_guard = None;
let decode_indices_ = flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(&api_that, 0, false)]);
        for i in decode_indices_ {
            match i {
                0 => api_that_guard = Some(api_that.lockable_decode_sync_ref()),
                _ => unreachable!(),
            }
        }
        let api_that_guard = api_that_guard.unwrap();
 let output_ok = Result::<_,()>::Ok(crate::api::dart::api::local_media_track::LocalMediaTrack::is_audio_processing_available(&*api_that_guard))?;   Ok(output_ok)
                })()) })
}
fn wire__crate__api__dart__api__local_media_track__LocalMediaTrack_is_auto_gain_control_enabled_impl(
    ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
    rust_vec_len_: i32,
    data_len_: i32,
) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec,_>(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "LocalMediaTrack_is_auto_gain_control_enabled", port: None, mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync }, move || { 
            let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) };
            let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message);
            let api_that = <RustOpaqueMoi<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<LocalMediaTrack>>>::sse_decode(&mut deserializer);deserializer.end();
                transform_result_sse::<_, ()>((move || {
                    let mut api_that_guard = None;
let decode_indices_ = flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(&api_that, 0, false)]);
        for i in decode_indices_ {
            match i {
                0 => api_that_guard = Some(api_that.lockable_decode_sync_ref()),
                _ => unreachable!(),
            }
        }
        let api_that_guard = api_that_guard.unwrap();
 let output_ok = Result::<_,()>::Ok(crate::api::dart::api::local_media_track::LocalMediaTrack::is_auto_gain_control_enabled(&*api_that_guard))?;   Ok(output_ok)
                })()) })
}
fn wire__crate__api__dart__api__local_media_track__LocalMediaTrack_is_echo_cancellation_enabled_impl(
    ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
    rust_vec_len_: i32,
    data_len_: i32,
) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec,_>(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "LocalMediaTrack_is_echo_cancellation_enabled", port: None, mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync }, move || { 
            let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) };
            let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message);
            let api_that = <RustOpaqueMoi<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<LocalMediaTrack>>>::sse_decode(&mut deserializer);deserializer.end();
                transform_result_sse::<_, ()>((move || {
                    let mut api_that_guard = None;
let decode_indices_ = flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(&api_that, 0, false)]);
        for i in decode_indices_ {
            match i {
                0 => api_that_guard = Some(api_that.lockable_decode_sync_ref()),
                _ => unreachable!(),
            }
        }
        let api_that_guard = api_that_guard.unwrap();
 let output_ok = Result::<_,()>::Ok(crate::api::dart::api::local_media_track::LocalMediaTrack::is_echo_cancellation_enabled(&*api_that_guard))?;   Ok(output_ok)
                })()) })
}
fn wire__crate__api__dart__api__local_media_track__LocalMediaTrack_is_high_pass_filter_enabled_impl(
    ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
    rust_vec_len_: i32,
    data_len_: i32,
) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec,_>(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "LocalMediaTrack_is_high_pass_filter_enabled", port: None, mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync }, move || { 
            let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) };
            let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message);
            let api_that = <RustOpaqueMoi<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<LocalMediaTrack>>>::sse_decode(&mut deserializer);deserializer.end();
                transform_result_sse::<_, ()>((move || {
                    let mut api_that_guard = None;
let decode_indices_ = flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(&api_that, 0, false)]);
        for i in decode_indices_ {
            match i {
                0 => api_that_guard = Some(api_that.lockable_decode_sync_ref()),
                _ => unreachable!(),
            }
        }
        let api_that_guard = api_that_guard.unwrap();
 let output_ok = Result::<_,()>::Ok(crate::api::dart::api::local_media_track::LocalMediaTrack::is_high_pass_filter_enabled(&*api_that_guard))?;   Ok(output_ok)
                })()) })
}
fn wire__crate__api__dart__api__local_media_track__LocalMediaTrack_is_noise_suppression_enabled_impl(
    ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
    rust_vec_len_: i32,
    data_len_: i32,
) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec,_>(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "LocalMediaTrack_is_noise_suppression_enabled", port: None, mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync }, move || { 
            let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) };
            let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message);
            let api_that = <RustOpaqueMoi<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<LocalMediaTrack>>>::sse_decode(&mut deserializer);deserializer.end();
                transform_result_sse::<_, ()>((move || {
                    let mut api_that_guard = None;
let decode_indices_ = flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(&api_that, 0, false)]);
        for i in decode_indices_ {
            match i {
                0 => api_that_guard = Some(api_that.lockable_decode_sync_ref()),
                _ => unreachable!(),
            }
        }
        let api_that_guard = api_that_guard.unwrap();
 let output_ok = Result::<_,()>::Ok(crate::api::dart::api::local_media_track::LocalMediaTrack::is_noise_suppression_enabled(&*api_that_guard))?;   Ok(output_ok)
                })()) })
}
fn wire__crate__api__dart__api__local_media_track__LocalMediaTrack_is_on_audio_level_available_impl(
    ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
    rust_vec_len_: i32,
    data_len_: i32,
) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec,_>(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "LocalMediaTrack_is_on_audio_level_available", port: None, mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync }, move || { 
            let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) };
            let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message);
            let api_that = <RustOpaqueMoi<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<LocalMediaTrack>>>::sse_decode(&mut deserializer);deserializer.end();
                transform_result_sse::<_, ()>((move || {
                    let mut api_that_guard = None;
let decode_indices_ = flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(&api_that, 0, false)]);
        for i in decode_indices_ {
            match i {
                0 => api_that_guard = Some(api_that.lockable_decode_sync_ref()),
                _ => unreachable!(),
            }
        }
        let api_that_guard = api_that_guard.unwrap();
 let output_ok = Result::<_,()>::Ok(crate::api::dart::api::local_media_track::LocalMediaTrack::is_on_audio_level_available(&*api_that_guard))?;   Ok(output_ok)
                })()) })
}
fn wire__crate__api__dart__api__local_media_track__LocalMediaTrack_kind_impl(
    ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
    rust_vec_len_: i32,
    data_len_: i32,
) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec,_>(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "LocalMediaTrack_kind", port: None, mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync }, move || { 
            let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) };
            let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message);
            let api_that = <RustOpaqueMoi<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<LocalMediaTrack>>>::sse_decode(&mut deserializer);deserializer.end();
                transform_result_sse::<_, ()>((move || {
                    let mut api_that_guard = None;
let decode_indices_ = flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(&api_that, 0, false)]);
        for i in decode_indices_ {
            match i {
                0 => api_that_guard = Some(api_that.lockable_decode_sync_ref()),
                _ => unreachable!(),
            }
        }
        let api_that_guard = api_that_guard.unwrap();
 let output_ok = Result::<_,()>::Ok(crate::api::dart::api::local_media_track::LocalMediaTrack::kind(&*api_that_guard))?;   Ok(output_ok)
                })()) })
}
fn wire__crate__api__dart__api__local_media_track__LocalMediaTrack_media_source_kind_impl(
    ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
    rust_vec_len_: i32,
    data_len_: i32,
) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec,_>(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "LocalMediaTrack_media_source_kind", port: None, mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync }, move || { 
            let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) };
            let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message);
            let api_that = <RustOpaqueMoi<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<LocalMediaTrack>>>::sse_decode(&mut deserializer);deserializer.end();
                transform_result_sse::<_, ()>((move || {
                    let mut api_that_guard = None;
let decode_indices_ = flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(&api_that, 0, false)]);
        for i in decode_indices_ {
            match i {
                0 => api_that_guard = Some(api_that.lockable_decode_sync_ref()),
                _ => unreachable!(),
            }
        }
        let api_that_guard = api_that_guard.unwrap();
 let output_ok = Result::<_,()>::Ok(crate::api::dart::api::local_media_track::LocalMediaTrack::media_source_kind(&*api_that_guard))?;   Ok(output_ok)
                })()) })
}
fn wire__crate__api__dart__api__local_media_track__LocalMediaTrack_on_audio_level_changed_impl(
    ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
    rust_vec_len_: i32,
    data_len_: i32,
) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec,_>(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "LocalMediaTrack_on_audio_level_changed", port: None, mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync }, move || { 
            let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) };
            let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message);
            let api_that = <RustOpaqueMoi<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<LocalMediaTrack>>>::sse_decode(&mut deserializer);
let api_f = <flutter_rust_bridge::DartOpaque>::sse_decode(&mut deserializer);deserializer.end();
                transform_result_sse::<_, ()>((move || {
                    let mut api_that_guard = None;
let decode_indices_ = flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(&api_that, 0, false)]);
        for i in decode_indices_ {
            match i {
                0 => api_that_guard = Some(api_that.lockable_decode_sync_ref()),
                _ => unreachable!(),
            }
        }
        let api_that_guard = api_that_guard.unwrap();
 let output_ok = Result::<_,()>::Ok({ crate::api::dart::api::local_media_track::LocalMediaTrack::on_audio_level_changed(&*api_that_guard, api_f); })?;   Ok(output_ok)
                })()) })
}
fn wire__crate__api__dart__api__local_media_track__LocalMediaTrack_on_ended_impl(
    ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
    rust_vec_len_: i32,
    data_len_: i32,
) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec,_>(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "LocalMediaTrack_on_ended", port: None, mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync }, move || { 
            let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) };
            let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message);
            let api_that = <RustOpaqueMoi<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<LocalMediaTrack>>>::sse_decode(&mut deserializer);
let api_f = <flutter_rust_bridge::DartOpaque>::sse_decode(&mut deserializer);deserializer.end();
                transform_result_sse::<_, ()>((move || {
                    let mut api_that_guard = None;
let decode_indices_ = flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(&api_that, 0, false)]);
        for i in decode_indices_ {
            match i {
                0 => api_that_guard = Some(api_that.lockable_decode_sync_ref()),
                _ => unreachable!(),
            }
        }
        let api_that_guard = api_that_guard.unwrap();
 let output_ok = Result::<_,()>::Ok({ crate::api::dart::api::local_media_track::LocalMediaTrack::on_ended(&*api_that_guard, api_f); })?;   Ok(output_ok)
                })()) })
}
fn wire__crate__api__dart__api__local_media_track__LocalMediaTrack_set_auto_gain_control_enabled_impl(
    ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
    rust_vec_len_: i32,
    data_len_: i32,
) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec,_>(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "LocalMediaTrack_set_auto_gain_control_enabled", port: None, mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync }, move || { 
            let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) };
            let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message);
            let api_that = <RustOpaqueMoi<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<LocalMediaTrack>>>::sse_decode(&mut deserializer);
let api_enabled = <bool>::sse_decode(&mut deserializer);deserializer.end();
                transform_result_sse::<_, ()>((move || {
                    let mut api_that_guard = None;
let decode_indices_ = flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(&api_that, 0, false)]);
        for i in decode_indices_ {
            match i {
                0 => api_that_guard = Some(api_that.lockable_decode_sync_ref()),
                _ => unreachable!(),
            }
        }
        let api_that_guard = api_that_guard.unwrap();
 let output_ok = Result::<_,()>::Ok(crate::api::dart::api::local_media_track::LocalMediaTrack::set_auto_gain_control_enabled(&*api_that_guard, api_enabled))?;   Ok(output_ok)
                })()) })
}
fn wire__crate__api__dart__api__local_media_track__LocalMediaTrack_set_echo_cancellation_enabled_impl(
    ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
    rust_vec_len_: i32,
    data_len_: i32,
) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec,_>(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "LocalMediaTrack_set_echo_cancellation_enabled", port: None, mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync }, move || { 
            let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) };
            let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message);
            let api_that = <RustOpaqueMoi<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<LocalMediaTrack>>>::sse_decode(&mut deserializer);
let api_enabled = <bool>::sse_decode(&mut deserializer);deserializer.end();
                transform_result_sse::<_, ()>((move || {
                    let mut api_that_guard = None;
let decode_indices_ = flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(&api_that, 0, false)]);
        for i in decode_indices_ {
            match i {
                0 => api_that_guard = Some(api_that.lockable_decode_sync_ref()),
                _ => unreachable!(),
            }
        }
        let api_that_guard = api_that_guard.unwrap();
 let output_ok = Result::<_,()>::Ok(crate::api::dart::api::local_media_track::LocalMediaTrack::set_echo_cancellation_enabled(&*api_that_guard, api_enabled))?;   Ok(output_ok)
                })()) })
}
fn wire__crate__api__dart__api__local_media_track__LocalMediaTrack_set_high_pass_filter_enabled_impl(
    ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
    rust_vec_len_: i32,
    data_len_: i32,
) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec,_>(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "LocalMediaTrack_set_high_pass_filter_enabled", port: None, mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync }, move || { 
            let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) };
            let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message);
            let api_that = <RustOpaqueMoi<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<LocalMediaTrack>>>::sse_decode(&mut deserializer);
let api_enabled = <bool>::sse_decode(&mut deserializer);deserializer.end();
                transform_result_sse::<_, ()>((move || {
                    let mut api_that_guard = None;
let decode_indices_ = flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(&api_that, 0, false)]);
        for i in decode_indices_ {
            match i {
                0 => api_that_guard = Some(api_that.lockable_decode_sync_ref()),
                _ => unreachable!(),
            }
        }
        let api_that_guard = api_that_guard.unwrap();
 let output_ok = Result::<_,()>::Ok(crate::api::dart::api::local_media_track::LocalMediaTrack::set_high_pass_filter_enabled(&*api_that_guard, api_enabled))?;   Ok(output_ok)
                })()) })
}
fn wire__crate__api__dart__api__local_media_track__LocalMediaTrack_set_noise_suppression_enabled_impl(
    ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
    rust_vec_len_: i32,
    data_len_: i32,
) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec,_>(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "LocalMediaTrack_set_noise_suppression_enabled", port: None, mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync }, move || { 
            let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) };
            let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message);
            let api_that = <RustOpaqueMoi<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<LocalMediaTrack>>>::sse_decode(&mut deserializer);
let api_enabled = <bool>::sse_decode(&mut deserializer);deserializer.end();
                transform_result_sse::<_, ()>((move || {
                    let mut api_that_guard = None;
let decode_indices_ = flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(&api_that, 0, false)]);
        for i in decode_indices_ {
            match i {
                0 => api_that_guard = Some(api_that.lockable_decode_sync_ref()),
                _ => unreachable!(),
            }
        }
        let api_that_guard = api_that_guard.unwrap();
 let output_ok = Result::<_,()>::Ok(crate::api::dart::api::local_media_track::LocalMediaTrack::set_noise_suppression_enabled(&*api_that_guard, api_enabled))?;   Ok(output_ok)
                })()) })
}
fn wire__crate__api__dart__api__local_media_track__LocalMediaTrack_set_noise_suppression_level_impl(
    ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
    rust_vec_len_: i32,
    data_len_: i32,
) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec,_>(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "LocalMediaTrack_set_noise_suppression_level", port: None, mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync }, move || { 
            let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) };
            let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message);
            let api_that = <RustOpaqueMoi<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<LocalMediaTrack>>>::sse_decode(&mut deserializer);
let api_level = <crate::media::constraints::NoiseSuppressionLevel>::sse_decode(&mut deserializer);deserializer.end();
                transform_result_sse::<_, ()>((move || {
                    let mut api_that_guard = None;
let decode_indices_ = flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(&api_that, 0, false)]);
        for i in decode_indices_ {
            match i {
                0 => api_that_guard = Some(api_that.lockable_decode_sync_ref()),
                _ => unreachable!(),
            }
        }
        let api_that_guard = api_that_guard.unwrap();
 let output_ok = Result::<_,()>::Ok(crate::api::dart::api::local_media_track::LocalMediaTrack::set_noise_suppression_level(&*api_that_guard, api_level))?;   Ok(output_ok)
                })()) })
}
fn wire__crate__api__dart__api__local_media_track__LocalMediaTrack_state_impl(
    ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
    rust_vec_len_: i32,
    data_len_: i32,
) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec,_>(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "LocalMediaTrack_state", port: None, mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync }, move || { 
            let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) };
            let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message);
            let api_that = <RustOpaqueMoi<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<LocalMediaTrack>>>::sse_decode(&mut deserializer);deserializer.end();
                transform_result_sse::<_, ()>((move || {
                    let mut api_that_guard = None;
let decode_indices_ = flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(&api_that, 0, false)]);
        for i in decode_indices_ {
            match i {
                0 => api_that_guard = Some(api_that.lockable_decode_sync_ref()),
                _ => unreachable!(),
            }
        }
        let api_that_guard = api_that_guard.unwrap();
 let output_ok = Result::<_,()>::Ok(crate::api::dart::api::local_media_track::LocalMediaTrack::state(&*api_that_guard))?;   Ok(output_ok)
                })()) })
}
fn wire__crate__api__dart__api__media_manager__MediaManagerHandle_enumerate_devices_impl(
    ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
    rust_vec_len_: i32,
    data_len_: i32,
) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec,_>(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "MediaManagerHandle_enumerate_devices", port: None, mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync }, move || { 
            let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) };
            let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message);
            let api_that = <RustOpaqueMoi<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<MediaManagerHandle>>>::sse_decode(&mut deserializer);deserializer.end();
                transform_result_sse::<_, ()>((move || {
                    let mut api_that_guard = None;
let decode_indices_ = flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(&api_that, 0, false)]);
        for i in decode_indices_ {
            match i {
                0 => api_that_guard = Some(api_that.lockable_decode_sync_ref()),
                _ => unreachable!(),
            }
        }
        let api_that_guard = api_that_guard.unwrap();
 let output_ok = Result::<_,()>::Ok(crate::api::dart::api::media_manager::MediaManagerHandle::enumerate_devices(&*api_that_guard))?;   Ok(output_ok)
                })()) })
}
fn wire__crate__api__dart__api__media_manager__MediaManagerHandle_enumerate_displays_impl(
    ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
    rust_vec_len_: i32,
    data_len_: i32,
) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec,_>(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "MediaManagerHandle_enumerate_displays", port: None, mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync }, move || { 
            let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) };
            let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message);
            let api_that = <RustOpaqueMoi<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<MediaManagerHandle>>>::sse_decode(&mut deserializer);deserializer.end();
                transform_result_sse::<_, ()>((move || {
                    let mut api_that_guard = None;
let decode_indices_ = flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(&api_that, 0, false)]);
        for i in decode_indices_ {
            match i {
                0 => api_that_guard = Some(api_that.lockable_decode_sync_ref()),
                _ => unreachable!(),
            }
        }
        let api_that_guard = api_that_guard.unwrap();
 let output_ok = Result::<_,()>::Ok(crate::api::dart::api::media_manager::MediaManagerHandle::enumerate_displays(&*api_that_guard))?;   Ok(output_ok)
                })()) })
}
fn wire__crate__api__dart__api__media_manager__MediaManagerHandle_init_local_tracks_impl(
    ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
    rust_vec_len_: i32,
    data_len_: i32,
) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec,_>(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "MediaManagerHandle_init_local_tracks", port: None, mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync }, move || { 
            let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) };
            let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message);
            let api_that = <RustOpaqueMoi<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<MediaManagerHandle>>>::sse_decode(&mut deserializer);
let api_caps = <crate::api::dart::api::ApiMediaStreamSettings>::sse_decode(&mut deserializer);deserializer.end();
                transform_result_sse::<_, ()>((move || {
                    let mut api_that_guard = None;
let decode_indices_ = flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(&api_that, 0, false)]);
        for i in decode_indices_ {
            match i {
                0 => api_that_guard = Some(api_that.lockable_decode_sync_ref()),
                _ => unreachable!(),
            }
        }
        let api_that_guard = api_that_guard.unwrap();
 let output_ok = Result::<_,()>::Ok(crate::api::dart::api::media_manager::MediaManagerHandle::init_local_tracks(&*api_that_guard, api_caps))?;   Ok(output_ok)
                })()) })
}
fn wire__crate__api__dart__api__media_manager__MediaManagerHandle_microphone_volume_impl(
    ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
    rust_vec_len_: i32,
    data_len_: i32,
) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec,_>(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "MediaManagerHandle_microphone_volume", port: None, mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync }, move || { 
            let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) };
            let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message);
            let api_that = <RustOpaqueMoi<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<MediaManagerHandle>>>::sse_decode(&mut deserializer);deserializer.end();
                transform_result_sse::<_, ()>((move || {
                    let mut api_that_guard = None;
let decode_indices_ = flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(&api_that, 0, false)]);
        for i in decode_indices_ {
            match i {
                0 => api_that_guard = Some(api_that.lockable_decode_sync_ref()),
                _ => unreachable!(),
            }
        }
        let api_that_guard = api_that_guard.unwrap();
 let output_ok = Result::<_,()>::Ok(crate::api::dart::api::media_manager::MediaManagerHandle::microphone_volume(&*api_that_guard))?;   Ok(output_ok)
                })()) })
}
fn wire__crate__api__dart__api__media_manager__MediaManagerHandle_microphone_volume_is_available_impl(
    ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
    rust_vec_len_: i32,
    data_len_: i32,
) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec,_>(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "MediaManagerHandle_microphone_volume_is_available", port: None, mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync }, move || { 
            let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) };
            let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message);
            let api_that = <RustOpaqueMoi<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<MediaManagerHandle>>>::sse_decode(&mut deserializer);deserializer.end();
                transform_result_sse::<_, ()>((move || {
                    let mut api_that_guard = None;
let decode_indices_ = flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(&api_that, 0, false)]);
        for i in decode_indices_ {
            match i {
                0 => api_that_guard = Some(api_that.lockable_decode_sync_ref()),
                _ => unreachable!(),
            }
        }
        let api_that_guard = api_that_guard.unwrap();
 let output_ok = Result::<_,()>::Ok(crate::api::dart::api::media_manager::MediaManagerHandle::microphone_volume_is_available(&*api_that_guard))?;   Ok(output_ok)
                })()) })
}
fn wire__crate__api__dart__api__media_manager__MediaManagerHandle_on_device_change_impl(
    ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
    rust_vec_len_: i32,
    data_len_: i32,
) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec,_>(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "MediaManagerHandle_on_device_change", port: None, mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync }, move || { 
            let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) };
            let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message);
            let api_that = <RustOpaqueMoi<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<MediaManagerHandle>>>::sse_decode(&mut deserializer);
let api_cb = <flutter_rust_bridge::DartOpaque>::sse_decode(&mut deserializer);deserializer.end();
                transform_result_sse::<_, flutter_rust_bridge::DartOpaque>((move || {
                    let mut api_that_guard = None;
let decode_indices_ = flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(&api_that, 0, false)]);
        for i in decode_indices_ {
            match i {
                0 => api_that_guard = Some(api_that.lockable_decode_sync_ref()),
                _ => unreachable!(),
            }
        }
        let api_that_guard = api_that_guard.unwrap();
 let output_ok = crate::api::dart::api::media_manager::MediaManagerHandle::on_device_change(&*api_that_guard, api_cb)?;   Ok(output_ok)
                })()) })
}
fn wire__crate__api__dart__api__media_manager__MediaManagerHandle_set_microphone_volume_impl(
    ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
    rust_vec_len_: i32,
    data_len_: i32,
) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec,_>(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "MediaManagerHandle_set_microphone_volume", port: None, mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync }, move || { 
            let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) };
            let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message);
            let api_that = <RustOpaqueMoi<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<MediaManagerHandle>>>::sse_decode(&mut deserializer);
let api_level = <i64>::sse_decode(&mut deserializer);deserializer.end();
                transform_result_sse::<_, ()>((move || {
                    let mut api_that_guard = None;
let decode_indices_ = flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(&api_that, 0, false)]);
        for i in decode_indices_ {
            match i {
                0 => api_that_guard = Some(api_that.lockable_decode_sync_ref()),
                _ => unreachable!(),
            }
        }
        let api_that_guard = api_that_guard.unwrap();
 let output_ok = Result::<_,()>::Ok(crate::api::dart::api::media_manager::MediaManagerHandle::set_microphone_volume(&*api_that_guard, api_level))?;   Ok(output_ok)
                })()) })
}
fn wire__crate__api__dart__api__media_manager__MediaManagerHandle_set_output_audio_id_impl(
    ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
    rust_vec_len_: i32,
    data_len_: i32,
) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec,_>(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "MediaManagerHandle_set_output_audio_id", port: None, mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync }, move || { 
            let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) };
            let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message);
            let api_that = <RustOpaqueMoi<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<MediaManagerHandle>>>::sse_decode(&mut deserializer);
let api_device_id = <String>::sse_decode(&mut deserializer);deserializer.end();
                transform_result_sse::<_, ()>((move || {
                    let mut api_that_guard = None;
let decode_indices_ = flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(&api_that, 0, false)]);
        for i in decode_indices_ {
            match i {
                0 => api_that_guard = Some(api_that.lockable_decode_sync_ref()),
                _ => unreachable!(),
            }
        }
        let api_that_guard = api_that_guard.unwrap();
 let output_ok = Result::<_,()>::Ok(crate::api::dart::api::media_manager::MediaManagerHandle::set_output_audio_id(&*api_that_guard, api_device_id))?;   Ok(output_ok)
                })()) })
}
fn wire__crate__api__dart__api__reconnect_handle__ReconnectHandle_from_ptr_impl(
    ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
    rust_vec_len_: i32,
    data_len_: i32,
) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec,_>(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "ReconnectHandle_from_ptr", port: None, mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync }, move || { 
            let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) };
            let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message);
            let api_ptr = <usize>::sse_decode(&mut deserializer);deserializer.end();
                transform_result_sse::<_, ()>((move || {
                     let output_ok = Result::<_,()>::Ok(crate::api::dart::api::reconnect_handle::ReconnectHandle::from_ptr(api_ptr))?;   Ok(output_ok)
                })()) })
}
fn wire__crate__api__dart__api__reconnect_handle__ReconnectHandle_reconnect_with_backoff_impl(
    ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
    rust_vec_len_: i32,
    data_len_: i32,
) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec,_>(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "ReconnectHandle_reconnect_with_backoff", port: None, mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync }, move || { 
            let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) };
            let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message);
            let api_that = <RustOpaqueMoi<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<ReconnectHandle>>>::sse_decode(&mut deserializer);
let api_starting_delay = <u32>::sse_decode(&mut deserializer);
let api_multiplier = <f64>::sse_decode(&mut deserializer);
let api_max_delay = <u32>::sse_decode(&mut deserializer);
let api_max_elapsed_time_ms = <Option<u32>>::sse_decode(&mut deserializer);deserializer.end();
                transform_result_sse::<_, ()>((move || {
                    let mut api_that_guard = None;
let decode_indices_ = flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(&api_that, 0, false)]);
        for i in decode_indices_ {
            match i {
                0 => api_that_guard = Some(api_that.lockable_decode_sync_ref()),
                _ => unreachable!(),
            }
        }
        let api_that_guard = api_that_guard.unwrap();
 let output_ok = Result::<_,()>::Ok(crate::api::dart::api::reconnect_handle::ReconnectHandle::reconnect_with_backoff(&*api_that_guard, api_starting_delay, api_multiplier, api_max_delay, api_max_elapsed_time_ms))?;   Ok(output_ok)
                })()) })
}
fn wire__crate__api__dart__api__reconnect_handle__ReconnectHandle_reconnect_with_delay_impl(
    ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
    rust_vec_len_: i32,
    data_len_: i32,
) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec,_>(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "ReconnectHandle_reconnect_with_delay", port: None, mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync }, move || { 
            let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) };
            let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message);
            let api_that = <RustOpaqueMoi<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<ReconnectHandle>>>::sse_decode(&mut deserializer);
let api_delay_ms = <u32>::sse_decode(&mut deserializer);deserializer.end();
                transform_result_sse::<_, ()>((move || {
                    let mut api_that_guard = None;
let decode_indices_ = flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(&api_that, 0, false)]);
        for i in decode_indices_ {
            match i {
                0 => api_that_guard = Some(api_that.lockable_decode_sync_ref()),
                _ => unreachable!(),
            }
        }
        let api_that_guard = api_that_guard.unwrap();
 let output_ok = Result::<_,()>::Ok(crate::api::dart::api::reconnect_handle::ReconnectHandle::reconnect_with_delay(&*api_that_guard, api_delay_ms))?;   Ok(output_ok)
                })()) })
}
fn wire__crate__api__dart__api__remote_media_track__RemoteMediaTrack_from_ptr_impl(
    ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
    rust_vec_len_: i32,
    data_len_: i32,
) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec,_>(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "RemoteMediaTrack_from_ptr", port: None, mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync }, move || { 
            let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) };
            let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message);
            let api_ptr = <usize>::sse_decode(&mut deserializer);deserializer.end();
                transform_result_sse::<_, ()>((move || {
                     let output_ok = Result::<_,()>::Ok(crate::api::dart::api::remote_media_track::RemoteMediaTrack::from_ptr(api_ptr))?;   Ok(output_ok)
                })()) })
}
fn wire__crate__api__dart__api__remote_media_track__RemoteMediaTrack_get_track_impl(
    ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
    rust_vec_len_: i32,
    data_len_: i32,
) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec,_>(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "RemoteMediaTrack_get_track", port: None, mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync }, move || { 
            let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) };
            let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message);
            let api_that = <RustOpaqueMoi<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RemoteMediaTrack>>>::sse_decode(&mut deserializer);deserializer.end();
                transform_result_sse::<_, ()>((move || {
                    let mut api_that_guard = None;
let decode_indices_ = flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(&api_that, 0, false)]);
        for i in decode_indices_ {
            match i {
                0 => api_that_guard = Some(api_that.lockable_decode_sync_ref()),
                _ => unreachable!(),
            }
        }
        let api_that_guard = api_that_guard.unwrap();
 let output_ok = Result::<_,()>::Ok(crate::api::dart::api::remote_media_track::RemoteMediaTrack::get_track(&*api_that_guard))?;   Ok(output_ok)
                })()) })
}
fn wire__crate__api__dart__api__remote_media_track__RemoteMediaTrack_kind_impl(
    ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
    rust_vec_len_: i32,
    data_len_: i32,
) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec,_>(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "RemoteMediaTrack_kind", port: None, mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync }, move || { 
            let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) };
            let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message);
            let api_that = <RustOpaqueMoi<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RemoteMediaTrack>>>::sse_decode(&mut deserializer);deserializer.end();
                transform_result_sse::<_, ()>((move || {
                    let mut api_that_guard = None;
let decode_indices_ = flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(&api_that, 0, false)]);
        for i in decode_indices_ {
            match i {
                0 => api_that_guard = Some(api_that.lockable_decode_sync_ref()),
                _ => unreachable!(),
            }
        }
        let api_that_guard = api_that_guard.unwrap();
 let output_ok = Result::<_,()>::Ok(crate::api::dart::api::remote_media_track::RemoteMediaTrack::kind(&*api_that_guard))?;   Ok(output_ok)
                })()) })
}
fn wire__crate__api__dart__api__remote_media_track__RemoteMediaTrack_media_direction_impl(
    ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
    rust_vec_len_: i32,
    data_len_: i32,
) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec,_>(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "RemoteMediaTrack_media_direction", port: None, mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync }, move || { 
            let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) };
            let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message);
            let api_that = <RustOpaqueMoi<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RemoteMediaTrack>>>::sse_decode(&mut deserializer);deserializer.end();
                transform_result_sse::<_, ()>((move || {
                    let mut api_that_guard = None;
let decode_indices_ = flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(&api_that, 0, false)]);
        for i in decode_indices_ {
            match i {
                0 => api_that_guard = Some(api_that.lockable_decode_sync_ref()),
                _ => unreachable!(),
            }
        }
        let api_that_guard = api_that_guard.unwrap();
 let output_ok = Result::<_,()>::Ok(crate::api::dart::api::remote_media_track::RemoteMediaTrack::media_direction(&*api_that_guard))?;   Ok(output_ok)
                })()) })
}
fn wire__crate__api__dart__api__remote_media_track__RemoteMediaTrack_media_source_kind_impl(
    ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
    rust_vec_len_: i32,
    data_len_: i32,
) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec,_>(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "RemoteMediaTrack_media_source_kind", port: None, mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync }, move || { 
            let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) };
            let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message);
            let api_that = <RustOpaqueMoi<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RemoteMediaTrack>>>::sse_decode(&mut deserializer);deserializer.end();
                transform_result_sse::<_, ()>((move || {
                    let mut api_that_guard = None;
let decode_indices_ = flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(&api_that, 0, false)]);
        for i in decode_indices_ {
            match i {
                0 => api_that_guard = Some(api_that.lockable_decode_sync_ref()),
                _ => unreachable!(),
            }
        }
        let api_that_guard = api_that_guard.unwrap();
 let output_ok = Result::<_,()>::Ok(crate::api::dart::api::remote_media_track::RemoteMediaTrack::media_source_kind(&*api_that_guard))?;   Ok(output_ok)
                })()) })
}
fn wire__crate__api__dart__api__remote_media_track__RemoteMediaTrack_muted_impl(
    ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
    rust_vec_len_: i32,
    data_len_: i32,
) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec,_>(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "RemoteMediaTrack_muted", port: None, mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync }, move || { 
            let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) };
            let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message);
            let api_that = <RustOpaqueMoi<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RemoteMediaTrack>>>::sse_decode(&mut deserializer);deserializer.end();
                transform_result_sse::<_, ()>((move || {
                    let mut api_that_guard = None;
let decode_indices_ = flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(&api_that, 0, false)]);
        for i in decode_indices_ {
            match i {
                0 => api_that_guard = Some(api_that.lockable_decode_sync_ref()),
                _ => unreachable!(),
            }
        }
        let api_that_guard = api_that_guard.unwrap();
 let output_ok = Result::<_,()>::Ok(crate::api::dart::api::remote_media_track::RemoteMediaTrack::muted(&*api_that_guard))?;   Ok(output_ok)
                })()) })
}
fn wire__crate__api__dart__api__remote_media_track__RemoteMediaTrack_on_media_direction_changed_impl(
    ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
    rust_vec_len_: i32,
    data_len_: i32,
) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec,_>(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "RemoteMediaTrack_on_media_direction_changed", port: None, mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync }, move || { 
            let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) };
            let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message);
            let api_that = <RustOpaqueMoi<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RemoteMediaTrack>>>::sse_decode(&mut deserializer);
let api_f = <flutter_rust_bridge::DartOpaque>::sse_decode(&mut deserializer);deserializer.end();
                transform_result_sse::<_, ()>((move || {
                    let mut api_that_guard = None;
let decode_indices_ = flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(&api_that, 0, false)]);
        for i in decode_indices_ {
            match i {
                0 => api_that_guard = Some(api_that.lockable_decode_sync_ref()),
                _ => unreachable!(),
            }
        }
        let api_that_guard = api_that_guard.unwrap();
 let output_ok = Result::<_,()>::Ok({ crate::api::dart::api::remote_media_track::RemoteMediaTrack::on_media_direction_changed(&*api_that_guard, api_f); })?;   Ok(output_ok)
                })()) })
}
fn wire__crate__api__dart__api__remote_media_track__RemoteMediaTrack_on_muted_impl(
    ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
    rust_vec_len_: i32,
    data_len_: i32,
) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec,_>(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "RemoteMediaTrack_on_muted", port: None, mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync }, move || { 
            let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) };
            let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message);
            let api_that = <RustOpaqueMoi<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RemoteMediaTrack>>>::sse_decode(&mut deserializer);
let api_f = <flutter_rust_bridge::DartOpaque>::sse_decode(&mut deserializer);deserializer.end();
                transform_result_sse::<_, ()>((move || {
                    let mut api_that_guard = None;
let decode_indices_ = flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(&api_that, 0, false)]);
        for i in decode_indices_ {
            match i {
                0 => api_that_guard = Some(api_that.lockable_decode_sync_ref()),
                _ => unreachable!(),
            }
        }
        let api_that_guard = api_that_guard.unwrap();
 let output_ok = Result::<_,()>::Ok({ crate::api::dart::api::remote_media_track::RemoteMediaTrack::on_muted(&*api_that_guard, api_f); })?;   Ok(output_ok)
                })()) })
}
fn wire__crate__api__dart__api__remote_media_track__RemoteMediaTrack_on_stopped_impl(
    ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
    rust_vec_len_: i32,
    data_len_: i32,
) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec,_>(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "RemoteMediaTrack_on_stopped", port: None, mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync }, move || { 
            let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) };
            let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message);
            let api_that = <RustOpaqueMoi<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RemoteMediaTrack>>>::sse_decode(&mut deserializer);
let api_f = <flutter_rust_bridge::DartOpaque>::sse_decode(&mut deserializer);deserializer.end();
                transform_result_sse::<_, ()>((move || {
                    let mut api_that_guard = None;
let decode_indices_ = flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(&api_that, 0, false)]);
        for i in decode_indices_ {
            match i {
                0 => api_that_guard = Some(api_that.lockable_decode_sync_ref()),
                _ => unreachable!(),
            }
        }
        let api_that_guard = api_that_guard.unwrap();
 let output_ok = Result::<_,()>::Ok({ crate::api::dart::api::remote_media_track::RemoteMediaTrack::on_stopped(&*api_that_guard, api_f); })?;   Ok(output_ok)
                })()) })
}
fn wire__crate__api__dart__api__remote_media_track__RemoteMediaTrack_on_unmuted_impl(
    ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
    rust_vec_len_: i32,
    data_len_: i32,
) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec,_>(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "RemoteMediaTrack_on_unmuted", port: None, mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync }, move || { 
            let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) };
            let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message);
            let api_that = <RustOpaqueMoi<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RemoteMediaTrack>>>::sse_decode(&mut deserializer);
let api_f = <flutter_rust_bridge::DartOpaque>::sse_decode(&mut deserializer);deserializer.end();
                transform_result_sse::<_, ()>((move || {
                    let mut api_that_guard = None;
let decode_indices_ = flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(&api_that, 0, false)]);
        for i in decode_indices_ {
            match i {
                0 => api_that_guard = Some(api_that.lockable_decode_sync_ref()),
                _ => unreachable!(),
            }
        }
        let api_that_guard = api_that_guard.unwrap();
 let output_ok = Result::<_,()>::Ok({ crate::api::dart::api::remote_media_track::RemoteMediaTrack::on_unmuted(&*api_that_guard, api_f); })?;   Ok(output_ok)
                })()) })
}
fn wire__crate__api__dart__api__room__RoomHandle_disable_audio_impl(
    ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
    rust_vec_len_: i32,
    data_len_: i32,
) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec,_>(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "RoomHandle_disable_audio", port: None, mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync }, move || { 
            let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) };
            let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message);
            let api_that = <RustOpaqueMoi<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RoomHandle>>>::sse_decode(&mut deserializer);
let api_source_kind = <Option<crate::media::track::MediaSourceKind>>::sse_decode(&mut deserializer);deserializer.end();
                transform_result_sse::<_, ()>((move || {
                    let mut api_that_guard = None;
let decode_indices_ = flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(&api_that, 0, false)]);
        for i in decode_indices_ {
            match i {
                0 => api_that_guard = Some(api_that.lockable_decode_sync_ref()),
                _ => unreachable!(),
            }
        }
        let api_that_guard = api_that_guard.unwrap();
 let output_ok = Result::<_,()>::Ok(crate::api::dart::api::room::RoomHandle::disable_audio(&*api_that_guard, api_source_kind))?;   Ok(output_ok)
                })()) })
}
fn wire__crate__api__dart__api__room__RoomHandle_disable_remote_audio_impl(
    ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
    rust_vec_len_: i32,
    data_len_: i32,
) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec,_>(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "RoomHandle_disable_remote_audio", port: None, mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync }, move || { 
            let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) };
            let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message);
            let api_that = <RustOpaqueMoi<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RoomHandle>>>::sse_decode(&mut deserializer);
let api_source_kind = <Option<crate::media::track::MediaSourceKind>>::sse_decode(&mut deserializer);deserializer.end();
                transform_result_sse::<_, ()>((move || {
                    let mut api_that_guard = None;
let decode_indices_ = flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(&api_that, 0, false)]);
        for i in decode_indices_ {
            match i {
                0 => api_that_guard = Some(api_that.lockable_decode_sync_ref()),
                _ => unreachable!(),
            }
        }
        let api_that_guard = api_that_guard.unwrap();
 let output_ok = Result::<_,()>::Ok(crate::api::dart::api::room::RoomHandle::disable_remote_audio(&*api_that_guard, api_source_kind))?;   Ok(output_ok)
                })()) })
}
fn wire__crate__api__dart__api__room__RoomHandle_disable_remote_video_impl(
    ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
    rust_vec_len_: i32,
    data_len_: i32,
) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec,_>(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "RoomHandle_disable_remote_video", port: None, mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync }, move || { 
            let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) };
            let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message);
            let api_that = <RustOpaqueMoi<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RoomHandle>>>::sse_decode(&mut deserializer);
let api_source_kind = <Option<crate::media::track::MediaSourceKind>>::sse_decode(&mut deserializer);deserializer.end();
                transform_result_sse::<_, ()>((move || {
                    let mut api_that_guard = None;
let decode_indices_ = flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(&api_that, 0, false)]);
        for i in decode_indices_ {
            match i {
                0 => api_that_guard = Some(api_that.lockable_decode_sync_ref()),
                _ => unreachable!(),
            }
        }
        let api_that_guard = api_that_guard.unwrap();
 let output_ok = Result::<_,()>::Ok(crate::api::dart::api::room::RoomHandle::disable_remote_video(&*api_that_guard, api_source_kind))?;   Ok(output_ok)
                })()) })
}
fn wire__crate__api__dart__api__room__RoomHandle_disable_video_impl(
    ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
    rust_vec_len_: i32,
    data_len_: i32,
) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec,_>(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "RoomHandle_disable_video", port: None, mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync }, move || { 
            let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) };
            let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message);
            let api_that = <RustOpaqueMoi<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RoomHandle>>>::sse_decode(&mut deserializer);
let api_source_kind = <Option<crate::media::track::MediaSourceKind>>::sse_decode(&mut deserializer);deserializer.end();
                transform_result_sse::<_, ()>((move || {
                    let mut api_that_guard = None;
let decode_indices_ = flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(&api_that, 0, false)]);
        for i in decode_indices_ {
            match i {
                0 => api_that_guard = Some(api_that.lockable_decode_sync_ref()),
                _ => unreachable!(),
            }
        }
        let api_that_guard = api_that_guard.unwrap();
 let output_ok = Result::<_,()>::Ok(crate::api::dart::api::room::RoomHandle::disable_video(&*api_that_guard, api_source_kind))?;   Ok(output_ok)
                })()) })
}
fn wire__crate__api__dart__api__room__RoomHandle_enable_audio_impl(
    ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
    rust_vec_len_: i32,
    data_len_: i32,
) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec,_>(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "RoomHandle_enable_audio", port: None, mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync }, move || { 
            let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) };
            let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message);
            let api_that = <RustOpaqueMoi<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RoomHandle>>>::sse_decode(&mut deserializer);
let api_source_kind = <Option<crate::media::track::MediaSourceKind>>::sse_decode(&mut deserializer);deserializer.end();
                transform_result_sse::<_, ()>((move || {
                    let mut api_that_guard = None;
let decode_indices_ = flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(&api_that, 0, false)]);
        for i in decode_indices_ {
            match i {
                0 => api_that_guard = Some(api_that.lockable_decode_sync_ref()),
                _ => unreachable!(),
            }
        }
        let api_that_guard = api_that_guard.unwrap();
 let output_ok = Result::<_,()>::Ok(crate::api::dart::api::room::RoomHandle::enable_audio(&*api_that_guard, api_source_kind))?;   Ok(output_ok)
                })()) })
}
fn wire__crate__api__dart__api__room__RoomHandle_enable_remote_audio_impl(
    ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
    rust_vec_len_: i32,
    data_len_: i32,
) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec,_>(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "RoomHandle_enable_remote_audio", port: None, mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync }, move || { 
            let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) };
            let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message);
            let api_that = <RustOpaqueMoi<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RoomHandle>>>::sse_decode(&mut deserializer);
let api_source_kind = <Option<crate::media::track::MediaSourceKind>>::sse_decode(&mut deserializer);deserializer.end();
                transform_result_sse::<_, ()>((move || {
                    let mut api_that_guard = None;
let decode_indices_ = flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(&api_that, 0, false)]);
        for i in decode_indices_ {
            match i {
                0 => api_that_guard = Some(api_that.lockable_decode_sync_ref()),
                _ => unreachable!(),
            }
        }
        let api_that_guard = api_that_guard.unwrap();
 let output_ok = Result::<_,()>::Ok(crate::api::dart::api::room::RoomHandle::enable_remote_audio(&*api_that_guard, api_source_kind))?;   Ok(output_ok)
                })()) })
}
fn wire__crate__api__dart__api__room__RoomHandle_enable_remote_video_impl(
    ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
    rust_vec_len_: i32,
    data_len_: i32,
) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec,_>(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "RoomHandle_enable_remote_video", port: None, mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync }, move || { 
            let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) };
            let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message);
            let api_that = <RustOpaqueMoi<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RoomHandle>>>::sse_decode(&mut deserializer);
let api_source_kind = <Option<crate::media::track::MediaSourceKind>>::sse_decode(&mut deserializer);deserializer.end();
                transform_result_sse::<_, ()>((move || {
                    let mut api_that_guard = None;
let decode_indices_ = flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(&api_that, 0, false)]);
        for i in decode_indices_ {
            match i {
                0 => api_that_guard = Some(api_that.lockable_decode_sync_ref()),
                _ => unreachable!(),
            }
        }
        let api_that_guard = api_that_guard.unwrap();
 let output_ok = Result::<_,()>::Ok(crate::api::dart::api::room::RoomHandle::enable_remote_video(&*api_that_guard, api_source_kind))?;   Ok(output_ok)
                })()) })
}
fn wire__crate__api__dart__api__room__RoomHandle_enable_video_impl(
    ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
    rust_vec_len_: i32,
    data_len_: i32,
) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec,_>(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "RoomHandle_enable_video", port: None, mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync }, move || { 
            let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) };
            let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message);
            let api_that = <RustOpaqueMoi<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RoomHandle>>>::sse_decode(&mut deserializer);
let api_source_kind = <Option<crate::media::track::MediaSourceKind>>::sse_decode(&mut deserializer);deserializer.end();
                transform_result_sse::<_, ()>((move || {
                    let mut api_that_guard = None;
let decode_indices_ = flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(&api_that, 0, false)]);
        for i in decode_indices_ {
            match i {
                0 => api_that_guard = Some(api_that.lockable_decode_sync_ref()),
                _ => unreachable!(),
            }
        }
        let api_that_guard = api_that_guard.unwrap();
 let output_ok = Result::<_,()>::Ok(crate::api::dart::api::room::RoomHandle::enable_video(&*api_that_guard, api_source_kind))?;   Ok(output_ok)
                })()) })
}
fn wire__crate__api__dart__api__room__RoomHandle_join_impl(
    ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
    rust_vec_len_: i32,
    data_len_: i32,
) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec,_>(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "RoomHandle_join", port: None, mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync }, move || { 
            let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) };
            let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message);
            let api_that = <RustOpaqueMoi<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RoomHandle>>>::sse_decode(&mut deserializer);
let api_token = <String>::sse_decode(&mut deserializer);deserializer.end();
                transform_result_sse::<_, ()>((move || {
                    let mut api_that_guard = None;
let decode_indices_ = flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(&api_that, 0, false)]);
        for i in decode_indices_ {
            match i {
                0 => api_that_guard = Some(api_that.lockable_decode_sync_ref()),
                _ => unreachable!(),
            }
        }
        let api_that_guard = api_that_guard.unwrap();
 let output_ok = Result::<_,()>::Ok(crate::api::dart::api::room::RoomHandle::join(&*api_that_guard, api_token))?;   Ok(output_ok)
                })()) })
}
fn wire__crate__api__dart__api__room__RoomHandle_mute_audio_impl(
    ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
    rust_vec_len_: i32,
    data_len_: i32,
) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec,_>(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "RoomHandle_mute_audio", port: None, mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync }, move || { 
            let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) };
            let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message);
            let api_that = <RustOpaqueMoi<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RoomHandle>>>::sse_decode(&mut deserializer);
let api_source_kind = <Option<crate::media::track::MediaSourceKind>>::sse_decode(&mut deserializer);deserializer.end();
                transform_result_sse::<_, ()>((move || {
                    let mut api_that_guard = None;
let decode_indices_ = flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(&api_that, 0, false)]);
        for i in decode_indices_ {
            match i {
                0 => api_that_guard = Some(api_that.lockable_decode_sync_ref()),
                _ => unreachable!(),
            }
        }
        let api_that_guard = api_that_guard.unwrap();
 let output_ok = Result::<_,()>::Ok(crate::api::dart::api::room::RoomHandle::mute_audio(&*api_that_guard, api_source_kind))?;   Ok(output_ok)
                })()) })
}
fn wire__crate__api__dart__api__room__RoomHandle_mute_video_impl(
    ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
    rust_vec_len_: i32,
    data_len_: i32,
) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec,_>(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "RoomHandle_mute_video", port: None, mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync }, move || { 
            let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) };
            let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message);
            let api_that = <RustOpaqueMoi<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RoomHandle>>>::sse_decode(&mut deserializer);
let api_source_kind = <Option<crate::media::track::MediaSourceKind>>::sse_decode(&mut deserializer);deserializer.end();
                transform_result_sse::<_, ()>((move || {
                    let mut api_that_guard = None;
let decode_indices_ = flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(&api_that, 0, false)]);
        for i in decode_indices_ {
            match i {
                0 => api_that_guard = Some(api_that.lockable_decode_sync_ref()),
                _ => unreachable!(),
            }
        }
        let api_that_guard = api_that_guard.unwrap();
 let output_ok = Result::<_,()>::Ok(crate::api::dart::api::room::RoomHandle::mute_video(&*api_that_guard, api_source_kind))?;   Ok(output_ok)
                })()) })
}
fn wire__crate__api__dart__api__room__RoomHandle_on_close_impl(
    ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
    rust_vec_len_: i32,
    data_len_: i32,
) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec,_>(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "RoomHandle_on_close", port: None, mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync }, move || { 
            let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) };
            let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message);
            let api_that = <RustOpaqueMoi<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RoomHandle>>>::sse_decode(&mut deserializer);
let api_cb = <flutter_rust_bridge::DartOpaque>::sse_decode(&mut deserializer);deserializer.end();
                transform_result_sse::<_, flutter_rust_bridge::DartOpaque>((move || {
                    let mut api_that_guard = None;
let decode_indices_ = flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(&api_that, 0, false)]);
        for i in decode_indices_ {
            match i {
                0 => api_that_guard = Some(api_that.lockable_decode_sync_ref()),
                _ => unreachable!(),
            }
        }
        let api_that_guard = api_that_guard.unwrap();
 let output_ok = crate::api::dart::api::room::RoomHandle::on_close(&*api_that_guard, api_cb)?;   Ok(output_ok)
                })()) })
}
fn wire__crate__api__dart__api__room__RoomHandle_on_connection_loss_impl(
    ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
    rust_vec_len_: i32,
    data_len_: i32,
) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec,_>(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "RoomHandle_on_connection_loss", port: None, mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync }, move || { 
            let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) };
            let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message);
            let api_that = <RustOpaqueMoi<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RoomHandle>>>::sse_decode(&mut deserializer);
let api_cb = <flutter_rust_bridge::DartOpaque>::sse_decode(&mut deserializer);deserializer.end();
                transform_result_sse::<_, flutter_rust_bridge::DartOpaque>((move || {
                    let mut api_that_guard = None;
let decode_indices_ = flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(&api_that, 0, false)]);
        for i in decode_indices_ {
            match i {
                0 => api_that_guard = Some(api_that.lockable_decode_sync_ref()),
                _ => unreachable!(),
            }
        }
        let api_that_guard = api_that_guard.unwrap();
 let output_ok = crate::api::dart::api::room::RoomHandle::on_connection_loss(&*api_that_guard, api_cb)?;   Ok(output_ok)
                })()) })
}
fn wire__crate__api__dart__api__room__RoomHandle_on_failed_local_media_impl(
    ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
    rust_vec_len_: i32,
    data_len_: i32,
) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec,_>(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "RoomHandle_on_failed_local_media", port: None, mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync }, move || { 
            let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) };
            let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message);
            let api_that = <RustOpaqueMoi<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RoomHandle>>>::sse_decode(&mut deserializer);
let api_cb = <flutter_rust_bridge::DartOpaque>::sse_decode(&mut deserializer);deserializer.end();
                transform_result_sse::<_, flutter_rust_bridge::DartOpaque>((move || {
                    let mut api_that_guard = None;
let decode_indices_ = flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(&api_that, 0, false)]);
        for i in decode_indices_ {
            match i {
                0 => api_that_guard = Some(api_that.lockable_decode_sync_ref()),
                _ => unreachable!(),
            }
        }
        let api_that_guard = api_that_guard.unwrap();
 let output_ok = crate::api::dart::api::room::RoomHandle::on_failed_local_media(&*api_that_guard, api_cb)?;   Ok(output_ok)
                })()) })
}
fn wire__crate__api__dart__api__room__RoomHandle_on_local_track_impl(
    ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
    rust_vec_len_: i32,
    data_len_: i32,
) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec,_>(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "RoomHandle_on_local_track", port: None, mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync }, move || { 
            let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) };
            let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message);
            let api_that = <RustOpaqueMoi<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RoomHandle>>>::sse_decode(&mut deserializer);
let api_cb = <flutter_rust_bridge::DartOpaque>::sse_decode(&mut deserializer);deserializer.end();
                transform_result_sse::<_, flutter_rust_bridge::DartOpaque>((move || {
                    let mut api_that_guard = None;
let decode_indices_ = flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(&api_that, 0, false)]);
        for i in decode_indices_ {
            match i {
                0 => api_that_guard = Some(api_that.lockable_decode_sync_ref()),
                _ => unreachable!(),
            }
        }
        let api_that_guard = api_that_guard.unwrap();
 let output_ok = crate::api::dart::api::room::RoomHandle::on_local_track(&*api_that_guard, api_cb)?;   Ok(output_ok)
                })()) })
}
fn wire__crate__api__dart__api__room__RoomHandle_on_new_connection_impl(
    ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
    rust_vec_len_: i32,
    data_len_: i32,
) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec,_>(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "RoomHandle_on_new_connection", port: None, mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync }, move || { 
            let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) };
            let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message);
            let api_that = <RustOpaqueMoi<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RoomHandle>>>::sse_decode(&mut deserializer);
let api_cb = <flutter_rust_bridge::DartOpaque>::sse_decode(&mut deserializer);deserializer.end();
                transform_result_sse::<_, flutter_rust_bridge::DartOpaque>((move || {
                    let mut api_that_guard = None;
let decode_indices_ = flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(&api_that, 0, false)]);
        for i in decode_indices_ {
            match i {
                0 => api_that_guard = Some(api_that.lockable_decode_sync_ref()),
                _ => unreachable!(),
            }
        }
        let api_that_guard = api_that_guard.unwrap();
 let output_ok = crate::api::dart::api::room::RoomHandle::on_new_connection(&*api_that_guard, api_cb)?;   Ok(output_ok)
                })()) })
}
fn wire__crate__api__dart__api__room__RoomHandle_set_local_media_settings_impl(
    ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
    rust_vec_len_: i32,
    data_len_: i32,
) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec,_>(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "RoomHandle_set_local_media_settings", port: None, mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync }, move || { 
            let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) };
            let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message);
            let api_that = <RustOpaqueMoi<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RoomHandle>>>::sse_decode(&mut deserializer);
let api_settings = <crate::api::dart::api::ApiMediaStreamSettings>::sse_decode(&mut deserializer);
let api_stop_first = <bool>::sse_decode(&mut deserializer);
let api_rollback_on_fail = <bool>::sse_decode(&mut deserializer);deserializer.end();
                transform_result_sse::<_, ()>((move || {
                    let mut api_that_guard = None;
let decode_indices_ = flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(&api_that, 0, false)]);
        for i in decode_indices_ {
            match i {
                0 => api_that_guard = Some(api_that.lockable_decode_sync_ref()),
                _ => unreachable!(),
            }
        }
        let api_that_guard = api_that_guard.unwrap();
 let output_ok = Result::<_,()>::Ok(crate::api::dart::api::room::RoomHandle::set_local_media_settings(&*api_that_guard, api_settings, api_stop_first, api_rollback_on_fail))?;   Ok(output_ok)
                })()) })
}
fn wire__crate__api__dart__api__room__RoomHandle_unmute_audio_impl(
    ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
    rust_vec_len_: i32,
    data_len_: i32,
) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec,_>(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "RoomHandle_unmute_audio", port: None, mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync }, move || { 
            let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) };
            let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message);
            let api_that = <RustOpaqueMoi<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RoomHandle>>>::sse_decode(&mut deserializer);
let api_source_kind = <Option<crate::media::track::MediaSourceKind>>::sse_decode(&mut deserializer);deserializer.end();
                transform_result_sse::<_, ()>((move || {
                    let mut api_that_guard = None;
let decode_indices_ = flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(&api_that, 0, false)]);
        for i in decode_indices_ {
            match i {
                0 => api_that_guard = Some(api_that.lockable_decode_sync_ref()),
                _ => unreachable!(),
            }
        }
        let api_that_guard = api_that_guard.unwrap();
 let output_ok = Result::<_,()>::Ok(crate::api::dart::api::room::RoomHandle::unmute_audio(&*api_that_guard, api_source_kind))?;   Ok(output_ok)
                })()) })
}
fn wire__crate__api__dart__api__room__RoomHandle_unmute_video_impl(
    ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
    rust_vec_len_: i32,
    data_len_: i32,
) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec,_>(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "RoomHandle_unmute_video", port: None, mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync }, move || { 
            let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) };
            let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message);
            let api_that = <RustOpaqueMoi<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RoomHandle>>>::sse_decode(&mut deserializer);
let api_source_kind = <Option<crate::media::track::MediaSourceKind>>::sse_decode(&mut deserializer);deserializer.end();
                transform_result_sse::<_, ()>((move || {
                    let mut api_that_guard = None;
let decode_indices_ = flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(&api_that, 0, false)]);
        for i in decode_indices_ {
            match i {
                0 => api_that_guard = Some(api_that.lockable_decode_sync_ref()),
                _ => unreachable!(),
            }
        }
        let api_that_guard = api_that_guard.unwrap();
 let output_ok = Result::<_,()>::Ok(crate::api::dart::api::room::RoomHandle::unmute_video(&*api_that_guard, api_source_kind))?;   Ok(output_ok)
                })()) })
}
fn wire__crate__api__dart__api__log_dart_exception_impl(
    ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
    rust_vec_len_: i32,
    data_len_: i32,
) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec,_>(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "log_dart_exception", port: None, mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync }, move || { 
            let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) };
            let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message);
            let api_message = <String>::sse_decode(&mut deserializer);
let api_stack_trace = <String>::sse_decode(&mut deserializer);deserializer.end();
                transform_result_sse::<_, ()>((move || {
                     let output_ok = Result::<_,()>::Ok({ crate::api::dart::api::log_dart_exception(api_message, api_stack_trace); })?;   Ok(output_ok)
                })()) })
}
fn wire__crate__api__dart__api__member_connection_state__member_connection_state_from_ptr_impl(
    ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
    rust_vec_len_: i32,
    data_len_: i32,
) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec,_>(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "member_connection_state_from_ptr", port: None, mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync }, move || { 
            let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) };
            let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message);
            let api_ptr = <usize>::sse_decode(&mut deserializer);deserializer.end();
                transform_result_sse::<_, ()>((move || {
                     let output_ok = Result::<_,()>::Ok(crate::api::dart::api::member_connection_state::MemberConnectionState::from_ptr(api_ptr))?;   Ok(output_ok)
                })()) })
}
fn wire__crate__api__dart__api__on_panic_impl(
    ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
    rust_vec_len_: i32,
    data_len_: i32,
) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec,_>(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "on_panic", port: None, mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync }, move || { 
            let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) };
            let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message);
            let api_cb = <flutter_rust_bridge::DartOpaque>::sse_decode(&mut deserializer);deserializer.end();
                transform_result_sse::<_, ()>((move || {
                     let output_ok = Result::<_,()>::Ok({ crate::api::dart::api::on_panic(api_cb); })?;   Ok(output_ok)
                })()) })
}
fn wire__crate__api__dart__api__room_close_reason__room_close_reason_from_ptr_impl(
    ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
    rust_vec_len_: i32,
    data_len_: i32,
) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec,_>(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "room_close_reason_from_ptr", port: None, mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync }, move || { 
            let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) };
            let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message);
            let api_ptr = <usize>::sse_decode(&mut deserializer);deserializer.end();
                transform_result_sse::<_, ()>((move || {
                     let output_ok = Result::<_,()>::Ok(crate::api::dart::api::room_close_reason::RoomCloseReason::from_ptr(api_ptr))?;   Ok(output_ok)
                })()) })
}
fn wire__crate__api__dart__api__set_dart_opaque_message_port_impl(
    ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
    rust_vec_len_: i32,
    data_len_: i32,
) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec,_>(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "set_dart_opaque_message_port", port: None, mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync }, move || { 
            let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) };
            let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message);
            let api_dart_handler_port = <i64>::sse_decode(&mut deserializer);deserializer.end();
                transform_result_sse::<_, ()>((move || {
                     let output_ok = Result::<_,()>::Ok({ crate::api::dart::api::set_dart_opaque_message_port(api_dart_handler_port); })?;   Ok(output_ok)
                })()) })
}
fn wire__crate__api__dart__api__local_media_track__vec_local_tracks_from_raw_impl(
    ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
    rust_vec_len_: i32,
    data_len_: i32,
) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec,_>(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "vec_local_tracks_from_raw", port: None, mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync }, move || { 
            let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) };
            let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message);
            let api_ptr = <usize>::sse_decode(&mut deserializer);deserializer.end();
                transform_result_sse::<_, ()>((move || {
                     let output_ok = Result::<_,()>::Ok(crate::api::dart::api::local_media_track::vec_local_tracks_from_raw(api_ptr))?;   Ok(output_ok)
                })()) })
}
fn wire__crate__api__dart__api__vec_media_device_details_from_raw_impl(
    ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
    rust_vec_len_: i32,
    data_len_: i32,
) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec,_>(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "vec_media_device_details_from_raw", port: None, mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync }, move || { 
            let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) };
            let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message);
            let api_ptr = <usize>::sse_decode(&mut deserializer);deserializer.end();
                transform_result_sse::<_, ()>((move || {
                     let output_ok = Result::<_,()>::Ok(crate::api::dart::api::vec_media_device_details_from_raw(api_ptr))?;   Ok(output_ok)
                })()) })
}
fn wire__crate__api__dart__api__vec_media_display_details_from_raw_impl(
    ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
    rust_vec_len_: i32,
    data_len_: i32,
) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec,_>(flutter_rust_bridge::for_generated::TaskInfo{ debug_name: "vec_media_display_details_from_raw", port: None, mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync }, move || { 
            let message = unsafe { flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(ptr_, rust_vec_len_, data_len_) };
            let mut deserializer = flutter_rust_bridge::for_generated::SseDeserializer::new(message);
            let api_ptr = <usize>::sse_decode(&mut deserializer);deserializer.end();
                transform_result_sse::<_, ()>((move || {
                     let output_ok = Result::<_,()>::Ok(crate::api::dart::api::vec_media_display_details_from_raw(api_ptr))?;   Ok(output_ok)
                })()) })
}

// Section: related_funcs

flutter_rust_bridge::frb_generated_moi_arc_impl_value!(
    flutter_rust_bridge::for_generated::RustAutoOpaqueInner<ConnectionHandle>
);
flutter_rust_bridge::frb_generated_moi_arc_impl_value!(
    flutter_rust_bridge::for_generated::RustAutoOpaqueInner<Jason>
);
flutter_rust_bridge::frb_generated_moi_arc_impl_value!(
    flutter_rust_bridge::for_generated::RustAutoOpaqueInner<LocalMediaTrack>
);
flutter_rust_bridge::frb_generated_moi_arc_impl_value!(
    flutter_rust_bridge::for_generated::RustAutoOpaqueInner<MediaManagerHandle>
);
flutter_rust_bridge::frb_generated_moi_arc_impl_value!(
    flutter_rust_bridge::for_generated::RustAutoOpaqueInner<ReconnectHandle>
);
flutter_rust_bridge::frb_generated_moi_arc_impl_value!(
    flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RemoteMediaTrack>
);
flutter_rust_bridge::frb_generated_moi_arc_impl_value!(
    flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RoomHandle>
);

// Section: dart2rust

impl SseDecode for ConnectionHandle {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_decode(
        deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer,
    ) -> Self {
        let mut inner = <RustOpaqueMoi<
            flutter_rust_bridge::for_generated::RustAutoOpaqueInner<
                ConnectionHandle,
            >,
        >>::sse_decode(deserializer);
        return flutter_rust_bridge::for_generated::rust_auto_opaque_decode_owned(inner);
    }
}

impl SseDecode for Jason {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_decode(
        deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer,
    ) -> Self {
        let mut inner = <RustOpaqueMoi<
            flutter_rust_bridge::for_generated::RustAutoOpaqueInner<Jason>,
        >>::sse_decode(deserializer);
        return flutter_rust_bridge::for_generated::rust_auto_opaque_decode_owned(inner);
    }
}

impl SseDecode for LocalMediaTrack {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_decode(
        deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer,
    ) -> Self {
        let mut inner = <RustOpaqueMoi<
            flutter_rust_bridge::for_generated::RustAutoOpaqueInner<
                LocalMediaTrack,
            >,
        >>::sse_decode(deserializer);
        return flutter_rust_bridge::for_generated::rust_auto_opaque_decode_owned(inner);
    }
}

impl SseDecode for MediaManagerHandle {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_decode(
        deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer,
    ) -> Self {
        let mut inner = <RustOpaqueMoi<
            flutter_rust_bridge::for_generated::RustAutoOpaqueInner<
                MediaManagerHandle,
            >,
        >>::sse_decode(deserializer);
        return flutter_rust_bridge::for_generated::rust_auto_opaque_decode_owned(inner);
    }
}

impl SseDecode for ReconnectHandle {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_decode(
        deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer,
    ) -> Self {
        let mut inner = <RustOpaqueMoi<
            flutter_rust_bridge::for_generated::RustAutoOpaqueInner<
                ReconnectHandle,
            >,
        >>::sse_decode(deserializer);
        return flutter_rust_bridge::for_generated::rust_auto_opaque_decode_owned(inner);
    }
}

impl SseDecode for RemoteMediaTrack {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_decode(
        deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer,
    ) -> Self {
        let mut inner = <RustOpaqueMoi<
            flutter_rust_bridge::for_generated::RustAutoOpaqueInner<
                RemoteMediaTrack,
            >,
        >>::sse_decode(deserializer);
        return flutter_rust_bridge::for_generated::rust_auto_opaque_decode_owned(inner);
    }
}

impl SseDecode for RoomHandle {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_decode(
        deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer,
    ) -> Self {
        let mut inner = <RustOpaqueMoi<
            flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RoomHandle>,
        >>::sse_decode(deserializer);
        return flutter_rust_bridge::for_generated::rust_auto_opaque_decode_owned(inner);
    }
}

impl SseDecode for flutter_rust_bridge::DartOpaque {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_decode(
        deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer,
    ) -> Self {
        let mut inner = <usize>::sse_decode(deserializer);
        return unsafe {
            flutter_rust_bridge::for_generated::sse_decode_dart_opaque(inner)
        };
    }
}

impl SseDecode
    for RustOpaqueMoi<
        flutter_rust_bridge::for_generated::RustAutoOpaqueInner<
            ConnectionHandle,
        >,
    >
{
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_decode(
        deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer,
    ) -> Self {
        let mut inner = <usize>::sse_decode(deserializer);
        return decode_rust_opaque_moi(inner);
    }
}

impl SseDecode
    for RustOpaqueMoi<
        flutter_rust_bridge::for_generated::RustAutoOpaqueInner<Jason>,
    >
{
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_decode(
        deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer,
    ) -> Self {
        let mut inner = <usize>::sse_decode(deserializer);
        return decode_rust_opaque_moi(inner);
    }
}

impl SseDecode
    for RustOpaqueMoi<
        flutter_rust_bridge::for_generated::RustAutoOpaqueInner<
            LocalMediaTrack,
        >,
    >
{
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_decode(
        deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer,
    ) -> Self {
        let mut inner = <usize>::sse_decode(deserializer);
        return decode_rust_opaque_moi(inner);
    }
}

impl SseDecode
    for RustOpaqueMoi<
        flutter_rust_bridge::for_generated::RustAutoOpaqueInner<
            MediaManagerHandle,
        >,
    >
{
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_decode(
        deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer,
    ) -> Self {
        let mut inner = <usize>::sse_decode(deserializer);
        return decode_rust_opaque_moi(inner);
    }
}

impl SseDecode
    for RustOpaqueMoi<
        flutter_rust_bridge::for_generated::RustAutoOpaqueInner<
            ReconnectHandle,
        >,
    >
{
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_decode(
        deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer,
    ) -> Self {
        let mut inner = <usize>::sse_decode(deserializer);
        return decode_rust_opaque_moi(inner);
    }
}

impl SseDecode
    for RustOpaqueMoi<
        flutter_rust_bridge::for_generated::RustAutoOpaqueInner<
            RemoteMediaTrack,
        >,
    >
{
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_decode(
        deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer,
    ) -> Self {
        let mut inner = <usize>::sse_decode(deserializer);
        return decode_rust_opaque_moi(inner);
    }
}

impl SseDecode
    for RustOpaqueMoi<
        flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RoomHandle>,
    >
{
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_decode(
        deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer,
    ) -> Self {
        let mut inner = <usize>::sse_decode(deserializer);
        return decode_rust_opaque_moi(inner);
    }
}

impl SseDecode for String {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_decode(
        deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer,
    ) -> Self {
        let mut inner = <Vec<u8>>::sse_decode(deserializer);
        return String::from_utf8(inner).unwrap();
    }
}

impl SseDecode for crate::api::dart::api::ApiConstrainFacingMode {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_decode(
        deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer,
    ) -> Self {
        let mut tag_ = <i32>::sse_decode(deserializer);
        match tag_ {
            0 => {
                let mut var_field0 =
                    <crate::media::constraints::FacingMode>::sse_decode(
                        deserializer,
                    );
                return crate::api::dart::api::ApiConstrainFacingMode::Exact(
                    var_field0,
                );
            }
            1 => {
                let mut var_field0 =
                    <crate::media::constraints::FacingMode>::sse_decode(
                        deserializer,
                    );
                return crate::api::dart::api::ApiConstrainFacingMode::Ideal(
                    var_field0,
                );
            }
            _ => {
                unimplemented!("");
            }
        }
    }
}

impl SseDecode for crate::api::dart::api::ApiDeviceAudioTrackConstraints {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_decode(
        deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer,
    ) -> Self {
        let mut var_deviceId = <Option<String>>::sse_decode(deserializer);
        let mut var_autoGainControl = <Option<
            crate::media::constraints::ConstrainBoolean,
        >>::sse_decode(deserializer);
        let mut var_noiseSuppression = <Option<
            crate::media::constraints::ConstrainBoolean,
        >>::sse_decode(deserializer);
        let mut var_noiseSuppressionLevel = <Option<
            crate::media::constraints::NoiseSuppressionLevel,
        >>::sse_decode(deserializer);
        let mut var_echoCancellation = <Option<
            crate::media::constraints::ConstrainBoolean,
        >>::sse_decode(deserializer);
        let mut var_highPassFilter = <Option<
            crate::media::constraints::ConstrainBoolean,
        >>::sse_decode(deserializer);
        return crate::api::dart::api::ApiDeviceAudioTrackConstraints {
            device_id: var_deviceId,
            auto_gain_control: var_autoGainControl,
            noise_suppression: var_noiseSuppression,
            noise_suppression_level: var_noiseSuppressionLevel,
            echo_cancellation: var_echoCancellation,
            high_pass_filter: var_highPassFilter,
        };
    }
}

impl SseDecode for crate::api::dart::api::ApiDeviceVideoTrackConstraints {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_decode(
        deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer,
    ) -> Self {
        let mut var_deviceId = <Option<String>>::sse_decode(deserializer);
        let mut var_facingMode = <Option<
            crate::api::dart::api::ApiConstrainFacingMode,
        >>::sse_decode(deserializer);
        let mut var_height =
            <Option<crate::media::constraints::ConstrainU32>>::sse_decode(
                deserializer,
            );
        let mut var_width =
            <Option<crate::media::constraints::ConstrainU32>>::sse_decode(
                deserializer,
            );
        return crate::api::dart::api::ApiDeviceVideoTrackConstraints {
            device_id: var_deviceId,
            facing_mode: var_facingMode,
            height: var_height,
            width: var_width,
        };
    }
}

impl SseDecode for crate::api::dart::api::ApiDisplayAudioTrackConstraints {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_decode(
        deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer,
    ) -> Self {
        return crate::api::dart::api::ApiDisplayAudioTrackConstraints {};
    }
}

impl SseDecode for crate::api::dart::api::ApiDisplayVideoTrackConstraints {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_decode(
        deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer,
    ) -> Self {
        let mut var_deviceId = <Option<String>>::sse_decode(deserializer);
        let mut var_height =
            <Option<crate::media::constraints::ConstrainU32>>::sse_decode(
                deserializer,
            );
        let mut var_width =
            <Option<crate::media::constraints::ConstrainU32>>::sse_decode(
                deserializer,
            );
        let mut var_frameRate =
            <Option<crate::media::constraints::ConstrainU32>>::sse_decode(
                deserializer,
            );
        return crate::api::dart::api::ApiDisplayVideoTrackConstraints {
            device_id: var_deviceId,
            height: var_height,
            width: var_width,
            frame_rate: var_frameRate,
        };
    }
}

impl SseDecode for crate::api::dart::api::ApiMediaDeviceDetails {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_decode(
        deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer,
    ) -> Self {
        let mut var_kind =
            <crate::media::MediaDeviceKind>::sse_decode(deserializer);
        let mut var_deviceId = <String>::sse_decode(deserializer);
        let mut var_label = <String>::sse_decode(deserializer);
        let mut var_audioDeviceKind =
            <Option<crate::media::AudioDeviceKind>>::sse_decode(deserializer);
        let mut var_groupId = <Option<String>>::sse_decode(deserializer);
        let mut var_isFailed = <bool>::sse_decode(deserializer);
        return crate::api::dart::api::ApiMediaDeviceDetails {
            kind: var_kind,
            device_id: var_deviceId,
            label: var_label,
            audio_device_kind: var_audioDeviceKind,
            group_id: var_groupId,
            is_failed: var_isFailed,
        };
    }
}

impl SseDecode for crate::api::dart::api::ApiMediaDisplayDetails {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_decode(
        deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer,
    ) -> Self {
        let mut var_deviceId = <String>::sse_decode(deserializer);
        let mut var_title = <Option<String>>::sse_decode(deserializer);
        return crate::api::dart::api::ApiMediaDisplayDetails {
            device_id: var_deviceId,
            title: var_title,
        };
    }
}

impl SseDecode for crate::api::dart::api::ApiMediaStreamSettings {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_decode(
        deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer,
    ) -> Self {
        let mut var_deviceAudio = <Option<
            crate::api::dart::api::ApiDeviceAudioTrackConstraints,
        >>::sse_decode(deserializer);
        let mut var_displayAudio = <Option<
            crate::api::dart::api::ApiDisplayAudioTrackConstraints,
        >>::sse_decode(deserializer);
        let mut var_deviceVideo = <Option<
            crate::api::dart::api::ApiDeviceVideoTrackConstraints,
        >>::sse_decode(deserializer);
        let mut var_displayVideo = <Option<
            crate::api::dart::api::ApiDisplayVideoTrackConstraints,
        >>::sse_decode(deserializer);
        return crate::api::dart::api::ApiMediaStreamSettings {
            device_audio: var_deviceAudio,
            display_audio: var_displayAudio,
            device_video: var_deviceVideo,
            display_video: var_displayVideo,
        };
    }
}

impl SseDecode for crate::media::AudioDeviceKind {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_decode(
        deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer,
    ) -> Self {
        let mut inner = <i32>::sse_decode(deserializer);
        return match inner {
            0 => crate::media::AudioDeviceKind::EarSpeaker,
            1 => crate::media::AudioDeviceKind::Speakerphone,
            2 => crate::media::AudioDeviceKind::WiredHeadphones,
            3 => crate::media::AudioDeviceKind::WiredHeadset,
            4 => crate::media::AudioDeviceKind::UsbHeadphones,
            5 => crate::media::AudioDeviceKind::UsbHeadset,
            6 => crate::media::AudioDeviceKind::BluetoothHeadphones,
            7 => crate::media::AudioDeviceKind::BluetoothHeadset,
            _ => unreachable!("Invalid variant for AudioDeviceKind: {}", inner),
        };
    }
}

impl SseDecode for bool {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_decode(
        deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer,
    ) -> Self {
        deserializer.cursor.read_u8().unwrap() != 0
    }
}

impl SseDecode for crate::media::constraints::ConstrainBoolean {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_decode(
        deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer,
    ) -> Self {
        let mut tag_ = <i32>::sse_decode(deserializer);
        match tag_ {
            0 => {
                let mut var_field0 = <bool>::sse_decode(deserializer);
                return crate::media::constraints::ConstrainBoolean::Exact(
                    var_field0,
                );
            }
            1 => {
                let mut var_field0 = <bool>::sse_decode(deserializer);
                return crate::media::constraints::ConstrainBoolean::Ideal(
                    var_field0,
                );
            }
            _ => {
                unimplemented!("");
            }
        }
    }
}

impl SseDecode for crate::media::constraints::ConstrainU32 {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_decode(
        deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer,
    ) -> Self {
        let mut tag_ = <i32>::sse_decode(deserializer);
        match tag_ {
            0 => {
                let mut var_field0 = <u32>::sse_decode(deserializer);
                return crate::media::constraints::ConstrainU32::Exact(
                    var_field0,
                );
            }
            1 => {
                let mut var_field0 = <u32>::sse_decode(deserializer);
                return crate::media::constraints::ConstrainU32::Ideal(
                    var_field0,
                );
            }
            2 => {
                let mut var_field0 = <u32>::sse_decode(deserializer);
                let mut var_field1 = <u32>::sse_decode(deserializer);
                return crate::media::constraints::ConstrainU32::Range(
                    var_field0, var_field1,
                );
            }
            _ => {
                unimplemented!("");
            }
        }
    }
}

impl SseDecode for f64 {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_decode(
        deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer,
    ) -> Self {
        deserializer.cursor.read_f64::<NativeEndian>().unwrap()
    }
}

impl SseDecode for crate::media::constraints::FacingMode {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_decode(
        deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer,
    ) -> Self {
        let mut inner = <i32>::sse_decode(deserializer);
        return match inner {
            0 => crate::media::constraints::FacingMode::User,
            1 => crate::media::constraints::FacingMode::Environment,
            2 => crate::media::constraints::FacingMode::Left,
            3 => crate::media::constraints::FacingMode::Right,
            _ => unreachable!("Invalid variant for FacingMode: {}", inner),
        };
    }
}

impl SseDecode for i32 {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_decode(
        deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer,
    ) -> Self {
        deserializer.cursor.read_i32::<NativeEndian>().unwrap()
    }
}

impl SseDecode for i64 {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_decode(
        deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer,
    ) -> Self {
        deserializer.cursor.read_i64::<NativeEndian>().unwrap()
    }
}

impl SseDecode for isize {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_decode(
        deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer,
    ) -> Self {
        deserializer.cursor.read_i64::<NativeEndian>().unwrap() as _
    }
}

impl SseDecode for Vec<LocalMediaTrack> {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_decode(
        deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer,
    ) -> Self {
        let mut len_ = <i32>::sse_decode(deserializer);
        let mut ans_ = vec![];
        for idx_ in 0..len_ {
            ans_.push(<LocalMediaTrack>::sse_decode(deserializer));
        }
        return ans_;
    }
}

impl SseDecode for Vec<crate::api::dart::api::ApiMediaDeviceDetails> {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_decode(
        deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer,
    ) -> Self {
        let mut len_ = <i32>::sse_decode(deserializer);
        let mut ans_ = vec![];
        for idx_ in 0..len_ {
            ans_.push(
                <crate::api::dart::api::ApiMediaDeviceDetails>::sse_decode(
                    deserializer,
                ),
            );
        }
        return ans_;
    }
}

impl SseDecode for Vec<crate::api::dart::api::ApiMediaDisplayDetails> {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_decode(
        deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer,
    ) -> Self {
        let mut len_ = <i32>::sse_decode(deserializer);
        let mut ans_ = vec![];
        for idx_ in 0..len_ {
            ans_.push(
                <crate::api::dart::api::ApiMediaDisplayDetails>::sse_decode(
                    deserializer,
                ),
            );
        }
        return ans_;
    }
}

impl SseDecode for Vec<u8> {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_decode(
        deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer,
    ) -> Self {
        let mut len_ = <i32>::sse_decode(deserializer);
        let mut ans_ = vec![];
        for idx_ in 0..len_ {
            ans_.push(<u8>::sse_decode(deserializer));
        }
        return ans_;
    }
}

impl SseDecode for crate::media::MediaDeviceKind {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_decode(
        deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer,
    ) -> Self {
        let mut inner = <i32>::sse_decode(deserializer);
        return match inner {
            0 => crate::media::MediaDeviceKind::AudioInput,
            1 => crate::media::MediaDeviceKind::VideoInput,
            2 => crate::media::MediaDeviceKind::AudioOutput,
            _ => unreachable!("Invalid variant for MediaDeviceKind: {}", inner),
        };
    }
}

impl SseDecode for crate::media::track::remote::MediaDirection {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_decode(
        deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer,
    ) -> Self {
        let mut inner = <i32>::sse_decode(deserializer);
        return match inner {
            0 => crate::media::track::remote::MediaDirection::SendRecv,
            1 => crate::media::track::remote::MediaDirection::SendOnly,
            2 => crate::media::track::remote::MediaDirection::RecvOnly,
            3 => crate::media::track::remote::MediaDirection::Inactive,
            _ => unreachable!("Invalid variant for MediaDirection: {}", inner),
        };
    }
}

impl SseDecode for crate::media::MediaKind {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_decode(
        deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer,
    ) -> Self {
        let mut inner = <i32>::sse_decode(deserializer);
        return match inner {
            0 => crate::media::MediaKind::Audio,
            1 => crate::media::MediaKind::Video,
            _ => unreachable!("Invalid variant for MediaKind: {}", inner),
        };
    }
}

impl SseDecode for crate::media::track::MediaSourceKind {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_decode(
        deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer,
    ) -> Self {
        let mut inner = <i32>::sse_decode(deserializer);
        return match inner {
            0 => crate::media::track::MediaSourceKind::Device,
            1 => crate::media::track::MediaSourceKind::Display,
            _ => unreachable!("Invalid variant for MediaSourceKind: {}", inner),
        };
    }
}

impl SseDecode
    for crate::api::dart::api::member_connection_state::MemberConnectionState
{
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_decode(
        deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer,
    ) -> Self {
        let mut tag_ = <i32>::sse_decode(deserializer);
        match tag_ {
            0 => {
                let mut var_field0 =
                    <crate::api::shared::PeerConnectionState>::sse_decode(
                        deserializer,
                    );
                return crate::api::dart::api::member_connection_state::MemberConnectionState::P2P(var_field0);
            }
            _ => {
                unimplemented!("");
            }
        }
    }
}

impl SseDecode for crate::media::constraints::NoiseSuppressionLevel {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_decode(
        deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer,
    ) -> Self {
        let mut inner = <i32>::sse_decode(deserializer);
        return match inner {
            0 => crate::media::constraints::NoiseSuppressionLevel::Low,
            1 => crate::media::constraints::NoiseSuppressionLevel::Moderate,
            2 => crate::media::constraints::NoiseSuppressionLevel::High,
            3 => crate::media::constraints::NoiseSuppressionLevel::VeryHigh,
            _ => unreachable!(
                "Invalid variant for NoiseSuppressionLevel: {}",
                inner
            ),
        };
    }
}

impl SseDecode for Option<String> {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_decode(
        deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer,
    ) -> Self {
        if (<bool>::sse_decode(deserializer)) {
            return Some(<String>::sse_decode(deserializer));
        } else {
            return None;
        }
    }
}

impl SseDecode for Option<crate::api::dart::api::ApiConstrainFacingMode> {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_decode(
        deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer,
    ) -> Self {
        if (<bool>::sse_decode(deserializer)) {
            return Some(
                <crate::api::dart::api::ApiConstrainFacingMode>::sse_decode(
                    deserializer,
                ),
            );
        } else {
            return None;
        }
    }
}

impl SseDecode
    for Option<crate::api::dart::api::ApiDeviceAudioTrackConstraints>
{
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_decode(
        deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer,
    ) -> Self {
        if (<bool>::sse_decode(deserializer)) {
            return Some(<crate::api::dart::api::ApiDeviceAudioTrackConstraints>::sse_decode(deserializer));
        } else {
            return None;
        }
    }
}

impl SseDecode
    for Option<crate::api::dart::api::ApiDeviceVideoTrackConstraints>
{
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_decode(
        deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer,
    ) -> Self {
        if (<bool>::sse_decode(deserializer)) {
            return Some(<crate::api::dart::api::ApiDeviceVideoTrackConstraints>::sse_decode(deserializer));
        } else {
            return None;
        }
    }
}

impl SseDecode
    for Option<crate::api::dart::api::ApiDisplayAudioTrackConstraints>
{
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_decode(
        deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer,
    ) -> Self {
        if (<bool>::sse_decode(deserializer)) {
            return Some(<crate::api::dart::api::ApiDisplayAudioTrackConstraints>::sse_decode(deserializer));
        } else {
            return None;
        }
    }
}

impl SseDecode
    for Option<crate::api::dart::api::ApiDisplayVideoTrackConstraints>
{
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_decode(
        deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer,
    ) -> Self {
        if (<bool>::sse_decode(deserializer)) {
            return Some(<crate::api::dart::api::ApiDisplayVideoTrackConstraints>::sse_decode(deserializer));
        } else {
            return None;
        }
    }
}

impl SseDecode for Option<crate::media::AudioDeviceKind> {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_decode(
        deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer,
    ) -> Self {
        if (<bool>::sse_decode(deserializer)) {
            return Some(<crate::media::AudioDeviceKind>::sse_decode(
                deserializer,
            ));
        } else {
            return None;
        }
    }
}

impl SseDecode for Option<crate::media::constraints::ConstrainBoolean> {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_decode(
        deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer,
    ) -> Self {
        if (<bool>::sse_decode(deserializer)) {
            return Some(
                <crate::media::constraints::ConstrainBoolean>::sse_decode(
                    deserializer,
                ),
            );
        } else {
            return None;
        }
    }
}

impl SseDecode for Option<crate::media::constraints::ConstrainU32> {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_decode(
        deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer,
    ) -> Self {
        if (<bool>::sse_decode(deserializer)) {
            return Some(
                <crate::media::constraints::ConstrainU32>::sse_decode(
                    deserializer,
                ),
            );
        } else {
            return None;
        }
    }
}

impl SseDecode for Option<crate::media::track::MediaSourceKind> {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_decode(
        deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer,
    ) -> Self {
        if (<bool>::sse_decode(deserializer)) {
            return Some(<crate::media::track::MediaSourceKind>::sse_decode(
                deserializer,
            ));
        } else {
            return None;
        }
    }
}

impl SseDecode
    for Option<
        crate::api::dart::api::member_connection_state::MemberConnectionState,
    >
{
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_decode(
        deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer,
    ) -> Self {
        if (<bool>::sse_decode(deserializer)) {
            return Some(<crate::api::dart::api::member_connection_state::MemberConnectionState>::sse_decode(deserializer));
        } else {
            return None;
        }
    }
}

impl SseDecode for Option<crate::media::constraints::NoiseSuppressionLevel> {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_decode(
        deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer,
    ) -> Self {
        if (<bool>::sse_decode(deserializer)) {
            return Some(
                <crate::media::constraints::NoiseSuppressionLevel>::sse_decode(
                    deserializer,
                ),
            );
        } else {
            return None;
        }
    }
}

impl SseDecode for Option<u32> {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_decode(
        deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer,
    ) -> Self {
        if (<bool>::sse_decode(deserializer)) {
            return Some(<u32>::sse_decode(deserializer));
        } else {
            return None;
        }
    }
}

impl SseDecode for crate::api::shared::PeerConnectionState {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_decode(
        deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer,
    ) -> Self {
        let mut inner = <i32>::sse_decode(deserializer);
        return match inner {
            0 => crate::api::shared::PeerConnectionState::New,
            1 => crate::api::shared::PeerConnectionState::Connecting,
            2 => crate::api::shared::PeerConnectionState::Connected,
            3 => crate::api::shared::PeerConnectionState::Disconnected,
            4 => crate::api::shared::PeerConnectionState::Failed,
            5 => crate::api::shared::PeerConnectionState::Closed,
            _ => unreachable!(
                "Invalid variant for PeerConnectionState: {}",
                inner
            ),
        };
    }
}

impl SseDecode for crate::api::shared::RoomCloseKind {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_decode(
        deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer,
    ) -> Self {
        let mut inner = <i32>::sse_decode(deserializer);
        return match inner {
            0 => crate::api::shared::RoomCloseKind::InternalClientError,
            1 => crate::api::shared::RoomCloseKind::InternalServerError,
            2 => crate::api::shared::RoomCloseKind::Finished,
            3 => crate::api::shared::RoomCloseKind::Idle,
            4 => crate::api::shared::RoomCloseKind::Rejected,
            5 => crate::api::shared::RoomCloseKind::Evicted,
            _ => unreachable!("Invalid variant for RoomCloseKind: {}", inner),
        };
    }
}

impl SseDecode for crate::api::dart::api::room_close_reason::RoomCloseReason {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_decode(
        deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer,
    ) -> Self {
        let mut var_reason =
            <crate::api::shared::RoomCloseKind>::sse_decode(deserializer);
        let mut var_isClosedByServer = <bool>::sse_decode(deserializer);
        return crate::api::dart::api::room_close_reason::RoomCloseReason {
            reason: var_reason,
            is_closed_by_server: var_isClosedByServer,
        };
    }
}

impl SseDecode for u32 {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_decode(
        deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer,
    ) -> Self {
        deserializer.cursor.read_u32::<NativeEndian>().unwrap()
    }
}

impl SseDecode for u8 {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_decode(
        deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer,
    ) -> Self {
        deserializer.cursor.read_u8().unwrap()
    }
}

impl SseDecode for () {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_decode(
        deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer,
    ) -> Self {
    }
}

impl SseDecode for usize {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_decode(
        deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer,
    ) -> Self {
        deserializer.cursor.read_u64::<NativeEndian>().unwrap() as _
    }
}

fn pde_ffi_dispatcher_primary_impl(
    func_id: i32,
    port: flutter_rust_bridge::for_generated::MessagePort,
    ptr: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
    rust_vec_len: i32,
    data_len: i32,
) {
    // Codec=Pde (Serialization + dispatch), see doc to use other codecs
    match func_id {
        _ => unreachable!(),
    }
}

fn pde_ffi_dispatcher_sync_impl(
    func_id: i32,
    ptr: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
    rust_vec_len: i32,
    data_len: i32,
) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
    // Codec=Pde (Serialization + dispatch), see doc to use other codecs
    match func_id {
                        1 => wire__crate__api__dart__api__connection_handle__ConnectionHandle_disable_remote_audio_impl(ptr, rust_vec_len, data_len),
2 => wire__crate__api__dart__api__connection_handle__ConnectionHandle_disable_remote_video_impl(ptr, rust_vec_len, data_len),
3 => wire__crate__api__dart__api__connection_handle__ConnectionHandle_enable_remote_audio_impl(ptr, rust_vec_len, data_len),
4 => wire__crate__api__dart__api__connection_handle__ConnectionHandle_enable_remote_video_impl(ptr, rust_vec_len, data_len),
5 => wire__crate__api__dart__api__connection_handle__ConnectionHandle_from_ptr_impl(ptr, rust_vec_len, data_len),
6 => wire__crate__api__dart__api__connection_handle__ConnectionHandle_get_remote_member_id_impl(ptr, rust_vec_len, data_len),
7 => wire__crate__api__dart__api__connection_handle__ConnectionHandle_get_state_impl(ptr, rust_vec_len, data_len),
8 => wire__crate__api__dart__api__connection_handle__ConnectionHandle_on_close_impl(ptr, rust_vec_len, data_len),
9 => wire__crate__api__dart__api__connection_handle__ConnectionHandle_on_quality_score_update_impl(ptr, rust_vec_len, data_len),
10 => wire__crate__api__dart__api__connection_handle__ConnectionHandle_on_remote_track_added_impl(ptr, rust_vec_len, data_len),
11 => wire__crate__api__dart__api__connection_handle__ConnectionHandle_on_state_change_impl(ptr, rust_vec_len, data_len),
12 => wire__crate__api__dart__api__jason__Jason_jason_close_room_impl(ptr, rust_vec_len, data_len),
13 => wire__crate__api__dart__api__jason__Jason_jason_dispose_impl(ptr, rust_vec_len, data_len),
14 => wire__crate__api__dart__api__jason__Jason_jason_init_room_impl(ptr, rust_vec_len, data_len),
15 => wire__crate__api__dart__api__jason__Jason_jason_media_manager_impl(ptr, rust_vec_len, data_len),
16 => wire__crate__api__dart__api__jason__Jason_jason_network_changed_impl(ptr, rust_vec_len, data_len),
17 => wire__crate__api__dart__api__jason__Jason_new_impl(ptr, rust_vec_len, data_len),
18 => wire__crate__api__dart__api__local_media_track__LocalMediaTrack_free_impl(ptr, rust_vec_len, data_len),
19 => wire__crate__api__dart__api__local_media_track__LocalMediaTrack_from_ptr_impl(ptr, rust_vec_len, data_len),
20 => wire__crate__api__dart__api__local_media_track__LocalMediaTrack_get_noise_suppression_level_impl(ptr, rust_vec_len, data_len),
21 => wire__crate__api__dart__api__local_media_track__LocalMediaTrack_get_track_impl(ptr, rust_vec_len, data_len),
22 => wire__crate__api__dart__api__local_media_track__LocalMediaTrack_is_audio_processing_available_impl(ptr, rust_vec_len, data_len),
23 => wire__crate__api__dart__api__local_media_track__LocalMediaTrack_is_auto_gain_control_enabled_impl(ptr, rust_vec_len, data_len),
24 => wire__crate__api__dart__api__local_media_track__LocalMediaTrack_is_echo_cancellation_enabled_impl(ptr, rust_vec_len, data_len),
25 => wire__crate__api__dart__api__local_media_track__LocalMediaTrack_is_high_pass_filter_enabled_impl(ptr, rust_vec_len, data_len),
26 => wire__crate__api__dart__api__local_media_track__LocalMediaTrack_is_noise_suppression_enabled_impl(ptr, rust_vec_len, data_len),
27 => wire__crate__api__dart__api__local_media_track__LocalMediaTrack_is_on_audio_level_available_impl(ptr, rust_vec_len, data_len),
28 => wire__crate__api__dart__api__local_media_track__LocalMediaTrack_kind_impl(ptr, rust_vec_len, data_len),
29 => wire__crate__api__dart__api__local_media_track__LocalMediaTrack_media_source_kind_impl(ptr, rust_vec_len, data_len),
30 => wire__crate__api__dart__api__local_media_track__LocalMediaTrack_on_audio_level_changed_impl(ptr, rust_vec_len, data_len),
31 => wire__crate__api__dart__api__local_media_track__LocalMediaTrack_on_ended_impl(ptr, rust_vec_len, data_len),
32 => wire__crate__api__dart__api__local_media_track__LocalMediaTrack_set_auto_gain_control_enabled_impl(ptr, rust_vec_len, data_len),
33 => wire__crate__api__dart__api__local_media_track__LocalMediaTrack_set_echo_cancellation_enabled_impl(ptr, rust_vec_len, data_len),
34 => wire__crate__api__dart__api__local_media_track__LocalMediaTrack_set_high_pass_filter_enabled_impl(ptr, rust_vec_len, data_len),
35 => wire__crate__api__dart__api__local_media_track__LocalMediaTrack_set_noise_suppression_enabled_impl(ptr, rust_vec_len, data_len),
36 => wire__crate__api__dart__api__local_media_track__LocalMediaTrack_set_noise_suppression_level_impl(ptr, rust_vec_len, data_len),
37 => wire__crate__api__dart__api__local_media_track__LocalMediaTrack_state_impl(ptr, rust_vec_len, data_len),
38 => wire__crate__api__dart__api__media_manager__MediaManagerHandle_enumerate_devices_impl(ptr, rust_vec_len, data_len),
39 => wire__crate__api__dart__api__media_manager__MediaManagerHandle_enumerate_displays_impl(ptr, rust_vec_len, data_len),
40 => wire__crate__api__dart__api__media_manager__MediaManagerHandle_init_local_tracks_impl(ptr, rust_vec_len, data_len),
41 => wire__crate__api__dart__api__media_manager__MediaManagerHandle_microphone_volume_impl(ptr, rust_vec_len, data_len),
42 => wire__crate__api__dart__api__media_manager__MediaManagerHandle_microphone_volume_is_available_impl(ptr, rust_vec_len, data_len),
43 => wire__crate__api__dart__api__media_manager__MediaManagerHandle_on_device_change_impl(ptr, rust_vec_len, data_len),
44 => wire__crate__api__dart__api__media_manager__MediaManagerHandle_set_microphone_volume_impl(ptr, rust_vec_len, data_len),
45 => wire__crate__api__dart__api__media_manager__MediaManagerHandle_set_output_audio_id_impl(ptr, rust_vec_len, data_len),
46 => wire__crate__api__dart__api__reconnect_handle__ReconnectHandle_from_ptr_impl(ptr, rust_vec_len, data_len),
47 => wire__crate__api__dart__api__reconnect_handle__ReconnectHandle_reconnect_with_backoff_impl(ptr, rust_vec_len, data_len),
48 => wire__crate__api__dart__api__reconnect_handle__ReconnectHandle_reconnect_with_delay_impl(ptr, rust_vec_len, data_len),
49 => wire__crate__api__dart__api__remote_media_track__RemoteMediaTrack_from_ptr_impl(ptr, rust_vec_len, data_len),
50 => wire__crate__api__dart__api__remote_media_track__RemoteMediaTrack_get_track_impl(ptr, rust_vec_len, data_len),
51 => wire__crate__api__dart__api__remote_media_track__RemoteMediaTrack_kind_impl(ptr, rust_vec_len, data_len),
52 => wire__crate__api__dart__api__remote_media_track__RemoteMediaTrack_media_direction_impl(ptr, rust_vec_len, data_len),
53 => wire__crate__api__dart__api__remote_media_track__RemoteMediaTrack_media_source_kind_impl(ptr, rust_vec_len, data_len),
54 => wire__crate__api__dart__api__remote_media_track__RemoteMediaTrack_muted_impl(ptr, rust_vec_len, data_len),
55 => wire__crate__api__dart__api__remote_media_track__RemoteMediaTrack_on_media_direction_changed_impl(ptr, rust_vec_len, data_len),
56 => wire__crate__api__dart__api__remote_media_track__RemoteMediaTrack_on_muted_impl(ptr, rust_vec_len, data_len),
57 => wire__crate__api__dart__api__remote_media_track__RemoteMediaTrack_on_stopped_impl(ptr, rust_vec_len, data_len),
58 => wire__crate__api__dart__api__remote_media_track__RemoteMediaTrack_on_unmuted_impl(ptr, rust_vec_len, data_len),
59 => wire__crate__api__dart__api__room__RoomHandle_disable_audio_impl(ptr, rust_vec_len, data_len),
60 => wire__crate__api__dart__api__room__RoomHandle_disable_remote_audio_impl(ptr, rust_vec_len, data_len),
61 => wire__crate__api__dart__api__room__RoomHandle_disable_remote_video_impl(ptr, rust_vec_len, data_len),
62 => wire__crate__api__dart__api__room__RoomHandle_disable_video_impl(ptr, rust_vec_len, data_len),
63 => wire__crate__api__dart__api__room__RoomHandle_enable_audio_impl(ptr, rust_vec_len, data_len),
64 => wire__crate__api__dart__api__room__RoomHandle_enable_remote_audio_impl(ptr, rust_vec_len, data_len),
65 => wire__crate__api__dart__api__room__RoomHandle_enable_remote_video_impl(ptr, rust_vec_len, data_len),
66 => wire__crate__api__dart__api__room__RoomHandle_enable_video_impl(ptr, rust_vec_len, data_len),
67 => wire__crate__api__dart__api__room__RoomHandle_join_impl(ptr, rust_vec_len, data_len),
68 => wire__crate__api__dart__api__room__RoomHandle_mute_audio_impl(ptr, rust_vec_len, data_len),
69 => wire__crate__api__dart__api__room__RoomHandle_mute_video_impl(ptr, rust_vec_len, data_len),
70 => wire__crate__api__dart__api__room__RoomHandle_on_close_impl(ptr, rust_vec_len, data_len),
71 => wire__crate__api__dart__api__room__RoomHandle_on_connection_loss_impl(ptr, rust_vec_len, data_len),
72 => wire__crate__api__dart__api__room__RoomHandle_on_failed_local_media_impl(ptr, rust_vec_len, data_len),
73 => wire__crate__api__dart__api__room__RoomHandle_on_local_track_impl(ptr, rust_vec_len, data_len),
74 => wire__crate__api__dart__api__room__RoomHandle_on_new_connection_impl(ptr, rust_vec_len, data_len),
75 => wire__crate__api__dart__api__room__RoomHandle_set_local_media_settings_impl(ptr, rust_vec_len, data_len),
76 => wire__crate__api__dart__api__room__RoomHandle_unmute_audio_impl(ptr, rust_vec_len, data_len),
77 => wire__crate__api__dart__api__room__RoomHandle_unmute_video_impl(ptr, rust_vec_len, data_len),
79 => wire__crate__api__dart__api__log_dart_exception_impl(ptr, rust_vec_len, data_len),
80 => wire__crate__api__dart__api__member_connection_state__member_connection_state_from_ptr_impl(ptr, rust_vec_len, data_len),
81 => wire__crate__api__dart__api__on_panic_impl(ptr, rust_vec_len, data_len),
82 => wire__crate__api__dart__api__room_close_reason__room_close_reason_from_ptr_impl(ptr, rust_vec_len, data_len),
83 => wire__crate__api__dart__api__set_dart_opaque_message_port_impl(ptr, rust_vec_len, data_len),
84 => wire__crate__api__dart__api__local_media_track__vec_local_tracks_from_raw_impl(ptr, rust_vec_len, data_len),
85 => wire__crate__api__dart__api__vec_media_device_details_from_raw_impl(ptr, rust_vec_len, data_len),
86 => wire__crate__api__dart__api__vec_media_display_details_from_raw_impl(ptr, rust_vec_len, data_len),
                        _ => unreachable!(),
                    }
}

// Section: rust2dart

// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for FrbWrapper<ConnectionHandle> {
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        flutter_rust_bridge::for_generated::rust_auto_opaque_encode::<
            _,
            MoiArc<_>,
        >(self.0)
        .into_dart()
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
    for FrbWrapper<ConnectionHandle>
{
}

impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<ConnectionHandle>>
    for ConnectionHandle
{
    fn into_into_dart(self) -> FrbWrapper<ConnectionHandle> {
        self.into()
    }
}

// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for FrbWrapper<Jason> {
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        flutter_rust_bridge::for_generated::rust_auto_opaque_encode::<
            _,
            MoiArc<_>,
        >(self.0)
        .into_dart()
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
    for FrbWrapper<Jason>
{
}

impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<Jason>> for Jason {
    fn into_into_dart(self) -> FrbWrapper<Jason> {
        self.into()
    }
}

// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for FrbWrapper<LocalMediaTrack> {
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        flutter_rust_bridge::for_generated::rust_auto_opaque_encode::<
            _,
            MoiArc<_>,
        >(self.0)
        .into_dart()
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
    for FrbWrapper<LocalMediaTrack>
{
}

impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<LocalMediaTrack>>
    for LocalMediaTrack
{
    fn into_into_dart(self) -> FrbWrapper<LocalMediaTrack> {
        self.into()
    }
}

// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for FrbWrapper<MediaManagerHandle> {
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        flutter_rust_bridge::for_generated::rust_auto_opaque_encode::<
            _,
            MoiArc<_>,
        >(self.0)
        .into_dart()
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
    for FrbWrapper<MediaManagerHandle>
{
}

impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<MediaManagerHandle>>
    for MediaManagerHandle
{
    fn into_into_dart(self) -> FrbWrapper<MediaManagerHandle> {
        self.into()
    }
}

// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for FrbWrapper<ReconnectHandle> {
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        flutter_rust_bridge::for_generated::rust_auto_opaque_encode::<
            _,
            MoiArc<_>,
        >(self.0)
        .into_dart()
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
    for FrbWrapper<ReconnectHandle>
{
}

impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<ReconnectHandle>>
    for ReconnectHandle
{
    fn into_into_dart(self) -> FrbWrapper<ReconnectHandle> {
        self.into()
    }
}

// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for FrbWrapper<RemoteMediaTrack> {
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        flutter_rust_bridge::for_generated::rust_auto_opaque_encode::<
            _,
            MoiArc<_>,
        >(self.0)
        .into_dart()
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
    for FrbWrapper<RemoteMediaTrack>
{
}

impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<RemoteMediaTrack>>
    for RemoteMediaTrack
{
    fn into_into_dart(self) -> FrbWrapper<RemoteMediaTrack> {
        self.into()
    }
}

// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for FrbWrapper<RoomHandle> {
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        flutter_rust_bridge::for_generated::rust_auto_opaque_encode::<
            _,
            MoiArc<_>,
        >(self.0)
        .into_dart()
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
    for FrbWrapper<RoomHandle>
{
}

impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<RoomHandle>> for RoomHandle {
    fn into_into_dart(self) -> FrbWrapper<RoomHandle> {
        self.into()
    }
}

// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart
    for crate::api::dart::api::ApiConstrainFacingMode
{
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        match self {
            crate::api::dart::api::ApiConstrainFacingMode::Exact(field0) => {
                [0.into_dart(), field0.into_into_dart().into_dart()].into_dart()
            }
            crate::api::dart::api::ApiConstrainFacingMode::Ideal(field0) => {
                [1.into_dart(), field0.into_into_dart().into_dart()].into_dart()
            }
            _ => {
                unimplemented!("");
            }
        }
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
    for crate::api::dart::api::ApiConstrainFacingMode
{
}
impl
    flutter_rust_bridge::IntoIntoDart<
        crate::api::dart::api::ApiConstrainFacingMode,
    > for crate::api::dart::api::ApiConstrainFacingMode
{
    fn into_into_dart(self) -> crate::api::dart::api::ApiConstrainFacingMode {
        self
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart
    for crate::api::dart::api::ApiDeviceAudioTrackConstraints
{
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        [
            self.device_id.into_into_dart().into_dart(),
            self.auto_gain_control.into_into_dart().into_dart(),
            self.noise_suppression.into_into_dart().into_dart(),
            self.noise_suppression_level.into_into_dart().into_dart(),
            self.echo_cancellation.into_into_dart().into_dart(),
            self.high_pass_filter.into_into_dart().into_dart(),
        ]
        .into_dart()
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
    for crate::api::dart::api::ApiDeviceAudioTrackConstraints
{
}
impl
    flutter_rust_bridge::IntoIntoDart<
        crate::api::dart::api::ApiDeviceAudioTrackConstraints,
    > for crate::api::dart::api::ApiDeviceAudioTrackConstraints
{
    fn into_into_dart(
        self,
    ) -> crate::api::dart::api::ApiDeviceAudioTrackConstraints {
        self
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart
    for crate::api::dart::api::ApiDeviceVideoTrackConstraints
{
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        [
            self.device_id.into_into_dart().into_dart(),
            self.facing_mode.into_into_dart().into_dart(),
            self.height.into_into_dart().into_dart(),
            self.width.into_into_dart().into_dart(),
        ]
        .into_dart()
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
    for crate::api::dart::api::ApiDeviceVideoTrackConstraints
{
}
impl
    flutter_rust_bridge::IntoIntoDart<
        crate::api::dart::api::ApiDeviceVideoTrackConstraints,
    > for crate::api::dart::api::ApiDeviceVideoTrackConstraints
{
    fn into_into_dart(
        self,
    ) -> crate::api::dart::api::ApiDeviceVideoTrackConstraints {
        self
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart
    for crate::api::dart::api::ApiDisplayAudioTrackConstraints
{
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        Vec::<u8>::new().into_dart()
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
    for crate::api::dart::api::ApiDisplayAudioTrackConstraints
{
}
impl
    flutter_rust_bridge::IntoIntoDart<
        crate::api::dart::api::ApiDisplayAudioTrackConstraints,
    > for crate::api::dart::api::ApiDisplayAudioTrackConstraints
{
    fn into_into_dart(
        self,
    ) -> crate::api::dart::api::ApiDisplayAudioTrackConstraints {
        self
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart
    for crate::api::dart::api::ApiDisplayVideoTrackConstraints
{
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        [
            self.device_id.into_into_dart().into_dart(),
            self.height.into_into_dart().into_dart(),
            self.width.into_into_dart().into_dart(),
            self.frame_rate.into_into_dart().into_dart(),
        ]
        .into_dart()
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
    for crate::api::dart::api::ApiDisplayVideoTrackConstraints
{
}
impl
    flutter_rust_bridge::IntoIntoDart<
        crate::api::dart::api::ApiDisplayVideoTrackConstraints,
    > for crate::api::dart::api::ApiDisplayVideoTrackConstraints
{
    fn into_into_dart(
        self,
    ) -> crate::api::dart::api::ApiDisplayVideoTrackConstraints {
        self
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart
    for crate::api::dart::api::ApiMediaDeviceDetails
{
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        [
            self.kind.into_into_dart().into_dart(),
            self.device_id.into_into_dart().into_dart(),
            self.label.into_into_dart().into_dart(),
            self.audio_device_kind.into_into_dart().into_dart(),
            self.group_id.into_into_dart().into_dart(),
            self.is_failed.into_into_dart().into_dart(),
        ]
        .into_dart()
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
    for crate::api::dart::api::ApiMediaDeviceDetails
{
}
impl
    flutter_rust_bridge::IntoIntoDart<
        crate::api::dart::api::ApiMediaDeviceDetails,
    > for crate::api::dart::api::ApiMediaDeviceDetails
{
    fn into_into_dart(self) -> crate::api::dart::api::ApiMediaDeviceDetails {
        self
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart
    for crate::api::dart::api::ApiMediaDisplayDetails
{
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        [
            self.device_id.into_into_dart().into_dart(),
            self.title.into_into_dart().into_dart(),
        ]
        .into_dart()
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
    for crate::api::dart::api::ApiMediaDisplayDetails
{
}
impl
    flutter_rust_bridge::IntoIntoDart<
        crate::api::dart::api::ApiMediaDisplayDetails,
    > for crate::api::dart::api::ApiMediaDisplayDetails
{
    fn into_into_dart(self) -> crate::api::dart::api::ApiMediaDisplayDetails {
        self
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart
    for crate::api::dart::api::ApiMediaStreamSettings
{
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        [
            self.device_audio.into_into_dart().into_dart(),
            self.display_audio.into_into_dart().into_dart(),
            self.device_video.into_into_dart().into_dart(),
            self.display_video.into_into_dart().into_dart(),
        ]
        .into_dart()
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
    for crate::api::dart::api::ApiMediaStreamSettings
{
}
impl
    flutter_rust_bridge::IntoIntoDart<
        crate::api::dart::api::ApiMediaStreamSettings,
    > for crate::api::dart::api::ApiMediaStreamSettings
{
    fn into_into_dart(self) -> crate::api::dart::api::ApiMediaStreamSettings {
        self
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for crate::media::AudioDeviceKind {
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        match self {
            Self::EarSpeaker => 0.into_dart(),
            Self::Speakerphone => 1.into_dart(),
            Self::WiredHeadphones => 2.into_dart(),
            Self::WiredHeadset => 3.into_dart(),
            Self::UsbHeadphones => 4.into_dart(),
            Self::UsbHeadset => 5.into_dart(),
            Self::BluetoothHeadphones => 6.into_dart(),
            Self::BluetoothHeadset => 7.into_dart(),
            _ => unreachable!(),
        }
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
    for crate::media::AudioDeviceKind
{
}
impl flutter_rust_bridge::IntoIntoDart<crate::media::AudioDeviceKind>
    for crate::media::AudioDeviceKind
{
    fn into_into_dart(self) -> crate::media::AudioDeviceKind {
        self
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart
    for crate::media::constraints::ConstrainBoolean
{
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        match self {
            crate::media::constraints::ConstrainBoolean::Exact(field0) => {
                [0.into_dart(), field0.into_into_dart().into_dart()].into_dart()
            }
            crate::media::constraints::ConstrainBoolean::Ideal(field0) => {
                [1.into_dart(), field0.into_into_dart().into_dart()].into_dart()
            }
            _ => {
                unimplemented!("");
            }
        }
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
    for crate::media::constraints::ConstrainBoolean
{
}
impl
    flutter_rust_bridge::IntoIntoDart<
        crate::media::constraints::ConstrainBoolean,
    > for crate::media::constraints::ConstrainBoolean
{
    fn into_into_dart(self) -> crate::media::constraints::ConstrainBoolean {
        self
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for crate::media::constraints::ConstrainU32 {
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        match self {
            crate::media::constraints::ConstrainU32::Exact(field0) => {
                [0.into_dart(), field0.into_into_dart().into_dart()].into_dart()
            }
            crate::media::constraints::ConstrainU32::Ideal(field0) => {
                [1.into_dart(), field0.into_into_dart().into_dart()].into_dart()
            }
            crate::media::constraints::ConstrainU32::Range(field0, field1) => [
                2.into_dart(),
                field0.into_into_dart().into_dart(),
                field1.into_into_dart().into_dart(),
            ]
            .into_dart(),
            _ => {
                unimplemented!("");
            }
        }
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
    for crate::media::constraints::ConstrainU32
{
}
impl flutter_rust_bridge::IntoIntoDart<crate::media::constraints::ConstrainU32>
    for crate::media::constraints::ConstrainU32
{
    fn into_into_dart(self) -> crate::media::constraints::ConstrainU32 {
        self
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for crate::media::constraints::FacingMode {
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        match self {
            Self::User => 0.into_dart(),
            Self::Environment => 1.into_dart(),
            Self::Left => 2.into_dart(),
            Self::Right => 3.into_dart(),
            _ => unreachable!(),
        }
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
    for crate::media::constraints::FacingMode
{
}
impl flutter_rust_bridge::IntoIntoDart<crate::media::constraints::FacingMode>
    for crate::media::constraints::FacingMode
{
    fn into_into_dart(self) -> crate::media::constraints::FacingMode {
        self
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for crate::media::MediaDeviceKind {
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        match self {
            Self::AudioInput => 0.into_dart(),
            Self::VideoInput => 1.into_dart(),
            Self::AudioOutput => 2.into_dart(),
            _ => unreachable!(),
        }
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
    for crate::media::MediaDeviceKind
{
}
impl flutter_rust_bridge::IntoIntoDart<crate::media::MediaDeviceKind>
    for crate::media::MediaDeviceKind
{
    fn into_into_dart(self) -> crate::media::MediaDeviceKind {
        self
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart
    for crate::media::track::remote::MediaDirection
{
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        match self {
            Self::SendRecv => 0.into_dart(),
            Self::SendOnly => 1.into_dart(),
            Self::RecvOnly => 2.into_dart(),
            Self::Inactive => 3.into_dart(),
            _ => unreachable!(),
        }
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
    for crate::media::track::remote::MediaDirection
{
}
impl
    flutter_rust_bridge::IntoIntoDart<
        crate::media::track::remote::MediaDirection,
    > for crate::media::track::remote::MediaDirection
{
    fn into_into_dart(self) -> crate::media::track::remote::MediaDirection {
        self
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for crate::media::MediaKind {
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        match self {
            Self::Audio => 0.into_dart(),
            Self::Video => 1.into_dart(),
            _ => unreachable!(),
        }
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
    for crate::media::MediaKind
{
}
impl flutter_rust_bridge::IntoIntoDart<crate::media::MediaKind>
    for crate::media::MediaKind
{
    fn into_into_dart(self) -> crate::media::MediaKind {
        self
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for crate::media::track::MediaSourceKind {
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        match self {
            Self::Device => 0.into_dart(),
            Self::Display => 1.into_dart(),
            _ => unreachable!(),
        }
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
    for crate::media::track::MediaSourceKind
{
}
impl flutter_rust_bridge::IntoIntoDart<crate::media::track::MediaSourceKind>
    for crate::media::track::MediaSourceKind
{
    fn into_into_dart(self) -> crate::media::track::MediaSourceKind {
        self
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart
    for crate::api::dart::api::member_connection_state::MemberConnectionState
{
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        match self {crate::api::dart::api::member_connection_state::MemberConnectionState::P2P(field0) => { [0.into_dart(),
field0.into_into_dart().into_dart()].into_dart() }
 _ => { unimplemented!(""); }}
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
    for crate::api::dart::api::member_connection_state::MemberConnectionState
{
}
impl
    flutter_rust_bridge::IntoIntoDart<
        crate::api::dart::api::member_connection_state::MemberConnectionState,
    >
    for crate::api::dart::api::member_connection_state::MemberConnectionState
{
    fn into_into_dart(
        self,
    ) -> crate::api::dart::api::member_connection_state::MemberConnectionState
    {
        self
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart
    for crate::media::constraints::NoiseSuppressionLevel
{
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        match self {
            Self::Low => 0.into_dart(),
            Self::Moderate => 1.into_dart(),
            Self::High => 2.into_dart(),
            Self::VeryHigh => 3.into_dart(),
            _ => unreachable!(),
        }
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
    for crate::media::constraints::NoiseSuppressionLevel
{
}
impl
    flutter_rust_bridge::IntoIntoDart<
        crate::media::constraints::NoiseSuppressionLevel,
    > for crate::media::constraints::NoiseSuppressionLevel
{
    fn into_into_dart(
        self,
    ) -> crate::media::constraints::NoiseSuppressionLevel {
        self
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for crate::api::shared::PeerConnectionState {
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        match self {
            Self::New => 0.into_dart(),
            Self::Connecting => 1.into_dart(),
            Self::Connected => 2.into_dart(),
            Self::Disconnected => 3.into_dart(),
            Self::Failed => 4.into_dart(),
            Self::Closed => 5.into_dart(),
            _ => unreachable!(),
        }
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
    for crate::api::shared::PeerConnectionState
{
}
impl flutter_rust_bridge::IntoIntoDart<crate::api::shared::PeerConnectionState>
    for crate::api::shared::PeerConnectionState
{
    fn into_into_dart(self) -> crate::api::shared::PeerConnectionState {
        self
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for crate::api::shared::RoomCloseKind {
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        match self {
            Self::InternalClientError => 0.into_dart(),
            Self::InternalServerError => 1.into_dart(),
            Self::Finished => 2.into_dart(),
            Self::Idle => 3.into_dart(),
            Self::Rejected => 4.into_dart(),
            Self::Evicted => 5.into_dart(),
            _ => unreachable!(),
        }
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
    for crate::api::shared::RoomCloseKind
{
}
impl flutter_rust_bridge::IntoIntoDart<crate::api::shared::RoomCloseKind>
    for crate::api::shared::RoomCloseKind
{
    fn into_into_dart(self) -> crate::api::shared::RoomCloseKind {
        self
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart
    for crate::api::dart::api::room_close_reason::RoomCloseReason
{
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        [
            self.reason.into_into_dart().into_dart(),
            self.is_closed_by_server.into_into_dart().into_dart(),
        ]
        .into_dart()
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
    for crate::api::dart::api::room_close_reason::RoomCloseReason
{
}
impl
    flutter_rust_bridge::IntoIntoDart<
        crate::api::dart::api::room_close_reason::RoomCloseReason,
    > for crate::api::dart::api::room_close_reason::RoomCloseReason
{
    fn into_into_dart(
        self,
    ) -> crate::api::dart::api::room_close_reason::RoomCloseReason {
        self
    }
}

impl SseEncode for ConnectionHandle {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_encode(
        self,
        serializer: &mut flutter_rust_bridge::for_generated::SseSerializer,
    ) {
        <RustOpaqueMoi<
            flutter_rust_bridge::for_generated::RustAutoOpaqueInner<
                ConnectionHandle,
            >,
        >>::sse_encode(
            flutter_rust_bridge::for_generated::rust_auto_opaque_encode::<
                _,
                MoiArc<_>,
            >(self),
            serializer,
        );
    }
}

impl SseEncode for Jason {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_encode(
        self,
        serializer: &mut flutter_rust_bridge::for_generated::SseSerializer,
    ) {
        <RustOpaqueMoi<
            flutter_rust_bridge::for_generated::RustAutoOpaqueInner<Jason>,
        >>::sse_encode(
            flutter_rust_bridge::for_generated::rust_auto_opaque_encode::<
                _,
                MoiArc<_>,
            >(self),
            serializer,
        );
    }
}

impl SseEncode for LocalMediaTrack {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_encode(
        self,
        serializer: &mut flutter_rust_bridge::for_generated::SseSerializer,
    ) {
        <RustOpaqueMoi<
            flutter_rust_bridge::for_generated::RustAutoOpaqueInner<
                LocalMediaTrack,
            >,
        >>::sse_encode(
            flutter_rust_bridge::for_generated::rust_auto_opaque_encode::<
                _,
                MoiArc<_>,
            >(self),
            serializer,
        );
    }
}

impl SseEncode for MediaManagerHandle {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_encode(
        self,
        serializer: &mut flutter_rust_bridge::for_generated::SseSerializer,
    ) {
        <RustOpaqueMoi<
            flutter_rust_bridge::for_generated::RustAutoOpaqueInner<
                MediaManagerHandle,
            >,
        >>::sse_encode(
            flutter_rust_bridge::for_generated::rust_auto_opaque_encode::<
                _,
                MoiArc<_>,
            >(self),
            serializer,
        );
    }
}

impl SseEncode for ReconnectHandle {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_encode(
        self,
        serializer: &mut flutter_rust_bridge::for_generated::SseSerializer,
    ) {
        <RustOpaqueMoi<
            flutter_rust_bridge::for_generated::RustAutoOpaqueInner<
                ReconnectHandle,
            >,
        >>::sse_encode(
            flutter_rust_bridge::for_generated::rust_auto_opaque_encode::<
                _,
                MoiArc<_>,
            >(self),
            serializer,
        );
    }
}

impl SseEncode for RemoteMediaTrack {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_encode(
        self,
        serializer: &mut flutter_rust_bridge::for_generated::SseSerializer,
    ) {
        <RustOpaqueMoi<
            flutter_rust_bridge::for_generated::RustAutoOpaqueInner<
                RemoteMediaTrack,
            >,
        >>::sse_encode(
            flutter_rust_bridge::for_generated::rust_auto_opaque_encode::<
                _,
                MoiArc<_>,
            >(self),
            serializer,
        );
    }
}

impl SseEncode for RoomHandle {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_encode(
        self,
        serializer: &mut flutter_rust_bridge::for_generated::SseSerializer,
    ) {
        <RustOpaqueMoi<
            flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RoomHandle>,
        >>::sse_encode(
            flutter_rust_bridge::for_generated::rust_auto_opaque_encode::<
                _,
                MoiArc<_>,
            >(self),
            serializer,
        );
    }
}

impl SseEncode for flutter_rust_bridge::DartOpaque {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_encode(
        self,
        serializer: &mut flutter_rust_bridge::for_generated::SseSerializer,
    ) {
        <usize>::sse_encode(self.encode(), serializer);
    }
}

impl SseEncode
    for RustOpaqueMoi<
        flutter_rust_bridge::for_generated::RustAutoOpaqueInner<
            ConnectionHandle,
        >,
    >
{
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_encode(
        self,
        serializer: &mut flutter_rust_bridge::for_generated::SseSerializer,
    ) {
        let (ptr, size) = self.sse_encode_raw();
        <usize>::sse_encode(ptr, serializer);
        <i32>::sse_encode(size, serializer);
    }
}

impl SseEncode
    for RustOpaqueMoi<
        flutter_rust_bridge::for_generated::RustAutoOpaqueInner<Jason>,
    >
{
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_encode(
        self,
        serializer: &mut flutter_rust_bridge::for_generated::SseSerializer,
    ) {
        let (ptr, size) = self.sse_encode_raw();
        <usize>::sse_encode(ptr, serializer);
        <i32>::sse_encode(size, serializer);
    }
}

impl SseEncode
    for RustOpaqueMoi<
        flutter_rust_bridge::for_generated::RustAutoOpaqueInner<
            LocalMediaTrack,
        >,
    >
{
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_encode(
        self,
        serializer: &mut flutter_rust_bridge::for_generated::SseSerializer,
    ) {
        let (ptr, size) = self.sse_encode_raw();
        <usize>::sse_encode(ptr, serializer);
        <i32>::sse_encode(size, serializer);
    }
}

impl SseEncode
    for RustOpaqueMoi<
        flutter_rust_bridge::for_generated::RustAutoOpaqueInner<
            MediaManagerHandle,
        >,
    >
{
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_encode(
        self,
        serializer: &mut flutter_rust_bridge::for_generated::SseSerializer,
    ) {
        let (ptr, size) = self.sse_encode_raw();
        <usize>::sse_encode(ptr, serializer);
        <i32>::sse_encode(size, serializer);
    }
}

impl SseEncode
    for RustOpaqueMoi<
        flutter_rust_bridge::for_generated::RustAutoOpaqueInner<
            ReconnectHandle,
        >,
    >
{
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_encode(
        self,
        serializer: &mut flutter_rust_bridge::for_generated::SseSerializer,
    ) {
        let (ptr, size) = self.sse_encode_raw();
        <usize>::sse_encode(ptr, serializer);
        <i32>::sse_encode(size, serializer);
    }
}

impl SseEncode
    for RustOpaqueMoi<
        flutter_rust_bridge::for_generated::RustAutoOpaqueInner<
            RemoteMediaTrack,
        >,
    >
{
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_encode(
        self,
        serializer: &mut flutter_rust_bridge::for_generated::SseSerializer,
    ) {
        let (ptr, size) = self.sse_encode_raw();
        <usize>::sse_encode(ptr, serializer);
        <i32>::sse_encode(size, serializer);
    }
}

impl SseEncode
    for RustOpaqueMoi<
        flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RoomHandle>,
    >
{
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_encode(
        self,
        serializer: &mut flutter_rust_bridge::for_generated::SseSerializer,
    ) {
        let (ptr, size) = self.sse_encode_raw();
        <usize>::sse_encode(ptr, serializer);
        <i32>::sse_encode(size, serializer);
    }
}

impl SseEncode for String {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_encode(
        self,
        serializer: &mut flutter_rust_bridge::for_generated::SseSerializer,
    ) {
        <Vec<u8>>::sse_encode(self.into_bytes(), serializer);
    }
}

impl SseEncode for crate::api::dart::api::ApiConstrainFacingMode {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_encode(
        self,
        serializer: &mut flutter_rust_bridge::for_generated::SseSerializer,
    ) {
        match self {
            crate::api::dart::api::ApiConstrainFacingMode::Exact(field0) => {
                <i32>::sse_encode(0, serializer);
                <crate::media::constraints::FacingMode>::sse_encode(
                    field0, serializer,
                );
            }
            crate::api::dart::api::ApiConstrainFacingMode::Ideal(field0) => {
                <i32>::sse_encode(1, serializer);
                <crate::media::constraints::FacingMode>::sse_encode(
                    field0, serializer,
                );
            }
            _ => {
                unimplemented!("");
            }
        }
    }
}

impl SseEncode for crate::api::dart::api::ApiDeviceAudioTrackConstraints {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_encode(
        self,
        serializer: &mut flutter_rust_bridge::for_generated::SseSerializer,
    ) {
        <Option<String>>::sse_encode(self.device_id, serializer);
        <Option<crate::media::constraints::ConstrainBoolean>>::sse_encode(
            self.auto_gain_control,
            serializer,
        );
        <Option<crate::media::constraints::ConstrainBoolean>>::sse_encode(
            self.noise_suppression,
            serializer,
        );
        <Option<crate::media::constraints::NoiseSuppressionLevel>>::sse_encode(
            self.noise_suppression_level,
            serializer,
        );
        <Option<crate::media::constraints::ConstrainBoolean>>::sse_encode(
            self.echo_cancellation,
            serializer,
        );
        <Option<crate::media::constraints::ConstrainBoolean>>::sse_encode(
            self.high_pass_filter,
            serializer,
        );
    }
}

impl SseEncode for crate::api::dart::api::ApiDeviceVideoTrackConstraints {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_encode(
        self,
        serializer: &mut flutter_rust_bridge::for_generated::SseSerializer,
    ) {
        <Option<String>>::sse_encode(self.device_id, serializer);
        <Option<crate::api::dart::api::ApiConstrainFacingMode>>::sse_encode(
            self.facing_mode,
            serializer,
        );
        <Option<crate::media::constraints::ConstrainU32>>::sse_encode(
            self.height,
            serializer,
        );
        <Option<crate::media::constraints::ConstrainU32>>::sse_encode(
            self.width, serializer,
        );
    }
}

impl SseEncode for crate::api::dart::api::ApiDisplayAudioTrackConstraints {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_encode(
        self,
        serializer: &mut flutter_rust_bridge::for_generated::SseSerializer,
    ) {
    }
}

impl SseEncode for crate::api::dart::api::ApiDisplayVideoTrackConstraints {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_encode(
        self,
        serializer: &mut flutter_rust_bridge::for_generated::SseSerializer,
    ) {
        <Option<String>>::sse_encode(self.device_id, serializer);
        <Option<crate::media::constraints::ConstrainU32>>::sse_encode(
            self.height,
            serializer,
        );
        <Option<crate::media::constraints::ConstrainU32>>::sse_encode(
            self.width, serializer,
        );
        <Option<crate::media::constraints::ConstrainU32>>::sse_encode(
            self.frame_rate,
            serializer,
        );
    }
}

impl SseEncode for crate::api::dart::api::ApiMediaDeviceDetails {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_encode(
        self,
        serializer: &mut flutter_rust_bridge::for_generated::SseSerializer,
    ) {
        <crate::media::MediaDeviceKind>::sse_encode(self.kind, serializer);
        <String>::sse_encode(self.device_id, serializer);
        <String>::sse_encode(self.label, serializer);
        <Option<crate::media::AudioDeviceKind>>::sse_encode(
            self.audio_device_kind,
            serializer,
        );
        <Option<String>>::sse_encode(self.group_id, serializer);
        <bool>::sse_encode(self.is_failed, serializer);
    }
}

impl SseEncode for crate::api::dart::api::ApiMediaDisplayDetails {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_encode(
        self,
        serializer: &mut flutter_rust_bridge::for_generated::SseSerializer,
    ) {
        <String>::sse_encode(self.device_id, serializer);
        <Option<String>>::sse_encode(self.title, serializer);
    }
}

impl SseEncode for crate::api::dart::api::ApiMediaStreamSettings {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_encode(
        self,
        serializer: &mut flutter_rust_bridge::for_generated::SseSerializer,
    ) {
        <Option<crate::api::dart::api::ApiDeviceAudioTrackConstraints>>::sse_encode(self.device_audio, serializer);
        <Option<crate::api::dart::api::ApiDisplayAudioTrackConstraints>>::sse_encode(self.display_audio, serializer);
        <Option<crate::api::dart::api::ApiDeviceVideoTrackConstraints>>::sse_encode(self.device_video, serializer);
        <Option<crate::api::dart::api::ApiDisplayVideoTrackConstraints>>::sse_encode(self.display_video, serializer);
    }
}

impl SseEncode for crate::media::AudioDeviceKind {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_encode(
        self,
        serializer: &mut flutter_rust_bridge::for_generated::SseSerializer,
    ) {
        <i32>::sse_encode(
            match self {
                crate::media::AudioDeviceKind::EarSpeaker => 0,
                crate::media::AudioDeviceKind::Speakerphone => 1,
                crate::media::AudioDeviceKind::WiredHeadphones => 2,
                crate::media::AudioDeviceKind::WiredHeadset => 3,
                crate::media::AudioDeviceKind::UsbHeadphones => 4,
                crate::media::AudioDeviceKind::UsbHeadset => 5,
                crate::media::AudioDeviceKind::BluetoothHeadphones => 6,
                crate::media::AudioDeviceKind::BluetoothHeadset => 7,
                _ => {
                    unimplemented!("");
                }
            },
            serializer,
        );
    }
}

impl SseEncode for bool {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_encode(
        self,
        serializer: &mut flutter_rust_bridge::for_generated::SseSerializer,
    ) {
        serializer.cursor.write_u8(self as _).unwrap();
    }
}

impl SseEncode for crate::media::constraints::ConstrainBoolean {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_encode(
        self,
        serializer: &mut flutter_rust_bridge::for_generated::SseSerializer,
    ) {
        match self {
            crate::media::constraints::ConstrainBoolean::Exact(field0) => {
                <i32>::sse_encode(0, serializer);
                <bool>::sse_encode(field0, serializer);
            }
            crate::media::constraints::ConstrainBoolean::Ideal(field0) => {
                <i32>::sse_encode(1, serializer);
                <bool>::sse_encode(field0, serializer);
            }
            _ => {
                unimplemented!("");
            }
        }
    }
}

impl SseEncode for crate::media::constraints::ConstrainU32 {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_encode(
        self,
        serializer: &mut flutter_rust_bridge::for_generated::SseSerializer,
    ) {
        match self {
            crate::media::constraints::ConstrainU32::Exact(field0) => {
                <i32>::sse_encode(0, serializer);
                <u32>::sse_encode(field0, serializer);
            }
            crate::media::constraints::ConstrainU32::Ideal(field0) => {
                <i32>::sse_encode(1, serializer);
                <u32>::sse_encode(field0, serializer);
            }
            crate::media::constraints::ConstrainU32::Range(field0, field1) => {
                <i32>::sse_encode(2, serializer);
                <u32>::sse_encode(field0, serializer);
                <u32>::sse_encode(field1, serializer);
            }
            _ => {
                unimplemented!("");
            }
        }
    }
}

impl SseEncode for f64 {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_encode(
        self,
        serializer: &mut flutter_rust_bridge::for_generated::SseSerializer,
    ) {
        serializer.cursor.write_f64::<NativeEndian>(self).unwrap();
    }
}

impl SseEncode for crate::media::constraints::FacingMode {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_encode(
        self,
        serializer: &mut flutter_rust_bridge::for_generated::SseSerializer,
    ) {
        <i32>::sse_encode(
            match self {
                crate::media::constraints::FacingMode::User => 0,
                crate::media::constraints::FacingMode::Environment => 1,
                crate::media::constraints::FacingMode::Left => 2,
                crate::media::constraints::FacingMode::Right => 3,
                _ => {
                    unimplemented!("");
                }
            },
            serializer,
        );
    }
}

impl SseEncode for i32 {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_encode(
        self,
        serializer: &mut flutter_rust_bridge::for_generated::SseSerializer,
    ) {
        serializer.cursor.write_i32::<NativeEndian>(self).unwrap();
    }
}

impl SseEncode for i64 {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_encode(
        self,
        serializer: &mut flutter_rust_bridge::for_generated::SseSerializer,
    ) {
        serializer.cursor.write_i64::<NativeEndian>(self).unwrap();
    }
}

impl SseEncode for isize {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_encode(
        self,
        serializer: &mut flutter_rust_bridge::for_generated::SseSerializer,
    ) {
        serializer.cursor.write_i64::<NativeEndian>(self as _).unwrap();
    }
}

impl SseEncode for Vec<LocalMediaTrack> {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_encode(
        self,
        serializer: &mut flutter_rust_bridge::for_generated::SseSerializer,
    ) {
        <i32>::sse_encode(self.len() as _, serializer);
        for item in self {
            <LocalMediaTrack>::sse_encode(item, serializer);
        }
    }
}

impl SseEncode for Vec<crate::api::dart::api::ApiMediaDeviceDetails> {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_encode(
        self,
        serializer: &mut flutter_rust_bridge::for_generated::SseSerializer,
    ) {
        <i32>::sse_encode(self.len() as _, serializer);
        for item in self {
            <crate::api::dart::api::ApiMediaDeviceDetails>::sse_encode(
                item, serializer,
            );
        }
    }
}

impl SseEncode for Vec<crate::api::dart::api::ApiMediaDisplayDetails> {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_encode(
        self,
        serializer: &mut flutter_rust_bridge::for_generated::SseSerializer,
    ) {
        <i32>::sse_encode(self.len() as _, serializer);
        for item in self {
            <crate::api::dart::api::ApiMediaDisplayDetails>::sse_encode(
                item, serializer,
            );
        }
    }
}

impl SseEncode for Vec<u8> {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_encode(
        self,
        serializer: &mut flutter_rust_bridge::for_generated::SseSerializer,
    ) {
        <i32>::sse_encode(self.len() as _, serializer);
        for item in self {
            <u8>::sse_encode(item, serializer);
        }
    }
}

impl SseEncode for crate::media::MediaDeviceKind {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_encode(
        self,
        serializer: &mut flutter_rust_bridge::for_generated::SseSerializer,
    ) {
        <i32>::sse_encode(
            match self {
                crate::media::MediaDeviceKind::AudioInput => 0,
                crate::media::MediaDeviceKind::VideoInput => 1,
                crate::media::MediaDeviceKind::AudioOutput => 2,
                _ => {
                    unimplemented!("");
                }
            },
            serializer,
        );
    }
}

impl SseEncode for crate::media::track::remote::MediaDirection {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_encode(
        self,
        serializer: &mut flutter_rust_bridge::for_generated::SseSerializer,
    ) {
        <i32>::sse_encode(
            match self {
                crate::media::track::remote::MediaDirection::SendRecv => 0,
                crate::media::track::remote::MediaDirection::SendOnly => 1,
                crate::media::track::remote::MediaDirection::RecvOnly => 2,
                crate::media::track::remote::MediaDirection::Inactive => 3,
                _ => {
                    unimplemented!("");
                }
            },
            serializer,
        );
    }
}

impl SseEncode for crate::media::MediaKind {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_encode(
        self,
        serializer: &mut flutter_rust_bridge::for_generated::SseSerializer,
    ) {
        <i32>::sse_encode(
            match self {
                crate::media::MediaKind::Audio => 0,
                crate::media::MediaKind::Video => 1,
                _ => {
                    unimplemented!("");
                }
            },
            serializer,
        );
    }
}

impl SseEncode for crate::media::track::MediaSourceKind {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_encode(
        self,
        serializer: &mut flutter_rust_bridge::for_generated::SseSerializer,
    ) {
        <i32>::sse_encode(
            match self {
                crate::media::track::MediaSourceKind::Device => 0,
                crate::media::track::MediaSourceKind::Display => 1,
                _ => {
                    unimplemented!("");
                }
            },
            serializer,
        );
    }
}

impl SseEncode
    for crate::api::dart::api::member_connection_state::MemberConnectionState
{
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_encode(
        self,
        serializer: &mut flutter_rust_bridge::for_generated::SseSerializer,
    ) {
        match self {crate::api::dart::api::member_connection_state::MemberConnectionState::P2P(field0) => { <i32>::sse_encode(0, serializer); <crate::api::shared::PeerConnectionState>::sse_encode(field0, serializer);
 }
 _ => { unimplemented!(""); }}
    }
}

impl SseEncode for crate::media::constraints::NoiseSuppressionLevel {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_encode(
        self,
        serializer: &mut flutter_rust_bridge::for_generated::SseSerializer,
    ) {
        <i32>::sse_encode(
            match self {
                crate::media::constraints::NoiseSuppressionLevel::Low => 0,
                crate::media::constraints::NoiseSuppressionLevel::Moderate => 1,
                crate::media::constraints::NoiseSuppressionLevel::High => 2,
                crate::media::constraints::NoiseSuppressionLevel::VeryHigh => 3,
                _ => {
                    unimplemented!("");
                }
            },
            serializer,
        );
    }
}

impl SseEncode for Option<String> {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_encode(
        self,
        serializer: &mut flutter_rust_bridge::for_generated::SseSerializer,
    ) {
        <bool>::sse_encode(self.is_some(), serializer);
        if let Some(value) = self {
            <String>::sse_encode(value, serializer);
        }
    }
}

impl SseEncode for Option<crate::api::dart::api::ApiConstrainFacingMode> {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_encode(
        self,
        serializer: &mut flutter_rust_bridge::for_generated::SseSerializer,
    ) {
        <bool>::sse_encode(self.is_some(), serializer);
        if let Some(value) = self {
            <crate::api::dart::api::ApiConstrainFacingMode>::sse_encode(
                value, serializer,
            );
        }
    }
}

impl SseEncode
    for Option<crate::api::dart::api::ApiDeviceAudioTrackConstraints>
{
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_encode(
        self,
        serializer: &mut flutter_rust_bridge::for_generated::SseSerializer,
    ) {
        <bool>::sse_encode(self.is_some(), serializer);
        if let Some(value) = self {
            <crate::api::dart::api::ApiDeviceAudioTrackConstraints>::sse_encode(
                value, serializer,
            );
        }
    }
}

impl SseEncode
    for Option<crate::api::dart::api::ApiDeviceVideoTrackConstraints>
{
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_encode(
        self,
        serializer: &mut flutter_rust_bridge::for_generated::SseSerializer,
    ) {
        <bool>::sse_encode(self.is_some(), serializer);
        if let Some(value) = self {
            <crate::api::dart::api::ApiDeviceVideoTrackConstraints>::sse_encode(
                value, serializer,
            );
        }
    }
}

impl SseEncode
    for Option<crate::api::dart::api::ApiDisplayAudioTrackConstraints>
{
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_encode(
        self,
        serializer: &mut flutter_rust_bridge::for_generated::SseSerializer,
    ) {
        <bool>::sse_encode(self.is_some(), serializer);
        if let Some(value) = self {
            <crate::api::dart::api::ApiDisplayAudioTrackConstraints>::sse_encode(value, serializer);
        }
    }
}

impl SseEncode
    for Option<crate::api::dart::api::ApiDisplayVideoTrackConstraints>
{
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_encode(
        self,
        serializer: &mut flutter_rust_bridge::for_generated::SseSerializer,
    ) {
        <bool>::sse_encode(self.is_some(), serializer);
        if let Some(value) = self {
            <crate::api::dart::api::ApiDisplayVideoTrackConstraints>::sse_encode(value, serializer);
        }
    }
}

impl SseEncode for Option<crate::media::AudioDeviceKind> {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_encode(
        self,
        serializer: &mut flutter_rust_bridge::for_generated::SseSerializer,
    ) {
        <bool>::sse_encode(self.is_some(), serializer);
        if let Some(value) = self {
            <crate::media::AudioDeviceKind>::sse_encode(value, serializer);
        }
    }
}

impl SseEncode for Option<crate::media::constraints::ConstrainBoolean> {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_encode(
        self,
        serializer: &mut flutter_rust_bridge::for_generated::SseSerializer,
    ) {
        <bool>::sse_encode(self.is_some(), serializer);
        if let Some(value) = self {
            <crate::media::constraints::ConstrainBoolean>::sse_encode(
                value, serializer,
            );
        }
    }
}

impl SseEncode for Option<crate::media::constraints::ConstrainU32> {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_encode(
        self,
        serializer: &mut flutter_rust_bridge::for_generated::SseSerializer,
    ) {
        <bool>::sse_encode(self.is_some(), serializer);
        if let Some(value) = self {
            <crate::media::constraints::ConstrainU32>::sse_encode(
                value, serializer,
            );
        }
    }
}

impl SseEncode for Option<crate::media::track::MediaSourceKind> {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_encode(
        self,
        serializer: &mut flutter_rust_bridge::for_generated::SseSerializer,
    ) {
        <bool>::sse_encode(self.is_some(), serializer);
        if let Some(value) = self {
            <crate::media::track::MediaSourceKind>::sse_encode(
                value, serializer,
            );
        }
    }
}

impl SseEncode
    for Option<
        crate::api::dart::api::member_connection_state::MemberConnectionState,
    >
{
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_encode(
        self,
        serializer: &mut flutter_rust_bridge::for_generated::SseSerializer,
    ) {
        <bool>::sse_encode(self.is_some(), serializer);
        if let Some(value) = self {
            <crate::api::dart::api::member_connection_state::MemberConnectionState>::sse_encode(value, serializer);
        }
    }
}

impl SseEncode for Option<crate::media::constraints::NoiseSuppressionLevel> {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_encode(
        self,
        serializer: &mut flutter_rust_bridge::for_generated::SseSerializer,
    ) {
        <bool>::sse_encode(self.is_some(), serializer);
        if let Some(value) = self {
            <crate::media::constraints::NoiseSuppressionLevel>::sse_encode(
                value, serializer,
            );
        }
    }
}

impl SseEncode for Option<u32> {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_encode(
        self,
        serializer: &mut flutter_rust_bridge::for_generated::SseSerializer,
    ) {
        <bool>::sse_encode(self.is_some(), serializer);
        if let Some(value) = self {
            <u32>::sse_encode(value, serializer);
        }
    }
}

impl SseEncode for crate::api::shared::PeerConnectionState {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_encode(
        self,
        serializer: &mut flutter_rust_bridge::for_generated::SseSerializer,
    ) {
        <i32>::sse_encode(
            match self {
                crate::api::shared::PeerConnectionState::New => 0,
                crate::api::shared::PeerConnectionState::Connecting => 1,
                crate::api::shared::PeerConnectionState::Connected => 2,
                crate::api::shared::PeerConnectionState::Disconnected => 3,
                crate::api::shared::PeerConnectionState::Failed => 4,
                crate::api::shared::PeerConnectionState::Closed => 5,
                _ => {
                    unimplemented!("");
                }
            },
            serializer,
        );
    }
}

impl SseEncode for crate::api::shared::RoomCloseKind {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_encode(
        self,
        serializer: &mut flutter_rust_bridge::for_generated::SseSerializer,
    ) {
        <i32>::sse_encode(
            match self {
                crate::api::shared::RoomCloseKind::InternalClientError => 0,
                crate::api::shared::RoomCloseKind::InternalServerError => 1,
                crate::api::shared::RoomCloseKind::Finished => 2,
                crate::api::shared::RoomCloseKind::Idle => 3,
                crate::api::shared::RoomCloseKind::Rejected => 4,
                crate::api::shared::RoomCloseKind::Evicted => 5,
                _ => {
                    unimplemented!("");
                }
            },
            serializer,
        );
    }
}

impl SseEncode for crate::api::dart::api::room_close_reason::RoomCloseReason {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_encode(
        self,
        serializer: &mut flutter_rust_bridge::for_generated::SseSerializer,
    ) {
        <crate::api::shared::RoomCloseKind>::sse_encode(
            self.reason,
            serializer,
        );
        <bool>::sse_encode(self.is_closed_by_server, serializer);
    }
}

impl SseEncode for u32 {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_encode(
        self,
        serializer: &mut flutter_rust_bridge::for_generated::SseSerializer,
    ) {
        serializer.cursor.write_u32::<NativeEndian>(self).unwrap();
    }
}

impl SseEncode for u8 {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_encode(
        self,
        serializer: &mut flutter_rust_bridge::for_generated::SseSerializer,
    ) {
        serializer.cursor.write_u8(self).unwrap();
    }
}

impl SseEncode for () {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_encode(
        self,
        serializer: &mut flutter_rust_bridge::for_generated::SseSerializer,
    ) {
    }
}

impl SseEncode for usize {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_encode(
        self,
        serializer: &mut flutter_rust_bridge::for_generated::SseSerializer,
    ) {
        serializer.cursor.write_u64::<NativeEndian>(self as _).unwrap();
    }
}

#[cfg(not(target_family = "wasm"))]
mod io {
    // This file is automatically generated, so please do not edit it.
    // @generated by `flutter_rust_bridge`@ 2.11.1.

    // Section: imports

    use super::*;
    use crate::api::dart::api::connection_handle::*;
    use crate::api::dart::api::jason::*;
    use crate::api::dart::api::local_media_track::*;
    use crate::api::dart::api::media_manager::*;
    use crate::api::dart::api::reconnect_handle::*;
    use crate::api::dart::api::remote_media_track::*;
    use crate::api::dart::api::room::*;
    use crate::api::dart::api::ForeignClass;
    use flutter_rust_bridge::for_generated::byteorder::{
        NativeEndian, ReadBytesExt, WriteBytesExt,
    };
    use flutter_rust_bridge::for_generated::{
        transform_result_dco, Lifetimeable, Lockable,
    };
    use flutter_rust_bridge::{Handler, IntoIntoDart};

    // Section: boilerplate

    flutter_rust_bridge::frb_generated_boilerplate_io!();

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_medea_jason_rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerConnectionHandle(
        ptr: *const std::ffi::c_void,
    ) {
        MoiArc::<
            flutter_rust_bridge::for_generated::RustAutoOpaqueInner<
                ConnectionHandle,
            >,
        >::increment_strong_count(ptr as _);
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_medea_jason_rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerConnectionHandle(
        ptr: *const std::ffi::c_void,
    ) {
        MoiArc::<
            flutter_rust_bridge::for_generated::RustAutoOpaqueInner<
                ConnectionHandle,
            >,
        >::decrement_strong_count(ptr as _);
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_medea_jason_rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerJason(
        ptr: *const std::ffi::c_void,
    ) {
        MoiArc::<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<Jason>>::increment_strong_count(ptr as _);
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_medea_jason_rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerJason(
        ptr: *const std::ffi::c_void,
    ) {
        MoiArc::<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<Jason>>::decrement_strong_count(ptr as _);
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_medea_jason_rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerLocalMediaTrack(
        ptr: *const std::ffi::c_void,
    ) {
        MoiArc::<
            flutter_rust_bridge::for_generated::RustAutoOpaqueInner<
                LocalMediaTrack,
            >,
        >::increment_strong_count(ptr as _);
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_medea_jason_rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerLocalMediaTrack(
        ptr: *const std::ffi::c_void,
    ) {
        MoiArc::<
            flutter_rust_bridge::for_generated::RustAutoOpaqueInner<
                LocalMediaTrack,
            >,
        >::decrement_strong_count(ptr as _);
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_medea_jason_rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerMediaManagerHandle(
        ptr: *const std::ffi::c_void,
    ) {
        MoiArc::<
            flutter_rust_bridge::for_generated::RustAutoOpaqueInner<
                MediaManagerHandle,
            >,
        >::increment_strong_count(ptr as _);
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_medea_jason_rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerMediaManagerHandle(
        ptr: *const std::ffi::c_void,
    ) {
        MoiArc::<
            flutter_rust_bridge::for_generated::RustAutoOpaqueInner<
                MediaManagerHandle,
            >,
        >::decrement_strong_count(ptr as _);
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_medea_jason_rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerReconnectHandle(
        ptr: *const std::ffi::c_void,
    ) {
        MoiArc::<
            flutter_rust_bridge::for_generated::RustAutoOpaqueInner<
                ReconnectHandle,
            >,
        >::increment_strong_count(ptr as _);
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_medea_jason_rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerReconnectHandle(
        ptr: *const std::ffi::c_void,
    ) {
        MoiArc::<
            flutter_rust_bridge::for_generated::RustAutoOpaqueInner<
                ReconnectHandle,
            >,
        >::decrement_strong_count(ptr as _);
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_medea_jason_rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerRemoteMediaTrack(
        ptr: *const std::ffi::c_void,
    ) {
        MoiArc::<
            flutter_rust_bridge::for_generated::RustAutoOpaqueInner<
                RemoteMediaTrack,
            >,
        >::increment_strong_count(ptr as _);
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_medea_jason_rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerRemoteMediaTrack(
        ptr: *const std::ffi::c_void,
    ) {
        MoiArc::<
            flutter_rust_bridge::for_generated::RustAutoOpaqueInner<
                RemoteMediaTrack,
            >,
        >::decrement_strong_count(ptr as _);
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_medea_jason_rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerRoomHandle(
        ptr: *const std::ffi::c_void,
    ) {
        MoiArc::<
            flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RoomHandle>,
        >::increment_strong_count(ptr as _);
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_medea_jason_rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerRoomHandle(
        ptr: *const std::ffi::c_void,
    ) {
        MoiArc::<
            flutter_rust_bridge::for_generated::RustAutoOpaqueInner<RoomHandle>,
        >::decrement_strong_count(ptr as _);
    }
}
#[cfg(not(target_family = "wasm"))]
pub use io::*;