breez_sdk_core/

frb_generated.rs

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

#![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::breez_services::EventListener;
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 = DcoCodec,
    default_rust_opaque = RustOpaqueNom,
    default_rust_auto_opaque = RustAutoOpaqueNom,
);
pub(crate) const FLUTTER_RUST_BRIDGE_CODEGEN_VERSION: &str = "2.9.0";
pub(crate) const FLUTTER_RUST_BRIDGE_CODEGEN_CONTENT_HASH: i32 = -1202170102;

// Section: executor

flutter_rust_bridge::frb_generated_default_handler!();

// Section: wire_funcs

fn wire__crate__binding__backup_impl(port_: flutter_rust_bridge::for_generated::MessagePort) {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::<flutter_rust_bridge::for_generated::DcoCodec, _, _>(
        flutter_rust_bridge::for_generated::TaskInfo {
            debug_name: "backup",
            port: Some(port_),
            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
        },
        move || {
            move |context| {
                transform_result_dco::<_, _, flutter_rust_bridge::for_generated::anyhow::Error>(
                    (move || {
                        let output_ok = crate::binding::backup()?;
                        Ok(output_ok)
                    })(),
                )
            }
        },
    )
}
fn wire__crate__binding__backup_status_impl(
    port_: flutter_rust_bridge::for_generated::MessagePort,
) {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::<flutter_rust_bridge::for_generated::DcoCodec, _, _>(
        flutter_rust_bridge::for_generated::TaskInfo {
            debug_name: "backup_status",
            port: Some(port_),
            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
        },
        move || {
            move |context| {
                transform_result_dco::<_, _, flutter_rust_bridge::for_generated::anyhow::Error>(
                    (move || {
                        let output_ok = crate::binding::backup_status()?;
                        Ok(output_ok)
                    })(),
                )
            }
        },
    )
}
fn wire__crate__binding__binding_event_listener_on_event_impl(
    port_: flutter_rust_bridge::for_generated::MessagePort,
    that: impl CstDecode<crate::binding::BindingEventListener>,
    e: impl CstDecode<crate::breez_services::BreezEvent>,
) {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::<flutter_rust_bridge::for_generated::DcoCodec, _, _>(
        flutter_rust_bridge::for_generated::TaskInfo {
            debug_name: "binding_event_listener_on_event",
            port: Some(port_),
            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
        },
        move || {
            let api_that = that.cst_decode();
            let api_e = e.cst_decode();
            move |context| {
                transform_result_dco::<_, _, ()>((move || {
                    let output_ok = Result::<_, ()>::Ok({
                        crate::binding::BindingEventListener::on_event(&api_that, api_e);
                    })?;
                    Ok(output_ok)
                })())
            }
        },
    )
}
fn wire__crate__binding__breez_events_stream_impl(
    port_: flutter_rust_bridge::for_generated::MessagePort,
    s: impl CstDecode<
        StreamSink<crate::breez_services::BreezEvent, flutter_rust_bridge::for_generated::DcoCodec>,
    >,
) {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::<flutter_rust_bridge::for_generated::DcoCodec, _, _>(
        flutter_rust_bridge::for_generated::TaskInfo {
            debug_name: "breez_events_stream",
            port: Some(port_),
            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
        },
        move || {
            let api_s = s.cst_decode();
            move |context| {
                transform_result_dco::<_, _, flutter_rust_bridge::for_generated::anyhow::Error>(
                    (move || {
                        let output_ok = crate::binding::breez_events_stream(api_s)?;
                        Ok(output_ok)
                    })(),
                )
            }
        },
    )
}
fn wire__crate__binding__breez_log_stream_impl(
    port_: flutter_rust_bridge::for_generated::MessagePort,
    s: impl CstDecode<StreamSink<crate::models::LogEntry, flutter_rust_bridge::for_generated::DcoCodec>>,
) {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::<flutter_rust_bridge::for_generated::DcoCodec, _, _>(
        flutter_rust_bridge::for_generated::TaskInfo {
            debug_name: "breez_log_stream",
            port: Some(port_),
            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
        },
        move || {
            let api_s = s.cst_decode();
            move |context| {
                transform_result_dco::<_, _, flutter_rust_bridge::for_generated::anyhow::Error>(
                    (move || {
                        let output_ok = crate::binding::breez_log_stream(api_s)?;
                        Ok(output_ok)
                    })(),
                )
            }
        },
    )
}
fn wire__crate__binding__buy_bitcoin_impl(
    port_: flutter_rust_bridge::for_generated::MessagePort,
    req: impl CstDecode<crate::models::BuyBitcoinRequest>,
) {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::<flutter_rust_bridge::for_generated::DcoCodec, _, _>(
        flutter_rust_bridge::for_generated::TaskInfo {
            debug_name: "buy_bitcoin",
            port: Some(port_),
            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
        },
        move || {
            let api_req = req.cst_decode();
            move |context| {
                transform_result_dco::<_, _, flutter_rust_bridge::for_generated::anyhow::Error>(
                    (move || {
                        let output_ok = crate::binding::buy_bitcoin(api_req)?;
                        Ok(output_ok)
                    })(),
                )
            }
        },
    )
}
fn wire__crate__binding__check_message_impl(
    port_: flutter_rust_bridge::for_generated::MessagePort,
    req: impl CstDecode<crate::breez_services::CheckMessageRequest>,
) {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::<flutter_rust_bridge::for_generated::DcoCodec, _, _>(
        flutter_rust_bridge::for_generated::TaskInfo {
            debug_name: "check_message",
            port: Some(port_),
            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
        },
        move || {
            let api_req = req.cst_decode();
            move |context| {
                transform_result_dco::<_, _, flutter_rust_bridge::for_generated::anyhow::Error>(
                    (move || {
                        let output_ok = crate::binding::check_message(api_req)?;
                        Ok(output_ok)
                    })(),
                )
            }
        },
    )
}
fn wire__crate__binding__claim_reverse_swap_impl(
    port_: flutter_rust_bridge::for_generated::MessagePort,
    lockup_address: impl CstDecode<String>,
) {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::<flutter_rust_bridge::for_generated::DcoCodec, _, _>(
        flutter_rust_bridge::for_generated::TaskInfo {
            debug_name: "claim_reverse_swap",
            port: Some(port_),
            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
        },
        move || {
            let api_lockup_address = lockup_address.cst_decode();
            move |context| {
                transform_result_dco::<_, _, flutter_rust_bridge::for_generated::anyhow::Error>(
                    (move || {
                        let output_ok = crate::binding::claim_reverse_swap(api_lockup_address)?;
                        Ok(output_ok)
                    })(),
                )
            }
        },
    )
}
fn wire__crate__binding__close_lsp_channels_impl(
    port_: flutter_rust_bridge::for_generated::MessagePort,
) {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::<flutter_rust_bridge::for_generated::DcoCodec, _, _>(
        flutter_rust_bridge::for_generated::TaskInfo {
            debug_name: "close_lsp_channels",
            port: Some(port_),
            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
        },
        move || {
            move |context| {
                transform_result_dco::<_, _, flutter_rust_bridge::for_generated::anyhow::Error>(
                    (move || {
                        let output_ok = crate::binding::close_lsp_channels()?;
                        Ok(output_ok)
                    })(),
                )
            }
        },
    )
}
fn wire__crate__binding__configure_node_impl(
    port_: flutter_rust_bridge::for_generated::MessagePort,
    req: impl CstDecode<crate::models::ConfigureNodeRequest>,
) {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::<flutter_rust_bridge::for_generated::DcoCodec, _, _>(
        flutter_rust_bridge::for_generated::TaskInfo {
            debug_name: "configure_node",
            port: Some(port_),
            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
        },
        move || {
            let api_req = req.cst_decode();
            move |context| {
                transform_result_dco::<_, _, flutter_rust_bridge::for_generated::anyhow::Error>(
                    (move || {
                        let output_ok = crate::binding::configure_node(api_req)?;
                        Ok(output_ok)
                    })(),
                )
            }
        },
    )
}
fn wire__crate__binding__connect_impl(
    port_: flutter_rust_bridge::for_generated::MessagePort,
    req: impl CstDecode<crate::models::ConnectRequest>,
) {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::<flutter_rust_bridge::for_generated::DcoCodec, _, _>(
        flutter_rust_bridge::for_generated::TaskInfo {
            debug_name: "connect",
            port: Some(port_),
            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
        },
        move || {
            let api_req = req.cst_decode();
            move |context| {
                transform_result_dco::<_, _, flutter_rust_bridge::for_generated::anyhow::Error>(
                    (move || {
                        let output_ok = crate::binding::connect(api_req)?;
                        Ok(output_ok)
                    })(),
                )
            }
        },
    )
}
fn wire__crate__binding__connect_lsp_impl(
    port_: flutter_rust_bridge::for_generated::MessagePort,
    lsp_id: impl CstDecode<String>,
) {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::<flutter_rust_bridge::for_generated::DcoCodec, _, _>(
        flutter_rust_bridge::for_generated::TaskInfo {
            debug_name: "connect_lsp",
            port: Some(port_),
            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
        },
        move || {
            let api_lsp_id = lsp_id.cst_decode();
            move |context| {
                transform_result_dco::<_, _, flutter_rust_bridge::for_generated::anyhow::Error>(
                    (move || {
                        let output_ok = crate::binding::connect_lsp(api_lsp_id)?;
                        Ok(output_ok)
                    })(),
                )
            }
        },
    )
}
fn wire__crate__binding__default_config_impl(
    port_: flutter_rust_bridge::for_generated::MessagePort,
    env_type: impl CstDecode<crate::models::EnvironmentType>,
    api_key: impl CstDecode<String>,
    node_config: impl CstDecode<crate::models::NodeConfig>,
) {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::<flutter_rust_bridge::for_generated::DcoCodec, _, _>(
        flutter_rust_bridge::for_generated::TaskInfo {
            debug_name: "default_config",
            port: Some(port_),
            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
        },
        move || {
            let api_env_type = env_type.cst_decode();
            let api_api_key = api_key.cst_decode();
            let api_node_config = node_config.cst_decode();
            move |context| {
                transform_result_dco::<_, _, ()>((move || {
                    let output_ok = Result::<_, ()>::Ok(crate::binding::default_config(
                        api_env_type,
                        api_api_key,
                        api_node_config,
                    ))?;
                    Ok(output_ok)
                })())
            }
        },
    )
}
fn wire__crate__binding__disconnect_impl(port_: flutter_rust_bridge::for_generated::MessagePort) {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::<flutter_rust_bridge::for_generated::DcoCodec, _, _>(
        flutter_rust_bridge::for_generated::TaskInfo {
            debug_name: "disconnect",
            port: Some(port_),
            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
        },
        move || {
            move |context| {
                transform_result_dco::<_, _, flutter_rust_bridge::for_generated::anyhow::Error>(
                    (move || {
                        let output_ok = crate::binding::disconnect()?;
                        Ok(output_ok)
                    })(),
                )
            }
        },
    )
}
fn wire__crate__binding__execute_command_impl(
    port_: flutter_rust_bridge::for_generated::MessagePort,
    command: impl CstDecode<String>,
) {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::<flutter_rust_bridge::for_generated::DcoCodec, _, _>(
        flutter_rust_bridge::for_generated::TaskInfo {
            debug_name: "execute_command",
            port: Some(port_),
            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
        },
        move || {
            let api_command = command.cst_decode();
            move |context| {
                transform_result_dco::<_, _, flutter_rust_bridge::for_generated::anyhow::Error>(
                    (move || {
                        let output_ok = crate::binding::execute_command(api_command)?;
                        Ok(output_ok)
                    })(),
                )
            }
        },
    )
}
fn wire__crate__binding__fetch_fiat_rates_impl(
    port_: flutter_rust_bridge::for_generated::MessagePort,
) {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::<flutter_rust_bridge::for_generated::DcoCodec, _, _>(
        flutter_rust_bridge::for_generated::TaskInfo {
            debug_name: "fetch_fiat_rates",
            port: Some(port_),
            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
        },
        move || {
            move |context| {
                transform_result_dco::<_, _, flutter_rust_bridge::for_generated::anyhow::Error>(
                    (move || {
                        let output_ok = crate::binding::fetch_fiat_rates()?;
                        Ok(output_ok)
                    })(),
                )
            }
        },
    )
}
fn wire__crate__binding__fetch_lsp_info_impl(
    port_: flutter_rust_bridge::for_generated::MessagePort,
    id: impl CstDecode<String>,
) {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::<flutter_rust_bridge::for_generated::DcoCodec, _, _>(
        flutter_rust_bridge::for_generated::TaskInfo {
            debug_name: "fetch_lsp_info",
            port: Some(port_),
            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
        },
        move || {
            let api_id = id.cst_decode();
            move |context| {
                transform_result_dco::<_, _, flutter_rust_bridge::for_generated::anyhow::Error>(
                    (move || {
                        let output_ok = crate::binding::fetch_lsp_info(api_id)?;
                        Ok(output_ok)
                    })(),
                )
            }
        },
    )
}
fn wire__crate__binding__fetch_reverse_swap_fees_impl(
    port_: flutter_rust_bridge::for_generated::MessagePort,
    req: impl CstDecode<crate::models::ReverseSwapFeesRequest>,
) {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::<flutter_rust_bridge::for_generated::DcoCodec, _, _>(
        flutter_rust_bridge::for_generated::TaskInfo {
            debug_name: "fetch_reverse_swap_fees",
            port: Some(port_),
            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
        },
        move || {
            let api_req = req.cst_decode();
            move |context| {
                transform_result_dco::<_, _, flutter_rust_bridge::for_generated::anyhow::Error>(
                    (move || {
                        let output_ok = crate::binding::fetch_reverse_swap_fees(api_req)?;
                        Ok(output_ok)
                    })(),
                )
            }
        },
    )
}
fn wire__crate__binding__generate_diagnostic_data_impl(
    port_: flutter_rust_bridge::for_generated::MessagePort,
) {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::<flutter_rust_bridge::for_generated::DcoCodec, _, _>(
        flutter_rust_bridge::for_generated::TaskInfo {
            debug_name: "generate_diagnostic_data",
            port: Some(port_),
            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
        },
        move || {
            move |context| {
                transform_result_dco::<_, _, flutter_rust_bridge::for_generated::anyhow::Error>(
                    (move || {
                        let output_ok = crate::binding::generate_diagnostic_data()?;
                        Ok(output_ok)
                    })(),
                )
            }
        },
    )
}
fn wire__crate__binding__in_progress_onchain_payments_impl(
    port_: flutter_rust_bridge::for_generated::MessagePort,
) {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::<flutter_rust_bridge::for_generated::DcoCodec, _, _>(
        flutter_rust_bridge::for_generated::TaskInfo {
            debug_name: "in_progress_onchain_payments",
            port: Some(port_),
            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
        },
        move || {
            move |context| {
                transform_result_dco::<_, _, flutter_rust_bridge::for_generated::anyhow::Error>(
                    (move || {
                        let output_ok = crate::binding::in_progress_onchain_payments()?;
                        Ok(output_ok)
                    })(),
                )
            }
        },
    )
}
fn wire__crate__binding__in_progress_swap_impl(
    port_: flutter_rust_bridge::for_generated::MessagePort,
) {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::<flutter_rust_bridge::for_generated::DcoCodec, _, _>(
        flutter_rust_bridge::for_generated::TaskInfo {
            debug_name: "in_progress_swap",
            port: Some(port_),
            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
        },
        move || {
            move |context| {
                transform_result_dco::<_, _, flutter_rust_bridge::for_generated::anyhow::Error>(
                    (move || {
                        let output_ok = crate::binding::in_progress_swap()?;
                        Ok(output_ok)
                    })(),
                )
            }
        },
    )
}
fn wire__crate__binding__is_initialized_impl(
    port_: flutter_rust_bridge::for_generated::MessagePort,
) {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::<flutter_rust_bridge::for_generated::DcoCodec, _, _>(
        flutter_rust_bridge::for_generated::TaskInfo {
            debug_name: "is_initialized",
            port: Some(port_),
            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
        },
        move || {
            move |context| {
                transform_result_dco::<_, _, ()>((move || {
                    let output_ok = Result::<_, ()>::Ok(crate::binding::is_initialized())?;
                    Ok(output_ok)
                })())
            }
        },
    )
}
fn wire__crate__binding__list_fiat_currencies_impl(
    port_: flutter_rust_bridge::for_generated::MessagePort,
) {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::<flutter_rust_bridge::for_generated::DcoCodec, _, _>(
        flutter_rust_bridge::for_generated::TaskInfo {
            debug_name: "list_fiat_currencies",
            port: Some(port_),
            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
        },
        move || {
            move |context| {
                transform_result_dco::<_, _, flutter_rust_bridge::for_generated::anyhow::Error>(
                    (move || {
                        let output_ok = crate::binding::list_fiat_currencies()?;
                        Ok(output_ok)
                    })(),
                )
            }
        },
    )
}
fn wire__crate__binding__list_lsps_impl(port_: flutter_rust_bridge::for_generated::MessagePort) {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::<flutter_rust_bridge::for_generated::DcoCodec, _, _>(
        flutter_rust_bridge::for_generated::TaskInfo {
            debug_name: "list_lsps",
            port: Some(port_),
            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
        },
        move || {
            move |context| {
                transform_result_dco::<_, _, flutter_rust_bridge::for_generated::anyhow::Error>(
                    (move || {
                        let output_ok = crate::binding::list_lsps()?;
                        Ok(output_ok)
                    })(),
                )
            }
        },
    )
}
fn wire__crate__binding__list_payments_impl(
    port_: flutter_rust_bridge::for_generated::MessagePort,
    req: impl CstDecode<crate::models::ListPaymentsRequest>,
) {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::<flutter_rust_bridge::for_generated::DcoCodec, _, _>(
        flutter_rust_bridge::for_generated::TaskInfo {
            debug_name: "list_payments",
            port: Some(port_),
            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
        },
        move || {
            let api_req = req.cst_decode();
            move |context| {
                transform_result_dco::<_, _, flutter_rust_bridge::for_generated::anyhow::Error>(
                    (move || {
                        let output_ok = crate::binding::list_payments(api_req)?;
                        Ok(output_ok)
                    })(),
                )
            }
        },
    )
}
fn wire__crate__binding__list_refundables_impl(
    port_: flutter_rust_bridge::for_generated::MessagePort,
) {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::<flutter_rust_bridge::for_generated::DcoCodec, _, _>(
        flutter_rust_bridge::for_generated::TaskInfo {
            debug_name: "list_refundables",
            port: Some(port_),
            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
        },
        move || {
            move |context| {
                transform_result_dco::<_, _, flutter_rust_bridge::for_generated::anyhow::Error>(
                    (move || {
                        let output_ok = crate::binding::list_refundables()?;
                        Ok(output_ok)
                    })(),
                )
            }
        },
    )
}
fn wire__crate__binding__list_swaps_impl(
    port_: flutter_rust_bridge::for_generated::MessagePort,
    req: impl CstDecode<crate::models::ListSwapsRequest>,
) {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::<flutter_rust_bridge::for_generated::DcoCodec, _, _>(
        flutter_rust_bridge::for_generated::TaskInfo {
            debug_name: "list_swaps",
            port: Some(port_),
            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
        },
        move || {
            let api_req = req.cst_decode();
            move |context| {
                transform_result_dco::<_, _, flutter_rust_bridge::for_generated::anyhow::Error>(
                    (move || {
                        let output_ok = crate::binding::list_swaps(api_req)?;
                        Ok(output_ok)
                    })(),
                )
            }
        },
    )
}
fn wire__crate__binding__lnurl_auth_impl(
    port_: flutter_rust_bridge::for_generated::MessagePort,
    req_data: impl CstDecode<crate::binding::LnUrlAuthRequestData>,
) {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::<flutter_rust_bridge::for_generated::DcoCodec, _, _>(
        flutter_rust_bridge::for_generated::TaskInfo {
            debug_name: "lnurl_auth",
            port: Some(port_),
            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
        },
        move || {
            let api_req_data = req_data.cst_decode();
            move |context| {
                transform_result_dco::<_, _, flutter_rust_bridge::for_generated::anyhow::Error>(
                    (move || {
                        let output_ok = crate::binding::lnurl_auth(api_req_data)?;
                        Ok(output_ok)
                    })(),
                )
            }
        },
    )
}
fn wire__crate__binding__lnurl_pay_impl(
    port_: flutter_rust_bridge::for_generated::MessagePort,
    req: impl CstDecode<crate::binding::LnUrlPayRequest>,
) {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::<flutter_rust_bridge::for_generated::DcoCodec, _, _>(
        flutter_rust_bridge::for_generated::TaskInfo {
            debug_name: "lnurl_pay",
            port: Some(port_),
            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
        },
        move || {
            let api_req = req.cst_decode();
            move |context| {
                transform_result_dco::<_, _, flutter_rust_bridge::for_generated::anyhow::Error>(
                    (move || {
                        let output_ok = crate::binding::lnurl_pay(api_req)?;
                        Ok(output_ok)
                    })(),
                )
            }
        },
    )
}
fn wire__crate__binding__lnurl_withdraw_impl(
    port_: flutter_rust_bridge::for_generated::MessagePort,
    req: impl CstDecode<crate::binding::LnUrlWithdrawRequest>,
) {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::<flutter_rust_bridge::for_generated::DcoCodec, _, _>(
        flutter_rust_bridge::for_generated::TaskInfo {
            debug_name: "lnurl_withdraw",
            port: Some(port_),
            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
        },
        move || {
            let api_req = req.cst_decode();
            move |context| {
                transform_result_dco::<_, _, flutter_rust_bridge::for_generated::anyhow::Error>(
                    (move || {
                        let output_ok = crate::binding::lnurl_withdraw(api_req)?;
                        Ok(output_ok)
                    })(),
                )
            }
        },
    )
}
fn wire__crate__binding__lsp_id_impl(port_: flutter_rust_bridge::for_generated::MessagePort) {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::<flutter_rust_bridge::for_generated::DcoCodec, _, _>(
        flutter_rust_bridge::for_generated::TaskInfo {
            debug_name: "lsp_id",
            port: Some(port_),
            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
        },
        move || {
            move |context| {
                transform_result_dco::<_, _, flutter_rust_bridge::for_generated::anyhow::Error>(
                    (move || {
                        let output_ok = crate::binding::lsp_id()?;
                        Ok(output_ok)
                    })(),
                )
            }
        },
    )
}
fn wire__crate__binding__lsp_info_impl(port_: flutter_rust_bridge::for_generated::MessagePort) {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::<flutter_rust_bridge::for_generated::DcoCodec, _, _>(
        flutter_rust_bridge::for_generated::TaskInfo {
            debug_name: "lsp_info",
            port: Some(port_),
            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
        },
        move || {
            move |context| {
                transform_result_dco::<_, _, flutter_rust_bridge::for_generated::anyhow::Error>(
                    (move || {
                        let output_ok = crate::binding::lsp_info()?;
                        Ok(output_ok)
                    })(),
                )
            }
        },
    )
}
fn wire__crate__binding__mnemonic_to_seed_impl(
    port_: flutter_rust_bridge::for_generated::MessagePort,
    phrase: impl CstDecode<String>,
) {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::<flutter_rust_bridge::for_generated::DcoCodec, _, _>(
        flutter_rust_bridge::for_generated::TaskInfo {
            debug_name: "mnemonic_to_seed",
            port: Some(port_),
            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
        },
        move || {
            let api_phrase = phrase.cst_decode();
            move |context| {
                transform_result_dco::<_, _, flutter_rust_bridge::for_generated::anyhow::Error>(
                    (move || {
                        let output_ok = crate::binding::mnemonic_to_seed(api_phrase)?;
                        Ok(output_ok)
                    })(),
                )
            }
        },
    )
}
fn wire__crate__binding__node_credentials_impl(
    port_: flutter_rust_bridge::for_generated::MessagePort,
) {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::<flutter_rust_bridge::for_generated::DcoCodec, _, _>(
        flutter_rust_bridge::for_generated::TaskInfo {
            debug_name: "node_credentials",
            port: Some(port_),
            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
        },
        move || {
            move |context| {
                transform_result_dco::<_, _, flutter_rust_bridge::for_generated::anyhow::Error>(
                    (move || {
                        let output_ok = crate::binding::node_credentials()?;
                        Ok(output_ok)
                    })(),
                )
            }
        },
    )
}
fn wire__crate__binding__node_info_impl(port_: flutter_rust_bridge::for_generated::MessagePort) {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::<flutter_rust_bridge::for_generated::DcoCodec, _, _>(
        flutter_rust_bridge::for_generated::TaskInfo {
            debug_name: "node_info",
            port: Some(port_),
            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
        },
        move || {
            move |context| {
                transform_result_dco::<_, _, flutter_rust_bridge::for_generated::anyhow::Error>(
                    (move || {
                        let output_ok = crate::binding::node_info()?;
                        Ok(output_ok)
                    })(),
                )
            }
        },
    )
}
fn wire__crate__binding__onchain_payment_limits_impl(
    port_: flutter_rust_bridge::for_generated::MessagePort,
) {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::<flutter_rust_bridge::for_generated::DcoCodec, _, _>(
        flutter_rust_bridge::for_generated::TaskInfo {
            debug_name: "onchain_payment_limits",
            port: Some(port_),
            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
        },
        move || {
            move |context| {
                transform_result_dco::<_, _, flutter_rust_bridge::for_generated::anyhow::Error>(
                    (move || {
                        let output_ok = crate::binding::onchain_payment_limits()?;
                        Ok(output_ok)
                    })(),
                )
            }
        },
    )
}
fn wire__crate__binding__open_channel_fee_impl(
    port_: flutter_rust_bridge::for_generated::MessagePort,
    req: impl CstDecode<crate::models::OpenChannelFeeRequest>,
) {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::<flutter_rust_bridge::for_generated::DcoCodec, _, _>(
        flutter_rust_bridge::for_generated::TaskInfo {
            debug_name: "open_channel_fee",
            port: Some(port_),
            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
        },
        move || {
            let api_req = req.cst_decode();
            move |context| {
                transform_result_dco::<_, _, flutter_rust_bridge::for_generated::anyhow::Error>(
                    (move || {
                        let output_ok = crate::binding::open_channel_fee(api_req)?;
                        Ok(output_ok)
                    })(),
                )
            }
        },
    )
}
fn wire__crate__binding__parse_input_impl(
    port_: flutter_rust_bridge::for_generated::MessagePort,
    input: impl CstDecode<String>,
) {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::<flutter_rust_bridge::for_generated::DcoCodec, _, _>(
        flutter_rust_bridge::for_generated::TaskInfo {
            debug_name: "parse_input",
            port: Some(port_),
            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
        },
        move || {
            let api_input = input.cst_decode();
            move |context| {
                transform_result_dco::<_, _, flutter_rust_bridge::for_generated::anyhow::Error>(
                    (move || {
                        let output_ok = crate::binding::parse_input(api_input)?;
                        Ok(output_ok)
                    })(),
                )
            }
        },
    )
}
fn wire__crate__binding__parse_invoice_impl(
    port_: flutter_rust_bridge::for_generated::MessagePort,
    invoice: impl CstDecode<String>,
) {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::<flutter_rust_bridge::for_generated::DcoCodec, _, _>(
        flutter_rust_bridge::for_generated::TaskInfo {
            debug_name: "parse_invoice",
            port: Some(port_),
            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
        },
        move || {
            let api_invoice = invoice.cst_decode();
            move |context| {
                transform_result_dco::<_, _, flutter_rust_bridge::for_generated::anyhow::Error>(
                    (move || {
                        let output_ok = crate::binding::parse_invoice(api_invoice)?;
                        Ok(output_ok)
                    })(),
                )
            }
        },
    )
}
fn wire__crate__binding__pay_onchain_impl(
    port_: flutter_rust_bridge::for_generated::MessagePort,
    req: impl CstDecode<crate::models::PayOnchainRequest>,
) {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::<flutter_rust_bridge::for_generated::DcoCodec, _, _>(
        flutter_rust_bridge::for_generated::TaskInfo {
            debug_name: "pay_onchain",
            port: Some(port_),
            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
        },
        move || {
            let api_req = req.cst_decode();
            move |context| {
                transform_result_dco::<_, _, flutter_rust_bridge::for_generated::anyhow::Error>(
                    (move || {
                        let output_ok = crate::binding::pay_onchain(api_req)?;
                        Ok(output_ok)
                    })(),
                )
            }
        },
    )
}
fn wire__crate__binding__payment_by_hash_impl(
    port_: flutter_rust_bridge::for_generated::MessagePort,
    hash: impl CstDecode<String>,
) {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::<flutter_rust_bridge::for_generated::DcoCodec, _, _>(
        flutter_rust_bridge::for_generated::TaskInfo {
            debug_name: "payment_by_hash",
            port: Some(port_),
            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
        },
        move || {
            let api_hash = hash.cst_decode();
            move |context| {
                transform_result_dco::<_, _, flutter_rust_bridge::for_generated::anyhow::Error>(
                    (move || {
                        let output_ok = crate::binding::payment_by_hash(api_hash)?;
                        Ok(output_ok)
                    })(),
                )
            }
        },
    )
}
fn wire__crate__binding__prepare_onchain_payment_impl(
    port_: flutter_rust_bridge::for_generated::MessagePort,
    req: impl CstDecode<crate::models::PrepareOnchainPaymentRequest>,
) {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::<flutter_rust_bridge::for_generated::DcoCodec, _, _>(
        flutter_rust_bridge::for_generated::TaskInfo {
            debug_name: "prepare_onchain_payment",
            port: Some(port_),
            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
        },
        move || {
            let api_req = req.cst_decode();
            move |context| {
                transform_result_dco::<_, _, flutter_rust_bridge::for_generated::anyhow::Error>(
                    (move || {
                        let output_ok = crate::binding::prepare_onchain_payment(api_req)?;
                        Ok(output_ok)
                    })(),
                )
            }
        },
    )
}
fn wire__crate__binding__prepare_redeem_onchain_funds_impl(
    port_: flutter_rust_bridge::for_generated::MessagePort,
    req: impl CstDecode<crate::models::PrepareRedeemOnchainFundsRequest>,
) {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::<flutter_rust_bridge::for_generated::DcoCodec, _, _>(
        flutter_rust_bridge::for_generated::TaskInfo {
            debug_name: "prepare_redeem_onchain_funds",
            port: Some(port_),
            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
        },
        move || {
            let api_req = req.cst_decode();
            move |context| {
                transform_result_dco::<_, _, flutter_rust_bridge::for_generated::anyhow::Error>(
                    (move || {
                        let output_ok = crate::binding::prepare_redeem_onchain_funds(api_req)?;
                        Ok(output_ok)
                    })(),
                )
            }
        },
    )
}
fn wire__crate__binding__prepare_refund_impl(
    port_: flutter_rust_bridge::for_generated::MessagePort,
    req: impl CstDecode<crate::models::PrepareRefundRequest>,
) {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::<flutter_rust_bridge::for_generated::DcoCodec, _, _>(
        flutter_rust_bridge::for_generated::TaskInfo {
            debug_name: "prepare_refund",
            port: Some(port_),
            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
        },
        move || {
            let api_req = req.cst_decode();
            move |context| {
                transform_result_dco::<_, _, flutter_rust_bridge::for_generated::anyhow::Error>(
                    (move || {
                        let output_ok = crate::binding::prepare_refund(api_req)?;
                        Ok(output_ok)
                    })(),
                )
            }
        },
    )
}
fn wire__crate__binding__receive_onchain_impl(
    port_: flutter_rust_bridge::for_generated::MessagePort,
    req: impl CstDecode<crate::models::ReceiveOnchainRequest>,
) {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::<flutter_rust_bridge::for_generated::DcoCodec, _, _>(
        flutter_rust_bridge::for_generated::TaskInfo {
            debug_name: "receive_onchain",
            port: Some(port_),
            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
        },
        move || {
            let api_req = req.cst_decode();
            move |context| {
                transform_result_dco::<_, _, flutter_rust_bridge::for_generated::anyhow::Error>(
                    (move || {
                        let output_ok = crate::binding::receive_onchain(api_req)?;
                        Ok(output_ok)
                    })(),
                )
            }
        },
    )
}
fn wire__crate__binding__receive_payment_impl(
    port_: flutter_rust_bridge::for_generated::MessagePort,
    req: impl CstDecode<crate::models::ReceivePaymentRequest>,
) {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::<flutter_rust_bridge::for_generated::DcoCodec, _, _>(
        flutter_rust_bridge::for_generated::TaskInfo {
            debug_name: "receive_payment",
            port: Some(port_),
            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
        },
        move || {
            let api_req = req.cst_decode();
            move |context| {
                transform_result_dco::<_, _, flutter_rust_bridge::for_generated::anyhow::Error>(
                    (move || {
                        let output_ok = crate::binding::receive_payment(api_req)?;
                        Ok(output_ok)
                    })(),
                )
            }
        },
    )
}
fn wire__crate__binding__recommended_fees_impl(
    port_: flutter_rust_bridge::for_generated::MessagePort,
) {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::<flutter_rust_bridge::for_generated::DcoCodec, _, _>(
        flutter_rust_bridge::for_generated::TaskInfo {
            debug_name: "recommended_fees",
            port: Some(port_),
            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
        },
        move || {
            move |context| {
                transform_result_dco::<_, _, flutter_rust_bridge::for_generated::anyhow::Error>(
                    (move || {
                        let output_ok = crate::binding::recommended_fees()?;
                        Ok(output_ok)
                    })(),
                )
            }
        },
    )
}
fn wire__crate__binding__redeem_onchain_funds_impl(
    port_: flutter_rust_bridge::for_generated::MessagePort,
    req: impl CstDecode<crate::models::RedeemOnchainFundsRequest>,
) {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::<flutter_rust_bridge::for_generated::DcoCodec, _, _>(
        flutter_rust_bridge::for_generated::TaskInfo {
            debug_name: "redeem_onchain_funds",
            port: Some(port_),
            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
        },
        move || {
            let api_req = req.cst_decode();
            move |context| {
                transform_result_dco::<_, _, flutter_rust_bridge::for_generated::anyhow::Error>(
                    (move || {
                        let output_ok = crate::binding::redeem_onchain_funds(api_req)?;
                        Ok(output_ok)
                    })(),
                )
            }
        },
    )
}
fn wire__crate__binding__redeem_swap_impl(
    port_: flutter_rust_bridge::for_generated::MessagePort,
    swap_address: impl CstDecode<String>,
) {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::<flutter_rust_bridge::for_generated::DcoCodec, _, _>(
        flutter_rust_bridge::for_generated::TaskInfo {
            debug_name: "redeem_swap",
            port: Some(port_),
            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
        },
        move || {
            let api_swap_address = swap_address.cst_decode();
            move |context| {
                transform_result_dco::<_, _, flutter_rust_bridge::for_generated::anyhow::Error>(
                    (move || {
                        let output_ok = crate::binding::redeem_swap(api_swap_address)?;
                        Ok(output_ok)
                    })(),
                )
            }
        },
    )
}
fn wire__crate__binding__refund_impl(
    port_: flutter_rust_bridge::for_generated::MessagePort,
    req: impl CstDecode<crate::models::RefundRequest>,
) {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::<flutter_rust_bridge::for_generated::DcoCodec, _, _>(
        flutter_rust_bridge::for_generated::TaskInfo {
            debug_name: "refund",
            port: Some(port_),
            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
        },
        move || {
            let api_req = req.cst_decode();
            move |context| {
                transform_result_dco::<_, _, flutter_rust_bridge::for_generated::anyhow::Error>(
                    (move || {
                        let output_ok = crate::binding::refund(api_req)?;
                        Ok(output_ok)
                    })(),
                )
            }
        },
    )
}
fn wire__crate__binding__register_webhook_impl(
    port_: flutter_rust_bridge::for_generated::MessagePort,
    webhook_url: impl CstDecode<String>,
) {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::<flutter_rust_bridge::for_generated::DcoCodec, _, _>(
        flutter_rust_bridge::for_generated::TaskInfo {
            debug_name: "register_webhook",
            port: Some(port_),
            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
        },
        move || {
            let api_webhook_url = webhook_url.cst_decode();
            move |context| {
                transform_result_dco::<_, _, flutter_rust_bridge::for_generated::anyhow::Error>(
                    (move || {
                        let output_ok = crate::binding::register_webhook(api_webhook_url)?;
                        Ok(output_ok)
                    })(),
                )
            }
        },
    )
}
fn wire__crate__binding__report_issue_impl(
    port_: flutter_rust_bridge::for_generated::MessagePort,
    req: impl CstDecode<crate::models::ReportIssueRequest>,
) {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::<flutter_rust_bridge::for_generated::DcoCodec, _, _>(
        flutter_rust_bridge::for_generated::TaskInfo {
            debug_name: "report_issue",
            port: Some(port_),
            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
        },
        move || {
            let api_req = req.cst_decode();
            move |context| {
                transform_result_dco::<_, _, flutter_rust_bridge::for_generated::anyhow::Error>(
                    (move || {
                        let output_ok = crate::binding::report_issue(api_req)?;
                        Ok(output_ok)
                    })(),
                )
            }
        },
    )
}
fn wire__crate__binding__rescan_swaps_impl(port_: flutter_rust_bridge::for_generated::MessagePort) {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::<flutter_rust_bridge::for_generated::DcoCodec, _, _>(
        flutter_rust_bridge::for_generated::TaskInfo {
            debug_name: "rescan_swaps",
            port: Some(port_),
            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
        },
        move || {
            move |context| {
                transform_result_dco::<_, _, flutter_rust_bridge::for_generated::anyhow::Error>(
                    (move || {
                        let output_ok = crate::binding::rescan_swaps()?;
                        Ok(output_ok)
                    })(),
                )
            }
        },
    )
}
fn wire__crate__binding__send_payment_impl(
    port_: flutter_rust_bridge::for_generated::MessagePort,
    req: impl CstDecode<crate::models::SendPaymentRequest>,
) {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::<flutter_rust_bridge::for_generated::DcoCodec, _, _>(
        flutter_rust_bridge::for_generated::TaskInfo {
            debug_name: "send_payment",
            port: Some(port_),
            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
        },
        move || {
            let api_req = req.cst_decode();
            move |context| {
                transform_result_dco::<_, _, flutter_rust_bridge::for_generated::anyhow::Error>(
                    (move || {
                        let output_ok = crate::binding::send_payment(api_req)?;
                        Ok(output_ok)
                    })(),
                )
            }
        },
    )
}
fn wire__crate__binding__send_spontaneous_payment_impl(
    port_: flutter_rust_bridge::for_generated::MessagePort,
    req: impl CstDecode<crate::models::SendSpontaneousPaymentRequest>,
) {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::<flutter_rust_bridge::for_generated::DcoCodec, _, _>(
        flutter_rust_bridge::for_generated::TaskInfo {
            debug_name: "send_spontaneous_payment",
            port: Some(port_),
            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
        },
        move || {
            let api_req = req.cst_decode();
            move |context| {
                transform_result_dco::<_, _, flutter_rust_bridge::for_generated::anyhow::Error>(
                    (move || {
                        let output_ok = crate::binding::send_spontaneous_payment(api_req)?;
                        Ok(output_ok)
                    })(),
                )
            }
        },
    )
}
fn wire__crate__binding__service_health_check_impl(
    port_: flutter_rust_bridge::for_generated::MessagePort,
    api_key: impl CstDecode<String>,
) {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::<flutter_rust_bridge::for_generated::DcoCodec, _, _>(
        flutter_rust_bridge::for_generated::TaskInfo {
            debug_name: "service_health_check",
            port: Some(port_),
            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
        },
        move || {
            let api_api_key = api_key.cst_decode();
            move |context| {
                transform_result_dco::<_, _, flutter_rust_bridge::for_generated::anyhow::Error>(
                    (move || {
                        let output_ok = crate::binding::service_health_check(api_api_key)?;
                        Ok(output_ok)
                    })(),
                )
            }
        },
    )
}
fn wire__crate__binding__set_payment_metadata_impl(
    port_: flutter_rust_bridge::for_generated::MessagePort,
    hash: impl CstDecode<String>,
    metadata: impl CstDecode<String>,
) {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::<flutter_rust_bridge::for_generated::DcoCodec, _, _>(
        flutter_rust_bridge::for_generated::TaskInfo {
            debug_name: "set_payment_metadata",
            port: Some(port_),
            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
        },
        move || {
            let api_hash = hash.cst_decode();
            let api_metadata = metadata.cst_decode();
            move |context| {
                transform_result_dco::<_, _, flutter_rust_bridge::for_generated::anyhow::Error>(
                    (move || {
                        let output_ok =
                            crate::binding::set_payment_metadata(api_hash, api_metadata)?;
                        Ok(output_ok)
                    })(),
                )
            }
        },
    )
}
fn wire__crate__binding__sign_message_impl(
    port_: flutter_rust_bridge::for_generated::MessagePort,
    req: impl CstDecode<crate::breez_services::SignMessageRequest>,
) {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::<flutter_rust_bridge::for_generated::DcoCodec, _, _>(
        flutter_rust_bridge::for_generated::TaskInfo {
            debug_name: "sign_message",
            port: Some(port_),
            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
        },
        move || {
            let api_req = req.cst_decode();
            move |context| {
                transform_result_dco::<_, _, flutter_rust_bridge::for_generated::anyhow::Error>(
                    (move || {
                        let output_ok = crate::binding::sign_message(api_req)?;
                        Ok(output_ok)
                    })(),
                )
            }
        },
    )
}
fn wire__crate__binding__static_backup_impl(
    port_: flutter_rust_bridge::for_generated::MessagePort,
    req: impl CstDecode<crate::models::StaticBackupRequest>,
) {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::<flutter_rust_bridge::for_generated::DcoCodec, _, _>(
        flutter_rust_bridge::for_generated::TaskInfo {
            debug_name: "static_backup",
            port: Some(port_),
            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
        },
        move || {
            let api_req = req.cst_decode();
            move |context| {
                transform_result_dco::<_, _, flutter_rust_bridge::for_generated::anyhow::Error>(
                    (move || {
                        let output_ok = crate::binding::static_backup(api_req)?;
                        Ok(output_ok)
                    })(),
                )
            }
        },
    )
}
fn wire__crate__binding__sync_impl(port_: flutter_rust_bridge::for_generated::MessagePort) {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::<flutter_rust_bridge::for_generated::DcoCodec, _, _>(
        flutter_rust_bridge::for_generated::TaskInfo {
            debug_name: "sync(dart_style=sync)",
            port: Some(port_),
            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
        },
        move || {
            move |context| {
                transform_result_dco::<_, _, flutter_rust_bridge::for_generated::anyhow::Error>(
                    (move || {
                        let output_ok = crate::binding::sync()?;
                        Ok(output_ok)
                    })(),
                )
            }
        },
    )
}
fn wire__crate__binding__unregister_webhook_impl(
    port_: flutter_rust_bridge::for_generated::MessagePort,
    webhook_url: impl CstDecode<String>,
) {
    FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::<flutter_rust_bridge::for_generated::DcoCodec, _, _>(
        flutter_rust_bridge::for_generated::TaskInfo {
            debug_name: "unregister_webhook",
            port: Some(port_),
            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
        },
        move || {
            let api_webhook_url = webhook_url.cst_decode();
            move |context| {
                transform_result_dco::<_, _, flutter_rust_bridge::for_generated::anyhow::Error>(
                    (move || {
                        let output_ok = crate::binding::unregister_webhook(api_webhook_url)?;
                        Ok(output_ok)
                    })(),
                )
            }
        },
    )
}

// Section: static_checks

#[allow(clippy::unnecessary_literal_unwrap)]
const _: fn() = || {
    {
        let AesSuccessActionDataDecrypted =
            None::<crate::binding::AesSuccessActionDataDecrypted>.unwrap();
        let _: String = AesSuccessActionDataDecrypted.description;
        let _: String = AesSuccessActionDataDecrypted.plaintext;
    }
    match None::<crate::binding::AesSuccessActionDataResult>.unwrap() {
        crate::binding::AesSuccessActionDataResult::Decrypted { data } => {
            let _: crate::binding::AesSuccessActionDataDecrypted = data;
        }
        crate::binding::AesSuccessActionDataResult::ErrorStatus { reason } => {
            let _: String = reason;
        }
    }
    {
        let BitcoinAddressData = None::<crate::binding::BitcoinAddressData>.unwrap();
        let _: String = BitcoinAddressData.address;
        let _: crate::binding::Network = BitcoinAddressData.network;
        let _: Option<u64> = BitcoinAddressData.amount_sat;
        let _: Option<String> = BitcoinAddressData.label;
        let _: Option<String> = BitcoinAddressData.message;
    }
    {
        let CurrencyInfo = None::<crate::binding::CurrencyInfo>.unwrap();
        let _: String = CurrencyInfo.name;
        let _: u32 = CurrencyInfo.fraction_size;
        let _: Option<u32> = CurrencyInfo.spacing;
        let _: Option<crate::binding::Symbol> = CurrencyInfo.symbol;
        let _: Option<crate::binding::Symbol> = CurrencyInfo.uniq_symbol;
        let _: Vec<crate::binding::LocalizedName> = CurrencyInfo.localized_name;
        let _: Vec<crate::binding::LocaleOverrides> = CurrencyInfo.locale_overrides;
    }
    {
        let FiatCurrency = None::<crate::binding::FiatCurrency>.unwrap();
        let _: String = FiatCurrency.id;
        let _: crate::binding::CurrencyInfo = FiatCurrency.info;
    }
    match None::<crate::binding::InputType>.unwrap() {
        crate::binding::InputType::BitcoinAddress { address } => {
            let _: crate::binding::BitcoinAddressData = address;
        }
        crate::binding::InputType::Bolt11 { invoice } => {
            let _: crate::binding::LNInvoice = invoice;
        }
        crate::binding::InputType::NodeId { node_id } => {
            let _: String = node_id;
        }
        crate::binding::InputType::Url { url } => {
            let _: String = url;
        }
        crate::binding::InputType::LnUrlPay {
            data,
            bip353_address,
        } => {
            let _: crate::binding::LnUrlPayRequestData = data;
            let _: Option<String> = bip353_address;
        }
        crate::binding::InputType::LnUrlWithdraw { data } => {
            let _: crate::binding::LnUrlWithdrawRequestData = data;
        }
        crate::binding::InputType::LnUrlAuth { data } => {
            let _: crate::binding::LnUrlAuthRequestData = data;
        }
        crate::binding::InputType::LnUrlError { data } => {
            let _: crate::binding::LnUrlErrorData = data;
        }
    }
    {
        let LNInvoice = None::<crate::binding::LNInvoice>.unwrap();
        let _: String = LNInvoice.bolt11;
        let _: crate::binding::Network = LNInvoice.network;
        let _: String = LNInvoice.payee_pubkey;
        let _: String = LNInvoice.payment_hash;
        let _: Option<String> = LNInvoice.description;
        let _: Option<String> = LNInvoice.description_hash;
        let _: Option<u64> = LNInvoice.amount_msat;
        let _: u64 = LNInvoice.timestamp;
        let _: u64 = LNInvoice.expiry;
        let _: Vec<crate::binding::RouteHint> = LNInvoice.routing_hints;
        let _: Vec<u8> = LNInvoice.payment_secret;
        let _: u64 = LNInvoice.min_final_cltv_expiry_delta;
    }
    {
        let LnUrlAuthRequestData = None::<crate::binding::LnUrlAuthRequestData>.unwrap();
        let _: String = LnUrlAuthRequestData.k1;
        let _: Option<String> = LnUrlAuthRequestData.action;
        let _: String = LnUrlAuthRequestData.domain;
        let _: String = LnUrlAuthRequestData.url;
    }
    match None::<crate::binding::LnUrlCallbackStatus>.unwrap() {
        crate::binding::LnUrlCallbackStatus::Ok => {}
        crate::binding::LnUrlCallbackStatus::ErrorStatus { data } => {
            let _: crate::binding::LnUrlErrorData = data;
        }
    }
    {
        let LnUrlErrorData = None::<crate::binding::LnUrlErrorData>.unwrap();
        let _: String = LnUrlErrorData.reason;
    }
    {
        let LnUrlPayErrorData = None::<crate::binding::LnUrlPayErrorData>.unwrap();
        let _: String = LnUrlPayErrorData.payment_hash;
        let _: String = LnUrlPayErrorData.reason;
    }
    {
        let LnUrlPayRequest = None::<crate::binding::LnUrlPayRequest>.unwrap();
        let _: crate::binding::LnUrlPayRequestData = LnUrlPayRequest.data;
        let _: u64 = LnUrlPayRequest.amount_msat;
        let _: bool = LnUrlPayRequest.use_trampoline;
        let _: Option<String> = LnUrlPayRequest.comment;
        let _: Option<String> = LnUrlPayRequest.payment_label;
        let _: Option<bool> = LnUrlPayRequest.validate_success_action_url;
    }
    {
        let LnUrlPayRequestData = None::<crate::binding::LnUrlPayRequestData>.unwrap();
        let _: String = LnUrlPayRequestData.callback;
        let _: u64 = LnUrlPayRequestData.min_sendable;
        let _: u64 = LnUrlPayRequestData.max_sendable;
        let _: String = LnUrlPayRequestData.metadata_str;
        let _: u16 = LnUrlPayRequestData.comment_allowed;
        let _: String = LnUrlPayRequestData.domain;
        let _: bool = LnUrlPayRequestData.allows_nostr;
        let _: Option<String> = LnUrlPayRequestData.nostr_pubkey;
        let _: Option<String> = LnUrlPayRequestData.ln_address;
    }
    {
        let LnUrlWithdrawRequest = None::<crate::binding::LnUrlWithdrawRequest>.unwrap();
        let _: crate::binding::LnUrlWithdrawRequestData = LnUrlWithdrawRequest.data;
        let _: u64 = LnUrlWithdrawRequest.amount_msat;
        let _: Option<String> = LnUrlWithdrawRequest.description;
    }
    {
        let LnUrlWithdrawRequestData = None::<crate::binding::LnUrlWithdrawRequestData>.unwrap();
        let _: String = LnUrlWithdrawRequestData.callback;
        let _: String = LnUrlWithdrawRequestData.k1;
        let _: String = LnUrlWithdrawRequestData.default_description;
        let _: u64 = LnUrlWithdrawRequestData.min_withdrawable;
        let _: u64 = LnUrlWithdrawRequestData.max_withdrawable;
    }
    match None::<crate::binding::LnUrlWithdrawResult>.unwrap() {
        crate::binding::LnUrlWithdrawResult::Ok { data } => {
            let _: crate::binding::LnUrlWithdrawSuccessData = data;
        }
        crate::binding::LnUrlWithdrawResult::Timeout { data } => {
            let _: crate::binding::LnUrlWithdrawSuccessData = data;
        }
        crate::binding::LnUrlWithdrawResult::ErrorStatus { data } => {
            let _: crate::binding::LnUrlErrorData = data;
        }
    }
    {
        let LnUrlWithdrawSuccessData = None::<crate::binding::LnUrlWithdrawSuccessData>.unwrap();
        let _: crate::binding::LNInvoice = LnUrlWithdrawSuccessData.invoice;
    }
    {
        let LocaleOverrides = None::<crate::binding::LocaleOverrides>.unwrap();
        let _: String = LocaleOverrides.locale;
        let _: Option<u32> = LocaleOverrides.spacing;
        let _: crate::binding::Symbol = LocaleOverrides.symbol;
    }
    {
        let LocalizedName = None::<crate::binding::LocalizedName>.unwrap();
        let _: String = LocalizedName.locale;
        let _: String = LocalizedName.name;
    }
    {
        let MessageSuccessActionData = None::<crate::binding::MessageSuccessActionData>.unwrap();
        let _: String = MessageSuccessActionData.message;
    }
    {
        let Rate = None::<crate::binding::Rate>.unwrap();
        let _: String = Rate.coin;
        let _: f64 = Rate.value;
    }
    {
        let RouteHint = None::<crate::binding::RouteHint>.unwrap();
        let _: Vec<crate::binding::RouteHintHop> = RouteHint.hops;
    }
    {
        let RouteHintHop = None::<crate::binding::RouteHintHop>.unwrap();
        let _: String = RouteHintHop.src_node_id;
        let _: String = RouteHintHop.short_channel_id;
        let _: u32 = RouteHintHop.fees_base_msat;
        let _: u32 = RouteHintHop.fees_proportional_millionths;
        let _: u64 = RouteHintHop.cltv_expiry_delta;
        let _: Option<u64> = RouteHintHop.htlc_minimum_msat;
        let _: Option<u64> = RouteHintHop.htlc_maximum_msat;
    }
    match None::<crate::binding::SuccessActionProcessed>.unwrap() {
        crate::binding::SuccessActionProcessed::Aes { result } => {
            let _: crate::binding::AesSuccessActionDataResult = result;
        }
        crate::binding::SuccessActionProcessed::Message { data } => {
            let _: crate::binding::MessageSuccessActionData = data;
        }
        crate::binding::SuccessActionProcessed::Url { data } => {
            let _: crate::binding::UrlSuccessActionData = data;
        }
    }
    {
        let Symbol = None::<crate::binding::Symbol>.unwrap();
        let _: Option<String> = Symbol.grapheme;
        let _: Option<String> = Symbol.template;
        let _: Option<bool> = Symbol.rtl;
        let _: Option<u32> = Symbol.position;
    }
    {
        let UrlSuccessActionData = None::<crate::binding::UrlSuccessActionData>.unwrap();
        let _: String = UrlSuccessActionData.description;
        let _: String = UrlSuccessActionData.url;
        let _: bool = UrlSuccessActionData.matches_callback_domain;
    }
};

// Section: dart2rust

impl CstDecode<bool> for bool {
    // Codec=Cst (C-struct based), see doc to use other codecs
    fn cst_decode(self) -> bool {
        self
    }
}
impl CstDecode<crate::models::BuyBitcoinProvider> for i32 {
    // Codec=Cst (C-struct based), see doc to use other codecs
    fn cst_decode(self) -> crate::models::BuyBitcoinProvider {
        match self {
            0 => crate::models::BuyBitcoinProvider::Moonpay,
            _ => unreachable!("Invalid variant for BuyBitcoinProvider: {}", self),
        }
    }
}
impl CstDecode<crate::models::ChannelState> for i32 {
    // Codec=Cst (C-struct based), see doc to use other codecs
    fn cst_decode(self) -> crate::models::ChannelState {
        match self {
            0 => crate::models::ChannelState::PendingOpen,
            1 => crate::models::ChannelState::Opened,
            2 => crate::models::ChannelState::PendingClose,
            3 => crate::models::ChannelState::Closed,
            _ => unreachable!("Invalid variant for ChannelState: {}", self),
        }
    }
}
impl CstDecode<crate::models::EnvironmentType> for i32 {
    // Codec=Cst (C-struct based), see doc to use other codecs
    fn cst_decode(self) -> crate::models::EnvironmentType {
        match self {
            0 => crate::models::EnvironmentType::Production,
            1 => crate::models::EnvironmentType::Staging,
            2 => crate::models::EnvironmentType::Regtest,
            _ => unreachable!("Invalid variant for EnvironmentType: {}", self),
        }
    }
}
impl CstDecode<f64> for f64 {
    // Codec=Cst (C-struct based), see doc to use other codecs
    fn cst_decode(self) -> f64 {
        self
    }
}
impl CstDecode<crate::models::HealthCheckStatus> for i32 {
    // Codec=Cst (C-struct based), see doc to use other codecs
    fn cst_decode(self) -> crate::models::HealthCheckStatus {
        match self {
            0 => crate::models::HealthCheckStatus::Operational,
            1 => crate::models::HealthCheckStatus::Maintenance,
            2 => crate::models::HealthCheckStatus::ServiceDisruption,
            _ => unreachable!("Invalid variant for HealthCheckStatus: {}", self),
        }
    }
}
impl CstDecode<i32> for i32 {
    // Codec=Cst (C-struct based), see doc to use other codecs
    fn cst_decode(self) -> i32 {
        self
    }
}
impl CstDecode<i64> for i64 {
    // Codec=Cst (C-struct based), see doc to use other codecs
    fn cst_decode(self) -> i64 {
        self
    }
}
impl CstDecode<crate::binding::Network> for i32 {
    // Codec=Cst (C-struct based), see doc to use other codecs
    fn cst_decode(self) -> crate::binding::Network {
        match self {
            0 => crate::binding::Network::Bitcoin,
            1 => crate::binding::Network::Testnet,
            2 => crate::binding::Network::Signet,
            3 => crate::binding::Network::Regtest,
            _ => unreachable!("Invalid variant for Network: {}", self),
        }
    }
}
impl CstDecode<crate::models::PaymentStatus> for i32 {
    // Codec=Cst (C-struct based), see doc to use other codecs
    fn cst_decode(self) -> crate::models::PaymentStatus {
        match self {
            0 => crate::models::PaymentStatus::Pending,
            1 => crate::models::PaymentStatus::Complete,
            2 => crate::models::PaymentStatus::Failed,
            _ => unreachable!("Invalid variant for PaymentStatus: {}", self),
        }
    }
}
impl CstDecode<crate::models::PaymentType> for i32 {
    // Codec=Cst (C-struct based), see doc to use other codecs
    fn cst_decode(self) -> crate::models::PaymentType {
        match self {
            0 => crate::models::PaymentType::Sent,
            1 => crate::models::PaymentType::Received,
            2 => crate::models::PaymentType::ClosedChannel,
            _ => unreachable!("Invalid variant for PaymentType: {}", self),
        }
    }
}
impl CstDecode<crate::models::PaymentTypeFilter> for i32 {
    // Codec=Cst (C-struct based), see doc to use other codecs
    fn cst_decode(self) -> crate::models::PaymentTypeFilter {
        match self {
            0 => crate::models::PaymentTypeFilter::Sent,
            1 => crate::models::PaymentTypeFilter::Received,
            2 => crate::models::PaymentTypeFilter::ClosedChannel,
            _ => unreachable!("Invalid variant for PaymentTypeFilter: {}", self),
        }
    }
}
impl CstDecode<crate::models::ReverseSwapStatus> for i32 {
    // Codec=Cst (C-struct based), see doc to use other codecs
    fn cst_decode(self) -> crate::models::ReverseSwapStatus {
        match self {
            0 => crate::models::ReverseSwapStatus::Initial,
            1 => crate::models::ReverseSwapStatus::InProgress,
            2 => crate::models::ReverseSwapStatus::Cancelled,
            3 => crate::models::ReverseSwapStatus::CompletedSeen,
            4 => crate::models::ReverseSwapStatus::CompletedConfirmed,
            _ => unreachable!("Invalid variant for ReverseSwapStatus: {}", self),
        }
    }
}
impl CstDecode<crate::models::SwapAmountType> for i32 {
    // Codec=Cst (C-struct based), see doc to use other codecs
    fn cst_decode(self) -> crate::models::SwapAmountType {
        match self {
            0 => crate::models::SwapAmountType::Send,
            1 => crate::models::SwapAmountType::Receive,
            _ => unreachable!("Invalid variant for SwapAmountType: {}", self),
        }
    }
}
impl CstDecode<crate::models::SwapStatus> for i32 {
    // Codec=Cst (C-struct based), see doc to use other codecs
    fn cst_decode(self) -> crate::models::SwapStatus {
        match self {
            0 => crate::models::SwapStatus::Initial,
            1 => crate::models::SwapStatus::WaitingConfirmation,
            2 => crate::models::SwapStatus::Redeemable,
            3 => crate::models::SwapStatus::Redeemed,
            4 => crate::models::SwapStatus::Refundable,
            5 => crate::models::SwapStatus::Completed,
            _ => unreachable!("Invalid variant for SwapStatus: {}", self),
        }
    }
}
impl CstDecode<u16> for u16 {
    // Codec=Cst (C-struct based), see doc to use other codecs
    fn cst_decode(self) -> u16 {
        self
    }
}
impl CstDecode<u32> for u32 {
    // Codec=Cst (C-struct based), see doc to use other codecs
    fn cst_decode(self) -> u32 {
        self
    }
}
impl CstDecode<u64> for u64 {
    // Codec=Cst (C-struct based), see doc to use other codecs
    fn cst_decode(self) -> u64 {
        self
    }
}
impl CstDecode<u8> for u8 {
    // Codec=Cst (C-struct based), see doc to use other codecs
    fn cst_decode(self) -> u8 {
        self
    }
}
impl SseDecode for flutter_rust_bridge::for_generated::anyhow::Error {
    // 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 = <String>::sse_decode(deserializer);
        return flutter_rust_bridge::for_generated::anyhow::anyhow!("{}", inner);
    }
}

impl SseDecode
    for StreamSink<crate::breez_services::BreezEvent, flutter_rust_bridge::for_generated::DcoCodec>
{
    // 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 = <String>::sse_decode(deserializer);
        return StreamSink::deserialize(inner);
    }
}

impl SseDecode
    for StreamSink<crate::models::LogEntry, flutter_rust_bridge::for_generated::DcoCodec>
{
    // 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 = <String>::sse_decode(deserializer);
        return StreamSink::deserialize(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::binding::AesSuccessActionDataDecrypted {
    // 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_description = <String>::sse_decode(deserializer);
        let mut var_plaintext = <String>::sse_decode(deserializer);
        return crate::binding::AesSuccessActionDataDecrypted {
            description: var_description,
            plaintext: var_plaintext,
        };
    }
}

impl SseDecode for crate::binding::AesSuccessActionDataResult {
    // 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_data =
                    <crate::binding::AesSuccessActionDataDecrypted>::sse_decode(deserializer);
                return crate::binding::AesSuccessActionDataResult::Decrypted { data: var_data };
            }
            1 => {
                let mut var_reason = <String>::sse_decode(deserializer);
                return crate::binding::AesSuccessActionDataResult::ErrorStatus {
                    reason: var_reason,
                };
            }
            _ => {
                unimplemented!("");
            }
        }
    }
}

impl SseDecode for crate::breez_services::BackupFailedData {
    // 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_error = <String>::sse_decode(deserializer);
        return crate::breez_services::BackupFailedData { error: var_error };
    }
}

impl SseDecode for crate::models::BackupStatus {
    // 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_backedUp = <bool>::sse_decode(deserializer);
        let mut var_lastBackupTime = <Option<u64>>::sse_decode(deserializer);
        return crate::models::BackupStatus {
            backed_up: var_backedUp,
            last_backup_time: var_lastBackupTime,
        };
    }
}

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

impl SseDecode for crate::binding::BitcoinAddressData {
    // 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_address = <String>::sse_decode(deserializer);
        let mut var_network = <crate::binding::Network>::sse_decode(deserializer);
        let mut var_amountSat = <Option<u64>>::sse_decode(deserializer);
        let mut var_label = <Option<String>>::sse_decode(deserializer);
        let mut var_message = <Option<String>>::sse_decode(deserializer);
        return crate::binding::BitcoinAddressData {
            address: var_address,
            network: var_network,
            amount_sat: var_amountSat,
            label: var_label,
            message: var_message,
        };
    }
}

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::breez_services::BreezEvent {
    // 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_block = <u32>::sse_decode(deserializer);
                return crate::breez_services::BreezEvent::NewBlock { block: var_block };
            }
            1 => {
                let mut var_details =
                    <crate::breez_services::InvoicePaidDetails>::sse_decode(deserializer);
                return crate::breez_services::BreezEvent::InvoicePaid {
                    details: var_details,
                };
            }
            2 => {
                return crate::breez_services::BreezEvent::Synced;
            }
            3 => {
                let mut var_details = <crate::models::Payment>::sse_decode(deserializer);
                return crate::breez_services::BreezEvent::PaymentSucceed {
                    details: var_details,
                };
            }
            4 => {
                let mut var_details =
                    <crate::breez_services::PaymentFailedData>::sse_decode(deserializer);
                return crate::breez_services::BreezEvent::PaymentFailed {
                    details: var_details,
                };
            }
            5 => {
                return crate::breez_services::BreezEvent::BackupStarted;
            }
            6 => {
                return crate::breez_services::BreezEvent::BackupSucceeded;
            }
            7 => {
                let mut var_details =
                    <crate::breez_services::BackupFailedData>::sse_decode(deserializer);
                return crate::breez_services::BreezEvent::BackupFailed {
                    details: var_details,
                };
            }
            8 => {
                let mut var_details = <crate::models::ReverseSwapInfo>::sse_decode(deserializer);
                return crate::breez_services::BreezEvent::ReverseSwapUpdated {
                    details: var_details,
                };
            }
            9 => {
                let mut var_details = <crate::models::SwapInfo>::sse_decode(deserializer);
                return crate::breez_services::BreezEvent::SwapUpdated {
                    details: var_details,
                };
            }
            _ => {
                unimplemented!("");
            }
        }
    }
}

impl SseDecode for crate::models::BuyBitcoinProvider {
    // 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::models::BuyBitcoinProvider::Moonpay,
            _ => unreachable!("Invalid variant for BuyBitcoinProvider: {}", inner),
        };
    }
}

impl SseDecode for crate::models::BuyBitcoinRequest {
    // 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_provider = <crate::models::BuyBitcoinProvider>::sse_decode(deserializer);
        let mut var_openingFeeParams =
            <Option<crate::models::OpeningFeeParams>>::sse_decode(deserializer);
        let mut var_redirectUrl = <Option<String>>::sse_decode(deserializer);
        return crate::models::BuyBitcoinRequest {
            provider: var_provider,
            opening_fee_params: var_openingFeeParams,
            redirect_url: var_redirectUrl,
        };
    }
}

impl SseDecode for crate::models::BuyBitcoinResponse {
    // 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_url = <String>::sse_decode(deserializer);
        let mut var_openingFeeParams =
            <Option<crate::models::OpeningFeeParams>>::sse_decode(deserializer);
        return crate::models::BuyBitcoinResponse {
            url: var_url,
            opening_fee_params: var_openingFeeParams,
        };
    }
}

impl SseDecode for crate::models::ChannelState {
    // 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::models::ChannelState::PendingOpen,
            1 => crate::models::ChannelState::Opened,
            2 => crate::models::ChannelState::PendingClose,
            3 => crate::models::ChannelState::Closed,
            _ => unreachable!("Invalid variant for ChannelState: {}", inner),
        };
    }
}

impl SseDecode for crate::breez_services::CheckMessageRequest {
    // 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_message = <String>::sse_decode(deserializer);
        let mut var_pubkey = <String>::sse_decode(deserializer);
        let mut var_signature = <String>::sse_decode(deserializer);
        return crate::breez_services::CheckMessageRequest {
            message: var_message,
            pubkey: var_pubkey,
            signature: var_signature,
        };
    }
}

impl SseDecode for crate::breez_services::CheckMessageResponse {
    // 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_isValid = <bool>::sse_decode(deserializer);
        return crate::breez_services::CheckMessageResponse {
            is_valid: var_isValid,
        };
    }
}

impl SseDecode for crate::models::ClosedChannelPaymentDetails {
    // 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_state = <crate::models::ChannelState>::sse_decode(deserializer);
        let mut var_fundingTxid = <String>::sse_decode(deserializer);
        let mut var_shortChannelId = <Option<String>>::sse_decode(deserializer);
        let mut var_closingTxid = <Option<String>>::sse_decode(deserializer);
        return crate::models::ClosedChannelPaymentDetails {
            state: var_state,
            funding_txid: var_fundingTxid,
            short_channel_id: var_shortChannelId,
            closing_txid: var_closingTxid,
        };
    }
}

impl SseDecode for crate::models::Config {
    // 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_breezserver = <String>::sse_decode(deserializer);
        let mut var_chainnotifierUrl = <String>::sse_decode(deserializer);
        let mut var_mempoolspaceUrl = <Option<String>>::sse_decode(deserializer);
        let mut var_workingDir = <String>::sse_decode(deserializer);
        let mut var_network = <crate::binding::Network>::sse_decode(deserializer);
        let mut var_paymentTimeoutSec = <u32>::sse_decode(deserializer);
        let mut var_defaultLspId = <Option<String>>::sse_decode(deserializer);
        let mut var_apiKey = <Option<String>>::sse_decode(deserializer);
        let mut var_maxfeePercent = <f64>::sse_decode(deserializer);
        let mut var_exemptfeeMsat = <u64>::sse_decode(deserializer);
        let mut var_nodeConfig = <crate::models::NodeConfig>::sse_decode(deserializer);
        return crate::models::Config {
            breezserver: var_breezserver,
            chainnotifier_url: var_chainnotifierUrl,
            mempoolspace_url: var_mempoolspaceUrl,
            working_dir: var_workingDir,
            network: var_network,
            payment_timeout_sec: var_paymentTimeoutSec,
            default_lsp_id: var_defaultLspId,
            api_key: var_apiKey,
            maxfee_percent: var_maxfeePercent,
            exemptfee_msat: var_exemptfeeMsat,
            node_config: var_nodeConfig,
        };
    }
}

impl SseDecode for crate::models::ConfigureNodeRequest {
    // 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_closeToAddress = <Option<String>>::sse_decode(deserializer);
        return crate::models::ConfigureNodeRequest {
            close_to_address: var_closeToAddress,
        };
    }
}

impl SseDecode for crate::models::ConnectRequest {
    // 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_config = <crate::models::Config>::sse_decode(deserializer);
        let mut var_seed = <Vec<u8>>::sse_decode(deserializer);
        let mut var_restoreOnly = <Option<bool>>::sse_decode(deserializer);
        return crate::models::ConnectRequest {
            config: var_config,
            seed: var_seed,
            restore_only: var_restoreOnly,
        };
    }
}

impl SseDecode for crate::binding::CurrencyInfo {
    // 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_name = <String>::sse_decode(deserializer);
        let mut var_fractionSize = <u32>::sse_decode(deserializer);
        let mut var_spacing = <Option<u32>>::sse_decode(deserializer);
        let mut var_symbol = <Option<crate::binding::Symbol>>::sse_decode(deserializer);
        let mut var_uniqSymbol = <Option<crate::binding::Symbol>>::sse_decode(deserializer);
        let mut var_localizedName = <Vec<crate::binding::LocalizedName>>::sse_decode(deserializer);
        let mut var_localeOverrides =
            <Vec<crate::binding::LocaleOverrides>>::sse_decode(deserializer);
        return crate::binding::CurrencyInfo {
            name: var_name,
            fraction_size: var_fractionSize,
            spacing: var_spacing,
            symbol: var_symbol,
            uniq_symbol: var_uniqSymbol,
            localized_name: var_localizedName,
            locale_overrides: var_localeOverrides,
        };
    }
}

impl SseDecode for crate::models::EnvironmentType {
    // 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::models::EnvironmentType::Production,
            1 => crate::models::EnvironmentType::Staging,
            2 => crate::models::EnvironmentType::Regtest,
            _ => unreachable!("Invalid variant for EnvironmentType: {}", inner),
        };
    }
}

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::binding::FiatCurrency {
    // 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_id = <String>::sse_decode(deserializer);
        let mut var_info = <crate::binding::CurrencyInfo>::sse_decode(deserializer);
        return crate::binding::FiatCurrency {
            id: var_id,
            info: var_info,
        };
    }
}

impl SseDecode for crate::models::GreenlightCredentials {
    // 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_developerKey = <Vec<u8>>::sse_decode(deserializer);
        let mut var_developerCert = <Vec<u8>>::sse_decode(deserializer);
        return crate::models::GreenlightCredentials {
            developer_key: var_developerKey,
            developer_cert: var_developerCert,
        };
    }
}

impl SseDecode for crate::models::GreenlightDeviceCredentials {
    // 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_device = <Vec<u8>>::sse_decode(deserializer);
        return crate::models::GreenlightDeviceCredentials { device: var_device };
    }
}

impl SseDecode for crate::models::GreenlightNodeConfig {
    // 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_partnerCredentials =
            <Option<crate::models::GreenlightCredentials>>::sse_decode(deserializer);
        let mut var_inviteCode = <Option<String>>::sse_decode(deserializer);
        return crate::models::GreenlightNodeConfig {
            partner_credentials: var_partnerCredentials,
            invite_code: var_inviteCode,
        };
    }
}

impl SseDecode for crate::models::HealthCheckStatus {
    // 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::models::HealthCheckStatus::Operational,
            1 => crate::models::HealthCheckStatus::Maintenance,
            2 => crate::models::HealthCheckStatus::ServiceDisruption,
            _ => unreachable!("Invalid variant for HealthCheckStatus: {}", 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 crate::binding::InputType {
    // 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_address =
                    <crate::binding::BitcoinAddressData>::sse_decode(deserializer);
                return crate::binding::InputType::BitcoinAddress {
                    address: var_address,
                };
            }
            1 => {
                let mut var_invoice = <crate::binding::LNInvoice>::sse_decode(deserializer);
                return crate::binding::InputType::Bolt11 {
                    invoice: var_invoice,
                };
            }
            2 => {
                let mut var_nodeId = <String>::sse_decode(deserializer);
                return crate::binding::InputType::NodeId {
                    node_id: var_nodeId,
                };
            }
            3 => {
                let mut var_url = <String>::sse_decode(deserializer);
                return crate::binding::InputType::Url { url: var_url };
            }
            4 => {
                let mut var_data = <crate::binding::LnUrlPayRequestData>::sse_decode(deserializer);
                let mut var_bip353Address = <Option<String>>::sse_decode(deserializer);
                return crate::binding::InputType::LnUrlPay {
                    data: var_data,
                    bip353_address: var_bip353Address,
                };
            }
            5 => {
                let mut var_data =
                    <crate::binding::LnUrlWithdrawRequestData>::sse_decode(deserializer);
                return crate::binding::InputType::LnUrlWithdraw { data: var_data };
            }
            6 => {
                let mut var_data = <crate::binding::LnUrlAuthRequestData>::sse_decode(deserializer);
                return crate::binding::InputType::LnUrlAuth { data: var_data };
            }
            7 => {
                let mut var_data = <crate::binding::LnUrlErrorData>::sse_decode(deserializer);
                return crate::binding::InputType::LnUrlError { data: var_data };
            }
            _ => {
                unimplemented!("");
            }
        }
    }
}

impl SseDecode for crate::breez_services::InvoicePaidDetails {
    // 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_paymentHash = <String>::sse_decode(deserializer);
        let mut var_bolt11 = <String>::sse_decode(deserializer);
        let mut var_payment = <Option<crate::models::Payment>>::sse_decode(deserializer);
        return crate::breez_services::InvoicePaidDetails {
            payment_hash: var_paymentHash,
            bolt11: var_bolt11,
            payment: var_payment,
        };
    }
}

impl SseDecode for Vec<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 len_ = <i32>::sse_decode(deserializer);
        let mut ans_ = vec![];
        for idx_ in 0..len_ {
            ans_.push(<String>::sse_decode(deserializer));
        }
        return ans_;
    }
}

impl SseDecode for Vec<crate::binding::FiatCurrency> {
    // 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::binding::FiatCurrency>::sse_decode(deserializer));
        }
        return ans_;
    }
}

impl SseDecode for Vec<crate::binding::LocaleOverrides> {
    // 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::binding::LocaleOverrides>::sse_decode(deserializer));
        }
        return ans_;
    }
}

impl SseDecode for Vec<crate::binding::LocalizedName> {
    // 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::binding::LocalizedName>::sse_decode(deserializer));
        }
        return ans_;
    }
}

impl SseDecode for Vec<crate::lsp::LspInformation> {
    // 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::lsp::LspInformation>::sse_decode(deserializer));
        }
        return ans_;
    }
}

impl SseDecode for Vec<crate::models::MetadataFilter> {
    // 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::models::MetadataFilter>::sse_decode(deserializer));
        }
        return ans_;
    }
}

impl SseDecode for Vec<crate::models::OpeningFeeParams> {
    // 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::models::OpeningFeeParams>::sse_decode(deserializer));
        }
        return ans_;
    }
}

impl SseDecode for Vec<crate::models::Payment> {
    // 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::models::Payment>::sse_decode(deserializer));
        }
        return ans_;
    }
}

impl SseDecode for Vec<crate::models::PaymentTypeFilter> {
    // 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::models::PaymentTypeFilter>::sse_decode(deserializer));
        }
        return ans_;
    }
}

impl SseDecode for crate::models::ListPaymentsRequest {
    // 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_filters =
            <Option<Vec<crate::models::PaymentTypeFilter>>>::sse_decode(deserializer);
        let mut var_metadataFilters =
            <Option<Vec<crate::models::MetadataFilter>>>::sse_decode(deserializer);
        let mut var_fromTimestamp = <Option<i64>>::sse_decode(deserializer);
        let mut var_toTimestamp = <Option<i64>>::sse_decode(deserializer);
        let mut var_includeFailures = <Option<bool>>::sse_decode(deserializer);
        let mut var_offset = <Option<u32>>::sse_decode(deserializer);
        let mut var_limit = <Option<u32>>::sse_decode(deserializer);
        return crate::models::ListPaymentsRequest {
            filters: var_filters,
            metadata_filters: var_metadataFilters,
            from_timestamp: var_fromTimestamp,
            to_timestamp: var_toTimestamp,
            include_failures: var_includeFailures,
            offset: var_offset,
            limit: var_limit,
        };
    }
}

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 Vec<crate::binding::Rate> {
    // 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::binding::Rate>::sse_decode(deserializer));
        }
        return ans_;
    }
}

impl SseDecode for Vec<crate::models::ReverseSwapInfo> {
    // 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::models::ReverseSwapInfo>::sse_decode(deserializer));
        }
        return ans_;
    }
}

impl SseDecode for Vec<crate::binding::RouteHint> {
    // 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::binding::RouteHint>::sse_decode(deserializer));
        }
        return ans_;
    }
}

impl SseDecode for Vec<crate::binding::RouteHintHop> {
    // 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::binding::RouteHintHop>::sse_decode(deserializer));
        }
        return ans_;
    }
}

impl SseDecode for Vec<crate::models::SwapInfo> {
    // 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::models::SwapInfo>::sse_decode(deserializer));
        }
        return ans_;
    }
}

impl SseDecode for Vec<crate::models::SwapStatus> {
    // 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::models::SwapStatus>::sse_decode(deserializer));
        }
        return ans_;
    }
}

impl SseDecode for crate::models::ListSwapsRequest {
    // 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_status = <Option<Vec<crate::models::SwapStatus>>>::sse_decode(deserializer);
        let mut var_fromTimestamp = <Option<i64>>::sse_decode(deserializer);
        let mut var_toTimestamp = <Option<i64>>::sse_decode(deserializer);
        let mut var_offset = <Option<u32>>::sse_decode(deserializer);
        let mut var_limit = <Option<u32>>::sse_decode(deserializer);
        return crate::models::ListSwapsRequest {
            status: var_status,
            from_timestamp: var_fromTimestamp,
            to_timestamp: var_toTimestamp,
            offset: var_offset,
            limit: var_limit,
        };
    }
}

impl SseDecode for Vec<crate::models::TlvEntry> {
    // 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::models::TlvEntry>::sse_decode(deserializer));
        }
        return ans_;
    }
}

impl SseDecode for Vec<crate::models::UnspentTransactionOutput> {
    // 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::models::UnspentTransactionOutput>::sse_decode(
                deserializer,
            ));
        }
        return ans_;
    }
}

impl SseDecode for crate::binding::LNInvoice {
    // 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_bolt11 = <String>::sse_decode(deserializer);
        let mut var_network = <crate::binding::Network>::sse_decode(deserializer);
        let mut var_payeePubkey = <String>::sse_decode(deserializer);
        let mut var_paymentHash = <String>::sse_decode(deserializer);
        let mut var_description = <Option<String>>::sse_decode(deserializer);
        let mut var_descriptionHash = <Option<String>>::sse_decode(deserializer);
        let mut var_amountMsat = <Option<u64>>::sse_decode(deserializer);
        let mut var_timestamp = <u64>::sse_decode(deserializer);
        let mut var_expiry = <u64>::sse_decode(deserializer);
        let mut var_routingHints = <Vec<crate::binding::RouteHint>>::sse_decode(deserializer);
        let mut var_paymentSecret = <Vec<u8>>::sse_decode(deserializer);
        let mut var_minFinalCltvExpiryDelta = <u64>::sse_decode(deserializer);
        return crate::binding::LNInvoice {
            bolt11: var_bolt11,
            network: var_network,
            payee_pubkey: var_payeePubkey,
            payment_hash: var_paymentHash,
            description: var_description,
            description_hash: var_descriptionHash,
            amount_msat: var_amountMsat,
            timestamp: var_timestamp,
            expiry: var_expiry,
            routing_hints: var_routingHints,
            payment_secret: var_paymentSecret,
            min_final_cltv_expiry_delta: var_minFinalCltvExpiryDelta,
        };
    }
}

impl SseDecode for crate::models::LnPaymentDetails {
    // 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_paymentHash = <String>::sse_decode(deserializer);
        let mut var_label = <String>::sse_decode(deserializer);
        let mut var_destinationPubkey = <String>::sse_decode(deserializer);
        let mut var_paymentPreimage = <String>::sse_decode(deserializer);
        let mut var_keysend = <bool>::sse_decode(deserializer);
        let mut var_bolt11 = <String>::sse_decode(deserializer);
        let mut var_openChannelBolt11 = <Option<String>>::sse_decode(deserializer);
        let mut var_lnurlSuccessAction =
            <Option<crate::binding::SuccessActionProcessed>>::sse_decode(deserializer);
        let mut var_lnurlPayDomain = <Option<String>>::sse_decode(deserializer);
        let mut var_lnurlPayComment = <Option<String>>::sse_decode(deserializer);
        let mut var_lnAddress = <Option<String>>::sse_decode(deserializer);
        let mut var_lnurlMetadata = <Option<String>>::sse_decode(deserializer);
        let mut var_lnurlWithdrawEndpoint = <Option<String>>::sse_decode(deserializer);
        let mut var_swapInfo = <Option<crate::models::SwapInfo>>::sse_decode(deserializer);
        let mut var_reverseSwapInfo =
            <Option<crate::models::ReverseSwapInfo>>::sse_decode(deserializer);
        let mut var_pendingExpirationBlock = <Option<u32>>::sse_decode(deserializer);
        return crate::models::LnPaymentDetails {
            payment_hash: var_paymentHash,
            label: var_label,
            destination_pubkey: var_destinationPubkey,
            payment_preimage: var_paymentPreimage,
            keysend: var_keysend,
            bolt11: var_bolt11,
            open_channel_bolt11: var_openChannelBolt11,
            lnurl_success_action: var_lnurlSuccessAction,
            lnurl_pay_domain: var_lnurlPayDomain,
            lnurl_pay_comment: var_lnurlPayComment,
            ln_address: var_lnAddress,
            lnurl_metadata: var_lnurlMetadata,
            lnurl_withdraw_endpoint: var_lnurlWithdrawEndpoint,
            swap_info: var_swapInfo,
            reverse_swap_info: var_reverseSwapInfo,
            pending_expiration_block: var_pendingExpirationBlock,
        };
    }
}

impl SseDecode for crate::binding::LnUrlAuthRequestData {
    // 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_k1 = <String>::sse_decode(deserializer);
        let mut var_action = <Option<String>>::sse_decode(deserializer);
        let mut var_domain = <String>::sse_decode(deserializer);
        let mut var_url = <String>::sse_decode(deserializer);
        return crate::binding::LnUrlAuthRequestData {
            k1: var_k1,
            action: var_action,
            domain: var_domain,
            url: var_url,
        };
    }
}

impl SseDecode for crate::binding::LnUrlCallbackStatus {
    // 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 => {
                return crate::binding::LnUrlCallbackStatus::Ok;
            }
            1 => {
                let mut var_data = <crate::binding::LnUrlErrorData>::sse_decode(deserializer);
                return crate::binding::LnUrlCallbackStatus::ErrorStatus { data: var_data };
            }
            _ => {
                unimplemented!("");
            }
        }
    }
}

impl SseDecode for crate::binding::LnUrlErrorData {
    // 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 = <String>::sse_decode(deserializer);
        return crate::binding::LnUrlErrorData { reason: var_reason };
    }
}

impl SseDecode for crate::binding::LnUrlPayErrorData {
    // 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_paymentHash = <String>::sse_decode(deserializer);
        let mut var_reason = <String>::sse_decode(deserializer);
        return crate::binding::LnUrlPayErrorData {
            payment_hash: var_paymentHash,
            reason: var_reason,
        };
    }
}

impl SseDecode for crate::binding::LnUrlPayRequest {
    // 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_data = <crate::binding::LnUrlPayRequestData>::sse_decode(deserializer);
        let mut var_amountMsat = <u64>::sse_decode(deserializer);
        let mut var_useTrampoline = <bool>::sse_decode(deserializer);
        let mut var_comment = <Option<String>>::sse_decode(deserializer);
        let mut var_paymentLabel = <Option<String>>::sse_decode(deserializer);
        let mut var_validateSuccessActionUrl = <Option<bool>>::sse_decode(deserializer);
        return crate::binding::LnUrlPayRequest {
            data: var_data,
            amount_msat: var_amountMsat,
            use_trampoline: var_useTrampoline,
            comment: var_comment,
            payment_label: var_paymentLabel,
            validate_success_action_url: var_validateSuccessActionUrl,
        };
    }
}

impl SseDecode for crate::binding::LnUrlPayRequestData {
    // 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_callback = <String>::sse_decode(deserializer);
        let mut var_minSendable = <u64>::sse_decode(deserializer);
        let mut var_maxSendable = <u64>::sse_decode(deserializer);
        let mut var_metadataStr = <String>::sse_decode(deserializer);
        let mut var_commentAllowed = <u16>::sse_decode(deserializer);
        let mut var_domain = <String>::sse_decode(deserializer);
        let mut var_allowsNostr = <bool>::sse_decode(deserializer);
        let mut var_nostrPubkey = <Option<String>>::sse_decode(deserializer);
        let mut var_lnAddress = <Option<String>>::sse_decode(deserializer);
        return crate::binding::LnUrlPayRequestData {
            callback: var_callback,
            min_sendable: var_minSendable,
            max_sendable: var_maxSendable,
            metadata_str: var_metadataStr,
            comment_allowed: var_commentAllowed,
            domain: var_domain,
            allows_nostr: var_allowsNostr,
            nostr_pubkey: var_nostrPubkey,
            ln_address: var_lnAddress,
        };
    }
}

impl SseDecode for crate::lnurl::pay::LnUrlPayResult {
    // 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_data =
                    <crate::lnurl::pay::LnUrlPaySuccessData>::sse_decode(deserializer);
                return crate::lnurl::pay::LnUrlPayResult::EndpointSuccess { data: var_data };
            }
            1 => {
                let mut var_data = <crate::binding::LnUrlErrorData>::sse_decode(deserializer);
                return crate::lnurl::pay::LnUrlPayResult::EndpointError { data: var_data };
            }
            2 => {
                let mut var_data = <crate::binding::LnUrlPayErrorData>::sse_decode(deserializer);
                return crate::lnurl::pay::LnUrlPayResult::PayError { data: var_data };
            }
            _ => {
                unimplemented!("");
            }
        }
    }
}

impl SseDecode for crate::lnurl::pay::LnUrlPaySuccessData {
    // 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_payment = <crate::models::Payment>::sse_decode(deserializer);
        let mut var_successAction =
            <Option<crate::binding::SuccessActionProcessed>>::sse_decode(deserializer);
        return crate::lnurl::pay::LnUrlPaySuccessData {
            payment: var_payment,
            success_action: var_successAction,
        };
    }
}

impl SseDecode for crate::binding::LnUrlWithdrawRequest {
    // 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_data = <crate::binding::LnUrlWithdrawRequestData>::sse_decode(deserializer);
        let mut var_amountMsat = <u64>::sse_decode(deserializer);
        let mut var_description = <Option<String>>::sse_decode(deserializer);
        return crate::binding::LnUrlWithdrawRequest {
            data: var_data,
            amount_msat: var_amountMsat,
            description: var_description,
        };
    }
}

impl SseDecode for crate::binding::LnUrlWithdrawRequestData {
    // 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_callback = <String>::sse_decode(deserializer);
        let mut var_k1 = <String>::sse_decode(deserializer);
        let mut var_defaultDescription = <String>::sse_decode(deserializer);
        let mut var_minWithdrawable = <u64>::sse_decode(deserializer);
        let mut var_maxWithdrawable = <u64>::sse_decode(deserializer);
        return crate::binding::LnUrlWithdrawRequestData {
            callback: var_callback,
            k1: var_k1,
            default_description: var_defaultDescription,
            min_withdrawable: var_minWithdrawable,
            max_withdrawable: var_maxWithdrawable,
        };
    }
}

impl SseDecode for crate::binding::LnUrlWithdrawResult {
    // 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_data =
                    <crate::binding::LnUrlWithdrawSuccessData>::sse_decode(deserializer);
                return crate::binding::LnUrlWithdrawResult::Ok { data: var_data };
            }
            1 => {
                let mut var_data =
                    <crate::binding::LnUrlWithdrawSuccessData>::sse_decode(deserializer);
                return crate::binding::LnUrlWithdrawResult::Timeout { data: var_data };
            }
            2 => {
                let mut var_data = <crate::binding::LnUrlErrorData>::sse_decode(deserializer);
                return crate::binding::LnUrlWithdrawResult::ErrorStatus { data: var_data };
            }
            _ => {
                unimplemented!("");
            }
        }
    }
}

impl SseDecode for crate::binding::LnUrlWithdrawSuccessData {
    // 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_invoice = <crate::binding::LNInvoice>::sse_decode(deserializer);
        return crate::binding::LnUrlWithdrawSuccessData {
            invoice: var_invoice,
        };
    }
}

impl SseDecode for crate::binding::LocaleOverrides {
    // 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_locale = <String>::sse_decode(deserializer);
        let mut var_spacing = <Option<u32>>::sse_decode(deserializer);
        let mut var_symbol = <crate::binding::Symbol>::sse_decode(deserializer);
        return crate::binding::LocaleOverrides {
            locale: var_locale,
            spacing: var_spacing,
            symbol: var_symbol,
        };
    }
}

impl SseDecode for crate::binding::LocalizedName {
    // 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_locale = <String>::sse_decode(deserializer);
        let mut var_name = <String>::sse_decode(deserializer);
        return crate::binding::LocalizedName {
            locale: var_locale,
            name: var_name,
        };
    }
}

impl SseDecode for crate::models::LogEntry {
    // 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_line = <String>::sse_decode(deserializer);
        let mut var_level = <String>::sse_decode(deserializer);
        return crate::models::LogEntry {
            line: var_line,
            level: var_level,
        };
    }
}

impl SseDecode for crate::lsp::LspInformation {
    // 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_id = <String>::sse_decode(deserializer);
        let mut var_name = <String>::sse_decode(deserializer);
        let mut var_widgetUrl = <String>::sse_decode(deserializer);
        let mut var_pubkey = <String>::sse_decode(deserializer);
        let mut var_host = <String>::sse_decode(deserializer);
        let mut var_baseFeeMsat = <i64>::sse_decode(deserializer);
        let mut var_feeRate = <f64>::sse_decode(deserializer);
        let mut var_timeLockDelta = <u32>::sse_decode(deserializer);
        let mut var_minHtlcMsat = <i64>::sse_decode(deserializer);
        let mut var_lspPubkey = <Vec<u8>>::sse_decode(deserializer);
        let mut var_openingFeeParamsList =
            <crate::models::OpeningFeeParamsMenu>::sse_decode(deserializer);
        return crate::lsp::LspInformation {
            id: var_id,
            name: var_name,
            widget_url: var_widgetUrl,
            pubkey: var_pubkey,
            host: var_host,
            base_fee_msat: var_baseFeeMsat,
            fee_rate: var_feeRate,
            time_lock_delta: var_timeLockDelta,
            min_htlc_msat: var_minHtlcMsat,
            lsp_pubkey: var_lspPubkey,
            opening_fee_params_list: var_openingFeeParamsList,
        };
    }
}

impl SseDecode for crate::binding::MessageSuccessActionData {
    // 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_message = <String>::sse_decode(deserializer);
        return crate::binding::MessageSuccessActionData {
            message: var_message,
        };
    }
}

impl SseDecode for crate::models::MetadataFilter {
    // 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_jsonPath = <String>::sse_decode(deserializer);
        let mut var_jsonValue = <String>::sse_decode(deserializer);
        return crate::models::MetadataFilter {
            json_path: var_jsonPath,
            json_value: var_jsonValue,
        };
    }
}

impl SseDecode for crate::binding::Network {
    // 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::binding::Network::Bitcoin,
            1 => crate::binding::Network::Testnet,
            2 => crate::binding::Network::Signet,
            3 => crate::binding::Network::Regtest,
            _ => unreachable!("Invalid variant for Network: {}", inner),
        };
    }
}

impl SseDecode for crate::models::NodeConfig {
    // 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_config =
                    <crate::models::GreenlightNodeConfig>::sse_decode(deserializer);
                return crate::models::NodeConfig::Greenlight { config: var_config };
            }
            _ => {
                unimplemented!("");
            }
        }
    }
}

impl SseDecode for crate::models::NodeCredentials {
    // 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_credentials =
                    <crate::models::GreenlightDeviceCredentials>::sse_decode(deserializer);
                return crate::models::NodeCredentials::Greenlight {
                    credentials: var_credentials,
                };
            }
            _ => {
                unimplemented!("");
            }
        }
    }
}

impl SseDecode for crate::models::NodeState {
    // 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_id = <String>::sse_decode(deserializer);
        let mut var_blockHeight = <u32>::sse_decode(deserializer);
        let mut var_channelsBalanceMsat = <u64>::sse_decode(deserializer);
        let mut var_onchainBalanceMsat = <u64>::sse_decode(deserializer);
        let mut var_pendingOnchainBalanceMsat = <u64>::sse_decode(deserializer);
        let mut var_utxos =
            <Vec<crate::models::UnspentTransactionOutput>>::sse_decode(deserializer);
        let mut var_maxPayableMsat = <u64>::sse_decode(deserializer);
        let mut var_maxReceivableMsat = <u64>::sse_decode(deserializer);
        let mut var_maxSinglePaymentAmountMsat = <u64>::sse_decode(deserializer);
        let mut var_maxChanReserveMsats = <u64>::sse_decode(deserializer);
        let mut var_connectedPeers = <Vec<String>>::sse_decode(deserializer);
        let mut var_maxReceivableSinglePaymentAmountMsat = <u64>::sse_decode(deserializer);
        let mut var_totalInboundLiquidityMsats = <u64>::sse_decode(deserializer);
        return crate::models::NodeState {
            id: var_id,
            block_height: var_blockHeight,
            channels_balance_msat: var_channelsBalanceMsat,
            onchain_balance_msat: var_onchainBalanceMsat,
            pending_onchain_balance_msat: var_pendingOnchainBalanceMsat,
            utxos: var_utxos,
            max_payable_msat: var_maxPayableMsat,
            max_receivable_msat: var_maxReceivableMsat,
            max_single_payment_amount_msat: var_maxSinglePaymentAmountMsat,
            max_chan_reserve_msats: var_maxChanReserveMsats,
            connected_peers: var_connectedPeers,
            max_receivable_single_payment_amount_msat: var_maxReceivableSinglePaymentAmountMsat,
            total_inbound_liquidity_msats: var_totalInboundLiquidityMsats,
        };
    }
}

impl SseDecode for crate::models::OnchainPaymentLimitsResponse {
    // 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_minSat = <u64>::sse_decode(deserializer);
        let mut var_maxSat = <u64>::sse_decode(deserializer);
        let mut var_maxPayableSat = <u64>::sse_decode(deserializer);
        return crate::models::OnchainPaymentLimitsResponse {
            min_sat: var_minSat,
            max_sat: var_maxSat,
            max_payable_sat: var_maxPayableSat,
        };
    }
}

impl SseDecode for crate::models::OpenChannelFeeRequest {
    // 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_amountMsat = <Option<u64>>::sse_decode(deserializer);
        let mut var_expiry = <Option<u32>>::sse_decode(deserializer);
        return crate::models::OpenChannelFeeRequest {
            amount_msat: var_amountMsat,
            expiry: var_expiry,
        };
    }
}

impl SseDecode for crate::models::OpenChannelFeeResponse {
    // 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_feeMsat = <Option<u64>>::sse_decode(deserializer);
        let mut var_feeParams = <crate::models::OpeningFeeParams>::sse_decode(deserializer);
        return crate::models::OpenChannelFeeResponse {
            fee_msat: var_feeMsat,
            fee_params: var_feeParams,
        };
    }
}

impl SseDecode for crate::models::OpeningFeeParams {
    // 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_minMsat = <u64>::sse_decode(deserializer);
        let mut var_proportional = <u32>::sse_decode(deserializer);
        let mut var_validUntil = <String>::sse_decode(deserializer);
        let mut var_maxIdleTime = <u32>::sse_decode(deserializer);
        let mut var_maxClientToSelfDelay = <u32>::sse_decode(deserializer);
        let mut var_promise = <String>::sse_decode(deserializer);
        return crate::models::OpeningFeeParams {
            min_msat: var_minMsat,
            proportional: var_proportional,
            valid_until: var_validUntil,
            max_idle_time: var_maxIdleTime,
            max_client_to_self_delay: var_maxClientToSelfDelay,
            promise: var_promise,
        };
    }
}

impl SseDecode for crate::models::OpeningFeeParamsMenu {
    // 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_values = <Vec<crate::models::OpeningFeeParams>>::sse_decode(deserializer);
        return crate::models::OpeningFeeParamsMenu { values: var_values };
    }
}

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<bool> {
    // 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(<bool>::sse_decode(deserializer));
        } else {
            return None;
        }
    }
}

impl SseDecode for Option<crate::models::GreenlightCredentials> {
    // 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::models::GreenlightCredentials>::sse_decode(
                deserializer,
            ));
        } else {
            return None;
        }
    }
}

impl SseDecode for Option<i64> {
    // 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(<i64>::sse_decode(deserializer));
        } else {
            return None;
        }
    }
}

impl SseDecode for Option<crate::binding::LNInvoice> {
    // 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::binding::LNInvoice>::sse_decode(deserializer));
        } else {
            return None;
        }
    }
}

impl SseDecode for Option<crate::lsp::LspInformation> {
    // 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::lsp::LspInformation>::sse_decode(deserializer));
        } else {
            return None;
        }
    }
}

impl SseDecode for Option<crate::models::NodeCredentials> {
    // 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::models::NodeCredentials>::sse_decode(deserializer));
        } else {
            return None;
        }
    }
}

impl SseDecode for Option<crate::models::OpeningFeeParams> {
    // 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::models::OpeningFeeParams>::sse_decode(deserializer));
        } else {
            return None;
        }
    }
}

impl SseDecode for Option<crate::models::Payment> {
    // 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::models::Payment>::sse_decode(deserializer));
        } else {
            return None;
        }
    }
}

impl SseDecode for Option<crate::models::ReverseSwapInfo> {
    // 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::models::ReverseSwapInfo>::sse_decode(deserializer));
        } else {
            return None;
        }
    }
}

impl SseDecode for Option<crate::binding::SuccessActionProcessed> {
    // 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::binding::SuccessActionProcessed>::sse_decode(
                deserializer,
            ));
        } else {
            return None;
        }
    }
}

impl SseDecode for Option<crate::models::SwapInfo> {
    // 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::models::SwapInfo>::sse_decode(deserializer));
        } else {
            return None;
        }
    }
}

impl SseDecode for Option<crate::binding::Symbol> {
    // 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::binding::Symbol>::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 Option<u64> {
    // 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(<u64>::sse_decode(deserializer));
        } else {
            return None;
        }
    }
}

impl SseDecode for Option<Vec<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(<Vec<String>>::sse_decode(deserializer));
        } else {
            return None;
        }
    }
}

impl SseDecode for Option<Vec<crate::models::MetadataFilter>> {
    // 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(<Vec<crate::models::MetadataFilter>>::sse_decode(
                deserializer,
            ));
        } else {
            return None;
        }
    }
}

impl SseDecode for Option<Vec<crate::models::PaymentTypeFilter>> {
    // 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(<Vec<crate::models::PaymentTypeFilter>>::sse_decode(
                deserializer,
            ));
        } else {
            return None;
        }
    }
}

impl SseDecode for Option<Vec<u8>> {
    // 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(<Vec<u8>>::sse_decode(deserializer));
        } else {
            return None;
        }
    }
}

impl SseDecode for Option<Vec<crate::models::SwapStatus>> {
    // 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(<Vec<crate::models::SwapStatus>>::sse_decode(deserializer));
        } else {
            return None;
        }
    }
}

impl SseDecode for Option<Vec<crate::models::TlvEntry>> {
    // 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(<Vec<crate::models::TlvEntry>>::sse_decode(deserializer));
        } else {
            return None;
        }
    }
}

impl SseDecode for crate::models::PayOnchainRequest {
    // 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_recipientAddress = <String>::sse_decode(deserializer);
        let mut var_prepareRes =
            <crate::models::PrepareOnchainPaymentResponse>::sse_decode(deserializer);
        return crate::models::PayOnchainRequest {
            recipient_address: var_recipientAddress,
            prepare_res: var_prepareRes,
        };
    }
}

impl SseDecode for crate::models::PayOnchainResponse {
    // 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_reverseSwapInfo = <crate::models::ReverseSwapInfo>::sse_decode(deserializer);
        return crate::models::PayOnchainResponse {
            reverse_swap_info: var_reverseSwapInfo,
        };
    }
}

impl SseDecode for crate::models::Payment {
    // 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_id = <String>::sse_decode(deserializer);
        let mut var_paymentType = <crate::models::PaymentType>::sse_decode(deserializer);
        let mut var_paymentTime = <i64>::sse_decode(deserializer);
        let mut var_amountMsat = <u64>::sse_decode(deserializer);
        let mut var_feeMsat = <u64>::sse_decode(deserializer);
        let mut var_status = <crate::models::PaymentStatus>::sse_decode(deserializer);
        let mut var_error = <Option<String>>::sse_decode(deserializer);
        let mut var_description = <Option<String>>::sse_decode(deserializer);
        let mut var_details = <crate::models::PaymentDetails>::sse_decode(deserializer);
        let mut var_metadata = <Option<String>>::sse_decode(deserializer);
        return crate::models::Payment {
            id: var_id,
            payment_type: var_paymentType,
            payment_time: var_paymentTime,
            amount_msat: var_amountMsat,
            fee_msat: var_feeMsat,
            status: var_status,
            error: var_error,
            description: var_description,
            details: var_details,
            metadata: var_metadata,
        };
    }
}

impl SseDecode for crate::models::PaymentDetails {
    // 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_data = <crate::models::LnPaymentDetails>::sse_decode(deserializer);
                return crate::models::PaymentDetails::Ln { data: var_data };
            }
            1 => {
                let mut var_data =
                    <crate::models::ClosedChannelPaymentDetails>::sse_decode(deserializer);
                return crate::models::PaymentDetails::ClosedChannel { data: var_data };
            }
            _ => {
                unimplemented!("");
            }
        }
    }
}

impl SseDecode for crate::breez_services::PaymentFailedData {
    // 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_error = <String>::sse_decode(deserializer);
        let mut var_nodeId = <String>::sse_decode(deserializer);
        let mut var_invoice = <Option<crate::binding::LNInvoice>>::sse_decode(deserializer);
        let mut var_label = <Option<String>>::sse_decode(deserializer);
        return crate::breez_services::PaymentFailedData {
            error: var_error,
            node_id: var_nodeId,
            invoice: var_invoice,
            label: var_label,
        };
    }
}

impl SseDecode for crate::models::PaymentStatus {
    // 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::models::PaymentStatus::Pending,
            1 => crate::models::PaymentStatus::Complete,
            2 => crate::models::PaymentStatus::Failed,
            _ => unreachable!("Invalid variant for PaymentStatus: {}", inner),
        };
    }
}

impl SseDecode for crate::models::PaymentType {
    // 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::models::PaymentType::Sent,
            1 => crate::models::PaymentType::Received,
            2 => crate::models::PaymentType::ClosedChannel,
            _ => unreachable!("Invalid variant for PaymentType: {}", inner),
        };
    }
}

impl SseDecode for crate::models::PaymentTypeFilter {
    // 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::models::PaymentTypeFilter::Sent,
            1 => crate::models::PaymentTypeFilter::Received,
            2 => crate::models::PaymentTypeFilter::ClosedChannel,
            _ => unreachable!("Invalid variant for PaymentTypeFilter: {}", inner),
        };
    }
}

impl SseDecode for crate::models::PrepareOnchainPaymentRequest {
    // 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_amountSat = <u64>::sse_decode(deserializer);
        let mut var_amountType = <crate::models::SwapAmountType>::sse_decode(deserializer);
        let mut var_claimTxFeerate = <u32>::sse_decode(deserializer);
        return crate::models::PrepareOnchainPaymentRequest {
            amount_sat: var_amountSat,
            amount_type: var_amountType,
            claim_tx_feerate: var_claimTxFeerate,
        };
    }
}

impl SseDecode for crate::models::PrepareOnchainPaymentResponse {
    // 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_feesHash = <String>::sse_decode(deserializer);
        let mut var_feesPercentage = <f64>::sse_decode(deserializer);
        let mut var_feesLockup = <u64>::sse_decode(deserializer);
        let mut var_feesClaim = <u64>::sse_decode(deserializer);
        let mut var_senderAmountSat = <u64>::sse_decode(deserializer);
        let mut var_recipientAmountSat = <u64>::sse_decode(deserializer);
        let mut var_totalFees = <u64>::sse_decode(deserializer);
        return crate::models::PrepareOnchainPaymentResponse {
            fees_hash: var_feesHash,
            fees_percentage: var_feesPercentage,
            fees_lockup: var_feesLockup,
            fees_claim: var_feesClaim,
            sender_amount_sat: var_senderAmountSat,
            recipient_amount_sat: var_recipientAmountSat,
            total_fees: var_totalFees,
        };
    }
}

impl SseDecode for crate::models::PrepareRedeemOnchainFundsRequest {
    // 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_toAddress = <String>::sse_decode(deserializer);
        let mut var_satPerVbyte = <u32>::sse_decode(deserializer);
        return crate::models::PrepareRedeemOnchainFundsRequest {
            to_address: var_toAddress,
            sat_per_vbyte: var_satPerVbyte,
        };
    }
}

impl SseDecode for crate::models::PrepareRedeemOnchainFundsResponse {
    // 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_txWeight = <u64>::sse_decode(deserializer);
        let mut var_txFeeSat = <u64>::sse_decode(deserializer);
        return crate::models::PrepareRedeemOnchainFundsResponse {
            tx_weight: var_txWeight,
            tx_fee_sat: var_txFeeSat,
        };
    }
}

impl SseDecode for crate::models::PrepareRefundRequest {
    // 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_swapAddress = <String>::sse_decode(deserializer);
        let mut var_toAddress = <String>::sse_decode(deserializer);
        let mut var_satPerVbyte = <u32>::sse_decode(deserializer);
        let mut var_unilateral = <Option<bool>>::sse_decode(deserializer);
        return crate::models::PrepareRefundRequest {
            swap_address: var_swapAddress,
            to_address: var_toAddress,
            sat_per_vbyte: var_satPerVbyte,
            unilateral: var_unilateral,
        };
    }
}

impl SseDecode for crate::models::PrepareRefundResponse {
    // 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_refundTxWeight = <u32>::sse_decode(deserializer);
        let mut var_refundTxFeeSat = <u64>::sse_decode(deserializer);
        return crate::models::PrepareRefundResponse {
            refund_tx_weight: var_refundTxWeight,
            refund_tx_fee_sat: var_refundTxFeeSat,
        };
    }
}

impl SseDecode for crate::binding::Rate {
    // 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_coin = <String>::sse_decode(deserializer);
        let mut var_value = <f64>::sse_decode(deserializer);
        return crate::binding::Rate {
            coin: var_coin,
            value: var_value,
        };
    }
}

impl SseDecode for crate::models::ReceiveOnchainRequest {
    // 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_openingFeeParams =
            <Option<crate::models::OpeningFeeParams>>::sse_decode(deserializer);
        return crate::models::ReceiveOnchainRequest {
            opening_fee_params: var_openingFeeParams,
        };
    }
}

impl SseDecode for crate::models::ReceivePaymentRequest {
    // 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_amountMsat = <u64>::sse_decode(deserializer);
        let mut var_description = <String>::sse_decode(deserializer);
        let mut var_preimage = <Option<Vec<u8>>>::sse_decode(deserializer);
        let mut var_openingFeeParams =
            <Option<crate::models::OpeningFeeParams>>::sse_decode(deserializer);
        let mut var_useDescriptionHash = <Option<bool>>::sse_decode(deserializer);
        let mut var_expiry = <Option<u32>>::sse_decode(deserializer);
        let mut var_cltv = <Option<u32>>::sse_decode(deserializer);
        return crate::models::ReceivePaymentRequest {
            amount_msat: var_amountMsat,
            description: var_description,
            preimage: var_preimage,
            opening_fee_params: var_openingFeeParams,
            use_description_hash: var_useDescriptionHash,
            expiry: var_expiry,
            cltv: var_cltv,
        };
    }
}

impl SseDecode for crate::models::ReceivePaymentResponse {
    // 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_lnInvoice = <crate::binding::LNInvoice>::sse_decode(deserializer);
        let mut var_openingFeeParams =
            <Option<crate::models::OpeningFeeParams>>::sse_decode(deserializer);
        let mut var_openingFeeMsat = <Option<u64>>::sse_decode(deserializer);
        return crate::models::ReceivePaymentResponse {
            ln_invoice: var_lnInvoice,
            opening_fee_params: var_openingFeeParams,
            opening_fee_msat: var_openingFeeMsat,
        };
    }
}

impl SseDecode for crate::chain::RecommendedFees {
    // 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_fastestFee = <u64>::sse_decode(deserializer);
        let mut var_halfHourFee = <u64>::sse_decode(deserializer);
        let mut var_hourFee = <u64>::sse_decode(deserializer);
        let mut var_economyFee = <u64>::sse_decode(deserializer);
        let mut var_minimumFee = <u64>::sse_decode(deserializer);
        return crate::chain::RecommendedFees {
            fastest_fee: var_fastestFee,
            half_hour_fee: var_halfHourFee,
            hour_fee: var_hourFee,
            economy_fee: var_economyFee,
            minimum_fee: var_minimumFee,
        };
    }
}

impl SseDecode for crate::models::RedeemOnchainFundsRequest {
    // 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_toAddress = <String>::sse_decode(deserializer);
        let mut var_satPerVbyte = <u32>::sse_decode(deserializer);
        return crate::models::RedeemOnchainFundsRequest {
            to_address: var_toAddress,
            sat_per_vbyte: var_satPerVbyte,
        };
    }
}

impl SseDecode for crate::models::RedeemOnchainFundsResponse {
    // 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_txid = <Vec<u8>>::sse_decode(deserializer);
        return crate::models::RedeemOnchainFundsResponse { txid: var_txid };
    }
}

impl SseDecode for crate::models::RefundRequest {
    // 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_swapAddress = <String>::sse_decode(deserializer);
        let mut var_toAddress = <String>::sse_decode(deserializer);
        let mut var_satPerVbyte = <u32>::sse_decode(deserializer);
        let mut var_unilateral = <Option<bool>>::sse_decode(deserializer);
        return crate::models::RefundRequest {
            swap_address: var_swapAddress,
            to_address: var_toAddress,
            sat_per_vbyte: var_satPerVbyte,
            unilateral: var_unilateral,
        };
    }
}

impl SseDecode for crate::models::RefundResponse {
    // 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_refundTxId = <String>::sse_decode(deserializer);
        return crate::models::RefundResponse {
            refund_tx_id: var_refundTxId,
        };
    }
}

impl SseDecode for crate::models::ReportIssueRequest {
    // 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_data =
                    <crate::models::ReportPaymentFailureDetails>::sse_decode(deserializer);
                return crate::models::ReportIssueRequest::PaymentFailure { data: var_data };
            }
            _ => {
                unimplemented!("");
            }
        }
    }
}

impl SseDecode for crate::models::ReportPaymentFailureDetails {
    // 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_paymentHash = <String>::sse_decode(deserializer);
        let mut var_comment = <Option<String>>::sse_decode(deserializer);
        return crate::models::ReportPaymentFailureDetails {
            payment_hash: var_paymentHash,
            comment: var_comment,
        };
    }
}

impl SseDecode for crate::models::ReverseSwapFeesRequest {
    // 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_sendAmountSat = <Option<u64>>::sse_decode(deserializer);
        let mut var_claimTxFeerate = <Option<u32>>::sse_decode(deserializer);
        return crate::models::ReverseSwapFeesRequest {
            send_amount_sat: var_sendAmountSat,
            claim_tx_feerate: var_claimTxFeerate,
        };
    }
}

impl SseDecode for crate::models::ReverseSwapInfo {
    // 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_id = <String>::sse_decode(deserializer);
        let mut var_claimPubkey = <String>::sse_decode(deserializer);
        let mut var_lockupTxid = <Option<String>>::sse_decode(deserializer);
        let mut var_claimTxid = <Option<String>>::sse_decode(deserializer);
        let mut var_onchainAmountSat = <u64>::sse_decode(deserializer);
        let mut var_status = <crate::models::ReverseSwapStatus>::sse_decode(deserializer);
        return crate::models::ReverseSwapInfo {
            id: var_id,
            claim_pubkey: var_claimPubkey,
            lockup_txid: var_lockupTxid,
            claim_txid: var_claimTxid,
            onchain_amount_sat: var_onchainAmountSat,
            status: var_status,
        };
    }
}

impl SseDecode for crate::models::ReverseSwapPairInfo {
    // 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_min = <u64>::sse_decode(deserializer);
        let mut var_max = <u64>::sse_decode(deserializer);
        let mut var_feesHash = <String>::sse_decode(deserializer);
        let mut var_feesPercentage = <f64>::sse_decode(deserializer);
        let mut var_feesLockup = <u64>::sse_decode(deserializer);
        let mut var_feesClaim = <u64>::sse_decode(deserializer);
        let mut var_totalFees = <Option<u64>>::sse_decode(deserializer);
        return crate::models::ReverseSwapPairInfo {
            min: var_min,
            max: var_max,
            fees_hash: var_feesHash,
            fees_percentage: var_feesPercentage,
            fees_lockup: var_feesLockup,
            fees_claim: var_feesClaim,
            total_fees: var_totalFees,
        };
    }
}

impl SseDecode for crate::models::ReverseSwapStatus {
    // 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::models::ReverseSwapStatus::Initial,
            1 => crate::models::ReverseSwapStatus::InProgress,
            2 => crate::models::ReverseSwapStatus::Cancelled,
            3 => crate::models::ReverseSwapStatus::CompletedSeen,
            4 => crate::models::ReverseSwapStatus::CompletedConfirmed,
            _ => unreachable!("Invalid variant for ReverseSwapStatus: {}", inner),
        };
    }
}

impl SseDecode for crate::binding::RouteHint {
    // 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_hops = <Vec<crate::binding::RouteHintHop>>::sse_decode(deserializer);
        return crate::binding::RouteHint { hops: var_hops };
    }
}

impl SseDecode for crate::binding::RouteHintHop {
    // 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_srcNodeId = <String>::sse_decode(deserializer);
        let mut var_shortChannelId = <String>::sse_decode(deserializer);
        let mut var_feesBaseMsat = <u32>::sse_decode(deserializer);
        let mut var_feesProportionalMillionths = <u32>::sse_decode(deserializer);
        let mut var_cltvExpiryDelta = <u64>::sse_decode(deserializer);
        let mut var_htlcMinimumMsat = <Option<u64>>::sse_decode(deserializer);
        let mut var_htlcMaximumMsat = <Option<u64>>::sse_decode(deserializer);
        return crate::binding::RouteHintHop {
            src_node_id: var_srcNodeId,
            short_channel_id: var_shortChannelId,
            fees_base_msat: var_feesBaseMsat,
            fees_proportional_millionths: var_feesProportionalMillionths,
            cltv_expiry_delta: var_cltvExpiryDelta,
            htlc_minimum_msat: var_htlcMinimumMsat,
            htlc_maximum_msat: var_htlcMaximumMsat,
        };
    }
}

impl SseDecode for crate::models::SendPaymentRequest {
    // 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_bolt11 = <String>::sse_decode(deserializer);
        let mut var_useTrampoline = <bool>::sse_decode(deserializer);
        let mut var_amountMsat = <Option<u64>>::sse_decode(deserializer);
        let mut var_label = <Option<String>>::sse_decode(deserializer);
        return crate::models::SendPaymentRequest {
            bolt11: var_bolt11,
            use_trampoline: var_useTrampoline,
            amount_msat: var_amountMsat,
            label: var_label,
        };
    }
}

impl SseDecode for crate::models::SendPaymentResponse {
    // 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_payment = <crate::models::Payment>::sse_decode(deserializer);
        return crate::models::SendPaymentResponse {
            payment: var_payment,
        };
    }
}

impl SseDecode for crate::models::SendSpontaneousPaymentRequest {
    // 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_nodeId = <String>::sse_decode(deserializer);
        let mut var_amountMsat = <u64>::sse_decode(deserializer);
        let mut var_extraTlvs = <Option<Vec<crate::models::TlvEntry>>>::sse_decode(deserializer);
        let mut var_label = <Option<String>>::sse_decode(deserializer);
        return crate::models::SendSpontaneousPaymentRequest {
            node_id: var_nodeId,
            amount_msat: var_amountMsat,
            extra_tlvs: var_extraTlvs,
            label: var_label,
        };
    }
}

impl SseDecode for crate::models::ServiceHealthCheckResponse {
    // 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_status = <crate::models::HealthCheckStatus>::sse_decode(deserializer);
        return crate::models::ServiceHealthCheckResponse { status: var_status };
    }
}

impl SseDecode for crate::breez_services::SignMessageRequest {
    // 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_message = <String>::sse_decode(deserializer);
        return crate::breez_services::SignMessageRequest {
            message: var_message,
        };
    }
}

impl SseDecode for crate::breez_services::SignMessageResponse {
    // 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_signature = <String>::sse_decode(deserializer);
        return crate::breez_services::SignMessageResponse {
            signature: var_signature,
        };
    }
}

impl SseDecode for crate::models::StaticBackupRequest {
    // 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_workingDir = <String>::sse_decode(deserializer);
        return crate::models::StaticBackupRequest {
            working_dir: var_workingDir,
        };
    }
}

impl SseDecode for crate::models::StaticBackupResponse {
    // 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_backup = <Option<Vec<String>>>::sse_decode(deserializer);
        return crate::models::StaticBackupResponse { backup: var_backup };
    }
}

impl SseDecode for crate::binding::SuccessActionProcessed {
    // 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_result =
                    <crate::binding::AesSuccessActionDataResult>::sse_decode(deserializer);
                return crate::binding::SuccessActionProcessed::Aes { result: var_result };
            }
            1 => {
                let mut var_data =
                    <crate::binding::MessageSuccessActionData>::sse_decode(deserializer);
                return crate::binding::SuccessActionProcessed::Message { data: var_data };
            }
            2 => {
                let mut var_data = <crate::binding::UrlSuccessActionData>::sse_decode(deserializer);
                return crate::binding::SuccessActionProcessed::Url { data: var_data };
            }
            _ => {
                unimplemented!("");
            }
        }
    }
}

impl SseDecode for crate::models::SwapAmountType {
    // 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::models::SwapAmountType::Send,
            1 => crate::models::SwapAmountType::Receive,
            _ => unreachable!("Invalid variant for SwapAmountType: {}", inner),
        };
    }
}

impl SseDecode for crate::models::SwapInfo {
    // 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_bitcoinAddress = <String>::sse_decode(deserializer);
        let mut var_createdAt = <i64>::sse_decode(deserializer);
        let mut var_lockHeight = <i64>::sse_decode(deserializer);
        let mut var_paymentHash = <Vec<u8>>::sse_decode(deserializer);
        let mut var_preimage = <Vec<u8>>::sse_decode(deserializer);
        let mut var_privateKey = <Vec<u8>>::sse_decode(deserializer);
        let mut var_publicKey = <Vec<u8>>::sse_decode(deserializer);
        let mut var_swapperPublicKey = <Vec<u8>>::sse_decode(deserializer);
        let mut var_script = <Vec<u8>>::sse_decode(deserializer);
        let mut var_bolt11 = <Option<String>>::sse_decode(deserializer);
        let mut var_paidMsat = <u64>::sse_decode(deserializer);
        let mut var_totalIncomingTxs = <u64>::sse_decode(deserializer);
        let mut var_confirmedSats = <u64>::sse_decode(deserializer);
        let mut var_unconfirmedSats = <u64>::sse_decode(deserializer);
        let mut var_status = <crate::models::SwapStatus>::sse_decode(deserializer);
        let mut var_refundTxIds = <Vec<String>>::sse_decode(deserializer);
        let mut var_unconfirmedTxIds = <Vec<String>>::sse_decode(deserializer);
        let mut var_confirmedTxIds = <Vec<String>>::sse_decode(deserializer);
        let mut var_minAllowedDeposit = <i64>::sse_decode(deserializer);
        let mut var_maxAllowedDeposit = <i64>::sse_decode(deserializer);
        let mut var_maxSwapperPayable = <i64>::sse_decode(deserializer);
        let mut var_lastRedeemError = <Option<String>>::sse_decode(deserializer);
        let mut var_channelOpeningFees =
            <Option<crate::models::OpeningFeeParams>>::sse_decode(deserializer);
        let mut var_confirmedAt = <Option<u32>>::sse_decode(deserializer);
        return crate::models::SwapInfo {
            bitcoin_address: var_bitcoinAddress,
            created_at: var_createdAt,
            lock_height: var_lockHeight,
            payment_hash: var_paymentHash,
            preimage: var_preimage,
            private_key: var_privateKey,
            public_key: var_publicKey,
            swapper_public_key: var_swapperPublicKey,
            script: var_script,
            bolt11: var_bolt11,
            paid_msat: var_paidMsat,
            total_incoming_txs: var_totalIncomingTxs,
            confirmed_sats: var_confirmedSats,
            unconfirmed_sats: var_unconfirmedSats,
            status: var_status,
            refund_tx_ids: var_refundTxIds,
            unconfirmed_tx_ids: var_unconfirmedTxIds,
            confirmed_tx_ids: var_confirmedTxIds,
            min_allowed_deposit: var_minAllowedDeposit,
            max_allowed_deposit: var_maxAllowedDeposit,
            max_swapper_payable: var_maxSwapperPayable,
            last_redeem_error: var_lastRedeemError,
            channel_opening_fees: var_channelOpeningFees,
            confirmed_at: var_confirmedAt,
        };
    }
}

impl SseDecode for crate::models::SwapStatus {
    // 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::models::SwapStatus::Initial,
            1 => crate::models::SwapStatus::WaitingConfirmation,
            2 => crate::models::SwapStatus::Redeemable,
            3 => crate::models::SwapStatus::Redeemed,
            4 => crate::models::SwapStatus::Refundable,
            5 => crate::models::SwapStatus::Completed,
            _ => unreachable!("Invalid variant for SwapStatus: {}", inner),
        };
    }
}

impl SseDecode for crate::binding::Symbol {
    // 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_grapheme = <Option<String>>::sse_decode(deserializer);
        let mut var_template = <Option<String>>::sse_decode(deserializer);
        let mut var_rtl = <Option<bool>>::sse_decode(deserializer);
        let mut var_position = <Option<u32>>::sse_decode(deserializer);
        return crate::binding::Symbol {
            grapheme: var_grapheme,
            template: var_template,
            rtl: var_rtl,
            position: var_position,
        };
    }
}

impl SseDecode for crate::models::TlvEntry {
    // 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_fieldNumber = <u64>::sse_decode(deserializer);
        let mut var_value = <Vec<u8>>::sse_decode(deserializer);
        return crate::models::TlvEntry {
            field_number: var_fieldNumber,
            value: var_value,
        };
    }
}

impl SseDecode for u16 {
    // 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_u16::<NativeEndian>().unwrap()
    }
}

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 u64 {
    // 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()
    }
}

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 crate::models::UnspentTransactionOutput {
    // 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_txid = <Vec<u8>>::sse_decode(deserializer);
        let mut var_outnum = <u32>::sse_decode(deserializer);
        let mut var_amountMillisatoshi = <u64>::sse_decode(deserializer);
        let mut var_address = <String>::sse_decode(deserializer);
        let mut var_reserved = <bool>::sse_decode(deserializer);
        return crate::models::UnspentTransactionOutput {
            txid: var_txid,
            outnum: var_outnum,
            amount_millisatoshi: var_amountMillisatoshi,
            address: var_address,
            reserved: var_reserved,
        };
    }
}

impl SseDecode for crate::binding::UrlSuccessActionData {
    // 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_description = <String>::sse_decode(deserializer);
        let mut var_url = <String>::sse_decode(deserializer);
        let mut var_matchesCallbackDomain = <bool>::sse_decode(deserializer);
        return crate::binding::UrlSuccessActionData {
            description: var_description,
            url: var_url,
            matches_callback_domain: var_matchesCallbackDomain,
        };
    }
}

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 {
        _ => unreachable!(),
    }
}

// Section: rust2dart

// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::binding::AesSuccessActionDataDecrypted> {
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        [
            self.0.description.into_into_dart().into_dart(),
            self.0.plaintext.into_into_dart().into_dart(),
        ]
        .into_dart()
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
    for FrbWrapper<crate::binding::AesSuccessActionDataDecrypted>
{
}
impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::binding::AesSuccessActionDataDecrypted>>
    for crate::binding::AesSuccessActionDataDecrypted
{
    fn into_into_dart(self) -> FrbWrapper<crate::binding::AesSuccessActionDataDecrypted> {
        self.into()
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::binding::AesSuccessActionDataResult> {
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        match self.0 {
            crate::binding::AesSuccessActionDataResult::Decrypted { data } => {
                [0.into_dart(), data.into_into_dart().into_dart()].into_dart()
            }
            crate::binding::AesSuccessActionDataResult::ErrorStatus { reason } => {
                [1.into_dart(), reason.into_into_dart().into_dart()].into_dart()
            }
            _ => {
                unimplemented!("");
            }
        }
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
    for FrbWrapper<crate::binding::AesSuccessActionDataResult>
{
}
impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::binding::AesSuccessActionDataResult>>
    for crate::binding::AesSuccessActionDataResult
{
    fn into_into_dart(self) -> FrbWrapper<crate::binding::AesSuccessActionDataResult> {
        self.into()
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for crate::breez_services::BackupFailedData {
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        [self.error.into_into_dart().into_dart()].into_dart()
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
    for crate::breez_services::BackupFailedData
{
}
impl flutter_rust_bridge::IntoIntoDart<crate::breez_services::BackupFailedData>
    for crate::breez_services::BackupFailedData
{
    fn into_into_dart(self) -> crate::breez_services::BackupFailedData {
        self
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for crate::models::BackupStatus {
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        [
            self.backed_up.into_into_dart().into_dart(),
            self.last_backup_time.into_into_dart().into_dart(),
        ]
        .into_dart()
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::models::BackupStatus {}
impl flutter_rust_bridge::IntoIntoDart<crate::models::BackupStatus>
    for crate::models::BackupStatus
{
    fn into_into_dart(self) -> crate::models::BackupStatus {
        self
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for crate::binding::BindingEventListener {
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        Vec::<u8>::new().into_dart()
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
    for crate::binding::BindingEventListener
{
}
impl flutter_rust_bridge::IntoIntoDart<crate::binding::BindingEventListener>
    for crate::binding::BindingEventListener
{
    fn into_into_dart(self) -> crate::binding::BindingEventListener {
        self
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::binding::BitcoinAddressData> {
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        [
            self.0.address.into_into_dart().into_dart(),
            self.0.network.into_into_dart().into_dart(),
            self.0.amount_sat.into_into_dart().into_dart(),
            self.0.label.into_into_dart().into_dart(),
            self.0.message.into_into_dart().into_dart(),
        ]
        .into_dart()
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
    for FrbWrapper<crate::binding::BitcoinAddressData>
{
}
impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::binding::BitcoinAddressData>>
    for crate::binding::BitcoinAddressData
{
    fn into_into_dart(self) -> FrbWrapper<crate::binding::BitcoinAddressData> {
        self.into()
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for crate::breez_services::BreezEvent {
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        match self {
            crate::breez_services::BreezEvent::NewBlock { block } => {
                [0.into_dart(), block.into_into_dart().into_dart()].into_dart()
            }
            crate::breez_services::BreezEvent::InvoicePaid { details } => {
                [1.into_dart(), details.into_into_dart().into_dart()].into_dart()
            }
            crate::breez_services::BreezEvent::Synced => [2.into_dart()].into_dart(),
            crate::breez_services::BreezEvent::PaymentSucceed { details } => {
                [3.into_dart(), details.into_into_dart().into_dart()].into_dart()
            }
            crate::breez_services::BreezEvent::PaymentFailed { details } => {
                [4.into_dart(), details.into_into_dart().into_dart()].into_dart()
            }
            crate::breez_services::BreezEvent::BackupStarted => [5.into_dart()].into_dart(),
            crate::breez_services::BreezEvent::BackupSucceeded => [6.into_dart()].into_dart(),
            crate::breez_services::BreezEvent::BackupFailed { details } => {
                [7.into_dart(), details.into_into_dart().into_dart()].into_dart()
            }
            crate::breez_services::BreezEvent::ReverseSwapUpdated { details } => {
                [8.into_dart(), details.into_into_dart().into_dart()].into_dart()
            }
            crate::breez_services::BreezEvent::SwapUpdated { details } => {
                [9.into_dart(), details.into_into_dart().into_dart()].into_dart()
            }
            _ => {
                unimplemented!("");
            }
        }
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
    for crate::breez_services::BreezEvent
{
}
impl flutter_rust_bridge::IntoIntoDart<crate::breez_services::BreezEvent>
    for crate::breez_services::BreezEvent
{
    fn into_into_dart(self) -> crate::breez_services::BreezEvent {
        self
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for crate::models::BuyBitcoinProvider {
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        match self {
            Self::Moonpay => 0.into_dart(),
            _ => unreachable!(),
        }
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
    for crate::models::BuyBitcoinProvider
{
}
impl flutter_rust_bridge::IntoIntoDart<crate::models::BuyBitcoinProvider>
    for crate::models::BuyBitcoinProvider
{
    fn into_into_dart(self) -> crate::models::BuyBitcoinProvider {
        self
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for crate::models::BuyBitcoinRequest {
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        [
            self.provider.into_into_dart().into_dart(),
            self.opening_fee_params.into_into_dart().into_dart(),
            self.redirect_url.into_into_dart().into_dart(),
        ]
        .into_dart()
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
    for crate::models::BuyBitcoinRequest
{
}
impl flutter_rust_bridge::IntoIntoDart<crate::models::BuyBitcoinRequest>
    for crate::models::BuyBitcoinRequest
{
    fn into_into_dart(self) -> crate::models::BuyBitcoinRequest {
        self
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for crate::models::BuyBitcoinResponse {
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        [
            self.url.into_into_dart().into_dart(),
            self.opening_fee_params.into_into_dart().into_dart(),
        ]
        .into_dart()
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
    for crate::models::BuyBitcoinResponse
{
}
impl flutter_rust_bridge::IntoIntoDart<crate::models::BuyBitcoinResponse>
    for crate::models::BuyBitcoinResponse
{
    fn into_into_dart(self) -> crate::models::BuyBitcoinResponse {
        self
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for crate::models::ChannelState {
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        match self {
            Self::PendingOpen => 0.into_dart(),
            Self::Opened => 1.into_dart(),
            Self::PendingClose => 2.into_dart(),
            Self::Closed => 3.into_dart(),
            _ => unreachable!(),
        }
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::models::ChannelState {}
impl flutter_rust_bridge::IntoIntoDart<crate::models::ChannelState>
    for crate::models::ChannelState
{
    fn into_into_dart(self) -> crate::models::ChannelState {
        self
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for crate::breez_services::CheckMessageRequest {
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        [
            self.message.into_into_dart().into_dart(),
            self.pubkey.into_into_dart().into_dart(),
            self.signature.into_into_dart().into_dart(),
        ]
        .into_dart()
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
    for crate::breez_services::CheckMessageRequest
{
}
impl flutter_rust_bridge::IntoIntoDart<crate::breez_services::CheckMessageRequest>
    for crate::breez_services::CheckMessageRequest
{
    fn into_into_dart(self) -> crate::breez_services::CheckMessageRequest {
        self
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for crate::breez_services::CheckMessageResponse {
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        [self.is_valid.into_into_dart().into_dart()].into_dart()
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
    for crate::breez_services::CheckMessageResponse
{
}
impl flutter_rust_bridge::IntoIntoDart<crate::breez_services::CheckMessageResponse>
    for crate::breez_services::CheckMessageResponse
{
    fn into_into_dart(self) -> crate::breez_services::CheckMessageResponse {
        self
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for crate::models::ClosedChannelPaymentDetails {
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        [
            self.state.into_into_dart().into_dart(),
            self.funding_txid.into_into_dart().into_dart(),
            self.short_channel_id.into_into_dart().into_dart(),
            self.closing_txid.into_into_dart().into_dart(),
        ]
        .into_dart()
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
    for crate::models::ClosedChannelPaymentDetails
{
}
impl flutter_rust_bridge::IntoIntoDart<crate::models::ClosedChannelPaymentDetails>
    for crate::models::ClosedChannelPaymentDetails
{
    fn into_into_dart(self) -> crate::models::ClosedChannelPaymentDetails {
        self
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for crate::models::Config {
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        [
            self.breezserver.into_into_dart().into_dart(),
            self.chainnotifier_url.into_into_dart().into_dart(),
            self.mempoolspace_url.into_into_dart().into_dart(),
            self.working_dir.into_into_dart().into_dart(),
            self.network.into_into_dart().into_dart(),
            self.payment_timeout_sec.into_into_dart().into_dart(),
            self.default_lsp_id.into_into_dart().into_dart(),
            self.api_key.into_into_dart().into_dart(),
            self.maxfee_percent.into_into_dart().into_dart(),
            self.exemptfee_msat.into_into_dart().into_dart(),
            self.node_config.into_into_dart().into_dart(),
        ]
        .into_dart()
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::models::Config {}
impl flutter_rust_bridge::IntoIntoDart<crate::models::Config> for crate::models::Config {
    fn into_into_dart(self) -> crate::models::Config {
        self
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for crate::models::ConfigureNodeRequest {
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        [self.close_to_address.into_into_dart().into_dart()].into_dart()
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
    for crate::models::ConfigureNodeRequest
{
}
impl flutter_rust_bridge::IntoIntoDart<crate::models::ConfigureNodeRequest>
    for crate::models::ConfigureNodeRequest
{
    fn into_into_dart(self) -> crate::models::ConfigureNodeRequest {
        self
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for crate::models::ConnectRequest {
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        [
            self.config.into_into_dart().into_dart(),
            self.seed.into_into_dart().into_dart(),
            self.restore_only.into_into_dart().into_dart(),
        ]
        .into_dart()
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::models::ConnectRequest {}
impl flutter_rust_bridge::IntoIntoDart<crate::models::ConnectRequest>
    for crate::models::ConnectRequest
{
    fn into_into_dart(self) -> crate::models::ConnectRequest {
        self
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::binding::CurrencyInfo> {
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        [
            self.0.name.into_into_dart().into_dart(),
            self.0.fraction_size.into_into_dart().into_dart(),
            self.0.spacing.into_into_dart().into_dart(),
            self.0.symbol.into_into_dart().into_dart(),
            self.0.uniq_symbol.into_into_dart().into_dart(),
            self.0.localized_name.into_into_dart().into_dart(),
            self.0.locale_overrides.into_into_dart().into_dart(),
        ]
        .into_dart()
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
    for FrbWrapper<crate::binding::CurrencyInfo>
{
}
impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::binding::CurrencyInfo>>
    for crate::binding::CurrencyInfo
{
    fn into_into_dart(self) -> FrbWrapper<crate::binding::CurrencyInfo> {
        self.into()
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for crate::models::EnvironmentType {
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        match self {
            Self::Production => 0.into_dart(),
            Self::Staging => 1.into_dart(),
            Self::Regtest => 2.into_dart(),
            _ => unreachable!(),
        }
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
    for crate::models::EnvironmentType
{
}
impl flutter_rust_bridge::IntoIntoDart<crate::models::EnvironmentType>
    for crate::models::EnvironmentType
{
    fn into_into_dart(self) -> crate::models::EnvironmentType {
        self
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::binding::FiatCurrency> {
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        [
            self.0.id.into_into_dart().into_dart(),
            self.0.info.into_into_dart().into_dart(),
        ]
        .into_dart()
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
    for FrbWrapper<crate::binding::FiatCurrency>
{
}
impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::binding::FiatCurrency>>
    for crate::binding::FiatCurrency
{
    fn into_into_dart(self) -> FrbWrapper<crate::binding::FiatCurrency> {
        self.into()
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for crate::models::GreenlightCredentials {
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        [
            self.developer_key.into_into_dart().into_dart(),
            self.developer_cert.into_into_dart().into_dart(),
        ]
        .into_dart()
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
    for crate::models::GreenlightCredentials
{
}
impl flutter_rust_bridge::IntoIntoDart<crate::models::GreenlightCredentials>
    for crate::models::GreenlightCredentials
{
    fn into_into_dart(self) -> crate::models::GreenlightCredentials {
        self
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for crate::models::GreenlightDeviceCredentials {
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        [self.device.into_into_dart().into_dart()].into_dart()
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
    for crate::models::GreenlightDeviceCredentials
{
}
impl flutter_rust_bridge::IntoIntoDart<crate::models::GreenlightDeviceCredentials>
    for crate::models::GreenlightDeviceCredentials
{
    fn into_into_dart(self) -> crate::models::GreenlightDeviceCredentials {
        self
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for crate::models::GreenlightNodeConfig {
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        [
            self.partner_credentials.into_into_dart().into_dart(),
            self.invite_code.into_into_dart().into_dart(),
        ]
        .into_dart()
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
    for crate::models::GreenlightNodeConfig
{
}
impl flutter_rust_bridge::IntoIntoDart<crate::models::GreenlightNodeConfig>
    for crate::models::GreenlightNodeConfig
{
    fn into_into_dart(self) -> crate::models::GreenlightNodeConfig {
        self
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for crate::models::HealthCheckStatus {
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        match self {
            Self::Operational => 0.into_dart(),
            Self::Maintenance => 1.into_dart(),
            Self::ServiceDisruption => 2.into_dart(),
            _ => unreachable!(),
        }
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
    for crate::models::HealthCheckStatus
{
}
impl flutter_rust_bridge::IntoIntoDart<crate::models::HealthCheckStatus>
    for crate::models::HealthCheckStatus
{
    fn into_into_dart(self) -> crate::models::HealthCheckStatus {
        self
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::binding::InputType> {
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        match self.0 {
            crate::binding::InputType::BitcoinAddress { address } => {
                [0.into_dart(), address.into_into_dart().into_dart()].into_dart()
            }
            crate::binding::InputType::Bolt11 { invoice } => {
                [1.into_dart(), invoice.into_into_dart().into_dart()].into_dart()
            }
            crate::binding::InputType::NodeId { node_id } => {
                [2.into_dart(), node_id.into_into_dart().into_dart()].into_dart()
            }
            crate::binding::InputType::Url { url } => {
                [3.into_dart(), url.into_into_dart().into_dart()].into_dart()
            }
            crate::binding::InputType::LnUrlPay {
                data,
                bip353_address,
            } => [
                4.into_dart(),
                data.into_into_dart().into_dart(),
                bip353_address.into_into_dart().into_dart(),
            ]
            .into_dart(),
            crate::binding::InputType::LnUrlWithdraw { data } => {
                [5.into_dart(), data.into_into_dart().into_dart()].into_dart()
            }
            crate::binding::InputType::LnUrlAuth { data } => {
                [6.into_dart(), data.into_into_dart().into_dart()].into_dart()
            }
            crate::binding::InputType::LnUrlError { data } => {
                [7.into_dart(), data.into_into_dart().into_dart()].into_dart()
            }
            _ => {
                unimplemented!("");
            }
        }
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
    for FrbWrapper<crate::binding::InputType>
{
}
impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::binding::InputType>>
    for crate::binding::InputType
{
    fn into_into_dart(self) -> FrbWrapper<crate::binding::InputType> {
        self.into()
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for crate::breez_services::InvoicePaidDetails {
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        [
            self.payment_hash.into_into_dart().into_dart(),
            self.bolt11.into_into_dart().into_dart(),
            self.payment.into_into_dart().into_dart(),
        ]
        .into_dart()
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
    for crate::breez_services::InvoicePaidDetails
{
}
impl flutter_rust_bridge::IntoIntoDart<crate::breez_services::InvoicePaidDetails>
    for crate::breez_services::InvoicePaidDetails
{
    fn into_into_dart(self) -> crate::breez_services::InvoicePaidDetails {
        self
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for crate::models::ListPaymentsRequest {
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        [
            self.filters.into_into_dart().into_dart(),
            self.metadata_filters.into_into_dart().into_dart(),
            self.from_timestamp.into_into_dart().into_dart(),
            self.to_timestamp.into_into_dart().into_dart(),
            self.include_failures.into_into_dart().into_dart(),
            self.offset.into_into_dart().into_dart(),
            self.limit.into_into_dart().into_dart(),
        ]
        .into_dart()
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
    for crate::models::ListPaymentsRequest
{
}
impl flutter_rust_bridge::IntoIntoDart<crate::models::ListPaymentsRequest>
    for crate::models::ListPaymentsRequest
{
    fn into_into_dart(self) -> crate::models::ListPaymentsRequest {
        self
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for crate::models::ListSwapsRequest {
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        [
            self.status.into_into_dart().into_dart(),
            self.from_timestamp.into_into_dart().into_dart(),
            self.to_timestamp.into_into_dart().into_dart(),
            self.offset.into_into_dart().into_dart(),
            self.limit.into_into_dart().into_dart(),
        ]
        .into_dart()
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
    for crate::models::ListSwapsRequest
{
}
impl flutter_rust_bridge::IntoIntoDart<crate::models::ListSwapsRequest>
    for crate::models::ListSwapsRequest
{
    fn into_into_dart(self) -> crate::models::ListSwapsRequest {
        self
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::binding::LNInvoice> {
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        [
            self.0.bolt11.into_into_dart().into_dart(),
            self.0.network.into_into_dart().into_dart(),
            self.0.payee_pubkey.into_into_dart().into_dart(),
            self.0.payment_hash.into_into_dart().into_dart(),
            self.0.description.into_into_dart().into_dart(),
            self.0.description_hash.into_into_dart().into_dart(),
            self.0.amount_msat.into_into_dart().into_dart(),
            self.0.timestamp.into_into_dart().into_dart(),
            self.0.expiry.into_into_dart().into_dart(),
            self.0.routing_hints.into_into_dart().into_dart(),
            self.0.payment_secret.into_into_dart().into_dart(),
            self.0
                .min_final_cltv_expiry_delta
                .into_into_dart()
                .into_dart(),
        ]
        .into_dart()
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
    for FrbWrapper<crate::binding::LNInvoice>
{
}
impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::binding::LNInvoice>>
    for crate::binding::LNInvoice
{
    fn into_into_dart(self) -> FrbWrapper<crate::binding::LNInvoice> {
        self.into()
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for crate::models::LnPaymentDetails {
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        [
            self.payment_hash.into_into_dart().into_dart(),
            self.label.into_into_dart().into_dart(),
            self.destination_pubkey.into_into_dart().into_dart(),
            self.payment_preimage.into_into_dart().into_dart(),
            self.keysend.into_into_dart().into_dart(),
            self.bolt11.into_into_dart().into_dart(),
            self.open_channel_bolt11.into_into_dart().into_dart(),
            self.lnurl_success_action.into_into_dart().into_dart(),
            self.lnurl_pay_domain.into_into_dart().into_dart(),
            self.lnurl_pay_comment.into_into_dart().into_dart(),
            self.ln_address.into_into_dart().into_dart(),
            self.lnurl_metadata.into_into_dart().into_dart(),
            self.lnurl_withdraw_endpoint.into_into_dart().into_dart(),
            self.swap_info.into_into_dart().into_dart(),
            self.reverse_swap_info.into_into_dart().into_dart(),
            self.pending_expiration_block.into_into_dart().into_dart(),
        ]
        .into_dart()
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
    for crate::models::LnPaymentDetails
{
}
impl flutter_rust_bridge::IntoIntoDart<crate::models::LnPaymentDetails>
    for crate::models::LnPaymentDetails
{
    fn into_into_dart(self) -> crate::models::LnPaymentDetails {
        self
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::binding::LnUrlAuthRequestData> {
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        [
            self.0.k1.into_into_dart().into_dart(),
            self.0.action.into_into_dart().into_dart(),
            self.0.domain.into_into_dart().into_dart(),
            self.0.url.into_into_dart().into_dart(),
        ]
        .into_dart()
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
    for FrbWrapper<crate::binding::LnUrlAuthRequestData>
{
}
impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::binding::LnUrlAuthRequestData>>
    for crate::binding::LnUrlAuthRequestData
{
    fn into_into_dart(self) -> FrbWrapper<crate::binding::LnUrlAuthRequestData> {
        self.into()
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::binding::LnUrlCallbackStatus> {
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        match self.0 {
            crate::binding::LnUrlCallbackStatus::Ok => [0.into_dart()].into_dart(),
            crate::binding::LnUrlCallbackStatus::ErrorStatus { data } => {
                [1.into_dart(), data.into_into_dart().into_dart()].into_dart()
            }
            _ => {
                unimplemented!("");
            }
        }
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
    for FrbWrapper<crate::binding::LnUrlCallbackStatus>
{
}
impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::binding::LnUrlCallbackStatus>>
    for crate::binding::LnUrlCallbackStatus
{
    fn into_into_dart(self) -> FrbWrapper<crate::binding::LnUrlCallbackStatus> {
        self.into()
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::binding::LnUrlErrorData> {
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        [self.0.reason.into_into_dart().into_dart()].into_dart()
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
    for FrbWrapper<crate::binding::LnUrlErrorData>
{
}
impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::binding::LnUrlErrorData>>
    for crate::binding::LnUrlErrorData
{
    fn into_into_dart(self) -> FrbWrapper<crate::binding::LnUrlErrorData> {
        self.into()
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::binding::LnUrlPayErrorData> {
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        [
            self.0.payment_hash.into_into_dart().into_dart(),
            self.0.reason.into_into_dart().into_dart(),
        ]
        .into_dart()
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
    for FrbWrapper<crate::binding::LnUrlPayErrorData>
{
}
impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::binding::LnUrlPayErrorData>>
    for crate::binding::LnUrlPayErrorData
{
    fn into_into_dart(self) -> FrbWrapper<crate::binding::LnUrlPayErrorData> {
        self.into()
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::binding::LnUrlPayRequest> {
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        [
            self.0.data.into_into_dart().into_dart(),
            self.0.amount_msat.into_into_dart().into_dart(),
            self.0.use_trampoline.into_into_dart().into_dart(),
            self.0.comment.into_into_dart().into_dart(),
            self.0.payment_label.into_into_dart().into_dart(),
            self.0
                .validate_success_action_url
                .into_into_dart()
                .into_dart(),
        ]
        .into_dart()
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
    for FrbWrapper<crate::binding::LnUrlPayRequest>
{
}
impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::binding::LnUrlPayRequest>>
    for crate::binding::LnUrlPayRequest
{
    fn into_into_dart(self) -> FrbWrapper<crate::binding::LnUrlPayRequest> {
        self.into()
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::binding::LnUrlPayRequestData> {
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        [
            self.0.callback.into_into_dart().into_dart(),
            self.0.min_sendable.into_into_dart().into_dart(),
            self.0.max_sendable.into_into_dart().into_dart(),
            self.0.metadata_str.into_into_dart().into_dart(),
            self.0.comment_allowed.into_into_dart().into_dart(),
            self.0.domain.into_into_dart().into_dart(),
            self.0.allows_nostr.into_into_dart().into_dart(),
            self.0.nostr_pubkey.into_into_dart().into_dart(),
            self.0.ln_address.into_into_dart().into_dart(),
        ]
        .into_dart()
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
    for FrbWrapper<crate::binding::LnUrlPayRequestData>
{
}
impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::binding::LnUrlPayRequestData>>
    for crate::binding::LnUrlPayRequestData
{
    fn into_into_dart(self) -> FrbWrapper<crate::binding::LnUrlPayRequestData> {
        self.into()
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for crate::lnurl::pay::LnUrlPayResult {
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        match self {
            crate::lnurl::pay::LnUrlPayResult::EndpointSuccess { data } => {
                [0.into_dart(), data.into_into_dart().into_dart()].into_dart()
            }
            crate::lnurl::pay::LnUrlPayResult::EndpointError { data } => {
                [1.into_dart(), data.into_into_dart().into_dart()].into_dart()
            }
            crate::lnurl::pay::LnUrlPayResult::PayError { data } => {
                [2.into_dart(), data.into_into_dart().into_dart()].into_dart()
            }
            _ => {
                unimplemented!("");
            }
        }
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
    for crate::lnurl::pay::LnUrlPayResult
{
}
impl flutter_rust_bridge::IntoIntoDart<crate::lnurl::pay::LnUrlPayResult>
    for crate::lnurl::pay::LnUrlPayResult
{
    fn into_into_dart(self) -> crate::lnurl::pay::LnUrlPayResult {
        self
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for crate::lnurl::pay::LnUrlPaySuccessData {
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        [
            self.payment.into_into_dart().into_dart(),
            self.success_action.into_into_dart().into_dart(),
        ]
        .into_dart()
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
    for crate::lnurl::pay::LnUrlPaySuccessData
{
}
impl flutter_rust_bridge::IntoIntoDart<crate::lnurl::pay::LnUrlPaySuccessData>
    for crate::lnurl::pay::LnUrlPaySuccessData
{
    fn into_into_dart(self) -> crate::lnurl::pay::LnUrlPaySuccessData {
        self
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::binding::LnUrlWithdrawRequest> {
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        [
            self.0.data.into_into_dart().into_dart(),
            self.0.amount_msat.into_into_dart().into_dart(),
            self.0.description.into_into_dart().into_dart(),
        ]
        .into_dart()
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
    for FrbWrapper<crate::binding::LnUrlWithdrawRequest>
{
}
impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::binding::LnUrlWithdrawRequest>>
    for crate::binding::LnUrlWithdrawRequest
{
    fn into_into_dart(self) -> FrbWrapper<crate::binding::LnUrlWithdrawRequest> {
        self.into()
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::binding::LnUrlWithdrawRequestData> {
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        [
            self.0.callback.into_into_dart().into_dart(),
            self.0.k1.into_into_dart().into_dart(),
            self.0.default_description.into_into_dart().into_dart(),
            self.0.min_withdrawable.into_into_dart().into_dart(),
            self.0.max_withdrawable.into_into_dart().into_dart(),
        ]
        .into_dart()
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
    for FrbWrapper<crate::binding::LnUrlWithdrawRequestData>
{
}
impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::binding::LnUrlWithdrawRequestData>>
    for crate::binding::LnUrlWithdrawRequestData
{
    fn into_into_dart(self) -> FrbWrapper<crate::binding::LnUrlWithdrawRequestData> {
        self.into()
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::binding::LnUrlWithdrawResult> {
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        match self.0 {
            crate::binding::LnUrlWithdrawResult::Ok { data } => {
                [0.into_dart(), data.into_into_dart().into_dart()].into_dart()
            }
            crate::binding::LnUrlWithdrawResult::Timeout { data } => {
                [1.into_dart(), data.into_into_dart().into_dart()].into_dart()
            }
            crate::binding::LnUrlWithdrawResult::ErrorStatus { data } => {
                [2.into_dart(), data.into_into_dart().into_dart()].into_dart()
            }
            _ => {
                unimplemented!("");
            }
        }
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
    for FrbWrapper<crate::binding::LnUrlWithdrawResult>
{
}
impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::binding::LnUrlWithdrawResult>>
    for crate::binding::LnUrlWithdrawResult
{
    fn into_into_dart(self) -> FrbWrapper<crate::binding::LnUrlWithdrawResult> {
        self.into()
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::binding::LnUrlWithdrawSuccessData> {
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        [self.0.invoice.into_into_dart().into_dart()].into_dart()
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
    for FrbWrapper<crate::binding::LnUrlWithdrawSuccessData>
{
}
impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::binding::LnUrlWithdrawSuccessData>>
    for crate::binding::LnUrlWithdrawSuccessData
{
    fn into_into_dart(self) -> FrbWrapper<crate::binding::LnUrlWithdrawSuccessData> {
        self.into()
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::binding::LocaleOverrides> {
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        [
            self.0.locale.into_into_dart().into_dart(),
            self.0.spacing.into_into_dart().into_dart(),
            self.0.symbol.into_into_dart().into_dart(),
        ]
        .into_dart()
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
    for FrbWrapper<crate::binding::LocaleOverrides>
{
}
impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::binding::LocaleOverrides>>
    for crate::binding::LocaleOverrides
{
    fn into_into_dart(self) -> FrbWrapper<crate::binding::LocaleOverrides> {
        self.into()
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::binding::LocalizedName> {
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        [
            self.0.locale.into_into_dart().into_dart(),
            self.0.name.into_into_dart().into_dart(),
        ]
        .into_dart()
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
    for FrbWrapper<crate::binding::LocalizedName>
{
}
impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::binding::LocalizedName>>
    for crate::binding::LocalizedName
{
    fn into_into_dart(self) -> FrbWrapper<crate::binding::LocalizedName> {
        self.into()
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for crate::models::LogEntry {
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        [
            self.line.into_into_dart().into_dart(),
            self.level.into_into_dart().into_dart(),
        ]
        .into_dart()
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::models::LogEntry {}
impl flutter_rust_bridge::IntoIntoDart<crate::models::LogEntry> for crate::models::LogEntry {
    fn into_into_dart(self) -> crate::models::LogEntry {
        self
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for crate::lsp::LspInformation {
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        [
            self.id.into_into_dart().into_dart(),
            self.name.into_into_dart().into_dart(),
            self.widget_url.into_into_dart().into_dart(),
            self.pubkey.into_into_dart().into_dart(),
            self.host.into_into_dart().into_dart(),
            self.base_fee_msat.into_into_dart().into_dart(),
            self.fee_rate.into_into_dart().into_dart(),
            self.time_lock_delta.into_into_dart().into_dart(),
            self.min_htlc_msat.into_into_dart().into_dart(),
            self.lsp_pubkey.into_into_dart().into_dart(),
            self.opening_fee_params_list.into_into_dart().into_dart(),
        ]
        .into_dart()
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::lsp::LspInformation {}
impl flutter_rust_bridge::IntoIntoDart<crate::lsp::LspInformation> for crate::lsp::LspInformation {
    fn into_into_dart(self) -> crate::lsp::LspInformation {
        self
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::binding::MessageSuccessActionData> {
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        [self.0.message.into_into_dart().into_dart()].into_dart()
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
    for FrbWrapper<crate::binding::MessageSuccessActionData>
{
}
impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::binding::MessageSuccessActionData>>
    for crate::binding::MessageSuccessActionData
{
    fn into_into_dart(self) -> FrbWrapper<crate::binding::MessageSuccessActionData> {
        self.into()
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for crate::models::MetadataFilter {
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        [
            self.json_path.into_into_dart().into_dart(),
            self.json_value.into_into_dart().into_dart(),
        ]
        .into_dart()
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::models::MetadataFilter {}
impl flutter_rust_bridge::IntoIntoDart<crate::models::MetadataFilter>
    for crate::models::MetadataFilter
{
    fn into_into_dart(self) -> crate::models::MetadataFilter {
        self
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::binding::Network> {
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        match self.0 {
            crate::binding::Network::Bitcoin => 0.into_dart(),
            crate::binding::Network::Testnet => 1.into_dart(),
            crate::binding::Network::Signet => 2.into_dart(),
            crate::binding::Network::Regtest => 3.into_dart(),
            _ => unreachable!(),
        }
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
    for FrbWrapper<crate::binding::Network>
{
}
impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::binding::Network>>
    for crate::binding::Network
{
    fn into_into_dart(self) -> FrbWrapper<crate::binding::Network> {
        self.into()
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for crate::models::NodeConfig {
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        match self {
            crate::models::NodeConfig::Greenlight { config } => {
                [0.into_dart(), config.into_into_dart().into_dart()].into_dart()
            }
            _ => {
                unimplemented!("");
            }
        }
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::models::NodeConfig {}
impl flutter_rust_bridge::IntoIntoDart<crate::models::NodeConfig> for crate::models::NodeConfig {
    fn into_into_dart(self) -> crate::models::NodeConfig {
        self
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for crate::models::NodeCredentials {
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        match self {
            crate::models::NodeCredentials::Greenlight { credentials } => {
                [0.into_dart(), credentials.into_into_dart().into_dart()].into_dart()
            }
            _ => {
                unimplemented!("");
            }
        }
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
    for crate::models::NodeCredentials
{
}
impl flutter_rust_bridge::IntoIntoDart<crate::models::NodeCredentials>
    for crate::models::NodeCredentials
{
    fn into_into_dart(self) -> crate::models::NodeCredentials {
        self
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for crate::models::NodeState {
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        [
            self.id.into_into_dart().into_dart(),
            self.block_height.into_into_dart().into_dart(),
            self.channels_balance_msat.into_into_dart().into_dart(),
            self.onchain_balance_msat.into_into_dart().into_dart(),
            self.pending_onchain_balance_msat
                .into_into_dart()
                .into_dart(),
            self.utxos.into_into_dart().into_dart(),
            self.max_payable_msat.into_into_dart().into_dart(),
            self.max_receivable_msat.into_into_dart().into_dart(),
            self.max_single_payment_amount_msat
                .into_into_dart()
                .into_dart(),
            self.max_chan_reserve_msats.into_into_dart().into_dart(),
            self.connected_peers.into_into_dart().into_dart(),
            self.max_receivable_single_payment_amount_msat
                .into_into_dart()
                .into_dart(),
            self.total_inbound_liquidity_msats
                .into_into_dart()
                .into_dart(),
        ]
        .into_dart()
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::models::NodeState {}
impl flutter_rust_bridge::IntoIntoDart<crate::models::NodeState> for crate::models::NodeState {
    fn into_into_dart(self) -> crate::models::NodeState {
        self
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for crate::models::OnchainPaymentLimitsResponse {
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        [
            self.min_sat.into_into_dart().into_dart(),
            self.max_sat.into_into_dart().into_dart(),
            self.max_payable_sat.into_into_dart().into_dart(),
        ]
        .into_dart()
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
    for crate::models::OnchainPaymentLimitsResponse
{
}
impl flutter_rust_bridge::IntoIntoDart<crate::models::OnchainPaymentLimitsResponse>
    for crate::models::OnchainPaymentLimitsResponse
{
    fn into_into_dart(self) -> crate::models::OnchainPaymentLimitsResponse {
        self
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for crate::models::OpenChannelFeeRequest {
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        [
            self.amount_msat.into_into_dart().into_dart(),
            self.expiry.into_into_dart().into_dart(),
        ]
        .into_dart()
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
    for crate::models::OpenChannelFeeRequest
{
}
impl flutter_rust_bridge::IntoIntoDart<crate::models::OpenChannelFeeRequest>
    for crate::models::OpenChannelFeeRequest
{
    fn into_into_dart(self) -> crate::models::OpenChannelFeeRequest {
        self
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for crate::models::OpenChannelFeeResponse {
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        [
            self.fee_msat.into_into_dart().into_dart(),
            self.fee_params.into_into_dart().into_dart(),
        ]
        .into_dart()
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
    for crate::models::OpenChannelFeeResponse
{
}
impl flutter_rust_bridge::IntoIntoDart<crate::models::OpenChannelFeeResponse>
    for crate::models::OpenChannelFeeResponse
{
    fn into_into_dart(self) -> crate::models::OpenChannelFeeResponse {
        self
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for crate::models::OpeningFeeParams {
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        [
            self.min_msat.into_into_dart().into_dart(),
            self.proportional.into_into_dart().into_dart(),
            self.valid_until.into_into_dart().into_dart(),
            self.max_idle_time.into_into_dart().into_dart(),
            self.max_client_to_self_delay.into_into_dart().into_dart(),
            self.promise.into_into_dart().into_dart(),
        ]
        .into_dart()
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
    for crate::models::OpeningFeeParams
{
}
impl flutter_rust_bridge::IntoIntoDart<crate::models::OpeningFeeParams>
    for crate::models::OpeningFeeParams
{
    fn into_into_dart(self) -> crate::models::OpeningFeeParams {
        self
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for crate::models::OpeningFeeParamsMenu {
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        [self.values.into_into_dart().into_dart()].into_dart()
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
    for crate::models::OpeningFeeParamsMenu
{
}
impl flutter_rust_bridge::IntoIntoDart<crate::models::OpeningFeeParamsMenu>
    for crate::models::OpeningFeeParamsMenu
{
    fn into_into_dart(self) -> crate::models::OpeningFeeParamsMenu {
        self
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for crate::models::PayOnchainRequest {
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        [
            self.recipient_address.into_into_dart().into_dart(),
            self.prepare_res.into_into_dart().into_dart(),
        ]
        .into_dart()
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
    for crate::models::PayOnchainRequest
{
}
impl flutter_rust_bridge::IntoIntoDart<crate::models::PayOnchainRequest>
    for crate::models::PayOnchainRequest
{
    fn into_into_dart(self) -> crate::models::PayOnchainRequest {
        self
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for crate::models::PayOnchainResponse {
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        [self.reverse_swap_info.into_into_dart().into_dart()].into_dart()
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
    for crate::models::PayOnchainResponse
{
}
impl flutter_rust_bridge::IntoIntoDart<crate::models::PayOnchainResponse>
    for crate::models::PayOnchainResponse
{
    fn into_into_dart(self) -> crate::models::PayOnchainResponse {
        self
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for crate::models::Payment {
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        [
            self.id.into_into_dart().into_dart(),
            self.payment_type.into_into_dart().into_dart(),
            self.payment_time.into_into_dart().into_dart(),
            self.amount_msat.into_into_dart().into_dart(),
            self.fee_msat.into_into_dart().into_dart(),
            self.status.into_into_dart().into_dart(),
            self.error.into_into_dart().into_dart(),
            self.description.into_into_dart().into_dart(),
            self.details.into_into_dart().into_dart(),
            self.metadata.into_into_dart().into_dart(),
        ]
        .into_dart()
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::models::Payment {}
impl flutter_rust_bridge::IntoIntoDart<crate::models::Payment> for crate::models::Payment {
    fn into_into_dart(self) -> crate::models::Payment {
        self
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for crate::models::PaymentDetails {
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        match self {
            crate::models::PaymentDetails::Ln { data } => {
                [0.into_dart(), data.into_into_dart().into_dart()].into_dart()
            }
            crate::models::PaymentDetails::ClosedChannel { data } => {
                [1.into_dart(), data.into_into_dart().into_dart()].into_dart()
            }
            _ => {
                unimplemented!("");
            }
        }
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::models::PaymentDetails {}
impl flutter_rust_bridge::IntoIntoDart<crate::models::PaymentDetails>
    for crate::models::PaymentDetails
{
    fn into_into_dart(self) -> crate::models::PaymentDetails {
        self
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for crate::breez_services::PaymentFailedData {
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        [
            self.error.into_into_dart().into_dart(),
            self.node_id.into_into_dart().into_dart(),
            self.invoice.into_into_dart().into_dart(),
            self.label.into_into_dart().into_dart(),
        ]
        .into_dart()
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
    for crate::breez_services::PaymentFailedData
{
}
impl flutter_rust_bridge::IntoIntoDart<crate::breez_services::PaymentFailedData>
    for crate::breez_services::PaymentFailedData
{
    fn into_into_dart(self) -> crate::breez_services::PaymentFailedData {
        self
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for crate::models::PaymentStatus {
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        match self {
            Self::Pending => 0.into_dart(),
            Self::Complete => 1.into_dart(),
            Self::Failed => 2.into_dart(),
            _ => unreachable!(),
        }
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::models::PaymentStatus {}
impl flutter_rust_bridge::IntoIntoDart<crate::models::PaymentStatus>
    for crate::models::PaymentStatus
{
    fn into_into_dart(self) -> crate::models::PaymentStatus {
        self
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for crate::models::PaymentType {
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        match self {
            Self::Sent => 0.into_dart(),
            Self::Received => 1.into_dart(),
            Self::ClosedChannel => 2.into_dart(),
            _ => unreachable!(),
        }
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::models::PaymentType {}
impl flutter_rust_bridge::IntoIntoDart<crate::models::PaymentType> for crate::models::PaymentType {
    fn into_into_dart(self) -> crate::models::PaymentType {
        self
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for crate::models::PaymentTypeFilter {
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        match self {
            Self::Sent => 0.into_dart(),
            Self::Received => 1.into_dart(),
            Self::ClosedChannel => 2.into_dart(),
            _ => unreachable!(),
        }
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
    for crate::models::PaymentTypeFilter
{
}
impl flutter_rust_bridge::IntoIntoDart<crate::models::PaymentTypeFilter>
    for crate::models::PaymentTypeFilter
{
    fn into_into_dart(self) -> crate::models::PaymentTypeFilter {
        self
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for crate::models::PrepareOnchainPaymentRequest {
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        [
            self.amount_sat.into_into_dart().into_dart(),
            self.amount_type.into_into_dart().into_dart(),
            self.claim_tx_feerate.into_into_dart().into_dart(),
        ]
        .into_dart()
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
    for crate::models::PrepareOnchainPaymentRequest
{
}
impl flutter_rust_bridge::IntoIntoDart<crate::models::PrepareOnchainPaymentRequest>
    for crate::models::PrepareOnchainPaymentRequest
{
    fn into_into_dart(self) -> crate::models::PrepareOnchainPaymentRequest {
        self
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for crate::models::PrepareOnchainPaymentResponse {
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        [
            self.fees_hash.into_into_dart().into_dart(),
            self.fees_percentage.into_into_dart().into_dart(),
            self.fees_lockup.into_into_dart().into_dart(),
            self.fees_claim.into_into_dart().into_dart(),
            self.sender_amount_sat.into_into_dart().into_dart(),
            self.recipient_amount_sat.into_into_dart().into_dart(),
            self.total_fees.into_into_dart().into_dart(),
        ]
        .into_dart()
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
    for crate::models::PrepareOnchainPaymentResponse
{
}
impl flutter_rust_bridge::IntoIntoDart<crate::models::PrepareOnchainPaymentResponse>
    for crate::models::PrepareOnchainPaymentResponse
{
    fn into_into_dart(self) -> crate::models::PrepareOnchainPaymentResponse {
        self
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for crate::models::PrepareRedeemOnchainFundsRequest {
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        [
            self.to_address.into_into_dart().into_dart(),
            self.sat_per_vbyte.into_into_dart().into_dart(),
        ]
        .into_dart()
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
    for crate::models::PrepareRedeemOnchainFundsRequest
{
}
impl flutter_rust_bridge::IntoIntoDart<crate::models::PrepareRedeemOnchainFundsRequest>
    for crate::models::PrepareRedeemOnchainFundsRequest
{
    fn into_into_dart(self) -> crate::models::PrepareRedeemOnchainFundsRequest {
        self
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for crate::models::PrepareRedeemOnchainFundsResponse {
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        [
            self.tx_weight.into_into_dart().into_dart(),
            self.tx_fee_sat.into_into_dart().into_dart(),
        ]
        .into_dart()
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
    for crate::models::PrepareRedeemOnchainFundsResponse
{
}
impl flutter_rust_bridge::IntoIntoDart<crate::models::PrepareRedeemOnchainFundsResponse>
    for crate::models::PrepareRedeemOnchainFundsResponse
{
    fn into_into_dart(self) -> crate::models::PrepareRedeemOnchainFundsResponse {
        self
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for crate::models::PrepareRefundRequest {
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        [
            self.swap_address.into_into_dart().into_dart(),
            self.to_address.into_into_dart().into_dart(),
            self.sat_per_vbyte.into_into_dart().into_dart(),
            self.unilateral.into_into_dart().into_dart(),
        ]
        .into_dart()
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
    for crate::models::PrepareRefundRequest
{
}
impl flutter_rust_bridge::IntoIntoDart<crate::models::PrepareRefundRequest>
    for crate::models::PrepareRefundRequest
{
    fn into_into_dart(self) -> crate::models::PrepareRefundRequest {
        self
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for crate::models::PrepareRefundResponse {
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        [
            self.refund_tx_weight.into_into_dart().into_dart(),
            self.refund_tx_fee_sat.into_into_dart().into_dart(),
        ]
        .into_dart()
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
    for crate::models::PrepareRefundResponse
{
}
impl flutter_rust_bridge::IntoIntoDart<crate::models::PrepareRefundResponse>
    for crate::models::PrepareRefundResponse
{
    fn into_into_dart(self) -> crate::models::PrepareRefundResponse {
        self
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::binding::Rate> {
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        [
            self.0.coin.into_into_dart().into_dart(),
            self.0.value.into_into_dart().into_dart(),
        ]
        .into_dart()
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
    for FrbWrapper<crate::binding::Rate>
{
}
impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::binding::Rate>> for crate::binding::Rate {
    fn into_into_dart(self) -> FrbWrapper<crate::binding::Rate> {
        self.into()
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for crate::models::ReceiveOnchainRequest {
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        [self.opening_fee_params.into_into_dart().into_dart()].into_dart()
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
    for crate::models::ReceiveOnchainRequest
{
}
impl flutter_rust_bridge::IntoIntoDart<crate::models::ReceiveOnchainRequest>
    for crate::models::ReceiveOnchainRequest
{
    fn into_into_dart(self) -> crate::models::ReceiveOnchainRequest {
        self
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for crate::models::ReceivePaymentRequest {
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        [
            self.amount_msat.into_into_dart().into_dart(),
            self.description.into_into_dart().into_dart(),
            self.preimage.into_into_dart().into_dart(),
            self.opening_fee_params.into_into_dart().into_dart(),
            self.use_description_hash.into_into_dart().into_dart(),
            self.expiry.into_into_dart().into_dart(),
            self.cltv.into_into_dart().into_dart(),
        ]
        .into_dart()
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
    for crate::models::ReceivePaymentRequest
{
}
impl flutter_rust_bridge::IntoIntoDart<crate::models::ReceivePaymentRequest>
    for crate::models::ReceivePaymentRequest
{
    fn into_into_dart(self) -> crate::models::ReceivePaymentRequest {
        self
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for crate::models::ReceivePaymentResponse {
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        [
            self.ln_invoice.into_into_dart().into_dart(),
            self.opening_fee_params.into_into_dart().into_dart(),
            self.opening_fee_msat.into_into_dart().into_dart(),
        ]
        .into_dart()
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
    for crate::models::ReceivePaymentResponse
{
}
impl flutter_rust_bridge::IntoIntoDart<crate::models::ReceivePaymentResponse>
    for crate::models::ReceivePaymentResponse
{
    fn into_into_dart(self) -> crate::models::ReceivePaymentResponse {
        self
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for crate::chain::RecommendedFees {
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        [
            self.fastest_fee.into_into_dart().into_dart(),
            self.half_hour_fee.into_into_dart().into_dart(),
            self.hour_fee.into_into_dart().into_dart(),
            self.economy_fee.into_into_dart().into_dart(),
            self.minimum_fee.into_into_dart().into_dart(),
        ]
        .into_dart()
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::chain::RecommendedFees {}
impl flutter_rust_bridge::IntoIntoDart<crate::chain::RecommendedFees>
    for crate::chain::RecommendedFees
{
    fn into_into_dart(self) -> crate::chain::RecommendedFees {
        self
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for crate::models::RedeemOnchainFundsRequest {
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        [
            self.to_address.into_into_dart().into_dart(),
            self.sat_per_vbyte.into_into_dart().into_dart(),
        ]
        .into_dart()
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
    for crate::models::RedeemOnchainFundsRequest
{
}
impl flutter_rust_bridge::IntoIntoDart<crate::models::RedeemOnchainFundsRequest>
    for crate::models::RedeemOnchainFundsRequest
{
    fn into_into_dart(self) -> crate::models::RedeemOnchainFundsRequest {
        self
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for crate::models::RedeemOnchainFundsResponse {
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        [self.txid.into_into_dart().into_dart()].into_dart()
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
    for crate::models::RedeemOnchainFundsResponse
{
}
impl flutter_rust_bridge::IntoIntoDart<crate::models::RedeemOnchainFundsResponse>
    for crate::models::RedeemOnchainFundsResponse
{
    fn into_into_dart(self) -> crate::models::RedeemOnchainFundsResponse {
        self
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for crate::models::RefundRequest {
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        [
            self.swap_address.into_into_dart().into_dart(),
            self.to_address.into_into_dart().into_dart(),
            self.sat_per_vbyte.into_into_dart().into_dart(),
            self.unilateral.into_into_dart().into_dart(),
        ]
        .into_dart()
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::models::RefundRequest {}
impl flutter_rust_bridge::IntoIntoDart<crate::models::RefundRequest>
    for crate::models::RefundRequest
{
    fn into_into_dart(self) -> crate::models::RefundRequest {
        self
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for crate::models::RefundResponse {
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        [self.refund_tx_id.into_into_dart().into_dart()].into_dart()
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::models::RefundResponse {}
impl flutter_rust_bridge::IntoIntoDart<crate::models::RefundResponse>
    for crate::models::RefundResponse
{
    fn into_into_dart(self) -> crate::models::RefundResponse {
        self
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for crate::models::ReportIssueRequest {
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        match self {
            crate::models::ReportIssueRequest::PaymentFailure { data } => {
                [0.into_dart(), data.into_into_dart().into_dart()].into_dart()
            }
            _ => {
                unimplemented!("");
            }
        }
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
    for crate::models::ReportIssueRequest
{
}
impl flutter_rust_bridge::IntoIntoDart<crate::models::ReportIssueRequest>
    for crate::models::ReportIssueRequest
{
    fn into_into_dart(self) -> crate::models::ReportIssueRequest {
        self
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for crate::models::ReportPaymentFailureDetails {
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        [
            self.payment_hash.into_into_dart().into_dart(),
            self.comment.into_into_dart().into_dart(),
        ]
        .into_dart()
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
    for crate::models::ReportPaymentFailureDetails
{
}
impl flutter_rust_bridge::IntoIntoDart<crate::models::ReportPaymentFailureDetails>
    for crate::models::ReportPaymentFailureDetails
{
    fn into_into_dart(self) -> crate::models::ReportPaymentFailureDetails {
        self
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for crate::models::ReverseSwapFeesRequest {
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        [
            self.send_amount_sat.into_into_dart().into_dart(),
            self.claim_tx_feerate.into_into_dart().into_dart(),
        ]
        .into_dart()
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
    for crate::models::ReverseSwapFeesRequest
{
}
impl flutter_rust_bridge::IntoIntoDart<crate::models::ReverseSwapFeesRequest>
    for crate::models::ReverseSwapFeesRequest
{
    fn into_into_dart(self) -> crate::models::ReverseSwapFeesRequest {
        self
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for crate::models::ReverseSwapInfo {
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        [
            self.id.into_into_dart().into_dart(),
            self.claim_pubkey.into_into_dart().into_dart(),
            self.lockup_txid.into_into_dart().into_dart(),
            self.claim_txid.into_into_dart().into_dart(),
            self.onchain_amount_sat.into_into_dart().into_dart(),
            self.status.into_into_dart().into_dart(),
        ]
        .into_dart()
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
    for crate::models::ReverseSwapInfo
{
}
impl flutter_rust_bridge::IntoIntoDart<crate::models::ReverseSwapInfo>
    for crate::models::ReverseSwapInfo
{
    fn into_into_dart(self) -> crate::models::ReverseSwapInfo {
        self
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for crate::models::ReverseSwapPairInfo {
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        [
            self.min.into_into_dart().into_dart(),
            self.max.into_into_dart().into_dart(),
            self.fees_hash.into_into_dart().into_dart(),
            self.fees_percentage.into_into_dart().into_dart(),
            self.fees_lockup.into_into_dart().into_dart(),
            self.fees_claim.into_into_dart().into_dart(),
            self.total_fees.into_into_dart().into_dart(),
        ]
        .into_dart()
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
    for crate::models::ReverseSwapPairInfo
{
}
impl flutter_rust_bridge::IntoIntoDart<crate::models::ReverseSwapPairInfo>
    for crate::models::ReverseSwapPairInfo
{
    fn into_into_dart(self) -> crate::models::ReverseSwapPairInfo {
        self
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for crate::models::ReverseSwapStatus {
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        match self {
            Self::Initial => 0.into_dart(),
            Self::InProgress => 1.into_dart(),
            Self::Cancelled => 2.into_dart(),
            Self::CompletedSeen => 3.into_dart(),
            Self::CompletedConfirmed => 4.into_dart(),
            _ => unreachable!(),
        }
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
    for crate::models::ReverseSwapStatus
{
}
impl flutter_rust_bridge::IntoIntoDart<crate::models::ReverseSwapStatus>
    for crate::models::ReverseSwapStatus
{
    fn into_into_dart(self) -> crate::models::ReverseSwapStatus {
        self
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::binding::RouteHint> {
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        [self.0.hops.into_into_dart().into_dart()].into_dart()
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
    for FrbWrapper<crate::binding::RouteHint>
{
}
impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::binding::RouteHint>>
    for crate::binding::RouteHint
{
    fn into_into_dart(self) -> FrbWrapper<crate::binding::RouteHint> {
        self.into()
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::binding::RouteHintHop> {
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        [
            self.0.src_node_id.into_into_dart().into_dart(),
            self.0.short_channel_id.into_into_dart().into_dart(),
            self.0.fees_base_msat.into_into_dart().into_dart(),
            self.0
                .fees_proportional_millionths
                .into_into_dart()
                .into_dart(),
            self.0.cltv_expiry_delta.into_into_dart().into_dart(),
            self.0.htlc_minimum_msat.into_into_dart().into_dart(),
            self.0.htlc_maximum_msat.into_into_dart().into_dart(),
        ]
        .into_dart()
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
    for FrbWrapper<crate::binding::RouteHintHop>
{
}
impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::binding::RouteHintHop>>
    for crate::binding::RouteHintHop
{
    fn into_into_dart(self) -> FrbWrapper<crate::binding::RouteHintHop> {
        self.into()
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for crate::models::SendPaymentRequest {
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        [
            self.bolt11.into_into_dart().into_dart(),
            self.use_trampoline.into_into_dart().into_dart(),
            self.amount_msat.into_into_dart().into_dart(),
            self.label.into_into_dart().into_dart(),
        ]
        .into_dart()
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
    for crate::models::SendPaymentRequest
{
}
impl flutter_rust_bridge::IntoIntoDart<crate::models::SendPaymentRequest>
    for crate::models::SendPaymentRequest
{
    fn into_into_dart(self) -> crate::models::SendPaymentRequest {
        self
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for crate::models::SendPaymentResponse {
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        [self.payment.into_into_dart().into_dart()].into_dart()
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
    for crate::models::SendPaymentResponse
{
}
impl flutter_rust_bridge::IntoIntoDart<crate::models::SendPaymentResponse>
    for crate::models::SendPaymentResponse
{
    fn into_into_dart(self) -> crate::models::SendPaymentResponse {
        self
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for crate::models::SendSpontaneousPaymentRequest {
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        [
            self.node_id.into_into_dart().into_dart(),
            self.amount_msat.into_into_dart().into_dart(),
            self.extra_tlvs.into_into_dart().into_dart(),
            self.label.into_into_dart().into_dart(),
        ]
        .into_dart()
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
    for crate::models::SendSpontaneousPaymentRequest
{
}
impl flutter_rust_bridge::IntoIntoDart<crate::models::SendSpontaneousPaymentRequest>
    for crate::models::SendSpontaneousPaymentRequest
{
    fn into_into_dart(self) -> crate::models::SendSpontaneousPaymentRequest {
        self
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for crate::models::ServiceHealthCheckResponse {
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        [self.status.into_into_dart().into_dart()].into_dart()
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
    for crate::models::ServiceHealthCheckResponse
{
}
impl flutter_rust_bridge::IntoIntoDart<crate::models::ServiceHealthCheckResponse>
    for crate::models::ServiceHealthCheckResponse
{
    fn into_into_dart(self) -> crate::models::ServiceHealthCheckResponse {
        self
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for crate::breez_services::SignMessageRequest {
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        [self.message.into_into_dart().into_dart()].into_dart()
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
    for crate::breez_services::SignMessageRequest
{
}
impl flutter_rust_bridge::IntoIntoDart<crate::breez_services::SignMessageRequest>
    for crate::breez_services::SignMessageRequest
{
    fn into_into_dart(self) -> crate::breez_services::SignMessageRequest {
        self
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for crate::breez_services::SignMessageResponse {
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        [self.signature.into_into_dart().into_dart()].into_dart()
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
    for crate::breez_services::SignMessageResponse
{
}
impl flutter_rust_bridge::IntoIntoDart<crate::breez_services::SignMessageResponse>
    for crate::breez_services::SignMessageResponse
{
    fn into_into_dart(self) -> crate::breez_services::SignMessageResponse {
        self
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for crate::models::StaticBackupRequest {
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        [self.working_dir.into_into_dart().into_dart()].into_dart()
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
    for crate::models::StaticBackupRequest
{
}
impl flutter_rust_bridge::IntoIntoDart<crate::models::StaticBackupRequest>
    for crate::models::StaticBackupRequest
{
    fn into_into_dart(self) -> crate::models::StaticBackupRequest {
        self
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for crate::models::StaticBackupResponse {
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        [self.backup.into_into_dart().into_dart()].into_dart()
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
    for crate::models::StaticBackupResponse
{
}
impl flutter_rust_bridge::IntoIntoDart<crate::models::StaticBackupResponse>
    for crate::models::StaticBackupResponse
{
    fn into_into_dart(self) -> crate::models::StaticBackupResponse {
        self
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::binding::SuccessActionProcessed> {
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        match self.0 {
            crate::binding::SuccessActionProcessed::Aes { result } => {
                [0.into_dart(), result.into_into_dart().into_dart()].into_dart()
            }
            crate::binding::SuccessActionProcessed::Message { data } => {
                [1.into_dart(), data.into_into_dart().into_dart()].into_dart()
            }
            crate::binding::SuccessActionProcessed::Url { data } => {
                [2.into_dart(), data.into_into_dart().into_dart()].into_dart()
            }
            _ => {
                unimplemented!("");
            }
        }
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
    for FrbWrapper<crate::binding::SuccessActionProcessed>
{
}
impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::binding::SuccessActionProcessed>>
    for crate::binding::SuccessActionProcessed
{
    fn into_into_dart(self) -> FrbWrapper<crate::binding::SuccessActionProcessed> {
        self.into()
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for crate::models::SwapAmountType {
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        match self {
            Self::Send => 0.into_dart(),
            Self::Receive => 1.into_dart(),
            _ => unreachable!(),
        }
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::models::SwapAmountType {}
impl flutter_rust_bridge::IntoIntoDart<crate::models::SwapAmountType>
    for crate::models::SwapAmountType
{
    fn into_into_dart(self) -> crate::models::SwapAmountType {
        self
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for crate::models::SwapInfo {
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        [
            self.bitcoin_address.into_into_dart().into_dart(),
            self.created_at.into_into_dart().into_dart(),
            self.lock_height.into_into_dart().into_dart(),
            self.payment_hash.into_into_dart().into_dart(),
            self.preimage.into_into_dart().into_dart(),
            self.private_key.into_into_dart().into_dart(),
            self.public_key.into_into_dart().into_dart(),
            self.swapper_public_key.into_into_dart().into_dart(),
            self.script.into_into_dart().into_dart(),
            self.bolt11.into_into_dart().into_dart(),
            self.paid_msat.into_into_dart().into_dart(),
            self.total_incoming_txs.into_into_dart().into_dart(),
            self.confirmed_sats.into_into_dart().into_dart(),
            self.unconfirmed_sats.into_into_dart().into_dart(),
            self.status.into_into_dart().into_dart(),
            self.refund_tx_ids.into_into_dart().into_dart(),
            self.unconfirmed_tx_ids.into_into_dart().into_dart(),
            self.confirmed_tx_ids.into_into_dart().into_dart(),
            self.min_allowed_deposit.into_into_dart().into_dart(),
            self.max_allowed_deposit.into_into_dart().into_dart(),
            self.max_swapper_payable.into_into_dart().into_dart(),
            self.last_redeem_error.into_into_dart().into_dart(),
            self.channel_opening_fees.into_into_dart().into_dart(),
            self.confirmed_at.into_into_dart().into_dart(),
        ]
        .into_dart()
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::models::SwapInfo {}
impl flutter_rust_bridge::IntoIntoDart<crate::models::SwapInfo> for crate::models::SwapInfo {
    fn into_into_dart(self) -> crate::models::SwapInfo {
        self
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for crate::models::SwapStatus {
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        match self {
            Self::Initial => 0.into_dart(),
            Self::WaitingConfirmation => 1.into_dart(),
            Self::Redeemable => 2.into_dart(),
            Self::Redeemed => 3.into_dart(),
            Self::Refundable => 4.into_dart(),
            Self::Completed => 5.into_dart(),
            _ => unreachable!(),
        }
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::models::SwapStatus {}
impl flutter_rust_bridge::IntoIntoDart<crate::models::SwapStatus> for crate::models::SwapStatus {
    fn into_into_dart(self) -> crate::models::SwapStatus {
        self
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::binding::Symbol> {
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        [
            self.0.grapheme.into_into_dart().into_dart(),
            self.0.template.into_into_dart().into_dart(),
            self.0.rtl.into_into_dart().into_dart(),
            self.0.position.into_into_dart().into_dart(),
        ]
        .into_dart()
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
    for FrbWrapper<crate::binding::Symbol>
{
}
impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::binding::Symbol>>
    for crate::binding::Symbol
{
    fn into_into_dart(self) -> FrbWrapper<crate::binding::Symbol> {
        self.into()
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for crate::models::TlvEntry {
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        [
            self.field_number.into_into_dart().into_dart(),
            self.value.into_into_dart().into_dart(),
        ]
        .into_dart()
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::models::TlvEntry {}
impl flutter_rust_bridge::IntoIntoDart<crate::models::TlvEntry> for crate::models::TlvEntry {
    fn into_into_dart(self) -> crate::models::TlvEntry {
        self
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for crate::models::UnspentTransactionOutput {
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        [
            self.txid.into_into_dart().into_dart(),
            self.outnum.into_into_dart().into_dart(),
            self.amount_millisatoshi.into_into_dart().into_dart(),
            self.address.into_into_dart().into_dart(),
            self.reserved.into_into_dart().into_dart(),
        ]
        .into_dart()
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
    for crate::models::UnspentTransactionOutput
{
}
impl flutter_rust_bridge::IntoIntoDart<crate::models::UnspentTransactionOutput>
    for crate::models::UnspentTransactionOutput
{
    fn into_into_dart(self) -> crate::models::UnspentTransactionOutput {
        self
    }
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::binding::UrlSuccessActionData> {
    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
        [
            self.0.description.into_into_dart().into_dart(),
            self.0.url.into_into_dart().into_dart(),
            self.0.matches_callback_domain.into_into_dart().into_dart(),
        ]
        .into_dart()
    }
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
    for FrbWrapper<crate::binding::UrlSuccessActionData>
{
}
impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::binding::UrlSuccessActionData>>
    for crate::binding::UrlSuccessActionData
{
    fn into_into_dart(self) -> FrbWrapper<crate::binding::UrlSuccessActionData> {
        self.into()
    }
}

impl SseEncode for flutter_rust_bridge::for_generated::anyhow::Error {
    // 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(format!("{:?}", self), serializer);
    }
}

impl SseEncode
    for StreamSink<crate::breez_services::BreezEvent, flutter_rust_bridge::for_generated::DcoCodec>
{
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
        unimplemented!("")
    }
}

impl SseEncode
    for StreamSink<crate::models::LogEntry, flutter_rust_bridge::for_generated::DcoCodec>
{
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
        unimplemented!("")
    }
}

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::binding::AesSuccessActionDataDecrypted {
    // 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.description, serializer);
        <String>::sse_encode(self.plaintext, serializer);
    }
}

impl SseEncode for crate::binding::AesSuccessActionDataResult {
    // 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::binding::AesSuccessActionDataResult::Decrypted { data } => {
                <i32>::sse_encode(0, serializer);
                <crate::binding::AesSuccessActionDataDecrypted>::sse_encode(data, serializer);
            }
            crate::binding::AesSuccessActionDataResult::ErrorStatus { reason } => {
                <i32>::sse_encode(1, serializer);
                <String>::sse_encode(reason, serializer);
            }
            _ => {
                unimplemented!("");
            }
        }
    }
}

impl SseEncode for crate::breez_services::BackupFailedData {
    // 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.error, serializer);
    }
}

impl SseEncode for crate::models::BackupStatus {
    // 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.backed_up, serializer);
        <Option<u64>>::sse_encode(self.last_backup_time, serializer);
    }
}

impl SseEncode for crate::binding::BindingEventListener {
    // 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::binding::BitcoinAddressData {
    // 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.address, serializer);
        <crate::binding::Network>::sse_encode(self.network, serializer);
        <Option<u64>>::sse_encode(self.amount_sat, serializer);
        <Option<String>>::sse_encode(self.label, serializer);
        <Option<String>>::sse_encode(self.message, 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::breez_services::BreezEvent {
    // 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::breez_services::BreezEvent::NewBlock { block } => {
                <i32>::sse_encode(0, serializer);
                <u32>::sse_encode(block, serializer);
            }
            crate::breez_services::BreezEvent::InvoicePaid { details } => {
                <i32>::sse_encode(1, serializer);
                <crate::breez_services::InvoicePaidDetails>::sse_encode(details, serializer);
            }
            crate::breez_services::BreezEvent::Synced => {
                <i32>::sse_encode(2, serializer);
            }
            crate::breez_services::BreezEvent::PaymentSucceed { details } => {
                <i32>::sse_encode(3, serializer);
                <crate::models::Payment>::sse_encode(details, serializer);
            }
            crate::breez_services::BreezEvent::PaymentFailed { details } => {
                <i32>::sse_encode(4, serializer);
                <crate::breez_services::PaymentFailedData>::sse_encode(details, serializer);
            }
            crate::breez_services::BreezEvent::BackupStarted => {
                <i32>::sse_encode(5, serializer);
            }
            crate::breez_services::BreezEvent::BackupSucceeded => {
                <i32>::sse_encode(6, serializer);
            }
            crate::breez_services::BreezEvent::BackupFailed { details } => {
                <i32>::sse_encode(7, serializer);
                <crate::breez_services::BackupFailedData>::sse_encode(details, serializer);
            }
            crate::breez_services::BreezEvent::ReverseSwapUpdated { details } => {
                <i32>::sse_encode(8, serializer);
                <crate::models::ReverseSwapInfo>::sse_encode(details, serializer);
            }
            crate::breez_services::BreezEvent::SwapUpdated { details } => {
                <i32>::sse_encode(9, serializer);
                <crate::models::SwapInfo>::sse_encode(details, serializer);
            }
            _ => {
                unimplemented!("");
            }
        }
    }
}

impl SseEncode for crate::models::BuyBitcoinProvider {
    // 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::models::BuyBitcoinProvider::Moonpay => 0,
                _ => {
                    unimplemented!("");
                }
            },
            serializer,
        );
    }
}

impl SseEncode for crate::models::BuyBitcoinRequest {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
        <crate::models::BuyBitcoinProvider>::sse_encode(self.provider, serializer);
        <Option<crate::models::OpeningFeeParams>>::sse_encode(self.opening_fee_params, serializer);
        <Option<String>>::sse_encode(self.redirect_url, serializer);
    }
}

impl SseEncode for crate::models::BuyBitcoinResponse {
    // 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.url, serializer);
        <Option<crate::models::OpeningFeeParams>>::sse_encode(self.opening_fee_params, serializer);
    }
}

impl SseEncode for crate::models::ChannelState {
    // 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::models::ChannelState::PendingOpen => 0,
                crate::models::ChannelState::Opened => 1,
                crate::models::ChannelState::PendingClose => 2,
                crate::models::ChannelState::Closed => 3,
                _ => {
                    unimplemented!("");
                }
            },
            serializer,
        );
    }
}

impl SseEncode for crate::breez_services::CheckMessageRequest {
    // 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.message, serializer);
        <String>::sse_encode(self.pubkey, serializer);
        <String>::sse_encode(self.signature, serializer);
    }
}

impl SseEncode for crate::breez_services::CheckMessageResponse {
    // 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_valid, serializer);
    }
}

impl SseEncode for crate::models::ClosedChannelPaymentDetails {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
        <crate::models::ChannelState>::sse_encode(self.state, serializer);
        <String>::sse_encode(self.funding_txid, serializer);
        <Option<String>>::sse_encode(self.short_channel_id, serializer);
        <Option<String>>::sse_encode(self.closing_txid, serializer);
    }
}

impl SseEncode for crate::models::Config {
    // 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.breezserver, serializer);
        <String>::sse_encode(self.chainnotifier_url, serializer);
        <Option<String>>::sse_encode(self.mempoolspace_url, serializer);
        <String>::sse_encode(self.working_dir, serializer);
        <crate::binding::Network>::sse_encode(self.network, serializer);
        <u32>::sse_encode(self.payment_timeout_sec, serializer);
        <Option<String>>::sse_encode(self.default_lsp_id, serializer);
        <Option<String>>::sse_encode(self.api_key, serializer);
        <f64>::sse_encode(self.maxfee_percent, serializer);
        <u64>::sse_encode(self.exemptfee_msat, serializer);
        <crate::models::NodeConfig>::sse_encode(self.node_config, serializer);
    }
}

impl SseEncode for crate::models::ConfigureNodeRequest {
    // 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.close_to_address, serializer);
    }
}

impl SseEncode for crate::models::ConnectRequest {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
        <crate::models::Config>::sse_encode(self.config, serializer);
        <Vec<u8>>::sse_encode(self.seed, serializer);
        <Option<bool>>::sse_encode(self.restore_only, serializer);
    }
}

impl SseEncode for crate::binding::CurrencyInfo {
    // 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.name, serializer);
        <u32>::sse_encode(self.fraction_size, serializer);
        <Option<u32>>::sse_encode(self.spacing, serializer);
        <Option<crate::binding::Symbol>>::sse_encode(self.symbol, serializer);
        <Option<crate::binding::Symbol>>::sse_encode(self.uniq_symbol, serializer);
        <Vec<crate::binding::LocalizedName>>::sse_encode(self.localized_name, serializer);
        <Vec<crate::binding::LocaleOverrides>>::sse_encode(self.locale_overrides, serializer);
    }
}

impl SseEncode for crate::models::EnvironmentType {
    // 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::models::EnvironmentType::Production => 0,
                crate::models::EnvironmentType::Staging => 1,
                crate::models::EnvironmentType::Regtest => 2,
                _ => {
                    unimplemented!("");
                }
            },
            serializer,
        );
    }
}

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::binding::FiatCurrency {
    // 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.id, serializer);
        <crate::binding::CurrencyInfo>::sse_encode(self.info, serializer);
    }
}

impl SseEncode for crate::models::GreenlightCredentials {
    // 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.developer_key, serializer);
        <Vec<u8>>::sse_encode(self.developer_cert, serializer);
    }
}

impl SseEncode for crate::models::GreenlightDeviceCredentials {
    // 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.device, serializer);
    }
}

impl SseEncode for crate::models::GreenlightNodeConfig {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
        <Option<crate::models::GreenlightCredentials>>::sse_encode(
            self.partner_credentials,
            serializer,
        );
        <Option<String>>::sse_encode(self.invite_code, serializer);
    }
}

impl SseEncode for crate::models::HealthCheckStatus {
    // 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::models::HealthCheckStatus::Operational => 0,
                crate::models::HealthCheckStatus::Maintenance => 1,
                crate::models::HealthCheckStatus::ServiceDisruption => 2,
                _ => {
                    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 crate::binding::InputType {
    // 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::binding::InputType::BitcoinAddress { address } => {
                <i32>::sse_encode(0, serializer);
                <crate::binding::BitcoinAddressData>::sse_encode(address, serializer);
            }
            crate::binding::InputType::Bolt11 { invoice } => {
                <i32>::sse_encode(1, serializer);
                <crate::binding::LNInvoice>::sse_encode(invoice, serializer);
            }
            crate::binding::InputType::NodeId { node_id } => {
                <i32>::sse_encode(2, serializer);
                <String>::sse_encode(node_id, serializer);
            }
            crate::binding::InputType::Url { url } => {
                <i32>::sse_encode(3, serializer);
                <String>::sse_encode(url, serializer);
            }
            crate::binding::InputType::LnUrlPay {
                data,
                bip353_address,
            } => {
                <i32>::sse_encode(4, serializer);
                <crate::binding::LnUrlPayRequestData>::sse_encode(data, serializer);
                <Option<String>>::sse_encode(bip353_address, serializer);
            }
            crate::binding::InputType::LnUrlWithdraw { data } => {
                <i32>::sse_encode(5, serializer);
                <crate::binding::LnUrlWithdrawRequestData>::sse_encode(data, serializer);
            }
            crate::binding::InputType::LnUrlAuth { data } => {
                <i32>::sse_encode(6, serializer);
                <crate::binding::LnUrlAuthRequestData>::sse_encode(data, serializer);
            }
            crate::binding::InputType::LnUrlError { data } => {
                <i32>::sse_encode(7, serializer);
                <crate::binding::LnUrlErrorData>::sse_encode(data, serializer);
            }
            _ => {
                unimplemented!("");
            }
        }
    }
}

impl SseEncode for crate::breez_services::InvoicePaidDetails {
    // 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.payment_hash, serializer);
        <String>::sse_encode(self.bolt11, serializer);
        <Option<crate::models::Payment>>::sse_encode(self.payment, serializer);
    }
}

impl SseEncode for Vec<String> {
    // 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 {
            <String>::sse_encode(item, serializer);
        }
    }
}

impl SseEncode for Vec<crate::binding::FiatCurrency> {
    // 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::binding::FiatCurrency>::sse_encode(item, serializer);
        }
    }
}

impl SseEncode for Vec<crate::binding::LocaleOverrides> {
    // 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::binding::LocaleOverrides>::sse_encode(item, serializer);
        }
    }
}

impl SseEncode for Vec<crate::binding::LocalizedName> {
    // 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::binding::LocalizedName>::sse_encode(item, serializer);
        }
    }
}

impl SseEncode for Vec<crate::lsp::LspInformation> {
    // 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::lsp::LspInformation>::sse_encode(item, serializer);
        }
    }
}

impl SseEncode for Vec<crate::models::MetadataFilter> {
    // 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::models::MetadataFilter>::sse_encode(item, serializer);
        }
    }
}

impl SseEncode for Vec<crate::models::OpeningFeeParams> {
    // 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::models::OpeningFeeParams>::sse_encode(item, serializer);
        }
    }
}

impl SseEncode for Vec<crate::models::Payment> {
    // 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::models::Payment>::sse_encode(item, serializer);
        }
    }
}

impl SseEncode for Vec<crate::models::PaymentTypeFilter> {
    // 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::models::PaymentTypeFilter>::sse_encode(item, serializer);
        }
    }
}

impl SseEncode for crate::models::ListPaymentsRequest {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
        <Option<Vec<crate::models::PaymentTypeFilter>>>::sse_encode(self.filters, serializer);
        <Option<Vec<crate::models::MetadataFilter>>>::sse_encode(self.metadata_filters, serializer);
        <Option<i64>>::sse_encode(self.from_timestamp, serializer);
        <Option<i64>>::sse_encode(self.to_timestamp, serializer);
        <Option<bool>>::sse_encode(self.include_failures, serializer);
        <Option<u32>>::sse_encode(self.offset, serializer);
        <Option<u32>>::sse_encode(self.limit, 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 Vec<crate::binding::Rate> {
    // 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::binding::Rate>::sse_encode(item, serializer);
        }
    }
}

impl SseEncode for Vec<crate::models::ReverseSwapInfo> {
    // 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::models::ReverseSwapInfo>::sse_encode(item, serializer);
        }
    }
}

impl SseEncode for Vec<crate::binding::RouteHint> {
    // 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::binding::RouteHint>::sse_encode(item, serializer);
        }
    }
}

impl SseEncode for Vec<crate::binding::RouteHintHop> {
    // 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::binding::RouteHintHop>::sse_encode(item, serializer);
        }
    }
}

impl SseEncode for Vec<crate::models::SwapInfo> {
    // 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::models::SwapInfo>::sse_encode(item, serializer);
        }
    }
}

impl SseEncode for Vec<crate::models::SwapStatus> {
    // 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::models::SwapStatus>::sse_encode(item, serializer);
        }
    }
}

impl SseEncode for crate::models::ListSwapsRequest {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
        <Option<Vec<crate::models::SwapStatus>>>::sse_encode(self.status, serializer);
        <Option<i64>>::sse_encode(self.from_timestamp, serializer);
        <Option<i64>>::sse_encode(self.to_timestamp, serializer);
        <Option<u32>>::sse_encode(self.offset, serializer);
        <Option<u32>>::sse_encode(self.limit, serializer);
    }
}

impl SseEncode for Vec<crate::models::TlvEntry> {
    // 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::models::TlvEntry>::sse_encode(item, serializer);
        }
    }
}

impl SseEncode for Vec<crate::models::UnspentTransactionOutput> {
    // 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::models::UnspentTransactionOutput>::sse_encode(item, serializer);
        }
    }
}

impl SseEncode for crate::binding::LNInvoice {
    // 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.bolt11, serializer);
        <crate::binding::Network>::sse_encode(self.network, serializer);
        <String>::sse_encode(self.payee_pubkey, serializer);
        <String>::sse_encode(self.payment_hash, serializer);
        <Option<String>>::sse_encode(self.description, serializer);
        <Option<String>>::sse_encode(self.description_hash, serializer);
        <Option<u64>>::sse_encode(self.amount_msat, serializer);
        <u64>::sse_encode(self.timestamp, serializer);
        <u64>::sse_encode(self.expiry, serializer);
        <Vec<crate::binding::RouteHint>>::sse_encode(self.routing_hints, serializer);
        <Vec<u8>>::sse_encode(self.payment_secret, serializer);
        <u64>::sse_encode(self.min_final_cltv_expiry_delta, serializer);
    }
}

impl SseEncode for crate::models::LnPaymentDetails {
    // 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.payment_hash, serializer);
        <String>::sse_encode(self.label, serializer);
        <String>::sse_encode(self.destination_pubkey, serializer);
        <String>::sse_encode(self.payment_preimage, serializer);
        <bool>::sse_encode(self.keysend, serializer);
        <String>::sse_encode(self.bolt11, serializer);
        <Option<String>>::sse_encode(self.open_channel_bolt11, serializer);
        <Option<crate::binding::SuccessActionProcessed>>::sse_encode(
            self.lnurl_success_action,
            serializer,
        );
        <Option<String>>::sse_encode(self.lnurl_pay_domain, serializer);
        <Option<String>>::sse_encode(self.lnurl_pay_comment, serializer);
        <Option<String>>::sse_encode(self.ln_address, serializer);
        <Option<String>>::sse_encode(self.lnurl_metadata, serializer);
        <Option<String>>::sse_encode(self.lnurl_withdraw_endpoint, serializer);
        <Option<crate::models::SwapInfo>>::sse_encode(self.swap_info, serializer);
        <Option<crate::models::ReverseSwapInfo>>::sse_encode(self.reverse_swap_info, serializer);
        <Option<u32>>::sse_encode(self.pending_expiration_block, serializer);
    }
}

impl SseEncode for crate::binding::LnUrlAuthRequestData {
    // 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.k1, serializer);
        <Option<String>>::sse_encode(self.action, serializer);
        <String>::sse_encode(self.domain, serializer);
        <String>::sse_encode(self.url, serializer);
    }
}

impl SseEncode for crate::binding::LnUrlCallbackStatus {
    // 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::binding::LnUrlCallbackStatus::Ok => {
                <i32>::sse_encode(0, serializer);
            }
            crate::binding::LnUrlCallbackStatus::ErrorStatus { data } => {
                <i32>::sse_encode(1, serializer);
                <crate::binding::LnUrlErrorData>::sse_encode(data, serializer);
            }
            _ => {
                unimplemented!("");
            }
        }
    }
}

impl SseEncode for crate::binding::LnUrlErrorData {
    // 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.reason, serializer);
    }
}

impl SseEncode for crate::binding::LnUrlPayErrorData {
    // 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.payment_hash, serializer);
        <String>::sse_encode(self.reason, serializer);
    }
}

impl SseEncode for crate::binding::LnUrlPayRequest {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
        <crate::binding::LnUrlPayRequestData>::sse_encode(self.data, serializer);
        <u64>::sse_encode(self.amount_msat, serializer);
        <bool>::sse_encode(self.use_trampoline, serializer);
        <Option<String>>::sse_encode(self.comment, serializer);
        <Option<String>>::sse_encode(self.payment_label, serializer);
        <Option<bool>>::sse_encode(self.validate_success_action_url, serializer);
    }
}

impl SseEncode for crate::binding::LnUrlPayRequestData {
    // 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.callback, serializer);
        <u64>::sse_encode(self.min_sendable, serializer);
        <u64>::sse_encode(self.max_sendable, serializer);
        <String>::sse_encode(self.metadata_str, serializer);
        <u16>::sse_encode(self.comment_allowed, serializer);
        <String>::sse_encode(self.domain, serializer);
        <bool>::sse_encode(self.allows_nostr, serializer);
        <Option<String>>::sse_encode(self.nostr_pubkey, serializer);
        <Option<String>>::sse_encode(self.ln_address, serializer);
    }
}

impl SseEncode for crate::lnurl::pay::LnUrlPayResult {
    // 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::lnurl::pay::LnUrlPayResult::EndpointSuccess { data } => {
                <i32>::sse_encode(0, serializer);
                <crate::lnurl::pay::LnUrlPaySuccessData>::sse_encode(data, serializer);
            }
            crate::lnurl::pay::LnUrlPayResult::EndpointError { data } => {
                <i32>::sse_encode(1, serializer);
                <crate::binding::LnUrlErrorData>::sse_encode(data, serializer);
            }
            crate::lnurl::pay::LnUrlPayResult::PayError { data } => {
                <i32>::sse_encode(2, serializer);
                <crate::binding::LnUrlPayErrorData>::sse_encode(data, serializer);
            }
            _ => {
                unimplemented!("");
            }
        }
    }
}

impl SseEncode for crate::lnurl::pay::LnUrlPaySuccessData {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
        <crate::models::Payment>::sse_encode(self.payment, serializer);
        <Option<crate::binding::SuccessActionProcessed>>::sse_encode(
            self.success_action,
            serializer,
        );
    }
}

impl SseEncode for crate::binding::LnUrlWithdrawRequest {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
        <crate::binding::LnUrlWithdrawRequestData>::sse_encode(self.data, serializer);
        <u64>::sse_encode(self.amount_msat, serializer);
        <Option<String>>::sse_encode(self.description, serializer);
    }
}

impl SseEncode for crate::binding::LnUrlWithdrawRequestData {
    // 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.callback, serializer);
        <String>::sse_encode(self.k1, serializer);
        <String>::sse_encode(self.default_description, serializer);
        <u64>::sse_encode(self.min_withdrawable, serializer);
        <u64>::sse_encode(self.max_withdrawable, serializer);
    }
}

impl SseEncode for crate::binding::LnUrlWithdrawResult {
    // 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::binding::LnUrlWithdrawResult::Ok { data } => {
                <i32>::sse_encode(0, serializer);
                <crate::binding::LnUrlWithdrawSuccessData>::sse_encode(data, serializer);
            }
            crate::binding::LnUrlWithdrawResult::Timeout { data } => {
                <i32>::sse_encode(1, serializer);
                <crate::binding::LnUrlWithdrawSuccessData>::sse_encode(data, serializer);
            }
            crate::binding::LnUrlWithdrawResult::ErrorStatus { data } => {
                <i32>::sse_encode(2, serializer);
                <crate::binding::LnUrlErrorData>::sse_encode(data, serializer);
            }
            _ => {
                unimplemented!("");
            }
        }
    }
}

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

impl SseEncode for crate::binding::LocaleOverrides {
    // 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.locale, serializer);
        <Option<u32>>::sse_encode(self.spacing, serializer);
        <crate::binding::Symbol>::sse_encode(self.symbol, serializer);
    }
}

impl SseEncode for crate::binding::LocalizedName {
    // 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.locale, serializer);
        <String>::sse_encode(self.name, serializer);
    }
}

impl SseEncode for crate::models::LogEntry {
    // 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.line, serializer);
        <String>::sse_encode(self.level, serializer);
    }
}

impl SseEncode for crate::lsp::LspInformation {
    // 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.id, serializer);
        <String>::sse_encode(self.name, serializer);
        <String>::sse_encode(self.widget_url, serializer);
        <String>::sse_encode(self.pubkey, serializer);
        <String>::sse_encode(self.host, serializer);
        <i64>::sse_encode(self.base_fee_msat, serializer);
        <f64>::sse_encode(self.fee_rate, serializer);
        <u32>::sse_encode(self.time_lock_delta, serializer);
        <i64>::sse_encode(self.min_htlc_msat, serializer);
        <Vec<u8>>::sse_encode(self.lsp_pubkey, serializer);
        <crate::models::OpeningFeeParamsMenu>::sse_encode(self.opening_fee_params_list, serializer);
    }
}

impl SseEncode for crate::binding::MessageSuccessActionData {
    // 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.message, serializer);
    }
}

impl SseEncode for crate::models::MetadataFilter {
    // 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.json_path, serializer);
        <String>::sse_encode(self.json_value, serializer);
    }
}

impl SseEncode for crate::binding::Network {
    // 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::binding::Network::Bitcoin => 0,
                crate::binding::Network::Testnet => 1,
                crate::binding::Network::Signet => 2,
                crate::binding::Network::Regtest => 3,
                _ => {
                    unimplemented!("");
                }
            },
            serializer,
        );
    }
}

impl SseEncode for crate::models::NodeConfig {
    // 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::models::NodeConfig::Greenlight { config } => {
                <i32>::sse_encode(0, serializer);
                <crate::models::GreenlightNodeConfig>::sse_encode(config, serializer);
            }
            _ => {
                unimplemented!("");
            }
        }
    }
}

impl SseEncode for crate::models::NodeCredentials {
    // 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::models::NodeCredentials::Greenlight { credentials } => {
                <i32>::sse_encode(0, serializer);
                <crate::models::GreenlightDeviceCredentials>::sse_encode(credentials, serializer);
            }
            _ => {
                unimplemented!("");
            }
        }
    }
}

impl SseEncode for crate::models::NodeState {
    // 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.id, serializer);
        <u32>::sse_encode(self.block_height, serializer);
        <u64>::sse_encode(self.channels_balance_msat, serializer);
        <u64>::sse_encode(self.onchain_balance_msat, serializer);
        <u64>::sse_encode(self.pending_onchain_balance_msat, serializer);
        <Vec<crate::models::UnspentTransactionOutput>>::sse_encode(self.utxos, serializer);
        <u64>::sse_encode(self.max_payable_msat, serializer);
        <u64>::sse_encode(self.max_receivable_msat, serializer);
        <u64>::sse_encode(self.max_single_payment_amount_msat, serializer);
        <u64>::sse_encode(self.max_chan_reserve_msats, serializer);
        <Vec<String>>::sse_encode(self.connected_peers, serializer);
        <u64>::sse_encode(self.max_receivable_single_payment_amount_msat, serializer);
        <u64>::sse_encode(self.total_inbound_liquidity_msats, serializer);
    }
}

impl SseEncode for crate::models::OnchainPaymentLimitsResponse {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
        <u64>::sse_encode(self.min_sat, serializer);
        <u64>::sse_encode(self.max_sat, serializer);
        <u64>::sse_encode(self.max_payable_sat, serializer);
    }
}

impl SseEncode for crate::models::OpenChannelFeeRequest {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
        <Option<u64>>::sse_encode(self.amount_msat, serializer);
        <Option<u32>>::sse_encode(self.expiry, serializer);
    }
}

impl SseEncode for crate::models::OpenChannelFeeResponse {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
        <Option<u64>>::sse_encode(self.fee_msat, serializer);
        <crate::models::OpeningFeeParams>::sse_encode(self.fee_params, serializer);
    }
}

impl SseEncode for crate::models::OpeningFeeParams {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
        <u64>::sse_encode(self.min_msat, serializer);
        <u32>::sse_encode(self.proportional, serializer);
        <String>::sse_encode(self.valid_until, serializer);
        <u32>::sse_encode(self.max_idle_time, serializer);
        <u32>::sse_encode(self.max_client_to_self_delay, serializer);
        <String>::sse_encode(self.promise, serializer);
    }
}

impl SseEncode for crate::models::OpeningFeeParamsMenu {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
        <Vec<crate::models::OpeningFeeParams>>::sse_encode(self.values, 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<bool> {
    // 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 {
            <bool>::sse_encode(value, serializer);
        }
    }
}

impl SseEncode for Option<crate::models::GreenlightCredentials> {
    // 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::models::GreenlightCredentials>::sse_encode(value, serializer);
        }
    }
}

impl SseEncode for Option<i64> {
    // 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 {
            <i64>::sse_encode(value, serializer);
        }
    }
}

impl SseEncode for Option<crate::binding::LNInvoice> {
    // 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::binding::LNInvoice>::sse_encode(value, serializer);
        }
    }
}

impl SseEncode for Option<crate::lsp::LspInformation> {
    // 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::lsp::LspInformation>::sse_encode(value, serializer);
        }
    }
}

impl SseEncode for Option<crate::models::NodeCredentials> {
    // 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::models::NodeCredentials>::sse_encode(value, serializer);
        }
    }
}

impl SseEncode for Option<crate::models::OpeningFeeParams> {
    // 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::models::OpeningFeeParams>::sse_encode(value, serializer);
        }
    }
}

impl SseEncode for Option<crate::models::Payment> {
    // 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::models::Payment>::sse_encode(value, serializer);
        }
    }
}

impl SseEncode for Option<crate::models::ReverseSwapInfo> {
    // 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::models::ReverseSwapInfo>::sse_encode(value, serializer);
        }
    }
}

impl SseEncode for Option<crate::binding::SuccessActionProcessed> {
    // 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::binding::SuccessActionProcessed>::sse_encode(value, serializer);
        }
    }
}

impl SseEncode for Option<crate::models::SwapInfo> {
    // 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::models::SwapInfo>::sse_encode(value, serializer);
        }
    }
}

impl SseEncode for Option<crate::binding::Symbol> {
    // 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::binding::Symbol>::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 Option<u64> {
    // 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 {
            <u64>::sse_encode(value, serializer);
        }
    }
}

impl SseEncode for Option<Vec<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 {
            <Vec<String>>::sse_encode(value, serializer);
        }
    }
}

impl SseEncode for Option<Vec<crate::models::MetadataFilter>> {
    // 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 {
            <Vec<crate::models::MetadataFilter>>::sse_encode(value, serializer);
        }
    }
}

impl SseEncode for Option<Vec<crate::models::PaymentTypeFilter>> {
    // 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 {
            <Vec<crate::models::PaymentTypeFilter>>::sse_encode(value, serializer);
        }
    }
}

impl SseEncode for Option<Vec<u8>> {
    // 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 {
            <Vec<u8>>::sse_encode(value, serializer);
        }
    }
}

impl SseEncode for Option<Vec<crate::models::SwapStatus>> {
    // 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 {
            <Vec<crate::models::SwapStatus>>::sse_encode(value, serializer);
        }
    }
}

impl SseEncode for Option<Vec<crate::models::TlvEntry>> {
    // 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 {
            <Vec<crate::models::TlvEntry>>::sse_encode(value, serializer);
        }
    }
}

impl SseEncode for crate::models::PayOnchainRequest {
    // 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.recipient_address, serializer);
        <crate::models::PrepareOnchainPaymentResponse>::sse_encode(self.prepare_res, serializer);
    }
}

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

impl SseEncode for crate::models::Payment {
    // 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.id, serializer);
        <crate::models::PaymentType>::sse_encode(self.payment_type, serializer);
        <i64>::sse_encode(self.payment_time, serializer);
        <u64>::sse_encode(self.amount_msat, serializer);
        <u64>::sse_encode(self.fee_msat, serializer);
        <crate::models::PaymentStatus>::sse_encode(self.status, serializer);
        <Option<String>>::sse_encode(self.error, serializer);
        <Option<String>>::sse_encode(self.description, serializer);
        <crate::models::PaymentDetails>::sse_encode(self.details, serializer);
        <Option<String>>::sse_encode(self.metadata, serializer);
    }
}

impl SseEncode for crate::models::PaymentDetails {
    // 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::models::PaymentDetails::Ln { data } => {
                <i32>::sse_encode(0, serializer);
                <crate::models::LnPaymentDetails>::sse_encode(data, serializer);
            }
            crate::models::PaymentDetails::ClosedChannel { data } => {
                <i32>::sse_encode(1, serializer);
                <crate::models::ClosedChannelPaymentDetails>::sse_encode(data, serializer);
            }
            _ => {
                unimplemented!("");
            }
        }
    }
}

impl SseEncode for crate::breez_services::PaymentFailedData {
    // 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.error, serializer);
        <String>::sse_encode(self.node_id, serializer);
        <Option<crate::binding::LNInvoice>>::sse_encode(self.invoice, serializer);
        <Option<String>>::sse_encode(self.label, serializer);
    }
}

impl SseEncode for crate::models::PaymentStatus {
    // 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::models::PaymentStatus::Pending => 0,
                crate::models::PaymentStatus::Complete => 1,
                crate::models::PaymentStatus::Failed => 2,
                _ => {
                    unimplemented!("");
                }
            },
            serializer,
        );
    }
}

impl SseEncode for crate::models::PaymentType {
    // 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::models::PaymentType::Sent => 0,
                crate::models::PaymentType::Received => 1,
                crate::models::PaymentType::ClosedChannel => 2,
                _ => {
                    unimplemented!("");
                }
            },
            serializer,
        );
    }
}

impl SseEncode for crate::models::PaymentTypeFilter {
    // 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::models::PaymentTypeFilter::Sent => 0,
                crate::models::PaymentTypeFilter::Received => 1,
                crate::models::PaymentTypeFilter::ClosedChannel => 2,
                _ => {
                    unimplemented!("");
                }
            },
            serializer,
        );
    }
}

impl SseEncode for crate::models::PrepareOnchainPaymentRequest {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
        <u64>::sse_encode(self.amount_sat, serializer);
        <crate::models::SwapAmountType>::sse_encode(self.amount_type, serializer);
        <u32>::sse_encode(self.claim_tx_feerate, serializer);
    }
}

impl SseEncode for crate::models::PrepareOnchainPaymentResponse {
    // 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.fees_hash, serializer);
        <f64>::sse_encode(self.fees_percentage, serializer);
        <u64>::sse_encode(self.fees_lockup, serializer);
        <u64>::sse_encode(self.fees_claim, serializer);
        <u64>::sse_encode(self.sender_amount_sat, serializer);
        <u64>::sse_encode(self.recipient_amount_sat, serializer);
        <u64>::sse_encode(self.total_fees, serializer);
    }
}

impl SseEncode for crate::models::PrepareRedeemOnchainFundsRequest {
    // 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.to_address, serializer);
        <u32>::sse_encode(self.sat_per_vbyte, serializer);
    }
}

impl SseEncode for crate::models::PrepareRedeemOnchainFundsResponse {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
        <u64>::sse_encode(self.tx_weight, serializer);
        <u64>::sse_encode(self.tx_fee_sat, serializer);
    }
}

impl SseEncode for crate::models::PrepareRefundRequest {
    // 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.swap_address, serializer);
        <String>::sse_encode(self.to_address, serializer);
        <u32>::sse_encode(self.sat_per_vbyte, serializer);
        <Option<bool>>::sse_encode(self.unilateral, serializer);
    }
}

impl SseEncode for crate::models::PrepareRefundResponse {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
        <u32>::sse_encode(self.refund_tx_weight, serializer);
        <u64>::sse_encode(self.refund_tx_fee_sat, serializer);
    }
}

impl SseEncode for crate::binding::Rate {
    // 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.coin, serializer);
        <f64>::sse_encode(self.value, serializer);
    }
}

impl SseEncode for crate::models::ReceiveOnchainRequest {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
        <Option<crate::models::OpeningFeeParams>>::sse_encode(self.opening_fee_params, serializer);
    }
}

impl SseEncode for crate::models::ReceivePaymentRequest {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
        <u64>::sse_encode(self.amount_msat, serializer);
        <String>::sse_encode(self.description, serializer);
        <Option<Vec<u8>>>::sse_encode(self.preimage, serializer);
        <Option<crate::models::OpeningFeeParams>>::sse_encode(self.opening_fee_params, serializer);
        <Option<bool>>::sse_encode(self.use_description_hash, serializer);
        <Option<u32>>::sse_encode(self.expiry, serializer);
        <Option<u32>>::sse_encode(self.cltv, serializer);
    }
}

impl SseEncode for crate::models::ReceivePaymentResponse {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
        <crate::binding::LNInvoice>::sse_encode(self.ln_invoice, serializer);
        <Option<crate::models::OpeningFeeParams>>::sse_encode(self.opening_fee_params, serializer);
        <Option<u64>>::sse_encode(self.opening_fee_msat, serializer);
    }
}

impl SseEncode for crate::chain::RecommendedFees {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
        <u64>::sse_encode(self.fastest_fee, serializer);
        <u64>::sse_encode(self.half_hour_fee, serializer);
        <u64>::sse_encode(self.hour_fee, serializer);
        <u64>::sse_encode(self.economy_fee, serializer);
        <u64>::sse_encode(self.minimum_fee, serializer);
    }
}

impl SseEncode for crate::models::RedeemOnchainFundsRequest {
    // 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.to_address, serializer);
        <u32>::sse_encode(self.sat_per_vbyte, serializer);
    }
}

impl SseEncode for crate::models::RedeemOnchainFundsResponse {
    // 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.txid, serializer);
    }
}

impl SseEncode for crate::models::RefundRequest {
    // 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.swap_address, serializer);
        <String>::sse_encode(self.to_address, serializer);
        <u32>::sse_encode(self.sat_per_vbyte, serializer);
        <Option<bool>>::sse_encode(self.unilateral, serializer);
    }
}

impl SseEncode for crate::models::RefundResponse {
    // 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.refund_tx_id, serializer);
    }
}

impl SseEncode for crate::models::ReportIssueRequest {
    // 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::models::ReportIssueRequest::PaymentFailure { data } => {
                <i32>::sse_encode(0, serializer);
                <crate::models::ReportPaymentFailureDetails>::sse_encode(data, serializer);
            }
            _ => {
                unimplemented!("");
            }
        }
    }
}

impl SseEncode for crate::models::ReportPaymentFailureDetails {
    // 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.payment_hash, serializer);
        <Option<String>>::sse_encode(self.comment, serializer);
    }
}

impl SseEncode for crate::models::ReverseSwapFeesRequest {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
        <Option<u64>>::sse_encode(self.send_amount_sat, serializer);
        <Option<u32>>::sse_encode(self.claim_tx_feerate, serializer);
    }
}

impl SseEncode for crate::models::ReverseSwapInfo {
    // 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.id, serializer);
        <String>::sse_encode(self.claim_pubkey, serializer);
        <Option<String>>::sse_encode(self.lockup_txid, serializer);
        <Option<String>>::sse_encode(self.claim_txid, serializer);
        <u64>::sse_encode(self.onchain_amount_sat, serializer);
        <crate::models::ReverseSwapStatus>::sse_encode(self.status, serializer);
    }
}

impl SseEncode for crate::models::ReverseSwapPairInfo {
    // Codec=Sse (Serialization based), see doc to use other codecs
    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
        <u64>::sse_encode(self.min, serializer);
        <u64>::sse_encode(self.max, serializer);
        <String>::sse_encode(self.fees_hash, serializer);
        <f64>::sse_encode(self.fees_percentage, serializer);
        <u64>::sse_encode(self.fees_lockup, serializer);
        <u64>::sse_encode(self.fees_claim, serializer);
        <Option<u64>>::sse_encode(self.total_fees, serializer);
    }
}

impl SseEncode for crate::models::ReverseSwapStatus {
    // 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::models::ReverseSwapStatus::Initial => 0,
                crate::models::ReverseSwapStatus::InProgress => 1,
                crate::models::ReverseSwapStatus::Cancelled => 2,
                crate::models::ReverseSwapStatus::CompletedSeen => 3,
                crate::models::ReverseSwapStatus::CompletedConfirmed => 4,
                _ => {
                    unimplemented!("");
                }
            },
            serializer,
        );
    }
}

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

impl SseEncode for crate::binding::RouteHintHop {
    // 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.src_node_id, serializer);
        <String>::sse_encode(self.short_channel_id, serializer);
        <u32>::sse_encode(self.fees_base_msat, serializer);
        <u32>::sse_encode(self.fees_proportional_millionths, serializer);
        <u64>::sse_encode(self.cltv_expiry_delta, serializer);
        <Option<u64>>::sse_encode(self.htlc_minimum_msat, serializer);
        <Option<u64>>::sse_encode(self.htlc_maximum_msat, serializer);
    }
}

impl SseEncode for crate::models::SendPaymentRequest {
    // 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.bolt11, serializer);
        <bool>::sse_encode(self.use_trampoline, serializer);
        <Option<u64>>::sse_encode(self.amount_msat, serializer);
        <Option<String>>::sse_encode(self.label, serializer);
    }
}

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

impl SseEncode for crate::models::SendSpontaneousPaymentRequest {
    // 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.node_id, serializer);
        <u64>::sse_encode(self.amount_msat, serializer);
        <Option<Vec<crate::models::TlvEntry>>>::sse_encode(self.extra_tlvs, serializer);
        <Option<String>>::sse_encode(self.label, serializer);
    }
}

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

impl SseEncode for crate::breez_services::SignMessageRequest {
    // 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.message, serializer);
    }
}

impl SseEncode for crate::breez_services::SignMessageResponse {
    // 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.signature, serializer);
    }
}

impl SseEncode for crate::models::StaticBackupRequest {
    // 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.working_dir, serializer);
    }
}

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

impl SseEncode for crate::binding::SuccessActionProcessed {
    // 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::binding::SuccessActionProcessed::Aes { result } => {
                <i32>::sse_encode(0, serializer);
                <crate::binding::AesSuccessActionDataResult>::sse_encode(result, serializer);
            }
            crate::binding::SuccessActionProcessed::Message { data } => {
                <i32>::sse_encode(1, serializer);
                <crate::binding::MessageSuccessActionData>::sse_encode(data, serializer);
            }
            crate::binding::SuccessActionProcessed::Url { data } => {
                <i32>::sse_encode(2, serializer);
                <crate::binding::UrlSuccessActionData>::sse_encode(data, serializer);
            }
            _ => {
                unimplemented!("");
            }
        }
    }
}

impl SseEncode for crate::models::SwapAmountType {
    // 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::models::SwapAmountType::Send => 0,
                crate::models::SwapAmountType::Receive => 1,
                _ => {
                    unimplemented!("");
                }
            },
            serializer,
        );
    }
}

impl SseEncode for crate::models::SwapInfo {
    // 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.bitcoin_address, serializer);
        <i64>::sse_encode(self.created_at, serializer);
        <i64>::sse_encode(self.lock_height, serializer);
        <Vec<u8>>::sse_encode(self.payment_hash, serializer);
        <Vec<u8>>::sse_encode(self.preimage, serializer);
        <Vec<u8>>::sse_encode(self.private_key, serializer);
        <Vec<u8>>::sse_encode(self.public_key, serializer);
        <Vec<u8>>::sse_encode(self.swapper_public_key, serializer);
        <Vec<u8>>::sse_encode(self.script, serializer);
        <Option<String>>::sse_encode(self.bolt11, serializer);
        <u64>::sse_encode(self.paid_msat, serializer);
        <u64>::sse_encode(self.total_incoming_txs, serializer);
        <u64>::sse_encode(self.confirmed_sats, serializer);
        <u64>::sse_encode(self.unconfirmed_sats, serializer);
        <crate::models::SwapStatus>::sse_encode(self.status, serializer);
        <Vec<String>>::sse_encode(self.refund_tx_ids, serializer);
        <Vec<String>>::sse_encode(self.unconfirmed_tx_ids, serializer);
        <Vec<String>>::sse_encode(self.confirmed_tx_ids, serializer);
        <i64>::sse_encode(self.min_allowed_deposit, serializer);
        <i64>::sse_encode(self.max_allowed_deposit, serializer);
        <i64>::sse_encode(self.max_swapper_payable, serializer);
        <Option<String>>::sse_encode(self.last_redeem_error, serializer);
        <Option<crate::models::OpeningFeeParams>>::sse_encode(
            self.channel_opening_fees,
            serializer,
        );
        <Option<u32>>::sse_encode(self.confirmed_at, serializer);
    }
}

impl SseEncode for crate::models::SwapStatus {
    // 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::models::SwapStatus::Initial => 0,
                crate::models::SwapStatus::WaitingConfirmation => 1,
                crate::models::SwapStatus::Redeemable => 2,
                crate::models::SwapStatus::Redeemed => 3,
                crate::models::SwapStatus::Refundable => 4,
                crate::models::SwapStatus::Completed => 5,
                _ => {
                    unimplemented!("");
                }
            },
            serializer,
        );
    }
}

impl SseEncode for crate::binding::Symbol {
    // 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.grapheme, serializer);
        <Option<String>>::sse_encode(self.template, serializer);
        <Option<bool>>::sse_encode(self.rtl, serializer);
        <Option<u32>>::sse_encode(self.position, serializer);
    }
}

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

impl SseEncode for u16 {
    // 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_u16::<NativeEndian>(self).unwrap();
    }
}

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 u64 {
    // 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).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 crate::models::UnspentTransactionOutput {
    // 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.txid, serializer);
        <u32>::sse_encode(self.outnum, serializer);
        <u64>::sse_encode(self.amount_millisatoshi, serializer);
        <String>::sse_encode(self.address, serializer);
        <bool>::sse_encode(self.reserved, serializer);
    }
}

impl SseEncode for crate::binding::UrlSuccessActionData {
    // 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.description, serializer);
        <String>::sse_encode(self.url, serializer);
        <bool>::sse_encode(self.matches_callback_domain, serializer);
    }
}

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

    // Section: imports

    use super::*;
    use crate::breez_services::EventListener;
    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!();

    // Section: dart2rust

    impl CstDecode<flutter_rust_bridge::for_generated::anyhow::Error>
        for *mut wire_cst_list_prim_u_8_strict
    {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> flutter_rust_bridge::for_generated::anyhow::Error {
            unimplemented!()
        }
    }
    impl
        CstDecode<
            StreamSink<
                crate::breez_services::BreezEvent,
                flutter_rust_bridge::for_generated::DcoCodec,
            >,
        > for *mut wire_cst_list_prim_u_8_strict
    {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(
            self,
        ) -> StreamSink<
            crate::breez_services::BreezEvent,
            flutter_rust_bridge::for_generated::DcoCodec,
        > {
            let raw: String = self.cst_decode();
            StreamSink::deserialize(raw)
        }
    }
    impl
        CstDecode<StreamSink<crate::models::LogEntry, flutter_rust_bridge::for_generated::DcoCodec>>
        for *mut wire_cst_list_prim_u_8_strict
    {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(
            self,
        ) -> StreamSink<crate::models::LogEntry, flutter_rust_bridge::for_generated::DcoCodec>
        {
            let raw: String = self.cst_decode();
            StreamSink::deserialize(raw)
        }
    }
    impl CstDecode<String> for *mut wire_cst_list_prim_u_8_strict {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> String {
            let vec: Vec<u8> = self.cst_decode();
            String::from_utf8(vec).unwrap()
        }
    }
    impl CstDecode<crate::binding::AesSuccessActionDataDecrypted>
        for wire_cst_aes_success_action_data_decrypted
    {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::binding::AesSuccessActionDataDecrypted {
            crate::binding::AesSuccessActionDataDecrypted {
                description: self.description.cst_decode(),
                plaintext: self.plaintext.cst_decode(),
            }
        }
    }
    impl CstDecode<crate::binding::AesSuccessActionDataResult>
        for wire_cst_aes_success_action_data_result
    {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::binding::AesSuccessActionDataResult {
            match self.tag {
                0 => {
                    let ans = unsafe { self.kind.Decrypted };
                    crate::binding::AesSuccessActionDataResult::Decrypted {
                        data: ans.data.cst_decode(),
                    }
                }
                1 => {
                    let ans = unsafe { self.kind.ErrorStatus };
                    crate::binding::AesSuccessActionDataResult::ErrorStatus {
                        reason: ans.reason.cst_decode(),
                    }
                }
                _ => unreachable!(),
            }
        }
    }
    impl CstDecode<crate::breez_services::BackupFailedData> for wire_cst_backup_failed_data {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::breez_services::BackupFailedData {
            crate::breez_services::BackupFailedData {
                error: self.error.cst_decode(),
            }
        }
    }
    impl CstDecode<crate::models::BackupStatus> for wire_cst_backup_status {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::models::BackupStatus {
            crate::models::BackupStatus {
                backed_up: self.backed_up.cst_decode(),
                last_backup_time: self.last_backup_time.cst_decode(),
            }
        }
    }
    impl CstDecode<crate::binding::BindingEventListener> for wire_cst_binding_event_listener {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::binding::BindingEventListener {
            crate::binding::BindingEventListener {}
        }
    }
    impl CstDecode<crate::binding::BitcoinAddressData> for wire_cst_bitcoin_address_data {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::binding::BitcoinAddressData {
            crate::binding::BitcoinAddressData {
                address: self.address.cst_decode(),
                network: self.network.cst_decode(),
                amount_sat: self.amount_sat.cst_decode(),
                label: self.label.cst_decode(),
                message: self.message.cst_decode(),
            }
        }
    }
    impl CstDecode<crate::binding::AesSuccessActionDataDecrypted>
        for *mut wire_cst_aes_success_action_data_decrypted
    {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::binding::AesSuccessActionDataDecrypted {
            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
            CstDecode::<crate::binding::AesSuccessActionDataDecrypted>::cst_decode(*wrap).into()
        }
    }
    impl CstDecode<crate::binding::AesSuccessActionDataResult>
        for *mut wire_cst_aes_success_action_data_result
    {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::binding::AesSuccessActionDataResult {
            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
            CstDecode::<crate::binding::AesSuccessActionDataResult>::cst_decode(*wrap).into()
        }
    }
    impl CstDecode<crate::breez_services::BackupFailedData> for *mut wire_cst_backup_failed_data {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::breez_services::BackupFailedData {
            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
            CstDecode::<crate::breez_services::BackupFailedData>::cst_decode(*wrap).into()
        }
    }
    impl CstDecode<crate::binding::BindingEventListener> for *mut wire_cst_binding_event_listener {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::binding::BindingEventListener {
            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
            CstDecode::<crate::binding::BindingEventListener>::cst_decode(*wrap).into()
        }
    }
    impl CstDecode<crate::binding::BitcoinAddressData> for *mut wire_cst_bitcoin_address_data {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::binding::BitcoinAddressData {
            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
            CstDecode::<crate::binding::BitcoinAddressData>::cst_decode(*wrap).into()
        }
    }
    impl CstDecode<bool> for *mut bool {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> bool {
            unsafe { *flutter_rust_bridge::for_generated::box_from_leak_ptr(self) }
        }
    }
    impl CstDecode<crate::breez_services::BreezEvent> for *mut wire_cst_breez_event {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::breez_services::BreezEvent {
            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
            CstDecode::<crate::breez_services::BreezEvent>::cst_decode(*wrap).into()
        }
    }
    impl CstDecode<crate::models::BuyBitcoinRequest> for *mut wire_cst_buy_bitcoin_request {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::models::BuyBitcoinRequest {
            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
            CstDecode::<crate::models::BuyBitcoinRequest>::cst_decode(*wrap).into()
        }
    }
    impl CstDecode<crate::breez_services::CheckMessageRequest> for *mut wire_cst_check_message_request {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::breez_services::CheckMessageRequest {
            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
            CstDecode::<crate::breez_services::CheckMessageRequest>::cst_decode(*wrap).into()
        }
    }
    impl CstDecode<crate::models::ClosedChannelPaymentDetails>
        for *mut wire_cst_closed_channel_payment_details
    {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::models::ClosedChannelPaymentDetails {
            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
            CstDecode::<crate::models::ClosedChannelPaymentDetails>::cst_decode(*wrap).into()
        }
    }
    impl CstDecode<crate::models::ConfigureNodeRequest> for *mut wire_cst_configure_node_request {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::models::ConfigureNodeRequest {
            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
            CstDecode::<crate::models::ConfigureNodeRequest>::cst_decode(*wrap).into()
        }
    }
    impl CstDecode<crate::models::ConnectRequest> for *mut wire_cst_connect_request {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::models::ConnectRequest {
            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
            CstDecode::<crate::models::ConnectRequest>::cst_decode(*wrap).into()
        }
    }
    impl CstDecode<crate::models::GreenlightCredentials> for *mut wire_cst_greenlight_credentials {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::models::GreenlightCredentials {
            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
            CstDecode::<crate::models::GreenlightCredentials>::cst_decode(*wrap).into()
        }
    }
    impl CstDecode<crate::models::GreenlightDeviceCredentials>
        for *mut wire_cst_greenlight_device_credentials
    {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::models::GreenlightDeviceCredentials {
            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
            CstDecode::<crate::models::GreenlightDeviceCredentials>::cst_decode(*wrap).into()
        }
    }
    impl CstDecode<crate::models::GreenlightNodeConfig> for *mut wire_cst_greenlight_node_config {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::models::GreenlightNodeConfig {
            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
            CstDecode::<crate::models::GreenlightNodeConfig>::cst_decode(*wrap).into()
        }
    }
    impl CstDecode<i64> for *mut i64 {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> i64 {
            unsafe { *flutter_rust_bridge::for_generated::box_from_leak_ptr(self) }
        }
    }
    impl CstDecode<crate::breez_services::InvoicePaidDetails> for *mut wire_cst_invoice_paid_details {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::breez_services::InvoicePaidDetails {
            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
            CstDecode::<crate::breez_services::InvoicePaidDetails>::cst_decode(*wrap).into()
        }
    }
    impl CstDecode<crate::models::ListPaymentsRequest> for *mut wire_cst_list_payments_request {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::models::ListPaymentsRequest {
            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
            CstDecode::<crate::models::ListPaymentsRequest>::cst_decode(*wrap).into()
        }
    }
    impl CstDecode<crate::models::ListSwapsRequest> for *mut wire_cst_list_swaps_request {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::models::ListSwapsRequest {
            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
            CstDecode::<crate::models::ListSwapsRequest>::cst_decode(*wrap).into()
        }
    }
    impl CstDecode<crate::binding::LNInvoice> for *mut wire_cst_ln_invoice {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::binding::LNInvoice {
            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
            CstDecode::<crate::binding::LNInvoice>::cst_decode(*wrap).into()
        }
    }
    impl CstDecode<crate::models::LnPaymentDetails> for *mut wire_cst_ln_payment_details {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::models::LnPaymentDetails {
            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
            CstDecode::<crate::models::LnPaymentDetails>::cst_decode(*wrap).into()
        }
    }
    impl CstDecode<crate::binding::LnUrlAuthRequestData> for *mut wire_cst_ln_url_auth_request_data {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::binding::LnUrlAuthRequestData {
            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
            CstDecode::<crate::binding::LnUrlAuthRequestData>::cst_decode(*wrap).into()
        }
    }
    impl CstDecode<crate::binding::LnUrlErrorData> for *mut wire_cst_ln_url_error_data {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::binding::LnUrlErrorData {
            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
            CstDecode::<crate::binding::LnUrlErrorData>::cst_decode(*wrap).into()
        }
    }
    impl CstDecode<crate::binding::LnUrlPayErrorData> for *mut wire_cst_ln_url_pay_error_data {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::binding::LnUrlPayErrorData {
            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
            CstDecode::<crate::binding::LnUrlPayErrorData>::cst_decode(*wrap).into()
        }
    }
    impl CstDecode<crate::binding::LnUrlPayRequest> for *mut wire_cst_ln_url_pay_request {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::binding::LnUrlPayRequest {
            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
            CstDecode::<crate::binding::LnUrlPayRequest>::cst_decode(*wrap).into()
        }
    }
    impl CstDecode<crate::binding::LnUrlPayRequestData> for *mut wire_cst_ln_url_pay_request_data {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::binding::LnUrlPayRequestData {
            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
            CstDecode::<crate::binding::LnUrlPayRequestData>::cst_decode(*wrap).into()
        }
    }
    impl CstDecode<crate::lnurl::pay::LnUrlPaySuccessData> for *mut wire_cst_ln_url_pay_success_data {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::lnurl::pay::LnUrlPaySuccessData {
            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
            CstDecode::<crate::lnurl::pay::LnUrlPaySuccessData>::cst_decode(*wrap).into()
        }
    }
    impl CstDecode<crate::binding::LnUrlWithdrawRequest> for *mut wire_cst_ln_url_withdraw_request {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::binding::LnUrlWithdrawRequest {
            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
            CstDecode::<crate::binding::LnUrlWithdrawRequest>::cst_decode(*wrap).into()
        }
    }
    impl CstDecode<crate::binding::LnUrlWithdrawRequestData>
        for *mut wire_cst_ln_url_withdraw_request_data
    {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::binding::LnUrlWithdrawRequestData {
            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
            CstDecode::<crate::binding::LnUrlWithdrawRequestData>::cst_decode(*wrap).into()
        }
    }
    impl CstDecode<crate::binding::LnUrlWithdrawSuccessData>
        for *mut wire_cst_ln_url_withdraw_success_data
    {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::binding::LnUrlWithdrawSuccessData {
            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
            CstDecode::<crate::binding::LnUrlWithdrawSuccessData>::cst_decode(*wrap).into()
        }
    }
    impl CstDecode<crate::lsp::LspInformation> for *mut wire_cst_lsp_information {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::lsp::LspInformation {
            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
            CstDecode::<crate::lsp::LspInformation>::cst_decode(*wrap).into()
        }
    }
    impl CstDecode<crate::binding::MessageSuccessActionData>
        for *mut wire_cst_message_success_action_data
    {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::binding::MessageSuccessActionData {
            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
            CstDecode::<crate::binding::MessageSuccessActionData>::cst_decode(*wrap).into()
        }
    }
    impl CstDecode<crate::models::NodeConfig> for *mut wire_cst_node_config {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::models::NodeConfig {
            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
            CstDecode::<crate::models::NodeConfig>::cst_decode(*wrap).into()
        }
    }
    impl CstDecode<crate::models::NodeCredentials> for *mut wire_cst_node_credentials {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::models::NodeCredentials {
            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
            CstDecode::<crate::models::NodeCredentials>::cst_decode(*wrap).into()
        }
    }
    impl CstDecode<crate::models::OpenChannelFeeRequest> for *mut wire_cst_open_channel_fee_request {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::models::OpenChannelFeeRequest {
            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
            CstDecode::<crate::models::OpenChannelFeeRequest>::cst_decode(*wrap).into()
        }
    }
    impl CstDecode<crate::models::OpeningFeeParams> for *mut wire_cst_opening_fee_params {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::models::OpeningFeeParams {
            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
            CstDecode::<crate::models::OpeningFeeParams>::cst_decode(*wrap).into()
        }
    }
    impl CstDecode<crate::models::PayOnchainRequest> for *mut wire_cst_pay_onchain_request {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::models::PayOnchainRequest {
            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
            CstDecode::<crate::models::PayOnchainRequest>::cst_decode(*wrap).into()
        }
    }
    impl CstDecode<crate::models::Payment> for *mut wire_cst_payment {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::models::Payment {
            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
            CstDecode::<crate::models::Payment>::cst_decode(*wrap).into()
        }
    }
    impl CstDecode<crate::breez_services::PaymentFailedData> for *mut wire_cst_payment_failed_data {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::breez_services::PaymentFailedData {
            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
            CstDecode::<crate::breez_services::PaymentFailedData>::cst_decode(*wrap).into()
        }
    }
    impl CstDecode<crate::models::PrepareOnchainPaymentRequest>
        for *mut wire_cst_prepare_onchain_payment_request
    {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::models::PrepareOnchainPaymentRequest {
            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
            CstDecode::<crate::models::PrepareOnchainPaymentRequest>::cst_decode(*wrap).into()
        }
    }
    impl CstDecode<crate::models::PrepareRedeemOnchainFundsRequest>
        for *mut wire_cst_prepare_redeem_onchain_funds_request
    {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::models::PrepareRedeemOnchainFundsRequest {
            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
            CstDecode::<crate::models::PrepareRedeemOnchainFundsRequest>::cst_decode(*wrap).into()
        }
    }
    impl CstDecode<crate::models::PrepareRefundRequest> for *mut wire_cst_prepare_refund_request {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::models::PrepareRefundRequest {
            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
            CstDecode::<crate::models::PrepareRefundRequest>::cst_decode(*wrap).into()
        }
    }
    impl CstDecode<crate::models::ReceiveOnchainRequest> for *mut wire_cst_receive_onchain_request {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::models::ReceiveOnchainRequest {
            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
            CstDecode::<crate::models::ReceiveOnchainRequest>::cst_decode(*wrap).into()
        }
    }
    impl CstDecode<crate::models::ReceivePaymentRequest> for *mut wire_cst_receive_payment_request {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::models::ReceivePaymentRequest {
            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
            CstDecode::<crate::models::ReceivePaymentRequest>::cst_decode(*wrap).into()
        }
    }
    impl CstDecode<crate::models::RedeemOnchainFundsRequest>
        for *mut wire_cst_redeem_onchain_funds_request
    {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::models::RedeemOnchainFundsRequest {
            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
            CstDecode::<crate::models::RedeemOnchainFundsRequest>::cst_decode(*wrap).into()
        }
    }
    impl CstDecode<crate::models::RefundRequest> for *mut wire_cst_refund_request {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::models::RefundRequest {
            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
            CstDecode::<crate::models::RefundRequest>::cst_decode(*wrap).into()
        }
    }
    impl CstDecode<crate::models::ReportIssueRequest> for *mut wire_cst_report_issue_request {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::models::ReportIssueRequest {
            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
            CstDecode::<crate::models::ReportIssueRequest>::cst_decode(*wrap).into()
        }
    }
    impl CstDecode<crate::models::ReportPaymentFailureDetails>
        for *mut wire_cst_report_payment_failure_details
    {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::models::ReportPaymentFailureDetails {
            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
            CstDecode::<crate::models::ReportPaymentFailureDetails>::cst_decode(*wrap).into()
        }
    }
    impl CstDecode<crate::models::ReverseSwapFeesRequest> for *mut wire_cst_reverse_swap_fees_request {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::models::ReverseSwapFeesRequest {
            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
            CstDecode::<crate::models::ReverseSwapFeesRequest>::cst_decode(*wrap).into()
        }
    }
    impl CstDecode<crate::models::ReverseSwapInfo> for *mut wire_cst_reverse_swap_info {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::models::ReverseSwapInfo {
            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
            CstDecode::<crate::models::ReverseSwapInfo>::cst_decode(*wrap).into()
        }
    }
    impl CstDecode<crate::models::SendPaymentRequest> for *mut wire_cst_send_payment_request {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::models::SendPaymentRequest {
            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
            CstDecode::<crate::models::SendPaymentRequest>::cst_decode(*wrap).into()
        }
    }
    impl CstDecode<crate::models::SendSpontaneousPaymentRequest>
        for *mut wire_cst_send_spontaneous_payment_request
    {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::models::SendSpontaneousPaymentRequest {
            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
            CstDecode::<crate::models::SendSpontaneousPaymentRequest>::cst_decode(*wrap).into()
        }
    }
    impl CstDecode<crate::breez_services::SignMessageRequest> for *mut wire_cst_sign_message_request {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::breez_services::SignMessageRequest {
            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
            CstDecode::<crate::breez_services::SignMessageRequest>::cst_decode(*wrap).into()
        }
    }
    impl CstDecode<crate::models::StaticBackupRequest> for *mut wire_cst_static_backup_request {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::models::StaticBackupRequest {
            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
            CstDecode::<crate::models::StaticBackupRequest>::cst_decode(*wrap).into()
        }
    }
    impl CstDecode<crate::binding::SuccessActionProcessed> for *mut wire_cst_success_action_processed {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::binding::SuccessActionProcessed {
            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
            CstDecode::<crate::binding::SuccessActionProcessed>::cst_decode(*wrap).into()
        }
    }
    impl CstDecode<crate::models::SwapInfo> for *mut wire_cst_swap_info {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::models::SwapInfo {
            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
            CstDecode::<crate::models::SwapInfo>::cst_decode(*wrap).into()
        }
    }
    impl CstDecode<crate::binding::Symbol> for *mut wire_cst_symbol {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::binding::Symbol {
            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
            CstDecode::<crate::binding::Symbol>::cst_decode(*wrap).into()
        }
    }
    impl CstDecode<u32> for *mut u32 {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> u32 {
            unsafe { *flutter_rust_bridge::for_generated::box_from_leak_ptr(self) }
        }
    }
    impl CstDecode<u64> for *mut u64 {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> u64 {
            unsafe { *flutter_rust_bridge::for_generated::box_from_leak_ptr(self) }
        }
    }
    impl CstDecode<crate::binding::UrlSuccessActionData> for *mut wire_cst_url_success_action_data {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::binding::UrlSuccessActionData {
            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
            CstDecode::<crate::binding::UrlSuccessActionData>::cst_decode(*wrap).into()
        }
    }
    impl CstDecode<crate::breez_services::BreezEvent> for wire_cst_breez_event {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::breez_services::BreezEvent {
            match self.tag {
                0 => {
                    let ans = unsafe { self.kind.NewBlock };
                    crate::breez_services::BreezEvent::NewBlock {
                        block: ans.block.cst_decode(),
                    }
                }
                1 => {
                    let ans = unsafe { self.kind.InvoicePaid };
                    crate::breez_services::BreezEvent::InvoicePaid {
                        details: ans.details.cst_decode(),
                    }
                }
                2 => crate::breez_services::BreezEvent::Synced,
                3 => {
                    let ans = unsafe { self.kind.PaymentSucceed };
                    crate::breez_services::BreezEvent::PaymentSucceed {
                        details: ans.details.cst_decode(),
                    }
                }
                4 => {
                    let ans = unsafe { self.kind.PaymentFailed };
                    crate::breez_services::BreezEvent::PaymentFailed {
                        details: ans.details.cst_decode(),
                    }
                }
                5 => crate::breez_services::BreezEvent::BackupStarted,
                6 => crate::breez_services::BreezEvent::BackupSucceeded,
                7 => {
                    let ans = unsafe { self.kind.BackupFailed };
                    crate::breez_services::BreezEvent::BackupFailed {
                        details: ans.details.cst_decode(),
                    }
                }
                8 => {
                    let ans = unsafe { self.kind.ReverseSwapUpdated };
                    crate::breez_services::BreezEvent::ReverseSwapUpdated {
                        details: ans.details.cst_decode(),
                    }
                }
                9 => {
                    let ans = unsafe { self.kind.SwapUpdated };
                    crate::breez_services::BreezEvent::SwapUpdated {
                        details: ans.details.cst_decode(),
                    }
                }
                _ => unreachable!(),
            }
        }
    }
    impl CstDecode<crate::models::BuyBitcoinRequest> for wire_cst_buy_bitcoin_request {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::models::BuyBitcoinRequest {
            crate::models::BuyBitcoinRequest {
                provider: self.provider.cst_decode(),
                opening_fee_params: self.opening_fee_params.cst_decode(),
                redirect_url: self.redirect_url.cst_decode(),
            }
        }
    }
    impl CstDecode<crate::models::BuyBitcoinResponse> for wire_cst_buy_bitcoin_response {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::models::BuyBitcoinResponse {
            crate::models::BuyBitcoinResponse {
                url: self.url.cst_decode(),
                opening_fee_params: self.opening_fee_params.cst_decode(),
            }
        }
    }
    impl CstDecode<crate::breez_services::CheckMessageRequest> for wire_cst_check_message_request {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::breez_services::CheckMessageRequest {
            crate::breez_services::CheckMessageRequest {
                message: self.message.cst_decode(),
                pubkey: self.pubkey.cst_decode(),
                signature: self.signature.cst_decode(),
            }
        }
    }
    impl CstDecode<crate::breez_services::CheckMessageResponse> for wire_cst_check_message_response {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::breez_services::CheckMessageResponse {
            crate::breez_services::CheckMessageResponse {
                is_valid: self.is_valid.cst_decode(),
            }
        }
    }
    impl CstDecode<crate::models::ClosedChannelPaymentDetails>
        for wire_cst_closed_channel_payment_details
    {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::models::ClosedChannelPaymentDetails {
            crate::models::ClosedChannelPaymentDetails {
                state: self.state.cst_decode(),
                funding_txid: self.funding_txid.cst_decode(),
                short_channel_id: self.short_channel_id.cst_decode(),
                closing_txid: self.closing_txid.cst_decode(),
            }
        }
    }
    impl CstDecode<crate::models::Config> for wire_cst_config {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::models::Config {
            crate::models::Config {
                breezserver: self.breezserver.cst_decode(),
                chainnotifier_url: self.chainnotifier_url.cst_decode(),
                mempoolspace_url: self.mempoolspace_url.cst_decode(),
                working_dir: self.working_dir.cst_decode(),
                network: self.network.cst_decode(),
                payment_timeout_sec: self.payment_timeout_sec.cst_decode(),
                default_lsp_id: self.default_lsp_id.cst_decode(),
                api_key: self.api_key.cst_decode(),
                maxfee_percent: self.maxfee_percent.cst_decode(),
                exemptfee_msat: self.exemptfee_msat.cst_decode(),
                node_config: self.node_config.cst_decode(),
            }
        }
    }
    impl CstDecode<crate::models::ConfigureNodeRequest> for wire_cst_configure_node_request {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::models::ConfigureNodeRequest {
            crate::models::ConfigureNodeRequest {
                close_to_address: self.close_to_address.cst_decode(),
            }
        }
    }
    impl CstDecode<crate::models::ConnectRequest> for wire_cst_connect_request {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::models::ConnectRequest {
            crate::models::ConnectRequest {
                config: self.config.cst_decode(),
                seed: self.seed.cst_decode(),
                restore_only: self.restore_only.cst_decode(),
            }
        }
    }
    impl CstDecode<crate::binding::CurrencyInfo> for wire_cst_currency_info {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::binding::CurrencyInfo {
            crate::binding::CurrencyInfo {
                name: self.name.cst_decode(),
                fraction_size: self.fraction_size.cst_decode(),
                spacing: self.spacing.cst_decode(),
                symbol: self.symbol.cst_decode(),
                uniq_symbol: self.uniq_symbol.cst_decode(),
                localized_name: self.localized_name.cst_decode(),
                locale_overrides: self.locale_overrides.cst_decode(),
            }
        }
    }
    impl CstDecode<crate::binding::FiatCurrency> for wire_cst_fiat_currency {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::binding::FiatCurrency {
            crate::binding::FiatCurrency {
                id: self.id.cst_decode(),
                info: self.info.cst_decode(),
            }
        }
    }
    impl CstDecode<crate::models::GreenlightCredentials> for wire_cst_greenlight_credentials {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::models::GreenlightCredentials {
            crate::models::GreenlightCredentials {
                developer_key: self.developer_key.cst_decode(),
                developer_cert: self.developer_cert.cst_decode(),
            }
        }
    }
    impl CstDecode<crate::models::GreenlightDeviceCredentials>
        for wire_cst_greenlight_device_credentials
    {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::models::GreenlightDeviceCredentials {
            crate::models::GreenlightDeviceCredentials {
                device: self.device.cst_decode(),
            }
        }
    }
    impl CstDecode<crate::models::GreenlightNodeConfig> for wire_cst_greenlight_node_config {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::models::GreenlightNodeConfig {
            crate::models::GreenlightNodeConfig {
                partner_credentials: self.partner_credentials.cst_decode(),
                invite_code: self.invite_code.cst_decode(),
            }
        }
    }
    impl CstDecode<crate::binding::InputType> for wire_cst_input_type {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::binding::InputType {
            match self.tag {
                0 => {
                    let ans = unsafe { self.kind.BitcoinAddress };
                    crate::binding::InputType::BitcoinAddress {
                        address: ans.address.cst_decode(),
                    }
                }
                1 => {
                    let ans = unsafe { self.kind.Bolt11 };
                    crate::binding::InputType::Bolt11 {
                        invoice: ans.invoice.cst_decode(),
                    }
                }
                2 => {
                    let ans = unsafe { self.kind.NodeId };
                    crate::binding::InputType::NodeId {
                        node_id: ans.node_id.cst_decode(),
                    }
                }
                3 => {
                    let ans = unsafe { self.kind.Url };
                    crate::binding::InputType::Url {
                        url: ans.url.cst_decode(),
                    }
                }
                4 => {
                    let ans = unsafe { self.kind.LnUrlPay };
                    crate::binding::InputType::LnUrlPay {
                        data: ans.data.cst_decode(),
                        bip353_address: ans.bip353_address.cst_decode(),
                    }
                }
                5 => {
                    let ans = unsafe { self.kind.LnUrlWithdraw };
                    crate::binding::InputType::LnUrlWithdraw {
                        data: ans.data.cst_decode(),
                    }
                }
                6 => {
                    let ans = unsafe { self.kind.LnUrlAuth };
                    crate::binding::InputType::LnUrlAuth {
                        data: ans.data.cst_decode(),
                    }
                }
                7 => {
                    let ans = unsafe { self.kind.LnUrlError };
                    crate::binding::InputType::LnUrlError {
                        data: ans.data.cst_decode(),
                    }
                }
                _ => unreachable!(),
            }
        }
    }
    impl CstDecode<crate::breez_services::InvoicePaidDetails> for wire_cst_invoice_paid_details {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::breez_services::InvoicePaidDetails {
            crate::breez_services::InvoicePaidDetails {
                payment_hash: self.payment_hash.cst_decode(),
                bolt11: self.bolt11.cst_decode(),
                payment: self.payment.cst_decode(),
            }
        }
    }
    impl CstDecode<Vec<String>> for *mut wire_cst_list_String {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> Vec<String> {
            let vec = unsafe {
                let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
                flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
            };
            vec.into_iter().map(CstDecode::cst_decode).collect()
        }
    }
    impl CstDecode<Vec<crate::binding::FiatCurrency>> for *mut wire_cst_list_fiat_currency {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> Vec<crate::binding::FiatCurrency> {
            let vec = unsafe {
                let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
                flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
            };
            vec.into_iter().map(CstDecode::cst_decode).collect()
        }
    }
    impl CstDecode<Vec<crate::binding::LocaleOverrides>> for *mut wire_cst_list_locale_overrides {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> Vec<crate::binding::LocaleOverrides> {
            let vec = unsafe {
                let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
                flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
            };
            vec.into_iter().map(CstDecode::cst_decode).collect()
        }
    }
    impl CstDecode<Vec<crate::binding::LocalizedName>> for *mut wire_cst_list_localized_name {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> Vec<crate::binding::LocalizedName> {
            let vec = unsafe {
                let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
                flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
            };
            vec.into_iter().map(CstDecode::cst_decode).collect()
        }
    }
    impl CstDecode<Vec<crate::lsp::LspInformation>> for *mut wire_cst_list_lsp_information {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> Vec<crate::lsp::LspInformation> {
            let vec = unsafe {
                let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
                flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
            };
            vec.into_iter().map(CstDecode::cst_decode).collect()
        }
    }
    impl CstDecode<Vec<crate::models::MetadataFilter>> for *mut wire_cst_list_metadata_filter {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> Vec<crate::models::MetadataFilter> {
            let vec = unsafe {
                let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
                flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
            };
            vec.into_iter().map(CstDecode::cst_decode).collect()
        }
    }
    impl CstDecode<Vec<crate::models::OpeningFeeParams>> for *mut wire_cst_list_opening_fee_params {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> Vec<crate::models::OpeningFeeParams> {
            let vec = unsafe {
                let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
                flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
            };
            vec.into_iter().map(CstDecode::cst_decode).collect()
        }
    }
    impl CstDecode<Vec<crate::models::Payment>> for *mut wire_cst_list_payment {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> Vec<crate::models::Payment> {
            let vec = unsafe {
                let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
                flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
            };
            vec.into_iter().map(CstDecode::cst_decode).collect()
        }
    }
    impl CstDecode<Vec<crate::models::PaymentTypeFilter>> for *mut wire_cst_list_payment_type_filter {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> Vec<crate::models::PaymentTypeFilter> {
            let vec = unsafe {
                let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
                flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
            };
            vec.into_iter().map(CstDecode::cst_decode).collect()
        }
    }
    impl CstDecode<crate::models::ListPaymentsRequest> for wire_cst_list_payments_request {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::models::ListPaymentsRequest {
            crate::models::ListPaymentsRequest {
                filters: self.filters.cst_decode(),
                metadata_filters: self.metadata_filters.cst_decode(),
                from_timestamp: self.from_timestamp.cst_decode(),
                to_timestamp: self.to_timestamp.cst_decode(),
                include_failures: self.include_failures.cst_decode(),
                offset: self.offset.cst_decode(),
                limit: self.limit.cst_decode(),
            }
        }
    }
    impl CstDecode<Vec<u8>> for *mut wire_cst_list_prim_u_8_strict {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> Vec<u8> {
            unsafe {
                let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
                flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
            }
        }
    }
    impl CstDecode<Vec<crate::binding::Rate>> for *mut wire_cst_list_rate {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> Vec<crate::binding::Rate> {
            let vec = unsafe {
                let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
                flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
            };
            vec.into_iter().map(CstDecode::cst_decode).collect()
        }
    }
    impl CstDecode<Vec<crate::models::ReverseSwapInfo>> for *mut wire_cst_list_reverse_swap_info {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> Vec<crate::models::ReverseSwapInfo> {
            let vec = unsafe {
                let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
                flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
            };
            vec.into_iter().map(CstDecode::cst_decode).collect()
        }
    }
    impl CstDecode<Vec<crate::binding::RouteHint>> for *mut wire_cst_list_route_hint {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> Vec<crate::binding::RouteHint> {
            let vec = unsafe {
                let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
                flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
            };
            vec.into_iter().map(CstDecode::cst_decode).collect()
        }
    }
    impl CstDecode<Vec<crate::binding::RouteHintHop>> for *mut wire_cst_list_route_hint_hop {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> Vec<crate::binding::RouteHintHop> {
            let vec = unsafe {
                let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
                flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
            };
            vec.into_iter().map(CstDecode::cst_decode).collect()
        }
    }
    impl CstDecode<Vec<crate::models::SwapInfo>> for *mut wire_cst_list_swap_info {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> Vec<crate::models::SwapInfo> {
            let vec = unsafe {
                let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
                flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
            };
            vec.into_iter().map(CstDecode::cst_decode).collect()
        }
    }
    impl CstDecode<Vec<crate::models::SwapStatus>> for *mut wire_cst_list_swap_status {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> Vec<crate::models::SwapStatus> {
            let vec = unsafe {
                let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
                flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
            };
            vec.into_iter().map(CstDecode::cst_decode).collect()
        }
    }
    impl CstDecode<crate::models::ListSwapsRequest> for wire_cst_list_swaps_request {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::models::ListSwapsRequest {
            crate::models::ListSwapsRequest {
                status: self.status.cst_decode(),
                from_timestamp: self.from_timestamp.cst_decode(),
                to_timestamp: self.to_timestamp.cst_decode(),
                offset: self.offset.cst_decode(),
                limit: self.limit.cst_decode(),
            }
        }
    }
    impl CstDecode<Vec<crate::models::TlvEntry>> for *mut wire_cst_list_tlv_entry {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> Vec<crate::models::TlvEntry> {
            let vec = unsafe {
                let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
                flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
            };
            vec.into_iter().map(CstDecode::cst_decode).collect()
        }
    }
    impl CstDecode<Vec<crate::models::UnspentTransactionOutput>>
        for *mut wire_cst_list_unspent_transaction_output
    {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> Vec<crate::models::UnspentTransactionOutput> {
            let vec = unsafe {
                let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
                flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
            };
            vec.into_iter().map(CstDecode::cst_decode).collect()
        }
    }
    impl CstDecode<crate::binding::LNInvoice> for wire_cst_ln_invoice {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::binding::LNInvoice {
            crate::binding::LNInvoice {
                bolt11: self.bolt11.cst_decode(),
                network: self.network.cst_decode(),
                payee_pubkey: self.payee_pubkey.cst_decode(),
                payment_hash: self.payment_hash.cst_decode(),
                description: self.description.cst_decode(),
                description_hash: self.description_hash.cst_decode(),
                amount_msat: self.amount_msat.cst_decode(),
                timestamp: self.timestamp.cst_decode(),
                expiry: self.expiry.cst_decode(),
                routing_hints: self.routing_hints.cst_decode(),
                payment_secret: self.payment_secret.cst_decode(),
                min_final_cltv_expiry_delta: self.min_final_cltv_expiry_delta.cst_decode(),
            }
        }
    }
    impl CstDecode<crate::models::LnPaymentDetails> for wire_cst_ln_payment_details {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::models::LnPaymentDetails {
            crate::models::LnPaymentDetails {
                payment_hash: self.payment_hash.cst_decode(),
                label: self.label.cst_decode(),
                destination_pubkey: self.destination_pubkey.cst_decode(),
                payment_preimage: self.payment_preimage.cst_decode(),
                keysend: self.keysend.cst_decode(),
                bolt11: self.bolt11.cst_decode(),
                open_channel_bolt11: self.open_channel_bolt11.cst_decode(),
                lnurl_success_action: self.lnurl_success_action.cst_decode(),
                lnurl_pay_domain: self.lnurl_pay_domain.cst_decode(),
                lnurl_pay_comment: self.lnurl_pay_comment.cst_decode(),
                ln_address: self.ln_address.cst_decode(),
                lnurl_metadata: self.lnurl_metadata.cst_decode(),
                lnurl_withdraw_endpoint: self.lnurl_withdraw_endpoint.cst_decode(),
                swap_info: self.swap_info.cst_decode(),
                reverse_swap_info: self.reverse_swap_info.cst_decode(),
                pending_expiration_block: self.pending_expiration_block.cst_decode(),
            }
        }
    }
    impl CstDecode<crate::binding::LnUrlAuthRequestData> for wire_cst_ln_url_auth_request_data {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::binding::LnUrlAuthRequestData {
            crate::binding::LnUrlAuthRequestData {
                k1: self.k1.cst_decode(),
                action: self.action.cst_decode(),
                domain: self.domain.cst_decode(),
                url: self.url.cst_decode(),
            }
        }
    }
    impl CstDecode<crate::binding::LnUrlCallbackStatus> for wire_cst_ln_url_callback_status {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::binding::LnUrlCallbackStatus {
            match self.tag {
                0 => crate::binding::LnUrlCallbackStatus::Ok,
                1 => {
                    let ans = unsafe { self.kind.ErrorStatus };
                    crate::binding::LnUrlCallbackStatus::ErrorStatus {
                        data: ans.data.cst_decode(),
                    }
                }
                _ => unreachable!(),
            }
        }
    }
    impl CstDecode<crate::binding::LnUrlErrorData> for wire_cst_ln_url_error_data {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::binding::LnUrlErrorData {
            crate::binding::LnUrlErrorData {
                reason: self.reason.cst_decode(),
            }
        }
    }
    impl CstDecode<crate::binding::LnUrlPayErrorData> for wire_cst_ln_url_pay_error_data {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::binding::LnUrlPayErrorData {
            crate::binding::LnUrlPayErrorData {
                payment_hash: self.payment_hash.cst_decode(),
                reason: self.reason.cst_decode(),
            }
        }
    }
    impl CstDecode<crate::binding::LnUrlPayRequest> for wire_cst_ln_url_pay_request {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::binding::LnUrlPayRequest {
            crate::binding::LnUrlPayRequest {
                data: self.data.cst_decode(),
                amount_msat: self.amount_msat.cst_decode(),
                use_trampoline: self.use_trampoline.cst_decode(),
                comment: self.comment.cst_decode(),
                payment_label: self.payment_label.cst_decode(),
                validate_success_action_url: self.validate_success_action_url.cst_decode(),
            }
        }
    }
    impl CstDecode<crate::binding::LnUrlPayRequestData> for wire_cst_ln_url_pay_request_data {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::binding::LnUrlPayRequestData {
            crate::binding::LnUrlPayRequestData {
                callback: self.callback.cst_decode(),
                min_sendable: self.min_sendable.cst_decode(),
                max_sendable: self.max_sendable.cst_decode(),
                metadata_str: self.metadata_str.cst_decode(),
                comment_allowed: self.comment_allowed.cst_decode(),
                domain: self.domain.cst_decode(),
                allows_nostr: self.allows_nostr.cst_decode(),
                nostr_pubkey: self.nostr_pubkey.cst_decode(),
                ln_address: self.ln_address.cst_decode(),
            }
        }
    }
    impl CstDecode<crate::lnurl::pay::LnUrlPayResult> for wire_cst_ln_url_pay_result {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::lnurl::pay::LnUrlPayResult {
            match self.tag {
                0 => {
                    let ans = unsafe { self.kind.EndpointSuccess };
                    crate::lnurl::pay::LnUrlPayResult::EndpointSuccess {
                        data: ans.data.cst_decode(),
                    }
                }
                1 => {
                    let ans = unsafe { self.kind.EndpointError };
                    crate::lnurl::pay::LnUrlPayResult::EndpointError {
                        data: ans.data.cst_decode(),
                    }
                }
                2 => {
                    let ans = unsafe { self.kind.PayError };
                    crate::lnurl::pay::LnUrlPayResult::PayError {
                        data: ans.data.cst_decode(),
                    }
                }
                _ => unreachable!(),
            }
        }
    }
    impl CstDecode<crate::lnurl::pay::LnUrlPaySuccessData> for wire_cst_ln_url_pay_success_data {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::lnurl::pay::LnUrlPaySuccessData {
            crate::lnurl::pay::LnUrlPaySuccessData {
                payment: self.payment.cst_decode(),
                success_action: self.success_action.cst_decode(),
            }
        }
    }
    impl CstDecode<crate::binding::LnUrlWithdrawRequest> for wire_cst_ln_url_withdraw_request {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::binding::LnUrlWithdrawRequest {
            crate::binding::LnUrlWithdrawRequest {
                data: self.data.cst_decode(),
                amount_msat: self.amount_msat.cst_decode(),
                description: self.description.cst_decode(),
            }
        }
    }
    impl CstDecode<crate::binding::LnUrlWithdrawRequestData> for wire_cst_ln_url_withdraw_request_data {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::binding::LnUrlWithdrawRequestData {
            crate::binding::LnUrlWithdrawRequestData {
                callback: self.callback.cst_decode(),
                k1: self.k1.cst_decode(),
                default_description: self.default_description.cst_decode(),
                min_withdrawable: self.min_withdrawable.cst_decode(),
                max_withdrawable: self.max_withdrawable.cst_decode(),
            }
        }
    }
    impl CstDecode<crate::binding::LnUrlWithdrawResult> for wire_cst_ln_url_withdraw_result {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::binding::LnUrlWithdrawResult {
            match self.tag {
                0 => {
                    let ans = unsafe { self.kind.Ok };
                    crate::binding::LnUrlWithdrawResult::Ok {
                        data: ans.data.cst_decode(),
                    }
                }
                1 => {
                    let ans = unsafe { self.kind.Timeout };
                    crate::binding::LnUrlWithdrawResult::Timeout {
                        data: ans.data.cst_decode(),
                    }
                }
                2 => {
                    let ans = unsafe { self.kind.ErrorStatus };
                    crate::binding::LnUrlWithdrawResult::ErrorStatus {
                        data: ans.data.cst_decode(),
                    }
                }
                _ => unreachable!(),
            }
        }
    }
    impl CstDecode<crate::binding::LnUrlWithdrawSuccessData> for wire_cst_ln_url_withdraw_success_data {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::binding::LnUrlWithdrawSuccessData {
            crate::binding::LnUrlWithdrawSuccessData {
                invoice: self.invoice.cst_decode(),
            }
        }
    }
    impl CstDecode<crate::binding::LocaleOverrides> for wire_cst_locale_overrides {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::binding::LocaleOverrides {
            crate::binding::LocaleOverrides {
                locale: self.locale.cst_decode(),
                spacing: self.spacing.cst_decode(),
                symbol: self.symbol.cst_decode(),
            }
        }
    }
    impl CstDecode<crate::binding::LocalizedName> for wire_cst_localized_name {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::binding::LocalizedName {
            crate::binding::LocalizedName {
                locale: self.locale.cst_decode(),
                name: self.name.cst_decode(),
            }
        }
    }
    impl CstDecode<crate::models::LogEntry> for wire_cst_log_entry {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::models::LogEntry {
            crate::models::LogEntry {
                line: self.line.cst_decode(),
                level: self.level.cst_decode(),
            }
        }
    }
    impl CstDecode<crate::lsp::LspInformation> for wire_cst_lsp_information {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::lsp::LspInformation {
            crate::lsp::LspInformation {
                id: self.id.cst_decode(),
                name: self.name.cst_decode(),
                widget_url: self.widget_url.cst_decode(),
                pubkey: self.pubkey.cst_decode(),
                host: self.host.cst_decode(),
                base_fee_msat: self.base_fee_msat.cst_decode(),
                fee_rate: self.fee_rate.cst_decode(),
                time_lock_delta: self.time_lock_delta.cst_decode(),
                min_htlc_msat: self.min_htlc_msat.cst_decode(),
                lsp_pubkey: self.lsp_pubkey.cst_decode(),
                opening_fee_params_list: self.opening_fee_params_list.cst_decode(),
            }
        }
    }
    impl CstDecode<crate::binding::MessageSuccessActionData> for wire_cst_message_success_action_data {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::binding::MessageSuccessActionData {
            crate::binding::MessageSuccessActionData {
                message: self.message.cst_decode(),
            }
        }
    }
    impl CstDecode<crate::models::MetadataFilter> for wire_cst_metadata_filter {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::models::MetadataFilter {
            crate::models::MetadataFilter {
                json_path: self.json_path.cst_decode(),
                json_value: self.json_value.cst_decode(),
            }
        }
    }
    impl CstDecode<crate::models::NodeConfig> for wire_cst_node_config {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::models::NodeConfig {
            match self.tag {
                0 => {
                    let ans = unsafe { self.kind.Greenlight };
                    crate::models::NodeConfig::Greenlight {
                        config: ans.config.cst_decode(),
                    }
                }
                _ => unreachable!(),
            }
        }
    }
    impl CstDecode<crate::models::NodeCredentials> for wire_cst_node_credentials {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::models::NodeCredentials {
            match self.tag {
                0 => {
                    let ans = unsafe { self.kind.Greenlight };
                    crate::models::NodeCredentials::Greenlight {
                        credentials: ans.credentials.cst_decode(),
                    }
                }
                _ => unreachable!(),
            }
        }
    }
    impl CstDecode<crate::models::NodeState> for wire_cst_node_state {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::models::NodeState {
            crate::models::NodeState {
                id: self.id.cst_decode(),
                block_height: self.block_height.cst_decode(),
                channels_balance_msat: self.channels_balance_msat.cst_decode(),
                onchain_balance_msat: self.onchain_balance_msat.cst_decode(),
                pending_onchain_balance_msat: self.pending_onchain_balance_msat.cst_decode(),
                utxos: self.utxos.cst_decode(),
                max_payable_msat: self.max_payable_msat.cst_decode(),
                max_receivable_msat: self.max_receivable_msat.cst_decode(),
                max_single_payment_amount_msat: self.max_single_payment_amount_msat.cst_decode(),
                max_chan_reserve_msats: self.max_chan_reserve_msats.cst_decode(),
                connected_peers: self.connected_peers.cst_decode(),
                max_receivable_single_payment_amount_msat: self
                    .max_receivable_single_payment_amount_msat
                    .cst_decode(),
                total_inbound_liquidity_msats: self.total_inbound_liquidity_msats.cst_decode(),
            }
        }
    }
    impl CstDecode<crate::models::OnchainPaymentLimitsResponse>
        for wire_cst_onchain_payment_limits_response
    {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::models::OnchainPaymentLimitsResponse {
            crate::models::OnchainPaymentLimitsResponse {
                min_sat: self.min_sat.cst_decode(),
                max_sat: self.max_sat.cst_decode(),
                max_payable_sat: self.max_payable_sat.cst_decode(),
            }
        }
    }
    impl CstDecode<crate::models::OpenChannelFeeRequest> for wire_cst_open_channel_fee_request {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::models::OpenChannelFeeRequest {
            crate::models::OpenChannelFeeRequest {
                amount_msat: self.amount_msat.cst_decode(),
                expiry: self.expiry.cst_decode(),
            }
        }
    }
    impl CstDecode<crate::models::OpenChannelFeeResponse> for wire_cst_open_channel_fee_response {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::models::OpenChannelFeeResponse {
            crate::models::OpenChannelFeeResponse {
                fee_msat: self.fee_msat.cst_decode(),
                fee_params: self.fee_params.cst_decode(),
            }
        }
    }
    impl CstDecode<crate::models::OpeningFeeParams> for wire_cst_opening_fee_params {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::models::OpeningFeeParams {
            crate::models::OpeningFeeParams {
                min_msat: self.min_msat.cst_decode(),
                proportional: self.proportional.cst_decode(),
                valid_until: self.valid_until.cst_decode(),
                max_idle_time: self.max_idle_time.cst_decode(),
                max_client_to_self_delay: self.max_client_to_self_delay.cst_decode(),
                promise: self.promise.cst_decode(),
            }
        }
    }
    impl CstDecode<crate::models::OpeningFeeParamsMenu> for wire_cst_opening_fee_params_menu {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::models::OpeningFeeParamsMenu {
            crate::models::OpeningFeeParamsMenu {
                values: self.values.cst_decode(),
            }
        }
    }
    impl CstDecode<crate::models::PayOnchainRequest> for wire_cst_pay_onchain_request {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::models::PayOnchainRequest {
            crate::models::PayOnchainRequest {
                recipient_address: self.recipient_address.cst_decode(),
                prepare_res: self.prepare_res.cst_decode(),
            }
        }
    }
    impl CstDecode<crate::models::PayOnchainResponse> for wire_cst_pay_onchain_response {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::models::PayOnchainResponse {
            crate::models::PayOnchainResponse {
                reverse_swap_info: self.reverse_swap_info.cst_decode(),
            }
        }
    }
    impl CstDecode<crate::models::Payment> for wire_cst_payment {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::models::Payment {
            crate::models::Payment {
                id: self.id.cst_decode(),
                payment_type: self.payment_type.cst_decode(),
                payment_time: self.payment_time.cst_decode(),
                amount_msat: self.amount_msat.cst_decode(),
                fee_msat: self.fee_msat.cst_decode(),
                status: self.status.cst_decode(),
                error: self.error.cst_decode(),
                description: self.description.cst_decode(),
                details: self.details.cst_decode(),
                metadata: self.metadata.cst_decode(),
            }
        }
    }
    impl CstDecode<crate::models::PaymentDetails> for wire_cst_payment_details {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::models::PaymentDetails {
            match self.tag {
                0 => {
                    let ans = unsafe { self.kind.Ln };
                    crate::models::PaymentDetails::Ln {
                        data: ans.data.cst_decode(),
                    }
                }
                1 => {
                    let ans = unsafe { self.kind.ClosedChannel };
                    crate::models::PaymentDetails::ClosedChannel {
                        data: ans.data.cst_decode(),
                    }
                }
                _ => unreachable!(),
            }
        }
    }
    impl CstDecode<crate::breez_services::PaymentFailedData> for wire_cst_payment_failed_data {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::breez_services::PaymentFailedData {
            crate::breez_services::PaymentFailedData {
                error: self.error.cst_decode(),
                node_id: self.node_id.cst_decode(),
                invoice: self.invoice.cst_decode(),
                label: self.label.cst_decode(),
            }
        }
    }
    impl CstDecode<crate::models::PrepareOnchainPaymentRequest>
        for wire_cst_prepare_onchain_payment_request
    {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::models::PrepareOnchainPaymentRequest {
            crate::models::PrepareOnchainPaymentRequest {
                amount_sat: self.amount_sat.cst_decode(),
                amount_type: self.amount_type.cst_decode(),
                claim_tx_feerate: self.claim_tx_feerate.cst_decode(),
            }
        }
    }
    impl CstDecode<crate::models::PrepareOnchainPaymentResponse>
        for wire_cst_prepare_onchain_payment_response
    {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::models::PrepareOnchainPaymentResponse {
            crate::models::PrepareOnchainPaymentResponse {
                fees_hash: self.fees_hash.cst_decode(),
                fees_percentage: self.fees_percentage.cst_decode(),
                fees_lockup: self.fees_lockup.cst_decode(),
                fees_claim: self.fees_claim.cst_decode(),
                sender_amount_sat: self.sender_amount_sat.cst_decode(),
                recipient_amount_sat: self.recipient_amount_sat.cst_decode(),
                total_fees: self.total_fees.cst_decode(),
            }
        }
    }
    impl CstDecode<crate::models::PrepareRedeemOnchainFundsRequest>
        for wire_cst_prepare_redeem_onchain_funds_request
    {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::models::PrepareRedeemOnchainFundsRequest {
            crate::models::PrepareRedeemOnchainFundsRequest {
                to_address: self.to_address.cst_decode(),
                sat_per_vbyte: self.sat_per_vbyte.cst_decode(),
            }
        }
    }
    impl CstDecode<crate::models::PrepareRedeemOnchainFundsResponse>
        for wire_cst_prepare_redeem_onchain_funds_response
    {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::models::PrepareRedeemOnchainFundsResponse {
            crate::models::PrepareRedeemOnchainFundsResponse {
                tx_weight: self.tx_weight.cst_decode(),
                tx_fee_sat: self.tx_fee_sat.cst_decode(),
            }
        }
    }
    impl CstDecode<crate::models::PrepareRefundRequest> for wire_cst_prepare_refund_request {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::models::PrepareRefundRequest {
            crate::models::PrepareRefundRequest {
                swap_address: self.swap_address.cst_decode(),
                to_address: self.to_address.cst_decode(),
                sat_per_vbyte: self.sat_per_vbyte.cst_decode(),
                unilateral: self.unilateral.cst_decode(),
            }
        }
    }
    impl CstDecode<crate::models::PrepareRefundResponse> for wire_cst_prepare_refund_response {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::models::PrepareRefundResponse {
            crate::models::PrepareRefundResponse {
                refund_tx_weight: self.refund_tx_weight.cst_decode(),
                refund_tx_fee_sat: self.refund_tx_fee_sat.cst_decode(),
            }
        }
    }
    impl CstDecode<crate::binding::Rate> for wire_cst_rate {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::binding::Rate {
            crate::binding::Rate {
                coin: self.coin.cst_decode(),
                value: self.value.cst_decode(),
            }
        }
    }
    impl CstDecode<crate::models::ReceiveOnchainRequest> for wire_cst_receive_onchain_request {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::models::ReceiveOnchainRequest {
            crate::models::ReceiveOnchainRequest {
                opening_fee_params: self.opening_fee_params.cst_decode(),
            }
        }
    }
    impl CstDecode<crate::models::ReceivePaymentRequest> for wire_cst_receive_payment_request {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::models::ReceivePaymentRequest {
            crate::models::ReceivePaymentRequest {
                amount_msat: self.amount_msat.cst_decode(),
                description: self.description.cst_decode(),
                preimage: self.preimage.cst_decode(),
                opening_fee_params: self.opening_fee_params.cst_decode(),
                use_description_hash: self.use_description_hash.cst_decode(),
                expiry: self.expiry.cst_decode(),
                cltv: self.cltv.cst_decode(),
            }
        }
    }
    impl CstDecode<crate::models::ReceivePaymentResponse> for wire_cst_receive_payment_response {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::models::ReceivePaymentResponse {
            crate::models::ReceivePaymentResponse {
                ln_invoice: self.ln_invoice.cst_decode(),
                opening_fee_params: self.opening_fee_params.cst_decode(),
                opening_fee_msat: self.opening_fee_msat.cst_decode(),
            }
        }
    }
    impl CstDecode<crate::chain::RecommendedFees> for wire_cst_recommended_fees {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::chain::RecommendedFees {
            crate::chain::RecommendedFees {
                fastest_fee: self.fastest_fee.cst_decode(),
                half_hour_fee: self.half_hour_fee.cst_decode(),
                hour_fee: self.hour_fee.cst_decode(),
                economy_fee: self.economy_fee.cst_decode(),
                minimum_fee: self.minimum_fee.cst_decode(),
            }
        }
    }
    impl CstDecode<crate::models::RedeemOnchainFundsRequest> for wire_cst_redeem_onchain_funds_request {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::models::RedeemOnchainFundsRequest {
            crate::models::RedeemOnchainFundsRequest {
                to_address: self.to_address.cst_decode(),
                sat_per_vbyte: self.sat_per_vbyte.cst_decode(),
            }
        }
    }
    impl CstDecode<crate::models::RedeemOnchainFundsResponse>
        for wire_cst_redeem_onchain_funds_response
    {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::models::RedeemOnchainFundsResponse {
            crate::models::RedeemOnchainFundsResponse {
                txid: self.txid.cst_decode(),
            }
        }
    }
    impl CstDecode<crate::models::RefundRequest> for wire_cst_refund_request {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::models::RefundRequest {
            crate::models::RefundRequest {
                swap_address: self.swap_address.cst_decode(),
                to_address: self.to_address.cst_decode(),
                sat_per_vbyte: self.sat_per_vbyte.cst_decode(),
                unilateral: self.unilateral.cst_decode(),
            }
        }
    }
    impl CstDecode<crate::models::RefundResponse> for wire_cst_refund_response {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::models::RefundResponse {
            crate::models::RefundResponse {
                refund_tx_id: self.refund_tx_id.cst_decode(),
            }
        }
    }
    impl CstDecode<crate::models::ReportIssueRequest> for wire_cst_report_issue_request {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::models::ReportIssueRequest {
            match self.tag {
                0 => {
                    let ans = unsafe { self.kind.PaymentFailure };
                    crate::models::ReportIssueRequest::PaymentFailure {
                        data: ans.data.cst_decode(),
                    }
                }
                _ => unreachable!(),
            }
        }
    }
    impl CstDecode<crate::models::ReportPaymentFailureDetails>
        for wire_cst_report_payment_failure_details
    {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::models::ReportPaymentFailureDetails {
            crate::models::ReportPaymentFailureDetails {
                payment_hash: self.payment_hash.cst_decode(),
                comment: self.comment.cst_decode(),
            }
        }
    }
    impl CstDecode<crate::models::ReverseSwapFeesRequest> for wire_cst_reverse_swap_fees_request {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::models::ReverseSwapFeesRequest {
            crate::models::ReverseSwapFeesRequest {
                send_amount_sat: self.send_amount_sat.cst_decode(),
                claim_tx_feerate: self.claim_tx_feerate.cst_decode(),
            }
        }
    }
    impl CstDecode<crate::models::ReverseSwapInfo> for wire_cst_reverse_swap_info {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::models::ReverseSwapInfo {
            crate::models::ReverseSwapInfo {
                id: self.id.cst_decode(),
                claim_pubkey: self.claim_pubkey.cst_decode(),
                lockup_txid: self.lockup_txid.cst_decode(),
                claim_txid: self.claim_txid.cst_decode(),
                onchain_amount_sat: self.onchain_amount_sat.cst_decode(),
                status: self.status.cst_decode(),
            }
        }
    }
    impl CstDecode<crate::models::ReverseSwapPairInfo> for wire_cst_reverse_swap_pair_info {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::models::ReverseSwapPairInfo {
            crate::models::ReverseSwapPairInfo {
                min: self.min.cst_decode(),
                max: self.max.cst_decode(),
                fees_hash: self.fees_hash.cst_decode(),
                fees_percentage: self.fees_percentage.cst_decode(),
                fees_lockup: self.fees_lockup.cst_decode(),
                fees_claim: self.fees_claim.cst_decode(),
                total_fees: self.total_fees.cst_decode(),
            }
        }
    }
    impl CstDecode<crate::binding::RouteHint> for wire_cst_route_hint {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::binding::RouteHint {
            crate::binding::RouteHint {
                hops: self.hops.cst_decode(),
            }
        }
    }
    impl CstDecode<crate::binding::RouteHintHop> for wire_cst_route_hint_hop {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::binding::RouteHintHop {
            crate::binding::RouteHintHop {
                src_node_id: self.src_node_id.cst_decode(),
                short_channel_id: self.short_channel_id.cst_decode(),
                fees_base_msat: self.fees_base_msat.cst_decode(),
                fees_proportional_millionths: self.fees_proportional_millionths.cst_decode(),
                cltv_expiry_delta: self.cltv_expiry_delta.cst_decode(),
                htlc_minimum_msat: self.htlc_minimum_msat.cst_decode(),
                htlc_maximum_msat: self.htlc_maximum_msat.cst_decode(),
            }
        }
    }
    impl CstDecode<crate::models::SendPaymentRequest> for wire_cst_send_payment_request {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::models::SendPaymentRequest {
            crate::models::SendPaymentRequest {
                bolt11: self.bolt11.cst_decode(),
                use_trampoline: self.use_trampoline.cst_decode(),
                amount_msat: self.amount_msat.cst_decode(),
                label: self.label.cst_decode(),
            }
        }
    }
    impl CstDecode<crate::models::SendPaymentResponse> for wire_cst_send_payment_response {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::models::SendPaymentResponse {
            crate::models::SendPaymentResponse {
                payment: self.payment.cst_decode(),
            }
        }
    }
    impl CstDecode<crate::models::SendSpontaneousPaymentRequest>
        for wire_cst_send_spontaneous_payment_request
    {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::models::SendSpontaneousPaymentRequest {
            crate::models::SendSpontaneousPaymentRequest {
                node_id: self.node_id.cst_decode(),
                amount_msat: self.amount_msat.cst_decode(),
                extra_tlvs: self.extra_tlvs.cst_decode(),
                label: self.label.cst_decode(),
            }
        }
    }
    impl CstDecode<crate::models::ServiceHealthCheckResponse>
        for wire_cst_service_health_check_response
    {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::models::ServiceHealthCheckResponse {
            crate::models::ServiceHealthCheckResponse {
                status: self.status.cst_decode(),
            }
        }
    }
    impl CstDecode<crate::breez_services::SignMessageRequest> for wire_cst_sign_message_request {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::breez_services::SignMessageRequest {
            crate::breez_services::SignMessageRequest {
                message: self.message.cst_decode(),
            }
        }
    }
    impl CstDecode<crate::breez_services::SignMessageResponse> for wire_cst_sign_message_response {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::breez_services::SignMessageResponse {
            crate::breez_services::SignMessageResponse {
                signature: self.signature.cst_decode(),
            }
        }
    }
    impl CstDecode<crate::models::StaticBackupRequest> for wire_cst_static_backup_request {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::models::StaticBackupRequest {
            crate::models::StaticBackupRequest {
                working_dir: self.working_dir.cst_decode(),
            }
        }
    }
    impl CstDecode<crate::models::StaticBackupResponse> for wire_cst_static_backup_response {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::models::StaticBackupResponse {
            crate::models::StaticBackupResponse {
                backup: self.backup.cst_decode(),
            }
        }
    }
    impl CstDecode<crate::binding::SuccessActionProcessed> for wire_cst_success_action_processed {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::binding::SuccessActionProcessed {
            match self.tag {
                0 => {
                    let ans = unsafe { self.kind.Aes };
                    crate::binding::SuccessActionProcessed::Aes {
                        result: ans.result.cst_decode(),
                    }
                }
                1 => {
                    let ans = unsafe { self.kind.Message };
                    crate::binding::SuccessActionProcessed::Message {
                        data: ans.data.cst_decode(),
                    }
                }
                2 => {
                    let ans = unsafe { self.kind.Url };
                    crate::binding::SuccessActionProcessed::Url {
                        data: ans.data.cst_decode(),
                    }
                }
                _ => unreachable!(),
            }
        }
    }
    impl CstDecode<crate::models::SwapInfo> for wire_cst_swap_info {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::models::SwapInfo {
            crate::models::SwapInfo {
                bitcoin_address: self.bitcoin_address.cst_decode(),
                created_at: self.created_at.cst_decode(),
                lock_height: self.lock_height.cst_decode(),
                payment_hash: self.payment_hash.cst_decode(),
                preimage: self.preimage.cst_decode(),
                private_key: self.private_key.cst_decode(),
                public_key: self.public_key.cst_decode(),
                swapper_public_key: self.swapper_public_key.cst_decode(),
                script: self.script.cst_decode(),
                bolt11: self.bolt11.cst_decode(),
                paid_msat: self.paid_msat.cst_decode(),
                total_incoming_txs: self.total_incoming_txs.cst_decode(),
                confirmed_sats: self.confirmed_sats.cst_decode(),
                unconfirmed_sats: self.unconfirmed_sats.cst_decode(),
                status: self.status.cst_decode(),
                refund_tx_ids: self.refund_tx_ids.cst_decode(),
                unconfirmed_tx_ids: self.unconfirmed_tx_ids.cst_decode(),
                confirmed_tx_ids: self.confirmed_tx_ids.cst_decode(),
                min_allowed_deposit: self.min_allowed_deposit.cst_decode(),
                max_allowed_deposit: self.max_allowed_deposit.cst_decode(),
                max_swapper_payable: self.max_swapper_payable.cst_decode(),
                last_redeem_error: self.last_redeem_error.cst_decode(),
                channel_opening_fees: self.channel_opening_fees.cst_decode(),
                confirmed_at: self.confirmed_at.cst_decode(),
            }
        }
    }
    impl CstDecode<crate::binding::Symbol> for wire_cst_symbol {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::binding::Symbol {
            crate::binding::Symbol {
                grapheme: self.grapheme.cst_decode(),
                template: self.template.cst_decode(),
                rtl: self.rtl.cst_decode(),
                position: self.position.cst_decode(),
            }
        }
    }
    impl CstDecode<crate::models::TlvEntry> for wire_cst_tlv_entry {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::models::TlvEntry {
            crate::models::TlvEntry {
                field_number: self.field_number.cst_decode(),
                value: self.value.cst_decode(),
            }
        }
    }
    impl CstDecode<crate::models::UnspentTransactionOutput> for wire_cst_unspent_transaction_output {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::models::UnspentTransactionOutput {
            crate::models::UnspentTransactionOutput {
                txid: self.txid.cst_decode(),
                outnum: self.outnum.cst_decode(),
                amount_millisatoshi: self.amount_millisatoshi.cst_decode(),
                address: self.address.cst_decode(),
                reserved: self.reserved.cst_decode(),
            }
        }
    }
    impl CstDecode<crate::binding::UrlSuccessActionData> for wire_cst_url_success_action_data {
        // Codec=Cst (C-struct based), see doc to use other codecs
        fn cst_decode(self) -> crate::binding::UrlSuccessActionData {
            crate::binding::UrlSuccessActionData {
                description: self.description.cst_decode(),
                url: self.url.cst_decode(),
                matches_callback_domain: self.matches_callback_domain.cst_decode(),
            }
        }
    }
    impl NewWithNullPtr for wire_cst_aes_success_action_data_decrypted {
        fn new_with_null_ptr() -> Self {
            Self {
                description: core::ptr::null_mut(),
                plaintext: core::ptr::null_mut(),
            }
        }
    }
    impl Default for wire_cst_aes_success_action_data_decrypted {
        fn default() -> Self {
            Self::new_with_null_ptr()
        }
    }
    impl NewWithNullPtr for wire_cst_aes_success_action_data_result {
        fn new_with_null_ptr() -> Self {
            Self {
                tag: -1,
                kind: AesSuccessActionDataResultKind { nil__: () },
            }
        }
    }
    impl Default for wire_cst_aes_success_action_data_result {
        fn default() -> Self {
            Self::new_with_null_ptr()
        }
    }
    impl NewWithNullPtr for wire_cst_backup_failed_data {
        fn new_with_null_ptr() -> Self {
            Self {
                error: core::ptr::null_mut(),
            }
        }
    }
    impl Default for wire_cst_backup_failed_data {
        fn default() -> Self {
            Self::new_with_null_ptr()
        }
    }
    impl NewWithNullPtr for wire_cst_backup_status {
        fn new_with_null_ptr() -> Self {
            Self {
                backed_up: Default::default(),
                last_backup_time: core::ptr::null_mut(),
            }
        }
    }
    impl Default for wire_cst_backup_status {
        fn default() -> Self {
            Self::new_with_null_ptr()
        }
    }
    impl NewWithNullPtr for wire_cst_binding_event_listener {
        fn new_with_null_ptr() -> Self {
            Self {}
        }
    }
    impl Default for wire_cst_binding_event_listener {
        fn default() -> Self {
            Self::new_with_null_ptr()
        }
    }
    impl NewWithNullPtr for wire_cst_bitcoin_address_data {
        fn new_with_null_ptr() -> Self {
            Self {
                address: core::ptr::null_mut(),
                network: Default::default(),
                amount_sat: core::ptr::null_mut(),
                label: core::ptr::null_mut(),
                message: core::ptr::null_mut(),
            }
        }
    }
    impl Default for wire_cst_bitcoin_address_data {
        fn default() -> Self {
            Self::new_with_null_ptr()
        }
    }
    impl NewWithNullPtr for wire_cst_breez_event {
        fn new_with_null_ptr() -> Self {
            Self {
                tag: -1,
                kind: BreezEventKind { nil__: () },
            }
        }
    }
    impl Default for wire_cst_breez_event {
        fn default() -> Self {
            Self::new_with_null_ptr()
        }
    }
    impl NewWithNullPtr for wire_cst_buy_bitcoin_request {
        fn new_with_null_ptr() -> Self {
            Self {
                provider: Default::default(),
                opening_fee_params: core::ptr::null_mut(),
                redirect_url: core::ptr::null_mut(),
            }
        }
    }
    impl Default for wire_cst_buy_bitcoin_request {
        fn default() -> Self {
            Self::new_with_null_ptr()
        }
    }
    impl NewWithNullPtr for wire_cst_buy_bitcoin_response {
        fn new_with_null_ptr() -> Self {
            Self {
                url: core::ptr::null_mut(),
                opening_fee_params: core::ptr::null_mut(),
            }
        }
    }
    impl Default for wire_cst_buy_bitcoin_response {
        fn default() -> Self {
            Self::new_with_null_ptr()
        }
    }
    impl NewWithNullPtr for wire_cst_check_message_request {
        fn new_with_null_ptr() -> Self {
            Self {
                message: core::ptr::null_mut(),
                pubkey: core::ptr::null_mut(),
                signature: core::ptr::null_mut(),
            }
        }
    }
    impl Default for wire_cst_check_message_request {
        fn default() -> Self {
            Self::new_with_null_ptr()
        }
    }
    impl NewWithNullPtr for wire_cst_check_message_response {
        fn new_with_null_ptr() -> Self {
            Self {
                is_valid: Default::default(),
            }
        }
    }
    impl Default for wire_cst_check_message_response {
        fn default() -> Self {
            Self::new_with_null_ptr()
        }
    }
    impl NewWithNullPtr for wire_cst_closed_channel_payment_details {
        fn new_with_null_ptr() -> Self {
            Self {
                state: Default::default(),
                funding_txid: core::ptr::null_mut(),
                short_channel_id: core::ptr::null_mut(),
                closing_txid: core::ptr::null_mut(),
            }
        }
    }
    impl Default for wire_cst_closed_channel_payment_details {
        fn default() -> Self {
            Self::new_with_null_ptr()
        }
    }
    impl NewWithNullPtr for wire_cst_config {
        fn new_with_null_ptr() -> Self {
            Self {
                breezserver: core::ptr::null_mut(),
                chainnotifier_url: core::ptr::null_mut(),
                mempoolspace_url: core::ptr::null_mut(),
                working_dir: core::ptr::null_mut(),
                network: Default::default(),
                payment_timeout_sec: Default::default(),
                default_lsp_id: core::ptr::null_mut(),
                api_key: core::ptr::null_mut(),
                maxfee_percent: Default::default(),
                exemptfee_msat: Default::default(),
                node_config: Default::default(),
            }
        }
    }
    impl Default for wire_cst_config {
        fn default() -> Self {
            Self::new_with_null_ptr()
        }
    }
    impl NewWithNullPtr for wire_cst_configure_node_request {
        fn new_with_null_ptr() -> Self {
            Self {
                close_to_address: core::ptr::null_mut(),
            }
        }
    }
    impl Default for wire_cst_configure_node_request {
        fn default() -> Self {
            Self::new_with_null_ptr()
        }
    }
    impl NewWithNullPtr for wire_cst_connect_request {
        fn new_with_null_ptr() -> Self {
            Self {
                config: Default::default(),
                seed: core::ptr::null_mut(),
                restore_only: core::ptr::null_mut(),
            }
        }
    }
    impl Default for wire_cst_connect_request {
        fn default() -> Self {
            Self::new_with_null_ptr()
        }
    }
    impl NewWithNullPtr for wire_cst_currency_info {
        fn new_with_null_ptr() -> Self {
            Self {
                name: core::ptr::null_mut(),
                fraction_size: Default::default(),
                spacing: core::ptr::null_mut(),
                symbol: core::ptr::null_mut(),
                uniq_symbol: core::ptr::null_mut(),
                localized_name: core::ptr::null_mut(),
                locale_overrides: core::ptr::null_mut(),
            }
        }
    }
    impl Default for wire_cst_currency_info {
        fn default() -> Self {
            Self::new_with_null_ptr()
        }
    }
    impl NewWithNullPtr for wire_cst_fiat_currency {
        fn new_with_null_ptr() -> Self {
            Self {
                id: core::ptr::null_mut(),
                info: Default::default(),
            }
        }
    }
    impl Default for wire_cst_fiat_currency {
        fn default() -> Self {
            Self::new_with_null_ptr()
        }
    }
    impl NewWithNullPtr for wire_cst_greenlight_credentials {
        fn new_with_null_ptr() -> Self {
            Self {
                developer_key: core::ptr::null_mut(),
                developer_cert: core::ptr::null_mut(),
            }
        }
    }
    impl Default for wire_cst_greenlight_credentials {
        fn default() -> Self {
            Self::new_with_null_ptr()
        }
    }
    impl NewWithNullPtr for wire_cst_greenlight_device_credentials {
        fn new_with_null_ptr() -> Self {
            Self {
                device: core::ptr::null_mut(),
            }
        }
    }
    impl Default for wire_cst_greenlight_device_credentials {
        fn default() -> Self {
            Self::new_with_null_ptr()
        }
    }
    impl NewWithNullPtr for wire_cst_greenlight_node_config {
        fn new_with_null_ptr() -> Self {
            Self {
                partner_credentials: core::ptr::null_mut(),
                invite_code: core::ptr::null_mut(),
            }
        }
    }
    impl Default for wire_cst_greenlight_node_config {
        fn default() -> Self {
            Self::new_with_null_ptr()
        }
    }
    impl NewWithNullPtr for wire_cst_input_type {
        fn new_with_null_ptr() -> Self {
            Self {
                tag: -1,
                kind: InputTypeKind { nil__: () },
            }
        }
    }
    impl Default for wire_cst_input_type {
        fn default() -> Self {
            Self::new_with_null_ptr()
        }
    }
    impl NewWithNullPtr for wire_cst_invoice_paid_details {
        fn new_with_null_ptr() -> Self {
            Self {
                payment_hash: core::ptr::null_mut(),
                bolt11: core::ptr::null_mut(),
                payment: core::ptr::null_mut(),
            }
        }
    }
    impl Default for wire_cst_invoice_paid_details {
        fn default() -> Self {
            Self::new_with_null_ptr()
        }
    }
    impl NewWithNullPtr for wire_cst_list_payments_request {
        fn new_with_null_ptr() -> Self {
            Self {
                filters: core::ptr::null_mut(),
                metadata_filters: core::ptr::null_mut(),
                from_timestamp: core::ptr::null_mut(),
                to_timestamp: core::ptr::null_mut(),
                include_failures: core::ptr::null_mut(),
                offset: core::ptr::null_mut(),
                limit: core::ptr::null_mut(),
            }
        }
    }
    impl Default for wire_cst_list_payments_request {
        fn default() -> Self {
            Self::new_with_null_ptr()
        }
    }
    impl NewWithNullPtr for wire_cst_list_swaps_request {
        fn new_with_null_ptr() -> Self {
            Self {
                status: core::ptr::null_mut(),
                from_timestamp: core::ptr::null_mut(),
                to_timestamp: core::ptr::null_mut(),
                offset: core::ptr::null_mut(),
                limit: core::ptr::null_mut(),
            }
        }
    }
    impl Default for wire_cst_list_swaps_request {
        fn default() -> Self {
            Self::new_with_null_ptr()
        }
    }
    impl NewWithNullPtr for wire_cst_ln_invoice {
        fn new_with_null_ptr() -> Self {
            Self {
                bolt11: core::ptr::null_mut(),
                network: Default::default(),
                payee_pubkey: core::ptr::null_mut(),
                payment_hash: core::ptr::null_mut(),
                description: core::ptr::null_mut(),
                description_hash: core::ptr::null_mut(),
                amount_msat: core::ptr::null_mut(),
                timestamp: Default::default(),
                expiry: Default::default(),
                routing_hints: core::ptr::null_mut(),
                payment_secret: core::ptr::null_mut(),
                min_final_cltv_expiry_delta: Default::default(),
            }
        }
    }
    impl Default for wire_cst_ln_invoice {
        fn default() -> Self {
            Self::new_with_null_ptr()
        }
    }
    impl NewWithNullPtr for wire_cst_ln_payment_details {
        fn new_with_null_ptr() -> Self {
            Self {
                payment_hash: core::ptr::null_mut(),
                label: core::ptr::null_mut(),
                destination_pubkey: core::ptr::null_mut(),
                payment_preimage: core::ptr::null_mut(),
                keysend: Default::default(),
                bolt11: core::ptr::null_mut(),
                open_channel_bolt11: core::ptr::null_mut(),
                lnurl_success_action: core::ptr::null_mut(),
                lnurl_pay_domain: core::ptr::null_mut(),
                lnurl_pay_comment: core::ptr::null_mut(),
                ln_address: core::ptr::null_mut(),
                lnurl_metadata: core::ptr::null_mut(),
                lnurl_withdraw_endpoint: core::ptr::null_mut(),
                swap_info: core::ptr::null_mut(),
                reverse_swap_info: core::ptr::null_mut(),
                pending_expiration_block: core::ptr::null_mut(),
            }
        }
    }
    impl Default for wire_cst_ln_payment_details {
        fn default() -> Self {
            Self::new_with_null_ptr()
        }
    }
    impl NewWithNullPtr for wire_cst_ln_url_auth_request_data {
        fn new_with_null_ptr() -> Self {
            Self {
                k1: core::ptr::null_mut(),
                action: core::ptr::null_mut(),
                domain: core::ptr::null_mut(),
                url: core::ptr::null_mut(),
            }
        }
    }
    impl Default for wire_cst_ln_url_auth_request_data {
        fn default() -> Self {
            Self::new_with_null_ptr()
        }
    }
    impl NewWithNullPtr for wire_cst_ln_url_callback_status {
        fn new_with_null_ptr() -> Self {
            Self {
                tag: -1,
                kind: LnUrlCallbackStatusKind { nil__: () },
            }
        }
    }
    impl Default for wire_cst_ln_url_callback_status {
        fn default() -> Self {
            Self::new_with_null_ptr()
        }
    }
    impl NewWithNullPtr for wire_cst_ln_url_error_data {
        fn new_with_null_ptr() -> Self {
            Self {
                reason: core::ptr::null_mut(),
            }
        }
    }
    impl Default for wire_cst_ln_url_error_data {
        fn default() -> Self {
            Self::new_with_null_ptr()
        }
    }
    impl NewWithNullPtr for wire_cst_ln_url_pay_error_data {
        fn new_with_null_ptr() -> Self {
            Self {
                payment_hash: core::ptr::null_mut(),
                reason: core::ptr::null_mut(),
            }
        }
    }
    impl Default for wire_cst_ln_url_pay_error_data {
        fn default() -> Self {
            Self::new_with_null_ptr()
        }
    }
    impl NewWithNullPtr for wire_cst_ln_url_pay_request {
        fn new_with_null_ptr() -> Self {
            Self {
                data: Default::default(),
                amount_msat: Default::default(),
                use_trampoline: Default::default(),
                comment: core::ptr::null_mut(),
                payment_label: core::ptr::null_mut(),
                validate_success_action_url: core::ptr::null_mut(),
            }
        }
    }
    impl Default for wire_cst_ln_url_pay_request {
        fn default() -> Self {
            Self::new_with_null_ptr()
        }
    }
    impl NewWithNullPtr for wire_cst_ln_url_pay_request_data {
        fn new_with_null_ptr() -> Self {
            Self {
                callback: core::ptr::null_mut(),
                min_sendable: Default::default(),
                max_sendable: Default::default(),
                metadata_str: core::ptr::null_mut(),
                comment_allowed: Default::default(),
                domain: core::ptr::null_mut(),
                allows_nostr: Default::default(),
                nostr_pubkey: core::ptr::null_mut(),
                ln_address: core::ptr::null_mut(),
            }
        }
    }
    impl Default for wire_cst_ln_url_pay_request_data {
        fn default() -> Self {
            Self::new_with_null_ptr()
        }
    }
    impl NewWithNullPtr for wire_cst_ln_url_pay_result {
        fn new_with_null_ptr() -> Self {
            Self {
                tag: -1,
                kind: LnUrlPayResultKind { nil__: () },
            }
        }
    }
    impl Default for wire_cst_ln_url_pay_result {
        fn default() -> Self {
            Self::new_with_null_ptr()
        }
    }
    impl NewWithNullPtr for wire_cst_ln_url_pay_success_data {
        fn new_with_null_ptr() -> Self {
            Self {
                payment: Default::default(),
                success_action: core::ptr::null_mut(),
            }
        }
    }
    impl Default for wire_cst_ln_url_pay_success_data {
        fn default() -> Self {
            Self::new_with_null_ptr()
        }
    }
    impl NewWithNullPtr for wire_cst_ln_url_withdraw_request {
        fn new_with_null_ptr() -> Self {
            Self {
                data: Default::default(),
                amount_msat: Default::default(),
                description: core::ptr::null_mut(),
            }
        }
    }
    impl Default for wire_cst_ln_url_withdraw_request {
        fn default() -> Self {
            Self::new_with_null_ptr()
        }
    }
    impl NewWithNullPtr for wire_cst_ln_url_withdraw_request_data {
        fn new_with_null_ptr() -> Self {
            Self {
                callback: core::ptr::null_mut(),
                k1: core::ptr::null_mut(),
                default_description: core::ptr::null_mut(),
                min_withdrawable: Default::default(),
                max_withdrawable: Default::default(),
            }
        }
    }
    impl Default for wire_cst_ln_url_withdraw_request_data {
        fn default() -> Self {
            Self::new_with_null_ptr()
        }
    }
    impl NewWithNullPtr for wire_cst_ln_url_withdraw_result {
        fn new_with_null_ptr() -> Self {
            Self {
                tag: -1,
                kind: LnUrlWithdrawResultKind { nil__: () },
            }
        }
    }
    impl Default for wire_cst_ln_url_withdraw_result {
        fn default() -> Self {
            Self::new_with_null_ptr()
        }
    }
    impl NewWithNullPtr for wire_cst_ln_url_withdraw_success_data {
        fn new_with_null_ptr() -> Self {
            Self {
                invoice: Default::default(),
            }
        }
    }
    impl Default for wire_cst_ln_url_withdraw_success_data {
        fn default() -> Self {
            Self::new_with_null_ptr()
        }
    }
    impl NewWithNullPtr for wire_cst_locale_overrides {
        fn new_with_null_ptr() -> Self {
            Self {
                locale: core::ptr::null_mut(),
                spacing: core::ptr::null_mut(),
                symbol: Default::default(),
            }
        }
    }
    impl Default for wire_cst_locale_overrides {
        fn default() -> Self {
            Self::new_with_null_ptr()
        }
    }
    impl NewWithNullPtr for wire_cst_localized_name {
        fn new_with_null_ptr() -> Self {
            Self {
                locale: core::ptr::null_mut(),
                name: core::ptr::null_mut(),
            }
        }
    }
    impl Default for wire_cst_localized_name {
        fn default() -> Self {
            Self::new_with_null_ptr()
        }
    }
    impl NewWithNullPtr for wire_cst_log_entry {
        fn new_with_null_ptr() -> Self {
            Self {
                line: core::ptr::null_mut(),
                level: core::ptr::null_mut(),
            }
        }
    }
    impl Default for wire_cst_log_entry {
        fn default() -> Self {
            Self::new_with_null_ptr()
        }
    }
    impl NewWithNullPtr for wire_cst_lsp_information {
        fn new_with_null_ptr() -> Self {
            Self {
                id: core::ptr::null_mut(),
                name: core::ptr::null_mut(),
                widget_url: core::ptr::null_mut(),
                pubkey: core::ptr::null_mut(),
                host: core::ptr::null_mut(),
                base_fee_msat: Default::default(),
                fee_rate: Default::default(),
                time_lock_delta: Default::default(),
                min_htlc_msat: Default::default(),
                lsp_pubkey: core::ptr::null_mut(),
                opening_fee_params_list: Default::default(),
            }
        }
    }
    impl Default for wire_cst_lsp_information {
        fn default() -> Self {
            Self::new_with_null_ptr()
        }
    }
    impl NewWithNullPtr for wire_cst_message_success_action_data {
        fn new_with_null_ptr() -> Self {
            Self {
                message: core::ptr::null_mut(),
            }
        }
    }
    impl Default for wire_cst_message_success_action_data {
        fn default() -> Self {
            Self::new_with_null_ptr()
        }
    }
    impl NewWithNullPtr for wire_cst_metadata_filter {
        fn new_with_null_ptr() -> Self {
            Self {
                json_path: core::ptr::null_mut(),
                json_value: core::ptr::null_mut(),
            }
        }
    }
    impl Default for wire_cst_metadata_filter {
        fn default() -> Self {
            Self::new_with_null_ptr()
        }
    }
    impl NewWithNullPtr for wire_cst_node_config {
        fn new_with_null_ptr() -> Self {
            Self {
                tag: -1,
                kind: NodeConfigKind { nil__: () },
            }
        }
    }
    impl Default for wire_cst_node_config {
        fn default() -> Self {
            Self::new_with_null_ptr()
        }
    }
    impl NewWithNullPtr for wire_cst_node_credentials {
        fn new_with_null_ptr() -> Self {
            Self {
                tag: -1,
                kind: NodeCredentialsKind { nil__: () },
            }
        }
    }
    impl Default for wire_cst_node_credentials {
        fn default() -> Self {
            Self::new_with_null_ptr()
        }
    }
    impl NewWithNullPtr for wire_cst_node_state {
        fn new_with_null_ptr() -> Self {
            Self {
                id: core::ptr::null_mut(),
                block_height: Default::default(),
                channels_balance_msat: Default::default(),
                onchain_balance_msat: Default::default(),
                pending_onchain_balance_msat: Default::default(),
                utxos: core::ptr::null_mut(),
                max_payable_msat: Default::default(),
                max_receivable_msat: Default::default(),
                max_single_payment_amount_msat: Default::default(),
                max_chan_reserve_msats: Default::default(),
                connected_peers: core::ptr::null_mut(),
                max_receivable_single_payment_amount_msat: Default::default(),
                total_inbound_liquidity_msats: Default::default(),
            }
        }
    }
    impl Default for wire_cst_node_state {
        fn default() -> Self {
            Self::new_with_null_ptr()
        }
    }
    impl NewWithNullPtr for wire_cst_onchain_payment_limits_response {
        fn new_with_null_ptr() -> Self {
            Self {
                min_sat: Default::default(),
                max_sat: Default::default(),
                max_payable_sat: Default::default(),
            }
        }
    }
    impl Default for wire_cst_onchain_payment_limits_response {
        fn default() -> Self {
            Self::new_with_null_ptr()
        }
    }
    impl NewWithNullPtr for wire_cst_open_channel_fee_request {
        fn new_with_null_ptr() -> Self {
            Self {
                amount_msat: core::ptr::null_mut(),
                expiry: core::ptr::null_mut(),
            }
        }
    }
    impl Default for wire_cst_open_channel_fee_request {
        fn default() -> Self {
            Self::new_with_null_ptr()
        }
    }
    impl NewWithNullPtr for wire_cst_open_channel_fee_response {
        fn new_with_null_ptr() -> Self {
            Self {
                fee_msat: core::ptr::null_mut(),
                fee_params: Default::default(),
            }
        }
    }
    impl Default for wire_cst_open_channel_fee_response {
        fn default() -> Self {
            Self::new_with_null_ptr()
        }
    }
    impl NewWithNullPtr for wire_cst_opening_fee_params {
        fn new_with_null_ptr() -> Self {
            Self {
                min_msat: Default::default(),
                proportional: Default::default(),
                valid_until: core::ptr::null_mut(),
                max_idle_time: Default::default(),
                max_client_to_self_delay: Default::default(),
                promise: core::ptr::null_mut(),
            }
        }
    }
    impl Default for wire_cst_opening_fee_params {
        fn default() -> Self {
            Self::new_with_null_ptr()
        }
    }
    impl NewWithNullPtr for wire_cst_opening_fee_params_menu {
        fn new_with_null_ptr() -> Self {
            Self {
                values: core::ptr::null_mut(),
            }
        }
    }
    impl Default for wire_cst_opening_fee_params_menu {
        fn default() -> Self {
            Self::new_with_null_ptr()
        }
    }
    impl NewWithNullPtr for wire_cst_pay_onchain_request {
        fn new_with_null_ptr() -> Self {
            Self {
                recipient_address: core::ptr::null_mut(),
                prepare_res: Default::default(),
            }
        }
    }
    impl Default for wire_cst_pay_onchain_request {
        fn default() -> Self {
            Self::new_with_null_ptr()
        }
    }
    impl NewWithNullPtr for wire_cst_pay_onchain_response {
        fn new_with_null_ptr() -> Self {
            Self {
                reverse_swap_info: Default::default(),
            }
        }
    }
    impl Default for wire_cst_pay_onchain_response {
        fn default() -> Self {
            Self::new_with_null_ptr()
        }
    }
    impl NewWithNullPtr for wire_cst_payment {
        fn new_with_null_ptr() -> Self {
            Self {
                id: core::ptr::null_mut(),
                payment_type: Default::default(),
                payment_time: Default::default(),
                amount_msat: Default::default(),
                fee_msat: Default::default(),
                status: Default::default(),
                error: core::ptr::null_mut(),
                description: core::ptr::null_mut(),
                details: Default::default(),
                metadata: core::ptr::null_mut(),
            }
        }
    }
    impl Default for wire_cst_payment {
        fn default() -> Self {
            Self::new_with_null_ptr()
        }
    }
    impl NewWithNullPtr for wire_cst_payment_details {
        fn new_with_null_ptr() -> Self {
            Self {
                tag: -1,
                kind: PaymentDetailsKind { nil__: () },
            }
        }
    }
    impl Default for wire_cst_payment_details {
        fn default() -> Self {
            Self::new_with_null_ptr()
        }
    }
    impl NewWithNullPtr for wire_cst_payment_failed_data {
        fn new_with_null_ptr() -> Self {
            Self {
                error: core::ptr::null_mut(),
                node_id: core::ptr::null_mut(),
                invoice: core::ptr::null_mut(),
                label: core::ptr::null_mut(),
            }
        }
    }
    impl Default for wire_cst_payment_failed_data {
        fn default() -> Self {
            Self::new_with_null_ptr()
        }
    }
    impl NewWithNullPtr for wire_cst_prepare_onchain_payment_request {
        fn new_with_null_ptr() -> Self {
            Self {
                amount_sat: Default::default(),
                amount_type: Default::default(),
                claim_tx_feerate: Default::default(),
            }
        }
    }
    impl Default for wire_cst_prepare_onchain_payment_request {
        fn default() -> Self {
            Self::new_with_null_ptr()
        }
    }
    impl NewWithNullPtr for wire_cst_prepare_onchain_payment_response {
        fn new_with_null_ptr() -> Self {
            Self {
                fees_hash: core::ptr::null_mut(),
                fees_percentage: Default::default(),
                fees_lockup: Default::default(),
                fees_claim: Default::default(),
                sender_amount_sat: Default::default(),
                recipient_amount_sat: Default::default(),
                total_fees: Default::default(),
            }
        }
    }
    impl Default for wire_cst_prepare_onchain_payment_response {
        fn default() -> Self {
            Self::new_with_null_ptr()
        }
    }
    impl NewWithNullPtr for wire_cst_prepare_redeem_onchain_funds_request {
        fn new_with_null_ptr() -> Self {
            Self {
                to_address: core::ptr::null_mut(),
                sat_per_vbyte: Default::default(),
            }
        }
    }
    impl Default for wire_cst_prepare_redeem_onchain_funds_request {
        fn default() -> Self {
            Self::new_with_null_ptr()
        }
    }
    impl NewWithNullPtr for wire_cst_prepare_redeem_onchain_funds_response {
        fn new_with_null_ptr() -> Self {
            Self {
                tx_weight: Default::default(),
                tx_fee_sat: Default::default(),
            }
        }
    }
    impl Default for wire_cst_prepare_redeem_onchain_funds_response {
        fn default() -> Self {
            Self::new_with_null_ptr()
        }
    }
    impl NewWithNullPtr for wire_cst_prepare_refund_request {
        fn new_with_null_ptr() -> Self {
            Self {
                swap_address: core::ptr::null_mut(),
                to_address: core::ptr::null_mut(),
                sat_per_vbyte: Default::default(),
                unilateral: core::ptr::null_mut(),
            }
        }
    }
    impl Default for wire_cst_prepare_refund_request {
        fn default() -> Self {
            Self::new_with_null_ptr()
        }
    }
    impl NewWithNullPtr for wire_cst_prepare_refund_response {
        fn new_with_null_ptr() -> Self {
            Self {
                refund_tx_weight: Default::default(),
                refund_tx_fee_sat: Default::default(),
            }
        }
    }
    impl Default for wire_cst_prepare_refund_response {
        fn default() -> Self {
            Self::new_with_null_ptr()
        }
    }
    impl NewWithNullPtr for wire_cst_rate {
        fn new_with_null_ptr() -> Self {
            Self {
                coin: core::ptr::null_mut(),
                value: Default::default(),
            }
        }
    }
    impl Default for wire_cst_rate {
        fn default() -> Self {
            Self::new_with_null_ptr()
        }
    }
    impl NewWithNullPtr for wire_cst_receive_onchain_request {
        fn new_with_null_ptr() -> Self {
            Self {
                opening_fee_params: core::ptr::null_mut(),
            }
        }
    }
    impl Default for wire_cst_receive_onchain_request {
        fn default() -> Self {
            Self::new_with_null_ptr()
        }
    }
    impl NewWithNullPtr for wire_cst_receive_payment_request {
        fn new_with_null_ptr() -> Self {
            Self {
                amount_msat: Default::default(),
                description: core::ptr::null_mut(),
                preimage: core::ptr::null_mut(),
                opening_fee_params: core::ptr::null_mut(),
                use_description_hash: core::ptr::null_mut(),
                expiry: core::ptr::null_mut(),
                cltv: core::ptr::null_mut(),
            }
        }
    }
    impl Default for wire_cst_receive_payment_request {
        fn default() -> Self {
            Self::new_with_null_ptr()
        }
    }
    impl NewWithNullPtr for wire_cst_receive_payment_response {
        fn new_with_null_ptr() -> Self {
            Self {
                ln_invoice: Default::default(),
                opening_fee_params: core::ptr::null_mut(),
                opening_fee_msat: core::ptr::null_mut(),
            }
        }
    }
    impl Default for wire_cst_receive_payment_response {
        fn default() -> Self {
            Self::new_with_null_ptr()
        }
    }
    impl NewWithNullPtr for wire_cst_recommended_fees {
        fn new_with_null_ptr() -> Self {
            Self {
                fastest_fee: Default::default(),
                half_hour_fee: Default::default(),
                hour_fee: Default::default(),
                economy_fee: Default::default(),
                minimum_fee: Default::default(),
            }
        }
    }
    impl Default for wire_cst_recommended_fees {
        fn default() -> Self {
            Self::new_with_null_ptr()
        }
    }
    impl NewWithNullPtr for wire_cst_redeem_onchain_funds_request {
        fn new_with_null_ptr() -> Self {
            Self {
                to_address: core::ptr::null_mut(),
                sat_per_vbyte: Default::default(),
            }
        }
    }
    impl Default for wire_cst_redeem_onchain_funds_request {
        fn default() -> Self {
            Self::new_with_null_ptr()
        }
    }
    impl NewWithNullPtr for wire_cst_redeem_onchain_funds_response {
        fn new_with_null_ptr() -> Self {
            Self {
                txid: core::ptr::null_mut(),
            }
        }
    }
    impl Default for wire_cst_redeem_onchain_funds_response {
        fn default() -> Self {
            Self::new_with_null_ptr()
        }
    }
    impl NewWithNullPtr for wire_cst_refund_request {
        fn new_with_null_ptr() -> Self {
            Self {
                swap_address: core::ptr::null_mut(),
                to_address: core::ptr::null_mut(),
                sat_per_vbyte: Default::default(),
                unilateral: core::ptr::null_mut(),
            }
        }
    }
    impl Default for wire_cst_refund_request {
        fn default() -> Self {
            Self::new_with_null_ptr()
        }
    }
    impl NewWithNullPtr for wire_cst_refund_response {
        fn new_with_null_ptr() -> Self {
            Self {
                refund_tx_id: core::ptr::null_mut(),
            }
        }
    }
    impl Default for wire_cst_refund_response {
        fn default() -> Self {
            Self::new_with_null_ptr()
        }
    }
    impl NewWithNullPtr for wire_cst_report_issue_request {
        fn new_with_null_ptr() -> Self {
            Self {
                tag: -1,
                kind: ReportIssueRequestKind { nil__: () },
            }
        }
    }
    impl Default for wire_cst_report_issue_request {
        fn default() -> Self {
            Self::new_with_null_ptr()
        }
    }
    impl NewWithNullPtr for wire_cst_report_payment_failure_details {
        fn new_with_null_ptr() -> Self {
            Self {
                payment_hash: core::ptr::null_mut(),
                comment: core::ptr::null_mut(),
            }
        }
    }
    impl Default for wire_cst_report_payment_failure_details {
        fn default() -> Self {
            Self::new_with_null_ptr()
        }
    }
    impl NewWithNullPtr for wire_cst_reverse_swap_fees_request {
        fn new_with_null_ptr() -> Self {
            Self {
                send_amount_sat: core::ptr::null_mut(),
                claim_tx_feerate: core::ptr::null_mut(),
            }
        }
    }
    impl Default for wire_cst_reverse_swap_fees_request {
        fn default() -> Self {
            Self::new_with_null_ptr()
        }
    }
    impl NewWithNullPtr for wire_cst_reverse_swap_info {
        fn new_with_null_ptr() -> Self {
            Self {
                id: core::ptr::null_mut(),
                claim_pubkey: core::ptr::null_mut(),
                lockup_txid: core::ptr::null_mut(),
                claim_txid: core::ptr::null_mut(),
                onchain_amount_sat: Default::default(),
                status: Default::default(),
            }
        }
    }
    impl Default for wire_cst_reverse_swap_info {
        fn default() -> Self {
            Self::new_with_null_ptr()
        }
    }
    impl NewWithNullPtr for wire_cst_reverse_swap_pair_info {
        fn new_with_null_ptr() -> Self {
            Self {
                min: Default::default(),
                max: Default::default(),
                fees_hash: core::ptr::null_mut(),
                fees_percentage: Default::default(),
                fees_lockup: Default::default(),
                fees_claim: Default::default(),
                total_fees: core::ptr::null_mut(),
            }
        }
    }
    impl Default for wire_cst_reverse_swap_pair_info {
        fn default() -> Self {
            Self::new_with_null_ptr()
        }
    }
    impl NewWithNullPtr for wire_cst_route_hint {
        fn new_with_null_ptr() -> Self {
            Self {
                hops: core::ptr::null_mut(),
            }
        }
    }
    impl Default for wire_cst_route_hint {
        fn default() -> Self {
            Self::new_with_null_ptr()
        }
    }
    impl NewWithNullPtr for wire_cst_route_hint_hop {
        fn new_with_null_ptr() -> Self {
            Self {
                src_node_id: core::ptr::null_mut(),
                short_channel_id: core::ptr::null_mut(),
                fees_base_msat: Default::default(),
                fees_proportional_millionths: Default::default(),
                cltv_expiry_delta: Default::default(),
                htlc_minimum_msat: core::ptr::null_mut(),
                htlc_maximum_msat: core::ptr::null_mut(),
            }
        }
    }
    impl Default for wire_cst_route_hint_hop {
        fn default() -> Self {
            Self::new_with_null_ptr()
        }
    }
    impl NewWithNullPtr for wire_cst_send_payment_request {
        fn new_with_null_ptr() -> Self {
            Self {
                bolt11: core::ptr::null_mut(),
                use_trampoline: Default::default(),
                amount_msat: core::ptr::null_mut(),
                label: core::ptr::null_mut(),
            }
        }
    }
    impl Default for wire_cst_send_payment_request {
        fn default() -> Self {
            Self::new_with_null_ptr()
        }
    }
    impl NewWithNullPtr for wire_cst_send_payment_response {
        fn new_with_null_ptr() -> Self {
            Self {
                payment: Default::default(),
            }
        }
    }
    impl Default for wire_cst_send_payment_response {
        fn default() -> Self {
            Self::new_with_null_ptr()
        }
    }
    impl NewWithNullPtr for wire_cst_send_spontaneous_payment_request {
        fn new_with_null_ptr() -> Self {
            Self {
                node_id: core::ptr::null_mut(),
                amount_msat: Default::default(),
                extra_tlvs: core::ptr::null_mut(),
                label: core::ptr::null_mut(),
            }
        }
    }
    impl Default for wire_cst_send_spontaneous_payment_request {
        fn default() -> Self {
            Self::new_with_null_ptr()
        }
    }
    impl NewWithNullPtr for wire_cst_service_health_check_response {
        fn new_with_null_ptr() -> Self {
            Self {
                status: Default::default(),
            }
        }
    }
    impl Default for wire_cst_service_health_check_response {
        fn default() -> Self {
            Self::new_with_null_ptr()
        }
    }
    impl NewWithNullPtr for wire_cst_sign_message_request {
        fn new_with_null_ptr() -> Self {
            Self {
                message: core::ptr::null_mut(),
            }
        }
    }
    impl Default for wire_cst_sign_message_request {
        fn default() -> Self {
            Self::new_with_null_ptr()
        }
    }
    impl NewWithNullPtr for wire_cst_sign_message_response {
        fn new_with_null_ptr() -> Self {
            Self {
                signature: core::ptr::null_mut(),
            }
        }
    }
    impl Default for wire_cst_sign_message_response {
        fn default() -> Self {
            Self::new_with_null_ptr()
        }
    }
    impl NewWithNullPtr for wire_cst_static_backup_request {
        fn new_with_null_ptr() -> Self {
            Self {
                working_dir: core::ptr::null_mut(),
            }
        }
    }
    impl Default for wire_cst_static_backup_request {
        fn default() -> Self {
            Self::new_with_null_ptr()
        }
    }
    impl NewWithNullPtr for wire_cst_static_backup_response {
        fn new_with_null_ptr() -> Self {
            Self {
                backup: core::ptr::null_mut(),
            }
        }
    }
    impl Default for wire_cst_static_backup_response {
        fn default() -> Self {
            Self::new_with_null_ptr()
        }
    }
    impl NewWithNullPtr for wire_cst_success_action_processed {
        fn new_with_null_ptr() -> Self {
            Self {
                tag: -1,
                kind: SuccessActionProcessedKind { nil__: () },
            }
        }
    }
    impl Default for wire_cst_success_action_processed {
        fn default() -> Self {
            Self::new_with_null_ptr()
        }
    }
    impl NewWithNullPtr for wire_cst_swap_info {
        fn new_with_null_ptr() -> Self {
            Self {
                bitcoin_address: core::ptr::null_mut(),
                created_at: Default::default(),
                lock_height: Default::default(),
                payment_hash: core::ptr::null_mut(),
                preimage: core::ptr::null_mut(),
                private_key: core::ptr::null_mut(),
                public_key: core::ptr::null_mut(),
                swapper_public_key: core::ptr::null_mut(),
                script: core::ptr::null_mut(),
                bolt11: core::ptr::null_mut(),
                paid_msat: Default::default(),
                total_incoming_txs: Default::default(),
                confirmed_sats: Default::default(),
                unconfirmed_sats: Default::default(),
                status: Default::default(),
                refund_tx_ids: core::ptr::null_mut(),
                unconfirmed_tx_ids: core::ptr::null_mut(),
                confirmed_tx_ids: core::ptr::null_mut(),
                min_allowed_deposit: Default::default(),
                max_allowed_deposit: Default::default(),
                max_swapper_payable: Default::default(),
                last_redeem_error: core::ptr::null_mut(),
                channel_opening_fees: core::ptr::null_mut(),
                confirmed_at: core::ptr::null_mut(),
            }
        }
    }
    impl Default for wire_cst_swap_info {
        fn default() -> Self {
            Self::new_with_null_ptr()
        }
    }
    impl NewWithNullPtr for wire_cst_symbol {
        fn new_with_null_ptr() -> Self {
            Self {
                grapheme: core::ptr::null_mut(),
                template: core::ptr::null_mut(),
                rtl: core::ptr::null_mut(),
                position: core::ptr::null_mut(),
            }
        }
    }
    impl Default for wire_cst_symbol {
        fn default() -> Self {
            Self::new_with_null_ptr()
        }
    }
    impl NewWithNullPtr for wire_cst_tlv_entry {
        fn new_with_null_ptr() -> Self {
            Self {
                field_number: Default::default(),
                value: core::ptr::null_mut(),
            }
        }
    }
    impl Default for wire_cst_tlv_entry {
        fn default() -> Self {
            Self::new_with_null_ptr()
        }
    }
    impl NewWithNullPtr for wire_cst_unspent_transaction_output {
        fn new_with_null_ptr() -> Self {
            Self {
                txid: core::ptr::null_mut(),
                outnum: Default::default(),
                amount_millisatoshi: Default::default(),
                address: core::ptr::null_mut(),
                reserved: Default::default(),
            }
        }
    }
    impl Default for wire_cst_unspent_transaction_output {
        fn default() -> Self {
            Self::new_with_null_ptr()
        }
    }
    impl NewWithNullPtr for wire_cst_url_success_action_data {
        fn new_with_null_ptr() -> Self {
            Self {
                description: core::ptr::null_mut(),
                url: core::ptr::null_mut(),
                matches_callback_domain: Default::default(),
            }
        }
    }
    impl Default for wire_cst_url_success_action_data {
        fn default() -> Self {
            Self::new_with_null_ptr()
        }
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_wire__crate__binding__backup(port_: i64) {
        wire__crate__binding__backup_impl(port_)
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_wire__crate__binding__backup_status(port_: i64) {
        wire__crate__binding__backup_status_impl(port_)
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_wire__crate__binding__binding_event_listener_on_event(
        port_: i64,
        that: *mut wire_cst_binding_event_listener,
        e: *mut wire_cst_breez_event,
    ) {
        wire__crate__binding__binding_event_listener_on_event_impl(port_, that, e)
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_wire__crate__binding__breez_events_stream(
        port_: i64,
        s: *mut wire_cst_list_prim_u_8_strict,
    ) {
        wire__crate__binding__breez_events_stream_impl(port_, s)
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_wire__crate__binding__breez_log_stream(
        port_: i64,
        s: *mut wire_cst_list_prim_u_8_strict,
    ) {
        wire__crate__binding__breez_log_stream_impl(port_, s)
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_wire__crate__binding__buy_bitcoin(
        port_: i64,
        req: *mut wire_cst_buy_bitcoin_request,
    ) {
        wire__crate__binding__buy_bitcoin_impl(port_, req)
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_wire__crate__binding__check_message(
        port_: i64,
        req: *mut wire_cst_check_message_request,
    ) {
        wire__crate__binding__check_message_impl(port_, req)
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_wire__crate__binding__claim_reverse_swap(
        port_: i64,
        lockup_address: *mut wire_cst_list_prim_u_8_strict,
    ) {
        wire__crate__binding__claim_reverse_swap_impl(port_, lockup_address)
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_wire__crate__binding__close_lsp_channels(port_: i64) {
        wire__crate__binding__close_lsp_channels_impl(port_)
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_wire__crate__binding__configure_node(
        port_: i64,
        req: *mut wire_cst_configure_node_request,
    ) {
        wire__crate__binding__configure_node_impl(port_, req)
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_wire__crate__binding__connect(
        port_: i64,
        req: *mut wire_cst_connect_request,
    ) {
        wire__crate__binding__connect_impl(port_, req)
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_wire__crate__binding__connect_lsp(
        port_: i64,
        lsp_id: *mut wire_cst_list_prim_u_8_strict,
    ) {
        wire__crate__binding__connect_lsp_impl(port_, lsp_id)
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_wire__crate__binding__default_config(
        port_: i64,
        env_type: i32,
        api_key: *mut wire_cst_list_prim_u_8_strict,
        node_config: *mut wire_cst_node_config,
    ) {
        wire__crate__binding__default_config_impl(port_, env_type, api_key, node_config)
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_wire__crate__binding__disconnect(port_: i64) {
        wire__crate__binding__disconnect_impl(port_)
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_wire__crate__binding__execute_command(
        port_: i64,
        command: *mut wire_cst_list_prim_u_8_strict,
    ) {
        wire__crate__binding__execute_command_impl(port_, command)
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_wire__crate__binding__fetch_fiat_rates(port_: i64) {
        wire__crate__binding__fetch_fiat_rates_impl(port_)
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_wire__crate__binding__fetch_lsp_info(
        port_: i64,
        id: *mut wire_cst_list_prim_u_8_strict,
    ) {
        wire__crate__binding__fetch_lsp_info_impl(port_, id)
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_wire__crate__binding__fetch_reverse_swap_fees(
        port_: i64,
        req: *mut wire_cst_reverse_swap_fees_request,
    ) {
        wire__crate__binding__fetch_reverse_swap_fees_impl(port_, req)
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_wire__crate__binding__generate_diagnostic_data(port_: i64) {
        wire__crate__binding__generate_diagnostic_data_impl(port_)
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_wire__crate__binding__in_progress_onchain_payments(
        port_: i64,
    ) {
        wire__crate__binding__in_progress_onchain_payments_impl(port_)
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_wire__crate__binding__in_progress_swap(port_: i64) {
        wire__crate__binding__in_progress_swap_impl(port_)
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_wire__crate__binding__is_initialized(port_: i64) {
        wire__crate__binding__is_initialized_impl(port_)
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_wire__crate__binding__list_fiat_currencies(port_: i64) {
        wire__crate__binding__list_fiat_currencies_impl(port_)
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_wire__crate__binding__list_lsps(port_: i64) {
        wire__crate__binding__list_lsps_impl(port_)
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_wire__crate__binding__list_payments(
        port_: i64,
        req: *mut wire_cst_list_payments_request,
    ) {
        wire__crate__binding__list_payments_impl(port_, req)
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_wire__crate__binding__list_refundables(port_: i64) {
        wire__crate__binding__list_refundables_impl(port_)
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_wire__crate__binding__list_swaps(
        port_: i64,
        req: *mut wire_cst_list_swaps_request,
    ) {
        wire__crate__binding__list_swaps_impl(port_, req)
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_wire__crate__binding__lnurl_auth(
        port_: i64,
        req_data: *mut wire_cst_ln_url_auth_request_data,
    ) {
        wire__crate__binding__lnurl_auth_impl(port_, req_data)
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_wire__crate__binding__lnurl_pay(
        port_: i64,
        req: *mut wire_cst_ln_url_pay_request,
    ) {
        wire__crate__binding__lnurl_pay_impl(port_, req)
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_wire__crate__binding__lnurl_withdraw(
        port_: i64,
        req: *mut wire_cst_ln_url_withdraw_request,
    ) {
        wire__crate__binding__lnurl_withdraw_impl(port_, req)
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_wire__crate__binding__lsp_id(port_: i64) {
        wire__crate__binding__lsp_id_impl(port_)
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_wire__crate__binding__lsp_info(port_: i64) {
        wire__crate__binding__lsp_info_impl(port_)
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_wire__crate__binding__mnemonic_to_seed(
        port_: i64,
        phrase: *mut wire_cst_list_prim_u_8_strict,
    ) {
        wire__crate__binding__mnemonic_to_seed_impl(port_, phrase)
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_wire__crate__binding__node_credentials(port_: i64) {
        wire__crate__binding__node_credentials_impl(port_)
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_wire__crate__binding__node_info(port_: i64) {
        wire__crate__binding__node_info_impl(port_)
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_wire__crate__binding__onchain_payment_limits(port_: i64) {
        wire__crate__binding__onchain_payment_limits_impl(port_)
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_wire__crate__binding__open_channel_fee(
        port_: i64,
        req: *mut wire_cst_open_channel_fee_request,
    ) {
        wire__crate__binding__open_channel_fee_impl(port_, req)
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_wire__crate__binding__parse_input(
        port_: i64,
        input: *mut wire_cst_list_prim_u_8_strict,
    ) {
        wire__crate__binding__parse_input_impl(port_, input)
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_wire__crate__binding__parse_invoice(
        port_: i64,
        invoice: *mut wire_cst_list_prim_u_8_strict,
    ) {
        wire__crate__binding__parse_invoice_impl(port_, invoice)
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_wire__crate__binding__pay_onchain(
        port_: i64,
        req: *mut wire_cst_pay_onchain_request,
    ) {
        wire__crate__binding__pay_onchain_impl(port_, req)
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_wire__crate__binding__payment_by_hash(
        port_: i64,
        hash: *mut wire_cst_list_prim_u_8_strict,
    ) {
        wire__crate__binding__payment_by_hash_impl(port_, hash)
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_wire__crate__binding__prepare_onchain_payment(
        port_: i64,
        req: *mut wire_cst_prepare_onchain_payment_request,
    ) {
        wire__crate__binding__prepare_onchain_payment_impl(port_, req)
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_wire__crate__binding__prepare_redeem_onchain_funds(
        port_: i64,
        req: *mut wire_cst_prepare_redeem_onchain_funds_request,
    ) {
        wire__crate__binding__prepare_redeem_onchain_funds_impl(port_, req)
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_wire__crate__binding__prepare_refund(
        port_: i64,
        req: *mut wire_cst_prepare_refund_request,
    ) {
        wire__crate__binding__prepare_refund_impl(port_, req)
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_wire__crate__binding__receive_onchain(
        port_: i64,
        req: *mut wire_cst_receive_onchain_request,
    ) {
        wire__crate__binding__receive_onchain_impl(port_, req)
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_wire__crate__binding__receive_payment(
        port_: i64,
        req: *mut wire_cst_receive_payment_request,
    ) {
        wire__crate__binding__receive_payment_impl(port_, req)
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_wire__crate__binding__recommended_fees(port_: i64) {
        wire__crate__binding__recommended_fees_impl(port_)
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_wire__crate__binding__redeem_onchain_funds(
        port_: i64,
        req: *mut wire_cst_redeem_onchain_funds_request,
    ) {
        wire__crate__binding__redeem_onchain_funds_impl(port_, req)
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_wire__crate__binding__redeem_swap(
        port_: i64,
        swap_address: *mut wire_cst_list_prim_u_8_strict,
    ) {
        wire__crate__binding__redeem_swap_impl(port_, swap_address)
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_wire__crate__binding__refund(
        port_: i64,
        req: *mut wire_cst_refund_request,
    ) {
        wire__crate__binding__refund_impl(port_, req)
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_wire__crate__binding__register_webhook(
        port_: i64,
        webhook_url: *mut wire_cst_list_prim_u_8_strict,
    ) {
        wire__crate__binding__register_webhook_impl(port_, webhook_url)
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_wire__crate__binding__report_issue(
        port_: i64,
        req: *mut wire_cst_report_issue_request,
    ) {
        wire__crate__binding__report_issue_impl(port_, req)
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_wire__crate__binding__rescan_swaps(port_: i64) {
        wire__crate__binding__rescan_swaps_impl(port_)
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_wire__crate__binding__send_payment(
        port_: i64,
        req: *mut wire_cst_send_payment_request,
    ) {
        wire__crate__binding__send_payment_impl(port_, req)
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_wire__crate__binding__send_spontaneous_payment(
        port_: i64,
        req: *mut wire_cst_send_spontaneous_payment_request,
    ) {
        wire__crate__binding__send_spontaneous_payment_impl(port_, req)
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_wire__crate__binding__service_health_check(
        port_: i64,
        api_key: *mut wire_cst_list_prim_u_8_strict,
    ) {
        wire__crate__binding__service_health_check_impl(port_, api_key)
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_wire__crate__binding__set_payment_metadata(
        port_: i64,
        hash: *mut wire_cst_list_prim_u_8_strict,
        metadata: *mut wire_cst_list_prim_u_8_strict,
    ) {
        wire__crate__binding__set_payment_metadata_impl(port_, hash, metadata)
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_wire__crate__binding__sign_message(
        port_: i64,
        req: *mut wire_cst_sign_message_request,
    ) {
        wire__crate__binding__sign_message_impl(port_, req)
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_wire__crate__binding__static_backup(
        port_: i64,
        req: *mut wire_cst_static_backup_request,
    ) {
        wire__crate__binding__static_backup_impl(port_, req)
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_wire__crate__binding__sync(port_: i64) {
        wire__crate__binding__sync_impl(port_)
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_wire__crate__binding__unregister_webhook(
        port_: i64,
        webhook_url: *mut wire_cst_list_prim_u_8_strict,
    ) {
        wire__crate__binding__unregister_webhook_impl(port_, webhook_url)
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_cst_new_box_autoadd_aes_success_action_data_decrypted(
    ) -> *mut wire_cst_aes_success_action_data_decrypted {
        flutter_rust_bridge::for_generated::new_leak_box_ptr(
            wire_cst_aes_success_action_data_decrypted::new_with_null_ptr(),
        )
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_cst_new_box_autoadd_aes_success_action_data_result(
    ) -> *mut wire_cst_aes_success_action_data_result {
        flutter_rust_bridge::for_generated::new_leak_box_ptr(
            wire_cst_aes_success_action_data_result::new_with_null_ptr(),
        )
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_cst_new_box_autoadd_backup_failed_data(
    ) -> *mut wire_cst_backup_failed_data {
        flutter_rust_bridge::for_generated::new_leak_box_ptr(
            wire_cst_backup_failed_data::new_with_null_ptr(),
        )
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_cst_new_box_autoadd_binding_event_listener(
    ) -> *mut wire_cst_binding_event_listener {
        flutter_rust_bridge::for_generated::new_leak_box_ptr(
            wire_cst_binding_event_listener::new_with_null_ptr(),
        )
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_cst_new_box_autoadd_bitcoin_address_data(
    ) -> *mut wire_cst_bitcoin_address_data {
        flutter_rust_bridge::for_generated::new_leak_box_ptr(
            wire_cst_bitcoin_address_data::new_with_null_ptr(),
        )
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_cst_new_box_autoadd_bool(value: bool) -> *mut bool {
        flutter_rust_bridge::for_generated::new_leak_box_ptr(value)
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_cst_new_box_autoadd_breez_event() -> *mut wire_cst_breez_event
    {
        flutter_rust_bridge::for_generated::new_leak_box_ptr(
            wire_cst_breez_event::new_with_null_ptr(),
        )
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_cst_new_box_autoadd_buy_bitcoin_request(
    ) -> *mut wire_cst_buy_bitcoin_request {
        flutter_rust_bridge::for_generated::new_leak_box_ptr(
            wire_cst_buy_bitcoin_request::new_with_null_ptr(),
        )
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_cst_new_box_autoadd_check_message_request(
    ) -> *mut wire_cst_check_message_request {
        flutter_rust_bridge::for_generated::new_leak_box_ptr(
            wire_cst_check_message_request::new_with_null_ptr(),
        )
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_cst_new_box_autoadd_closed_channel_payment_details(
    ) -> *mut wire_cst_closed_channel_payment_details {
        flutter_rust_bridge::for_generated::new_leak_box_ptr(
            wire_cst_closed_channel_payment_details::new_with_null_ptr(),
        )
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_cst_new_box_autoadd_configure_node_request(
    ) -> *mut wire_cst_configure_node_request {
        flutter_rust_bridge::for_generated::new_leak_box_ptr(
            wire_cst_configure_node_request::new_with_null_ptr(),
        )
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_cst_new_box_autoadd_connect_request(
    ) -> *mut wire_cst_connect_request {
        flutter_rust_bridge::for_generated::new_leak_box_ptr(
            wire_cst_connect_request::new_with_null_ptr(),
        )
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_cst_new_box_autoadd_greenlight_credentials(
    ) -> *mut wire_cst_greenlight_credentials {
        flutter_rust_bridge::for_generated::new_leak_box_ptr(
            wire_cst_greenlight_credentials::new_with_null_ptr(),
        )
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_cst_new_box_autoadd_greenlight_device_credentials(
    ) -> *mut wire_cst_greenlight_device_credentials {
        flutter_rust_bridge::for_generated::new_leak_box_ptr(
            wire_cst_greenlight_device_credentials::new_with_null_ptr(),
        )
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_cst_new_box_autoadd_greenlight_node_config(
    ) -> *mut wire_cst_greenlight_node_config {
        flutter_rust_bridge::for_generated::new_leak_box_ptr(
            wire_cst_greenlight_node_config::new_with_null_ptr(),
        )
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_cst_new_box_autoadd_i_64(value: i64) -> *mut i64 {
        flutter_rust_bridge::for_generated::new_leak_box_ptr(value)
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_cst_new_box_autoadd_invoice_paid_details(
    ) -> *mut wire_cst_invoice_paid_details {
        flutter_rust_bridge::for_generated::new_leak_box_ptr(
            wire_cst_invoice_paid_details::new_with_null_ptr(),
        )
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_cst_new_box_autoadd_list_payments_request(
    ) -> *mut wire_cst_list_payments_request {
        flutter_rust_bridge::for_generated::new_leak_box_ptr(
            wire_cst_list_payments_request::new_with_null_ptr(),
        )
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_cst_new_box_autoadd_list_swaps_request(
    ) -> *mut wire_cst_list_swaps_request {
        flutter_rust_bridge::for_generated::new_leak_box_ptr(
            wire_cst_list_swaps_request::new_with_null_ptr(),
        )
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_cst_new_box_autoadd_ln_invoice() -> *mut wire_cst_ln_invoice
    {
        flutter_rust_bridge::for_generated::new_leak_box_ptr(
            wire_cst_ln_invoice::new_with_null_ptr(),
        )
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_cst_new_box_autoadd_ln_payment_details(
    ) -> *mut wire_cst_ln_payment_details {
        flutter_rust_bridge::for_generated::new_leak_box_ptr(
            wire_cst_ln_payment_details::new_with_null_ptr(),
        )
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_cst_new_box_autoadd_ln_url_auth_request_data(
    ) -> *mut wire_cst_ln_url_auth_request_data {
        flutter_rust_bridge::for_generated::new_leak_box_ptr(
            wire_cst_ln_url_auth_request_data::new_with_null_ptr(),
        )
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_cst_new_box_autoadd_ln_url_error_data(
    ) -> *mut wire_cst_ln_url_error_data {
        flutter_rust_bridge::for_generated::new_leak_box_ptr(
            wire_cst_ln_url_error_data::new_with_null_ptr(),
        )
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_cst_new_box_autoadd_ln_url_pay_error_data(
    ) -> *mut wire_cst_ln_url_pay_error_data {
        flutter_rust_bridge::for_generated::new_leak_box_ptr(
            wire_cst_ln_url_pay_error_data::new_with_null_ptr(),
        )
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_cst_new_box_autoadd_ln_url_pay_request(
    ) -> *mut wire_cst_ln_url_pay_request {
        flutter_rust_bridge::for_generated::new_leak_box_ptr(
            wire_cst_ln_url_pay_request::new_with_null_ptr(),
        )
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_cst_new_box_autoadd_ln_url_pay_request_data(
    ) -> *mut wire_cst_ln_url_pay_request_data {
        flutter_rust_bridge::for_generated::new_leak_box_ptr(
            wire_cst_ln_url_pay_request_data::new_with_null_ptr(),
        )
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_cst_new_box_autoadd_ln_url_pay_success_data(
    ) -> *mut wire_cst_ln_url_pay_success_data {
        flutter_rust_bridge::for_generated::new_leak_box_ptr(
            wire_cst_ln_url_pay_success_data::new_with_null_ptr(),
        )
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_cst_new_box_autoadd_ln_url_withdraw_request(
    ) -> *mut wire_cst_ln_url_withdraw_request {
        flutter_rust_bridge::for_generated::new_leak_box_ptr(
            wire_cst_ln_url_withdraw_request::new_with_null_ptr(),
        )
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_cst_new_box_autoadd_ln_url_withdraw_request_data(
    ) -> *mut wire_cst_ln_url_withdraw_request_data {
        flutter_rust_bridge::for_generated::new_leak_box_ptr(
            wire_cst_ln_url_withdraw_request_data::new_with_null_ptr(),
        )
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_cst_new_box_autoadd_ln_url_withdraw_success_data(
    ) -> *mut wire_cst_ln_url_withdraw_success_data {
        flutter_rust_bridge::for_generated::new_leak_box_ptr(
            wire_cst_ln_url_withdraw_success_data::new_with_null_ptr(),
        )
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_cst_new_box_autoadd_lsp_information(
    ) -> *mut wire_cst_lsp_information {
        flutter_rust_bridge::for_generated::new_leak_box_ptr(
            wire_cst_lsp_information::new_with_null_ptr(),
        )
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_cst_new_box_autoadd_message_success_action_data(
    ) -> *mut wire_cst_message_success_action_data {
        flutter_rust_bridge::for_generated::new_leak_box_ptr(
            wire_cst_message_success_action_data::new_with_null_ptr(),
        )
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_cst_new_box_autoadd_node_config() -> *mut wire_cst_node_config
    {
        flutter_rust_bridge::for_generated::new_leak_box_ptr(
            wire_cst_node_config::new_with_null_ptr(),
        )
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_cst_new_box_autoadd_node_credentials(
    ) -> *mut wire_cst_node_credentials {
        flutter_rust_bridge::for_generated::new_leak_box_ptr(
            wire_cst_node_credentials::new_with_null_ptr(),
        )
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_cst_new_box_autoadd_open_channel_fee_request(
    ) -> *mut wire_cst_open_channel_fee_request {
        flutter_rust_bridge::for_generated::new_leak_box_ptr(
            wire_cst_open_channel_fee_request::new_with_null_ptr(),
        )
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_cst_new_box_autoadd_opening_fee_params(
    ) -> *mut wire_cst_opening_fee_params {
        flutter_rust_bridge::for_generated::new_leak_box_ptr(
            wire_cst_opening_fee_params::new_with_null_ptr(),
        )
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_cst_new_box_autoadd_pay_onchain_request(
    ) -> *mut wire_cst_pay_onchain_request {
        flutter_rust_bridge::for_generated::new_leak_box_ptr(
            wire_cst_pay_onchain_request::new_with_null_ptr(),
        )
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_cst_new_box_autoadd_payment() -> *mut wire_cst_payment {
        flutter_rust_bridge::for_generated::new_leak_box_ptr(wire_cst_payment::new_with_null_ptr())
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_cst_new_box_autoadd_payment_failed_data(
    ) -> *mut wire_cst_payment_failed_data {
        flutter_rust_bridge::for_generated::new_leak_box_ptr(
            wire_cst_payment_failed_data::new_with_null_ptr(),
        )
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_cst_new_box_autoadd_prepare_onchain_payment_request(
    ) -> *mut wire_cst_prepare_onchain_payment_request {
        flutter_rust_bridge::for_generated::new_leak_box_ptr(
            wire_cst_prepare_onchain_payment_request::new_with_null_ptr(),
        )
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_cst_new_box_autoadd_prepare_redeem_onchain_funds_request(
    ) -> *mut wire_cst_prepare_redeem_onchain_funds_request {
        flutter_rust_bridge::for_generated::new_leak_box_ptr(
            wire_cst_prepare_redeem_onchain_funds_request::new_with_null_ptr(),
        )
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_cst_new_box_autoadd_prepare_refund_request(
    ) -> *mut wire_cst_prepare_refund_request {
        flutter_rust_bridge::for_generated::new_leak_box_ptr(
            wire_cst_prepare_refund_request::new_with_null_ptr(),
        )
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_cst_new_box_autoadd_receive_onchain_request(
    ) -> *mut wire_cst_receive_onchain_request {
        flutter_rust_bridge::for_generated::new_leak_box_ptr(
            wire_cst_receive_onchain_request::new_with_null_ptr(),
        )
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_cst_new_box_autoadd_receive_payment_request(
    ) -> *mut wire_cst_receive_payment_request {
        flutter_rust_bridge::for_generated::new_leak_box_ptr(
            wire_cst_receive_payment_request::new_with_null_ptr(),
        )
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_cst_new_box_autoadd_redeem_onchain_funds_request(
    ) -> *mut wire_cst_redeem_onchain_funds_request {
        flutter_rust_bridge::for_generated::new_leak_box_ptr(
            wire_cst_redeem_onchain_funds_request::new_with_null_ptr(),
        )
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_cst_new_box_autoadd_refund_request(
    ) -> *mut wire_cst_refund_request {
        flutter_rust_bridge::for_generated::new_leak_box_ptr(
            wire_cst_refund_request::new_with_null_ptr(),
        )
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_cst_new_box_autoadd_report_issue_request(
    ) -> *mut wire_cst_report_issue_request {
        flutter_rust_bridge::for_generated::new_leak_box_ptr(
            wire_cst_report_issue_request::new_with_null_ptr(),
        )
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_cst_new_box_autoadd_report_payment_failure_details(
    ) -> *mut wire_cst_report_payment_failure_details {
        flutter_rust_bridge::for_generated::new_leak_box_ptr(
            wire_cst_report_payment_failure_details::new_with_null_ptr(),
        )
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_cst_new_box_autoadd_reverse_swap_fees_request(
    ) -> *mut wire_cst_reverse_swap_fees_request {
        flutter_rust_bridge::for_generated::new_leak_box_ptr(
            wire_cst_reverse_swap_fees_request::new_with_null_ptr(),
        )
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_cst_new_box_autoadd_reverse_swap_info(
    ) -> *mut wire_cst_reverse_swap_info {
        flutter_rust_bridge::for_generated::new_leak_box_ptr(
            wire_cst_reverse_swap_info::new_with_null_ptr(),
        )
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_cst_new_box_autoadd_send_payment_request(
    ) -> *mut wire_cst_send_payment_request {
        flutter_rust_bridge::for_generated::new_leak_box_ptr(
            wire_cst_send_payment_request::new_with_null_ptr(),
        )
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_cst_new_box_autoadd_send_spontaneous_payment_request(
    ) -> *mut wire_cst_send_spontaneous_payment_request {
        flutter_rust_bridge::for_generated::new_leak_box_ptr(
            wire_cst_send_spontaneous_payment_request::new_with_null_ptr(),
        )
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_cst_new_box_autoadd_sign_message_request(
    ) -> *mut wire_cst_sign_message_request {
        flutter_rust_bridge::for_generated::new_leak_box_ptr(
            wire_cst_sign_message_request::new_with_null_ptr(),
        )
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_cst_new_box_autoadd_static_backup_request(
    ) -> *mut wire_cst_static_backup_request {
        flutter_rust_bridge::for_generated::new_leak_box_ptr(
            wire_cst_static_backup_request::new_with_null_ptr(),
        )
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_cst_new_box_autoadd_success_action_processed(
    ) -> *mut wire_cst_success_action_processed {
        flutter_rust_bridge::for_generated::new_leak_box_ptr(
            wire_cst_success_action_processed::new_with_null_ptr(),
        )
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_cst_new_box_autoadd_swap_info() -> *mut wire_cst_swap_info {
        flutter_rust_bridge::for_generated::new_leak_box_ptr(wire_cst_swap_info::new_with_null_ptr())
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_cst_new_box_autoadd_symbol() -> *mut wire_cst_symbol {
        flutter_rust_bridge::for_generated::new_leak_box_ptr(wire_cst_symbol::new_with_null_ptr())
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_cst_new_box_autoadd_u_32(value: u32) -> *mut u32 {
        flutter_rust_bridge::for_generated::new_leak_box_ptr(value)
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_cst_new_box_autoadd_u_64(value: u64) -> *mut u64 {
        flutter_rust_bridge::for_generated::new_leak_box_ptr(value)
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_cst_new_box_autoadd_url_success_action_data(
    ) -> *mut wire_cst_url_success_action_data {
        flutter_rust_bridge::for_generated::new_leak_box_ptr(
            wire_cst_url_success_action_data::new_with_null_ptr(),
        )
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_cst_new_list_String(len: i32) -> *mut wire_cst_list_String {
        let wrap = wire_cst_list_String {
            ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
                <*mut wire_cst_list_prim_u_8_strict>::new_with_null_ptr(),
                len,
            ),
            len,
        };
        flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_cst_new_list_fiat_currency(
        len: i32,
    ) -> *mut wire_cst_list_fiat_currency {
        let wrap = wire_cst_list_fiat_currency {
            ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
                <wire_cst_fiat_currency>::new_with_null_ptr(),
                len,
            ),
            len,
        };
        flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_cst_new_list_locale_overrides(
        len: i32,
    ) -> *mut wire_cst_list_locale_overrides {
        let wrap = wire_cst_list_locale_overrides {
            ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
                <wire_cst_locale_overrides>::new_with_null_ptr(),
                len,
            ),
            len,
        };
        flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_cst_new_list_localized_name(
        len: i32,
    ) -> *mut wire_cst_list_localized_name {
        let wrap = wire_cst_list_localized_name {
            ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
                <wire_cst_localized_name>::new_with_null_ptr(),
                len,
            ),
            len,
        };
        flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_cst_new_list_lsp_information(
        len: i32,
    ) -> *mut wire_cst_list_lsp_information {
        let wrap = wire_cst_list_lsp_information {
            ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
                <wire_cst_lsp_information>::new_with_null_ptr(),
                len,
            ),
            len,
        };
        flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_cst_new_list_metadata_filter(
        len: i32,
    ) -> *mut wire_cst_list_metadata_filter {
        let wrap = wire_cst_list_metadata_filter {
            ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
                <wire_cst_metadata_filter>::new_with_null_ptr(),
                len,
            ),
            len,
        };
        flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_cst_new_list_opening_fee_params(
        len: i32,
    ) -> *mut wire_cst_list_opening_fee_params {
        let wrap = wire_cst_list_opening_fee_params {
            ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
                <wire_cst_opening_fee_params>::new_with_null_ptr(),
                len,
            ),
            len,
        };
        flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_cst_new_list_payment(
        len: i32,
    ) -> *mut wire_cst_list_payment {
        let wrap = wire_cst_list_payment {
            ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
                <wire_cst_payment>::new_with_null_ptr(),
                len,
            ),
            len,
        };
        flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_cst_new_list_payment_type_filter(
        len: i32,
    ) -> *mut wire_cst_list_payment_type_filter {
        let wrap = wire_cst_list_payment_type_filter {
            ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(Default::default(), len),
            len,
        };
        flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_cst_new_list_prim_u_8_strict(
        len: i32,
    ) -> *mut wire_cst_list_prim_u_8_strict {
        let ans = wire_cst_list_prim_u_8_strict {
            ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(Default::default(), len),
            len,
        };
        flutter_rust_bridge::for_generated::new_leak_box_ptr(ans)
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_cst_new_list_rate(len: i32) -> *mut wire_cst_list_rate {
        let wrap = wire_cst_list_rate {
            ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
                <wire_cst_rate>::new_with_null_ptr(),
                len,
            ),
            len,
        };
        flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_cst_new_list_reverse_swap_info(
        len: i32,
    ) -> *mut wire_cst_list_reverse_swap_info {
        let wrap = wire_cst_list_reverse_swap_info {
            ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
                <wire_cst_reverse_swap_info>::new_with_null_ptr(),
                len,
            ),
            len,
        };
        flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_cst_new_list_route_hint(
        len: i32,
    ) -> *mut wire_cst_list_route_hint {
        let wrap = wire_cst_list_route_hint {
            ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
                <wire_cst_route_hint>::new_with_null_ptr(),
                len,
            ),
            len,
        };
        flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_cst_new_list_route_hint_hop(
        len: i32,
    ) -> *mut wire_cst_list_route_hint_hop {
        let wrap = wire_cst_list_route_hint_hop {
            ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
                <wire_cst_route_hint_hop>::new_with_null_ptr(),
                len,
            ),
            len,
        };
        flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_cst_new_list_swap_info(
        len: i32,
    ) -> *mut wire_cst_list_swap_info {
        let wrap = wire_cst_list_swap_info {
            ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
                <wire_cst_swap_info>::new_with_null_ptr(),
                len,
            ),
            len,
        };
        flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_cst_new_list_swap_status(
        len: i32,
    ) -> *mut wire_cst_list_swap_status {
        let wrap = wire_cst_list_swap_status {
            ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(Default::default(), len),
            len,
        };
        flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_cst_new_list_tlv_entry(
        len: i32,
    ) -> *mut wire_cst_list_tlv_entry {
        let wrap = wire_cst_list_tlv_entry {
            ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
                <wire_cst_tlv_entry>::new_with_null_ptr(),
                len,
            ),
            len,
        };
        flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
    }

    #[unsafe(no_mangle)]
    pub extern "C" fn frbgen_breez_sdk_cst_new_list_unspent_transaction_output(
        len: i32,
    ) -> *mut wire_cst_list_unspent_transaction_output {
        let wrap = wire_cst_list_unspent_transaction_output {
            ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
                <wire_cst_unspent_transaction_output>::new_with_null_ptr(),
                len,
            ),
            len,
        };
        flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
    }

    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_aes_success_action_data_decrypted {
        description: *mut wire_cst_list_prim_u_8_strict,
        plaintext: *mut wire_cst_list_prim_u_8_strict,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_aes_success_action_data_result {
        tag: i32,
        kind: AesSuccessActionDataResultKind,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub union AesSuccessActionDataResultKind {
        Decrypted: wire_cst_AesSuccessActionDataResult_Decrypted,
        ErrorStatus: wire_cst_AesSuccessActionDataResult_ErrorStatus,
        nil__: (),
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_AesSuccessActionDataResult_Decrypted {
        data: *mut wire_cst_aes_success_action_data_decrypted,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_AesSuccessActionDataResult_ErrorStatus {
        reason: *mut wire_cst_list_prim_u_8_strict,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_backup_failed_data {
        error: *mut wire_cst_list_prim_u_8_strict,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_backup_status {
        backed_up: bool,
        last_backup_time: *mut u64,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_binding_event_listener {}
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_bitcoin_address_data {
        address: *mut wire_cst_list_prim_u_8_strict,
        network: i32,
        amount_sat: *mut u64,
        label: *mut wire_cst_list_prim_u_8_strict,
        message: *mut wire_cst_list_prim_u_8_strict,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_breez_event {
        tag: i32,
        kind: BreezEventKind,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub union BreezEventKind {
        NewBlock: wire_cst_BreezEvent_NewBlock,
        InvoicePaid: wire_cst_BreezEvent_InvoicePaid,
        PaymentSucceed: wire_cst_BreezEvent_PaymentSucceed,
        PaymentFailed: wire_cst_BreezEvent_PaymentFailed,
        BackupFailed: wire_cst_BreezEvent_BackupFailed,
        ReverseSwapUpdated: wire_cst_BreezEvent_ReverseSwapUpdated,
        SwapUpdated: wire_cst_BreezEvent_SwapUpdated,
        nil__: (),
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_BreezEvent_NewBlock {
        block: u32,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_BreezEvent_InvoicePaid {
        details: *mut wire_cst_invoice_paid_details,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_BreezEvent_PaymentSucceed {
        details: *mut wire_cst_payment,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_BreezEvent_PaymentFailed {
        details: *mut wire_cst_payment_failed_data,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_BreezEvent_BackupFailed {
        details: *mut wire_cst_backup_failed_data,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_BreezEvent_ReverseSwapUpdated {
        details: *mut wire_cst_reverse_swap_info,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_BreezEvent_SwapUpdated {
        details: *mut wire_cst_swap_info,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_buy_bitcoin_request {
        provider: i32,
        opening_fee_params: *mut wire_cst_opening_fee_params,
        redirect_url: *mut wire_cst_list_prim_u_8_strict,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_buy_bitcoin_response {
        url: *mut wire_cst_list_prim_u_8_strict,
        opening_fee_params: *mut wire_cst_opening_fee_params,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_check_message_request {
        message: *mut wire_cst_list_prim_u_8_strict,
        pubkey: *mut wire_cst_list_prim_u_8_strict,
        signature: *mut wire_cst_list_prim_u_8_strict,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_check_message_response {
        is_valid: bool,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_closed_channel_payment_details {
        state: i32,
        funding_txid: *mut wire_cst_list_prim_u_8_strict,
        short_channel_id: *mut wire_cst_list_prim_u_8_strict,
        closing_txid: *mut wire_cst_list_prim_u_8_strict,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_config {
        breezserver: *mut wire_cst_list_prim_u_8_strict,
        chainnotifier_url: *mut wire_cst_list_prim_u_8_strict,
        mempoolspace_url: *mut wire_cst_list_prim_u_8_strict,
        working_dir: *mut wire_cst_list_prim_u_8_strict,
        network: i32,
        payment_timeout_sec: u32,
        default_lsp_id: *mut wire_cst_list_prim_u_8_strict,
        api_key: *mut wire_cst_list_prim_u_8_strict,
        maxfee_percent: f64,
        exemptfee_msat: u64,
        node_config: wire_cst_node_config,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_configure_node_request {
        close_to_address: *mut wire_cst_list_prim_u_8_strict,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_connect_request {
        config: wire_cst_config,
        seed: *mut wire_cst_list_prim_u_8_strict,
        restore_only: *mut bool,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_currency_info {
        name: *mut wire_cst_list_prim_u_8_strict,
        fraction_size: u32,
        spacing: *mut u32,
        symbol: *mut wire_cst_symbol,
        uniq_symbol: *mut wire_cst_symbol,
        localized_name: *mut wire_cst_list_localized_name,
        locale_overrides: *mut wire_cst_list_locale_overrides,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_fiat_currency {
        id: *mut wire_cst_list_prim_u_8_strict,
        info: wire_cst_currency_info,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_greenlight_credentials {
        developer_key: *mut wire_cst_list_prim_u_8_strict,
        developer_cert: *mut wire_cst_list_prim_u_8_strict,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_greenlight_device_credentials {
        device: *mut wire_cst_list_prim_u_8_strict,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_greenlight_node_config {
        partner_credentials: *mut wire_cst_greenlight_credentials,
        invite_code: *mut wire_cst_list_prim_u_8_strict,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_input_type {
        tag: i32,
        kind: InputTypeKind,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub union InputTypeKind {
        BitcoinAddress: wire_cst_InputType_BitcoinAddress,
        Bolt11: wire_cst_InputType_Bolt11,
        NodeId: wire_cst_InputType_NodeId,
        Url: wire_cst_InputType_Url,
        LnUrlPay: wire_cst_InputType_LnUrlPay,
        LnUrlWithdraw: wire_cst_InputType_LnUrlWithdraw,
        LnUrlAuth: wire_cst_InputType_LnUrlAuth,
        LnUrlError: wire_cst_InputType_LnUrlError,
        nil__: (),
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_InputType_BitcoinAddress {
        address: *mut wire_cst_bitcoin_address_data,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_InputType_Bolt11 {
        invoice: *mut wire_cst_ln_invoice,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_InputType_NodeId {
        node_id: *mut wire_cst_list_prim_u_8_strict,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_InputType_Url {
        url: *mut wire_cst_list_prim_u_8_strict,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_InputType_LnUrlPay {
        data: *mut wire_cst_ln_url_pay_request_data,
        bip353_address: *mut wire_cst_list_prim_u_8_strict,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_InputType_LnUrlWithdraw {
        data: *mut wire_cst_ln_url_withdraw_request_data,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_InputType_LnUrlAuth {
        data: *mut wire_cst_ln_url_auth_request_data,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_InputType_LnUrlError {
        data: *mut wire_cst_ln_url_error_data,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_invoice_paid_details {
        payment_hash: *mut wire_cst_list_prim_u_8_strict,
        bolt11: *mut wire_cst_list_prim_u_8_strict,
        payment: *mut wire_cst_payment,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_list_String {
        ptr: *mut *mut wire_cst_list_prim_u_8_strict,
        len: i32,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_list_fiat_currency {
        ptr: *mut wire_cst_fiat_currency,
        len: i32,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_list_locale_overrides {
        ptr: *mut wire_cst_locale_overrides,
        len: i32,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_list_localized_name {
        ptr: *mut wire_cst_localized_name,
        len: i32,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_list_lsp_information {
        ptr: *mut wire_cst_lsp_information,
        len: i32,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_list_metadata_filter {
        ptr: *mut wire_cst_metadata_filter,
        len: i32,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_list_opening_fee_params {
        ptr: *mut wire_cst_opening_fee_params,
        len: i32,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_list_payment {
        ptr: *mut wire_cst_payment,
        len: i32,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_list_payment_type_filter {
        ptr: *mut i32,
        len: i32,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_list_payments_request {
        filters: *mut wire_cst_list_payment_type_filter,
        metadata_filters: *mut wire_cst_list_metadata_filter,
        from_timestamp: *mut i64,
        to_timestamp: *mut i64,
        include_failures: *mut bool,
        offset: *mut u32,
        limit: *mut u32,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_list_prim_u_8_strict {
        ptr: *mut u8,
        len: i32,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_list_rate {
        ptr: *mut wire_cst_rate,
        len: i32,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_list_reverse_swap_info {
        ptr: *mut wire_cst_reverse_swap_info,
        len: i32,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_list_route_hint {
        ptr: *mut wire_cst_route_hint,
        len: i32,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_list_route_hint_hop {
        ptr: *mut wire_cst_route_hint_hop,
        len: i32,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_list_swap_info {
        ptr: *mut wire_cst_swap_info,
        len: i32,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_list_swap_status {
        ptr: *mut i32,
        len: i32,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_list_swaps_request {
        status: *mut wire_cst_list_swap_status,
        from_timestamp: *mut i64,
        to_timestamp: *mut i64,
        offset: *mut u32,
        limit: *mut u32,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_list_tlv_entry {
        ptr: *mut wire_cst_tlv_entry,
        len: i32,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_list_unspent_transaction_output {
        ptr: *mut wire_cst_unspent_transaction_output,
        len: i32,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_ln_invoice {
        bolt11: *mut wire_cst_list_prim_u_8_strict,
        network: i32,
        payee_pubkey: *mut wire_cst_list_prim_u_8_strict,
        payment_hash: *mut wire_cst_list_prim_u_8_strict,
        description: *mut wire_cst_list_prim_u_8_strict,
        description_hash: *mut wire_cst_list_prim_u_8_strict,
        amount_msat: *mut u64,
        timestamp: u64,
        expiry: u64,
        routing_hints: *mut wire_cst_list_route_hint,
        payment_secret: *mut wire_cst_list_prim_u_8_strict,
        min_final_cltv_expiry_delta: u64,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_ln_payment_details {
        payment_hash: *mut wire_cst_list_prim_u_8_strict,
        label: *mut wire_cst_list_prim_u_8_strict,
        destination_pubkey: *mut wire_cst_list_prim_u_8_strict,
        payment_preimage: *mut wire_cst_list_prim_u_8_strict,
        keysend: bool,
        bolt11: *mut wire_cst_list_prim_u_8_strict,
        open_channel_bolt11: *mut wire_cst_list_prim_u_8_strict,
        lnurl_success_action: *mut wire_cst_success_action_processed,
        lnurl_pay_domain: *mut wire_cst_list_prim_u_8_strict,
        lnurl_pay_comment: *mut wire_cst_list_prim_u_8_strict,
        ln_address: *mut wire_cst_list_prim_u_8_strict,
        lnurl_metadata: *mut wire_cst_list_prim_u_8_strict,
        lnurl_withdraw_endpoint: *mut wire_cst_list_prim_u_8_strict,
        swap_info: *mut wire_cst_swap_info,
        reverse_swap_info: *mut wire_cst_reverse_swap_info,
        pending_expiration_block: *mut u32,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_ln_url_auth_request_data {
        k1: *mut wire_cst_list_prim_u_8_strict,
        action: *mut wire_cst_list_prim_u_8_strict,
        domain: *mut wire_cst_list_prim_u_8_strict,
        url: *mut wire_cst_list_prim_u_8_strict,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_ln_url_callback_status {
        tag: i32,
        kind: LnUrlCallbackStatusKind,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub union LnUrlCallbackStatusKind {
        ErrorStatus: wire_cst_LnUrlCallbackStatus_ErrorStatus,
        nil__: (),
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_LnUrlCallbackStatus_ErrorStatus {
        data: *mut wire_cst_ln_url_error_data,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_ln_url_error_data {
        reason: *mut wire_cst_list_prim_u_8_strict,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_ln_url_pay_error_data {
        payment_hash: *mut wire_cst_list_prim_u_8_strict,
        reason: *mut wire_cst_list_prim_u_8_strict,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_ln_url_pay_request {
        data: wire_cst_ln_url_pay_request_data,
        amount_msat: u64,
        use_trampoline: bool,
        comment: *mut wire_cst_list_prim_u_8_strict,
        payment_label: *mut wire_cst_list_prim_u_8_strict,
        validate_success_action_url: *mut bool,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_ln_url_pay_request_data {
        callback: *mut wire_cst_list_prim_u_8_strict,
        min_sendable: u64,
        max_sendable: u64,
        metadata_str: *mut wire_cst_list_prim_u_8_strict,
        comment_allowed: u16,
        domain: *mut wire_cst_list_prim_u_8_strict,
        allows_nostr: bool,
        nostr_pubkey: *mut wire_cst_list_prim_u_8_strict,
        ln_address: *mut wire_cst_list_prim_u_8_strict,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_ln_url_pay_result {
        tag: i32,
        kind: LnUrlPayResultKind,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub union LnUrlPayResultKind {
        EndpointSuccess: wire_cst_LnUrlPayResult_EndpointSuccess,
        EndpointError: wire_cst_LnUrlPayResult_EndpointError,
        PayError: wire_cst_LnUrlPayResult_PayError,
        nil__: (),
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_LnUrlPayResult_EndpointSuccess {
        data: *mut wire_cst_ln_url_pay_success_data,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_LnUrlPayResult_EndpointError {
        data: *mut wire_cst_ln_url_error_data,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_LnUrlPayResult_PayError {
        data: *mut wire_cst_ln_url_pay_error_data,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_ln_url_pay_success_data {
        payment: wire_cst_payment,
        success_action: *mut wire_cst_success_action_processed,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_ln_url_withdraw_request {
        data: wire_cst_ln_url_withdraw_request_data,
        amount_msat: u64,
        description: *mut wire_cst_list_prim_u_8_strict,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_ln_url_withdraw_request_data {
        callback: *mut wire_cst_list_prim_u_8_strict,
        k1: *mut wire_cst_list_prim_u_8_strict,
        default_description: *mut wire_cst_list_prim_u_8_strict,
        min_withdrawable: u64,
        max_withdrawable: u64,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_ln_url_withdraw_result {
        tag: i32,
        kind: LnUrlWithdrawResultKind,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub union LnUrlWithdrawResultKind {
        Ok: wire_cst_LnUrlWithdrawResult_Ok,
        Timeout: wire_cst_LnUrlWithdrawResult_Timeout,
        ErrorStatus: wire_cst_LnUrlWithdrawResult_ErrorStatus,
        nil__: (),
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_LnUrlWithdrawResult_Ok {
        data: *mut wire_cst_ln_url_withdraw_success_data,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_LnUrlWithdrawResult_Timeout {
        data: *mut wire_cst_ln_url_withdraw_success_data,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_LnUrlWithdrawResult_ErrorStatus {
        data: *mut wire_cst_ln_url_error_data,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_ln_url_withdraw_success_data {
        invoice: wire_cst_ln_invoice,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_locale_overrides {
        locale: *mut wire_cst_list_prim_u_8_strict,
        spacing: *mut u32,
        symbol: wire_cst_symbol,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_localized_name {
        locale: *mut wire_cst_list_prim_u_8_strict,
        name: *mut wire_cst_list_prim_u_8_strict,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_log_entry {
        line: *mut wire_cst_list_prim_u_8_strict,
        level: *mut wire_cst_list_prim_u_8_strict,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_lsp_information {
        id: *mut wire_cst_list_prim_u_8_strict,
        name: *mut wire_cst_list_prim_u_8_strict,
        widget_url: *mut wire_cst_list_prim_u_8_strict,
        pubkey: *mut wire_cst_list_prim_u_8_strict,
        host: *mut wire_cst_list_prim_u_8_strict,
        base_fee_msat: i64,
        fee_rate: f64,
        time_lock_delta: u32,
        min_htlc_msat: i64,
        lsp_pubkey: *mut wire_cst_list_prim_u_8_strict,
        opening_fee_params_list: wire_cst_opening_fee_params_menu,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_message_success_action_data {
        message: *mut wire_cst_list_prim_u_8_strict,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_metadata_filter {
        json_path: *mut wire_cst_list_prim_u_8_strict,
        json_value: *mut wire_cst_list_prim_u_8_strict,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_node_config {
        tag: i32,
        kind: NodeConfigKind,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub union NodeConfigKind {
        Greenlight: wire_cst_NodeConfig_Greenlight,
        nil__: (),
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_NodeConfig_Greenlight {
        config: *mut wire_cst_greenlight_node_config,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_node_credentials {
        tag: i32,
        kind: NodeCredentialsKind,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub union NodeCredentialsKind {
        Greenlight: wire_cst_NodeCredentials_Greenlight,
        nil__: (),
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_NodeCredentials_Greenlight {
        credentials: *mut wire_cst_greenlight_device_credentials,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_node_state {
        id: *mut wire_cst_list_prim_u_8_strict,
        block_height: u32,
        channels_balance_msat: u64,
        onchain_balance_msat: u64,
        pending_onchain_balance_msat: u64,
        utxos: *mut wire_cst_list_unspent_transaction_output,
        max_payable_msat: u64,
        max_receivable_msat: u64,
        max_single_payment_amount_msat: u64,
        max_chan_reserve_msats: u64,
        connected_peers: *mut wire_cst_list_String,
        max_receivable_single_payment_amount_msat: u64,
        total_inbound_liquidity_msats: u64,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_onchain_payment_limits_response {
        min_sat: u64,
        max_sat: u64,
        max_payable_sat: u64,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_open_channel_fee_request {
        amount_msat: *mut u64,
        expiry: *mut u32,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_open_channel_fee_response {
        fee_msat: *mut u64,
        fee_params: wire_cst_opening_fee_params,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_opening_fee_params {
        min_msat: u64,
        proportional: u32,
        valid_until: *mut wire_cst_list_prim_u_8_strict,
        max_idle_time: u32,
        max_client_to_self_delay: u32,
        promise: *mut wire_cst_list_prim_u_8_strict,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_opening_fee_params_menu {
        values: *mut wire_cst_list_opening_fee_params,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_pay_onchain_request {
        recipient_address: *mut wire_cst_list_prim_u_8_strict,
        prepare_res: wire_cst_prepare_onchain_payment_response,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_pay_onchain_response {
        reverse_swap_info: wire_cst_reverse_swap_info,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_payment {
        id: *mut wire_cst_list_prim_u_8_strict,
        payment_type: i32,
        payment_time: i64,
        amount_msat: u64,
        fee_msat: u64,
        status: i32,
        error: *mut wire_cst_list_prim_u_8_strict,
        description: *mut wire_cst_list_prim_u_8_strict,
        details: wire_cst_payment_details,
        metadata: *mut wire_cst_list_prim_u_8_strict,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_payment_details {
        tag: i32,
        kind: PaymentDetailsKind,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub union PaymentDetailsKind {
        Ln: wire_cst_PaymentDetails_Ln,
        ClosedChannel: wire_cst_PaymentDetails_ClosedChannel,
        nil__: (),
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_PaymentDetails_Ln {
        data: *mut wire_cst_ln_payment_details,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_PaymentDetails_ClosedChannel {
        data: *mut wire_cst_closed_channel_payment_details,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_payment_failed_data {
        error: *mut wire_cst_list_prim_u_8_strict,
        node_id: *mut wire_cst_list_prim_u_8_strict,
        invoice: *mut wire_cst_ln_invoice,
        label: *mut wire_cst_list_prim_u_8_strict,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_prepare_onchain_payment_request {
        amount_sat: u64,
        amount_type: i32,
        claim_tx_feerate: u32,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_prepare_onchain_payment_response {
        fees_hash: *mut wire_cst_list_prim_u_8_strict,
        fees_percentage: f64,
        fees_lockup: u64,
        fees_claim: u64,
        sender_amount_sat: u64,
        recipient_amount_sat: u64,
        total_fees: u64,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_prepare_redeem_onchain_funds_request {
        to_address: *mut wire_cst_list_prim_u_8_strict,
        sat_per_vbyte: u32,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_prepare_redeem_onchain_funds_response {
        tx_weight: u64,
        tx_fee_sat: u64,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_prepare_refund_request {
        swap_address: *mut wire_cst_list_prim_u_8_strict,
        to_address: *mut wire_cst_list_prim_u_8_strict,
        sat_per_vbyte: u32,
        unilateral: *mut bool,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_prepare_refund_response {
        refund_tx_weight: u32,
        refund_tx_fee_sat: u64,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_rate {
        coin: *mut wire_cst_list_prim_u_8_strict,
        value: f64,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_receive_onchain_request {
        opening_fee_params: *mut wire_cst_opening_fee_params,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_receive_payment_request {
        amount_msat: u64,
        description: *mut wire_cst_list_prim_u_8_strict,
        preimage: *mut wire_cst_list_prim_u_8_strict,
        opening_fee_params: *mut wire_cst_opening_fee_params,
        use_description_hash: *mut bool,
        expiry: *mut u32,
        cltv: *mut u32,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_receive_payment_response {
        ln_invoice: wire_cst_ln_invoice,
        opening_fee_params: *mut wire_cst_opening_fee_params,
        opening_fee_msat: *mut u64,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_recommended_fees {
        fastest_fee: u64,
        half_hour_fee: u64,
        hour_fee: u64,
        economy_fee: u64,
        minimum_fee: u64,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_redeem_onchain_funds_request {
        to_address: *mut wire_cst_list_prim_u_8_strict,
        sat_per_vbyte: u32,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_redeem_onchain_funds_response {
        txid: *mut wire_cst_list_prim_u_8_strict,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_refund_request {
        swap_address: *mut wire_cst_list_prim_u_8_strict,
        to_address: *mut wire_cst_list_prim_u_8_strict,
        sat_per_vbyte: u32,
        unilateral: *mut bool,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_refund_response {
        refund_tx_id: *mut wire_cst_list_prim_u_8_strict,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_report_issue_request {
        tag: i32,
        kind: ReportIssueRequestKind,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub union ReportIssueRequestKind {
        PaymentFailure: wire_cst_ReportIssueRequest_PaymentFailure,
        nil__: (),
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_ReportIssueRequest_PaymentFailure {
        data: *mut wire_cst_report_payment_failure_details,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_report_payment_failure_details {
        payment_hash: *mut wire_cst_list_prim_u_8_strict,
        comment: *mut wire_cst_list_prim_u_8_strict,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_reverse_swap_fees_request {
        send_amount_sat: *mut u64,
        claim_tx_feerate: *mut u32,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_reverse_swap_info {
        id: *mut wire_cst_list_prim_u_8_strict,
        claim_pubkey: *mut wire_cst_list_prim_u_8_strict,
        lockup_txid: *mut wire_cst_list_prim_u_8_strict,
        claim_txid: *mut wire_cst_list_prim_u_8_strict,
        onchain_amount_sat: u64,
        status: i32,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_reverse_swap_pair_info {
        min: u64,
        max: u64,
        fees_hash: *mut wire_cst_list_prim_u_8_strict,
        fees_percentage: f64,
        fees_lockup: u64,
        fees_claim: u64,
        total_fees: *mut u64,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_route_hint {
        hops: *mut wire_cst_list_route_hint_hop,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_route_hint_hop {
        src_node_id: *mut wire_cst_list_prim_u_8_strict,
        short_channel_id: *mut wire_cst_list_prim_u_8_strict,
        fees_base_msat: u32,
        fees_proportional_millionths: u32,
        cltv_expiry_delta: u64,
        htlc_minimum_msat: *mut u64,
        htlc_maximum_msat: *mut u64,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_send_payment_request {
        bolt11: *mut wire_cst_list_prim_u_8_strict,
        use_trampoline: bool,
        amount_msat: *mut u64,
        label: *mut wire_cst_list_prim_u_8_strict,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_send_payment_response {
        payment: wire_cst_payment,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_send_spontaneous_payment_request {
        node_id: *mut wire_cst_list_prim_u_8_strict,
        amount_msat: u64,
        extra_tlvs: *mut wire_cst_list_tlv_entry,
        label: *mut wire_cst_list_prim_u_8_strict,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_service_health_check_response {
        status: i32,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_sign_message_request {
        message: *mut wire_cst_list_prim_u_8_strict,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_sign_message_response {
        signature: *mut wire_cst_list_prim_u_8_strict,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_static_backup_request {
        working_dir: *mut wire_cst_list_prim_u_8_strict,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_static_backup_response {
        backup: *mut wire_cst_list_String,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_success_action_processed {
        tag: i32,
        kind: SuccessActionProcessedKind,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub union SuccessActionProcessedKind {
        Aes: wire_cst_SuccessActionProcessed_Aes,
        Message: wire_cst_SuccessActionProcessed_Message,
        Url: wire_cst_SuccessActionProcessed_Url,
        nil__: (),
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_SuccessActionProcessed_Aes {
        result: *mut wire_cst_aes_success_action_data_result,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_SuccessActionProcessed_Message {
        data: *mut wire_cst_message_success_action_data,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_SuccessActionProcessed_Url {
        data: *mut wire_cst_url_success_action_data,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_swap_info {
        bitcoin_address: *mut wire_cst_list_prim_u_8_strict,
        created_at: i64,
        lock_height: i64,
        payment_hash: *mut wire_cst_list_prim_u_8_strict,
        preimage: *mut wire_cst_list_prim_u_8_strict,
        private_key: *mut wire_cst_list_prim_u_8_strict,
        public_key: *mut wire_cst_list_prim_u_8_strict,
        swapper_public_key: *mut wire_cst_list_prim_u_8_strict,
        script: *mut wire_cst_list_prim_u_8_strict,
        bolt11: *mut wire_cst_list_prim_u_8_strict,
        paid_msat: u64,
        total_incoming_txs: u64,
        confirmed_sats: u64,
        unconfirmed_sats: u64,
        status: i32,
        refund_tx_ids: *mut wire_cst_list_String,
        unconfirmed_tx_ids: *mut wire_cst_list_String,
        confirmed_tx_ids: *mut wire_cst_list_String,
        min_allowed_deposit: i64,
        max_allowed_deposit: i64,
        max_swapper_payable: i64,
        last_redeem_error: *mut wire_cst_list_prim_u_8_strict,
        channel_opening_fees: *mut wire_cst_opening_fee_params,
        confirmed_at: *mut u32,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_symbol {
        grapheme: *mut wire_cst_list_prim_u_8_strict,
        template: *mut wire_cst_list_prim_u_8_strict,
        rtl: *mut bool,
        position: *mut u32,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_tlv_entry {
        field_number: u64,
        value: *mut wire_cst_list_prim_u_8_strict,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_unspent_transaction_output {
        txid: *mut wire_cst_list_prim_u_8_strict,
        outnum: u32,
        amount_millisatoshi: u64,
        address: *mut wire_cst_list_prim_u_8_strict,
        reserved: bool,
    }
    #[repr(C)]
    #[derive(Clone, Copy)]
    pub struct wire_cst_url_success_action_data {
        description: *mut wire_cst_list_prim_u_8_strict,
        url: *mut wire_cst_list_prim_u_8_strict,
        matches_callback_domain: bool,
    }
}
#[cfg(not(target_family = "wasm"))]
pub use io::*;