breez_sdk_liquid/
frb_generated.rs

1// This file is automatically generated, so please do not edit it.
2// @generated by `flutter_rust_bridge`@ 2.9.0.
3
4#![allow(
5    non_camel_case_types,
6    unused,
7    non_snake_case,
8    clippy::needless_return,
9    clippy::redundant_closure_call,
10    clippy::redundant_closure,
11    clippy::useless_conversion,
12    clippy::unit_arg,
13    clippy::unused_unit,
14    clippy::double_parens,
15    clippy::let_and_return,
16    clippy::too_many_arguments,
17    clippy::match_single_binding,
18    clippy::clone_on_copy,
19    clippy::let_unit_value,
20    clippy::deref_addrof,
21    clippy::explicit_auto_deref,
22    clippy::borrow_deref_ref,
23    clippy::needless_borrow
24)]
25
26// Section: imports
27
28use crate::bindings::*;
29use crate::model::EventListener;
30use flutter_rust_bridge::for_generated::byteorder::{NativeEndian, ReadBytesExt, WriteBytesExt};
31use flutter_rust_bridge::for_generated::{transform_result_dco, Lifetimeable, Lockable};
32use flutter_rust_bridge::{Handler, IntoIntoDart};
33
34// Section: boilerplate
35
36flutter_rust_bridge::frb_generated_boilerplate!(
37    default_stream_sink_codec = DcoCodec,
38    default_rust_opaque = RustOpaqueNom,
39    default_rust_auto_opaque = RustAutoOpaqueNom,
40);
41pub(crate) const FLUTTER_RUST_BRIDGE_CODEGEN_VERSION: &str = "2.9.0";
42pub(crate) const FLUTTER_RUST_BRIDGE_CODEGEN_CONTENT_HASH: i32 = 464449310;
43
44// Section: executor
45
46flutter_rust_bridge::frb_generated_default_handler!();
47
48// Section: wire_funcs
49
50fn wire__crate__bindings__BindingLiquidSdk_accept_payment_proposed_fees_impl(
51    port_: flutter_rust_bridge::for_generated::MessagePort,
52    that: impl CstDecode<
53        RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
54    >,
55    req: impl CstDecode<crate::model::AcceptPaymentProposedFeesRequest>,
56) {
57    FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
58        flutter_rust_bridge::for_generated::TaskInfo {
59            debug_name: "BindingLiquidSdk_accept_payment_proposed_fees",
60            port: Some(port_),
61            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
62        },
63        move || {
64            let api_that = that.cst_decode();
65            let api_req = req.cst_decode();
66            move |context| async move {
67                transform_result_dco::<_, _, crate::error::PaymentError>(
68                    (move || async move {
69                        let mut api_that_guard = None;
70                        let decode_indices_ =
71                            flutter_rust_bridge::for_generated::lockable_compute_decode_order(
72                                vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
73                                    &api_that, 0, false,
74                                )],
75                            );
76                        for i in decode_indices_ {
77                            match i {
78                                0 => {
79                                    api_that_guard =
80                                        Some(api_that.lockable_decode_async_ref().await)
81                                }
82                                _ => unreachable!(),
83                            }
84                        }
85                        let api_that_guard = api_that_guard.unwrap();
86                        let output_ok =
87                            crate::bindings::BindingLiquidSdk::accept_payment_proposed_fees(
88                                &*api_that_guard,
89                                api_req,
90                            )
91                            .await?;
92                        Ok(output_ok)
93                    })()
94                    .await,
95                )
96            }
97        },
98    )
99}
100fn wire__crate__bindings__BindingLiquidSdk_add_event_listener_impl(
101    port_: flutter_rust_bridge::for_generated::MessagePort,
102    that: impl CstDecode<
103        RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
104    >,
105    listener: impl CstDecode<
106        StreamSink<crate::model::SdkEvent, flutter_rust_bridge::for_generated::DcoCodec>,
107    >,
108) {
109    FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
110        flutter_rust_bridge::for_generated::TaskInfo {
111            debug_name: "BindingLiquidSdk_add_event_listener",
112            port: Some(port_),
113            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
114        },
115        move || {
116            let api_that = that.cst_decode();
117            let api_listener = listener.cst_decode();
118            move |context| async move {
119                transform_result_dco::<_, _, crate::error::SdkError>(
120                    (move || async move {
121                        let mut api_that_guard = None;
122                        let decode_indices_ =
123                            flutter_rust_bridge::for_generated::lockable_compute_decode_order(
124                                vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
125                                    &api_that, 0, false,
126                                )],
127                            );
128                        for i in decode_indices_ {
129                            match i {
130                                0 => {
131                                    api_that_guard =
132                                        Some(api_that.lockable_decode_async_ref().await)
133                                }
134                                _ => unreachable!(),
135                            }
136                        }
137                        let api_that_guard = api_that_guard.unwrap();
138                        let output_ok = crate::bindings::BindingLiquidSdk::add_event_listener(
139                            &*api_that_guard,
140                            api_listener,
141                        )
142                        .await?;
143                        Ok(output_ok)
144                    })()
145                    .await,
146                )
147            }
148        },
149    )
150}
151fn wire__crate__bindings__BindingLiquidSdk_backup_impl(
152    that: impl CstDecode<
153        RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
154    >,
155    req: impl CstDecode<crate::model::BackupRequest>,
156) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
157    FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::DcoCodec, _>(
158        flutter_rust_bridge::for_generated::TaskInfo {
159            debug_name: "BindingLiquidSdk_backup",
160            port: None,
161            mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync,
162        },
163        move || {
164            let api_that = that.cst_decode();
165            let api_req = req.cst_decode();
166            transform_result_dco::<_, _, crate::error::SdkError>((move || {
167                let mut api_that_guard = None;
168                let decode_indices_ =
169                    flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![
170                        flutter_rust_bridge::for_generated::LockableOrderInfo::new(
171                            &api_that, 0, false,
172                        ),
173                    ]);
174                for i in decode_indices_ {
175                    match i {
176                        0 => api_that_guard = Some(api_that.lockable_decode_sync_ref()),
177                        _ => unreachable!(),
178                    }
179                }
180                let api_that_guard = api_that_guard.unwrap();
181                let output_ok =
182                    crate::bindings::BindingLiquidSdk::backup(&*api_that_guard, api_req)?;
183                Ok(output_ok)
184            })())
185        },
186    )
187}
188fn wire__crate__bindings__BindingLiquidSdk_buy_bitcoin_impl(
189    port_: flutter_rust_bridge::for_generated::MessagePort,
190    that: impl CstDecode<
191        RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
192    >,
193    req: impl CstDecode<crate::model::BuyBitcoinRequest>,
194) {
195    FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
196        flutter_rust_bridge::for_generated::TaskInfo {
197            debug_name: "BindingLiquidSdk_buy_bitcoin",
198            port: Some(port_),
199            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
200        },
201        move || {
202            let api_that = that.cst_decode();
203            let api_req = req.cst_decode();
204            move |context| async move {
205                transform_result_dco::<_, _, crate::error::PaymentError>(
206                    (move || async move {
207                        let mut api_that_guard = None;
208                        let decode_indices_ =
209                            flutter_rust_bridge::for_generated::lockable_compute_decode_order(
210                                vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
211                                    &api_that, 0, false,
212                                )],
213                            );
214                        for i in decode_indices_ {
215                            match i {
216                                0 => {
217                                    api_that_guard =
218                                        Some(api_that.lockable_decode_async_ref().await)
219                                }
220                                _ => unreachable!(),
221                            }
222                        }
223                        let api_that_guard = api_that_guard.unwrap();
224                        let output_ok = crate::bindings::BindingLiquidSdk::buy_bitcoin(
225                            &*api_that_guard,
226                            api_req,
227                        )
228                        .await?;
229                        Ok(output_ok)
230                    })()
231                    .await,
232                )
233            }
234        },
235    )
236}
237fn wire__crate__bindings__BindingLiquidSdk_check_message_impl(
238    that: impl CstDecode<
239        RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
240    >,
241    req: impl CstDecode<crate::model::CheckMessageRequest>,
242) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
243    FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::DcoCodec, _>(
244        flutter_rust_bridge::for_generated::TaskInfo {
245            debug_name: "BindingLiquidSdk_check_message",
246            port: None,
247            mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync,
248        },
249        move || {
250            let api_that = that.cst_decode();
251            let api_req = req.cst_decode();
252            transform_result_dco::<_, _, crate::error::SdkError>((move || {
253                let mut api_that_guard = None;
254                let decode_indices_ =
255                    flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![
256                        flutter_rust_bridge::for_generated::LockableOrderInfo::new(
257                            &api_that, 0, false,
258                        ),
259                    ]);
260                for i in decode_indices_ {
261                    match i {
262                        0 => api_that_guard = Some(api_that.lockable_decode_sync_ref()),
263                        _ => unreachable!(),
264                    }
265                }
266                let api_that_guard = api_that_guard.unwrap();
267                let output_ok =
268                    crate::bindings::BindingLiquidSdk::check_message(&*api_that_guard, api_req)?;
269                Ok(output_ok)
270            })())
271        },
272    )
273}
274fn wire__crate__bindings__BindingLiquidSdk_create_bolt12_invoice_impl(
275    port_: flutter_rust_bridge::for_generated::MessagePort,
276    that: impl CstDecode<
277        RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
278    >,
279    req: impl CstDecode<crate::model::CreateBolt12InvoiceRequest>,
280) {
281    FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
282        flutter_rust_bridge::for_generated::TaskInfo {
283            debug_name: "BindingLiquidSdk_create_bolt12_invoice",
284            port: Some(port_),
285            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
286        },
287        move || {
288            let api_that = that.cst_decode();
289            let api_req = req.cst_decode();
290            move |context| async move {
291                transform_result_dco::<_, _, crate::error::PaymentError>(
292                    (move || async move {
293                        let mut api_that_guard = None;
294                        let decode_indices_ =
295                            flutter_rust_bridge::for_generated::lockable_compute_decode_order(
296                                vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
297                                    &api_that, 0, false,
298                                )],
299                            );
300                        for i in decode_indices_ {
301                            match i {
302                                0 => {
303                                    api_that_guard =
304                                        Some(api_that.lockable_decode_async_ref().await)
305                                }
306                                _ => unreachable!(),
307                            }
308                        }
309                        let api_that_guard = api_that_guard.unwrap();
310                        let output_ok = crate::bindings::BindingLiquidSdk::create_bolt12_invoice(
311                            &*api_that_guard,
312                            api_req,
313                        )
314                        .await?;
315                        Ok(output_ok)
316                    })()
317                    .await,
318                )
319            }
320        },
321    )
322}
323fn wire__crate__bindings__BindingLiquidSdk_disconnect_impl(
324    port_: flutter_rust_bridge::for_generated::MessagePort,
325    that: impl CstDecode<
326        RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
327    >,
328) {
329    FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
330        flutter_rust_bridge::for_generated::TaskInfo {
331            debug_name: "BindingLiquidSdk_disconnect",
332            port: Some(port_),
333            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
334        },
335        move || {
336            let api_that = that.cst_decode();
337            move |context| async move {
338                transform_result_dco::<_, _, crate::error::SdkError>(
339                    (move || async move {
340                        let mut api_that_guard = None;
341                        let decode_indices_ =
342                            flutter_rust_bridge::for_generated::lockable_compute_decode_order(
343                                vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
344                                    &api_that, 0, false,
345                                )],
346                            );
347                        for i in decode_indices_ {
348                            match i {
349                                0 => {
350                                    api_that_guard =
351                                        Some(api_that.lockable_decode_async_ref().await)
352                                }
353                                _ => unreachable!(),
354                            }
355                        }
356                        let api_that_guard = api_that_guard.unwrap();
357                        let output_ok =
358                            crate::bindings::BindingLiquidSdk::disconnect(&*api_that_guard).await?;
359                        Ok(output_ok)
360                    })()
361                    .await,
362                )
363            }
364        },
365    )
366}
367fn wire__crate__bindings__BindingLiquidSdk_empty_wallet_cache_impl(
368    that: impl CstDecode<
369        RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
370    >,
371) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
372    FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::DcoCodec, _>(
373        flutter_rust_bridge::for_generated::TaskInfo {
374            debug_name: "BindingLiquidSdk_empty_wallet_cache",
375            port: None,
376            mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync,
377        },
378        move || {
379            let api_that = that.cst_decode();
380            transform_result_dco::<_, _, crate::error::SdkError>((move || {
381                let mut api_that_guard = None;
382                let decode_indices_ =
383                    flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![
384                        flutter_rust_bridge::for_generated::LockableOrderInfo::new(
385                            &api_that, 0, false,
386                        ),
387                    ]);
388                for i in decode_indices_ {
389                    match i {
390                        0 => api_that_guard = Some(api_that.lockable_decode_sync_ref()),
391                        _ => unreachable!(),
392                    }
393                }
394                let api_that_guard = api_that_guard.unwrap();
395                let output_ok =
396                    crate::bindings::BindingLiquidSdk::empty_wallet_cache(&*api_that_guard)?;
397                Ok(output_ok)
398            })())
399        },
400    )
401}
402fn wire__crate__bindings__BindingLiquidSdk_fetch_fiat_rates_impl(
403    port_: flutter_rust_bridge::for_generated::MessagePort,
404    that: impl CstDecode<
405        RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
406    >,
407) {
408    FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
409        flutter_rust_bridge::for_generated::TaskInfo {
410            debug_name: "BindingLiquidSdk_fetch_fiat_rates",
411            port: Some(port_),
412            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
413        },
414        move || {
415            let api_that = that.cst_decode();
416            move |context| async move {
417                transform_result_dco::<_, _, crate::error::SdkError>(
418                    (move || async move {
419                        let mut api_that_guard = None;
420                        let decode_indices_ =
421                            flutter_rust_bridge::for_generated::lockable_compute_decode_order(
422                                vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
423                                    &api_that, 0, false,
424                                )],
425                            );
426                        for i in decode_indices_ {
427                            match i {
428                                0 => {
429                                    api_that_guard =
430                                        Some(api_that.lockable_decode_async_ref().await)
431                                }
432                                _ => unreachable!(),
433                            }
434                        }
435                        let api_that_guard = api_that_guard.unwrap();
436                        let output_ok =
437                            crate::bindings::BindingLiquidSdk::fetch_fiat_rates(&*api_that_guard)
438                                .await?;
439                        Ok(output_ok)
440                    })()
441                    .await,
442                )
443            }
444        },
445    )
446}
447fn wire__crate__bindings__BindingLiquidSdk_fetch_lightning_limits_impl(
448    port_: flutter_rust_bridge::for_generated::MessagePort,
449    that: impl CstDecode<
450        RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
451    >,
452) {
453    FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
454        flutter_rust_bridge::for_generated::TaskInfo {
455            debug_name: "BindingLiquidSdk_fetch_lightning_limits",
456            port: Some(port_),
457            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
458        },
459        move || {
460            let api_that = that.cst_decode();
461            move |context| async move {
462                transform_result_dco::<_, _, crate::error::PaymentError>(
463                    (move || async move {
464                        let mut api_that_guard = None;
465                        let decode_indices_ =
466                            flutter_rust_bridge::for_generated::lockable_compute_decode_order(
467                                vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
468                                    &api_that, 0, false,
469                                )],
470                            );
471                        for i in decode_indices_ {
472                            match i {
473                                0 => {
474                                    api_that_guard =
475                                        Some(api_that.lockable_decode_async_ref().await)
476                                }
477                                _ => unreachable!(),
478                            }
479                        }
480                        let api_that_guard = api_that_guard.unwrap();
481                        let output_ok = crate::bindings::BindingLiquidSdk::fetch_lightning_limits(
482                            &*api_that_guard,
483                        )
484                        .await?;
485                        Ok(output_ok)
486                    })()
487                    .await,
488                )
489            }
490        },
491    )
492}
493fn wire__crate__bindings__BindingLiquidSdk_fetch_onchain_limits_impl(
494    port_: flutter_rust_bridge::for_generated::MessagePort,
495    that: impl CstDecode<
496        RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
497    >,
498) {
499    FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
500        flutter_rust_bridge::for_generated::TaskInfo {
501            debug_name: "BindingLiquidSdk_fetch_onchain_limits",
502            port: Some(port_),
503            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
504        },
505        move || {
506            let api_that = that.cst_decode();
507            move |context| async move {
508                transform_result_dco::<_, _, crate::error::PaymentError>(
509                    (move || async move {
510                        let mut api_that_guard = None;
511                        let decode_indices_ =
512                            flutter_rust_bridge::for_generated::lockable_compute_decode_order(
513                                vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
514                                    &api_that, 0, false,
515                                )],
516                            );
517                        for i in decode_indices_ {
518                            match i {
519                                0 => {
520                                    api_that_guard =
521                                        Some(api_that.lockable_decode_async_ref().await)
522                                }
523                                _ => unreachable!(),
524                            }
525                        }
526                        let api_that_guard = api_that_guard.unwrap();
527                        let output_ok = crate::bindings::BindingLiquidSdk::fetch_onchain_limits(
528                            &*api_that_guard,
529                        )
530                        .await?;
531                        Ok(output_ok)
532                    })()
533                    .await,
534                )
535            }
536        },
537    )
538}
539fn wire__crate__bindings__BindingLiquidSdk_fetch_payment_proposed_fees_impl(
540    port_: flutter_rust_bridge::for_generated::MessagePort,
541    that: impl CstDecode<
542        RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
543    >,
544    req: impl CstDecode<crate::model::FetchPaymentProposedFeesRequest>,
545) {
546    FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
547        flutter_rust_bridge::for_generated::TaskInfo {
548            debug_name: "BindingLiquidSdk_fetch_payment_proposed_fees",
549            port: Some(port_),
550            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
551        },
552        move || {
553            let api_that = that.cst_decode();
554            let api_req = req.cst_decode();
555            move |context| async move {
556                transform_result_dco::<_, _, crate::error::SdkError>(
557                    (move || async move {
558                        let mut api_that_guard = None;
559                        let decode_indices_ =
560                            flutter_rust_bridge::for_generated::lockable_compute_decode_order(
561                                vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
562                                    &api_that, 0, false,
563                                )],
564                            );
565                        for i in decode_indices_ {
566                            match i {
567                                0 => {
568                                    api_that_guard =
569                                        Some(api_that.lockable_decode_async_ref().await)
570                                }
571                                _ => unreachable!(),
572                            }
573                        }
574                        let api_that_guard = api_that_guard.unwrap();
575                        let output_ok =
576                            crate::bindings::BindingLiquidSdk::fetch_payment_proposed_fees(
577                                &*api_that_guard,
578                                api_req,
579                            )
580                            .await?;
581                        Ok(output_ok)
582                    })()
583                    .await,
584                )
585            }
586        },
587    )
588}
589fn wire__crate__bindings__BindingLiquidSdk_get_info_impl(
590    port_: flutter_rust_bridge::for_generated::MessagePort,
591    that: impl CstDecode<
592        RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
593    >,
594) {
595    FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
596        flutter_rust_bridge::for_generated::TaskInfo {
597            debug_name: "BindingLiquidSdk_get_info",
598            port: Some(port_),
599            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
600        },
601        move || {
602            let api_that = that.cst_decode();
603            move |context| async move {
604                transform_result_dco::<_, _, crate::error::SdkError>(
605                    (move || async move {
606                        let mut api_that_guard = None;
607                        let decode_indices_ =
608                            flutter_rust_bridge::for_generated::lockable_compute_decode_order(
609                                vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
610                                    &api_that, 0, false,
611                                )],
612                            );
613                        for i in decode_indices_ {
614                            match i {
615                                0 => {
616                                    api_that_guard =
617                                        Some(api_that.lockable_decode_async_ref().await)
618                                }
619                                _ => unreachable!(),
620                            }
621                        }
622                        let api_that_guard = api_that_guard.unwrap();
623                        let output_ok =
624                            crate::bindings::BindingLiquidSdk::get_info(&*api_that_guard).await?;
625                        Ok(output_ok)
626                    })()
627                    .await,
628                )
629            }
630        },
631    )
632}
633fn wire__crate__bindings__BindingLiquidSdk_get_payment_impl(
634    port_: flutter_rust_bridge::for_generated::MessagePort,
635    that: impl CstDecode<
636        RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
637    >,
638    req: impl CstDecode<crate::model::GetPaymentRequest>,
639) {
640    FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
641        flutter_rust_bridge::for_generated::TaskInfo {
642            debug_name: "BindingLiquidSdk_get_payment",
643            port: Some(port_),
644            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
645        },
646        move || {
647            let api_that = that.cst_decode();
648            let api_req = req.cst_decode();
649            move |context| async move {
650                transform_result_dco::<_, _, crate::error::PaymentError>(
651                    (move || async move {
652                        let mut api_that_guard = None;
653                        let decode_indices_ =
654                            flutter_rust_bridge::for_generated::lockable_compute_decode_order(
655                                vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
656                                    &api_that, 0, false,
657                                )],
658                            );
659                        for i in decode_indices_ {
660                            match i {
661                                0 => {
662                                    api_that_guard =
663                                        Some(api_that.lockable_decode_async_ref().await)
664                                }
665                                _ => unreachable!(),
666                            }
667                        }
668                        let api_that_guard = api_that_guard.unwrap();
669                        let output_ok = crate::bindings::BindingLiquidSdk::get_payment(
670                            &*api_that_guard,
671                            api_req,
672                        )
673                        .await?;
674                        Ok(output_ok)
675                    })()
676                    .await,
677                )
678            }
679        },
680    )
681}
682fn wire__crate__bindings__BindingLiquidSdk_list_fiat_currencies_impl(
683    port_: flutter_rust_bridge::for_generated::MessagePort,
684    that: impl CstDecode<
685        RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
686    >,
687) {
688    FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
689        flutter_rust_bridge::for_generated::TaskInfo {
690            debug_name: "BindingLiquidSdk_list_fiat_currencies",
691            port: Some(port_),
692            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
693        },
694        move || {
695            let api_that = that.cst_decode();
696            move |context| async move {
697                transform_result_dco::<_, _, crate::error::SdkError>(
698                    (move || async move {
699                        let mut api_that_guard = None;
700                        let decode_indices_ =
701                            flutter_rust_bridge::for_generated::lockable_compute_decode_order(
702                                vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
703                                    &api_that, 0, false,
704                                )],
705                            );
706                        for i in decode_indices_ {
707                            match i {
708                                0 => {
709                                    api_that_guard =
710                                        Some(api_that.lockable_decode_async_ref().await)
711                                }
712                                _ => unreachable!(),
713                            }
714                        }
715                        let api_that_guard = api_that_guard.unwrap();
716                        let output_ok = crate::bindings::BindingLiquidSdk::list_fiat_currencies(
717                            &*api_that_guard,
718                        )
719                        .await?;
720                        Ok(output_ok)
721                    })()
722                    .await,
723                )
724            }
725        },
726    )
727}
728fn wire__crate__bindings__BindingLiquidSdk_list_payments_impl(
729    port_: flutter_rust_bridge::for_generated::MessagePort,
730    that: impl CstDecode<
731        RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
732    >,
733    req: impl CstDecode<crate::model::ListPaymentsRequest>,
734) {
735    FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
736        flutter_rust_bridge::for_generated::TaskInfo {
737            debug_name: "BindingLiquidSdk_list_payments",
738            port: Some(port_),
739            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
740        },
741        move || {
742            let api_that = that.cst_decode();
743            let api_req = req.cst_decode();
744            move |context| async move {
745                transform_result_dco::<_, _, crate::error::PaymentError>(
746                    (move || async move {
747                        let mut api_that_guard = None;
748                        let decode_indices_ =
749                            flutter_rust_bridge::for_generated::lockable_compute_decode_order(
750                                vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
751                                    &api_that, 0, false,
752                                )],
753                            );
754                        for i in decode_indices_ {
755                            match i {
756                                0 => {
757                                    api_that_guard =
758                                        Some(api_that.lockable_decode_async_ref().await)
759                                }
760                                _ => unreachable!(),
761                            }
762                        }
763                        let api_that_guard = api_that_guard.unwrap();
764                        let output_ok = crate::bindings::BindingLiquidSdk::list_payments(
765                            &*api_that_guard,
766                            api_req,
767                        )
768                        .await?;
769                        Ok(output_ok)
770                    })()
771                    .await,
772                )
773            }
774        },
775    )
776}
777fn wire__crate__bindings__BindingLiquidSdk_list_refundables_impl(
778    port_: flutter_rust_bridge::for_generated::MessagePort,
779    that: impl CstDecode<
780        RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
781    >,
782) {
783    FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
784        flutter_rust_bridge::for_generated::TaskInfo {
785            debug_name: "BindingLiquidSdk_list_refundables",
786            port: Some(port_),
787            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
788        },
789        move || {
790            let api_that = that.cst_decode();
791            move |context| async move {
792                transform_result_dco::<_, _, crate::error::SdkError>(
793                    (move || async move {
794                        let mut api_that_guard = None;
795                        let decode_indices_ =
796                            flutter_rust_bridge::for_generated::lockable_compute_decode_order(
797                                vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
798                                    &api_that, 0, false,
799                                )],
800                            );
801                        for i in decode_indices_ {
802                            match i {
803                                0 => {
804                                    api_that_guard =
805                                        Some(api_that.lockable_decode_async_ref().await)
806                                }
807                                _ => unreachable!(),
808                            }
809                        }
810                        let api_that_guard = api_that_guard.unwrap();
811                        let output_ok =
812                            crate::bindings::BindingLiquidSdk::list_refundables(&*api_that_guard)
813                                .await?;
814                        Ok(output_ok)
815                    })()
816                    .await,
817                )
818            }
819        },
820    )
821}
822fn wire__crate__bindings__BindingLiquidSdk_lnurl_auth_impl(
823    port_: flutter_rust_bridge::for_generated::MessagePort,
824    that: impl CstDecode<
825        RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
826    >,
827    req_data: impl CstDecode<crate::bindings::LnUrlAuthRequestData>,
828) {
829    FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
830        flutter_rust_bridge::for_generated::TaskInfo {
831            debug_name: "BindingLiquidSdk_lnurl_auth",
832            port: Some(port_),
833            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
834        },
835        move || {
836            let api_that = that.cst_decode();
837            let api_req_data = req_data.cst_decode();
838            move |context| async move {
839                transform_result_dco::<_, _, crate::bindings::duplicates::LnUrlAuthError>(
840                    (move || async move {
841                        let mut api_that_guard = None;
842                        let decode_indices_ =
843                            flutter_rust_bridge::for_generated::lockable_compute_decode_order(
844                                vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
845                                    &api_that, 0, false,
846                                )],
847                            );
848                        for i in decode_indices_ {
849                            match i {
850                                0 => {
851                                    api_that_guard =
852                                        Some(api_that.lockable_decode_async_ref().await)
853                                }
854                                _ => unreachable!(),
855                            }
856                        }
857                        let api_that_guard = api_that_guard.unwrap();
858                        let output_ok = crate::bindings::BindingLiquidSdk::lnurl_auth(
859                            &*api_that_guard,
860                            api_req_data,
861                        )
862                        .await?;
863                        Ok(output_ok)
864                    })()
865                    .await,
866                )
867            }
868        },
869    )
870}
871fn wire__crate__bindings__BindingLiquidSdk_lnurl_pay_impl(
872    port_: flutter_rust_bridge::for_generated::MessagePort,
873    that: impl CstDecode<
874        RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
875    >,
876    req: impl CstDecode<crate::model::LnUrlPayRequest>,
877) {
878    FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
879        flutter_rust_bridge::for_generated::TaskInfo {
880            debug_name: "BindingLiquidSdk_lnurl_pay",
881            port: Some(port_),
882            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
883        },
884        move || {
885            let api_that = that.cst_decode();
886            let api_req = req.cst_decode();
887            move |context| async move {
888                transform_result_dco::<_, _, crate::bindings::duplicates::LnUrlPayError>(
889                    (move || async move {
890                        let mut api_that_guard = None;
891                        let decode_indices_ =
892                            flutter_rust_bridge::for_generated::lockable_compute_decode_order(
893                                vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
894                                    &api_that, 0, false,
895                                )],
896                            );
897                        for i in decode_indices_ {
898                            match i {
899                                0 => {
900                                    api_that_guard =
901                                        Some(api_that.lockable_decode_async_ref().await)
902                                }
903                                _ => unreachable!(),
904                            }
905                        }
906                        let api_that_guard = api_that_guard.unwrap();
907                        let output_ok =
908                            crate::bindings::BindingLiquidSdk::lnurl_pay(&*api_that_guard, api_req)
909                                .await?;
910                        Ok(output_ok)
911                    })()
912                    .await,
913                )
914            }
915        },
916    )
917}
918fn wire__crate__bindings__BindingLiquidSdk_lnurl_withdraw_impl(
919    port_: flutter_rust_bridge::for_generated::MessagePort,
920    that: impl CstDecode<
921        RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
922    >,
923    req: impl CstDecode<crate::bindings::LnUrlWithdrawRequest>,
924) {
925    FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
926        flutter_rust_bridge::for_generated::TaskInfo {
927            debug_name: "BindingLiquidSdk_lnurl_withdraw",
928            port: Some(port_),
929            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
930        },
931        move || {
932            let api_that = that.cst_decode();
933            let api_req = req.cst_decode();
934            move |context| async move {
935                transform_result_dco::<_, _, crate::bindings::duplicates::LnUrlWithdrawError>(
936                    (move || async move {
937                        let mut api_that_guard = None;
938                        let decode_indices_ =
939                            flutter_rust_bridge::for_generated::lockable_compute_decode_order(
940                                vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
941                                    &api_that, 0, false,
942                                )],
943                            );
944                        for i in decode_indices_ {
945                            match i {
946                                0 => {
947                                    api_that_guard =
948                                        Some(api_that.lockable_decode_async_ref().await)
949                                }
950                                _ => unreachable!(),
951                            }
952                        }
953                        let api_that_guard = api_that_guard.unwrap();
954                        let output_ok = crate::bindings::BindingLiquidSdk::lnurl_withdraw(
955                            &*api_that_guard,
956                            api_req,
957                        )
958                        .await?;
959                        Ok(output_ok)
960                    })()
961                    .await,
962                )
963            }
964        },
965    )
966}
967fn wire__crate__bindings__BindingLiquidSdk_parse_impl(
968    port_: flutter_rust_bridge::for_generated::MessagePort,
969    that: impl CstDecode<
970        RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
971    >,
972    input: impl CstDecode<String>,
973) {
974    FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
975        flutter_rust_bridge::for_generated::TaskInfo {
976            debug_name: "BindingLiquidSdk_parse",
977            port: Some(port_),
978            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
979        },
980        move || {
981            let api_that = that.cst_decode();
982            let api_input = input.cst_decode();
983            move |context| async move {
984                transform_result_dco::<_, _, crate::error::PaymentError>(
985                    (move || async move {
986                        let mut api_that_guard = None;
987                        let decode_indices_ =
988                            flutter_rust_bridge::for_generated::lockable_compute_decode_order(
989                                vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
990                                    &api_that, 0, false,
991                                )],
992                            );
993                        for i in decode_indices_ {
994                            match i {
995                                0 => {
996                                    api_that_guard =
997                                        Some(api_that.lockable_decode_async_ref().await)
998                                }
999                                _ => unreachable!(),
1000                            }
1001                        }
1002                        let api_that_guard = api_that_guard.unwrap();
1003                        let output_ok =
1004                            crate::bindings::BindingLiquidSdk::parse(&*api_that_guard, api_input)
1005                                .await?;
1006                        Ok(output_ok)
1007                    })()
1008                    .await,
1009                )
1010            }
1011        },
1012    )
1013}
1014fn wire__crate__bindings__BindingLiquidSdk_pay_onchain_impl(
1015    port_: flutter_rust_bridge::for_generated::MessagePort,
1016    that: impl CstDecode<
1017        RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
1018    >,
1019    req: impl CstDecode<crate::model::PayOnchainRequest>,
1020) {
1021    FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
1022        flutter_rust_bridge::for_generated::TaskInfo {
1023            debug_name: "BindingLiquidSdk_pay_onchain",
1024            port: Some(port_),
1025            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
1026        },
1027        move || {
1028            let api_that = that.cst_decode();
1029            let api_req = req.cst_decode();
1030            move |context| async move {
1031                transform_result_dco::<_, _, crate::error::PaymentError>(
1032                    (move || async move {
1033                        let mut api_that_guard = None;
1034                        let decode_indices_ =
1035                            flutter_rust_bridge::for_generated::lockable_compute_decode_order(
1036                                vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
1037                                    &api_that, 0, false,
1038                                )],
1039                            );
1040                        for i in decode_indices_ {
1041                            match i {
1042                                0 => {
1043                                    api_that_guard =
1044                                        Some(api_that.lockable_decode_async_ref().await)
1045                                }
1046                                _ => unreachable!(),
1047                            }
1048                        }
1049                        let api_that_guard = api_that_guard.unwrap();
1050                        let output_ok = crate::bindings::BindingLiquidSdk::pay_onchain(
1051                            &*api_that_guard,
1052                            api_req,
1053                        )
1054                        .await?;
1055                        Ok(output_ok)
1056                    })()
1057                    .await,
1058                )
1059            }
1060        },
1061    )
1062}
1063fn wire__crate__bindings__BindingLiquidSdk_prepare_buy_bitcoin_impl(
1064    port_: flutter_rust_bridge::for_generated::MessagePort,
1065    that: impl CstDecode<
1066        RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
1067    >,
1068    req: impl CstDecode<crate::model::PrepareBuyBitcoinRequest>,
1069) {
1070    FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
1071        flutter_rust_bridge::for_generated::TaskInfo {
1072            debug_name: "BindingLiquidSdk_prepare_buy_bitcoin",
1073            port: Some(port_),
1074            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
1075        },
1076        move || {
1077            let api_that = that.cst_decode();
1078            let api_req = req.cst_decode();
1079            move |context| async move {
1080                transform_result_dco::<_, _, crate::error::PaymentError>(
1081                    (move || async move {
1082                        let mut api_that_guard = None;
1083                        let decode_indices_ =
1084                            flutter_rust_bridge::for_generated::lockable_compute_decode_order(
1085                                vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
1086                                    &api_that, 0, false,
1087                                )],
1088                            );
1089                        for i in decode_indices_ {
1090                            match i {
1091                                0 => {
1092                                    api_that_guard =
1093                                        Some(api_that.lockable_decode_async_ref().await)
1094                                }
1095                                _ => unreachable!(),
1096                            }
1097                        }
1098                        let api_that_guard = api_that_guard.unwrap();
1099                        let output_ok = crate::bindings::BindingLiquidSdk::prepare_buy_bitcoin(
1100                            &*api_that_guard,
1101                            api_req,
1102                        )
1103                        .await?;
1104                        Ok(output_ok)
1105                    })()
1106                    .await,
1107                )
1108            }
1109        },
1110    )
1111}
1112fn wire__crate__bindings__BindingLiquidSdk_prepare_lnurl_pay_impl(
1113    port_: flutter_rust_bridge::for_generated::MessagePort,
1114    that: impl CstDecode<
1115        RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
1116    >,
1117    req: impl CstDecode<crate::model::PrepareLnUrlPayRequest>,
1118) {
1119    FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
1120        flutter_rust_bridge::for_generated::TaskInfo {
1121            debug_name: "BindingLiquidSdk_prepare_lnurl_pay",
1122            port: Some(port_),
1123            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
1124        },
1125        move || {
1126            let api_that = that.cst_decode();
1127            let api_req = req.cst_decode();
1128            move |context| async move {
1129                transform_result_dco::<_, _, crate::bindings::duplicates::LnUrlPayError>(
1130                    (move || async move {
1131                        let mut api_that_guard = None;
1132                        let decode_indices_ =
1133                            flutter_rust_bridge::for_generated::lockable_compute_decode_order(
1134                                vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
1135                                    &api_that, 0, false,
1136                                )],
1137                            );
1138                        for i in decode_indices_ {
1139                            match i {
1140                                0 => {
1141                                    api_that_guard =
1142                                        Some(api_that.lockable_decode_async_ref().await)
1143                                }
1144                                _ => unreachable!(),
1145                            }
1146                        }
1147                        let api_that_guard = api_that_guard.unwrap();
1148                        let output_ok = crate::bindings::BindingLiquidSdk::prepare_lnurl_pay(
1149                            &*api_that_guard,
1150                            api_req,
1151                        )
1152                        .await?;
1153                        Ok(output_ok)
1154                    })()
1155                    .await,
1156                )
1157            }
1158        },
1159    )
1160}
1161fn wire__crate__bindings__BindingLiquidSdk_prepare_pay_onchain_impl(
1162    port_: flutter_rust_bridge::for_generated::MessagePort,
1163    that: impl CstDecode<
1164        RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
1165    >,
1166    req: impl CstDecode<crate::model::PreparePayOnchainRequest>,
1167) {
1168    FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
1169        flutter_rust_bridge::for_generated::TaskInfo {
1170            debug_name: "BindingLiquidSdk_prepare_pay_onchain",
1171            port: Some(port_),
1172            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
1173        },
1174        move || {
1175            let api_that = that.cst_decode();
1176            let api_req = req.cst_decode();
1177            move |context| async move {
1178                transform_result_dco::<_, _, crate::error::PaymentError>(
1179                    (move || async move {
1180                        let mut api_that_guard = None;
1181                        let decode_indices_ =
1182                            flutter_rust_bridge::for_generated::lockable_compute_decode_order(
1183                                vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
1184                                    &api_that, 0, false,
1185                                )],
1186                            );
1187                        for i in decode_indices_ {
1188                            match i {
1189                                0 => {
1190                                    api_that_guard =
1191                                        Some(api_that.lockable_decode_async_ref().await)
1192                                }
1193                                _ => unreachable!(),
1194                            }
1195                        }
1196                        let api_that_guard = api_that_guard.unwrap();
1197                        let output_ok = crate::bindings::BindingLiquidSdk::prepare_pay_onchain(
1198                            &*api_that_guard,
1199                            api_req,
1200                        )
1201                        .await?;
1202                        Ok(output_ok)
1203                    })()
1204                    .await,
1205                )
1206            }
1207        },
1208    )
1209}
1210fn wire__crate__bindings__BindingLiquidSdk_prepare_receive_payment_impl(
1211    port_: flutter_rust_bridge::for_generated::MessagePort,
1212    that: impl CstDecode<
1213        RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
1214    >,
1215    req: impl CstDecode<crate::model::PrepareReceiveRequest>,
1216) {
1217    FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
1218        flutter_rust_bridge::for_generated::TaskInfo {
1219            debug_name: "BindingLiquidSdk_prepare_receive_payment",
1220            port: Some(port_),
1221            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
1222        },
1223        move || {
1224            let api_that = that.cst_decode();
1225            let api_req = req.cst_decode();
1226            move |context| async move {
1227                transform_result_dco::<_, _, crate::error::PaymentError>(
1228                    (move || async move {
1229                        let mut api_that_guard = None;
1230                        let decode_indices_ =
1231                            flutter_rust_bridge::for_generated::lockable_compute_decode_order(
1232                                vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
1233                                    &api_that, 0, false,
1234                                )],
1235                            );
1236                        for i in decode_indices_ {
1237                            match i {
1238                                0 => {
1239                                    api_that_guard =
1240                                        Some(api_that.lockable_decode_async_ref().await)
1241                                }
1242                                _ => unreachable!(),
1243                            }
1244                        }
1245                        let api_that_guard = api_that_guard.unwrap();
1246                        let output_ok = crate::bindings::BindingLiquidSdk::prepare_receive_payment(
1247                            &*api_that_guard,
1248                            api_req,
1249                        )
1250                        .await?;
1251                        Ok(output_ok)
1252                    })()
1253                    .await,
1254                )
1255            }
1256        },
1257    )
1258}
1259fn wire__crate__bindings__BindingLiquidSdk_prepare_refund_impl(
1260    port_: flutter_rust_bridge::for_generated::MessagePort,
1261    that: impl CstDecode<
1262        RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
1263    >,
1264    req: impl CstDecode<crate::model::PrepareRefundRequest>,
1265) {
1266    FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
1267        flutter_rust_bridge::for_generated::TaskInfo {
1268            debug_name: "BindingLiquidSdk_prepare_refund",
1269            port: Some(port_),
1270            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
1271        },
1272        move || {
1273            let api_that = that.cst_decode();
1274            let api_req = req.cst_decode();
1275            move |context| async move {
1276                transform_result_dco::<_, _, crate::error::SdkError>(
1277                    (move || async move {
1278                        let mut api_that_guard = None;
1279                        let decode_indices_ =
1280                            flutter_rust_bridge::for_generated::lockable_compute_decode_order(
1281                                vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
1282                                    &api_that, 0, false,
1283                                )],
1284                            );
1285                        for i in decode_indices_ {
1286                            match i {
1287                                0 => {
1288                                    api_that_guard =
1289                                        Some(api_that.lockable_decode_async_ref().await)
1290                                }
1291                                _ => unreachable!(),
1292                            }
1293                        }
1294                        let api_that_guard = api_that_guard.unwrap();
1295                        let output_ok = crate::bindings::BindingLiquidSdk::prepare_refund(
1296                            &*api_that_guard,
1297                            api_req,
1298                        )
1299                        .await?;
1300                        Ok(output_ok)
1301                    })()
1302                    .await,
1303                )
1304            }
1305        },
1306    )
1307}
1308fn wire__crate__bindings__BindingLiquidSdk_prepare_send_payment_impl(
1309    port_: flutter_rust_bridge::for_generated::MessagePort,
1310    that: impl CstDecode<
1311        RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
1312    >,
1313    req: impl CstDecode<crate::model::PrepareSendRequest>,
1314) {
1315    FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
1316        flutter_rust_bridge::for_generated::TaskInfo {
1317            debug_name: "BindingLiquidSdk_prepare_send_payment",
1318            port: Some(port_),
1319            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
1320        },
1321        move || {
1322            let api_that = that.cst_decode();
1323            let api_req = req.cst_decode();
1324            move |context| async move {
1325                transform_result_dco::<_, _, crate::error::PaymentError>(
1326                    (move || async move {
1327                        let mut api_that_guard = None;
1328                        let decode_indices_ =
1329                            flutter_rust_bridge::for_generated::lockable_compute_decode_order(
1330                                vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
1331                                    &api_that, 0, false,
1332                                )],
1333                            );
1334                        for i in decode_indices_ {
1335                            match i {
1336                                0 => {
1337                                    api_that_guard =
1338                                        Some(api_that.lockable_decode_async_ref().await)
1339                                }
1340                                _ => unreachable!(),
1341                            }
1342                        }
1343                        let api_that_guard = api_that_guard.unwrap();
1344                        let output_ok = crate::bindings::BindingLiquidSdk::prepare_send_payment(
1345                            &*api_that_guard,
1346                            api_req,
1347                        )
1348                        .await?;
1349                        Ok(output_ok)
1350                    })()
1351                    .await,
1352                )
1353            }
1354        },
1355    )
1356}
1357fn wire__crate__bindings__BindingLiquidSdk_receive_payment_impl(
1358    port_: flutter_rust_bridge::for_generated::MessagePort,
1359    that: impl CstDecode<
1360        RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
1361    >,
1362    req: impl CstDecode<crate::model::ReceivePaymentRequest>,
1363) {
1364    FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
1365        flutter_rust_bridge::for_generated::TaskInfo {
1366            debug_name: "BindingLiquidSdk_receive_payment",
1367            port: Some(port_),
1368            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
1369        },
1370        move || {
1371            let api_that = that.cst_decode();
1372            let api_req = req.cst_decode();
1373            move |context| async move {
1374                transform_result_dco::<_, _, crate::error::PaymentError>(
1375                    (move || async move {
1376                        let mut api_that_guard = None;
1377                        let decode_indices_ =
1378                            flutter_rust_bridge::for_generated::lockable_compute_decode_order(
1379                                vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
1380                                    &api_that, 0, false,
1381                                )],
1382                            );
1383                        for i in decode_indices_ {
1384                            match i {
1385                                0 => {
1386                                    api_that_guard =
1387                                        Some(api_that.lockable_decode_async_ref().await)
1388                                }
1389                                _ => unreachable!(),
1390                            }
1391                        }
1392                        let api_that_guard = api_that_guard.unwrap();
1393                        let output_ok = crate::bindings::BindingLiquidSdk::receive_payment(
1394                            &*api_that_guard,
1395                            api_req,
1396                        )
1397                        .await?;
1398                        Ok(output_ok)
1399                    })()
1400                    .await,
1401                )
1402            }
1403        },
1404    )
1405}
1406fn wire__crate__bindings__BindingLiquidSdk_recommended_fees_impl(
1407    port_: flutter_rust_bridge::for_generated::MessagePort,
1408    that: impl CstDecode<
1409        RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
1410    >,
1411) {
1412    FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
1413        flutter_rust_bridge::for_generated::TaskInfo {
1414            debug_name: "BindingLiquidSdk_recommended_fees",
1415            port: Some(port_),
1416            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
1417        },
1418        move || {
1419            let api_that = that.cst_decode();
1420            move |context| async move {
1421                transform_result_dco::<_, _, crate::error::SdkError>(
1422                    (move || async move {
1423                        let mut api_that_guard = None;
1424                        let decode_indices_ =
1425                            flutter_rust_bridge::for_generated::lockable_compute_decode_order(
1426                                vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
1427                                    &api_that, 0, false,
1428                                )],
1429                            );
1430                        for i in decode_indices_ {
1431                            match i {
1432                                0 => {
1433                                    api_that_guard =
1434                                        Some(api_that.lockable_decode_async_ref().await)
1435                                }
1436                                _ => unreachable!(),
1437                            }
1438                        }
1439                        let api_that_guard = api_that_guard.unwrap();
1440                        let output_ok =
1441                            crate::bindings::BindingLiquidSdk::recommended_fees(&*api_that_guard)
1442                                .await?;
1443                        Ok(output_ok)
1444                    })()
1445                    .await,
1446                )
1447            }
1448        },
1449    )
1450}
1451fn wire__crate__bindings__BindingLiquidSdk_refund_impl(
1452    port_: flutter_rust_bridge::for_generated::MessagePort,
1453    that: impl CstDecode<
1454        RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
1455    >,
1456    req: impl CstDecode<crate::model::RefundRequest>,
1457) {
1458    FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
1459        flutter_rust_bridge::for_generated::TaskInfo {
1460            debug_name: "BindingLiquidSdk_refund",
1461            port: Some(port_),
1462            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
1463        },
1464        move || {
1465            let api_that = that.cst_decode();
1466            let api_req = req.cst_decode();
1467            move |context| async move {
1468                transform_result_dco::<_, _, crate::error::PaymentError>(
1469                    (move || async move {
1470                        let mut api_that_guard = None;
1471                        let decode_indices_ =
1472                            flutter_rust_bridge::for_generated::lockable_compute_decode_order(
1473                                vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
1474                                    &api_that, 0, false,
1475                                )],
1476                            );
1477                        for i in decode_indices_ {
1478                            match i {
1479                                0 => {
1480                                    api_that_guard =
1481                                        Some(api_that.lockable_decode_async_ref().await)
1482                                }
1483                                _ => unreachable!(),
1484                            }
1485                        }
1486                        let api_that_guard = api_that_guard.unwrap();
1487                        let output_ok =
1488                            crate::bindings::BindingLiquidSdk::refund(&*api_that_guard, api_req)
1489                                .await?;
1490                        Ok(output_ok)
1491                    })()
1492                    .await,
1493                )
1494            }
1495        },
1496    )
1497}
1498fn wire__crate__bindings__BindingLiquidSdk_register_webhook_impl(
1499    port_: flutter_rust_bridge::for_generated::MessagePort,
1500    that: impl CstDecode<
1501        RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
1502    >,
1503    webhook_url: impl CstDecode<String>,
1504) {
1505    FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
1506        flutter_rust_bridge::for_generated::TaskInfo {
1507            debug_name: "BindingLiquidSdk_register_webhook",
1508            port: Some(port_),
1509            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
1510        },
1511        move || {
1512            let api_that = that.cst_decode();
1513            let api_webhook_url = webhook_url.cst_decode();
1514            move |context| async move {
1515                transform_result_dco::<_, _, crate::error::SdkError>(
1516                    (move || async move {
1517                        let mut api_that_guard = None;
1518                        let decode_indices_ =
1519                            flutter_rust_bridge::for_generated::lockable_compute_decode_order(
1520                                vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
1521                                    &api_that, 0, false,
1522                                )],
1523                            );
1524                        for i in decode_indices_ {
1525                            match i {
1526                                0 => {
1527                                    api_that_guard =
1528                                        Some(api_that.lockable_decode_async_ref().await)
1529                                }
1530                                _ => unreachable!(),
1531                            }
1532                        }
1533                        let api_that_guard = api_that_guard.unwrap();
1534                        let output_ok = crate::bindings::BindingLiquidSdk::register_webhook(
1535                            &*api_that_guard,
1536                            api_webhook_url,
1537                        )
1538                        .await?;
1539                        Ok(output_ok)
1540                    })()
1541                    .await,
1542                )
1543            }
1544        },
1545    )
1546}
1547fn wire__crate__bindings__BindingLiquidSdk_rescan_onchain_swaps_impl(
1548    port_: flutter_rust_bridge::for_generated::MessagePort,
1549    that: impl CstDecode<
1550        RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
1551    >,
1552) {
1553    FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
1554        flutter_rust_bridge::for_generated::TaskInfo {
1555            debug_name: "BindingLiquidSdk_rescan_onchain_swaps",
1556            port: Some(port_),
1557            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
1558        },
1559        move || {
1560            let api_that = that.cst_decode();
1561            move |context| async move {
1562                transform_result_dco::<_, _, crate::error::SdkError>(
1563                    (move || async move {
1564                        let mut api_that_guard = None;
1565                        let decode_indices_ =
1566                            flutter_rust_bridge::for_generated::lockable_compute_decode_order(
1567                                vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
1568                                    &api_that, 0, false,
1569                                )],
1570                            );
1571                        for i in decode_indices_ {
1572                            match i {
1573                                0 => {
1574                                    api_that_guard =
1575                                        Some(api_that.lockable_decode_async_ref().await)
1576                                }
1577                                _ => unreachable!(),
1578                            }
1579                        }
1580                        let api_that_guard = api_that_guard.unwrap();
1581                        let output_ok = crate::bindings::BindingLiquidSdk::rescan_onchain_swaps(
1582                            &*api_that_guard,
1583                        )
1584                        .await?;
1585                        Ok(output_ok)
1586                    })()
1587                    .await,
1588                )
1589            }
1590        },
1591    )
1592}
1593fn wire__crate__bindings__BindingLiquidSdk_restore_impl(
1594    that: impl CstDecode<
1595        RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
1596    >,
1597    req: impl CstDecode<crate::model::RestoreRequest>,
1598) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
1599    FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::DcoCodec, _>(
1600        flutter_rust_bridge::for_generated::TaskInfo {
1601            debug_name: "BindingLiquidSdk_restore",
1602            port: None,
1603            mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync,
1604        },
1605        move || {
1606            let api_that = that.cst_decode();
1607            let api_req = req.cst_decode();
1608            transform_result_dco::<_, _, crate::error::SdkError>((move || {
1609                let mut api_that_guard = None;
1610                let decode_indices_ =
1611                    flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![
1612                        flutter_rust_bridge::for_generated::LockableOrderInfo::new(
1613                            &api_that, 0, false,
1614                        ),
1615                    ]);
1616                for i in decode_indices_ {
1617                    match i {
1618                        0 => api_that_guard = Some(api_that.lockable_decode_sync_ref()),
1619                        _ => unreachable!(),
1620                    }
1621                }
1622                let api_that_guard = api_that_guard.unwrap();
1623                let output_ok =
1624                    crate::bindings::BindingLiquidSdk::restore(&*api_that_guard, api_req)?;
1625                Ok(output_ok)
1626            })())
1627        },
1628    )
1629}
1630fn wire__crate__bindings__BindingLiquidSdk_send_payment_impl(
1631    port_: flutter_rust_bridge::for_generated::MessagePort,
1632    that: impl CstDecode<
1633        RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
1634    >,
1635    req: impl CstDecode<crate::model::SendPaymentRequest>,
1636) {
1637    FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
1638        flutter_rust_bridge::for_generated::TaskInfo {
1639            debug_name: "BindingLiquidSdk_send_payment",
1640            port: Some(port_),
1641            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
1642        },
1643        move || {
1644            let api_that = that.cst_decode();
1645            let api_req = req.cst_decode();
1646            move |context| async move {
1647                transform_result_dco::<_, _, crate::error::PaymentError>(
1648                    (move || async move {
1649                        let mut api_that_guard = None;
1650                        let decode_indices_ =
1651                            flutter_rust_bridge::for_generated::lockable_compute_decode_order(
1652                                vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
1653                                    &api_that, 0, false,
1654                                )],
1655                            );
1656                        for i in decode_indices_ {
1657                            match i {
1658                                0 => {
1659                                    api_that_guard =
1660                                        Some(api_that.lockable_decode_async_ref().await)
1661                                }
1662                                _ => unreachable!(),
1663                            }
1664                        }
1665                        let api_that_guard = api_that_guard.unwrap();
1666                        let output_ok = crate::bindings::BindingLiquidSdk::send_payment(
1667                            &*api_that_guard,
1668                            api_req,
1669                        )
1670                        .await?;
1671                        Ok(output_ok)
1672                    })()
1673                    .await,
1674                )
1675            }
1676        },
1677    )
1678}
1679fn wire__crate__bindings__BindingLiquidSdk_sign_message_impl(
1680    that: impl CstDecode<
1681        RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
1682    >,
1683    req: impl CstDecode<crate::model::SignMessageRequest>,
1684) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
1685    FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::DcoCodec, _>(
1686        flutter_rust_bridge::for_generated::TaskInfo {
1687            debug_name: "BindingLiquidSdk_sign_message",
1688            port: None,
1689            mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync,
1690        },
1691        move || {
1692            let api_that = that.cst_decode();
1693            let api_req = req.cst_decode();
1694            transform_result_dco::<_, _, crate::error::SdkError>((move || {
1695                let mut api_that_guard = None;
1696                let decode_indices_ =
1697                    flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![
1698                        flutter_rust_bridge::for_generated::LockableOrderInfo::new(
1699                            &api_that, 0, false,
1700                        ),
1701                    ]);
1702                for i in decode_indices_ {
1703                    match i {
1704                        0 => api_that_guard = Some(api_that.lockable_decode_sync_ref()),
1705                        _ => unreachable!(),
1706                    }
1707                }
1708                let api_that_guard = api_that_guard.unwrap();
1709                let output_ok =
1710                    crate::bindings::BindingLiquidSdk::sign_message(&*api_that_guard, api_req)?;
1711                Ok(output_ok)
1712            })())
1713        },
1714    )
1715}
1716fn wire__crate__bindings__BindingLiquidSdk_sync_impl(
1717    port_: flutter_rust_bridge::for_generated::MessagePort,
1718    that: impl CstDecode<
1719        RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
1720    >,
1721) {
1722    FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
1723        flutter_rust_bridge::for_generated::TaskInfo {
1724            debug_name: "BindingLiquidSdk_sync(dart_style=sync)",
1725            port: Some(port_),
1726            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
1727        },
1728        move || {
1729            let api_that = that.cst_decode();
1730            move |context| async move {
1731                transform_result_dco::<_, _, crate::error::SdkError>(
1732                    (move || async move {
1733                        let mut api_that_guard = None;
1734                        let decode_indices_ =
1735                            flutter_rust_bridge::for_generated::lockable_compute_decode_order(
1736                                vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
1737                                    &api_that, 0, false,
1738                                )],
1739                            );
1740                        for i in decode_indices_ {
1741                            match i {
1742                                0 => {
1743                                    api_that_guard =
1744                                        Some(api_that.lockable_decode_async_ref().await)
1745                                }
1746                                _ => unreachable!(),
1747                            }
1748                        }
1749                        let api_that_guard = api_that_guard.unwrap();
1750                        let output_ok =
1751                            crate::bindings::BindingLiquidSdk::sync(&*api_that_guard).await?;
1752                        Ok(output_ok)
1753                    })()
1754                    .await,
1755                )
1756            }
1757        },
1758    )
1759}
1760fn wire__crate__bindings__BindingLiquidSdk_unregister_webhook_impl(
1761    port_: flutter_rust_bridge::for_generated::MessagePort,
1762    that: impl CstDecode<
1763        RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
1764    >,
1765) {
1766    FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
1767        flutter_rust_bridge::for_generated::TaskInfo {
1768            debug_name: "BindingLiquidSdk_unregister_webhook",
1769            port: Some(port_),
1770            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
1771        },
1772        move || {
1773            let api_that = that.cst_decode();
1774            move |context| async move {
1775                transform_result_dco::<_, _, crate::error::SdkError>(
1776                    (move || async move {
1777                        let mut api_that_guard = None;
1778                        let decode_indices_ =
1779                            flutter_rust_bridge::for_generated::lockable_compute_decode_order(
1780                                vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
1781                                    &api_that, 0, false,
1782                                )],
1783                            );
1784                        for i in decode_indices_ {
1785                            match i {
1786                                0 => {
1787                                    api_that_guard =
1788                                        Some(api_that.lockable_decode_async_ref().await)
1789                                }
1790                                _ => unreachable!(),
1791                            }
1792                        }
1793                        let api_that_guard = api_that_guard.unwrap();
1794                        let output_ok =
1795                            crate::bindings::BindingLiquidSdk::unregister_webhook(&*api_that_guard)
1796                                .await?;
1797                        Ok(output_ok)
1798                    })()
1799                    .await,
1800                )
1801            }
1802        },
1803    )
1804}
1805fn wire__crate__bindings__binding_event_listener_on_event_impl(
1806    port_: flutter_rust_bridge::for_generated::MessagePort,
1807    that: impl CstDecode<crate::bindings::BindingEventListener>,
1808    e: impl CstDecode<crate::model::SdkEvent>,
1809) {
1810    FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::<flutter_rust_bridge::for_generated::DcoCodec, _, _>(
1811        flutter_rust_bridge::for_generated::TaskInfo {
1812            debug_name: "binding_event_listener_on_event",
1813            port: Some(port_),
1814            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
1815        },
1816        move || {
1817            let api_that = that.cst_decode();
1818            let api_e = e.cst_decode();
1819            move |context| {
1820                transform_result_dco::<_, _, ()>((move || {
1821                    let output_ok = Result::<_, ()>::Ok({
1822                        crate::bindings::BindingEventListener::on_event(&api_that, api_e);
1823                    })?;
1824                    Ok(output_ok)
1825                })())
1826            }
1827        },
1828    )
1829}
1830fn wire__crate__bindings__breez_log_stream_impl(
1831    port_: flutter_rust_bridge::for_generated::MessagePort,
1832    s: impl CstDecode<StreamSink<crate::model::LogEntry, flutter_rust_bridge::for_generated::DcoCodec>>,
1833) {
1834    FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::<flutter_rust_bridge::for_generated::DcoCodec, _, _>(
1835        flutter_rust_bridge::for_generated::TaskInfo {
1836            debug_name: "breez_log_stream",
1837            port: Some(port_),
1838            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
1839        },
1840        move || {
1841            let api_s = s.cst_decode();
1842            move |context| {
1843                transform_result_dco::<_, _, flutter_rust_bridge::for_generated::anyhow::Error>(
1844                    (move || {
1845                        let output_ok = crate::bindings::breez_log_stream(api_s)?;
1846                        Ok(output_ok)
1847                    })(),
1848                )
1849            }
1850        },
1851    )
1852}
1853fn wire__crate__bindings__connect_impl(
1854    port_: flutter_rust_bridge::for_generated::MessagePort,
1855    req: impl CstDecode<crate::model::ConnectRequest>,
1856) {
1857    FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
1858        flutter_rust_bridge::for_generated::TaskInfo {
1859            debug_name: "connect",
1860            port: Some(port_),
1861            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
1862        },
1863        move || {
1864            let api_req = req.cst_decode();
1865            move |context| async move {
1866                transform_result_dco::<_, _, crate::error::SdkError>(
1867                    (move || async move {
1868                        let output_ok = crate::bindings::connect(api_req).await?;
1869                        Ok(output_ok)
1870                    })()
1871                    .await,
1872                )
1873            }
1874        },
1875    )
1876}
1877fn wire__crate__bindings__default_config_impl(
1878    network: impl CstDecode<crate::model::LiquidNetwork>,
1879    breez_api_key: impl CstDecode<Option<String>>,
1880) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
1881    FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::DcoCodec, _>(
1882        flutter_rust_bridge::for_generated::TaskInfo {
1883            debug_name: "default_config",
1884            port: None,
1885            mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync,
1886        },
1887        move || {
1888            let api_network = network.cst_decode();
1889            let api_breez_api_key = breez_api_key.cst_decode();
1890            transform_result_dco::<_, _, crate::error::SdkError>((move || {
1891                let output_ok = crate::bindings::default_config(api_network, api_breez_api_key)?;
1892                Ok(output_ok)
1893            })())
1894        },
1895    )
1896}
1897fn wire__crate__bindings__parse_invoice_impl(
1898    input: impl CstDecode<String>,
1899) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
1900    FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::DcoCodec, _>(
1901        flutter_rust_bridge::for_generated::TaskInfo {
1902            debug_name: "parse_invoice",
1903            port: None,
1904            mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync,
1905        },
1906        move || {
1907            let api_input = input.cst_decode();
1908            transform_result_dco::<_, _, crate::error::PaymentError>((move || {
1909                let output_ok = crate::bindings::parse_invoice(api_input)?;
1910                Ok(output_ok)
1911            })())
1912        },
1913    )
1914}
1915
1916// Section: static_checks
1917
1918#[allow(clippy::unnecessary_literal_unwrap)]
1919const _: fn() = || {
1920    {
1921        let AesSuccessActionData = None::<crate::bindings::AesSuccessActionData>.unwrap();
1922        let _: String = AesSuccessActionData.description;
1923        let _: String = AesSuccessActionData.ciphertext;
1924        let _: String = AesSuccessActionData.iv;
1925    }
1926    {
1927        let AesSuccessActionDataDecrypted =
1928            None::<crate::bindings::AesSuccessActionDataDecrypted>.unwrap();
1929        let _: String = AesSuccessActionDataDecrypted.description;
1930        let _: String = AesSuccessActionDataDecrypted.plaintext;
1931    }
1932    match None::<crate::bindings::AesSuccessActionDataResult>.unwrap() {
1933        crate::bindings::AesSuccessActionDataResult::Decrypted { data } => {
1934            let _: crate::bindings::AesSuccessActionDataDecrypted = data;
1935        }
1936        crate::bindings::AesSuccessActionDataResult::ErrorStatus { reason } => {
1937            let _: String = reason;
1938        }
1939    }
1940    match None::<crate::bindings::Amount>.unwrap() {
1941        crate::bindings::Amount::Bitcoin { amount_msat } => {
1942            let _: u64 = amount_msat;
1943        }
1944        crate::bindings::Amount::Currency {
1945            iso4217_code,
1946            fractional_amount,
1947        } => {
1948            let _: String = iso4217_code;
1949            let _: u64 = fractional_amount;
1950        }
1951    }
1952    {
1953        let BitcoinAddressData = None::<crate::bindings::BitcoinAddressData>.unwrap();
1954        let _: String = BitcoinAddressData.address;
1955        let _: crate::bindings::Network = BitcoinAddressData.network;
1956        let _: Option<u64> = BitcoinAddressData.amount_sat;
1957        let _: Option<String> = BitcoinAddressData.label;
1958        let _: Option<String> = BitcoinAddressData.message;
1959    }
1960    {
1961        let CurrencyInfo = None::<crate::bindings::CurrencyInfo>.unwrap();
1962        let _: String = CurrencyInfo.name;
1963        let _: u32 = CurrencyInfo.fraction_size;
1964        let _: Option<u32> = CurrencyInfo.spacing;
1965        let _: Option<crate::bindings::Symbol> = CurrencyInfo.symbol;
1966        let _: Option<crate::bindings::Symbol> = CurrencyInfo.uniq_symbol;
1967        let _: Vec<crate::bindings::LocalizedName> = CurrencyInfo.localized_name;
1968        let _: Vec<crate::bindings::LocaleOverrides> = CurrencyInfo.locale_overrides;
1969    }
1970    {
1971        let ExternalInputParser = None::<crate::bindings::ExternalInputParser>.unwrap();
1972        let _: String = ExternalInputParser.provider_id;
1973        let _: String = ExternalInputParser.input_regex;
1974        let _: String = ExternalInputParser.parser_url;
1975    }
1976    {
1977        let FiatCurrency = None::<crate::bindings::FiatCurrency>.unwrap();
1978        let _: String = FiatCurrency.id;
1979        let _: crate::bindings::CurrencyInfo = FiatCurrency.info;
1980    }
1981    match None::<crate::bindings::InputType>.unwrap() {
1982        crate::bindings::InputType::BitcoinAddress { address } => {
1983            let _: crate::bindings::BitcoinAddressData = address;
1984        }
1985        crate::bindings::InputType::LiquidAddress { address } => {
1986            let _: crate::bindings::LiquidAddressData = address;
1987        }
1988        crate::bindings::InputType::Bolt11 { invoice } => {
1989            let _: crate::bindings::LNInvoice = invoice;
1990        }
1991        crate::bindings::InputType::Bolt12Offer {
1992            offer,
1993            bip353_address,
1994        } => {
1995            let _: crate::bindings::LNOffer = offer;
1996            let _: Option<String> = bip353_address;
1997        }
1998        crate::bindings::InputType::NodeId { node_id } => {
1999            let _: String = node_id;
2000        }
2001        crate::bindings::InputType::Url { url } => {
2002            let _: String = url;
2003        }
2004        crate::bindings::InputType::LnUrlPay {
2005            data,
2006            bip353_address,
2007        } => {
2008            let _: crate::bindings::LnUrlPayRequestData = data;
2009            let _: Option<String> = bip353_address;
2010        }
2011        crate::bindings::InputType::LnUrlWithdraw { data } => {
2012            let _: crate::bindings::LnUrlWithdrawRequestData = data;
2013        }
2014        crate::bindings::InputType::LnUrlAuth { data } => {
2015            let _: crate::bindings::LnUrlAuthRequestData = data;
2016        }
2017        crate::bindings::InputType::LnUrlError { data } => {
2018            let _: crate::bindings::LnUrlErrorData = data;
2019        }
2020    }
2021    {
2022        let LiquidAddressData = None::<crate::bindings::LiquidAddressData>.unwrap();
2023        let _: String = LiquidAddressData.address;
2024        let _: crate::bindings::Network = LiquidAddressData.network;
2025        let _: Option<String> = LiquidAddressData.asset_id;
2026        let _: Option<f64> = LiquidAddressData.amount;
2027        let _: Option<u64> = LiquidAddressData.amount_sat;
2028        let _: Option<String> = LiquidAddressData.label;
2029        let _: Option<String> = LiquidAddressData.message;
2030    }
2031    {
2032        let LNInvoice = None::<crate::bindings::LNInvoice>.unwrap();
2033        let _: String = LNInvoice.bolt11;
2034        let _: crate::bindings::Network = LNInvoice.network;
2035        let _: String = LNInvoice.payee_pubkey;
2036        let _: String = LNInvoice.payment_hash;
2037        let _: Option<String> = LNInvoice.description;
2038        let _: Option<String> = LNInvoice.description_hash;
2039        let _: Option<u64> = LNInvoice.amount_msat;
2040        let _: u64 = LNInvoice.timestamp;
2041        let _: u64 = LNInvoice.expiry;
2042        let _: Vec<crate::bindings::RouteHint> = LNInvoice.routing_hints;
2043        let _: Vec<u8> = LNInvoice.payment_secret;
2044        let _: u64 = LNInvoice.min_final_cltv_expiry_delta;
2045    }
2046    {
2047        let LNOffer = None::<crate::bindings::LNOffer>.unwrap();
2048        let _: String = LNOffer.offer;
2049        let _: Vec<String> = LNOffer.chains;
2050        let _: Option<crate::bindings::Amount> = LNOffer.min_amount;
2051        let _: Option<String> = LNOffer.description;
2052        let _: Option<u64> = LNOffer.absolute_expiry;
2053        let _: Option<String> = LNOffer.issuer;
2054        let _: Option<String> = LNOffer.signing_pubkey;
2055        let _: Vec<crate::bindings::LnOfferBlindedPath> = LNOffer.paths;
2056    }
2057    {
2058        let LnOfferBlindedPath = None::<crate::bindings::LnOfferBlindedPath>.unwrap();
2059        let _: Vec<String> = LnOfferBlindedPath.blinded_hops;
2060    }
2061    {
2062        let LnUrlAuthRequestData = None::<crate::bindings::LnUrlAuthRequestData>.unwrap();
2063        let _: String = LnUrlAuthRequestData.k1;
2064        let _: Option<String> = LnUrlAuthRequestData.action;
2065        let _: String = LnUrlAuthRequestData.domain;
2066        let _: String = LnUrlAuthRequestData.url;
2067    }
2068    {
2069        let LnUrlErrorData = None::<crate::bindings::LnUrlErrorData>.unwrap();
2070        let _: String = LnUrlErrorData.reason;
2071    }
2072    {
2073        let LnUrlPayErrorData = None::<crate::bindings::LnUrlPayErrorData>.unwrap();
2074        let _: String = LnUrlPayErrorData.payment_hash;
2075        let _: String = LnUrlPayErrorData.reason;
2076    }
2077    {
2078        let LnUrlPayRequestData = None::<crate::bindings::LnUrlPayRequestData>.unwrap();
2079        let _: String = LnUrlPayRequestData.callback;
2080        let _: u64 = LnUrlPayRequestData.min_sendable;
2081        let _: u64 = LnUrlPayRequestData.max_sendable;
2082        let _: String = LnUrlPayRequestData.metadata_str;
2083        let _: u16 = LnUrlPayRequestData.comment_allowed;
2084        let _: String = LnUrlPayRequestData.domain;
2085        let _: bool = LnUrlPayRequestData.allows_nostr;
2086        let _: Option<String> = LnUrlPayRequestData.nostr_pubkey;
2087        let _: Option<String> = LnUrlPayRequestData.ln_address;
2088    }
2089    {
2090        let LnUrlWithdrawRequest = None::<crate::bindings::LnUrlWithdrawRequest>.unwrap();
2091        let _: crate::bindings::LnUrlWithdrawRequestData = LnUrlWithdrawRequest.data;
2092        let _: u64 = LnUrlWithdrawRequest.amount_msat;
2093        let _: Option<String> = LnUrlWithdrawRequest.description;
2094    }
2095    {
2096        let LnUrlWithdrawRequestData = None::<crate::bindings::LnUrlWithdrawRequestData>.unwrap();
2097        let _: String = LnUrlWithdrawRequestData.callback;
2098        let _: String = LnUrlWithdrawRequestData.k1;
2099        let _: String = LnUrlWithdrawRequestData.default_description;
2100        let _: u64 = LnUrlWithdrawRequestData.min_withdrawable;
2101        let _: u64 = LnUrlWithdrawRequestData.max_withdrawable;
2102    }
2103    {
2104        let LocaleOverrides = None::<crate::bindings::LocaleOverrides>.unwrap();
2105        let _: String = LocaleOverrides.locale;
2106        let _: Option<u32> = LocaleOverrides.spacing;
2107        let _: crate::bindings::Symbol = LocaleOverrides.symbol;
2108    }
2109    {
2110        let LocalizedName = None::<crate::bindings::LocalizedName>.unwrap();
2111        let _: String = LocalizedName.locale;
2112        let _: String = LocalizedName.name;
2113    }
2114    {
2115        let MessageSuccessActionData = None::<crate::bindings::MessageSuccessActionData>.unwrap();
2116        let _: String = MessageSuccessActionData.message;
2117    }
2118    {
2119        let Rate = None::<crate::bindings::Rate>.unwrap();
2120        let _: String = Rate.coin;
2121        let _: f64 = Rate.value;
2122    }
2123    {
2124        let RouteHint = None::<crate::bindings::RouteHint>.unwrap();
2125        let _: Vec<crate::bindings::RouteHintHop> = RouteHint.hops;
2126    }
2127    {
2128        let RouteHintHop = None::<crate::bindings::RouteHintHop>.unwrap();
2129        let _: String = RouteHintHop.src_node_id;
2130        let _: String = RouteHintHop.short_channel_id;
2131        let _: u32 = RouteHintHop.fees_base_msat;
2132        let _: u32 = RouteHintHop.fees_proportional_millionths;
2133        let _: u64 = RouteHintHop.cltv_expiry_delta;
2134        let _: Option<u64> = RouteHintHop.htlc_minimum_msat;
2135        let _: Option<u64> = RouteHintHop.htlc_maximum_msat;
2136    }
2137    match None::<crate::bindings::SuccessAction>.unwrap() {
2138        crate::bindings::SuccessAction::Aes { data } => {
2139            let _: crate::bindings::AesSuccessActionData = data;
2140        }
2141        crate::bindings::SuccessAction::Message { data } => {
2142            let _: crate::bindings::MessageSuccessActionData = data;
2143        }
2144        crate::bindings::SuccessAction::Url { data } => {
2145            let _: crate::bindings::UrlSuccessActionData = data;
2146        }
2147    }
2148    match None::<crate::bindings::SuccessActionProcessed>.unwrap() {
2149        crate::bindings::SuccessActionProcessed::Aes { result } => {
2150            let _: crate::bindings::AesSuccessActionDataResult = result;
2151        }
2152        crate::bindings::SuccessActionProcessed::Message { data } => {
2153            let _: crate::bindings::MessageSuccessActionData = data;
2154        }
2155        crate::bindings::SuccessActionProcessed::Url { data } => {
2156            let _: crate::bindings::UrlSuccessActionData = data;
2157        }
2158    }
2159    {
2160        let Symbol = None::<crate::bindings::Symbol>.unwrap();
2161        let _: Option<String> = Symbol.grapheme;
2162        let _: Option<String> = Symbol.template;
2163        let _: Option<bool> = Symbol.rtl;
2164        let _: Option<u32> = Symbol.position;
2165    }
2166    {
2167        let UrlSuccessActionData = None::<crate::bindings::UrlSuccessActionData>.unwrap();
2168        let _: String = UrlSuccessActionData.description;
2169        let _: String = UrlSuccessActionData.url;
2170        let _: bool = UrlSuccessActionData.matches_callback_domain;
2171    }
2172};
2173
2174// Section: dart2rust
2175
2176impl CstDecode<bool> for bool {
2177    // Codec=Cst (C-struct based), see doc to use other codecs
2178    fn cst_decode(self) -> bool {
2179        self
2180    }
2181}
2182impl CstDecode<crate::model::BuyBitcoinProvider> for i32 {
2183    // Codec=Cst (C-struct based), see doc to use other codecs
2184    fn cst_decode(self) -> crate::model::BuyBitcoinProvider {
2185        match self {
2186            0 => crate::model::BuyBitcoinProvider::Moonpay,
2187            _ => unreachable!("Invalid variant for BuyBitcoinProvider: {}", self),
2188        }
2189    }
2190}
2191impl CstDecode<f64> for f64 {
2192    // Codec=Cst (C-struct based), see doc to use other codecs
2193    fn cst_decode(self) -> f64 {
2194        self
2195    }
2196}
2197impl CstDecode<i32> for i32 {
2198    // Codec=Cst (C-struct based), see doc to use other codecs
2199    fn cst_decode(self) -> i32 {
2200        self
2201    }
2202}
2203impl CstDecode<i64> for i64 {
2204    // Codec=Cst (C-struct based), see doc to use other codecs
2205    fn cst_decode(self) -> i64 {
2206        self
2207    }
2208}
2209impl CstDecode<crate::model::LiquidNetwork> for i32 {
2210    // Codec=Cst (C-struct based), see doc to use other codecs
2211    fn cst_decode(self) -> crate::model::LiquidNetwork {
2212        match self {
2213            0 => crate::model::LiquidNetwork::Mainnet,
2214            1 => crate::model::LiquidNetwork::Testnet,
2215            2 => crate::model::LiquidNetwork::Regtest,
2216            _ => unreachable!("Invalid variant for LiquidNetwork: {}", self),
2217        }
2218    }
2219}
2220impl CstDecode<crate::bindings::Network> for i32 {
2221    // Codec=Cst (C-struct based), see doc to use other codecs
2222    fn cst_decode(self) -> crate::bindings::Network {
2223        match self {
2224            0 => crate::bindings::Network::Bitcoin,
2225            1 => crate::bindings::Network::Testnet,
2226            2 => crate::bindings::Network::Signet,
2227            3 => crate::bindings::Network::Regtest,
2228            _ => unreachable!("Invalid variant for Network: {}", self),
2229        }
2230    }
2231}
2232impl CstDecode<crate::model::PaymentMethod> for i32 {
2233    // Codec=Cst (C-struct based), see doc to use other codecs
2234    fn cst_decode(self) -> crate::model::PaymentMethod {
2235        match self {
2236            0 => crate::model::PaymentMethod::Lightning,
2237            1 => crate::model::PaymentMethod::Bolt11Invoice,
2238            2 => crate::model::PaymentMethod::Bolt12Offer,
2239            3 => crate::model::PaymentMethod::BitcoinAddress,
2240            4 => crate::model::PaymentMethod::LiquidAddress,
2241            _ => unreachable!("Invalid variant for PaymentMethod: {}", self),
2242        }
2243    }
2244}
2245impl CstDecode<crate::model::PaymentState> for i32 {
2246    // Codec=Cst (C-struct based), see doc to use other codecs
2247    fn cst_decode(self) -> crate::model::PaymentState {
2248        match self {
2249            0 => crate::model::PaymentState::Created,
2250            1 => crate::model::PaymentState::Pending,
2251            2 => crate::model::PaymentState::Complete,
2252            3 => crate::model::PaymentState::Failed,
2253            4 => crate::model::PaymentState::TimedOut,
2254            5 => crate::model::PaymentState::Refundable,
2255            6 => crate::model::PaymentState::RefundPending,
2256            7 => crate::model::PaymentState::WaitingFeeAcceptance,
2257            _ => unreachable!("Invalid variant for PaymentState: {}", self),
2258        }
2259    }
2260}
2261impl CstDecode<crate::model::PaymentType> for i32 {
2262    // Codec=Cst (C-struct based), see doc to use other codecs
2263    fn cst_decode(self) -> crate::model::PaymentType {
2264        match self {
2265            0 => crate::model::PaymentType::Receive,
2266            1 => crate::model::PaymentType::Send,
2267            _ => unreachable!("Invalid variant for PaymentType: {}", self),
2268        }
2269    }
2270}
2271impl CstDecode<u16> for u16 {
2272    // Codec=Cst (C-struct based), see doc to use other codecs
2273    fn cst_decode(self) -> u16 {
2274        self
2275    }
2276}
2277impl CstDecode<u32> for u32 {
2278    // Codec=Cst (C-struct based), see doc to use other codecs
2279    fn cst_decode(self) -> u32 {
2280        self
2281    }
2282}
2283impl CstDecode<u64> for u64 {
2284    // Codec=Cst (C-struct based), see doc to use other codecs
2285    fn cst_decode(self) -> u64 {
2286        self
2287    }
2288}
2289impl CstDecode<u8> for u8 {
2290    // Codec=Cst (C-struct based), see doc to use other codecs
2291    fn cst_decode(self) -> u8 {
2292        self
2293    }
2294}
2295impl CstDecode<usize> for usize {
2296    // Codec=Cst (C-struct based), see doc to use other codecs
2297    fn cst_decode(self) -> usize {
2298        self
2299    }
2300}
2301impl SseDecode for flutter_rust_bridge::for_generated::anyhow::Error {
2302    // Codec=Sse (Serialization based), see doc to use other codecs
2303    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2304        let mut inner = <String>::sse_decode(deserializer);
2305        return flutter_rust_bridge::for_generated::anyhow::anyhow!("{}", inner);
2306    }
2307}
2308
2309impl SseDecode for BindingLiquidSdk {
2310    // Codec=Sse (Serialization based), see doc to use other codecs
2311    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2312        let mut inner = <RustOpaqueNom<
2313            flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>,
2314        >>::sse_decode(deserializer);
2315        return flutter_rust_bridge::for_generated::rust_auto_opaque_decode_owned(inner);
2316    }
2317}
2318
2319impl SseDecode
2320    for RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>
2321{
2322    // Codec=Sse (Serialization based), see doc to use other codecs
2323    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2324        let mut inner = <usize>::sse_decode(deserializer);
2325        return unsafe { decode_rust_opaque_nom(inner) };
2326    }
2327}
2328
2329impl SseDecode
2330    for StreamSink<crate::model::LogEntry, flutter_rust_bridge::for_generated::DcoCodec>
2331{
2332    // Codec=Sse (Serialization based), see doc to use other codecs
2333    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2334        let mut inner = <String>::sse_decode(deserializer);
2335        return StreamSink::deserialize(inner);
2336    }
2337}
2338
2339impl SseDecode
2340    for StreamSink<crate::model::SdkEvent, flutter_rust_bridge::for_generated::DcoCodec>
2341{
2342    // Codec=Sse (Serialization based), see doc to use other codecs
2343    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2344        let mut inner = <String>::sse_decode(deserializer);
2345        return StreamSink::deserialize(inner);
2346    }
2347}
2348
2349impl SseDecode for String {
2350    // Codec=Sse (Serialization based), see doc to use other codecs
2351    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2352        let mut inner = <Vec<u8>>::sse_decode(deserializer);
2353        return String::from_utf8(inner).unwrap();
2354    }
2355}
2356
2357impl SseDecode for crate::model::AcceptPaymentProposedFeesRequest {
2358    // Codec=Sse (Serialization based), see doc to use other codecs
2359    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2360        let mut var_response =
2361            <crate::model::FetchPaymentProposedFeesResponse>::sse_decode(deserializer);
2362        return crate::model::AcceptPaymentProposedFeesRequest {
2363            response: var_response,
2364        };
2365    }
2366}
2367
2368impl SseDecode for crate::bindings::AesSuccessActionData {
2369    // Codec=Sse (Serialization based), see doc to use other codecs
2370    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2371        let mut var_description = <String>::sse_decode(deserializer);
2372        let mut var_ciphertext = <String>::sse_decode(deserializer);
2373        let mut var_iv = <String>::sse_decode(deserializer);
2374        return crate::bindings::AesSuccessActionData {
2375            description: var_description,
2376            ciphertext: var_ciphertext,
2377            iv: var_iv,
2378        };
2379    }
2380}
2381
2382impl SseDecode for crate::bindings::AesSuccessActionDataDecrypted {
2383    // Codec=Sse (Serialization based), see doc to use other codecs
2384    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2385        let mut var_description = <String>::sse_decode(deserializer);
2386        let mut var_plaintext = <String>::sse_decode(deserializer);
2387        return crate::bindings::AesSuccessActionDataDecrypted {
2388            description: var_description,
2389            plaintext: var_plaintext,
2390        };
2391    }
2392}
2393
2394impl SseDecode for crate::bindings::AesSuccessActionDataResult {
2395    // Codec=Sse (Serialization based), see doc to use other codecs
2396    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2397        let mut tag_ = <i32>::sse_decode(deserializer);
2398        match tag_ {
2399            0 => {
2400                let mut var_data =
2401                    <crate::bindings::AesSuccessActionDataDecrypted>::sse_decode(deserializer);
2402                return crate::bindings::AesSuccessActionDataResult::Decrypted { data: var_data };
2403            }
2404            1 => {
2405                let mut var_reason = <String>::sse_decode(deserializer);
2406                return crate::bindings::AesSuccessActionDataResult::ErrorStatus {
2407                    reason: var_reason,
2408                };
2409            }
2410            _ => {
2411                unimplemented!("");
2412            }
2413        }
2414    }
2415}
2416
2417impl SseDecode for crate::bindings::Amount {
2418    // Codec=Sse (Serialization based), see doc to use other codecs
2419    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2420        let mut tag_ = <i32>::sse_decode(deserializer);
2421        match tag_ {
2422            0 => {
2423                let mut var_amountMsat = <u64>::sse_decode(deserializer);
2424                return crate::bindings::Amount::Bitcoin {
2425                    amount_msat: var_amountMsat,
2426                };
2427            }
2428            1 => {
2429                let mut var_iso4217Code = <String>::sse_decode(deserializer);
2430                let mut var_fractionalAmount = <u64>::sse_decode(deserializer);
2431                return crate::bindings::Amount::Currency {
2432                    iso4217_code: var_iso4217Code,
2433                    fractional_amount: var_fractionalAmount,
2434                };
2435            }
2436            _ => {
2437                unimplemented!("");
2438            }
2439        }
2440    }
2441}
2442
2443impl SseDecode for crate::model::AssetBalance {
2444    // Codec=Sse (Serialization based), see doc to use other codecs
2445    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2446        let mut var_assetId = <String>::sse_decode(deserializer);
2447        let mut var_balanceSat = <u64>::sse_decode(deserializer);
2448        let mut var_name = <Option<String>>::sse_decode(deserializer);
2449        let mut var_ticker = <Option<String>>::sse_decode(deserializer);
2450        let mut var_balance = <Option<f64>>::sse_decode(deserializer);
2451        return crate::model::AssetBalance {
2452            asset_id: var_assetId,
2453            balance_sat: var_balanceSat,
2454            name: var_name,
2455            ticker: var_ticker,
2456            balance: var_balance,
2457        };
2458    }
2459}
2460
2461impl SseDecode for crate::model::AssetInfo {
2462    // Codec=Sse (Serialization based), see doc to use other codecs
2463    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2464        let mut var_name = <String>::sse_decode(deserializer);
2465        let mut var_ticker = <String>::sse_decode(deserializer);
2466        let mut var_amount = <f64>::sse_decode(deserializer);
2467        let mut var_fees = <Option<f64>>::sse_decode(deserializer);
2468        return crate::model::AssetInfo {
2469            name: var_name,
2470            ticker: var_ticker,
2471            amount: var_amount,
2472            fees: var_fees,
2473        };
2474    }
2475}
2476
2477impl SseDecode for crate::model::AssetMetadata {
2478    // Codec=Sse (Serialization based), see doc to use other codecs
2479    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2480        let mut var_assetId = <String>::sse_decode(deserializer);
2481        let mut var_name = <String>::sse_decode(deserializer);
2482        let mut var_ticker = <String>::sse_decode(deserializer);
2483        let mut var_precision = <u8>::sse_decode(deserializer);
2484        let mut var_fiatId = <Option<String>>::sse_decode(deserializer);
2485        return crate::model::AssetMetadata {
2486            asset_id: var_assetId,
2487            name: var_name,
2488            ticker: var_ticker,
2489            precision: var_precision,
2490            fiat_id: var_fiatId,
2491        };
2492    }
2493}
2494
2495impl SseDecode for crate::model::BackupRequest {
2496    // Codec=Sse (Serialization based), see doc to use other codecs
2497    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2498        let mut var_backupPath = <Option<String>>::sse_decode(deserializer);
2499        return crate::model::BackupRequest {
2500            backup_path: var_backupPath,
2501        };
2502    }
2503}
2504
2505impl SseDecode for crate::bindings::BindingEventListener {
2506    // Codec=Sse (Serialization based), see doc to use other codecs
2507    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2508        let mut var_stream = <StreamSink<
2509            crate::model::SdkEvent,
2510            flutter_rust_bridge::for_generated::DcoCodec,
2511        >>::sse_decode(deserializer);
2512        return crate::bindings::BindingEventListener { stream: var_stream };
2513    }
2514}
2515
2516impl SseDecode for crate::bindings::BitcoinAddressData {
2517    // Codec=Sse (Serialization based), see doc to use other codecs
2518    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2519        let mut var_address = <String>::sse_decode(deserializer);
2520        let mut var_network = <crate::bindings::Network>::sse_decode(deserializer);
2521        let mut var_amountSat = <Option<u64>>::sse_decode(deserializer);
2522        let mut var_label = <Option<String>>::sse_decode(deserializer);
2523        let mut var_message = <Option<String>>::sse_decode(deserializer);
2524        return crate::bindings::BitcoinAddressData {
2525            address: var_address,
2526            network: var_network,
2527            amount_sat: var_amountSat,
2528            label: var_label,
2529            message: var_message,
2530        };
2531    }
2532}
2533
2534impl SseDecode for crate::model::BlockchainExplorer {
2535    // Codec=Sse (Serialization based), see doc to use other codecs
2536    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2537        let mut tag_ = <i32>::sse_decode(deserializer);
2538        match tag_ {
2539            0 => {
2540                let mut var_url = <String>::sse_decode(deserializer);
2541                return crate::model::BlockchainExplorer::Electrum { url: var_url };
2542            }
2543            1 => {
2544                let mut var_url = <String>::sse_decode(deserializer);
2545                let mut var_useWaterfalls = <bool>::sse_decode(deserializer);
2546                return crate::model::BlockchainExplorer::Esplora {
2547                    url: var_url,
2548                    use_waterfalls: var_useWaterfalls,
2549                };
2550            }
2551            _ => {
2552                unimplemented!("");
2553            }
2554        }
2555    }
2556}
2557
2558impl SseDecode for crate::model::BlockchainInfo {
2559    // Codec=Sse (Serialization based), see doc to use other codecs
2560    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2561        let mut var_liquidTip = <u32>::sse_decode(deserializer);
2562        let mut var_bitcoinTip = <u32>::sse_decode(deserializer);
2563        return crate::model::BlockchainInfo {
2564            liquid_tip: var_liquidTip,
2565            bitcoin_tip: var_bitcoinTip,
2566        };
2567    }
2568}
2569
2570impl SseDecode for bool {
2571    // Codec=Sse (Serialization based), see doc to use other codecs
2572    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2573        deserializer.cursor.read_u8().unwrap() != 0
2574    }
2575}
2576
2577impl SseDecode for crate::model::BuyBitcoinProvider {
2578    // Codec=Sse (Serialization based), see doc to use other codecs
2579    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2580        let mut inner = <i32>::sse_decode(deserializer);
2581        return match inner {
2582            0 => crate::model::BuyBitcoinProvider::Moonpay,
2583            _ => unreachable!("Invalid variant for BuyBitcoinProvider: {}", inner),
2584        };
2585    }
2586}
2587
2588impl SseDecode for crate::model::BuyBitcoinRequest {
2589    // Codec=Sse (Serialization based), see doc to use other codecs
2590    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2591        let mut var_prepareResponse =
2592            <crate::model::PrepareBuyBitcoinResponse>::sse_decode(deserializer);
2593        let mut var_redirectUrl = <Option<String>>::sse_decode(deserializer);
2594        return crate::model::BuyBitcoinRequest {
2595            prepare_response: var_prepareResponse,
2596            redirect_url: var_redirectUrl,
2597        };
2598    }
2599}
2600
2601impl SseDecode for crate::model::CheckMessageRequest {
2602    // Codec=Sse (Serialization based), see doc to use other codecs
2603    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2604        let mut var_message = <String>::sse_decode(deserializer);
2605        let mut var_pubkey = <String>::sse_decode(deserializer);
2606        let mut var_signature = <String>::sse_decode(deserializer);
2607        return crate::model::CheckMessageRequest {
2608            message: var_message,
2609            pubkey: var_pubkey,
2610            signature: var_signature,
2611        };
2612    }
2613}
2614
2615impl SseDecode for crate::model::CheckMessageResponse {
2616    // Codec=Sse (Serialization based), see doc to use other codecs
2617    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2618        let mut var_isValid = <bool>::sse_decode(deserializer);
2619        return crate::model::CheckMessageResponse {
2620            is_valid: var_isValid,
2621        };
2622    }
2623}
2624
2625impl SseDecode for crate::model::Config {
2626    // Codec=Sse (Serialization based), see doc to use other codecs
2627    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2628        let mut var_liquidExplorer = <crate::model::BlockchainExplorer>::sse_decode(deserializer);
2629        let mut var_bitcoinExplorer = <crate::model::BlockchainExplorer>::sse_decode(deserializer);
2630        let mut var_workingDir = <String>::sse_decode(deserializer);
2631        let mut var_cacheDir = <Option<String>>::sse_decode(deserializer);
2632        let mut var_network = <crate::model::LiquidNetwork>::sse_decode(deserializer);
2633        let mut var_paymentTimeoutSec = <u64>::sse_decode(deserializer);
2634        let mut var_syncServiceUrl = <Option<String>>::sse_decode(deserializer);
2635        let mut var_zeroConfMaxAmountSat = <Option<u64>>::sse_decode(deserializer);
2636        let mut var_breezApiKey = <Option<String>>::sse_decode(deserializer);
2637        let mut var_externalInputParsers =
2638            <Option<Vec<crate::bindings::ExternalInputParser>>>::sse_decode(deserializer);
2639        let mut var_useDefaultExternalInputParsers = <bool>::sse_decode(deserializer);
2640        let mut var_onchainFeeRateLeewaySatPerVbyte = <Option<u32>>::sse_decode(deserializer);
2641        let mut var_assetMetadata =
2642            <Option<Vec<crate::model::AssetMetadata>>>::sse_decode(deserializer);
2643        let mut var_sideswapApiKey = <Option<String>>::sse_decode(deserializer);
2644        return crate::model::Config {
2645            liquid_explorer: var_liquidExplorer,
2646            bitcoin_explorer: var_bitcoinExplorer,
2647            working_dir: var_workingDir,
2648            cache_dir: var_cacheDir,
2649            network: var_network,
2650            payment_timeout_sec: var_paymentTimeoutSec,
2651            sync_service_url: var_syncServiceUrl,
2652            zero_conf_max_amount_sat: var_zeroConfMaxAmountSat,
2653            breez_api_key: var_breezApiKey,
2654            external_input_parsers: var_externalInputParsers,
2655            use_default_external_input_parsers: var_useDefaultExternalInputParsers,
2656            onchain_fee_rate_leeway_sat_per_vbyte: var_onchainFeeRateLeewaySatPerVbyte,
2657            asset_metadata: var_assetMetadata,
2658            sideswap_api_key: var_sideswapApiKey,
2659        };
2660    }
2661}
2662
2663impl SseDecode for crate::model::ConnectRequest {
2664    // Codec=Sse (Serialization based), see doc to use other codecs
2665    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2666        let mut var_config = <crate::model::Config>::sse_decode(deserializer);
2667        let mut var_mnemonic = <Option<String>>::sse_decode(deserializer);
2668        let mut var_passphrase = <Option<String>>::sse_decode(deserializer);
2669        let mut var_seed = <Option<Vec<u8>>>::sse_decode(deserializer);
2670        return crate::model::ConnectRequest {
2671            config: var_config,
2672            mnemonic: var_mnemonic,
2673            passphrase: var_passphrase,
2674            seed: var_seed,
2675        };
2676    }
2677}
2678
2679impl SseDecode for crate::model::CreateBolt12InvoiceRequest {
2680    // Codec=Sse (Serialization based), see doc to use other codecs
2681    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2682        let mut var_offer = <String>::sse_decode(deserializer);
2683        let mut var_invoiceRequest = <String>::sse_decode(deserializer);
2684        return crate::model::CreateBolt12InvoiceRequest {
2685            offer: var_offer,
2686            invoice_request: var_invoiceRequest,
2687        };
2688    }
2689}
2690
2691impl SseDecode for crate::model::CreateBolt12InvoiceResponse {
2692    // Codec=Sse (Serialization based), see doc to use other codecs
2693    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2694        let mut var_invoice = <String>::sse_decode(deserializer);
2695        return crate::model::CreateBolt12InvoiceResponse {
2696            invoice: var_invoice,
2697        };
2698    }
2699}
2700
2701impl SseDecode for crate::bindings::CurrencyInfo {
2702    // Codec=Sse (Serialization based), see doc to use other codecs
2703    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2704        let mut var_name = <String>::sse_decode(deserializer);
2705        let mut var_fractionSize = <u32>::sse_decode(deserializer);
2706        let mut var_spacing = <Option<u32>>::sse_decode(deserializer);
2707        let mut var_symbol = <Option<crate::bindings::Symbol>>::sse_decode(deserializer);
2708        let mut var_uniqSymbol = <Option<crate::bindings::Symbol>>::sse_decode(deserializer);
2709        let mut var_localizedName = <Vec<crate::bindings::LocalizedName>>::sse_decode(deserializer);
2710        let mut var_localeOverrides =
2711            <Vec<crate::bindings::LocaleOverrides>>::sse_decode(deserializer);
2712        return crate::bindings::CurrencyInfo {
2713            name: var_name,
2714            fraction_size: var_fractionSize,
2715            spacing: var_spacing,
2716            symbol: var_symbol,
2717            uniq_symbol: var_uniqSymbol,
2718            localized_name: var_localizedName,
2719            locale_overrides: var_localeOverrides,
2720        };
2721    }
2722}
2723
2724impl SseDecode for crate::bindings::ExternalInputParser {
2725    // Codec=Sse (Serialization based), see doc to use other codecs
2726    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2727        let mut var_providerId = <String>::sse_decode(deserializer);
2728        let mut var_inputRegex = <String>::sse_decode(deserializer);
2729        let mut var_parserUrl = <String>::sse_decode(deserializer);
2730        return crate::bindings::ExternalInputParser {
2731            provider_id: var_providerId,
2732            input_regex: var_inputRegex,
2733            parser_url: var_parserUrl,
2734        };
2735    }
2736}
2737
2738impl SseDecode for f64 {
2739    // Codec=Sse (Serialization based), see doc to use other codecs
2740    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2741        deserializer.cursor.read_f64::<NativeEndian>().unwrap()
2742    }
2743}
2744
2745impl SseDecode for crate::model::FetchPaymentProposedFeesRequest {
2746    // Codec=Sse (Serialization based), see doc to use other codecs
2747    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2748        let mut var_swapId = <String>::sse_decode(deserializer);
2749        return crate::model::FetchPaymentProposedFeesRequest {
2750            swap_id: var_swapId,
2751        };
2752    }
2753}
2754
2755impl SseDecode for crate::model::FetchPaymentProposedFeesResponse {
2756    // Codec=Sse (Serialization based), see doc to use other codecs
2757    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2758        let mut var_swapId = <String>::sse_decode(deserializer);
2759        let mut var_feesSat = <u64>::sse_decode(deserializer);
2760        let mut var_payerAmountSat = <u64>::sse_decode(deserializer);
2761        let mut var_receiverAmountSat = <u64>::sse_decode(deserializer);
2762        return crate::model::FetchPaymentProposedFeesResponse {
2763            swap_id: var_swapId,
2764            fees_sat: var_feesSat,
2765            payer_amount_sat: var_payerAmountSat,
2766            receiver_amount_sat: var_receiverAmountSat,
2767        };
2768    }
2769}
2770
2771impl SseDecode for crate::bindings::FiatCurrency {
2772    // Codec=Sse (Serialization based), see doc to use other codecs
2773    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2774        let mut var_id = <String>::sse_decode(deserializer);
2775        let mut var_info = <crate::bindings::CurrencyInfo>::sse_decode(deserializer);
2776        return crate::bindings::FiatCurrency {
2777            id: var_id,
2778            info: var_info,
2779        };
2780    }
2781}
2782
2783impl SseDecode for crate::model::GetInfoResponse {
2784    // Codec=Sse (Serialization based), see doc to use other codecs
2785    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2786        let mut var_walletInfo = <crate::model::WalletInfo>::sse_decode(deserializer);
2787        let mut var_blockchainInfo = <crate::model::BlockchainInfo>::sse_decode(deserializer);
2788        return crate::model::GetInfoResponse {
2789            wallet_info: var_walletInfo,
2790            blockchain_info: var_blockchainInfo,
2791        };
2792    }
2793}
2794
2795impl SseDecode for crate::model::GetPaymentRequest {
2796    // Codec=Sse (Serialization based), see doc to use other codecs
2797    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2798        let mut tag_ = <i32>::sse_decode(deserializer);
2799        match tag_ {
2800            0 => {
2801                let mut var_paymentHash = <String>::sse_decode(deserializer);
2802                return crate::model::GetPaymentRequest::PaymentHash {
2803                    payment_hash: var_paymentHash,
2804                };
2805            }
2806            1 => {
2807                let mut var_swapId = <String>::sse_decode(deserializer);
2808                return crate::model::GetPaymentRequest::SwapId {
2809                    swap_id: var_swapId,
2810                };
2811            }
2812            _ => {
2813                unimplemented!("");
2814            }
2815        }
2816    }
2817}
2818
2819impl SseDecode for i32 {
2820    // Codec=Sse (Serialization based), see doc to use other codecs
2821    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2822        deserializer.cursor.read_i32::<NativeEndian>().unwrap()
2823    }
2824}
2825
2826impl SseDecode for i64 {
2827    // Codec=Sse (Serialization based), see doc to use other codecs
2828    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2829        deserializer.cursor.read_i64::<NativeEndian>().unwrap()
2830    }
2831}
2832
2833impl SseDecode for crate::bindings::InputType {
2834    // Codec=Sse (Serialization based), see doc to use other codecs
2835    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2836        let mut tag_ = <i32>::sse_decode(deserializer);
2837        match tag_ {
2838            0 => {
2839                let mut var_address =
2840                    <crate::bindings::BitcoinAddressData>::sse_decode(deserializer);
2841                return crate::bindings::InputType::BitcoinAddress {
2842                    address: var_address,
2843                };
2844            }
2845            1 => {
2846                let mut var_address =
2847                    <crate::bindings::LiquidAddressData>::sse_decode(deserializer);
2848                return crate::bindings::InputType::LiquidAddress {
2849                    address: var_address,
2850                };
2851            }
2852            2 => {
2853                let mut var_invoice = <crate::bindings::LNInvoice>::sse_decode(deserializer);
2854                return crate::bindings::InputType::Bolt11 {
2855                    invoice: var_invoice,
2856                };
2857            }
2858            3 => {
2859                let mut var_offer = <crate::bindings::LNOffer>::sse_decode(deserializer);
2860                let mut var_bip353Address = <Option<String>>::sse_decode(deserializer);
2861                return crate::bindings::InputType::Bolt12Offer {
2862                    offer: var_offer,
2863                    bip353_address: var_bip353Address,
2864                };
2865            }
2866            4 => {
2867                let mut var_nodeId = <String>::sse_decode(deserializer);
2868                return crate::bindings::InputType::NodeId {
2869                    node_id: var_nodeId,
2870                };
2871            }
2872            5 => {
2873                let mut var_url = <String>::sse_decode(deserializer);
2874                return crate::bindings::InputType::Url { url: var_url };
2875            }
2876            6 => {
2877                let mut var_data = <crate::bindings::LnUrlPayRequestData>::sse_decode(deserializer);
2878                let mut var_bip353Address = <Option<String>>::sse_decode(deserializer);
2879                return crate::bindings::InputType::LnUrlPay {
2880                    data: var_data,
2881                    bip353_address: var_bip353Address,
2882                };
2883            }
2884            7 => {
2885                let mut var_data =
2886                    <crate::bindings::LnUrlWithdrawRequestData>::sse_decode(deserializer);
2887                return crate::bindings::InputType::LnUrlWithdraw { data: var_data };
2888            }
2889            8 => {
2890                let mut var_data =
2891                    <crate::bindings::LnUrlAuthRequestData>::sse_decode(deserializer);
2892                return crate::bindings::InputType::LnUrlAuth { data: var_data };
2893            }
2894            9 => {
2895                let mut var_data = <crate::bindings::LnUrlErrorData>::sse_decode(deserializer);
2896                return crate::bindings::InputType::LnUrlError { data: var_data };
2897            }
2898            _ => {
2899                unimplemented!("");
2900            }
2901        }
2902    }
2903}
2904
2905impl SseDecode for crate::model::LightningPaymentLimitsResponse {
2906    // Codec=Sse (Serialization based), see doc to use other codecs
2907    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2908        let mut var_send = <crate::model::Limits>::sse_decode(deserializer);
2909        let mut var_receive = <crate::model::Limits>::sse_decode(deserializer);
2910        return crate::model::LightningPaymentLimitsResponse {
2911            send: var_send,
2912            receive: var_receive,
2913        };
2914    }
2915}
2916
2917impl SseDecode for crate::model::Limits {
2918    // Codec=Sse (Serialization based), see doc to use other codecs
2919    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2920        let mut var_minSat = <u64>::sse_decode(deserializer);
2921        let mut var_maxSat = <u64>::sse_decode(deserializer);
2922        let mut var_maxZeroConfSat = <u64>::sse_decode(deserializer);
2923        return crate::model::Limits {
2924            min_sat: var_minSat,
2925            max_sat: var_maxSat,
2926            max_zero_conf_sat: var_maxZeroConfSat,
2927        };
2928    }
2929}
2930
2931impl SseDecode for crate::bindings::LiquidAddressData {
2932    // Codec=Sse (Serialization based), see doc to use other codecs
2933    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2934        let mut var_address = <String>::sse_decode(deserializer);
2935        let mut var_network = <crate::bindings::Network>::sse_decode(deserializer);
2936        let mut var_assetId = <Option<String>>::sse_decode(deserializer);
2937        let mut var_amount = <Option<f64>>::sse_decode(deserializer);
2938        let mut var_amountSat = <Option<u64>>::sse_decode(deserializer);
2939        let mut var_label = <Option<String>>::sse_decode(deserializer);
2940        let mut var_message = <Option<String>>::sse_decode(deserializer);
2941        return crate::bindings::LiquidAddressData {
2942            address: var_address,
2943            network: var_network,
2944            asset_id: var_assetId,
2945            amount: var_amount,
2946            amount_sat: var_amountSat,
2947            label: var_label,
2948            message: var_message,
2949        };
2950    }
2951}
2952
2953impl SseDecode for crate::model::LiquidNetwork {
2954    // Codec=Sse (Serialization based), see doc to use other codecs
2955    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2956        let mut inner = <i32>::sse_decode(deserializer);
2957        return match inner {
2958            0 => crate::model::LiquidNetwork::Mainnet,
2959            1 => crate::model::LiquidNetwork::Testnet,
2960            2 => crate::model::LiquidNetwork::Regtest,
2961            _ => unreachable!("Invalid variant for LiquidNetwork: {}", inner),
2962        };
2963    }
2964}
2965
2966impl SseDecode for Vec<String> {
2967    // Codec=Sse (Serialization based), see doc to use other codecs
2968    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2969        let mut len_ = <i32>::sse_decode(deserializer);
2970        let mut ans_ = vec![];
2971        for idx_ in 0..len_ {
2972            ans_.push(<String>::sse_decode(deserializer));
2973        }
2974        return ans_;
2975    }
2976}
2977
2978impl SseDecode for Vec<crate::model::AssetBalance> {
2979    // Codec=Sse (Serialization based), see doc to use other codecs
2980    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2981        let mut len_ = <i32>::sse_decode(deserializer);
2982        let mut ans_ = vec![];
2983        for idx_ in 0..len_ {
2984            ans_.push(<crate::model::AssetBalance>::sse_decode(deserializer));
2985        }
2986        return ans_;
2987    }
2988}
2989
2990impl SseDecode for Vec<crate::model::AssetMetadata> {
2991    // Codec=Sse (Serialization based), see doc to use other codecs
2992    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2993        let mut len_ = <i32>::sse_decode(deserializer);
2994        let mut ans_ = vec![];
2995        for idx_ in 0..len_ {
2996            ans_.push(<crate::model::AssetMetadata>::sse_decode(deserializer));
2997        }
2998        return ans_;
2999    }
3000}
3001
3002impl SseDecode for Vec<crate::bindings::ExternalInputParser> {
3003    // Codec=Sse (Serialization based), see doc to use other codecs
3004    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3005        let mut len_ = <i32>::sse_decode(deserializer);
3006        let mut ans_ = vec![];
3007        for idx_ in 0..len_ {
3008            ans_.push(<crate::bindings::ExternalInputParser>::sse_decode(
3009                deserializer,
3010            ));
3011        }
3012        return ans_;
3013    }
3014}
3015
3016impl SseDecode for Vec<crate::bindings::FiatCurrency> {
3017    // Codec=Sse (Serialization based), see doc to use other codecs
3018    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3019        let mut len_ = <i32>::sse_decode(deserializer);
3020        let mut ans_ = vec![];
3021        for idx_ in 0..len_ {
3022            ans_.push(<crate::bindings::FiatCurrency>::sse_decode(deserializer));
3023        }
3024        return ans_;
3025    }
3026}
3027
3028impl SseDecode for Vec<crate::bindings::LnOfferBlindedPath> {
3029    // Codec=Sse (Serialization based), see doc to use other codecs
3030    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3031        let mut len_ = <i32>::sse_decode(deserializer);
3032        let mut ans_ = vec![];
3033        for idx_ in 0..len_ {
3034            ans_.push(<crate::bindings::LnOfferBlindedPath>::sse_decode(
3035                deserializer,
3036            ));
3037        }
3038        return ans_;
3039    }
3040}
3041
3042impl SseDecode for Vec<crate::bindings::LocaleOverrides> {
3043    // Codec=Sse (Serialization based), see doc to use other codecs
3044    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3045        let mut len_ = <i32>::sse_decode(deserializer);
3046        let mut ans_ = vec![];
3047        for idx_ in 0..len_ {
3048            ans_.push(<crate::bindings::LocaleOverrides>::sse_decode(deserializer));
3049        }
3050        return ans_;
3051    }
3052}
3053
3054impl SseDecode for Vec<crate::bindings::LocalizedName> {
3055    // Codec=Sse (Serialization based), see doc to use other codecs
3056    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3057        let mut len_ = <i32>::sse_decode(deserializer);
3058        let mut ans_ = vec![];
3059        for idx_ in 0..len_ {
3060            ans_.push(<crate::bindings::LocalizedName>::sse_decode(deserializer));
3061        }
3062        return ans_;
3063    }
3064}
3065
3066impl SseDecode for Vec<crate::model::Payment> {
3067    // Codec=Sse (Serialization based), see doc to use other codecs
3068    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3069        let mut len_ = <i32>::sse_decode(deserializer);
3070        let mut ans_ = vec![];
3071        for idx_ in 0..len_ {
3072            ans_.push(<crate::model::Payment>::sse_decode(deserializer));
3073        }
3074        return ans_;
3075    }
3076}
3077
3078impl SseDecode for crate::model::ListPaymentDetails {
3079    // Codec=Sse (Serialization based), see doc to use other codecs
3080    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3081        let mut tag_ = <i32>::sse_decode(deserializer);
3082        match tag_ {
3083            0 => {
3084                let mut var_assetId = <Option<String>>::sse_decode(deserializer);
3085                let mut var_destination = <Option<String>>::sse_decode(deserializer);
3086                return crate::model::ListPaymentDetails::Liquid {
3087                    asset_id: var_assetId,
3088                    destination: var_destination,
3089                };
3090            }
3091            1 => {
3092                let mut var_address = <Option<String>>::sse_decode(deserializer);
3093                return crate::model::ListPaymentDetails::Bitcoin {
3094                    address: var_address,
3095                };
3096            }
3097            _ => {
3098                unimplemented!("");
3099            }
3100        }
3101    }
3102}
3103
3104impl SseDecode for Vec<crate::model::PaymentState> {
3105    // Codec=Sse (Serialization based), see doc to use other codecs
3106    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3107        let mut len_ = <i32>::sse_decode(deserializer);
3108        let mut ans_ = vec![];
3109        for idx_ in 0..len_ {
3110            ans_.push(<crate::model::PaymentState>::sse_decode(deserializer));
3111        }
3112        return ans_;
3113    }
3114}
3115
3116impl SseDecode for Vec<crate::model::PaymentType> {
3117    // Codec=Sse (Serialization based), see doc to use other codecs
3118    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3119        let mut len_ = <i32>::sse_decode(deserializer);
3120        let mut ans_ = vec![];
3121        for idx_ in 0..len_ {
3122            ans_.push(<crate::model::PaymentType>::sse_decode(deserializer));
3123        }
3124        return ans_;
3125    }
3126}
3127
3128impl SseDecode for crate::model::ListPaymentsRequest {
3129    // Codec=Sse (Serialization based), see doc to use other codecs
3130    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3131        let mut var_filters = <Option<Vec<crate::model::PaymentType>>>::sse_decode(deserializer);
3132        let mut var_states = <Option<Vec<crate::model::PaymentState>>>::sse_decode(deserializer);
3133        let mut var_fromTimestamp = <Option<i64>>::sse_decode(deserializer);
3134        let mut var_toTimestamp = <Option<i64>>::sse_decode(deserializer);
3135        let mut var_offset = <Option<u32>>::sse_decode(deserializer);
3136        let mut var_limit = <Option<u32>>::sse_decode(deserializer);
3137        let mut var_details = <Option<crate::model::ListPaymentDetails>>::sse_decode(deserializer);
3138        let mut var_sortAscending = <Option<bool>>::sse_decode(deserializer);
3139        return crate::model::ListPaymentsRequest {
3140            filters: var_filters,
3141            states: var_states,
3142            from_timestamp: var_fromTimestamp,
3143            to_timestamp: var_toTimestamp,
3144            offset: var_offset,
3145            limit: var_limit,
3146            details: var_details,
3147            sort_ascending: var_sortAscending,
3148        };
3149    }
3150}
3151
3152impl SseDecode for Vec<u8> {
3153    // Codec=Sse (Serialization based), see doc to use other codecs
3154    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3155        let mut len_ = <i32>::sse_decode(deserializer);
3156        let mut ans_ = vec![];
3157        for idx_ in 0..len_ {
3158            ans_.push(<u8>::sse_decode(deserializer));
3159        }
3160        return ans_;
3161    }
3162}
3163
3164impl SseDecode for Vec<crate::bindings::Rate> {
3165    // Codec=Sse (Serialization based), see doc to use other codecs
3166    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3167        let mut len_ = <i32>::sse_decode(deserializer);
3168        let mut ans_ = vec![];
3169        for idx_ in 0..len_ {
3170            ans_.push(<crate::bindings::Rate>::sse_decode(deserializer));
3171        }
3172        return ans_;
3173    }
3174}
3175
3176impl SseDecode for Vec<crate::model::RefundableSwap> {
3177    // Codec=Sse (Serialization based), see doc to use other codecs
3178    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3179        let mut len_ = <i32>::sse_decode(deserializer);
3180        let mut ans_ = vec![];
3181        for idx_ in 0..len_ {
3182            ans_.push(<crate::model::RefundableSwap>::sse_decode(deserializer));
3183        }
3184        return ans_;
3185    }
3186}
3187
3188impl SseDecode for Vec<crate::bindings::RouteHint> {
3189    // Codec=Sse (Serialization based), see doc to use other codecs
3190    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3191        let mut len_ = <i32>::sse_decode(deserializer);
3192        let mut ans_ = vec![];
3193        for idx_ in 0..len_ {
3194            ans_.push(<crate::bindings::RouteHint>::sse_decode(deserializer));
3195        }
3196        return ans_;
3197    }
3198}
3199
3200impl SseDecode for Vec<crate::bindings::RouteHintHop> {
3201    // Codec=Sse (Serialization based), see doc to use other codecs
3202    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3203        let mut len_ = <i32>::sse_decode(deserializer);
3204        let mut ans_ = vec![];
3205        for idx_ in 0..len_ {
3206            ans_.push(<crate::bindings::RouteHintHop>::sse_decode(deserializer));
3207        }
3208        return ans_;
3209    }
3210}
3211
3212impl SseDecode for crate::bindings::LNInvoice {
3213    // Codec=Sse (Serialization based), see doc to use other codecs
3214    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3215        let mut var_bolt11 = <String>::sse_decode(deserializer);
3216        let mut var_network = <crate::bindings::Network>::sse_decode(deserializer);
3217        let mut var_payeePubkey = <String>::sse_decode(deserializer);
3218        let mut var_paymentHash = <String>::sse_decode(deserializer);
3219        let mut var_description = <Option<String>>::sse_decode(deserializer);
3220        let mut var_descriptionHash = <Option<String>>::sse_decode(deserializer);
3221        let mut var_amountMsat = <Option<u64>>::sse_decode(deserializer);
3222        let mut var_timestamp = <u64>::sse_decode(deserializer);
3223        let mut var_expiry = <u64>::sse_decode(deserializer);
3224        let mut var_routingHints = <Vec<crate::bindings::RouteHint>>::sse_decode(deserializer);
3225        let mut var_paymentSecret = <Vec<u8>>::sse_decode(deserializer);
3226        let mut var_minFinalCltvExpiryDelta = <u64>::sse_decode(deserializer);
3227        return crate::bindings::LNInvoice {
3228            bolt11: var_bolt11,
3229            network: var_network,
3230            payee_pubkey: var_payeePubkey,
3231            payment_hash: var_paymentHash,
3232            description: var_description,
3233            description_hash: var_descriptionHash,
3234            amount_msat: var_amountMsat,
3235            timestamp: var_timestamp,
3236            expiry: var_expiry,
3237            routing_hints: var_routingHints,
3238            payment_secret: var_paymentSecret,
3239            min_final_cltv_expiry_delta: var_minFinalCltvExpiryDelta,
3240        };
3241    }
3242}
3243
3244impl SseDecode for crate::bindings::LNOffer {
3245    // Codec=Sse (Serialization based), see doc to use other codecs
3246    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3247        let mut var_offer = <String>::sse_decode(deserializer);
3248        let mut var_chains = <Vec<String>>::sse_decode(deserializer);
3249        let mut var_minAmount = <Option<crate::bindings::Amount>>::sse_decode(deserializer);
3250        let mut var_description = <Option<String>>::sse_decode(deserializer);
3251        let mut var_absoluteExpiry = <Option<u64>>::sse_decode(deserializer);
3252        let mut var_issuer = <Option<String>>::sse_decode(deserializer);
3253        let mut var_signingPubkey = <Option<String>>::sse_decode(deserializer);
3254        let mut var_paths = <Vec<crate::bindings::LnOfferBlindedPath>>::sse_decode(deserializer);
3255        return crate::bindings::LNOffer {
3256            offer: var_offer,
3257            chains: var_chains,
3258            min_amount: var_minAmount,
3259            description: var_description,
3260            absolute_expiry: var_absoluteExpiry,
3261            issuer: var_issuer,
3262            signing_pubkey: var_signingPubkey,
3263            paths: var_paths,
3264        };
3265    }
3266}
3267
3268impl SseDecode for crate::bindings::LnOfferBlindedPath {
3269    // Codec=Sse (Serialization based), see doc to use other codecs
3270    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3271        let mut var_blindedHops = <Vec<String>>::sse_decode(deserializer);
3272        return crate::bindings::LnOfferBlindedPath {
3273            blinded_hops: var_blindedHops,
3274        };
3275    }
3276}
3277
3278impl SseDecode for crate::bindings::duplicates::LnUrlAuthError {
3279    // Codec=Sse (Serialization based), see doc to use other codecs
3280    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3281        let mut tag_ = <i32>::sse_decode(deserializer);
3282        match tag_ {
3283            0 => {
3284                let mut var_err = <String>::sse_decode(deserializer);
3285                return crate::bindings::duplicates::LnUrlAuthError::Generic { err: var_err };
3286            }
3287            1 => {
3288                let mut var_err = <String>::sse_decode(deserializer);
3289                return crate::bindings::duplicates::LnUrlAuthError::InvalidUri { err: var_err };
3290            }
3291            2 => {
3292                let mut var_err = <String>::sse_decode(deserializer);
3293                return crate::bindings::duplicates::LnUrlAuthError::ServiceConnectivity {
3294                    err: var_err,
3295                };
3296            }
3297            _ => {
3298                unimplemented!("");
3299            }
3300        }
3301    }
3302}
3303
3304impl SseDecode for crate::bindings::LnUrlAuthRequestData {
3305    // Codec=Sse (Serialization based), see doc to use other codecs
3306    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3307        let mut var_k1 = <String>::sse_decode(deserializer);
3308        let mut var_action = <Option<String>>::sse_decode(deserializer);
3309        let mut var_domain = <String>::sse_decode(deserializer);
3310        let mut var_url = <String>::sse_decode(deserializer);
3311        return crate::bindings::LnUrlAuthRequestData {
3312            k1: var_k1,
3313            action: var_action,
3314            domain: var_domain,
3315            url: var_url,
3316        };
3317    }
3318}
3319
3320impl SseDecode for crate::bindings::duplicates::LnUrlCallbackStatus {
3321    // Codec=Sse (Serialization based), see doc to use other codecs
3322    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3323        let mut tag_ = <i32>::sse_decode(deserializer);
3324        match tag_ {
3325            0 => {
3326                return crate::bindings::duplicates::LnUrlCallbackStatus::Ok;
3327            }
3328            1 => {
3329                let mut var_data = <crate::bindings::LnUrlErrorData>::sse_decode(deserializer);
3330                return crate::bindings::duplicates::LnUrlCallbackStatus::ErrorStatus {
3331                    data: var_data,
3332                };
3333            }
3334            _ => {
3335                unimplemented!("");
3336            }
3337        }
3338    }
3339}
3340
3341impl SseDecode for crate::bindings::LnUrlErrorData {
3342    // Codec=Sse (Serialization based), see doc to use other codecs
3343    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3344        let mut var_reason = <String>::sse_decode(deserializer);
3345        return crate::bindings::LnUrlErrorData { reason: var_reason };
3346    }
3347}
3348
3349impl SseDecode for crate::model::LnUrlInfo {
3350    // Codec=Sse (Serialization based), see doc to use other codecs
3351    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3352        let mut var_lnAddress = <Option<String>>::sse_decode(deserializer);
3353        let mut var_lnurlPayComment = <Option<String>>::sse_decode(deserializer);
3354        let mut var_lnurlPayDomain = <Option<String>>::sse_decode(deserializer);
3355        let mut var_lnurlPayMetadata = <Option<String>>::sse_decode(deserializer);
3356        let mut var_lnurlPaySuccessAction =
3357            <Option<crate::bindings::SuccessActionProcessed>>::sse_decode(deserializer);
3358        let mut var_lnurlPayUnprocessedSuccessAction =
3359            <Option<crate::bindings::SuccessAction>>::sse_decode(deserializer);
3360        let mut var_lnurlWithdrawEndpoint = <Option<String>>::sse_decode(deserializer);
3361        return crate::model::LnUrlInfo {
3362            ln_address: var_lnAddress,
3363            lnurl_pay_comment: var_lnurlPayComment,
3364            lnurl_pay_domain: var_lnurlPayDomain,
3365            lnurl_pay_metadata: var_lnurlPayMetadata,
3366            lnurl_pay_success_action: var_lnurlPaySuccessAction,
3367            lnurl_pay_unprocessed_success_action: var_lnurlPayUnprocessedSuccessAction,
3368            lnurl_withdraw_endpoint: var_lnurlWithdrawEndpoint,
3369        };
3370    }
3371}
3372
3373impl SseDecode for crate::bindings::duplicates::LnUrlPayError {
3374    // Codec=Sse (Serialization based), see doc to use other codecs
3375    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3376        let mut tag_ = <i32>::sse_decode(deserializer);
3377        match tag_ {
3378            0 => {
3379                return crate::bindings::duplicates::LnUrlPayError::AlreadyPaid;
3380            }
3381            1 => {
3382                let mut var_err = <String>::sse_decode(deserializer);
3383                return crate::bindings::duplicates::LnUrlPayError::Generic { err: var_err };
3384            }
3385            2 => {
3386                let mut var_err = <String>::sse_decode(deserializer);
3387                return crate::bindings::duplicates::LnUrlPayError::InsufficientBalance {
3388                    err: var_err,
3389                };
3390            }
3391            3 => {
3392                let mut var_err = <String>::sse_decode(deserializer);
3393                return crate::bindings::duplicates::LnUrlPayError::InvalidAmount { err: var_err };
3394            }
3395            4 => {
3396                let mut var_err = <String>::sse_decode(deserializer);
3397                return crate::bindings::duplicates::LnUrlPayError::InvalidInvoice { err: var_err };
3398            }
3399            5 => {
3400                let mut var_err = <String>::sse_decode(deserializer);
3401                return crate::bindings::duplicates::LnUrlPayError::InvalidNetwork { err: var_err };
3402            }
3403            6 => {
3404                let mut var_err = <String>::sse_decode(deserializer);
3405                return crate::bindings::duplicates::LnUrlPayError::InvalidUri { err: var_err };
3406            }
3407            7 => {
3408                let mut var_err = <String>::sse_decode(deserializer);
3409                return crate::bindings::duplicates::LnUrlPayError::InvoiceExpired { err: var_err };
3410            }
3411            8 => {
3412                let mut var_err = <String>::sse_decode(deserializer);
3413                return crate::bindings::duplicates::LnUrlPayError::PaymentFailed { err: var_err };
3414            }
3415            9 => {
3416                let mut var_err = <String>::sse_decode(deserializer);
3417                return crate::bindings::duplicates::LnUrlPayError::PaymentTimeout { err: var_err };
3418            }
3419            10 => {
3420                let mut var_err = <String>::sse_decode(deserializer);
3421                return crate::bindings::duplicates::LnUrlPayError::RouteNotFound { err: var_err };
3422            }
3423            11 => {
3424                let mut var_err = <String>::sse_decode(deserializer);
3425                return crate::bindings::duplicates::LnUrlPayError::RouteTooExpensive {
3426                    err: var_err,
3427                };
3428            }
3429            12 => {
3430                let mut var_err = <String>::sse_decode(deserializer);
3431                return crate::bindings::duplicates::LnUrlPayError::ServiceConnectivity {
3432                    err: var_err,
3433                };
3434            }
3435            _ => {
3436                unimplemented!("");
3437            }
3438        }
3439    }
3440}
3441
3442impl SseDecode for crate::bindings::LnUrlPayErrorData {
3443    // Codec=Sse (Serialization based), see doc to use other codecs
3444    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3445        let mut var_paymentHash = <String>::sse_decode(deserializer);
3446        let mut var_reason = <String>::sse_decode(deserializer);
3447        return crate::bindings::LnUrlPayErrorData {
3448            payment_hash: var_paymentHash,
3449            reason: var_reason,
3450        };
3451    }
3452}
3453
3454impl SseDecode for crate::model::LnUrlPayRequest {
3455    // Codec=Sse (Serialization based), see doc to use other codecs
3456    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3457        let mut var_prepareResponse =
3458            <crate::model::PrepareLnUrlPayResponse>::sse_decode(deserializer);
3459        return crate::model::LnUrlPayRequest {
3460            prepare_response: var_prepareResponse,
3461        };
3462    }
3463}
3464
3465impl SseDecode for crate::bindings::LnUrlPayRequestData {
3466    // Codec=Sse (Serialization based), see doc to use other codecs
3467    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3468        let mut var_callback = <String>::sse_decode(deserializer);
3469        let mut var_minSendable = <u64>::sse_decode(deserializer);
3470        let mut var_maxSendable = <u64>::sse_decode(deserializer);
3471        let mut var_metadataStr = <String>::sse_decode(deserializer);
3472        let mut var_commentAllowed = <u16>::sse_decode(deserializer);
3473        let mut var_domain = <String>::sse_decode(deserializer);
3474        let mut var_allowsNostr = <bool>::sse_decode(deserializer);
3475        let mut var_nostrPubkey = <Option<String>>::sse_decode(deserializer);
3476        let mut var_lnAddress = <Option<String>>::sse_decode(deserializer);
3477        return crate::bindings::LnUrlPayRequestData {
3478            callback: var_callback,
3479            min_sendable: var_minSendable,
3480            max_sendable: var_maxSendable,
3481            metadata_str: var_metadataStr,
3482            comment_allowed: var_commentAllowed,
3483            domain: var_domain,
3484            allows_nostr: var_allowsNostr,
3485            nostr_pubkey: var_nostrPubkey,
3486            ln_address: var_lnAddress,
3487        };
3488    }
3489}
3490
3491impl SseDecode for crate::model::LnUrlPayResult {
3492    // Codec=Sse (Serialization based), see doc to use other codecs
3493    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3494        let mut tag_ = <i32>::sse_decode(deserializer);
3495        match tag_ {
3496            0 => {
3497                let mut var_data = <crate::model::LnUrlPaySuccessData>::sse_decode(deserializer);
3498                return crate::model::LnUrlPayResult::EndpointSuccess { data: var_data };
3499            }
3500            1 => {
3501                let mut var_data = <crate::bindings::LnUrlErrorData>::sse_decode(deserializer);
3502                return crate::model::LnUrlPayResult::EndpointError { data: var_data };
3503            }
3504            2 => {
3505                let mut var_data = <crate::bindings::LnUrlPayErrorData>::sse_decode(deserializer);
3506                return crate::model::LnUrlPayResult::PayError { data: var_data };
3507            }
3508            _ => {
3509                unimplemented!("");
3510            }
3511        }
3512    }
3513}
3514
3515impl SseDecode for crate::model::LnUrlPaySuccessData {
3516    // Codec=Sse (Serialization based), see doc to use other codecs
3517    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3518        let mut var_payment = <crate::model::Payment>::sse_decode(deserializer);
3519        let mut var_successAction =
3520            <Option<crate::bindings::SuccessActionProcessed>>::sse_decode(deserializer);
3521        return crate::model::LnUrlPaySuccessData {
3522            payment: var_payment,
3523            success_action: var_successAction,
3524        };
3525    }
3526}
3527
3528impl SseDecode for crate::bindings::duplicates::LnUrlWithdrawError {
3529    // Codec=Sse (Serialization based), see doc to use other codecs
3530    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3531        let mut tag_ = <i32>::sse_decode(deserializer);
3532        match tag_ {
3533            0 => {
3534                let mut var_err = <String>::sse_decode(deserializer);
3535                return crate::bindings::duplicates::LnUrlWithdrawError::Generic { err: var_err };
3536            }
3537            1 => {
3538                let mut var_err = <String>::sse_decode(deserializer);
3539                return crate::bindings::duplicates::LnUrlWithdrawError::InvalidAmount {
3540                    err: var_err,
3541                };
3542            }
3543            2 => {
3544                let mut var_err = <String>::sse_decode(deserializer);
3545                return crate::bindings::duplicates::LnUrlWithdrawError::InvalidInvoice {
3546                    err: var_err,
3547                };
3548            }
3549            3 => {
3550                let mut var_err = <String>::sse_decode(deserializer);
3551                return crate::bindings::duplicates::LnUrlWithdrawError::InvalidUri {
3552                    err: var_err,
3553                };
3554            }
3555            4 => {
3556                let mut var_err = <String>::sse_decode(deserializer);
3557                return crate::bindings::duplicates::LnUrlWithdrawError::InvoiceNoRoutingHints {
3558                    err: var_err,
3559                };
3560            }
3561            5 => {
3562                let mut var_err = <String>::sse_decode(deserializer);
3563                return crate::bindings::duplicates::LnUrlWithdrawError::ServiceConnectivity {
3564                    err: var_err,
3565                };
3566            }
3567            _ => {
3568                unimplemented!("");
3569            }
3570        }
3571    }
3572}
3573
3574impl SseDecode for crate::bindings::LnUrlWithdrawRequest {
3575    // Codec=Sse (Serialization based), see doc to use other codecs
3576    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3577        let mut var_data = <crate::bindings::LnUrlWithdrawRequestData>::sse_decode(deserializer);
3578        let mut var_amountMsat = <u64>::sse_decode(deserializer);
3579        let mut var_description = <Option<String>>::sse_decode(deserializer);
3580        return crate::bindings::LnUrlWithdrawRequest {
3581            data: var_data,
3582            amount_msat: var_amountMsat,
3583            description: var_description,
3584        };
3585    }
3586}
3587
3588impl SseDecode for crate::bindings::LnUrlWithdrawRequestData {
3589    // Codec=Sse (Serialization based), see doc to use other codecs
3590    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3591        let mut var_callback = <String>::sse_decode(deserializer);
3592        let mut var_k1 = <String>::sse_decode(deserializer);
3593        let mut var_defaultDescription = <String>::sse_decode(deserializer);
3594        let mut var_minWithdrawable = <u64>::sse_decode(deserializer);
3595        let mut var_maxWithdrawable = <u64>::sse_decode(deserializer);
3596        return crate::bindings::LnUrlWithdrawRequestData {
3597            callback: var_callback,
3598            k1: var_k1,
3599            default_description: var_defaultDescription,
3600            min_withdrawable: var_minWithdrawable,
3601            max_withdrawable: var_maxWithdrawable,
3602        };
3603    }
3604}
3605
3606impl SseDecode for crate::bindings::duplicates::LnUrlWithdrawResult {
3607    // Codec=Sse (Serialization based), see doc to use other codecs
3608    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3609        let mut tag_ = <i32>::sse_decode(deserializer);
3610        match tag_ {
3611            0 => {
3612                let mut var_data =
3613                    <crate::bindings::duplicates::LnUrlWithdrawSuccessData>::sse_decode(
3614                        deserializer,
3615                    );
3616                return crate::bindings::duplicates::LnUrlWithdrawResult::Ok { data: var_data };
3617            }
3618            1 => {
3619                let mut var_data =
3620                    <crate::bindings::duplicates::LnUrlWithdrawSuccessData>::sse_decode(
3621                        deserializer,
3622                    );
3623                return crate::bindings::duplicates::LnUrlWithdrawResult::Timeout {
3624                    data: var_data,
3625                };
3626            }
3627            2 => {
3628                let mut var_data = <crate::bindings::LnUrlErrorData>::sse_decode(deserializer);
3629                return crate::bindings::duplicates::LnUrlWithdrawResult::ErrorStatus {
3630                    data: var_data,
3631                };
3632            }
3633            _ => {
3634                unimplemented!("");
3635            }
3636        }
3637    }
3638}
3639
3640impl SseDecode for crate::bindings::duplicates::LnUrlWithdrawSuccessData {
3641    // Codec=Sse (Serialization based), see doc to use other codecs
3642    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3643        let mut var_invoice = <crate::bindings::LNInvoice>::sse_decode(deserializer);
3644        return crate::bindings::duplicates::LnUrlWithdrawSuccessData {
3645            invoice: var_invoice,
3646        };
3647    }
3648}
3649
3650impl SseDecode for crate::bindings::LocaleOverrides {
3651    // Codec=Sse (Serialization based), see doc to use other codecs
3652    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3653        let mut var_locale = <String>::sse_decode(deserializer);
3654        let mut var_spacing = <Option<u32>>::sse_decode(deserializer);
3655        let mut var_symbol = <crate::bindings::Symbol>::sse_decode(deserializer);
3656        return crate::bindings::LocaleOverrides {
3657            locale: var_locale,
3658            spacing: var_spacing,
3659            symbol: var_symbol,
3660        };
3661    }
3662}
3663
3664impl SseDecode for crate::bindings::LocalizedName {
3665    // Codec=Sse (Serialization based), see doc to use other codecs
3666    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3667        let mut var_locale = <String>::sse_decode(deserializer);
3668        let mut var_name = <String>::sse_decode(deserializer);
3669        return crate::bindings::LocalizedName {
3670            locale: var_locale,
3671            name: var_name,
3672        };
3673    }
3674}
3675
3676impl SseDecode for crate::model::LogEntry {
3677    // Codec=Sse (Serialization based), see doc to use other codecs
3678    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3679        let mut var_line = <String>::sse_decode(deserializer);
3680        let mut var_level = <String>::sse_decode(deserializer);
3681        return crate::model::LogEntry {
3682            line: var_line,
3683            level: var_level,
3684        };
3685    }
3686}
3687
3688impl SseDecode for crate::bindings::MessageSuccessActionData {
3689    // Codec=Sse (Serialization based), see doc to use other codecs
3690    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3691        let mut var_message = <String>::sse_decode(deserializer);
3692        return crate::bindings::MessageSuccessActionData {
3693            message: var_message,
3694        };
3695    }
3696}
3697
3698impl SseDecode for crate::bindings::Network {
3699    // Codec=Sse (Serialization based), see doc to use other codecs
3700    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3701        let mut inner = <i32>::sse_decode(deserializer);
3702        return match inner {
3703            0 => crate::bindings::Network::Bitcoin,
3704            1 => crate::bindings::Network::Testnet,
3705            2 => crate::bindings::Network::Signet,
3706            3 => crate::bindings::Network::Regtest,
3707            _ => unreachable!("Invalid variant for Network: {}", inner),
3708        };
3709    }
3710}
3711
3712impl SseDecode for crate::model::OnchainPaymentLimitsResponse {
3713    // Codec=Sse (Serialization based), see doc to use other codecs
3714    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3715        let mut var_send = <crate::model::Limits>::sse_decode(deserializer);
3716        let mut var_receive = <crate::model::Limits>::sse_decode(deserializer);
3717        return crate::model::OnchainPaymentLimitsResponse {
3718            send: var_send,
3719            receive: var_receive,
3720        };
3721    }
3722}
3723
3724impl SseDecode for Option<String> {
3725    // Codec=Sse (Serialization based), see doc to use other codecs
3726    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3727        if (<bool>::sse_decode(deserializer)) {
3728            return Some(<String>::sse_decode(deserializer));
3729        } else {
3730            return None;
3731        }
3732    }
3733}
3734
3735impl SseDecode for Option<crate::bindings::Amount> {
3736    // Codec=Sse (Serialization based), see doc to use other codecs
3737    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3738        if (<bool>::sse_decode(deserializer)) {
3739            return Some(<crate::bindings::Amount>::sse_decode(deserializer));
3740        } else {
3741            return None;
3742        }
3743    }
3744}
3745
3746impl SseDecode for Option<crate::model::AssetInfo> {
3747    // Codec=Sse (Serialization based), see doc to use other codecs
3748    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3749        if (<bool>::sse_decode(deserializer)) {
3750            return Some(<crate::model::AssetInfo>::sse_decode(deserializer));
3751        } else {
3752            return None;
3753        }
3754    }
3755}
3756
3757impl SseDecode for Option<bool> {
3758    // Codec=Sse (Serialization based), see doc to use other codecs
3759    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3760        if (<bool>::sse_decode(deserializer)) {
3761            return Some(<bool>::sse_decode(deserializer));
3762        } else {
3763            return None;
3764        }
3765    }
3766}
3767
3768impl SseDecode for Option<f64> {
3769    // Codec=Sse (Serialization based), see doc to use other codecs
3770    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3771        if (<bool>::sse_decode(deserializer)) {
3772            return Some(<f64>::sse_decode(deserializer));
3773        } else {
3774            return None;
3775        }
3776    }
3777}
3778
3779impl SseDecode for Option<i64> {
3780    // Codec=Sse (Serialization based), see doc to use other codecs
3781    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3782        if (<bool>::sse_decode(deserializer)) {
3783            return Some(<i64>::sse_decode(deserializer));
3784        } else {
3785            return None;
3786        }
3787    }
3788}
3789
3790impl SseDecode for Option<crate::model::ListPaymentDetails> {
3791    // Codec=Sse (Serialization based), see doc to use other codecs
3792    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3793        if (<bool>::sse_decode(deserializer)) {
3794            return Some(<crate::model::ListPaymentDetails>::sse_decode(deserializer));
3795        } else {
3796            return None;
3797        }
3798    }
3799}
3800
3801impl SseDecode for Option<crate::model::LnUrlInfo> {
3802    // Codec=Sse (Serialization based), see doc to use other codecs
3803    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3804        if (<bool>::sse_decode(deserializer)) {
3805            return Some(<crate::model::LnUrlInfo>::sse_decode(deserializer));
3806        } else {
3807            return None;
3808        }
3809    }
3810}
3811
3812impl SseDecode for Option<crate::model::PayAmount> {
3813    // Codec=Sse (Serialization based), see doc to use other codecs
3814    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3815        if (<bool>::sse_decode(deserializer)) {
3816            return Some(<crate::model::PayAmount>::sse_decode(deserializer));
3817        } else {
3818            return None;
3819        }
3820    }
3821}
3822
3823impl SseDecode for Option<crate::model::Payment> {
3824    // Codec=Sse (Serialization based), see doc to use other codecs
3825    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3826        if (<bool>::sse_decode(deserializer)) {
3827            return Some(<crate::model::Payment>::sse_decode(deserializer));
3828        } else {
3829            return None;
3830        }
3831    }
3832}
3833
3834impl SseDecode for Option<crate::model::ReceiveAmount> {
3835    // Codec=Sse (Serialization based), see doc to use other codecs
3836    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3837        if (<bool>::sse_decode(deserializer)) {
3838            return Some(<crate::model::ReceiveAmount>::sse_decode(deserializer));
3839        } else {
3840            return None;
3841        }
3842    }
3843}
3844
3845impl SseDecode for Option<crate::bindings::SuccessAction> {
3846    // Codec=Sse (Serialization based), see doc to use other codecs
3847    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3848        if (<bool>::sse_decode(deserializer)) {
3849            return Some(<crate::bindings::SuccessAction>::sse_decode(deserializer));
3850        } else {
3851            return None;
3852        }
3853    }
3854}
3855
3856impl SseDecode for Option<crate::bindings::SuccessActionProcessed> {
3857    // Codec=Sse (Serialization based), see doc to use other codecs
3858    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3859        if (<bool>::sse_decode(deserializer)) {
3860            return Some(<crate::bindings::SuccessActionProcessed>::sse_decode(
3861                deserializer,
3862            ));
3863        } else {
3864            return None;
3865        }
3866    }
3867}
3868
3869impl SseDecode for Option<crate::bindings::Symbol> {
3870    // Codec=Sse (Serialization based), see doc to use other codecs
3871    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3872        if (<bool>::sse_decode(deserializer)) {
3873            return Some(<crate::bindings::Symbol>::sse_decode(deserializer));
3874        } else {
3875            return None;
3876        }
3877    }
3878}
3879
3880impl SseDecode for Option<u32> {
3881    // Codec=Sse (Serialization based), see doc to use other codecs
3882    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3883        if (<bool>::sse_decode(deserializer)) {
3884            return Some(<u32>::sse_decode(deserializer));
3885        } else {
3886            return None;
3887        }
3888    }
3889}
3890
3891impl SseDecode for Option<u64> {
3892    // Codec=Sse (Serialization based), see doc to use other codecs
3893    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3894        if (<bool>::sse_decode(deserializer)) {
3895            return Some(<u64>::sse_decode(deserializer));
3896        } else {
3897            return None;
3898        }
3899    }
3900}
3901
3902impl SseDecode for Option<Vec<crate::model::AssetMetadata>> {
3903    // Codec=Sse (Serialization based), see doc to use other codecs
3904    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3905        if (<bool>::sse_decode(deserializer)) {
3906            return Some(<Vec<crate::model::AssetMetadata>>::sse_decode(deserializer));
3907        } else {
3908            return None;
3909        }
3910    }
3911}
3912
3913impl SseDecode for Option<Vec<crate::bindings::ExternalInputParser>> {
3914    // Codec=Sse (Serialization based), see doc to use other codecs
3915    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3916        if (<bool>::sse_decode(deserializer)) {
3917            return Some(<Vec<crate::bindings::ExternalInputParser>>::sse_decode(
3918                deserializer,
3919            ));
3920        } else {
3921            return None;
3922        }
3923    }
3924}
3925
3926impl SseDecode for Option<Vec<crate::model::PaymentState>> {
3927    // Codec=Sse (Serialization based), see doc to use other codecs
3928    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3929        if (<bool>::sse_decode(deserializer)) {
3930            return Some(<Vec<crate::model::PaymentState>>::sse_decode(deserializer));
3931        } else {
3932            return None;
3933        }
3934    }
3935}
3936
3937impl SseDecode for Option<Vec<crate::model::PaymentType>> {
3938    // Codec=Sse (Serialization based), see doc to use other codecs
3939    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3940        if (<bool>::sse_decode(deserializer)) {
3941            return Some(<Vec<crate::model::PaymentType>>::sse_decode(deserializer));
3942        } else {
3943            return None;
3944        }
3945    }
3946}
3947
3948impl SseDecode for Option<Vec<u8>> {
3949    // Codec=Sse (Serialization based), see doc to use other codecs
3950    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3951        if (<bool>::sse_decode(deserializer)) {
3952            return Some(<Vec<u8>>::sse_decode(deserializer));
3953        } else {
3954            return None;
3955        }
3956    }
3957}
3958
3959impl SseDecode for crate::model::PayAmount {
3960    // Codec=Sse (Serialization based), see doc to use other codecs
3961    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3962        let mut tag_ = <i32>::sse_decode(deserializer);
3963        match tag_ {
3964            0 => {
3965                let mut var_receiverAmountSat = <u64>::sse_decode(deserializer);
3966                return crate::model::PayAmount::Bitcoin {
3967                    receiver_amount_sat: var_receiverAmountSat,
3968                };
3969            }
3970            1 => {
3971                let mut var_assetId = <String>::sse_decode(deserializer);
3972                let mut var_receiverAmount = <f64>::sse_decode(deserializer);
3973                let mut var_estimateAssetFees = <Option<bool>>::sse_decode(deserializer);
3974                return crate::model::PayAmount::Asset {
3975                    asset_id: var_assetId,
3976                    receiver_amount: var_receiverAmount,
3977                    estimate_asset_fees: var_estimateAssetFees,
3978                };
3979            }
3980            2 => {
3981                return crate::model::PayAmount::Drain;
3982            }
3983            _ => {
3984                unimplemented!("");
3985            }
3986        }
3987    }
3988}
3989
3990impl SseDecode for crate::model::PayOnchainRequest {
3991    // Codec=Sse (Serialization based), see doc to use other codecs
3992    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3993        let mut var_address = <String>::sse_decode(deserializer);
3994        let mut var_prepareResponse =
3995            <crate::model::PreparePayOnchainResponse>::sse_decode(deserializer);
3996        return crate::model::PayOnchainRequest {
3997            address: var_address,
3998            prepare_response: var_prepareResponse,
3999        };
4000    }
4001}
4002
4003impl SseDecode for crate::model::Payment {
4004    // Codec=Sse (Serialization based), see doc to use other codecs
4005    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4006        let mut var_destination = <Option<String>>::sse_decode(deserializer);
4007        let mut var_txId = <Option<String>>::sse_decode(deserializer);
4008        let mut var_unblindingData = <Option<String>>::sse_decode(deserializer);
4009        let mut var_timestamp = <u32>::sse_decode(deserializer);
4010        let mut var_amountSat = <u64>::sse_decode(deserializer);
4011        let mut var_feesSat = <u64>::sse_decode(deserializer);
4012        let mut var_swapperFeesSat = <Option<u64>>::sse_decode(deserializer);
4013        let mut var_paymentType = <crate::model::PaymentType>::sse_decode(deserializer);
4014        let mut var_status = <crate::model::PaymentState>::sse_decode(deserializer);
4015        let mut var_details = <crate::model::PaymentDetails>::sse_decode(deserializer);
4016        return crate::model::Payment {
4017            destination: var_destination,
4018            tx_id: var_txId,
4019            unblinding_data: var_unblindingData,
4020            timestamp: var_timestamp,
4021            amount_sat: var_amountSat,
4022            fees_sat: var_feesSat,
4023            swapper_fees_sat: var_swapperFeesSat,
4024            payment_type: var_paymentType,
4025            status: var_status,
4026            details: var_details,
4027        };
4028    }
4029}
4030
4031impl SseDecode for crate::model::PaymentDetails {
4032    // Codec=Sse (Serialization based), see doc to use other codecs
4033    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4034        let mut tag_ = <i32>::sse_decode(deserializer);
4035        match tag_ {
4036            0 => {
4037                let mut var_swapId = <String>::sse_decode(deserializer);
4038                let mut var_description = <String>::sse_decode(deserializer);
4039                let mut var_liquidExpirationBlockheight = <u32>::sse_decode(deserializer);
4040                let mut var_preimage = <Option<String>>::sse_decode(deserializer);
4041                let mut var_invoice = <Option<String>>::sse_decode(deserializer);
4042                let mut var_bolt12Offer = <Option<String>>::sse_decode(deserializer);
4043                let mut var_paymentHash = <Option<String>>::sse_decode(deserializer);
4044                let mut var_destinationPubkey = <Option<String>>::sse_decode(deserializer);
4045                let mut var_lnurlInfo = <Option<crate::model::LnUrlInfo>>::sse_decode(deserializer);
4046                let mut var_bip353Address = <Option<String>>::sse_decode(deserializer);
4047                let mut var_claimTxId = <Option<String>>::sse_decode(deserializer);
4048                let mut var_refundTxId = <Option<String>>::sse_decode(deserializer);
4049                let mut var_refundTxAmountSat = <Option<u64>>::sse_decode(deserializer);
4050                return crate::model::PaymentDetails::Lightning {
4051                    swap_id: var_swapId,
4052                    description: var_description,
4053                    liquid_expiration_blockheight: var_liquidExpirationBlockheight,
4054                    preimage: var_preimage,
4055                    invoice: var_invoice,
4056                    bolt12_offer: var_bolt12Offer,
4057                    payment_hash: var_paymentHash,
4058                    destination_pubkey: var_destinationPubkey,
4059                    lnurl_info: var_lnurlInfo,
4060                    bip353_address: var_bip353Address,
4061                    claim_tx_id: var_claimTxId,
4062                    refund_tx_id: var_refundTxId,
4063                    refund_tx_amount_sat: var_refundTxAmountSat,
4064                };
4065            }
4066            1 => {
4067                let mut var_destination = <String>::sse_decode(deserializer);
4068                let mut var_description = <String>::sse_decode(deserializer);
4069                let mut var_assetId = <String>::sse_decode(deserializer);
4070                let mut var_assetInfo = <Option<crate::model::AssetInfo>>::sse_decode(deserializer);
4071                let mut var_lnurlInfo = <Option<crate::model::LnUrlInfo>>::sse_decode(deserializer);
4072                let mut var_bip353Address = <Option<String>>::sse_decode(deserializer);
4073                return crate::model::PaymentDetails::Liquid {
4074                    destination: var_destination,
4075                    description: var_description,
4076                    asset_id: var_assetId,
4077                    asset_info: var_assetInfo,
4078                    lnurl_info: var_lnurlInfo,
4079                    bip353_address: var_bip353Address,
4080                };
4081            }
4082            2 => {
4083                let mut var_swapId = <String>::sse_decode(deserializer);
4084                let mut var_description = <String>::sse_decode(deserializer);
4085                let mut var_autoAcceptedFees = <bool>::sse_decode(deserializer);
4086                let mut var_liquidExpirationBlockheight = <Option<u32>>::sse_decode(deserializer);
4087                let mut var_bitcoinExpirationBlockheight = <Option<u32>>::sse_decode(deserializer);
4088                let mut var_claimTxId = <Option<String>>::sse_decode(deserializer);
4089                let mut var_refundTxId = <Option<String>>::sse_decode(deserializer);
4090                let mut var_refundTxAmountSat = <Option<u64>>::sse_decode(deserializer);
4091                return crate::model::PaymentDetails::Bitcoin {
4092                    swap_id: var_swapId,
4093                    description: var_description,
4094                    auto_accepted_fees: var_autoAcceptedFees,
4095                    liquid_expiration_blockheight: var_liquidExpirationBlockheight,
4096                    bitcoin_expiration_blockheight: var_bitcoinExpirationBlockheight,
4097                    claim_tx_id: var_claimTxId,
4098                    refund_tx_id: var_refundTxId,
4099                    refund_tx_amount_sat: var_refundTxAmountSat,
4100                };
4101            }
4102            _ => {
4103                unimplemented!("");
4104            }
4105        }
4106    }
4107}
4108
4109impl SseDecode for crate::error::PaymentError {
4110    // Codec=Sse (Serialization based), see doc to use other codecs
4111    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4112        let mut tag_ = <i32>::sse_decode(deserializer);
4113        match tag_ {
4114            0 => {
4115                return crate::error::PaymentError::AlreadyClaimed;
4116            }
4117            1 => {
4118                return crate::error::PaymentError::AlreadyPaid;
4119            }
4120            2 => {
4121                return crate::error::PaymentError::PaymentInProgress;
4122            }
4123            3 => {
4124                let mut var_min = <u64>::sse_decode(deserializer);
4125                let mut var_max = <u64>::sse_decode(deserializer);
4126                return crate::error::PaymentError::AmountOutOfRange {
4127                    min: var_min,
4128                    max: var_max,
4129                };
4130            }
4131            4 => {
4132                let mut var_err = <String>::sse_decode(deserializer);
4133                return crate::error::PaymentError::AmountMissing { err: var_err };
4134            }
4135            5 => {
4136                let mut var_err = <String>::sse_decode(deserializer);
4137                return crate::error::PaymentError::AssetError { err: var_err };
4138            }
4139            6 => {
4140                let mut var_err = <String>::sse_decode(deserializer);
4141                return crate::error::PaymentError::InvalidNetwork { err: var_err };
4142            }
4143            7 => {
4144                let mut var_err = <String>::sse_decode(deserializer);
4145                return crate::error::PaymentError::Generic { err: var_err };
4146            }
4147            8 => {
4148                return crate::error::PaymentError::InvalidOrExpiredFees;
4149            }
4150            9 => {
4151                return crate::error::PaymentError::InsufficientFunds;
4152            }
4153            10 => {
4154                let mut var_err = <String>::sse_decode(deserializer);
4155                return crate::error::PaymentError::InvalidDescription { err: var_err };
4156            }
4157            11 => {
4158                let mut var_err = <String>::sse_decode(deserializer);
4159                return crate::error::PaymentError::InvalidInvoice { err: var_err };
4160            }
4161            12 => {
4162                return crate::error::PaymentError::InvalidPreimage;
4163            }
4164            13 => {
4165                return crate::error::PaymentError::PairsNotFound;
4166            }
4167            14 => {
4168                return crate::error::PaymentError::PaymentTimeout;
4169            }
4170            15 => {
4171                return crate::error::PaymentError::PersistError;
4172            }
4173            16 => {
4174                let mut var_err = <String>::sse_decode(deserializer);
4175                return crate::error::PaymentError::ReceiveError { err: var_err };
4176            }
4177            17 => {
4178                let mut var_err = <String>::sse_decode(deserializer);
4179                let mut var_refundTxId = <String>::sse_decode(deserializer);
4180                return crate::error::PaymentError::Refunded {
4181                    err: var_err,
4182                    refund_tx_id: var_refundTxId,
4183                };
4184            }
4185            18 => {
4186                return crate::error::PaymentError::SelfTransferNotSupported;
4187            }
4188            19 => {
4189                let mut var_err = <String>::sse_decode(deserializer);
4190                return crate::error::PaymentError::SendError { err: var_err };
4191            }
4192            20 => {
4193                let mut var_err = <String>::sse_decode(deserializer);
4194                return crate::error::PaymentError::SignerError { err: var_err };
4195            }
4196            _ => {
4197                unimplemented!("");
4198            }
4199        }
4200    }
4201}
4202
4203impl SseDecode for crate::model::PaymentMethod {
4204    // Codec=Sse (Serialization based), see doc to use other codecs
4205    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4206        let mut inner = <i32>::sse_decode(deserializer);
4207        return match inner {
4208            0 => crate::model::PaymentMethod::Lightning,
4209            1 => crate::model::PaymentMethod::Bolt11Invoice,
4210            2 => crate::model::PaymentMethod::Bolt12Offer,
4211            3 => crate::model::PaymentMethod::BitcoinAddress,
4212            4 => crate::model::PaymentMethod::LiquidAddress,
4213            _ => unreachable!("Invalid variant for PaymentMethod: {}", inner),
4214        };
4215    }
4216}
4217
4218impl SseDecode for crate::model::PaymentState {
4219    // Codec=Sse (Serialization based), see doc to use other codecs
4220    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4221        let mut inner = <i32>::sse_decode(deserializer);
4222        return match inner {
4223            0 => crate::model::PaymentState::Created,
4224            1 => crate::model::PaymentState::Pending,
4225            2 => crate::model::PaymentState::Complete,
4226            3 => crate::model::PaymentState::Failed,
4227            4 => crate::model::PaymentState::TimedOut,
4228            5 => crate::model::PaymentState::Refundable,
4229            6 => crate::model::PaymentState::RefundPending,
4230            7 => crate::model::PaymentState::WaitingFeeAcceptance,
4231            _ => unreachable!("Invalid variant for PaymentState: {}", inner),
4232        };
4233    }
4234}
4235
4236impl SseDecode for crate::model::PaymentType {
4237    // Codec=Sse (Serialization based), see doc to use other codecs
4238    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4239        let mut inner = <i32>::sse_decode(deserializer);
4240        return match inner {
4241            0 => crate::model::PaymentType::Receive,
4242            1 => crate::model::PaymentType::Send,
4243            _ => unreachable!("Invalid variant for PaymentType: {}", inner),
4244        };
4245    }
4246}
4247
4248impl SseDecode for crate::model::PrepareBuyBitcoinRequest {
4249    // Codec=Sse (Serialization based), see doc to use other codecs
4250    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4251        let mut var_provider = <crate::model::BuyBitcoinProvider>::sse_decode(deserializer);
4252        let mut var_amountSat = <u64>::sse_decode(deserializer);
4253        return crate::model::PrepareBuyBitcoinRequest {
4254            provider: var_provider,
4255            amount_sat: var_amountSat,
4256        };
4257    }
4258}
4259
4260impl SseDecode for crate::model::PrepareBuyBitcoinResponse {
4261    // Codec=Sse (Serialization based), see doc to use other codecs
4262    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4263        let mut var_provider = <crate::model::BuyBitcoinProvider>::sse_decode(deserializer);
4264        let mut var_amountSat = <u64>::sse_decode(deserializer);
4265        let mut var_feesSat = <u64>::sse_decode(deserializer);
4266        return crate::model::PrepareBuyBitcoinResponse {
4267            provider: var_provider,
4268            amount_sat: var_amountSat,
4269            fees_sat: var_feesSat,
4270        };
4271    }
4272}
4273
4274impl SseDecode for crate::model::PrepareLnUrlPayRequest {
4275    // Codec=Sse (Serialization based), see doc to use other codecs
4276    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4277        let mut var_data = <crate::bindings::LnUrlPayRequestData>::sse_decode(deserializer);
4278        let mut var_amount = <crate::model::PayAmount>::sse_decode(deserializer);
4279        let mut var_bip353Address = <Option<String>>::sse_decode(deserializer);
4280        let mut var_comment = <Option<String>>::sse_decode(deserializer);
4281        let mut var_validateSuccessActionUrl = <Option<bool>>::sse_decode(deserializer);
4282        return crate::model::PrepareLnUrlPayRequest {
4283            data: var_data,
4284            amount: var_amount,
4285            bip353_address: var_bip353Address,
4286            comment: var_comment,
4287            validate_success_action_url: var_validateSuccessActionUrl,
4288        };
4289    }
4290}
4291
4292impl SseDecode for crate::model::PrepareLnUrlPayResponse {
4293    // Codec=Sse (Serialization based), see doc to use other codecs
4294    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4295        let mut var_destination = <crate::model::SendDestination>::sse_decode(deserializer);
4296        let mut var_feesSat = <u64>::sse_decode(deserializer);
4297        let mut var_data = <crate::bindings::LnUrlPayRequestData>::sse_decode(deserializer);
4298        let mut var_comment = <Option<String>>::sse_decode(deserializer);
4299        let mut var_successAction =
4300            <Option<crate::bindings::SuccessAction>>::sse_decode(deserializer);
4301        return crate::model::PrepareLnUrlPayResponse {
4302            destination: var_destination,
4303            fees_sat: var_feesSat,
4304            data: var_data,
4305            comment: var_comment,
4306            success_action: var_successAction,
4307        };
4308    }
4309}
4310
4311impl SseDecode for crate::model::PreparePayOnchainRequest {
4312    // Codec=Sse (Serialization based), see doc to use other codecs
4313    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4314        let mut var_amount = <crate::model::PayAmount>::sse_decode(deserializer);
4315        let mut var_feeRateSatPerVbyte = <Option<u32>>::sse_decode(deserializer);
4316        return crate::model::PreparePayOnchainRequest {
4317            amount: var_amount,
4318            fee_rate_sat_per_vbyte: var_feeRateSatPerVbyte,
4319        };
4320    }
4321}
4322
4323impl SseDecode for crate::model::PreparePayOnchainResponse {
4324    // Codec=Sse (Serialization based), see doc to use other codecs
4325    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4326        let mut var_receiverAmountSat = <u64>::sse_decode(deserializer);
4327        let mut var_claimFeesSat = <u64>::sse_decode(deserializer);
4328        let mut var_totalFeesSat = <u64>::sse_decode(deserializer);
4329        return crate::model::PreparePayOnchainResponse {
4330            receiver_amount_sat: var_receiverAmountSat,
4331            claim_fees_sat: var_claimFeesSat,
4332            total_fees_sat: var_totalFeesSat,
4333        };
4334    }
4335}
4336
4337impl SseDecode for crate::model::PrepareReceiveRequest {
4338    // Codec=Sse (Serialization based), see doc to use other codecs
4339    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4340        let mut var_paymentMethod = <crate::model::PaymentMethod>::sse_decode(deserializer);
4341        let mut var_amount = <Option<crate::model::ReceiveAmount>>::sse_decode(deserializer);
4342        return crate::model::PrepareReceiveRequest {
4343            payment_method: var_paymentMethod,
4344            amount: var_amount,
4345        };
4346    }
4347}
4348
4349impl SseDecode for crate::model::PrepareReceiveResponse {
4350    // Codec=Sse (Serialization based), see doc to use other codecs
4351    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4352        let mut var_paymentMethod = <crate::model::PaymentMethod>::sse_decode(deserializer);
4353        let mut var_feesSat = <u64>::sse_decode(deserializer);
4354        let mut var_amount = <Option<crate::model::ReceiveAmount>>::sse_decode(deserializer);
4355        let mut var_minPayerAmountSat = <Option<u64>>::sse_decode(deserializer);
4356        let mut var_maxPayerAmountSat = <Option<u64>>::sse_decode(deserializer);
4357        let mut var_swapperFeerate = <Option<f64>>::sse_decode(deserializer);
4358        return crate::model::PrepareReceiveResponse {
4359            payment_method: var_paymentMethod,
4360            fees_sat: var_feesSat,
4361            amount: var_amount,
4362            min_payer_amount_sat: var_minPayerAmountSat,
4363            max_payer_amount_sat: var_maxPayerAmountSat,
4364            swapper_feerate: var_swapperFeerate,
4365        };
4366    }
4367}
4368
4369impl SseDecode for crate::model::PrepareRefundRequest {
4370    // Codec=Sse (Serialization based), see doc to use other codecs
4371    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4372        let mut var_swapAddress = <String>::sse_decode(deserializer);
4373        let mut var_refundAddress = <String>::sse_decode(deserializer);
4374        let mut var_feeRateSatPerVbyte = <u32>::sse_decode(deserializer);
4375        return crate::model::PrepareRefundRequest {
4376            swap_address: var_swapAddress,
4377            refund_address: var_refundAddress,
4378            fee_rate_sat_per_vbyte: var_feeRateSatPerVbyte,
4379        };
4380    }
4381}
4382
4383impl SseDecode for crate::model::PrepareRefundResponse {
4384    // Codec=Sse (Serialization based), see doc to use other codecs
4385    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4386        let mut var_txVsize = <u32>::sse_decode(deserializer);
4387        let mut var_txFeeSat = <u64>::sse_decode(deserializer);
4388        let mut var_lastRefundTxId = <Option<String>>::sse_decode(deserializer);
4389        return crate::model::PrepareRefundResponse {
4390            tx_vsize: var_txVsize,
4391            tx_fee_sat: var_txFeeSat,
4392            last_refund_tx_id: var_lastRefundTxId,
4393        };
4394    }
4395}
4396
4397impl SseDecode for crate::model::PrepareSendRequest {
4398    // Codec=Sse (Serialization based), see doc to use other codecs
4399    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4400        let mut var_destination = <String>::sse_decode(deserializer);
4401        let mut var_amount = <Option<crate::model::PayAmount>>::sse_decode(deserializer);
4402        return crate::model::PrepareSendRequest {
4403            destination: var_destination,
4404            amount: var_amount,
4405        };
4406    }
4407}
4408
4409impl SseDecode for crate::model::PrepareSendResponse {
4410    // Codec=Sse (Serialization based), see doc to use other codecs
4411    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4412        let mut var_destination = <crate::model::SendDestination>::sse_decode(deserializer);
4413        let mut var_feesSat = <Option<u64>>::sse_decode(deserializer);
4414        let mut var_estimatedAssetFees = <Option<f64>>::sse_decode(deserializer);
4415        return crate::model::PrepareSendResponse {
4416            destination: var_destination,
4417            fees_sat: var_feesSat,
4418            estimated_asset_fees: var_estimatedAssetFees,
4419        };
4420    }
4421}
4422
4423impl SseDecode for crate::bindings::Rate {
4424    // Codec=Sse (Serialization based), see doc to use other codecs
4425    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4426        let mut var_coin = <String>::sse_decode(deserializer);
4427        let mut var_value = <f64>::sse_decode(deserializer);
4428        return crate::bindings::Rate {
4429            coin: var_coin,
4430            value: var_value,
4431        };
4432    }
4433}
4434
4435impl SseDecode for crate::model::ReceiveAmount {
4436    // Codec=Sse (Serialization based), see doc to use other codecs
4437    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4438        let mut tag_ = <i32>::sse_decode(deserializer);
4439        match tag_ {
4440            0 => {
4441                let mut var_payerAmountSat = <u64>::sse_decode(deserializer);
4442                return crate::model::ReceiveAmount::Bitcoin {
4443                    payer_amount_sat: var_payerAmountSat,
4444                };
4445            }
4446            1 => {
4447                let mut var_assetId = <String>::sse_decode(deserializer);
4448                let mut var_payerAmount = <Option<f64>>::sse_decode(deserializer);
4449                return crate::model::ReceiveAmount::Asset {
4450                    asset_id: var_assetId,
4451                    payer_amount: var_payerAmount,
4452                };
4453            }
4454            _ => {
4455                unimplemented!("");
4456            }
4457        }
4458    }
4459}
4460
4461impl SseDecode for crate::model::ReceivePaymentRequest {
4462    // Codec=Sse (Serialization based), see doc to use other codecs
4463    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4464        let mut var_prepareResponse =
4465            <crate::model::PrepareReceiveResponse>::sse_decode(deserializer);
4466        let mut var_description = <Option<String>>::sse_decode(deserializer);
4467        let mut var_useDescriptionHash = <Option<bool>>::sse_decode(deserializer);
4468        return crate::model::ReceivePaymentRequest {
4469            prepare_response: var_prepareResponse,
4470            description: var_description,
4471            use_description_hash: var_useDescriptionHash,
4472        };
4473    }
4474}
4475
4476impl SseDecode for crate::model::ReceivePaymentResponse {
4477    // Codec=Sse (Serialization based), see doc to use other codecs
4478    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4479        let mut var_destination = <String>::sse_decode(deserializer);
4480        return crate::model::ReceivePaymentResponse {
4481            destination: var_destination,
4482        };
4483    }
4484}
4485
4486impl SseDecode for crate::model::RecommendedFees {
4487    // Codec=Sse (Serialization based), see doc to use other codecs
4488    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4489        let mut var_fastestFee = <u64>::sse_decode(deserializer);
4490        let mut var_halfHourFee = <u64>::sse_decode(deserializer);
4491        let mut var_hourFee = <u64>::sse_decode(deserializer);
4492        let mut var_economyFee = <u64>::sse_decode(deserializer);
4493        let mut var_minimumFee = <u64>::sse_decode(deserializer);
4494        return crate::model::RecommendedFees {
4495            fastest_fee: var_fastestFee,
4496            half_hour_fee: var_halfHourFee,
4497            hour_fee: var_hourFee,
4498            economy_fee: var_economyFee,
4499            minimum_fee: var_minimumFee,
4500        };
4501    }
4502}
4503
4504impl SseDecode for crate::model::RefundRequest {
4505    // Codec=Sse (Serialization based), see doc to use other codecs
4506    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4507        let mut var_swapAddress = <String>::sse_decode(deserializer);
4508        let mut var_refundAddress = <String>::sse_decode(deserializer);
4509        let mut var_feeRateSatPerVbyte = <u32>::sse_decode(deserializer);
4510        return crate::model::RefundRequest {
4511            swap_address: var_swapAddress,
4512            refund_address: var_refundAddress,
4513            fee_rate_sat_per_vbyte: var_feeRateSatPerVbyte,
4514        };
4515    }
4516}
4517
4518impl SseDecode for crate::model::RefundResponse {
4519    // Codec=Sse (Serialization based), see doc to use other codecs
4520    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4521        let mut var_refundTxId = <String>::sse_decode(deserializer);
4522        return crate::model::RefundResponse {
4523            refund_tx_id: var_refundTxId,
4524        };
4525    }
4526}
4527
4528impl SseDecode for crate::model::RefundableSwap {
4529    // Codec=Sse (Serialization based), see doc to use other codecs
4530    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4531        let mut var_swapAddress = <String>::sse_decode(deserializer);
4532        let mut var_timestamp = <u32>::sse_decode(deserializer);
4533        let mut var_amountSat = <u64>::sse_decode(deserializer);
4534        let mut var_lastRefundTxId = <Option<String>>::sse_decode(deserializer);
4535        return crate::model::RefundableSwap {
4536            swap_address: var_swapAddress,
4537            timestamp: var_timestamp,
4538            amount_sat: var_amountSat,
4539            last_refund_tx_id: var_lastRefundTxId,
4540        };
4541    }
4542}
4543
4544impl SseDecode for crate::model::RestoreRequest {
4545    // Codec=Sse (Serialization based), see doc to use other codecs
4546    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4547        let mut var_backupPath = <Option<String>>::sse_decode(deserializer);
4548        return crate::model::RestoreRequest {
4549            backup_path: var_backupPath,
4550        };
4551    }
4552}
4553
4554impl SseDecode for crate::bindings::RouteHint {
4555    // Codec=Sse (Serialization based), see doc to use other codecs
4556    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4557        let mut var_hops = <Vec<crate::bindings::RouteHintHop>>::sse_decode(deserializer);
4558        return crate::bindings::RouteHint { hops: var_hops };
4559    }
4560}
4561
4562impl SseDecode for crate::bindings::RouteHintHop {
4563    // Codec=Sse (Serialization based), see doc to use other codecs
4564    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4565        let mut var_srcNodeId = <String>::sse_decode(deserializer);
4566        let mut var_shortChannelId = <String>::sse_decode(deserializer);
4567        let mut var_feesBaseMsat = <u32>::sse_decode(deserializer);
4568        let mut var_feesProportionalMillionths = <u32>::sse_decode(deserializer);
4569        let mut var_cltvExpiryDelta = <u64>::sse_decode(deserializer);
4570        let mut var_htlcMinimumMsat = <Option<u64>>::sse_decode(deserializer);
4571        let mut var_htlcMaximumMsat = <Option<u64>>::sse_decode(deserializer);
4572        return crate::bindings::RouteHintHop {
4573            src_node_id: var_srcNodeId,
4574            short_channel_id: var_shortChannelId,
4575            fees_base_msat: var_feesBaseMsat,
4576            fees_proportional_millionths: var_feesProportionalMillionths,
4577            cltv_expiry_delta: var_cltvExpiryDelta,
4578            htlc_minimum_msat: var_htlcMinimumMsat,
4579            htlc_maximum_msat: var_htlcMaximumMsat,
4580        };
4581    }
4582}
4583
4584impl SseDecode for crate::error::SdkError {
4585    // Codec=Sse (Serialization based), see doc to use other codecs
4586    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4587        let mut tag_ = <i32>::sse_decode(deserializer);
4588        match tag_ {
4589            0 => {
4590                return crate::error::SdkError::AlreadyStarted;
4591            }
4592            1 => {
4593                let mut var_err = <String>::sse_decode(deserializer);
4594                return crate::error::SdkError::Generic { err: var_err };
4595            }
4596            2 => {
4597                return crate::error::SdkError::NotStarted;
4598            }
4599            3 => {
4600                let mut var_err = <String>::sse_decode(deserializer);
4601                return crate::error::SdkError::ServiceConnectivity { err: var_err };
4602            }
4603            _ => {
4604                unimplemented!("");
4605            }
4606        }
4607    }
4608}
4609
4610impl SseDecode for crate::model::SdkEvent {
4611    // Codec=Sse (Serialization based), see doc to use other codecs
4612    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4613        let mut tag_ = <i32>::sse_decode(deserializer);
4614        match tag_ {
4615            0 => {
4616                let mut var_details = <crate::model::Payment>::sse_decode(deserializer);
4617                return crate::model::SdkEvent::PaymentFailed {
4618                    details: var_details,
4619                };
4620            }
4621            1 => {
4622                let mut var_details = <crate::model::Payment>::sse_decode(deserializer);
4623                return crate::model::SdkEvent::PaymentPending {
4624                    details: var_details,
4625                };
4626            }
4627            2 => {
4628                let mut var_details = <crate::model::Payment>::sse_decode(deserializer);
4629                return crate::model::SdkEvent::PaymentRefundable {
4630                    details: var_details,
4631                };
4632            }
4633            3 => {
4634                let mut var_details = <crate::model::Payment>::sse_decode(deserializer);
4635                return crate::model::SdkEvent::PaymentRefunded {
4636                    details: var_details,
4637                };
4638            }
4639            4 => {
4640                let mut var_details = <crate::model::Payment>::sse_decode(deserializer);
4641                return crate::model::SdkEvent::PaymentRefundPending {
4642                    details: var_details,
4643                };
4644            }
4645            5 => {
4646                let mut var_details = <crate::model::Payment>::sse_decode(deserializer);
4647                return crate::model::SdkEvent::PaymentSucceeded {
4648                    details: var_details,
4649                };
4650            }
4651            6 => {
4652                let mut var_details = <crate::model::Payment>::sse_decode(deserializer);
4653                return crate::model::SdkEvent::PaymentWaitingConfirmation {
4654                    details: var_details,
4655                };
4656            }
4657            7 => {
4658                let mut var_details = <crate::model::Payment>::sse_decode(deserializer);
4659                return crate::model::SdkEvent::PaymentWaitingFeeAcceptance {
4660                    details: var_details,
4661                };
4662            }
4663            8 => {
4664                return crate::model::SdkEvent::Synced;
4665            }
4666            9 => {
4667                let mut var_didPullNewRecords = <bool>::sse_decode(deserializer);
4668                return crate::model::SdkEvent::DataSynced {
4669                    did_pull_new_records: var_didPullNewRecords,
4670                };
4671            }
4672            _ => {
4673                unimplemented!("");
4674            }
4675        }
4676    }
4677}
4678
4679impl SseDecode for crate::model::SendDestination {
4680    // Codec=Sse (Serialization based), see doc to use other codecs
4681    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4682        let mut tag_ = <i32>::sse_decode(deserializer);
4683        match tag_ {
4684            0 => {
4685                let mut var_addressData =
4686                    <crate::bindings::LiquidAddressData>::sse_decode(deserializer);
4687                let mut var_bip353Address = <Option<String>>::sse_decode(deserializer);
4688                return crate::model::SendDestination::LiquidAddress {
4689                    address_data: var_addressData,
4690                    bip353_address: var_bip353Address,
4691                };
4692            }
4693            1 => {
4694                let mut var_invoice = <crate::bindings::LNInvoice>::sse_decode(deserializer);
4695                let mut var_bip353Address = <Option<String>>::sse_decode(deserializer);
4696                return crate::model::SendDestination::Bolt11 {
4697                    invoice: var_invoice,
4698                    bip353_address: var_bip353Address,
4699                };
4700            }
4701            2 => {
4702                let mut var_offer = <crate::bindings::LNOffer>::sse_decode(deserializer);
4703                let mut var_receiverAmountSat = <u64>::sse_decode(deserializer);
4704                let mut var_bip353Address = <Option<String>>::sse_decode(deserializer);
4705                return crate::model::SendDestination::Bolt12 {
4706                    offer: var_offer,
4707                    receiver_amount_sat: var_receiverAmountSat,
4708                    bip353_address: var_bip353Address,
4709                };
4710            }
4711            _ => {
4712                unimplemented!("");
4713            }
4714        }
4715    }
4716}
4717
4718impl SseDecode for crate::model::SendPaymentRequest {
4719    // Codec=Sse (Serialization based), see doc to use other codecs
4720    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4721        let mut var_prepareResponse = <crate::model::PrepareSendResponse>::sse_decode(deserializer);
4722        let mut var_useAssetFees = <Option<bool>>::sse_decode(deserializer);
4723        return crate::model::SendPaymentRequest {
4724            prepare_response: var_prepareResponse,
4725            use_asset_fees: var_useAssetFees,
4726        };
4727    }
4728}
4729
4730impl SseDecode for crate::model::SendPaymentResponse {
4731    // Codec=Sse (Serialization based), see doc to use other codecs
4732    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4733        let mut var_payment = <crate::model::Payment>::sse_decode(deserializer);
4734        return crate::model::SendPaymentResponse {
4735            payment: var_payment,
4736        };
4737    }
4738}
4739
4740impl SseDecode for crate::model::SignMessageRequest {
4741    // Codec=Sse (Serialization based), see doc to use other codecs
4742    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4743        let mut var_message = <String>::sse_decode(deserializer);
4744        return crate::model::SignMessageRequest {
4745            message: var_message,
4746        };
4747    }
4748}
4749
4750impl SseDecode for crate::model::SignMessageResponse {
4751    // Codec=Sse (Serialization based), see doc to use other codecs
4752    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4753        let mut var_signature = <String>::sse_decode(deserializer);
4754        return crate::model::SignMessageResponse {
4755            signature: var_signature,
4756        };
4757    }
4758}
4759
4760impl SseDecode for crate::bindings::SuccessAction {
4761    // Codec=Sse (Serialization based), see doc to use other codecs
4762    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4763        let mut tag_ = <i32>::sse_decode(deserializer);
4764        match tag_ {
4765            0 => {
4766                let mut var_data =
4767                    <crate::bindings::AesSuccessActionData>::sse_decode(deserializer);
4768                return crate::bindings::SuccessAction::Aes { data: var_data };
4769            }
4770            1 => {
4771                let mut var_data =
4772                    <crate::bindings::MessageSuccessActionData>::sse_decode(deserializer);
4773                return crate::bindings::SuccessAction::Message { data: var_data };
4774            }
4775            2 => {
4776                let mut var_data =
4777                    <crate::bindings::UrlSuccessActionData>::sse_decode(deserializer);
4778                return crate::bindings::SuccessAction::Url { data: var_data };
4779            }
4780            _ => {
4781                unimplemented!("");
4782            }
4783        }
4784    }
4785}
4786
4787impl SseDecode for crate::bindings::SuccessActionProcessed {
4788    // Codec=Sse (Serialization based), see doc to use other codecs
4789    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4790        let mut tag_ = <i32>::sse_decode(deserializer);
4791        match tag_ {
4792            0 => {
4793                let mut var_result =
4794                    <crate::bindings::AesSuccessActionDataResult>::sse_decode(deserializer);
4795                return crate::bindings::SuccessActionProcessed::Aes { result: var_result };
4796            }
4797            1 => {
4798                let mut var_data =
4799                    <crate::bindings::MessageSuccessActionData>::sse_decode(deserializer);
4800                return crate::bindings::SuccessActionProcessed::Message { data: var_data };
4801            }
4802            2 => {
4803                let mut var_data =
4804                    <crate::bindings::UrlSuccessActionData>::sse_decode(deserializer);
4805                return crate::bindings::SuccessActionProcessed::Url { data: var_data };
4806            }
4807            _ => {
4808                unimplemented!("");
4809            }
4810        }
4811    }
4812}
4813
4814impl SseDecode for crate::bindings::Symbol {
4815    // Codec=Sse (Serialization based), see doc to use other codecs
4816    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4817        let mut var_grapheme = <Option<String>>::sse_decode(deserializer);
4818        let mut var_template = <Option<String>>::sse_decode(deserializer);
4819        let mut var_rtl = <Option<bool>>::sse_decode(deserializer);
4820        let mut var_position = <Option<u32>>::sse_decode(deserializer);
4821        return crate::bindings::Symbol {
4822            grapheme: var_grapheme,
4823            template: var_template,
4824            rtl: var_rtl,
4825            position: var_position,
4826        };
4827    }
4828}
4829
4830impl SseDecode for u16 {
4831    // Codec=Sse (Serialization based), see doc to use other codecs
4832    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4833        deserializer.cursor.read_u16::<NativeEndian>().unwrap()
4834    }
4835}
4836
4837impl SseDecode for u32 {
4838    // Codec=Sse (Serialization based), see doc to use other codecs
4839    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4840        deserializer.cursor.read_u32::<NativeEndian>().unwrap()
4841    }
4842}
4843
4844impl SseDecode for u64 {
4845    // Codec=Sse (Serialization based), see doc to use other codecs
4846    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4847        deserializer.cursor.read_u64::<NativeEndian>().unwrap()
4848    }
4849}
4850
4851impl SseDecode for u8 {
4852    // Codec=Sse (Serialization based), see doc to use other codecs
4853    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4854        deserializer.cursor.read_u8().unwrap()
4855    }
4856}
4857
4858impl SseDecode for () {
4859    // Codec=Sse (Serialization based), see doc to use other codecs
4860    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {}
4861}
4862
4863impl SseDecode for crate::bindings::UrlSuccessActionData {
4864    // Codec=Sse (Serialization based), see doc to use other codecs
4865    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4866        let mut var_description = <String>::sse_decode(deserializer);
4867        let mut var_url = <String>::sse_decode(deserializer);
4868        let mut var_matchesCallbackDomain = <bool>::sse_decode(deserializer);
4869        return crate::bindings::UrlSuccessActionData {
4870            description: var_description,
4871            url: var_url,
4872            matches_callback_domain: var_matchesCallbackDomain,
4873        };
4874    }
4875}
4876
4877impl SseDecode for usize {
4878    // Codec=Sse (Serialization based), see doc to use other codecs
4879    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4880        deserializer.cursor.read_u64::<NativeEndian>().unwrap() as _
4881    }
4882}
4883
4884impl SseDecode for crate::model::WalletInfo {
4885    // Codec=Sse (Serialization based), see doc to use other codecs
4886    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4887        let mut var_balanceSat = <u64>::sse_decode(deserializer);
4888        let mut var_pendingSendSat = <u64>::sse_decode(deserializer);
4889        let mut var_pendingReceiveSat = <u64>::sse_decode(deserializer);
4890        let mut var_fingerprint = <String>::sse_decode(deserializer);
4891        let mut var_pubkey = <String>::sse_decode(deserializer);
4892        let mut var_assetBalances = <Vec<crate::model::AssetBalance>>::sse_decode(deserializer);
4893        return crate::model::WalletInfo {
4894            balance_sat: var_balanceSat,
4895            pending_send_sat: var_pendingSendSat,
4896            pending_receive_sat: var_pendingReceiveSat,
4897            fingerprint: var_fingerprint,
4898            pubkey: var_pubkey,
4899            asset_balances: var_assetBalances,
4900        };
4901    }
4902}
4903
4904fn pde_ffi_dispatcher_primary_impl(
4905    func_id: i32,
4906    port: flutter_rust_bridge::for_generated::MessagePort,
4907    ptr: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
4908    rust_vec_len: i32,
4909    data_len: i32,
4910) {
4911    // Codec=Pde (Serialization + dispatch), see doc to use other codecs
4912    match func_id {
4913        _ => unreachable!(),
4914    }
4915}
4916
4917fn pde_ffi_dispatcher_sync_impl(
4918    func_id: i32,
4919    ptr: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
4920    rust_vec_len: i32,
4921    data_len: i32,
4922) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
4923    // Codec=Pde (Serialization + dispatch), see doc to use other codecs
4924    match func_id {
4925        _ => unreachable!(),
4926    }
4927}
4928
4929// Section: rust2dart
4930
4931// Codec=Dco (DartCObject based), see doc to use other codecs
4932impl flutter_rust_bridge::IntoDart for FrbWrapper<BindingLiquidSdk> {
4933    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
4934        flutter_rust_bridge::for_generated::rust_auto_opaque_encode::<_, StdArc<_>>(self.0)
4935            .into_dart()
4936    }
4937}
4938impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for FrbWrapper<BindingLiquidSdk> {}
4939
4940impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<BindingLiquidSdk>> for BindingLiquidSdk {
4941    fn into_into_dart(self) -> FrbWrapper<BindingLiquidSdk> {
4942        self.into()
4943    }
4944}
4945
4946// Codec=Dco (DartCObject based), see doc to use other codecs
4947impl flutter_rust_bridge::IntoDart for crate::model::AcceptPaymentProposedFeesRequest {
4948    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
4949        [self.response.into_into_dart().into_dart()].into_dart()
4950    }
4951}
4952impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
4953    for crate::model::AcceptPaymentProposedFeesRequest
4954{
4955}
4956impl flutter_rust_bridge::IntoIntoDart<crate::model::AcceptPaymentProposedFeesRequest>
4957    for crate::model::AcceptPaymentProposedFeesRequest
4958{
4959    fn into_into_dart(self) -> crate::model::AcceptPaymentProposedFeesRequest {
4960        self
4961    }
4962}
4963// Codec=Dco (DartCObject based), see doc to use other codecs
4964impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::AesSuccessActionData> {
4965    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
4966        [
4967            self.0.description.into_into_dart().into_dart(),
4968            self.0.ciphertext.into_into_dart().into_dart(),
4969            self.0.iv.into_into_dart().into_dart(),
4970        ]
4971        .into_dart()
4972    }
4973}
4974impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
4975    for FrbWrapper<crate::bindings::AesSuccessActionData>
4976{
4977}
4978impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::AesSuccessActionData>>
4979    for crate::bindings::AesSuccessActionData
4980{
4981    fn into_into_dart(self) -> FrbWrapper<crate::bindings::AesSuccessActionData> {
4982        self.into()
4983    }
4984}
4985// Codec=Dco (DartCObject based), see doc to use other codecs
4986impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::AesSuccessActionDataDecrypted> {
4987    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
4988        [
4989            self.0.description.into_into_dart().into_dart(),
4990            self.0.plaintext.into_into_dart().into_dart(),
4991        ]
4992        .into_dart()
4993    }
4994}
4995impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
4996    for FrbWrapper<crate::bindings::AesSuccessActionDataDecrypted>
4997{
4998}
4999impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::AesSuccessActionDataDecrypted>>
5000    for crate::bindings::AesSuccessActionDataDecrypted
5001{
5002    fn into_into_dart(self) -> FrbWrapper<crate::bindings::AesSuccessActionDataDecrypted> {
5003        self.into()
5004    }
5005}
5006// Codec=Dco (DartCObject based), see doc to use other codecs
5007impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::AesSuccessActionDataResult> {
5008    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5009        match self.0 {
5010            crate::bindings::AesSuccessActionDataResult::Decrypted { data } => {
5011                [0.into_dart(), data.into_into_dart().into_dart()].into_dart()
5012            }
5013            crate::bindings::AesSuccessActionDataResult::ErrorStatus { reason } => {
5014                [1.into_dart(), reason.into_into_dart().into_dart()].into_dart()
5015            }
5016            _ => {
5017                unimplemented!("");
5018            }
5019        }
5020    }
5021}
5022impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5023    for FrbWrapper<crate::bindings::AesSuccessActionDataResult>
5024{
5025}
5026impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::AesSuccessActionDataResult>>
5027    for crate::bindings::AesSuccessActionDataResult
5028{
5029    fn into_into_dart(self) -> FrbWrapper<crate::bindings::AesSuccessActionDataResult> {
5030        self.into()
5031    }
5032}
5033// Codec=Dco (DartCObject based), see doc to use other codecs
5034impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::Amount> {
5035    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5036        match self.0 {
5037            crate::bindings::Amount::Bitcoin { amount_msat } => {
5038                [0.into_dart(), amount_msat.into_into_dart().into_dart()].into_dart()
5039            }
5040            crate::bindings::Amount::Currency {
5041                iso4217_code,
5042                fractional_amount,
5043            } => [
5044                1.into_dart(),
5045                iso4217_code.into_into_dart().into_dart(),
5046                fractional_amount.into_into_dart().into_dart(),
5047            ]
5048            .into_dart(),
5049            _ => {
5050                unimplemented!("");
5051            }
5052        }
5053    }
5054}
5055impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5056    for FrbWrapper<crate::bindings::Amount>
5057{
5058}
5059impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::Amount>>
5060    for crate::bindings::Amount
5061{
5062    fn into_into_dart(self) -> FrbWrapper<crate::bindings::Amount> {
5063        self.into()
5064    }
5065}
5066// Codec=Dco (DartCObject based), see doc to use other codecs
5067impl flutter_rust_bridge::IntoDart for crate::model::AssetBalance {
5068    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5069        [
5070            self.asset_id.into_into_dart().into_dart(),
5071            self.balance_sat.into_into_dart().into_dart(),
5072            self.name.into_into_dart().into_dart(),
5073            self.ticker.into_into_dart().into_dart(),
5074            self.balance.into_into_dart().into_dart(),
5075        ]
5076        .into_dart()
5077    }
5078}
5079impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::AssetBalance {}
5080impl flutter_rust_bridge::IntoIntoDart<crate::model::AssetBalance> for crate::model::AssetBalance {
5081    fn into_into_dart(self) -> crate::model::AssetBalance {
5082        self
5083    }
5084}
5085// Codec=Dco (DartCObject based), see doc to use other codecs
5086impl flutter_rust_bridge::IntoDart for crate::model::AssetInfo {
5087    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5088        [
5089            self.name.into_into_dart().into_dart(),
5090            self.ticker.into_into_dart().into_dart(),
5091            self.amount.into_into_dart().into_dart(),
5092            self.fees.into_into_dart().into_dart(),
5093        ]
5094        .into_dart()
5095    }
5096}
5097impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::AssetInfo {}
5098impl flutter_rust_bridge::IntoIntoDart<crate::model::AssetInfo> for crate::model::AssetInfo {
5099    fn into_into_dart(self) -> crate::model::AssetInfo {
5100        self
5101    }
5102}
5103// Codec=Dco (DartCObject based), see doc to use other codecs
5104impl flutter_rust_bridge::IntoDart for crate::model::AssetMetadata {
5105    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5106        [
5107            self.asset_id.into_into_dart().into_dart(),
5108            self.name.into_into_dart().into_dart(),
5109            self.ticker.into_into_dart().into_dart(),
5110            self.precision.into_into_dart().into_dart(),
5111            self.fiat_id.into_into_dart().into_dart(),
5112        ]
5113        .into_dart()
5114    }
5115}
5116impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::AssetMetadata {}
5117impl flutter_rust_bridge::IntoIntoDart<crate::model::AssetMetadata>
5118    for crate::model::AssetMetadata
5119{
5120    fn into_into_dart(self) -> crate::model::AssetMetadata {
5121        self
5122    }
5123}
5124// Codec=Dco (DartCObject based), see doc to use other codecs
5125impl flutter_rust_bridge::IntoDart for crate::model::BackupRequest {
5126    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5127        [self.backup_path.into_into_dart().into_dart()].into_dart()
5128    }
5129}
5130impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::BackupRequest {}
5131impl flutter_rust_bridge::IntoIntoDart<crate::model::BackupRequest>
5132    for crate::model::BackupRequest
5133{
5134    fn into_into_dart(self) -> crate::model::BackupRequest {
5135        self
5136    }
5137}
5138// Codec=Dco (DartCObject based), see doc to use other codecs
5139impl flutter_rust_bridge::IntoDart for crate::bindings::BindingEventListener {
5140    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5141        [self.stream.into_into_dart().into_dart()].into_dart()
5142    }
5143}
5144impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5145    for crate::bindings::BindingEventListener
5146{
5147}
5148impl flutter_rust_bridge::IntoIntoDart<crate::bindings::BindingEventListener>
5149    for crate::bindings::BindingEventListener
5150{
5151    fn into_into_dart(self) -> crate::bindings::BindingEventListener {
5152        self
5153    }
5154}
5155// Codec=Dco (DartCObject based), see doc to use other codecs
5156impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::BitcoinAddressData> {
5157    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5158        [
5159            self.0.address.into_into_dart().into_dart(),
5160            self.0.network.into_into_dart().into_dart(),
5161            self.0.amount_sat.into_into_dart().into_dart(),
5162            self.0.label.into_into_dart().into_dart(),
5163            self.0.message.into_into_dart().into_dart(),
5164        ]
5165        .into_dart()
5166    }
5167}
5168impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5169    for FrbWrapper<crate::bindings::BitcoinAddressData>
5170{
5171}
5172impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::BitcoinAddressData>>
5173    for crate::bindings::BitcoinAddressData
5174{
5175    fn into_into_dart(self) -> FrbWrapper<crate::bindings::BitcoinAddressData> {
5176        self.into()
5177    }
5178}
5179// Codec=Dco (DartCObject based), see doc to use other codecs
5180impl flutter_rust_bridge::IntoDart for crate::model::BlockchainExplorer {
5181    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5182        match self {
5183            crate::model::BlockchainExplorer::Electrum { url } => {
5184                [0.into_dart(), url.into_into_dart().into_dart()].into_dart()
5185            }
5186            crate::model::BlockchainExplorer::Esplora {
5187                url,
5188                use_waterfalls,
5189            } => [
5190                1.into_dart(),
5191                url.into_into_dart().into_dart(),
5192                use_waterfalls.into_into_dart().into_dart(),
5193            ]
5194            .into_dart(),
5195            _ => {
5196                unimplemented!("");
5197            }
5198        }
5199    }
5200}
5201impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5202    for crate::model::BlockchainExplorer
5203{
5204}
5205impl flutter_rust_bridge::IntoIntoDart<crate::model::BlockchainExplorer>
5206    for crate::model::BlockchainExplorer
5207{
5208    fn into_into_dart(self) -> crate::model::BlockchainExplorer {
5209        self
5210    }
5211}
5212// Codec=Dco (DartCObject based), see doc to use other codecs
5213impl flutter_rust_bridge::IntoDart for crate::model::BlockchainInfo {
5214    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5215        [
5216            self.liquid_tip.into_into_dart().into_dart(),
5217            self.bitcoin_tip.into_into_dart().into_dart(),
5218        ]
5219        .into_dart()
5220    }
5221}
5222impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::BlockchainInfo {}
5223impl flutter_rust_bridge::IntoIntoDart<crate::model::BlockchainInfo>
5224    for crate::model::BlockchainInfo
5225{
5226    fn into_into_dart(self) -> crate::model::BlockchainInfo {
5227        self
5228    }
5229}
5230// Codec=Dco (DartCObject based), see doc to use other codecs
5231impl flutter_rust_bridge::IntoDart for crate::model::BuyBitcoinProvider {
5232    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5233        match self {
5234            Self::Moonpay => 0.into_dart(),
5235            _ => unreachable!(),
5236        }
5237    }
5238}
5239impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5240    for crate::model::BuyBitcoinProvider
5241{
5242}
5243impl flutter_rust_bridge::IntoIntoDart<crate::model::BuyBitcoinProvider>
5244    for crate::model::BuyBitcoinProvider
5245{
5246    fn into_into_dart(self) -> crate::model::BuyBitcoinProvider {
5247        self
5248    }
5249}
5250// Codec=Dco (DartCObject based), see doc to use other codecs
5251impl flutter_rust_bridge::IntoDart for crate::model::BuyBitcoinRequest {
5252    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5253        [
5254            self.prepare_response.into_into_dart().into_dart(),
5255            self.redirect_url.into_into_dart().into_dart(),
5256        ]
5257        .into_dart()
5258    }
5259}
5260impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5261    for crate::model::BuyBitcoinRequest
5262{
5263}
5264impl flutter_rust_bridge::IntoIntoDart<crate::model::BuyBitcoinRequest>
5265    for crate::model::BuyBitcoinRequest
5266{
5267    fn into_into_dart(self) -> crate::model::BuyBitcoinRequest {
5268        self
5269    }
5270}
5271// Codec=Dco (DartCObject based), see doc to use other codecs
5272impl flutter_rust_bridge::IntoDart for crate::model::CheckMessageRequest {
5273    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5274        [
5275            self.message.into_into_dart().into_dart(),
5276            self.pubkey.into_into_dart().into_dart(),
5277            self.signature.into_into_dart().into_dart(),
5278        ]
5279        .into_dart()
5280    }
5281}
5282impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5283    for crate::model::CheckMessageRequest
5284{
5285}
5286impl flutter_rust_bridge::IntoIntoDart<crate::model::CheckMessageRequest>
5287    for crate::model::CheckMessageRequest
5288{
5289    fn into_into_dart(self) -> crate::model::CheckMessageRequest {
5290        self
5291    }
5292}
5293// Codec=Dco (DartCObject based), see doc to use other codecs
5294impl flutter_rust_bridge::IntoDart for crate::model::CheckMessageResponse {
5295    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5296        [self.is_valid.into_into_dart().into_dart()].into_dart()
5297    }
5298}
5299impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5300    for crate::model::CheckMessageResponse
5301{
5302}
5303impl flutter_rust_bridge::IntoIntoDart<crate::model::CheckMessageResponse>
5304    for crate::model::CheckMessageResponse
5305{
5306    fn into_into_dart(self) -> crate::model::CheckMessageResponse {
5307        self
5308    }
5309}
5310// Codec=Dco (DartCObject based), see doc to use other codecs
5311impl flutter_rust_bridge::IntoDart for crate::model::Config {
5312    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5313        [
5314            self.liquid_explorer.into_into_dart().into_dart(),
5315            self.bitcoin_explorer.into_into_dart().into_dart(),
5316            self.working_dir.into_into_dart().into_dart(),
5317            self.cache_dir.into_into_dart().into_dart(),
5318            self.network.into_into_dart().into_dart(),
5319            self.payment_timeout_sec.into_into_dart().into_dart(),
5320            self.sync_service_url.into_into_dart().into_dart(),
5321            self.zero_conf_max_amount_sat.into_into_dart().into_dart(),
5322            self.breez_api_key.into_into_dart().into_dart(),
5323            self.external_input_parsers.into_into_dart().into_dart(),
5324            self.use_default_external_input_parsers
5325                .into_into_dart()
5326                .into_dart(),
5327            self.onchain_fee_rate_leeway_sat_per_vbyte
5328                .into_into_dart()
5329                .into_dart(),
5330            self.asset_metadata.into_into_dart().into_dart(),
5331            self.sideswap_api_key.into_into_dart().into_dart(),
5332        ]
5333        .into_dart()
5334    }
5335}
5336impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::Config {}
5337impl flutter_rust_bridge::IntoIntoDart<crate::model::Config> for crate::model::Config {
5338    fn into_into_dart(self) -> crate::model::Config {
5339        self
5340    }
5341}
5342// Codec=Dco (DartCObject based), see doc to use other codecs
5343impl flutter_rust_bridge::IntoDart for crate::model::ConnectRequest {
5344    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5345        [
5346            self.config.into_into_dart().into_dart(),
5347            self.mnemonic.into_into_dart().into_dart(),
5348            self.passphrase.into_into_dart().into_dart(),
5349            self.seed.into_into_dart().into_dart(),
5350        ]
5351        .into_dart()
5352    }
5353}
5354impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::ConnectRequest {}
5355impl flutter_rust_bridge::IntoIntoDart<crate::model::ConnectRequest>
5356    for crate::model::ConnectRequest
5357{
5358    fn into_into_dart(self) -> crate::model::ConnectRequest {
5359        self
5360    }
5361}
5362// Codec=Dco (DartCObject based), see doc to use other codecs
5363impl flutter_rust_bridge::IntoDart for crate::model::CreateBolt12InvoiceRequest {
5364    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5365        [
5366            self.offer.into_into_dart().into_dart(),
5367            self.invoice_request.into_into_dart().into_dart(),
5368        ]
5369        .into_dart()
5370    }
5371}
5372impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5373    for crate::model::CreateBolt12InvoiceRequest
5374{
5375}
5376impl flutter_rust_bridge::IntoIntoDart<crate::model::CreateBolt12InvoiceRequest>
5377    for crate::model::CreateBolt12InvoiceRequest
5378{
5379    fn into_into_dart(self) -> crate::model::CreateBolt12InvoiceRequest {
5380        self
5381    }
5382}
5383// Codec=Dco (DartCObject based), see doc to use other codecs
5384impl flutter_rust_bridge::IntoDart for crate::model::CreateBolt12InvoiceResponse {
5385    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5386        [self.invoice.into_into_dart().into_dart()].into_dart()
5387    }
5388}
5389impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5390    for crate::model::CreateBolt12InvoiceResponse
5391{
5392}
5393impl flutter_rust_bridge::IntoIntoDart<crate::model::CreateBolt12InvoiceResponse>
5394    for crate::model::CreateBolt12InvoiceResponse
5395{
5396    fn into_into_dart(self) -> crate::model::CreateBolt12InvoiceResponse {
5397        self
5398    }
5399}
5400// Codec=Dco (DartCObject based), see doc to use other codecs
5401impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::CurrencyInfo> {
5402    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5403        [
5404            self.0.name.into_into_dart().into_dart(),
5405            self.0.fraction_size.into_into_dart().into_dart(),
5406            self.0.spacing.into_into_dart().into_dart(),
5407            self.0.symbol.into_into_dart().into_dart(),
5408            self.0.uniq_symbol.into_into_dart().into_dart(),
5409            self.0.localized_name.into_into_dart().into_dart(),
5410            self.0.locale_overrides.into_into_dart().into_dart(),
5411        ]
5412        .into_dart()
5413    }
5414}
5415impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5416    for FrbWrapper<crate::bindings::CurrencyInfo>
5417{
5418}
5419impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::CurrencyInfo>>
5420    for crate::bindings::CurrencyInfo
5421{
5422    fn into_into_dart(self) -> FrbWrapper<crate::bindings::CurrencyInfo> {
5423        self.into()
5424    }
5425}
5426// Codec=Dco (DartCObject based), see doc to use other codecs
5427impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::ExternalInputParser> {
5428    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5429        [
5430            self.0.provider_id.into_into_dart().into_dart(),
5431            self.0.input_regex.into_into_dart().into_dart(),
5432            self.0.parser_url.into_into_dart().into_dart(),
5433        ]
5434        .into_dart()
5435    }
5436}
5437impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5438    for FrbWrapper<crate::bindings::ExternalInputParser>
5439{
5440}
5441impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::ExternalInputParser>>
5442    for crate::bindings::ExternalInputParser
5443{
5444    fn into_into_dart(self) -> FrbWrapper<crate::bindings::ExternalInputParser> {
5445        self.into()
5446    }
5447}
5448// Codec=Dco (DartCObject based), see doc to use other codecs
5449impl flutter_rust_bridge::IntoDart for crate::model::FetchPaymentProposedFeesRequest {
5450    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5451        [self.swap_id.into_into_dart().into_dart()].into_dart()
5452    }
5453}
5454impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5455    for crate::model::FetchPaymentProposedFeesRequest
5456{
5457}
5458impl flutter_rust_bridge::IntoIntoDart<crate::model::FetchPaymentProposedFeesRequest>
5459    for crate::model::FetchPaymentProposedFeesRequest
5460{
5461    fn into_into_dart(self) -> crate::model::FetchPaymentProposedFeesRequest {
5462        self
5463    }
5464}
5465// Codec=Dco (DartCObject based), see doc to use other codecs
5466impl flutter_rust_bridge::IntoDart for crate::model::FetchPaymentProposedFeesResponse {
5467    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5468        [
5469            self.swap_id.into_into_dart().into_dart(),
5470            self.fees_sat.into_into_dart().into_dart(),
5471            self.payer_amount_sat.into_into_dart().into_dart(),
5472            self.receiver_amount_sat.into_into_dart().into_dart(),
5473        ]
5474        .into_dart()
5475    }
5476}
5477impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5478    for crate::model::FetchPaymentProposedFeesResponse
5479{
5480}
5481impl flutter_rust_bridge::IntoIntoDart<crate::model::FetchPaymentProposedFeesResponse>
5482    for crate::model::FetchPaymentProposedFeesResponse
5483{
5484    fn into_into_dart(self) -> crate::model::FetchPaymentProposedFeesResponse {
5485        self
5486    }
5487}
5488// Codec=Dco (DartCObject based), see doc to use other codecs
5489impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::FiatCurrency> {
5490    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5491        [
5492            self.0.id.into_into_dart().into_dart(),
5493            self.0.info.into_into_dart().into_dart(),
5494        ]
5495        .into_dart()
5496    }
5497}
5498impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5499    for FrbWrapper<crate::bindings::FiatCurrency>
5500{
5501}
5502impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::FiatCurrency>>
5503    for crate::bindings::FiatCurrency
5504{
5505    fn into_into_dart(self) -> FrbWrapper<crate::bindings::FiatCurrency> {
5506        self.into()
5507    }
5508}
5509// Codec=Dco (DartCObject based), see doc to use other codecs
5510impl flutter_rust_bridge::IntoDart for crate::model::GetInfoResponse {
5511    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5512        [
5513            self.wallet_info.into_into_dart().into_dart(),
5514            self.blockchain_info.into_into_dart().into_dart(),
5515        ]
5516        .into_dart()
5517    }
5518}
5519impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::GetInfoResponse {}
5520impl flutter_rust_bridge::IntoIntoDart<crate::model::GetInfoResponse>
5521    for crate::model::GetInfoResponse
5522{
5523    fn into_into_dart(self) -> crate::model::GetInfoResponse {
5524        self
5525    }
5526}
5527// Codec=Dco (DartCObject based), see doc to use other codecs
5528impl flutter_rust_bridge::IntoDart for crate::model::GetPaymentRequest {
5529    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5530        match self {
5531            crate::model::GetPaymentRequest::PaymentHash { payment_hash } => {
5532                [0.into_dart(), payment_hash.into_into_dart().into_dart()].into_dart()
5533            }
5534            crate::model::GetPaymentRequest::SwapId { swap_id } => {
5535                [1.into_dart(), swap_id.into_into_dart().into_dart()].into_dart()
5536            }
5537            _ => {
5538                unimplemented!("");
5539            }
5540        }
5541    }
5542}
5543impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5544    for crate::model::GetPaymentRequest
5545{
5546}
5547impl flutter_rust_bridge::IntoIntoDart<crate::model::GetPaymentRequest>
5548    for crate::model::GetPaymentRequest
5549{
5550    fn into_into_dart(self) -> crate::model::GetPaymentRequest {
5551        self
5552    }
5553}
5554// Codec=Dco (DartCObject based), see doc to use other codecs
5555impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::InputType> {
5556    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5557        match self.0 {
5558            crate::bindings::InputType::BitcoinAddress { address } => {
5559                [0.into_dart(), address.into_into_dart().into_dart()].into_dart()
5560            }
5561            crate::bindings::InputType::LiquidAddress { address } => {
5562                [1.into_dart(), address.into_into_dart().into_dart()].into_dart()
5563            }
5564            crate::bindings::InputType::Bolt11 { invoice } => {
5565                [2.into_dart(), invoice.into_into_dart().into_dart()].into_dart()
5566            }
5567            crate::bindings::InputType::Bolt12Offer {
5568                offer,
5569                bip353_address,
5570            } => [
5571                3.into_dart(),
5572                offer.into_into_dart().into_dart(),
5573                bip353_address.into_into_dart().into_dart(),
5574            ]
5575            .into_dart(),
5576            crate::bindings::InputType::NodeId { node_id } => {
5577                [4.into_dart(), node_id.into_into_dart().into_dart()].into_dart()
5578            }
5579            crate::bindings::InputType::Url { url } => {
5580                [5.into_dart(), url.into_into_dart().into_dart()].into_dart()
5581            }
5582            crate::bindings::InputType::LnUrlPay {
5583                data,
5584                bip353_address,
5585            } => [
5586                6.into_dart(),
5587                data.into_into_dart().into_dart(),
5588                bip353_address.into_into_dart().into_dart(),
5589            ]
5590            .into_dart(),
5591            crate::bindings::InputType::LnUrlWithdraw { data } => {
5592                [7.into_dart(), data.into_into_dart().into_dart()].into_dart()
5593            }
5594            crate::bindings::InputType::LnUrlAuth { data } => {
5595                [8.into_dart(), data.into_into_dart().into_dart()].into_dart()
5596            }
5597            crate::bindings::InputType::LnUrlError { data } => {
5598                [9.into_dart(), data.into_into_dart().into_dart()].into_dart()
5599            }
5600            _ => {
5601                unimplemented!("");
5602            }
5603        }
5604    }
5605}
5606impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5607    for FrbWrapper<crate::bindings::InputType>
5608{
5609}
5610impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::InputType>>
5611    for crate::bindings::InputType
5612{
5613    fn into_into_dart(self) -> FrbWrapper<crate::bindings::InputType> {
5614        self.into()
5615    }
5616}
5617// Codec=Dco (DartCObject based), see doc to use other codecs
5618impl flutter_rust_bridge::IntoDart for crate::model::LightningPaymentLimitsResponse {
5619    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5620        [
5621            self.send.into_into_dart().into_dart(),
5622            self.receive.into_into_dart().into_dart(),
5623        ]
5624        .into_dart()
5625    }
5626}
5627impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5628    for crate::model::LightningPaymentLimitsResponse
5629{
5630}
5631impl flutter_rust_bridge::IntoIntoDart<crate::model::LightningPaymentLimitsResponse>
5632    for crate::model::LightningPaymentLimitsResponse
5633{
5634    fn into_into_dart(self) -> crate::model::LightningPaymentLimitsResponse {
5635        self
5636    }
5637}
5638// Codec=Dco (DartCObject based), see doc to use other codecs
5639impl flutter_rust_bridge::IntoDart for crate::model::Limits {
5640    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5641        [
5642            self.min_sat.into_into_dart().into_dart(),
5643            self.max_sat.into_into_dart().into_dart(),
5644            self.max_zero_conf_sat.into_into_dart().into_dart(),
5645        ]
5646        .into_dart()
5647    }
5648}
5649impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::Limits {}
5650impl flutter_rust_bridge::IntoIntoDart<crate::model::Limits> for crate::model::Limits {
5651    fn into_into_dart(self) -> crate::model::Limits {
5652        self
5653    }
5654}
5655// Codec=Dco (DartCObject based), see doc to use other codecs
5656impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LiquidAddressData> {
5657    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5658        [
5659            self.0.address.into_into_dart().into_dart(),
5660            self.0.network.into_into_dart().into_dart(),
5661            self.0.asset_id.into_into_dart().into_dart(),
5662            self.0.amount.into_into_dart().into_dart(),
5663            self.0.amount_sat.into_into_dart().into_dart(),
5664            self.0.label.into_into_dart().into_dart(),
5665            self.0.message.into_into_dart().into_dart(),
5666        ]
5667        .into_dart()
5668    }
5669}
5670impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5671    for FrbWrapper<crate::bindings::LiquidAddressData>
5672{
5673}
5674impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LiquidAddressData>>
5675    for crate::bindings::LiquidAddressData
5676{
5677    fn into_into_dart(self) -> FrbWrapper<crate::bindings::LiquidAddressData> {
5678        self.into()
5679    }
5680}
5681// Codec=Dco (DartCObject based), see doc to use other codecs
5682impl flutter_rust_bridge::IntoDart for crate::model::LiquidNetwork {
5683    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5684        match self {
5685            Self::Mainnet => 0.into_dart(),
5686            Self::Testnet => 1.into_dart(),
5687            Self::Regtest => 2.into_dart(),
5688            _ => unreachable!(),
5689        }
5690    }
5691}
5692impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::LiquidNetwork {}
5693impl flutter_rust_bridge::IntoIntoDart<crate::model::LiquidNetwork>
5694    for crate::model::LiquidNetwork
5695{
5696    fn into_into_dart(self) -> crate::model::LiquidNetwork {
5697        self
5698    }
5699}
5700// Codec=Dco (DartCObject based), see doc to use other codecs
5701impl flutter_rust_bridge::IntoDart for crate::model::ListPaymentDetails {
5702    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5703        match self {
5704            crate::model::ListPaymentDetails::Liquid {
5705                asset_id,
5706                destination,
5707            } => [
5708                0.into_dart(),
5709                asset_id.into_into_dart().into_dart(),
5710                destination.into_into_dart().into_dart(),
5711            ]
5712            .into_dart(),
5713            crate::model::ListPaymentDetails::Bitcoin { address } => {
5714                [1.into_dart(), address.into_into_dart().into_dart()].into_dart()
5715            }
5716            _ => {
5717                unimplemented!("");
5718            }
5719        }
5720    }
5721}
5722impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5723    for crate::model::ListPaymentDetails
5724{
5725}
5726impl flutter_rust_bridge::IntoIntoDart<crate::model::ListPaymentDetails>
5727    for crate::model::ListPaymentDetails
5728{
5729    fn into_into_dart(self) -> crate::model::ListPaymentDetails {
5730        self
5731    }
5732}
5733// Codec=Dco (DartCObject based), see doc to use other codecs
5734impl flutter_rust_bridge::IntoDart for crate::model::ListPaymentsRequest {
5735    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5736        [
5737            self.filters.into_into_dart().into_dart(),
5738            self.states.into_into_dart().into_dart(),
5739            self.from_timestamp.into_into_dart().into_dart(),
5740            self.to_timestamp.into_into_dart().into_dart(),
5741            self.offset.into_into_dart().into_dart(),
5742            self.limit.into_into_dart().into_dart(),
5743            self.details.into_into_dart().into_dart(),
5744            self.sort_ascending.into_into_dart().into_dart(),
5745        ]
5746        .into_dart()
5747    }
5748}
5749impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5750    for crate::model::ListPaymentsRequest
5751{
5752}
5753impl flutter_rust_bridge::IntoIntoDart<crate::model::ListPaymentsRequest>
5754    for crate::model::ListPaymentsRequest
5755{
5756    fn into_into_dart(self) -> crate::model::ListPaymentsRequest {
5757        self
5758    }
5759}
5760// Codec=Dco (DartCObject based), see doc to use other codecs
5761impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LNInvoice> {
5762    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5763        [
5764            self.0.bolt11.into_into_dart().into_dart(),
5765            self.0.network.into_into_dart().into_dart(),
5766            self.0.payee_pubkey.into_into_dart().into_dart(),
5767            self.0.payment_hash.into_into_dart().into_dart(),
5768            self.0.description.into_into_dart().into_dart(),
5769            self.0.description_hash.into_into_dart().into_dart(),
5770            self.0.amount_msat.into_into_dart().into_dart(),
5771            self.0.timestamp.into_into_dart().into_dart(),
5772            self.0.expiry.into_into_dart().into_dart(),
5773            self.0.routing_hints.into_into_dart().into_dart(),
5774            self.0.payment_secret.into_into_dart().into_dart(),
5775            self.0
5776                .min_final_cltv_expiry_delta
5777                .into_into_dart()
5778                .into_dart(),
5779        ]
5780        .into_dart()
5781    }
5782}
5783impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5784    for FrbWrapper<crate::bindings::LNInvoice>
5785{
5786}
5787impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LNInvoice>>
5788    for crate::bindings::LNInvoice
5789{
5790    fn into_into_dart(self) -> FrbWrapper<crate::bindings::LNInvoice> {
5791        self.into()
5792    }
5793}
5794// Codec=Dco (DartCObject based), see doc to use other codecs
5795impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LNOffer> {
5796    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5797        [
5798            self.0.offer.into_into_dart().into_dart(),
5799            self.0.chains.into_into_dart().into_dart(),
5800            self.0.min_amount.into_into_dart().into_dart(),
5801            self.0.description.into_into_dart().into_dart(),
5802            self.0.absolute_expiry.into_into_dart().into_dart(),
5803            self.0.issuer.into_into_dart().into_dart(),
5804            self.0.signing_pubkey.into_into_dart().into_dart(),
5805            self.0.paths.into_into_dart().into_dart(),
5806        ]
5807        .into_dart()
5808    }
5809}
5810impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5811    for FrbWrapper<crate::bindings::LNOffer>
5812{
5813}
5814impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LNOffer>>
5815    for crate::bindings::LNOffer
5816{
5817    fn into_into_dart(self) -> FrbWrapper<crate::bindings::LNOffer> {
5818        self.into()
5819    }
5820}
5821// Codec=Dco (DartCObject based), see doc to use other codecs
5822impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LnOfferBlindedPath> {
5823    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5824        [self.0.blinded_hops.into_into_dart().into_dart()].into_dart()
5825    }
5826}
5827impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5828    for FrbWrapper<crate::bindings::LnOfferBlindedPath>
5829{
5830}
5831impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LnOfferBlindedPath>>
5832    for crate::bindings::LnOfferBlindedPath
5833{
5834    fn into_into_dart(self) -> FrbWrapper<crate::bindings::LnOfferBlindedPath> {
5835        self.into()
5836    }
5837}
5838// Codec=Dco (DartCObject based), see doc to use other codecs
5839impl flutter_rust_bridge::IntoDart for crate::bindings::duplicates::LnUrlAuthError {
5840    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5841        match self {
5842            crate::bindings::duplicates::LnUrlAuthError::Generic { err } => {
5843                [0.into_dart(), err.into_into_dart().into_dart()].into_dart()
5844            }
5845            crate::bindings::duplicates::LnUrlAuthError::InvalidUri { err } => {
5846                [1.into_dart(), err.into_into_dart().into_dart()].into_dart()
5847            }
5848            crate::bindings::duplicates::LnUrlAuthError::ServiceConnectivity { err } => {
5849                [2.into_dart(), err.into_into_dart().into_dart()].into_dart()
5850            }
5851            _ => {
5852                unimplemented!("");
5853            }
5854        }
5855    }
5856}
5857impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5858    for crate::bindings::duplicates::LnUrlAuthError
5859{
5860}
5861impl flutter_rust_bridge::IntoIntoDart<crate::bindings::duplicates::LnUrlAuthError>
5862    for crate::bindings::duplicates::LnUrlAuthError
5863{
5864    fn into_into_dart(self) -> crate::bindings::duplicates::LnUrlAuthError {
5865        self
5866    }
5867}
5868// Codec=Dco (DartCObject based), see doc to use other codecs
5869impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LnUrlAuthRequestData> {
5870    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5871        [
5872            self.0.k1.into_into_dart().into_dart(),
5873            self.0.action.into_into_dart().into_dart(),
5874            self.0.domain.into_into_dart().into_dart(),
5875            self.0.url.into_into_dart().into_dart(),
5876        ]
5877        .into_dart()
5878    }
5879}
5880impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5881    for FrbWrapper<crate::bindings::LnUrlAuthRequestData>
5882{
5883}
5884impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LnUrlAuthRequestData>>
5885    for crate::bindings::LnUrlAuthRequestData
5886{
5887    fn into_into_dart(self) -> FrbWrapper<crate::bindings::LnUrlAuthRequestData> {
5888        self.into()
5889    }
5890}
5891// Codec=Dco (DartCObject based), see doc to use other codecs
5892impl flutter_rust_bridge::IntoDart for crate::bindings::duplicates::LnUrlCallbackStatus {
5893    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5894        match self {
5895            crate::bindings::duplicates::LnUrlCallbackStatus::Ok => [0.into_dart()].into_dart(),
5896            crate::bindings::duplicates::LnUrlCallbackStatus::ErrorStatus { data } => {
5897                [1.into_dart(), data.into_into_dart().into_dart()].into_dart()
5898            }
5899            _ => {
5900                unimplemented!("");
5901            }
5902        }
5903    }
5904}
5905impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5906    for crate::bindings::duplicates::LnUrlCallbackStatus
5907{
5908}
5909impl flutter_rust_bridge::IntoIntoDart<crate::bindings::duplicates::LnUrlCallbackStatus>
5910    for crate::bindings::duplicates::LnUrlCallbackStatus
5911{
5912    fn into_into_dart(self) -> crate::bindings::duplicates::LnUrlCallbackStatus {
5913        self
5914    }
5915}
5916// Codec=Dco (DartCObject based), see doc to use other codecs
5917impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LnUrlErrorData> {
5918    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5919        [self.0.reason.into_into_dart().into_dart()].into_dart()
5920    }
5921}
5922impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5923    for FrbWrapper<crate::bindings::LnUrlErrorData>
5924{
5925}
5926impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LnUrlErrorData>>
5927    for crate::bindings::LnUrlErrorData
5928{
5929    fn into_into_dart(self) -> FrbWrapper<crate::bindings::LnUrlErrorData> {
5930        self.into()
5931    }
5932}
5933// Codec=Dco (DartCObject based), see doc to use other codecs
5934impl flutter_rust_bridge::IntoDart for crate::model::LnUrlInfo {
5935    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5936        [
5937            self.ln_address.into_into_dart().into_dart(),
5938            self.lnurl_pay_comment.into_into_dart().into_dart(),
5939            self.lnurl_pay_domain.into_into_dart().into_dart(),
5940            self.lnurl_pay_metadata.into_into_dart().into_dart(),
5941            self.lnurl_pay_success_action.into_into_dart().into_dart(),
5942            self.lnurl_pay_unprocessed_success_action
5943                .into_into_dart()
5944                .into_dart(),
5945            self.lnurl_withdraw_endpoint.into_into_dart().into_dart(),
5946        ]
5947        .into_dart()
5948    }
5949}
5950impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::LnUrlInfo {}
5951impl flutter_rust_bridge::IntoIntoDart<crate::model::LnUrlInfo> for crate::model::LnUrlInfo {
5952    fn into_into_dart(self) -> crate::model::LnUrlInfo {
5953        self
5954    }
5955}
5956// Codec=Dco (DartCObject based), see doc to use other codecs
5957impl flutter_rust_bridge::IntoDart for crate::bindings::duplicates::LnUrlPayError {
5958    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5959        match self {
5960            crate::bindings::duplicates::LnUrlPayError::AlreadyPaid => [0.into_dart()].into_dart(),
5961            crate::bindings::duplicates::LnUrlPayError::Generic { err } => {
5962                [1.into_dart(), err.into_into_dart().into_dart()].into_dart()
5963            }
5964            crate::bindings::duplicates::LnUrlPayError::InsufficientBalance { err } => {
5965                [2.into_dart(), err.into_into_dart().into_dart()].into_dart()
5966            }
5967            crate::bindings::duplicates::LnUrlPayError::InvalidAmount { err } => {
5968                [3.into_dart(), err.into_into_dart().into_dart()].into_dart()
5969            }
5970            crate::bindings::duplicates::LnUrlPayError::InvalidInvoice { err } => {
5971                [4.into_dart(), err.into_into_dart().into_dart()].into_dart()
5972            }
5973            crate::bindings::duplicates::LnUrlPayError::InvalidNetwork { err } => {
5974                [5.into_dart(), err.into_into_dart().into_dart()].into_dart()
5975            }
5976            crate::bindings::duplicates::LnUrlPayError::InvalidUri { err } => {
5977                [6.into_dart(), err.into_into_dart().into_dart()].into_dart()
5978            }
5979            crate::bindings::duplicates::LnUrlPayError::InvoiceExpired { err } => {
5980                [7.into_dart(), err.into_into_dart().into_dart()].into_dart()
5981            }
5982            crate::bindings::duplicates::LnUrlPayError::PaymentFailed { err } => {
5983                [8.into_dart(), err.into_into_dart().into_dart()].into_dart()
5984            }
5985            crate::bindings::duplicates::LnUrlPayError::PaymentTimeout { err } => {
5986                [9.into_dart(), err.into_into_dart().into_dart()].into_dart()
5987            }
5988            crate::bindings::duplicates::LnUrlPayError::RouteNotFound { err } => {
5989                [10.into_dart(), err.into_into_dart().into_dart()].into_dart()
5990            }
5991            crate::bindings::duplicates::LnUrlPayError::RouteTooExpensive { err } => {
5992                [11.into_dart(), err.into_into_dart().into_dart()].into_dart()
5993            }
5994            crate::bindings::duplicates::LnUrlPayError::ServiceConnectivity { err } => {
5995                [12.into_dart(), err.into_into_dart().into_dart()].into_dart()
5996            }
5997            _ => {
5998                unimplemented!("");
5999            }
6000        }
6001    }
6002}
6003impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6004    for crate::bindings::duplicates::LnUrlPayError
6005{
6006}
6007impl flutter_rust_bridge::IntoIntoDart<crate::bindings::duplicates::LnUrlPayError>
6008    for crate::bindings::duplicates::LnUrlPayError
6009{
6010    fn into_into_dart(self) -> crate::bindings::duplicates::LnUrlPayError {
6011        self
6012    }
6013}
6014// Codec=Dco (DartCObject based), see doc to use other codecs
6015impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LnUrlPayErrorData> {
6016    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6017        [
6018            self.0.payment_hash.into_into_dart().into_dart(),
6019            self.0.reason.into_into_dart().into_dart(),
6020        ]
6021        .into_dart()
6022    }
6023}
6024impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6025    for FrbWrapper<crate::bindings::LnUrlPayErrorData>
6026{
6027}
6028impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LnUrlPayErrorData>>
6029    for crate::bindings::LnUrlPayErrorData
6030{
6031    fn into_into_dart(self) -> FrbWrapper<crate::bindings::LnUrlPayErrorData> {
6032        self.into()
6033    }
6034}
6035// Codec=Dco (DartCObject based), see doc to use other codecs
6036impl flutter_rust_bridge::IntoDart for crate::model::LnUrlPayRequest {
6037    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6038        [self.prepare_response.into_into_dart().into_dart()].into_dart()
6039    }
6040}
6041impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::LnUrlPayRequest {}
6042impl flutter_rust_bridge::IntoIntoDart<crate::model::LnUrlPayRequest>
6043    for crate::model::LnUrlPayRequest
6044{
6045    fn into_into_dart(self) -> crate::model::LnUrlPayRequest {
6046        self
6047    }
6048}
6049// Codec=Dco (DartCObject based), see doc to use other codecs
6050impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LnUrlPayRequestData> {
6051    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6052        [
6053            self.0.callback.into_into_dart().into_dart(),
6054            self.0.min_sendable.into_into_dart().into_dart(),
6055            self.0.max_sendable.into_into_dart().into_dart(),
6056            self.0.metadata_str.into_into_dart().into_dart(),
6057            self.0.comment_allowed.into_into_dart().into_dart(),
6058            self.0.domain.into_into_dart().into_dart(),
6059            self.0.allows_nostr.into_into_dart().into_dart(),
6060            self.0.nostr_pubkey.into_into_dart().into_dart(),
6061            self.0.ln_address.into_into_dart().into_dart(),
6062        ]
6063        .into_dart()
6064    }
6065}
6066impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6067    for FrbWrapper<crate::bindings::LnUrlPayRequestData>
6068{
6069}
6070impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LnUrlPayRequestData>>
6071    for crate::bindings::LnUrlPayRequestData
6072{
6073    fn into_into_dart(self) -> FrbWrapper<crate::bindings::LnUrlPayRequestData> {
6074        self.into()
6075    }
6076}
6077// Codec=Dco (DartCObject based), see doc to use other codecs
6078impl flutter_rust_bridge::IntoDart for crate::model::LnUrlPayResult {
6079    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6080        match self {
6081            crate::model::LnUrlPayResult::EndpointSuccess { data } => {
6082                [0.into_dart(), data.into_into_dart().into_dart()].into_dart()
6083            }
6084            crate::model::LnUrlPayResult::EndpointError { data } => {
6085                [1.into_dart(), data.into_into_dart().into_dart()].into_dart()
6086            }
6087            crate::model::LnUrlPayResult::PayError { data } => {
6088                [2.into_dart(), data.into_into_dart().into_dart()].into_dart()
6089            }
6090            _ => {
6091                unimplemented!("");
6092            }
6093        }
6094    }
6095}
6096impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::LnUrlPayResult {}
6097impl flutter_rust_bridge::IntoIntoDart<crate::model::LnUrlPayResult>
6098    for crate::model::LnUrlPayResult
6099{
6100    fn into_into_dart(self) -> crate::model::LnUrlPayResult {
6101        self
6102    }
6103}
6104// Codec=Dco (DartCObject based), see doc to use other codecs
6105impl flutter_rust_bridge::IntoDart for crate::model::LnUrlPaySuccessData {
6106    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6107        [
6108            self.payment.into_into_dart().into_dart(),
6109            self.success_action.into_into_dart().into_dart(),
6110        ]
6111        .into_dart()
6112    }
6113}
6114impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6115    for crate::model::LnUrlPaySuccessData
6116{
6117}
6118impl flutter_rust_bridge::IntoIntoDart<crate::model::LnUrlPaySuccessData>
6119    for crate::model::LnUrlPaySuccessData
6120{
6121    fn into_into_dart(self) -> crate::model::LnUrlPaySuccessData {
6122        self
6123    }
6124}
6125// Codec=Dco (DartCObject based), see doc to use other codecs
6126impl flutter_rust_bridge::IntoDart for crate::bindings::duplicates::LnUrlWithdrawError {
6127    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6128        match self {
6129            crate::bindings::duplicates::LnUrlWithdrawError::Generic { err } => {
6130                [0.into_dart(), err.into_into_dart().into_dart()].into_dart()
6131            }
6132            crate::bindings::duplicates::LnUrlWithdrawError::InvalidAmount { err } => {
6133                [1.into_dart(), err.into_into_dart().into_dart()].into_dart()
6134            }
6135            crate::bindings::duplicates::LnUrlWithdrawError::InvalidInvoice { err } => {
6136                [2.into_dart(), err.into_into_dart().into_dart()].into_dart()
6137            }
6138            crate::bindings::duplicates::LnUrlWithdrawError::InvalidUri { err } => {
6139                [3.into_dart(), err.into_into_dart().into_dart()].into_dart()
6140            }
6141            crate::bindings::duplicates::LnUrlWithdrawError::InvoiceNoRoutingHints { err } => {
6142                [4.into_dart(), err.into_into_dart().into_dart()].into_dart()
6143            }
6144            crate::bindings::duplicates::LnUrlWithdrawError::ServiceConnectivity { err } => {
6145                [5.into_dart(), err.into_into_dart().into_dart()].into_dart()
6146            }
6147            _ => {
6148                unimplemented!("");
6149            }
6150        }
6151    }
6152}
6153impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6154    for crate::bindings::duplicates::LnUrlWithdrawError
6155{
6156}
6157impl flutter_rust_bridge::IntoIntoDart<crate::bindings::duplicates::LnUrlWithdrawError>
6158    for crate::bindings::duplicates::LnUrlWithdrawError
6159{
6160    fn into_into_dart(self) -> crate::bindings::duplicates::LnUrlWithdrawError {
6161        self
6162    }
6163}
6164// Codec=Dco (DartCObject based), see doc to use other codecs
6165impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LnUrlWithdrawRequest> {
6166    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6167        [
6168            self.0.data.into_into_dart().into_dart(),
6169            self.0.amount_msat.into_into_dart().into_dart(),
6170            self.0.description.into_into_dart().into_dart(),
6171        ]
6172        .into_dart()
6173    }
6174}
6175impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6176    for FrbWrapper<crate::bindings::LnUrlWithdrawRequest>
6177{
6178}
6179impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LnUrlWithdrawRequest>>
6180    for crate::bindings::LnUrlWithdrawRequest
6181{
6182    fn into_into_dart(self) -> FrbWrapper<crate::bindings::LnUrlWithdrawRequest> {
6183        self.into()
6184    }
6185}
6186// Codec=Dco (DartCObject based), see doc to use other codecs
6187impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LnUrlWithdrawRequestData> {
6188    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6189        [
6190            self.0.callback.into_into_dart().into_dart(),
6191            self.0.k1.into_into_dart().into_dart(),
6192            self.0.default_description.into_into_dart().into_dart(),
6193            self.0.min_withdrawable.into_into_dart().into_dart(),
6194            self.0.max_withdrawable.into_into_dart().into_dart(),
6195        ]
6196        .into_dart()
6197    }
6198}
6199impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6200    for FrbWrapper<crate::bindings::LnUrlWithdrawRequestData>
6201{
6202}
6203impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LnUrlWithdrawRequestData>>
6204    for crate::bindings::LnUrlWithdrawRequestData
6205{
6206    fn into_into_dart(self) -> FrbWrapper<crate::bindings::LnUrlWithdrawRequestData> {
6207        self.into()
6208    }
6209}
6210// Codec=Dco (DartCObject based), see doc to use other codecs
6211impl flutter_rust_bridge::IntoDart for crate::bindings::duplicates::LnUrlWithdrawResult {
6212    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6213        match self {
6214            crate::bindings::duplicates::LnUrlWithdrawResult::Ok { data } => {
6215                [0.into_dart(), data.into_into_dart().into_dart()].into_dart()
6216            }
6217            crate::bindings::duplicates::LnUrlWithdrawResult::Timeout { data } => {
6218                [1.into_dart(), data.into_into_dart().into_dart()].into_dart()
6219            }
6220            crate::bindings::duplicates::LnUrlWithdrawResult::ErrorStatus { data } => {
6221                [2.into_dart(), data.into_into_dart().into_dart()].into_dart()
6222            }
6223            _ => {
6224                unimplemented!("");
6225            }
6226        }
6227    }
6228}
6229impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6230    for crate::bindings::duplicates::LnUrlWithdrawResult
6231{
6232}
6233impl flutter_rust_bridge::IntoIntoDart<crate::bindings::duplicates::LnUrlWithdrawResult>
6234    for crate::bindings::duplicates::LnUrlWithdrawResult
6235{
6236    fn into_into_dart(self) -> crate::bindings::duplicates::LnUrlWithdrawResult {
6237        self
6238    }
6239}
6240// Codec=Dco (DartCObject based), see doc to use other codecs
6241impl flutter_rust_bridge::IntoDart for crate::bindings::duplicates::LnUrlWithdrawSuccessData {
6242    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6243        [self.invoice.into_into_dart().into_dart()].into_dart()
6244    }
6245}
6246impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6247    for crate::bindings::duplicates::LnUrlWithdrawSuccessData
6248{
6249}
6250impl flutter_rust_bridge::IntoIntoDart<crate::bindings::duplicates::LnUrlWithdrawSuccessData>
6251    for crate::bindings::duplicates::LnUrlWithdrawSuccessData
6252{
6253    fn into_into_dart(self) -> crate::bindings::duplicates::LnUrlWithdrawSuccessData {
6254        self
6255    }
6256}
6257// Codec=Dco (DartCObject based), see doc to use other codecs
6258impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LocaleOverrides> {
6259    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6260        [
6261            self.0.locale.into_into_dart().into_dart(),
6262            self.0.spacing.into_into_dart().into_dart(),
6263            self.0.symbol.into_into_dart().into_dart(),
6264        ]
6265        .into_dart()
6266    }
6267}
6268impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6269    for FrbWrapper<crate::bindings::LocaleOverrides>
6270{
6271}
6272impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LocaleOverrides>>
6273    for crate::bindings::LocaleOverrides
6274{
6275    fn into_into_dart(self) -> FrbWrapper<crate::bindings::LocaleOverrides> {
6276        self.into()
6277    }
6278}
6279// Codec=Dco (DartCObject based), see doc to use other codecs
6280impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LocalizedName> {
6281    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6282        [
6283            self.0.locale.into_into_dart().into_dart(),
6284            self.0.name.into_into_dart().into_dart(),
6285        ]
6286        .into_dart()
6287    }
6288}
6289impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6290    for FrbWrapper<crate::bindings::LocalizedName>
6291{
6292}
6293impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LocalizedName>>
6294    for crate::bindings::LocalizedName
6295{
6296    fn into_into_dart(self) -> FrbWrapper<crate::bindings::LocalizedName> {
6297        self.into()
6298    }
6299}
6300// Codec=Dco (DartCObject based), see doc to use other codecs
6301impl flutter_rust_bridge::IntoDart for crate::model::LogEntry {
6302    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6303        [
6304            self.line.into_into_dart().into_dart(),
6305            self.level.into_into_dart().into_dart(),
6306        ]
6307        .into_dart()
6308    }
6309}
6310impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::LogEntry {}
6311impl flutter_rust_bridge::IntoIntoDart<crate::model::LogEntry> for crate::model::LogEntry {
6312    fn into_into_dart(self) -> crate::model::LogEntry {
6313        self
6314    }
6315}
6316// Codec=Dco (DartCObject based), see doc to use other codecs
6317impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::MessageSuccessActionData> {
6318    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6319        [self.0.message.into_into_dart().into_dart()].into_dart()
6320    }
6321}
6322impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6323    for FrbWrapper<crate::bindings::MessageSuccessActionData>
6324{
6325}
6326impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::MessageSuccessActionData>>
6327    for crate::bindings::MessageSuccessActionData
6328{
6329    fn into_into_dart(self) -> FrbWrapper<crate::bindings::MessageSuccessActionData> {
6330        self.into()
6331    }
6332}
6333// Codec=Dco (DartCObject based), see doc to use other codecs
6334impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::Network> {
6335    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6336        match self.0 {
6337            crate::bindings::Network::Bitcoin => 0.into_dart(),
6338            crate::bindings::Network::Testnet => 1.into_dart(),
6339            crate::bindings::Network::Signet => 2.into_dart(),
6340            crate::bindings::Network::Regtest => 3.into_dart(),
6341            _ => unreachable!(),
6342        }
6343    }
6344}
6345impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6346    for FrbWrapper<crate::bindings::Network>
6347{
6348}
6349impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::Network>>
6350    for crate::bindings::Network
6351{
6352    fn into_into_dart(self) -> FrbWrapper<crate::bindings::Network> {
6353        self.into()
6354    }
6355}
6356// Codec=Dco (DartCObject based), see doc to use other codecs
6357impl flutter_rust_bridge::IntoDart for crate::model::OnchainPaymentLimitsResponse {
6358    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6359        [
6360            self.send.into_into_dart().into_dart(),
6361            self.receive.into_into_dart().into_dart(),
6362        ]
6363        .into_dart()
6364    }
6365}
6366impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6367    for crate::model::OnchainPaymentLimitsResponse
6368{
6369}
6370impl flutter_rust_bridge::IntoIntoDart<crate::model::OnchainPaymentLimitsResponse>
6371    for crate::model::OnchainPaymentLimitsResponse
6372{
6373    fn into_into_dart(self) -> crate::model::OnchainPaymentLimitsResponse {
6374        self
6375    }
6376}
6377// Codec=Dco (DartCObject based), see doc to use other codecs
6378impl flutter_rust_bridge::IntoDart for crate::model::PayAmount {
6379    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6380        match self {
6381            crate::model::PayAmount::Bitcoin {
6382                receiver_amount_sat,
6383            } => [
6384                0.into_dart(),
6385                receiver_amount_sat.into_into_dart().into_dart(),
6386            ]
6387            .into_dart(),
6388            crate::model::PayAmount::Asset {
6389                asset_id,
6390                receiver_amount,
6391                estimate_asset_fees,
6392            } => [
6393                1.into_dart(),
6394                asset_id.into_into_dart().into_dart(),
6395                receiver_amount.into_into_dart().into_dart(),
6396                estimate_asset_fees.into_into_dart().into_dart(),
6397            ]
6398            .into_dart(),
6399            crate::model::PayAmount::Drain => [2.into_dart()].into_dart(),
6400            _ => {
6401                unimplemented!("");
6402            }
6403        }
6404    }
6405}
6406impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::PayAmount {}
6407impl flutter_rust_bridge::IntoIntoDart<crate::model::PayAmount> for crate::model::PayAmount {
6408    fn into_into_dart(self) -> crate::model::PayAmount {
6409        self
6410    }
6411}
6412// Codec=Dco (DartCObject based), see doc to use other codecs
6413impl flutter_rust_bridge::IntoDart for crate::model::PayOnchainRequest {
6414    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6415        [
6416            self.address.into_into_dart().into_dart(),
6417            self.prepare_response.into_into_dart().into_dart(),
6418        ]
6419        .into_dart()
6420    }
6421}
6422impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6423    for crate::model::PayOnchainRequest
6424{
6425}
6426impl flutter_rust_bridge::IntoIntoDart<crate::model::PayOnchainRequest>
6427    for crate::model::PayOnchainRequest
6428{
6429    fn into_into_dart(self) -> crate::model::PayOnchainRequest {
6430        self
6431    }
6432}
6433// Codec=Dco (DartCObject based), see doc to use other codecs
6434impl flutter_rust_bridge::IntoDart for crate::model::Payment {
6435    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6436        [
6437            self.destination.into_into_dart().into_dart(),
6438            self.tx_id.into_into_dart().into_dart(),
6439            self.unblinding_data.into_into_dart().into_dart(),
6440            self.timestamp.into_into_dart().into_dart(),
6441            self.amount_sat.into_into_dart().into_dart(),
6442            self.fees_sat.into_into_dart().into_dart(),
6443            self.swapper_fees_sat.into_into_dart().into_dart(),
6444            self.payment_type.into_into_dart().into_dart(),
6445            self.status.into_into_dart().into_dart(),
6446            self.details.into_into_dart().into_dart(),
6447        ]
6448        .into_dart()
6449    }
6450}
6451impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::Payment {}
6452impl flutter_rust_bridge::IntoIntoDart<crate::model::Payment> for crate::model::Payment {
6453    fn into_into_dart(self) -> crate::model::Payment {
6454        self
6455    }
6456}
6457// Codec=Dco (DartCObject based), see doc to use other codecs
6458impl flutter_rust_bridge::IntoDart for crate::model::PaymentDetails {
6459    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6460        match self {
6461            crate::model::PaymentDetails::Lightning {
6462                swap_id,
6463                description,
6464                liquid_expiration_blockheight,
6465                preimage,
6466                invoice,
6467                bolt12_offer,
6468                payment_hash,
6469                destination_pubkey,
6470                lnurl_info,
6471                bip353_address,
6472                claim_tx_id,
6473                refund_tx_id,
6474                refund_tx_amount_sat,
6475            } => [
6476                0.into_dart(),
6477                swap_id.into_into_dart().into_dart(),
6478                description.into_into_dart().into_dart(),
6479                liquid_expiration_blockheight.into_into_dart().into_dart(),
6480                preimage.into_into_dart().into_dart(),
6481                invoice.into_into_dart().into_dart(),
6482                bolt12_offer.into_into_dart().into_dart(),
6483                payment_hash.into_into_dart().into_dart(),
6484                destination_pubkey.into_into_dart().into_dart(),
6485                lnurl_info.into_into_dart().into_dart(),
6486                bip353_address.into_into_dart().into_dart(),
6487                claim_tx_id.into_into_dart().into_dart(),
6488                refund_tx_id.into_into_dart().into_dart(),
6489                refund_tx_amount_sat.into_into_dart().into_dart(),
6490            ]
6491            .into_dart(),
6492            crate::model::PaymentDetails::Liquid {
6493                destination,
6494                description,
6495                asset_id,
6496                asset_info,
6497                lnurl_info,
6498                bip353_address,
6499            } => [
6500                1.into_dart(),
6501                destination.into_into_dart().into_dart(),
6502                description.into_into_dart().into_dart(),
6503                asset_id.into_into_dart().into_dart(),
6504                asset_info.into_into_dart().into_dart(),
6505                lnurl_info.into_into_dart().into_dart(),
6506                bip353_address.into_into_dart().into_dart(),
6507            ]
6508            .into_dart(),
6509            crate::model::PaymentDetails::Bitcoin {
6510                swap_id,
6511                description,
6512                auto_accepted_fees,
6513                liquid_expiration_blockheight,
6514                bitcoin_expiration_blockheight,
6515                claim_tx_id,
6516                refund_tx_id,
6517                refund_tx_amount_sat,
6518            } => [
6519                2.into_dart(),
6520                swap_id.into_into_dart().into_dart(),
6521                description.into_into_dart().into_dart(),
6522                auto_accepted_fees.into_into_dart().into_dart(),
6523                liquid_expiration_blockheight.into_into_dart().into_dart(),
6524                bitcoin_expiration_blockheight.into_into_dart().into_dart(),
6525                claim_tx_id.into_into_dart().into_dart(),
6526                refund_tx_id.into_into_dart().into_dart(),
6527                refund_tx_amount_sat.into_into_dart().into_dart(),
6528            ]
6529            .into_dart(),
6530            _ => {
6531                unimplemented!("");
6532            }
6533        }
6534    }
6535}
6536impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::PaymentDetails {}
6537impl flutter_rust_bridge::IntoIntoDart<crate::model::PaymentDetails>
6538    for crate::model::PaymentDetails
6539{
6540    fn into_into_dart(self) -> crate::model::PaymentDetails {
6541        self
6542    }
6543}
6544// Codec=Dco (DartCObject based), see doc to use other codecs
6545impl flutter_rust_bridge::IntoDart for crate::error::PaymentError {
6546    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6547        match self {
6548            crate::error::PaymentError::AlreadyClaimed => [0.into_dart()].into_dart(),
6549            crate::error::PaymentError::AlreadyPaid => [1.into_dart()].into_dart(),
6550            crate::error::PaymentError::PaymentInProgress => [2.into_dart()].into_dart(),
6551            crate::error::PaymentError::AmountOutOfRange { min, max } => [
6552                3.into_dart(),
6553                min.into_into_dart().into_dart(),
6554                max.into_into_dart().into_dart(),
6555            ]
6556            .into_dart(),
6557            crate::error::PaymentError::AmountMissing { err } => {
6558                [4.into_dart(), err.into_into_dart().into_dart()].into_dart()
6559            }
6560            crate::error::PaymentError::AssetError { err } => {
6561                [5.into_dart(), err.into_into_dart().into_dart()].into_dart()
6562            }
6563            crate::error::PaymentError::InvalidNetwork { err } => {
6564                [6.into_dart(), err.into_into_dart().into_dart()].into_dart()
6565            }
6566            crate::error::PaymentError::Generic { err } => {
6567                [7.into_dart(), err.into_into_dart().into_dart()].into_dart()
6568            }
6569            crate::error::PaymentError::InvalidOrExpiredFees => [8.into_dart()].into_dart(),
6570            crate::error::PaymentError::InsufficientFunds => [9.into_dart()].into_dart(),
6571            crate::error::PaymentError::InvalidDescription { err } => {
6572                [10.into_dart(), err.into_into_dart().into_dart()].into_dart()
6573            }
6574            crate::error::PaymentError::InvalidInvoice { err } => {
6575                [11.into_dart(), err.into_into_dart().into_dart()].into_dart()
6576            }
6577            crate::error::PaymentError::InvalidPreimage => [12.into_dart()].into_dart(),
6578            crate::error::PaymentError::PairsNotFound => [13.into_dart()].into_dart(),
6579            crate::error::PaymentError::PaymentTimeout => [14.into_dart()].into_dart(),
6580            crate::error::PaymentError::PersistError => [15.into_dart()].into_dart(),
6581            crate::error::PaymentError::ReceiveError { err } => {
6582                [16.into_dart(), err.into_into_dart().into_dart()].into_dart()
6583            }
6584            crate::error::PaymentError::Refunded { err, refund_tx_id } => [
6585                17.into_dart(),
6586                err.into_into_dart().into_dart(),
6587                refund_tx_id.into_into_dart().into_dart(),
6588            ]
6589            .into_dart(),
6590            crate::error::PaymentError::SelfTransferNotSupported => [18.into_dart()].into_dart(),
6591            crate::error::PaymentError::SendError { err } => {
6592                [19.into_dart(), err.into_into_dart().into_dart()].into_dart()
6593            }
6594            crate::error::PaymentError::SignerError { err } => {
6595                [20.into_dart(), err.into_into_dart().into_dart()].into_dart()
6596            }
6597            _ => {
6598                unimplemented!("");
6599            }
6600        }
6601    }
6602}
6603impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::error::PaymentError {}
6604impl flutter_rust_bridge::IntoIntoDart<crate::error::PaymentError> for crate::error::PaymentError {
6605    fn into_into_dart(self) -> crate::error::PaymentError {
6606        self
6607    }
6608}
6609// Codec=Dco (DartCObject based), see doc to use other codecs
6610impl flutter_rust_bridge::IntoDart for crate::model::PaymentMethod {
6611    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6612        match self {
6613            Self::Lightning => 0.into_dart(),
6614            Self::Bolt11Invoice => 1.into_dart(),
6615            Self::Bolt12Offer => 2.into_dart(),
6616            Self::BitcoinAddress => 3.into_dart(),
6617            Self::LiquidAddress => 4.into_dart(),
6618            _ => unreachable!(),
6619        }
6620    }
6621}
6622impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::PaymentMethod {}
6623impl flutter_rust_bridge::IntoIntoDart<crate::model::PaymentMethod>
6624    for crate::model::PaymentMethod
6625{
6626    fn into_into_dart(self) -> crate::model::PaymentMethod {
6627        self
6628    }
6629}
6630// Codec=Dco (DartCObject based), see doc to use other codecs
6631impl flutter_rust_bridge::IntoDart for crate::model::PaymentState {
6632    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6633        match self {
6634            Self::Created => 0.into_dart(),
6635            Self::Pending => 1.into_dart(),
6636            Self::Complete => 2.into_dart(),
6637            Self::Failed => 3.into_dart(),
6638            Self::TimedOut => 4.into_dart(),
6639            Self::Refundable => 5.into_dart(),
6640            Self::RefundPending => 6.into_dart(),
6641            Self::WaitingFeeAcceptance => 7.into_dart(),
6642            _ => unreachable!(),
6643        }
6644    }
6645}
6646impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::PaymentState {}
6647impl flutter_rust_bridge::IntoIntoDart<crate::model::PaymentState> for crate::model::PaymentState {
6648    fn into_into_dart(self) -> crate::model::PaymentState {
6649        self
6650    }
6651}
6652// Codec=Dco (DartCObject based), see doc to use other codecs
6653impl flutter_rust_bridge::IntoDart for crate::model::PaymentType {
6654    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6655        match self {
6656            Self::Receive => 0.into_dart(),
6657            Self::Send => 1.into_dart(),
6658            _ => unreachable!(),
6659        }
6660    }
6661}
6662impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::PaymentType {}
6663impl flutter_rust_bridge::IntoIntoDart<crate::model::PaymentType> for crate::model::PaymentType {
6664    fn into_into_dart(self) -> crate::model::PaymentType {
6665        self
6666    }
6667}
6668// Codec=Dco (DartCObject based), see doc to use other codecs
6669impl flutter_rust_bridge::IntoDart for crate::model::PrepareBuyBitcoinRequest {
6670    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6671        [
6672            self.provider.into_into_dart().into_dart(),
6673            self.amount_sat.into_into_dart().into_dart(),
6674        ]
6675        .into_dart()
6676    }
6677}
6678impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6679    for crate::model::PrepareBuyBitcoinRequest
6680{
6681}
6682impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareBuyBitcoinRequest>
6683    for crate::model::PrepareBuyBitcoinRequest
6684{
6685    fn into_into_dart(self) -> crate::model::PrepareBuyBitcoinRequest {
6686        self
6687    }
6688}
6689// Codec=Dco (DartCObject based), see doc to use other codecs
6690impl flutter_rust_bridge::IntoDart for crate::model::PrepareBuyBitcoinResponse {
6691    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6692        [
6693            self.provider.into_into_dart().into_dart(),
6694            self.amount_sat.into_into_dart().into_dart(),
6695            self.fees_sat.into_into_dart().into_dart(),
6696        ]
6697        .into_dart()
6698    }
6699}
6700impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6701    for crate::model::PrepareBuyBitcoinResponse
6702{
6703}
6704impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareBuyBitcoinResponse>
6705    for crate::model::PrepareBuyBitcoinResponse
6706{
6707    fn into_into_dart(self) -> crate::model::PrepareBuyBitcoinResponse {
6708        self
6709    }
6710}
6711// Codec=Dco (DartCObject based), see doc to use other codecs
6712impl flutter_rust_bridge::IntoDart for crate::model::PrepareLnUrlPayRequest {
6713    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6714        [
6715            self.data.into_into_dart().into_dart(),
6716            self.amount.into_into_dart().into_dart(),
6717            self.bip353_address.into_into_dart().into_dart(),
6718            self.comment.into_into_dart().into_dart(),
6719            self.validate_success_action_url
6720                .into_into_dart()
6721                .into_dart(),
6722        ]
6723        .into_dart()
6724    }
6725}
6726impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6727    for crate::model::PrepareLnUrlPayRequest
6728{
6729}
6730impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareLnUrlPayRequest>
6731    for crate::model::PrepareLnUrlPayRequest
6732{
6733    fn into_into_dart(self) -> crate::model::PrepareLnUrlPayRequest {
6734        self
6735    }
6736}
6737// Codec=Dco (DartCObject based), see doc to use other codecs
6738impl flutter_rust_bridge::IntoDart for crate::model::PrepareLnUrlPayResponse {
6739    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6740        [
6741            self.destination.into_into_dart().into_dart(),
6742            self.fees_sat.into_into_dart().into_dart(),
6743            self.data.into_into_dart().into_dart(),
6744            self.comment.into_into_dart().into_dart(),
6745            self.success_action.into_into_dart().into_dart(),
6746        ]
6747        .into_dart()
6748    }
6749}
6750impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6751    for crate::model::PrepareLnUrlPayResponse
6752{
6753}
6754impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareLnUrlPayResponse>
6755    for crate::model::PrepareLnUrlPayResponse
6756{
6757    fn into_into_dart(self) -> crate::model::PrepareLnUrlPayResponse {
6758        self
6759    }
6760}
6761// Codec=Dco (DartCObject based), see doc to use other codecs
6762impl flutter_rust_bridge::IntoDart for crate::model::PreparePayOnchainRequest {
6763    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6764        [
6765            self.amount.into_into_dart().into_dart(),
6766            self.fee_rate_sat_per_vbyte.into_into_dart().into_dart(),
6767        ]
6768        .into_dart()
6769    }
6770}
6771impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6772    for crate::model::PreparePayOnchainRequest
6773{
6774}
6775impl flutter_rust_bridge::IntoIntoDart<crate::model::PreparePayOnchainRequest>
6776    for crate::model::PreparePayOnchainRequest
6777{
6778    fn into_into_dart(self) -> crate::model::PreparePayOnchainRequest {
6779        self
6780    }
6781}
6782// Codec=Dco (DartCObject based), see doc to use other codecs
6783impl flutter_rust_bridge::IntoDart for crate::model::PreparePayOnchainResponse {
6784    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6785        [
6786            self.receiver_amount_sat.into_into_dart().into_dart(),
6787            self.claim_fees_sat.into_into_dart().into_dart(),
6788            self.total_fees_sat.into_into_dart().into_dart(),
6789        ]
6790        .into_dart()
6791    }
6792}
6793impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6794    for crate::model::PreparePayOnchainResponse
6795{
6796}
6797impl flutter_rust_bridge::IntoIntoDart<crate::model::PreparePayOnchainResponse>
6798    for crate::model::PreparePayOnchainResponse
6799{
6800    fn into_into_dart(self) -> crate::model::PreparePayOnchainResponse {
6801        self
6802    }
6803}
6804// Codec=Dco (DartCObject based), see doc to use other codecs
6805impl flutter_rust_bridge::IntoDart for crate::model::PrepareReceiveRequest {
6806    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6807        [
6808            self.payment_method.into_into_dart().into_dart(),
6809            self.amount.into_into_dart().into_dart(),
6810        ]
6811        .into_dart()
6812    }
6813}
6814impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6815    for crate::model::PrepareReceiveRequest
6816{
6817}
6818impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareReceiveRequest>
6819    for crate::model::PrepareReceiveRequest
6820{
6821    fn into_into_dart(self) -> crate::model::PrepareReceiveRequest {
6822        self
6823    }
6824}
6825// Codec=Dco (DartCObject based), see doc to use other codecs
6826impl flutter_rust_bridge::IntoDart for crate::model::PrepareReceiveResponse {
6827    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6828        [
6829            self.payment_method.into_into_dart().into_dart(),
6830            self.fees_sat.into_into_dart().into_dart(),
6831            self.amount.into_into_dart().into_dart(),
6832            self.min_payer_amount_sat.into_into_dart().into_dart(),
6833            self.max_payer_amount_sat.into_into_dart().into_dart(),
6834            self.swapper_feerate.into_into_dart().into_dart(),
6835        ]
6836        .into_dart()
6837    }
6838}
6839impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6840    for crate::model::PrepareReceiveResponse
6841{
6842}
6843impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareReceiveResponse>
6844    for crate::model::PrepareReceiveResponse
6845{
6846    fn into_into_dart(self) -> crate::model::PrepareReceiveResponse {
6847        self
6848    }
6849}
6850// Codec=Dco (DartCObject based), see doc to use other codecs
6851impl flutter_rust_bridge::IntoDart for crate::model::PrepareRefundRequest {
6852    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6853        [
6854            self.swap_address.into_into_dart().into_dart(),
6855            self.refund_address.into_into_dart().into_dart(),
6856            self.fee_rate_sat_per_vbyte.into_into_dart().into_dart(),
6857        ]
6858        .into_dart()
6859    }
6860}
6861impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6862    for crate::model::PrepareRefundRequest
6863{
6864}
6865impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareRefundRequest>
6866    for crate::model::PrepareRefundRequest
6867{
6868    fn into_into_dart(self) -> crate::model::PrepareRefundRequest {
6869        self
6870    }
6871}
6872// Codec=Dco (DartCObject based), see doc to use other codecs
6873impl flutter_rust_bridge::IntoDart for crate::model::PrepareRefundResponse {
6874    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6875        [
6876            self.tx_vsize.into_into_dart().into_dart(),
6877            self.tx_fee_sat.into_into_dart().into_dart(),
6878            self.last_refund_tx_id.into_into_dart().into_dart(),
6879        ]
6880        .into_dart()
6881    }
6882}
6883impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6884    for crate::model::PrepareRefundResponse
6885{
6886}
6887impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareRefundResponse>
6888    for crate::model::PrepareRefundResponse
6889{
6890    fn into_into_dart(self) -> crate::model::PrepareRefundResponse {
6891        self
6892    }
6893}
6894// Codec=Dco (DartCObject based), see doc to use other codecs
6895impl flutter_rust_bridge::IntoDart for crate::model::PrepareSendRequest {
6896    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6897        [
6898            self.destination.into_into_dart().into_dart(),
6899            self.amount.into_into_dart().into_dart(),
6900        ]
6901        .into_dart()
6902    }
6903}
6904impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6905    for crate::model::PrepareSendRequest
6906{
6907}
6908impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareSendRequest>
6909    for crate::model::PrepareSendRequest
6910{
6911    fn into_into_dart(self) -> crate::model::PrepareSendRequest {
6912        self
6913    }
6914}
6915// Codec=Dco (DartCObject based), see doc to use other codecs
6916impl flutter_rust_bridge::IntoDart for crate::model::PrepareSendResponse {
6917    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6918        [
6919            self.destination.into_into_dart().into_dart(),
6920            self.fees_sat.into_into_dart().into_dart(),
6921            self.estimated_asset_fees.into_into_dart().into_dart(),
6922        ]
6923        .into_dart()
6924    }
6925}
6926impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6927    for crate::model::PrepareSendResponse
6928{
6929}
6930impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareSendResponse>
6931    for crate::model::PrepareSendResponse
6932{
6933    fn into_into_dart(self) -> crate::model::PrepareSendResponse {
6934        self
6935    }
6936}
6937// Codec=Dco (DartCObject based), see doc to use other codecs
6938impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::Rate> {
6939    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6940        [
6941            self.0.coin.into_into_dart().into_dart(),
6942            self.0.value.into_into_dart().into_dart(),
6943        ]
6944        .into_dart()
6945    }
6946}
6947impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6948    for FrbWrapper<crate::bindings::Rate>
6949{
6950}
6951impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::Rate>>
6952    for crate::bindings::Rate
6953{
6954    fn into_into_dart(self) -> FrbWrapper<crate::bindings::Rate> {
6955        self.into()
6956    }
6957}
6958// Codec=Dco (DartCObject based), see doc to use other codecs
6959impl flutter_rust_bridge::IntoDart for crate::model::ReceiveAmount {
6960    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6961        match self {
6962            crate::model::ReceiveAmount::Bitcoin { payer_amount_sat } => {
6963                [0.into_dart(), payer_amount_sat.into_into_dart().into_dart()].into_dart()
6964            }
6965            crate::model::ReceiveAmount::Asset {
6966                asset_id,
6967                payer_amount,
6968            } => [
6969                1.into_dart(),
6970                asset_id.into_into_dart().into_dart(),
6971                payer_amount.into_into_dart().into_dart(),
6972            ]
6973            .into_dart(),
6974            _ => {
6975                unimplemented!("");
6976            }
6977        }
6978    }
6979}
6980impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::ReceiveAmount {}
6981impl flutter_rust_bridge::IntoIntoDart<crate::model::ReceiveAmount>
6982    for crate::model::ReceiveAmount
6983{
6984    fn into_into_dart(self) -> crate::model::ReceiveAmount {
6985        self
6986    }
6987}
6988// Codec=Dco (DartCObject based), see doc to use other codecs
6989impl flutter_rust_bridge::IntoDart for crate::model::ReceivePaymentRequest {
6990    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6991        [
6992            self.prepare_response.into_into_dart().into_dart(),
6993            self.description.into_into_dart().into_dart(),
6994            self.use_description_hash.into_into_dart().into_dart(),
6995        ]
6996        .into_dart()
6997    }
6998}
6999impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7000    for crate::model::ReceivePaymentRequest
7001{
7002}
7003impl flutter_rust_bridge::IntoIntoDart<crate::model::ReceivePaymentRequest>
7004    for crate::model::ReceivePaymentRequest
7005{
7006    fn into_into_dart(self) -> crate::model::ReceivePaymentRequest {
7007        self
7008    }
7009}
7010// Codec=Dco (DartCObject based), see doc to use other codecs
7011impl flutter_rust_bridge::IntoDart for crate::model::ReceivePaymentResponse {
7012    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7013        [self.destination.into_into_dart().into_dart()].into_dart()
7014    }
7015}
7016impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7017    for crate::model::ReceivePaymentResponse
7018{
7019}
7020impl flutter_rust_bridge::IntoIntoDart<crate::model::ReceivePaymentResponse>
7021    for crate::model::ReceivePaymentResponse
7022{
7023    fn into_into_dart(self) -> crate::model::ReceivePaymentResponse {
7024        self
7025    }
7026}
7027// Codec=Dco (DartCObject based), see doc to use other codecs
7028impl flutter_rust_bridge::IntoDart for crate::model::RecommendedFees {
7029    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7030        [
7031            self.fastest_fee.into_into_dart().into_dart(),
7032            self.half_hour_fee.into_into_dart().into_dart(),
7033            self.hour_fee.into_into_dart().into_dart(),
7034            self.economy_fee.into_into_dart().into_dart(),
7035            self.minimum_fee.into_into_dart().into_dart(),
7036        ]
7037        .into_dart()
7038    }
7039}
7040impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::RecommendedFees {}
7041impl flutter_rust_bridge::IntoIntoDart<crate::model::RecommendedFees>
7042    for crate::model::RecommendedFees
7043{
7044    fn into_into_dart(self) -> crate::model::RecommendedFees {
7045        self
7046    }
7047}
7048// Codec=Dco (DartCObject based), see doc to use other codecs
7049impl flutter_rust_bridge::IntoDart for crate::model::RefundRequest {
7050    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7051        [
7052            self.swap_address.into_into_dart().into_dart(),
7053            self.refund_address.into_into_dart().into_dart(),
7054            self.fee_rate_sat_per_vbyte.into_into_dart().into_dart(),
7055        ]
7056        .into_dart()
7057    }
7058}
7059impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::RefundRequest {}
7060impl flutter_rust_bridge::IntoIntoDart<crate::model::RefundRequest>
7061    for crate::model::RefundRequest
7062{
7063    fn into_into_dart(self) -> crate::model::RefundRequest {
7064        self
7065    }
7066}
7067// Codec=Dco (DartCObject based), see doc to use other codecs
7068impl flutter_rust_bridge::IntoDart for crate::model::RefundResponse {
7069    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7070        [self.refund_tx_id.into_into_dart().into_dart()].into_dart()
7071    }
7072}
7073impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::RefundResponse {}
7074impl flutter_rust_bridge::IntoIntoDart<crate::model::RefundResponse>
7075    for crate::model::RefundResponse
7076{
7077    fn into_into_dart(self) -> crate::model::RefundResponse {
7078        self
7079    }
7080}
7081// Codec=Dco (DartCObject based), see doc to use other codecs
7082impl flutter_rust_bridge::IntoDart for crate::model::RefundableSwap {
7083    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7084        [
7085            self.swap_address.into_into_dart().into_dart(),
7086            self.timestamp.into_into_dart().into_dart(),
7087            self.amount_sat.into_into_dart().into_dart(),
7088            self.last_refund_tx_id.into_into_dart().into_dart(),
7089        ]
7090        .into_dart()
7091    }
7092}
7093impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::RefundableSwap {}
7094impl flutter_rust_bridge::IntoIntoDart<crate::model::RefundableSwap>
7095    for crate::model::RefundableSwap
7096{
7097    fn into_into_dart(self) -> crate::model::RefundableSwap {
7098        self
7099    }
7100}
7101// Codec=Dco (DartCObject based), see doc to use other codecs
7102impl flutter_rust_bridge::IntoDart for crate::model::RestoreRequest {
7103    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7104        [self.backup_path.into_into_dart().into_dart()].into_dart()
7105    }
7106}
7107impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::RestoreRequest {}
7108impl flutter_rust_bridge::IntoIntoDart<crate::model::RestoreRequest>
7109    for crate::model::RestoreRequest
7110{
7111    fn into_into_dart(self) -> crate::model::RestoreRequest {
7112        self
7113    }
7114}
7115// Codec=Dco (DartCObject based), see doc to use other codecs
7116impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::RouteHint> {
7117    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7118        [self.0.hops.into_into_dart().into_dart()].into_dart()
7119    }
7120}
7121impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7122    for FrbWrapper<crate::bindings::RouteHint>
7123{
7124}
7125impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::RouteHint>>
7126    for crate::bindings::RouteHint
7127{
7128    fn into_into_dart(self) -> FrbWrapper<crate::bindings::RouteHint> {
7129        self.into()
7130    }
7131}
7132// Codec=Dco (DartCObject based), see doc to use other codecs
7133impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::RouteHintHop> {
7134    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7135        [
7136            self.0.src_node_id.into_into_dart().into_dart(),
7137            self.0.short_channel_id.into_into_dart().into_dart(),
7138            self.0.fees_base_msat.into_into_dart().into_dart(),
7139            self.0
7140                .fees_proportional_millionths
7141                .into_into_dart()
7142                .into_dart(),
7143            self.0.cltv_expiry_delta.into_into_dart().into_dart(),
7144            self.0.htlc_minimum_msat.into_into_dart().into_dart(),
7145            self.0.htlc_maximum_msat.into_into_dart().into_dart(),
7146        ]
7147        .into_dart()
7148    }
7149}
7150impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7151    for FrbWrapper<crate::bindings::RouteHintHop>
7152{
7153}
7154impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::RouteHintHop>>
7155    for crate::bindings::RouteHintHop
7156{
7157    fn into_into_dart(self) -> FrbWrapper<crate::bindings::RouteHintHop> {
7158        self.into()
7159    }
7160}
7161// Codec=Dco (DartCObject based), see doc to use other codecs
7162impl flutter_rust_bridge::IntoDart for crate::error::SdkError {
7163    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7164        match self {
7165            crate::error::SdkError::AlreadyStarted => [0.into_dart()].into_dart(),
7166            crate::error::SdkError::Generic { err } => {
7167                [1.into_dart(), err.into_into_dart().into_dart()].into_dart()
7168            }
7169            crate::error::SdkError::NotStarted => [2.into_dart()].into_dart(),
7170            crate::error::SdkError::ServiceConnectivity { err } => {
7171                [3.into_dart(), err.into_into_dart().into_dart()].into_dart()
7172            }
7173            _ => {
7174                unimplemented!("");
7175            }
7176        }
7177    }
7178}
7179impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::error::SdkError {}
7180impl flutter_rust_bridge::IntoIntoDart<crate::error::SdkError> for crate::error::SdkError {
7181    fn into_into_dart(self) -> crate::error::SdkError {
7182        self
7183    }
7184}
7185// Codec=Dco (DartCObject based), see doc to use other codecs
7186impl flutter_rust_bridge::IntoDart for crate::model::SdkEvent {
7187    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7188        match self {
7189            crate::model::SdkEvent::PaymentFailed { details } => {
7190                [0.into_dart(), details.into_into_dart().into_dart()].into_dart()
7191            }
7192            crate::model::SdkEvent::PaymentPending { details } => {
7193                [1.into_dart(), details.into_into_dart().into_dart()].into_dart()
7194            }
7195            crate::model::SdkEvent::PaymentRefundable { details } => {
7196                [2.into_dart(), details.into_into_dart().into_dart()].into_dart()
7197            }
7198            crate::model::SdkEvent::PaymentRefunded { details } => {
7199                [3.into_dart(), details.into_into_dart().into_dart()].into_dart()
7200            }
7201            crate::model::SdkEvent::PaymentRefundPending { details } => {
7202                [4.into_dart(), details.into_into_dart().into_dart()].into_dart()
7203            }
7204            crate::model::SdkEvent::PaymentSucceeded { details } => {
7205                [5.into_dart(), details.into_into_dart().into_dart()].into_dart()
7206            }
7207            crate::model::SdkEvent::PaymentWaitingConfirmation { details } => {
7208                [6.into_dart(), details.into_into_dart().into_dart()].into_dart()
7209            }
7210            crate::model::SdkEvent::PaymentWaitingFeeAcceptance { details } => {
7211                [7.into_dart(), details.into_into_dart().into_dart()].into_dart()
7212            }
7213            crate::model::SdkEvent::Synced => [8.into_dart()].into_dart(),
7214            crate::model::SdkEvent::DataSynced {
7215                did_pull_new_records,
7216            } => [
7217                9.into_dart(),
7218                did_pull_new_records.into_into_dart().into_dart(),
7219            ]
7220            .into_dart(),
7221            _ => {
7222                unimplemented!("");
7223            }
7224        }
7225    }
7226}
7227impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::SdkEvent {}
7228impl flutter_rust_bridge::IntoIntoDart<crate::model::SdkEvent> for crate::model::SdkEvent {
7229    fn into_into_dart(self) -> crate::model::SdkEvent {
7230        self
7231    }
7232}
7233// Codec=Dco (DartCObject based), see doc to use other codecs
7234impl flutter_rust_bridge::IntoDart for crate::model::SendDestination {
7235    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7236        match self {
7237            crate::model::SendDestination::LiquidAddress {
7238                address_data,
7239                bip353_address,
7240            } => [
7241                0.into_dart(),
7242                address_data.into_into_dart().into_dart(),
7243                bip353_address.into_into_dart().into_dart(),
7244            ]
7245            .into_dart(),
7246            crate::model::SendDestination::Bolt11 {
7247                invoice,
7248                bip353_address,
7249            } => [
7250                1.into_dart(),
7251                invoice.into_into_dart().into_dart(),
7252                bip353_address.into_into_dart().into_dart(),
7253            ]
7254            .into_dart(),
7255            crate::model::SendDestination::Bolt12 {
7256                offer,
7257                receiver_amount_sat,
7258                bip353_address,
7259            } => [
7260                2.into_dart(),
7261                offer.into_into_dart().into_dart(),
7262                receiver_amount_sat.into_into_dart().into_dart(),
7263                bip353_address.into_into_dart().into_dart(),
7264            ]
7265            .into_dart(),
7266            _ => {
7267                unimplemented!("");
7268            }
7269        }
7270    }
7271}
7272impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::SendDestination {}
7273impl flutter_rust_bridge::IntoIntoDart<crate::model::SendDestination>
7274    for crate::model::SendDestination
7275{
7276    fn into_into_dart(self) -> crate::model::SendDestination {
7277        self
7278    }
7279}
7280// Codec=Dco (DartCObject based), see doc to use other codecs
7281impl flutter_rust_bridge::IntoDart for crate::model::SendPaymentRequest {
7282    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7283        [
7284            self.prepare_response.into_into_dart().into_dart(),
7285            self.use_asset_fees.into_into_dart().into_dart(),
7286        ]
7287        .into_dart()
7288    }
7289}
7290impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7291    for crate::model::SendPaymentRequest
7292{
7293}
7294impl flutter_rust_bridge::IntoIntoDart<crate::model::SendPaymentRequest>
7295    for crate::model::SendPaymentRequest
7296{
7297    fn into_into_dart(self) -> crate::model::SendPaymentRequest {
7298        self
7299    }
7300}
7301// Codec=Dco (DartCObject based), see doc to use other codecs
7302impl flutter_rust_bridge::IntoDart for crate::model::SendPaymentResponse {
7303    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7304        [self.payment.into_into_dart().into_dart()].into_dart()
7305    }
7306}
7307impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7308    for crate::model::SendPaymentResponse
7309{
7310}
7311impl flutter_rust_bridge::IntoIntoDart<crate::model::SendPaymentResponse>
7312    for crate::model::SendPaymentResponse
7313{
7314    fn into_into_dart(self) -> crate::model::SendPaymentResponse {
7315        self
7316    }
7317}
7318// Codec=Dco (DartCObject based), see doc to use other codecs
7319impl flutter_rust_bridge::IntoDart for crate::model::SignMessageRequest {
7320    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7321        [self.message.into_into_dart().into_dart()].into_dart()
7322    }
7323}
7324impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7325    for crate::model::SignMessageRequest
7326{
7327}
7328impl flutter_rust_bridge::IntoIntoDart<crate::model::SignMessageRequest>
7329    for crate::model::SignMessageRequest
7330{
7331    fn into_into_dart(self) -> crate::model::SignMessageRequest {
7332        self
7333    }
7334}
7335// Codec=Dco (DartCObject based), see doc to use other codecs
7336impl flutter_rust_bridge::IntoDart for crate::model::SignMessageResponse {
7337    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7338        [self.signature.into_into_dart().into_dart()].into_dart()
7339    }
7340}
7341impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7342    for crate::model::SignMessageResponse
7343{
7344}
7345impl flutter_rust_bridge::IntoIntoDart<crate::model::SignMessageResponse>
7346    for crate::model::SignMessageResponse
7347{
7348    fn into_into_dart(self) -> crate::model::SignMessageResponse {
7349        self
7350    }
7351}
7352// Codec=Dco (DartCObject based), see doc to use other codecs
7353impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::SuccessAction> {
7354    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7355        match self.0 {
7356            crate::bindings::SuccessAction::Aes { data } => {
7357                [0.into_dart(), data.into_into_dart().into_dart()].into_dart()
7358            }
7359            crate::bindings::SuccessAction::Message { data } => {
7360                [1.into_dart(), data.into_into_dart().into_dart()].into_dart()
7361            }
7362            crate::bindings::SuccessAction::Url { data } => {
7363                [2.into_dart(), data.into_into_dart().into_dart()].into_dart()
7364            }
7365            _ => {
7366                unimplemented!("");
7367            }
7368        }
7369    }
7370}
7371impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7372    for FrbWrapper<crate::bindings::SuccessAction>
7373{
7374}
7375impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::SuccessAction>>
7376    for crate::bindings::SuccessAction
7377{
7378    fn into_into_dart(self) -> FrbWrapper<crate::bindings::SuccessAction> {
7379        self.into()
7380    }
7381}
7382// Codec=Dco (DartCObject based), see doc to use other codecs
7383impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::SuccessActionProcessed> {
7384    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7385        match self.0 {
7386            crate::bindings::SuccessActionProcessed::Aes { result } => {
7387                [0.into_dart(), result.into_into_dart().into_dart()].into_dart()
7388            }
7389            crate::bindings::SuccessActionProcessed::Message { data } => {
7390                [1.into_dart(), data.into_into_dart().into_dart()].into_dart()
7391            }
7392            crate::bindings::SuccessActionProcessed::Url { data } => {
7393                [2.into_dart(), data.into_into_dart().into_dart()].into_dart()
7394            }
7395            _ => {
7396                unimplemented!("");
7397            }
7398        }
7399    }
7400}
7401impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7402    for FrbWrapper<crate::bindings::SuccessActionProcessed>
7403{
7404}
7405impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::SuccessActionProcessed>>
7406    for crate::bindings::SuccessActionProcessed
7407{
7408    fn into_into_dart(self) -> FrbWrapper<crate::bindings::SuccessActionProcessed> {
7409        self.into()
7410    }
7411}
7412// Codec=Dco (DartCObject based), see doc to use other codecs
7413impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::Symbol> {
7414    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7415        [
7416            self.0.grapheme.into_into_dart().into_dart(),
7417            self.0.template.into_into_dart().into_dart(),
7418            self.0.rtl.into_into_dart().into_dart(),
7419            self.0.position.into_into_dart().into_dart(),
7420        ]
7421        .into_dart()
7422    }
7423}
7424impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7425    for FrbWrapper<crate::bindings::Symbol>
7426{
7427}
7428impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::Symbol>>
7429    for crate::bindings::Symbol
7430{
7431    fn into_into_dart(self) -> FrbWrapper<crate::bindings::Symbol> {
7432        self.into()
7433    }
7434}
7435// Codec=Dco (DartCObject based), see doc to use other codecs
7436impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::UrlSuccessActionData> {
7437    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7438        [
7439            self.0.description.into_into_dart().into_dart(),
7440            self.0.url.into_into_dart().into_dart(),
7441            self.0.matches_callback_domain.into_into_dart().into_dart(),
7442        ]
7443        .into_dart()
7444    }
7445}
7446impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7447    for FrbWrapper<crate::bindings::UrlSuccessActionData>
7448{
7449}
7450impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::UrlSuccessActionData>>
7451    for crate::bindings::UrlSuccessActionData
7452{
7453    fn into_into_dart(self) -> FrbWrapper<crate::bindings::UrlSuccessActionData> {
7454        self.into()
7455    }
7456}
7457// Codec=Dco (DartCObject based), see doc to use other codecs
7458impl flutter_rust_bridge::IntoDart for crate::model::WalletInfo {
7459    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7460        [
7461            self.balance_sat.into_into_dart().into_dart(),
7462            self.pending_send_sat.into_into_dart().into_dart(),
7463            self.pending_receive_sat.into_into_dart().into_dart(),
7464            self.fingerprint.into_into_dart().into_dart(),
7465            self.pubkey.into_into_dart().into_dart(),
7466            self.asset_balances.into_into_dart().into_dart(),
7467        ]
7468        .into_dart()
7469    }
7470}
7471impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::WalletInfo {}
7472impl flutter_rust_bridge::IntoIntoDart<crate::model::WalletInfo> for crate::model::WalletInfo {
7473    fn into_into_dart(self) -> crate::model::WalletInfo {
7474        self
7475    }
7476}
7477
7478impl SseEncode for flutter_rust_bridge::for_generated::anyhow::Error {
7479    // Codec=Sse (Serialization based), see doc to use other codecs
7480    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7481        <String>::sse_encode(format!("{:?}", self), serializer);
7482    }
7483}
7484
7485impl SseEncode for BindingLiquidSdk {
7486    // Codec=Sse (Serialization based), see doc to use other codecs
7487    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7488        <RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>>::sse_encode(flutter_rust_bridge::for_generated::rust_auto_opaque_encode::<_, StdArc<_>>(self), serializer);
7489    }
7490}
7491
7492impl SseEncode
7493    for RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>
7494{
7495    // Codec=Sse (Serialization based), see doc to use other codecs
7496    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7497        let (ptr, size) = self.sse_encode_raw();
7498        <usize>::sse_encode(ptr, serializer);
7499        <i32>::sse_encode(size, serializer);
7500    }
7501}
7502
7503impl SseEncode
7504    for StreamSink<crate::model::LogEntry, flutter_rust_bridge::for_generated::DcoCodec>
7505{
7506    // Codec=Sse (Serialization based), see doc to use other codecs
7507    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7508        unimplemented!("")
7509    }
7510}
7511
7512impl SseEncode
7513    for StreamSink<crate::model::SdkEvent, flutter_rust_bridge::for_generated::DcoCodec>
7514{
7515    // Codec=Sse (Serialization based), see doc to use other codecs
7516    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7517        unimplemented!("")
7518    }
7519}
7520
7521impl SseEncode for String {
7522    // Codec=Sse (Serialization based), see doc to use other codecs
7523    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7524        <Vec<u8>>::sse_encode(self.into_bytes(), serializer);
7525    }
7526}
7527
7528impl SseEncode for crate::model::AcceptPaymentProposedFeesRequest {
7529    // Codec=Sse (Serialization based), see doc to use other codecs
7530    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7531        <crate::model::FetchPaymentProposedFeesResponse>::sse_encode(self.response, serializer);
7532    }
7533}
7534
7535impl SseEncode for crate::bindings::AesSuccessActionData {
7536    // Codec=Sse (Serialization based), see doc to use other codecs
7537    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7538        <String>::sse_encode(self.description, serializer);
7539        <String>::sse_encode(self.ciphertext, serializer);
7540        <String>::sse_encode(self.iv, serializer);
7541    }
7542}
7543
7544impl SseEncode for crate::bindings::AesSuccessActionDataDecrypted {
7545    // Codec=Sse (Serialization based), see doc to use other codecs
7546    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7547        <String>::sse_encode(self.description, serializer);
7548        <String>::sse_encode(self.plaintext, serializer);
7549    }
7550}
7551
7552impl SseEncode for crate::bindings::AesSuccessActionDataResult {
7553    // Codec=Sse (Serialization based), see doc to use other codecs
7554    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7555        match self {
7556            crate::bindings::AesSuccessActionDataResult::Decrypted { data } => {
7557                <i32>::sse_encode(0, serializer);
7558                <crate::bindings::AesSuccessActionDataDecrypted>::sse_encode(data, serializer);
7559            }
7560            crate::bindings::AesSuccessActionDataResult::ErrorStatus { reason } => {
7561                <i32>::sse_encode(1, serializer);
7562                <String>::sse_encode(reason, serializer);
7563            }
7564            _ => {
7565                unimplemented!("");
7566            }
7567        }
7568    }
7569}
7570
7571impl SseEncode for crate::bindings::Amount {
7572    // Codec=Sse (Serialization based), see doc to use other codecs
7573    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7574        match self {
7575            crate::bindings::Amount::Bitcoin { amount_msat } => {
7576                <i32>::sse_encode(0, serializer);
7577                <u64>::sse_encode(amount_msat, serializer);
7578            }
7579            crate::bindings::Amount::Currency {
7580                iso4217_code,
7581                fractional_amount,
7582            } => {
7583                <i32>::sse_encode(1, serializer);
7584                <String>::sse_encode(iso4217_code, serializer);
7585                <u64>::sse_encode(fractional_amount, serializer);
7586            }
7587            _ => {
7588                unimplemented!("");
7589            }
7590        }
7591    }
7592}
7593
7594impl SseEncode for crate::model::AssetBalance {
7595    // Codec=Sse (Serialization based), see doc to use other codecs
7596    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7597        <String>::sse_encode(self.asset_id, serializer);
7598        <u64>::sse_encode(self.balance_sat, serializer);
7599        <Option<String>>::sse_encode(self.name, serializer);
7600        <Option<String>>::sse_encode(self.ticker, serializer);
7601        <Option<f64>>::sse_encode(self.balance, serializer);
7602    }
7603}
7604
7605impl SseEncode for crate::model::AssetInfo {
7606    // Codec=Sse (Serialization based), see doc to use other codecs
7607    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7608        <String>::sse_encode(self.name, serializer);
7609        <String>::sse_encode(self.ticker, serializer);
7610        <f64>::sse_encode(self.amount, serializer);
7611        <Option<f64>>::sse_encode(self.fees, serializer);
7612    }
7613}
7614
7615impl SseEncode for crate::model::AssetMetadata {
7616    // Codec=Sse (Serialization based), see doc to use other codecs
7617    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7618        <String>::sse_encode(self.asset_id, serializer);
7619        <String>::sse_encode(self.name, serializer);
7620        <String>::sse_encode(self.ticker, serializer);
7621        <u8>::sse_encode(self.precision, serializer);
7622        <Option<String>>::sse_encode(self.fiat_id, serializer);
7623    }
7624}
7625
7626impl SseEncode for crate::model::BackupRequest {
7627    // Codec=Sse (Serialization based), see doc to use other codecs
7628    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7629        <Option<String>>::sse_encode(self.backup_path, serializer);
7630    }
7631}
7632
7633impl SseEncode for crate::bindings::BindingEventListener {
7634    // Codec=Sse (Serialization based), see doc to use other codecs
7635    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7636        <StreamSink<crate::model::SdkEvent,flutter_rust_bridge::for_generated::DcoCodec>>::sse_encode(self.stream, serializer);
7637    }
7638}
7639
7640impl SseEncode for crate::bindings::BitcoinAddressData {
7641    // Codec=Sse (Serialization based), see doc to use other codecs
7642    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7643        <String>::sse_encode(self.address, serializer);
7644        <crate::bindings::Network>::sse_encode(self.network, serializer);
7645        <Option<u64>>::sse_encode(self.amount_sat, serializer);
7646        <Option<String>>::sse_encode(self.label, serializer);
7647        <Option<String>>::sse_encode(self.message, serializer);
7648    }
7649}
7650
7651impl SseEncode for crate::model::BlockchainExplorer {
7652    // Codec=Sse (Serialization based), see doc to use other codecs
7653    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7654        match self {
7655            crate::model::BlockchainExplorer::Electrum { url } => {
7656                <i32>::sse_encode(0, serializer);
7657                <String>::sse_encode(url, serializer);
7658            }
7659            crate::model::BlockchainExplorer::Esplora {
7660                url,
7661                use_waterfalls,
7662            } => {
7663                <i32>::sse_encode(1, serializer);
7664                <String>::sse_encode(url, serializer);
7665                <bool>::sse_encode(use_waterfalls, serializer);
7666            }
7667            _ => {
7668                unimplemented!("");
7669            }
7670        }
7671    }
7672}
7673
7674impl SseEncode for crate::model::BlockchainInfo {
7675    // Codec=Sse (Serialization based), see doc to use other codecs
7676    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7677        <u32>::sse_encode(self.liquid_tip, serializer);
7678        <u32>::sse_encode(self.bitcoin_tip, serializer);
7679    }
7680}
7681
7682impl SseEncode for bool {
7683    // Codec=Sse (Serialization based), see doc to use other codecs
7684    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7685        serializer.cursor.write_u8(self as _).unwrap();
7686    }
7687}
7688
7689impl SseEncode for crate::model::BuyBitcoinProvider {
7690    // Codec=Sse (Serialization based), see doc to use other codecs
7691    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7692        <i32>::sse_encode(
7693            match self {
7694                crate::model::BuyBitcoinProvider::Moonpay => 0,
7695                _ => {
7696                    unimplemented!("");
7697                }
7698            },
7699            serializer,
7700        );
7701    }
7702}
7703
7704impl SseEncode for crate::model::BuyBitcoinRequest {
7705    // Codec=Sse (Serialization based), see doc to use other codecs
7706    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7707        <crate::model::PrepareBuyBitcoinResponse>::sse_encode(self.prepare_response, serializer);
7708        <Option<String>>::sse_encode(self.redirect_url, serializer);
7709    }
7710}
7711
7712impl SseEncode for crate::model::CheckMessageRequest {
7713    // Codec=Sse (Serialization based), see doc to use other codecs
7714    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7715        <String>::sse_encode(self.message, serializer);
7716        <String>::sse_encode(self.pubkey, serializer);
7717        <String>::sse_encode(self.signature, serializer);
7718    }
7719}
7720
7721impl SseEncode for crate::model::CheckMessageResponse {
7722    // Codec=Sse (Serialization based), see doc to use other codecs
7723    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7724        <bool>::sse_encode(self.is_valid, serializer);
7725    }
7726}
7727
7728impl SseEncode for crate::model::Config {
7729    // Codec=Sse (Serialization based), see doc to use other codecs
7730    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7731        <crate::model::BlockchainExplorer>::sse_encode(self.liquid_explorer, serializer);
7732        <crate::model::BlockchainExplorer>::sse_encode(self.bitcoin_explorer, serializer);
7733        <String>::sse_encode(self.working_dir, serializer);
7734        <Option<String>>::sse_encode(self.cache_dir, serializer);
7735        <crate::model::LiquidNetwork>::sse_encode(self.network, serializer);
7736        <u64>::sse_encode(self.payment_timeout_sec, serializer);
7737        <Option<String>>::sse_encode(self.sync_service_url, serializer);
7738        <Option<u64>>::sse_encode(self.zero_conf_max_amount_sat, serializer);
7739        <Option<String>>::sse_encode(self.breez_api_key, serializer);
7740        <Option<Vec<crate::bindings::ExternalInputParser>>>::sse_encode(
7741            self.external_input_parsers,
7742            serializer,
7743        );
7744        <bool>::sse_encode(self.use_default_external_input_parsers, serializer);
7745        <Option<u32>>::sse_encode(self.onchain_fee_rate_leeway_sat_per_vbyte, serializer);
7746        <Option<Vec<crate::model::AssetMetadata>>>::sse_encode(self.asset_metadata, serializer);
7747        <Option<String>>::sse_encode(self.sideswap_api_key, serializer);
7748    }
7749}
7750
7751impl SseEncode for crate::model::ConnectRequest {
7752    // Codec=Sse (Serialization based), see doc to use other codecs
7753    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7754        <crate::model::Config>::sse_encode(self.config, serializer);
7755        <Option<String>>::sse_encode(self.mnemonic, serializer);
7756        <Option<String>>::sse_encode(self.passphrase, serializer);
7757        <Option<Vec<u8>>>::sse_encode(self.seed, serializer);
7758    }
7759}
7760
7761impl SseEncode for crate::model::CreateBolt12InvoiceRequest {
7762    // Codec=Sse (Serialization based), see doc to use other codecs
7763    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7764        <String>::sse_encode(self.offer, serializer);
7765        <String>::sse_encode(self.invoice_request, serializer);
7766    }
7767}
7768
7769impl SseEncode for crate::model::CreateBolt12InvoiceResponse {
7770    // Codec=Sse (Serialization based), see doc to use other codecs
7771    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7772        <String>::sse_encode(self.invoice, serializer);
7773    }
7774}
7775
7776impl SseEncode for crate::bindings::CurrencyInfo {
7777    // Codec=Sse (Serialization based), see doc to use other codecs
7778    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7779        <String>::sse_encode(self.name, serializer);
7780        <u32>::sse_encode(self.fraction_size, serializer);
7781        <Option<u32>>::sse_encode(self.spacing, serializer);
7782        <Option<crate::bindings::Symbol>>::sse_encode(self.symbol, serializer);
7783        <Option<crate::bindings::Symbol>>::sse_encode(self.uniq_symbol, serializer);
7784        <Vec<crate::bindings::LocalizedName>>::sse_encode(self.localized_name, serializer);
7785        <Vec<crate::bindings::LocaleOverrides>>::sse_encode(self.locale_overrides, serializer);
7786    }
7787}
7788
7789impl SseEncode for crate::bindings::ExternalInputParser {
7790    // Codec=Sse (Serialization based), see doc to use other codecs
7791    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7792        <String>::sse_encode(self.provider_id, serializer);
7793        <String>::sse_encode(self.input_regex, serializer);
7794        <String>::sse_encode(self.parser_url, serializer);
7795    }
7796}
7797
7798impl SseEncode for f64 {
7799    // Codec=Sse (Serialization based), see doc to use other codecs
7800    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7801        serializer.cursor.write_f64::<NativeEndian>(self).unwrap();
7802    }
7803}
7804
7805impl SseEncode for crate::model::FetchPaymentProposedFeesRequest {
7806    // Codec=Sse (Serialization based), see doc to use other codecs
7807    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7808        <String>::sse_encode(self.swap_id, serializer);
7809    }
7810}
7811
7812impl SseEncode for crate::model::FetchPaymentProposedFeesResponse {
7813    // Codec=Sse (Serialization based), see doc to use other codecs
7814    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7815        <String>::sse_encode(self.swap_id, serializer);
7816        <u64>::sse_encode(self.fees_sat, serializer);
7817        <u64>::sse_encode(self.payer_amount_sat, serializer);
7818        <u64>::sse_encode(self.receiver_amount_sat, serializer);
7819    }
7820}
7821
7822impl SseEncode for crate::bindings::FiatCurrency {
7823    // Codec=Sse (Serialization based), see doc to use other codecs
7824    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7825        <String>::sse_encode(self.id, serializer);
7826        <crate::bindings::CurrencyInfo>::sse_encode(self.info, serializer);
7827    }
7828}
7829
7830impl SseEncode for crate::model::GetInfoResponse {
7831    // Codec=Sse (Serialization based), see doc to use other codecs
7832    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7833        <crate::model::WalletInfo>::sse_encode(self.wallet_info, serializer);
7834        <crate::model::BlockchainInfo>::sse_encode(self.blockchain_info, serializer);
7835    }
7836}
7837
7838impl SseEncode for crate::model::GetPaymentRequest {
7839    // Codec=Sse (Serialization based), see doc to use other codecs
7840    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7841        match self {
7842            crate::model::GetPaymentRequest::PaymentHash { payment_hash } => {
7843                <i32>::sse_encode(0, serializer);
7844                <String>::sse_encode(payment_hash, serializer);
7845            }
7846            crate::model::GetPaymentRequest::SwapId { swap_id } => {
7847                <i32>::sse_encode(1, serializer);
7848                <String>::sse_encode(swap_id, serializer);
7849            }
7850            _ => {
7851                unimplemented!("");
7852            }
7853        }
7854    }
7855}
7856
7857impl SseEncode for i32 {
7858    // Codec=Sse (Serialization based), see doc to use other codecs
7859    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7860        serializer.cursor.write_i32::<NativeEndian>(self).unwrap();
7861    }
7862}
7863
7864impl SseEncode for i64 {
7865    // Codec=Sse (Serialization based), see doc to use other codecs
7866    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7867        serializer.cursor.write_i64::<NativeEndian>(self).unwrap();
7868    }
7869}
7870
7871impl SseEncode for crate::bindings::InputType {
7872    // Codec=Sse (Serialization based), see doc to use other codecs
7873    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7874        match self {
7875            crate::bindings::InputType::BitcoinAddress { address } => {
7876                <i32>::sse_encode(0, serializer);
7877                <crate::bindings::BitcoinAddressData>::sse_encode(address, serializer);
7878            }
7879            crate::bindings::InputType::LiquidAddress { address } => {
7880                <i32>::sse_encode(1, serializer);
7881                <crate::bindings::LiquidAddressData>::sse_encode(address, serializer);
7882            }
7883            crate::bindings::InputType::Bolt11 { invoice } => {
7884                <i32>::sse_encode(2, serializer);
7885                <crate::bindings::LNInvoice>::sse_encode(invoice, serializer);
7886            }
7887            crate::bindings::InputType::Bolt12Offer {
7888                offer,
7889                bip353_address,
7890            } => {
7891                <i32>::sse_encode(3, serializer);
7892                <crate::bindings::LNOffer>::sse_encode(offer, serializer);
7893                <Option<String>>::sse_encode(bip353_address, serializer);
7894            }
7895            crate::bindings::InputType::NodeId { node_id } => {
7896                <i32>::sse_encode(4, serializer);
7897                <String>::sse_encode(node_id, serializer);
7898            }
7899            crate::bindings::InputType::Url { url } => {
7900                <i32>::sse_encode(5, serializer);
7901                <String>::sse_encode(url, serializer);
7902            }
7903            crate::bindings::InputType::LnUrlPay {
7904                data,
7905                bip353_address,
7906            } => {
7907                <i32>::sse_encode(6, serializer);
7908                <crate::bindings::LnUrlPayRequestData>::sse_encode(data, serializer);
7909                <Option<String>>::sse_encode(bip353_address, serializer);
7910            }
7911            crate::bindings::InputType::LnUrlWithdraw { data } => {
7912                <i32>::sse_encode(7, serializer);
7913                <crate::bindings::LnUrlWithdrawRequestData>::sse_encode(data, serializer);
7914            }
7915            crate::bindings::InputType::LnUrlAuth { data } => {
7916                <i32>::sse_encode(8, serializer);
7917                <crate::bindings::LnUrlAuthRequestData>::sse_encode(data, serializer);
7918            }
7919            crate::bindings::InputType::LnUrlError { data } => {
7920                <i32>::sse_encode(9, serializer);
7921                <crate::bindings::LnUrlErrorData>::sse_encode(data, serializer);
7922            }
7923            _ => {
7924                unimplemented!("");
7925            }
7926        }
7927    }
7928}
7929
7930impl SseEncode for crate::model::LightningPaymentLimitsResponse {
7931    // Codec=Sse (Serialization based), see doc to use other codecs
7932    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7933        <crate::model::Limits>::sse_encode(self.send, serializer);
7934        <crate::model::Limits>::sse_encode(self.receive, serializer);
7935    }
7936}
7937
7938impl SseEncode for crate::model::Limits {
7939    // Codec=Sse (Serialization based), see doc to use other codecs
7940    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7941        <u64>::sse_encode(self.min_sat, serializer);
7942        <u64>::sse_encode(self.max_sat, serializer);
7943        <u64>::sse_encode(self.max_zero_conf_sat, serializer);
7944    }
7945}
7946
7947impl SseEncode for crate::bindings::LiquidAddressData {
7948    // Codec=Sse (Serialization based), see doc to use other codecs
7949    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7950        <String>::sse_encode(self.address, serializer);
7951        <crate::bindings::Network>::sse_encode(self.network, serializer);
7952        <Option<String>>::sse_encode(self.asset_id, serializer);
7953        <Option<f64>>::sse_encode(self.amount, serializer);
7954        <Option<u64>>::sse_encode(self.amount_sat, serializer);
7955        <Option<String>>::sse_encode(self.label, serializer);
7956        <Option<String>>::sse_encode(self.message, serializer);
7957    }
7958}
7959
7960impl SseEncode for crate::model::LiquidNetwork {
7961    // Codec=Sse (Serialization based), see doc to use other codecs
7962    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7963        <i32>::sse_encode(
7964            match self {
7965                crate::model::LiquidNetwork::Mainnet => 0,
7966                crate::model::LiquidNetwork::Testnet => 1,
7967                crate::model::LiquidNetwork::Regtest => 2,
7968                _ => {
7969                    unimplemented!("");
7970                }
7971            },
7972            serializer,
7973        );
7974    }
7975}
7976
7977impl SseEncode for Vec<String> {
7978    // Codec=Sse (Serialization based), see doc to use other codecs
7979    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7980        <i32>::sse_encode(self.len() as _, serializer);
7981        for item in self {
7982            <String>::sse_encode(item, serializer);
7983        }
7984    }
7985}
7986
7987impl SseEncode for Vec<crate::model::AssetBalance> {
7988    // Codec=Sse (Serialization based), see doc to use other codecs
7989    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7990        <i32>::sse_encode(self.len() as _, serializer);
7991        for item in self {
7992            <crate::model::AssetBalance>::sse_encode(item, serializer);
7993        }
7994    }
7995}
7996
7997impl SseEncode for Vec<crate::model::AssetMetadata> {
7998    // Codec=Sse (Serialization based), see doc to use other codecs
7999    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8000        <i32>::sse_encode(self.len() as _, serializer);
8001        for item in self {
8002            <crate::model::AssetMetadata>::sse_encode(item, serializer);
8003        }
8004    }
8005}
8006
8007impl SseEncode for Vec<crate::bindings::ExternalInputParser> {
8008    // Codec=Sse (Serialization based), see doc to use other codecs
8009    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8010        <i32>::sse_encode(self.len() as _, serializer);
8011        for item in self {
8012            <crate::bindings::ExternalInputParser>::sse_encode(item, serializer);
8013        }
8014    }
8015}
8016
8017impl SseEncode for Vec<crate::bindings::FiatCurrency> {
8018    // Codec=Sse (Serialization based), see doc to use other codecs
8019    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8020        <i32>::sse_encode(self.len() as _, serializer);
8021        for item in self {
8022            <crate::bindings::FiatCurrency>::sse_encode(item, serializer);
8023        }
8024    }
8025}
8026
8027impl SseEncode for Vec<crate::bindings::LnOfferBlindedPath> {
8028    // Codec=Sse (Serialization based), see doc to use other codecs
8029    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8030        <i32>::sse_encode(self.len() as _, serializer);
8031        for item in self {
8032            <crate::bindings::LnOfferBlindedPath>::sse_encode(item, serializer);
8033        }
8034    }
8035}
8036
8037impl SseEncode for Vec<crate::bindings::LocaleOverrides> {
8038    // Codec=Sse (Serialization based), see doc to use other codecs
8039    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8040        <i32>::sse_encode(self.len() as _, serializer);
8041        for item in self {
8042            <crate::bindings::LocaleOverrides>::sse_encode(item, serializer);
8043        }
8044    }
8045}
8046
8047impl SseEncode for Vec<crate::bindings::LocalizedName> {
8048    // Codec=Sse (Serialization based), see doc to use other codecs
8049    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8050        <i32>::sse_encode(self.len() as _, serializer);
8051        for item in self {
8052            <crate::bindings::LocalizedName>::sse_encode(item, serializer);
8053        }
8054    }
8055}
8056
8057impl SseEncode for Vec<crate::model::Payment> {
8058    // Codec=Sse (Serialization based), see doc to use other codecs
8059    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8060        <i32>::sse_encode(self.len() as _, serializer);
8061        for item in self {
8062            <crate::model::Payment>::sse_encode(item, serializer);
8063        }
8064    }
8065}
8066
8067impl SseEncode for crate::model::ListPaymentDetails {
8068    // Codec=Sse (Serialization based), see doc to use other codecs
8069    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8070        match self {
8071            crate::model::ListPaymentDetails::Liquid {
8072                asset_id,
8073                destination,
8074            } => {
8075                <i32>::sse_encode(0, serializer);
8076                <Option<String>>::sse_encode(asset_id, serializer);
8077                <Option<String>>::sse_encode(destination, serializer);
8078            }
8079            crate::model::ListPaymentDetails::Bitcoin { address } => {
8080                <i32>::sse_encode(1, serializer);
8081                <Option<String>>::sse_encode(address, serializer);
8082            }
8083            _ => {
8084                unimplemented!("");
8085            }
8086        }
8087    }
8088}
8089
8090impl SseEncode for Vec<crate::model::PaymentState> {
8091    // Codec=Sse (Serialization based), see doc to use other codecs
8092    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8093        <i32>::sse_encode(self.len() as _, serializer);
8094        for item in self {
8095            <crate::model::PaymentState>::sse_encode(item, serializer);
8096        }
8097    }
8098}
8099
8100impl SseEncode for Vec<crate::model::PaymentType> {
8101    // Codec=Sse (Serialization based), see doc to use other codecs
8102    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8103        <i32>::sse_encode(self.len() as _, serializer);
8104        for item in self {
8105            <crate::model::PaymentType>::sse_encode(item, serializer);
8106        }
8107    }
8108}
8109
8110impl SseEncode for crate::model::ListPaymentsRequest {
8111    // Codec=Sse (Serialization based), see doc to use other codecs
8112    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8113        <Option<Vec<crate::model::PaymentType>>>::sse_encode(self.filters, serializer);
8114        <Option<Vec<crate::model::PaymentState>>>::sse_encode(self.states, serializer);
8115        <Option<i64>>::sse_encode(self.from_timestamp, serializer);
8116        <Option<i64>>::sse_encode(self.to_timestamp, serializer);
8117        <Option<u32>>::sse_encode(self.offset, serializer);
8118        <Option<u32>>::sse_encode(self.limit, serializer);
8119        <Option<crate::model::ListPaymentDetails>>::sse_encode(self.details, serializer);
8120        <Option<bool>>::sse_encode(self.sort_ascending, serializer);
8121    }
8122}
8123
8124impl SseEncode for Vec<u8> {
8125    // Codec=Sse (Serialization based), see doc to use other codecs
8126    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8127        <i32>::sse_encode(self.len() as _, serializer);
8128        for item in self {
8129            <u8>::sse_encode(item, serializer);
8130        }
8131    }
8132}
8133
8134impl SseEncode for Vec<crate::bindings::Rate> {
8135    // Codec=Sse (Serialization based), see doc to use other codecs
8136    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8137        <i32>::sse_encode(self.len() as _, serializer);
8138        for item in self {
8139            <crate::bindings::Rate>::sse_encode(item, serializer);
8140        }
8141    }
8142}
8143
8144impl SseEncode for Vec<crate::model::RefundableSwap> {
8145    // Codec=Sse (Serialization based), see doc to use other codecs
8146    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8147        <i32>::sse_encode(self.len() as _, serializer);
8148        for item in self {
8149            <crate::model::RefundableSwap>::sse_encode(item, serializer);
8150        }
8151    }
8152}
8153
8154impl SseEncode for Vec<crate::bindings::RouteHint> {
8155    // Codec=Sse (Serialization based), see doc to use other codecs
8156    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8157        <i32>::sse_encode(self.len() as _, serializer);
8158        for item in self {
8159            <crate::bindings::RouteHint>::sse_encode(item, serializer);
8160        }
8161    }
8162}
8163
8164impl SseEncode for Vec<crate::bindings::RouteHintHop> {
8165    // Codec=Sse (Serialization based), see doc to use other codecs
8166    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8167        <i32>::sse_encode(self.len() as _, serializer);
8168        for item in self {
8169            <crate::bindings::RouteHintHop>::sse_encode(item, serializer);
8170        }
8171    }
8172}
8173
8174impl SseEncode for crate::bindings::LNInvoice {
8175    // Codec=Sse (Serialization based), see doc to use other codecs
8176    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8177        <String>::sse_encode(self.bolt11, serializer);
8178        <crate::bindings::Network>::sse_encode(self.network, serializer);
8179        <String>::sse_encode(self.payee_pubkey, serializer);
8180        <String>::sse_encode(self.payment_hash, serializer);
8181        <Option<String>>::sse_encode(self.description, serializer);
8182        <Option<String>>::sse_encode(self.description_hash, serializer);
8183        <Option<u64>>::sse_encode(self.amount_msat, serializer);
8184        <u64>::sse_encode(self.timestamp, serializer);
8185        <u64>::sse_encode(self.expiry, serializer);
8186        <Vec<crate::bindings::RouteHint>>::sse_encode(self.routing_hints, serializer);
8187        <Vec<u8>>::sse_encode(self.payment_secret, serializer);
8188        <u64>::sse_encode(self.min_final_cltv_expiry_delta, serializer);
8189    }
8190}
8191
8192impl SseEncode for crate::bindings::LNOffer {
8193    // Codec=Sse (Serialization based), see doc to use other codecs
8194    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8195        <String>::sse_encode(self.offer, serializer);
8196        <Vec<String>>::sse_encode(self.chains, serializer);
8197        <Option<crate::bindings::Amount>>::sse_encode(self.min_amount, serializer);
8198        <Option<String>>::sse_encode(self.description, serializer);
8199        <Option<u64>>::sse_encode(self.absolute_expiry, serializer);
8200        <Option<String>>::sse_encode(self.issuer, serializer);
8201        <Option<String>>::sse_encode(self.signing_pubkey, serializer);
8202        <Vec<crate::bindings::LnOfferBlindedPath>>::sse_encode(self.paths, serializer);
8203    }
8204}
8205
8206impl SseEncode for crate::bindings::LnOfferBlindedPath {
8207    // Codec=Sse (Serialization based), see doc to use other codecs
8208    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8209        <Vec<String>>::sse_encode(self.blinded_hops, serializer);
8210    }
8211}
8212
8213impl SseEncode for crate::bindings::duplicates::LnUrlAuthError {
8214    // Codec=Sse (Serialization based), see doc to use other codecs
8215    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8216        match self {
8217            crate::bindings::duplicates::LnUrlAuthError::Generic { err } => {
8218                <i32>::sse_encode(0, serializer);
8219                <String>::sse_encode(err, serializer);
8220            }
8221            crate::bindings::duplicates::LnUrlAuthError::InvalidUri { err } => {
8222                <i32>::sse_encode(1, serializer);
8223                <String>::sse_encode(err, serializer);
8224            }
8225            crate::bindings::duplicates::LnUrlAuthError::ServiceConnectivity { err } => {
8226                <i32>::sse_encode(2, serializer);
8227                <String>::sse_encode(err, serializer);
8228            }
8229            _ => {
8230                unimplemented!("");
8231            }
8232        }
8233    }
8234}
8235
8236impl SseEncode for crate::bindings::LnUrlAuthRequestData {
8237    // Codec=Sse (Serialization based), see doc to use other codecs
8238    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8239        <String>::sse_encode(self.k1, serializer);
8240        <Option<String>>::sse_encode(self.action, serializer);
8241        <String>::sse_encode(self.domain, serializer);
8242        <String>::sse_encode(self.url, serializer);
8243    }
8244}
8245
8246impl SseEncode for crate::bindings::duplicates::LnUrlCallbackStatus {
8247    // Codec=Sse (Serialization based), see doc to use other codecs
8248    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8249        match self {
8250            crate::bindings::duplicates::LnUrlCallbackStatus::Ok => {
8251                <i32>::sse_encode(0, serializer);
8252            }
8253            crate::bindings::duplicates::LnUrlCallbackStatus::ErrorStatus { data } => {
8254                <i32>::sse_encode(1, serializer);
8255                <crate::bindings::LnUrlErrorData>::sse_encode(data, serializer);
8256            }
8257            _ => {
8258                unimplemented!("");
8259            }
8260        }
8261    }
8262}
8263
8264impl SseEncode for crate::bindings::LnUrlErrorData {
8265    // Codec=Sse (Serialization based), see doc to use other codecs
8266    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8267        <String>::sse_encode(self.reason, serializer);
8268    }
8269}
8270
8271impl SseEncode for crate::model::LnUrlInfo {
8272    // Codec=Sse (Serialization based), see doc to use other codecs
8273    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8274        <Option<String>>::sse_encode(self.ln_address, serializer);
8275        <Option<String>>::sse_encode(self.lnurl_pay_comment, serializer);
8276        <Option<String>>::sse_encode(self.lnurl_pay_domain, serializer);
8277        <Option<String>>::sse_encode(self.lnurl_pay_metadata, serializer);
8278        <Option<crate::bindings::SuccessActionProcessed>>::sse_encode(
8279            self.lnurl_pay_success_action,
8280            serializer,
8281        );
8282        <Option<crate::bindings::SuccessAction>>::sse_encode(
8283            self.lnurl_pay_unprocessed_success_action,
8284            serializer,
8285        );
8286        <Option<String>>::sse_encode(self.lnurl_withdraw_endpoint, serializer);
8287    }
8288}
8289
8290impl SseEncode for crate::bindings::duplicates::LnUrlPayError {
8291    // Codec=Sse (Serialization based), see doc to use other codecs
8292    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8293        match self {
8294            crate::bindings::duplicates::LnUrlPayError::AlreadyPaid => {
8295                <i32>::sse_encode(0, serializer);
8296            }
8297            crate::bindings::duplicates::LnUrlPayError::Generic { err } => {
8298                <i32>::sse_encode(1, serializer);
8299                <String>::sse_encode(err, serializer);
8300            }
8301            crate::bindings::duplicates::LnUrlPayError::InsufficientBalance { err } => {
8302                <i32>::sse_encode(2, serializer);
8303                <String>::sse_encode(err, serializer);
8304            }
8305            crate::bindings::duplicates::LnUrlPayError::InvalidAmount { err } => {
8306                <i32>::sse_encode(3, serializer);
8307                <String>::sse_encode(err, serializer);
8308            }
8309            crate::bindings::duplicates::LnUrlPayError::InvalidInvoice { err } => {
8310                <i32>::sse_encode(4, serializer);
8311                <String>::sse_encode(err, serializer);
8312            }
8313            crate::bindings::duplicates::LnUrlPayError::InvalidNetwork { err } => {
8314                <i32>::sse_encode(5, serializer);
8315                <String>::sse_encode(err, serializer);
8316            }
8317            crate::bindings::duplicates::LnUrlPayError::InvalidUri { err } => {
8318                <i32>::sse_encode(6, serializer);
8319                <String>::sse_encode(err, serializer);
8320            }
8321            crate::bindings::duplicates::LnUrlPayError::InvoiceExpired { err } => {
8322                <i32>::sse_encode(7, serializer);
8323                <String>::sse_encode(err, serializer);
8324            }
8325            crate::bindings::duplicates::LnUrlPayError::PaymentFailed { err } => {
8326                <i32>::sse_encode(8, serializer);
8327                <String>::sse_encode(err, serializer);
8328            }
8329            crate::bindings::duplicates::LnUrlPayError::PaymentTimeout { err } => {
8330                <i32>::sse_encode(9, serializer);
8331                <String>::sse_encode(err, serializer);
8332            }
8333            crate::bindings::duplicates::LnUrlPayError::RouteNotFound { err } => {
8334                <i32>::sse_encode(10, serializer);
8335                <String>::sse_encode(err, serializer);
8336            }
8337            crate::bindings::duplicates::LnUrlPayError::RouteTooExpensive { err } => {
8338                <i32>::sse_encode(11, serializer);
8339                <String>::sse_encode(err, serializer);
8340            }
8341            crate::bindings::duplicates::LnUrlPayError::ServiceConnectivity { err } => {
8342                <i32>::sse_encode(12, serializer);
8343                <String>::sse_encode(err, serializer);
8344            }
8345            _ => {
8346                unimplemented!("");
8347            }
8348        }
8349    }
8350}
8351
8352impl SseEncode for crate::bindings::LnUrlPayErrorData {
8353    // Codec=Sse (Serialization based), see doc to use other codecs
8354    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8355        <String>::sse_encode(self.payment_hash, serializer);
8356        <String>::sse_encode(self.reason, serializer);
8357    }
8358}
8359
8360impl SseEncode for crate::model::LnUrlPayRequest {
8361    // Codec=Sse (Serialization based), see doc to use other codecs
8362    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8363        <crate::model::PrepareLnUrlPayResponse>::sse_encode(self.prepare_response, serializer);
8364    }
8365}
8366
8367impl SseEncode for crate::bindings::LnUrlPayRequestData {
8368    // Codec=Sse (Serialization based), see doc to use other codecs
8369    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8370        <String>::sse_encode(self.callback, serializer);
8371        <u64>::sse_encode(self.min_sendable, serializer);
8372        <u64>::sse_encode(self.max_sendable, serializer);
8373        <String>::sse_encode(self.metadata_str, serializer);
8374        <u16>::sse_encode(self.comment_allowed, serializer);
8375        <String>::sse_encode(self.domain, serializer);
8376        <bool>::sse_encode(self.allows_nostr, serializer);
8377        <Option<String>>::sse_encode(self.nostr_pubkey, serializer);
8378        <Option<String>>::sse_encode(self.ln_address, serializer);
8379    }
8380}
8381
8382impl SseEncode for crate::model::LnUrlPayResult {
8383    // Codec=Sse (Serialization based), see doc to use other codecs
8384    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8385        match self {
8386            crate::model::LnUrlPayResult::EndpointSuccess { data } => {
8387                <i32>::sse_encode(0, serializer);
8388                <crate::model::LnUrlPaySuccessData>::sse_encode(data, serializer);
8389            }
8390            crate::model::LnUrlPayResult::EndpointError { data } => {
8391                <i32>::sse_encode(1, serializer);
8392                <crate::bindings::LnUrlErrorData>::sse_encode(data, serializer);
8393            }
8394            crate::model::LnUrlPayResult::PayError { data } => {
8395                <i32>::sse_encode(2, serializer);
8396                <crate::bindings::LnUrlPayErrorData>::sse_encode(data, serializer);
8397            }
8398            _ => {
8399                unimplemented!("");
8400            }
8401        }
8402    }
8403}
8404
8405impl SseEncode for crate::model::LnUrlPaySuccessData {
8406    // Codec=Sse (Serialization based), see doc to use other codecs
8407    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8408        <crate::model::Payment>::sse_encode(self.payment, serializer);
8409        <Option<crate::bindings::SuccessActionProcessed>>::sse_encode(
8410            self.success_action,
8411            serializer,
8412        );
8413    }
8414}
8415
8416impl SseEncode for crate::bindings::duplicates::LnUrlWithdrawError {
8417    // Codec=Sse (Serialization based), see doc to use other codecs
8418    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8419        match self {
8420            crate::bindings::duplicates::LnUrlWithdrawError::Generic { err } => {
8421                <i32>::sse_encode(0, serializer);
8422                <String>::sse_encode(err, serializer);
8423            }
8424            crate::bindings::duplicates::LnUrlWithdrawError::InvalidAmount { err } => {
8425                <i32>::sse_encode(1, serializer);
8426                <String>::sse_encode(err, serializer);
8427            }
8428            crate::bindings::duplicates::LnUrlWithdrawError::InvalidInvoice { err } => {
8429                <i32>::sse_encode(2, serializer);
8430                <String>::sse_encode(err, serializer);
8431            }
8432            crate::bindings::duplicates::LnUrlWithdrawError::InvalidUri { err } => {
8433                <i32>::sse_encode(3, serializer);
8434                <String>::sse_encode(err, serializer);
8435            }
8436            crate::bindings::duplicates::LnUrlWithdrawError::InvoiceNoRoutingHints { err } => {
8437                <i32>::sse_encode(4, serializer);
8438                <String>::sse_encode(err, serializer);
8439            }
8440            crate::bindings::duplicates::LnUrlWithdrawError::ServiceConnectivity { err } => {
8441                <i32>::sse_encode(5, serializer);
8442                <String>::sse_encode(err, serializer);
8443            }
8444            _ => {
8445                unimplemented!("");
8446            }
8447        }
8448    }
8449}
8450
8451impl SseEncode for crate::bindings::LnUrlWithdrawRequest {
8452    // Codec=Sse (Serialization based), see doc to use other codecs
8453    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8454        <crate::bindings::LnUrlWithdrawRequestData>::sse_encode(self.data, serializer);
8455        <u64>::sse_encode(self.amount_msat, serializer);
8456        <Option<String>>::sse_encode(self.description, serializer);
8457    }
8458}
8459
8460impl SseEncode for crate::bindings::LnUrlWithdrawRequestData {
8461    // Codec=Sse (Serialization based), see doc to use other codecs
8462    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8463        <String>::sse_encode(self.callback, serializer);
8464        <String>::sse_encode(self.k1, serializer);
8465        <String>::sse_encode(self.default_description, serializer);
8466        <u64>::sse_encode(self.min_withdrawable, serializer);
8467        <u64>::sse_encode(self.max_withdrawable, serializer);
8468    }
8469}
8470
8471impl SseEncode for crate::bindings::duplicates::LnUrlWithdrawResult {
8472    // Codec=Sse (Serialization based), see doc to use other codecs
8473    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8474        match self {
8475            crate::bindings::duplicates::LnUrlWithdrawResult::Ok { data } => {
8476                <i32>::sse_encode(0, serializer);
8477                <crate::bindings::duplicates::LnUrlWithdrawSuccessData>::sse_encode(
8478                    data, serializer,
8479                );
8480            }
8481            crate::bindings::duplicates::LnUrlWithdrawResult::Timeout { data } => {
8482                <i32>::sse_encode(1, serializer);
8483                <crate::bindings::duplicates::LnUrlWithdrawSuccessData>::sse_encode(
8484                    data, serializer,
8485                );
8486            }
8487            crate::bindings::duplicates::LnUrlWithdrawResult::ErrorStatus { data } => {
8488                <i32>::sse_encode(2, serializer);
8489                <crate::bindings::LnUrlErrorData>::sse_encode(data, serializer);
8490            }
8491            _ => {
8492                unimplemented!("");
8493            }
8494        }
8495    }
8496}
8497
8498impl SseEncode for crate::bindings::duplicates::LnUrlWithdrawSuccessData {
8499    // Codec=Sse (Serialization based), see doc to use other codecs
8500    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8501        <crate::bindings::LNInvoice>::sse_encode(self.invoice, serializer);
8502    }
8503}
8504
8505impl SseEncode for crate::bindings::LocaleOverrides {
8506    // Codec=Sse (Serialization based), see doc to use other codecs
8507    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8508        <String>::sse_encode(self.locale, serializer);
8509        <Option<u32>>::sse_encode(self.spacing, serializer);
8510        <crate::bindings::Symbol>::sse_encode(self.symbol, serializer);
8511    }
8512}
8513
8514impl SseEncode for crate::bindings::LocalizedName {
8515    // Codec=Sse (Serialization based), see doc to use other codecs
8516    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8517        <String>::sse_encode(self.locale, serializer);
8518        <String>::sse_encode(self.name, serializer);
8519    }
8520}
8521
8522impl SseEncode for crate::model::LogEntry {
8523    // Codec=Sse (Serialization based), see doc to use other codecs
8524    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8525        <String>::sse_encode(self.line, serializer);
8526        <String>::sse_encode(self.level, serializer);
8527    }
8528}
8529
8530impl SseEncode for crate::bindings::MessageSuccessActionData {
8531    // Codec=Sse (Serialization based), see doc to use other codecs
8532    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8533        <String>::sse_encode(self.message, serializer);
8534    }
8535}
8536
8537impl SseEncode for crate::bindings::Network {
8538    // Codec=Sse (Serialization based), see doc to use other codecs
8539    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8540        <i32>::sse_encode(
8541            match self {
8542                crate::bindings::Network::Bitcoin => 0,
8543                crate::bindings::Network::Testnet => 1,
8544                crate::bindings::Network::Signet => 2,
8545                crate::bindings::Network::Regtest => 3,
8546                _ => {
8547                    unimplemented!("");
8548                }
8549            },
8550            serializer,
8551        );
8552    }
8553}
8554
8555impl SseEncode for crate::model::OnchainPaymentLimitsResponse {
8556    // Codec=Sse (Serialization based), see doc to use other codecs
8557    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8558        <crate::model::Limits>::sse_encode(self.send, serializer);
8559        <crate::model::Limits>::sse_encode(self.receive, serializer);
8560    }
8561}
8562
8563impl SseEncode for Option<String> {
8564    // Codec=Sse (Serialization based), see doc to use other codecs
8565    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8566        <bool>::sse_encode(self.is_some(), serializer);
8567        if let Some(value) = self {
8568            <String>::sse_encode(value, serializer);
8569        }
8570    }
8571}
8572
8573impl SseEncode for Option<crate::bindings::Amount> {
8574    // Codec=Sse (Serialization based), see doc to use other codecs
8575    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8576        <bool>::sse_encode(self.is_some(), serializer);
8577        if let Some(value) = self {
8578            <crate::bindings::Amount>::sse_encode(value, serializer);
8579        }
8580    }
8581}
8582
8583impl SseEncode for Option<crate::model::AssetInfo> {
8584    // Codec=Sse (Serialization based), see doc to use other codecs
8585    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8586        <bool>::sse_encode(self.is_some(), serializer);
8587        if let Some(value) = self {
8588            <crate::model::AssetInfo>::sse_encode(value, serializer);
8589        }
8590    }
8591}
8592
8593impl SseEncode for Option<bool> {
8594    // Codec=Sse (Serialization based), see doc to use other codecs
8595    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8596        <bool>::sse_encode(self.is_some(), serializer);
8597        if let Some(value) = self {
8598            <bool>::sse_encode(value, serializer);
8599        }
8600    }
8601}
8602
8603impl SseEncode for Option<f64> {
8604    // Codec=Sse (Serialization based), see doc to use other codecs
8605    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8606        <bool>::sse_encode(self.is_some(), serializer);
8607        if let Some(value) = self {
8608            <f64>::sse_encode(value, serializer);
8609        }
8610    }
8611}
8612
8613impl SseEncode for Option<i64> {
8614    // Codec=Sse (Serialization based), see doc to use other codecs
8615    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8616        <bool>::sse_encode(self.is_some(), serializer);
8617        if let Some(value) = self {
8618            <i64>::sse_encode(value, serializer);
8619        }
8620    }
8621}
8622
8623impl SseEncode for Option<crate::model::ListPaymentDetails> {
8624    // Codec=Sse (Serialization based), see doc to use other codecs
8625    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8626        <bool>::sse_encode(self.is_some(), serializer);
8627        if let Some(value) = self {
8628            <crate::model::ListPaymentDetails>::sse_encode(value, serializer);
8629        }
8630    }
8631}
8632
8633impl SseEncode for Option<crate::model::LnUrlInfo> {
8634    // Codec=Sse (Serialization based), see doc to use other codecs
8635    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8636        <bool>::sse_encode(self.is_some(), serializer);
8637        if let Some(value) = self {
8638            <crate::model::LnUrlInfo>::sse_encode(value, serializer);
8639        }
8640    }
8641}
8642
8643impl SseEncode for Option<crate::model::PayAmount> {
8644    // Codec=Sse (Serialization based), see doc to use other codecs
8645    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8646        <bool>::sse_encode(self.is_some(), serializer);
8647        if let Some(value) = self {
8648            <crate::model::PayAmount>::sse_encode(value, serializer);
8649        }
8650    }
8651}
8652
8653impl SseEncode for Option<crate::model::Payment> {
8654    // Codec=Sse (Serialization based), see doc to use other codecs
8655    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8656        <bool>::sse_encode(self.is_some(), serializer);
8657        if let Some(value) = self {
8658            <crate::model::Payment>::sse_encode(value, serializer);
8659        }
8660    }
8661}
8662
8663impl SseEncode for Option<crate::model::ReceiveAmount> {
8664    // Codec=Sse (Serialization based), see doc to use other codecs
8665    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8666        <bool>::sse_encode(self.is_some(), serializer);
8667        if let Some(value) = self {
8668            <crate::model::ReceiveAmount>::sse_encode(value, serializer);
8669        }
8670    }
8671}
8672
8673impl SseEncode for Option<crate::bindings::SuccessAction> {
8674    // Codec=Sse (Serialization based), see doc to use other codecs
8675    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8676        <bool>::sse_encode(self.is_some(), serializer);
8677        if let Some(value) = self {
8678            <crate::bindings::SuccessAction>::sse_encode(value, serializer);
8679        }
8680    }
8681}
8682
8683impl SseEncode for Option<crate::bindings::SuccessActionProcessed> {
8684    // Codec=Sse (Serialization based), see doc to use other codecs
8685    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8686        <bool>::sse_encode(self.is_some(), serializer);
8687        if let Some(value) = self {
8688            <crate::bindings::SuccessActionProcessed>::sse_encode(value, serializer);
8689        }
8690    }
8691}
8692
8693impl SseEncode for Option<crate::bindings::Symbol> {
8694    // Codec=Sse (Serialization based), see doc to use other codecs
8695    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8696        <bool>::sse_encode(self.is_some(), serializer);
8697        if let Some(value) = self {
8698            <crate::bindings::Symbol>::sse_encode(value, serializer);
8699        }
8700    }
8701}
8702
8703impl SseEncode for Option<u32> {
8704    // Codec=Sse (Serialization based), see doc to use other codecs
8705    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8706        <bool>::sse_encode(self.is_some(), serializer);
8707        if let Some(value) = self {
8708            <u32>::sse_encode(value, serializer);
8709        }
8710    }
8711}
8712
8713impl SseEncode for Option<u64> {
8714    // Codec=Sse (Serialization based), see doc to use other codecs
8715    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8716        <bool>::sse_encode(self.is_some(), serializer);
8717        if let Some(value) = self {
8718            <u64>::sse_encode(value, serializer);
8719        }
8720    }
8721}
8722
8723impl SseEncode for Option<Vec<crate::model::AssetMetadata>> {
8724    // Codec=Sse (Serialization based), see doc to use other codecs
8725    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8726        <bool>::sse_encode(self.is_some(), serializer);
8727        if let Some(value) = self {
8728            <Vec<crate::model::AssetMetadata>>::sse_encode(value, serializer);
8729        }
8730    }
8731}
8732
8733impl SseEncode for Option<Vec<crate::bindings::ExternalInputParser>> {
8734    // Codec=Sse (Serialization based), see doc to use other codecs
8735    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8736        <bool>::sse_encode(self.is_some(), serializer);
8737        if let Some(value) = self {
8738            <Vec<crate::bindings::ExternalInputParser>>::sse_encode(value, serializer);
8739        }
8740    }
8741}
8742
8743impl SseEncode for Option<Vec<crate::model::PaymentState>> {
8744    // Codec=Sse (Serialization based), see doc to use other codecs
8745    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8746        <bool>::sse_encode(self.is_some(), serializer);
8747        if let Some(value) = self {
8748            <Vec<crate::model::PaymentState>>::sse_encode(value, serializer);
8749        }
8750    }
8751}
8752
8753impl SseEncode for Option<Vec<crate::model::PaymentType>> {
8754    // Codec=Sse (Serialization based), see doc to use other codecs
8755    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8756        <bool>::sse_encode(self.is_some(), serializer);
8757        if let Some(value) = self {
8758            <Vec<crate::model::PaymentType>>::sse_encode(value, serializer);
8759        }
8760    }
8761}
8762
8763impl SseEncode for Option<Vec<u8>> {
8764    // Codec=Sse (Serialization based), see doc to use other codecs
8765    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8766        <bool>::sse_encode(self.is_some(), serializer);
8767        if let Some(value) = self {
8768            <Vec<u8>>::sse_encode(value, serializer);
8769        }
8770    }
8771}
8772
8773impl SseEncode for crate::model::PayAmount {
8774    // Codec=Sse (Serialization based), see doc to use other codecs
8775    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8776        match self {
8777            crate::model::PayAmount::Bitcoin {
8778                receiver_amount_sat,
8779            } => {
8780                <i32>::sse_encode(0, serializer);
8781                <u64>::sse_encode(receiver_amount_sat, serializer);
8782            }
8783            crate::model::PayAmount::Asset {
8784                asset_id,
8785                receiver_amount,
8786                estimate_asset_fees,
8787            } => {
8788                <i32>::sse_encode(1, serializer);
8789                <String>::sse_encode(asset_id, serializer);
8790                <f64>::sse_encode(receiver_amount, serializer);
8791                <Option<bool>>::sse_encode(estimate_asset_fees, serializer);
8792            }
8793            crate::model::PayAmount::Drain => {
8794                <i32>::sse_encode(2, serializer);
8795            }
8796            _ => {
8797                unimplemented!("");
8798            }
8799        }
8800    }
8801}
8802
8803impl SseEncode for crate::model::PayOnchainRequest {
8804    // Codec=Sse (Serialization based), see doc to use other codecs
8805    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8806        <String>::sse_encode(self.address, serializer);
8807        <crate::model::PreparePayOnchainResponse>::sse_encode(self.prepare_response, serializer);
8808    }
8809}
8810
8811impl SseEncode for crate::model::Payment {
8812    // Codec=Sse (Serialization based), see doc to use other codecs
8813    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8814        <Option<String>>::sse_encode(self.destination, serializer);
8815        <Option<String>>::sse_encode(self.tx_id, serializer);
8816        <Option<String>>::sse_encode(self.unblinding_data, serializer);
8817        <u32>::sse_encode(self.timestamp, serializer);
8818        <u64>::sse_encode(self.amount_sat, serializer);
8819        <u64>::sse_encode(self.fees_sat, serializer);
8820        <Option<u64>>::sse_encode(self.swapper_fees_sat, serializer);
8821        <crate::model::PaymentType>::sse_encode(self.payment_type, serializer);
8822        <crate::model::PaymentState>::sse_encode(self.status, serializer);
8823        <crate::model::PaymentDetails>::sse_encode(self.details, serializer);
8824    }
8825}
8826
8827impl SseEncode for crate::model::PaymentDetails {
8828    // Codec=Sse (Serialization based), see doc to use other codecs
8829    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8830        match self {
8831            crate::model::PaymentDetails::Lightning {
8832                swap_id,
8833                description,
8834                liquid_expiration_blockheight,
8835                preimage,
8836                invoice,
8837                bolt12_offer,
8838                payment_hash,
8839                destination_pubkey,
8840                lnurl_info,
8841                bip353_address,
8842                claim_tx_id,
8843                refund_tx_id,
8844                refund_tx_amount_sat,
8845            } => {
8846                <i32>::sse_encode(0, serializer);
8847                <String>::sse_encode(swap_id, serializer);
8848                <String>::sse_encode(description, serializer);
8849                <u32>::sse_encode(liquid_expiration_blockheight, serializer);
8850                <Option<String>>::sse_encode(preimage, serializer);
8851                <Option<String>>::sse_encode(invoice, serializer);
8852                <Option<String>>::sse_encode(bolt12_offer, serializer);
8853                <Option<String>>::sse_encode(payment_hash, serializer);
8854                <Option<String>>::sse_encode(destination_pubkey, serializer);
8855                <Option<crate::model::LnUrlInfo>>::sse_encode(lnurl_info, serializer);
8856                <Option<String>>::sse_encode(bip353_address, serializer);
8857                <Option<String>>::sse_encode(claim_tx_id, serializer);
8858                <Option<String>>::sse_encode(refund_tx_id, serializer);
8859                <Option<u64>>::sse_encode(refund_tx_amount_sat, serializer);
8860            }
8861            crate::model::PaymentDetails::Liquid {
8862                destination,
8863                description,
8864                asset_id,
8865                asset_info,
8866                lnurl_info,
8867                bip353_address,
8868            } => {
8869                <i32>::sse_encode(1, serializer);
8870                <String>::sse_encode(destination, serializer);
8871                <String>::sse_encode(description, serializer);
8872                <String>::sse_encode(asset_id, serializer);
8873                <Option<crate::model::AssetInfo>>::sse_encode(asset_info, serializer);
8874                <Option<crate::model::LnUrlInfo>>::sse_encode(lnurl_info, serializer);
8875                <Option<String>>::sse_encode(bip353_address, serializer);
8876            }
8877            crate::model::PaymentDetails::Bitcoin {
8878                swap_id,
8879                description,
8880                auto_accepted_fees,
8881                liquid_expiration_blockheight,
8882                bitcoin_expiration_blockheight,
8883                claim_tx_id,
8884                refund_tx_id,
8885                refund_tx_amount_sat,
8886            } => {
8887                <i32>::sse_encode(2, serializer);
8888                <String>::sse_encode(swap_id, serializer);
8889                <String>::sse_encode(description, serializer);
8890                <bool>::sse_encode(auto_accepted_fees, serializer);
8891                <Option<u32>>::sse_encode(liquid_expiration_blockheight, serializer);
8892                <Option<u32>>::sse_encode(bitcoin_expiration_blockheight, serializer);
8893                <Option<String>>::sse_encode(claim_tx_id, serializer);
8894                <Option<String>>::sse_encode(refund_tx_id, serializer);
8895                <Option<u64>>::sse_encode(refund_tx_amount_sat, serializer);
8896            }
8897            _ => {
8898                unimplemented!("");
8899            }
8900        }
8901    }
8902}
8903
8904impl SseEncode for crate::error::PaymentError {
8905    // Codec=Sse (Serialization based), see doc to use other codecs
8906    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8907        match self {
8908            crate::error::PaymentError::AlreadyClaimed => {
8909                <i32>::sse_encode(0, serializer);
8910            }
8911            crate::error::PaymentError::AlreadyPaid => {
8912                <i32>::sse_encode(1, serializer);
8913            }
8914            crate::error::PaymentError::PaymentInProgress => {
8915                <i32>::sse_encode(2, serializer);
8916            }
8917            crate::error::PaymentError::AmountOutOfRange { min, max } => {
8918                <i32>::sse_encode(3, serializer);
8919                <u64>::sse_encode(min, serializer);
8920                <u64>::sse_encode(max, serializer);
8921            }
8922            crate::error::PaymentError::AmountMissing { err } => {
8923                <i32>::sse_encode(4, serializer);
8924                <String>::sse_encode(err, serializer);
8925            }
8926            crate::error::PaymentError::AssetError { err } => {
8927                <i32>::sse_encode(5, serializer);
8928                <String>::sse_encode(err, serializer);
8929            }
8930            crate::error::PaymentError::InvalidNetwork { err } => {
8931                <i32>::sse_encode(6, serializer);
8932                <String>::sse_encode(err, serializer);
8933            }
8934            crate::error::PaymentError::Generic { err } => {
8935                <i32>::sse_encode(7, serializer);
8936                <String>::sse_encode(err, serializer);
8937            }
8938            crate::error::PaymentError::InvalidOrExpiredFees => {
8939                <i32>::sse_encode(8, serializer);
8940            }
8941            crate::error::PaymentError::InsufficientFunds => {
8942                <i32>::sse_encode(9, serializer);
8943            }
8944            crate::error::PaymentError::InvalidDescription { err } => {
8945                <i32>::sse_encode(10, serializer);
8946                <String>::sse_encode(err, serializer);
8947            }
8948            crate::error::PaymentError::InvalidInvoice { err } => {
8949                <i32>::sse_encode(11, serializer);
8950                <String>::sse_encode(err, serializer);
8951            }
8952            crate::error::PaymentError::InvalidPreimage => {
8953                <i32>::sse_encode(12, serializer);
8954            }
8955            crate::error::PaymentError::PairsNotFound => {
8956                <i32>::sse_encode(13, serializer);
8957            }
8958            crate::error::PaymentError::PaymentTimeout => {
8959                <i32>::sse_encode(14, serializer);
8960            }
8961            crate::error::PaymentError::PersistError => {
8962                <i32>::sse_encode(15, serializer);
8963            }
8964            crate::error::PaymentError::ReceiveError { err } => {
8965                <i32>::sse_encode(16, serializer);
8966                <String>::sse_encode(err, serializer);
8967            }
8968            crate::error::PaymentError::Refunded { err, refund_tx_id } => {
8969                <i32>::sse_encode(17, serializer);
8970                <String>::sse_encode(err, serializer);
8971                <String>::sse_encode(refund_tx_id, serializer);
8972            }
8973            crate::error::PaymentError::SelfTransferNotSupported => {
8974                <i32>::sse_encode(18, serializer);
8975            }
8976            crate::error::PaymentError::SendError { err } => {
8977                <i32>::sse_encode(19, serializer);
8978                <String>::sse_encode(err, serializer);
8979            }
8980            crate::error::PaymentError::SignerError { err } => {
8981                <i32>::sse_encode(20, serializer);
8982                <String>::sse_encode(err, serializer);
8983            }
8984            _ => {
8985                unimplemented!("");
8986            }
8987        }
8988    }
8989}
8990
8991impl SseEncode for crate::model::PaymentMethod {
8992    // Codec=Sse (Serialization based), see doc to use other codecs
8993    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8994        <i32>::sse_encode(
8995            match self {
8996                crate::model::PaymentMethod::Lightning => 0,
8997                crate::model::PaymentMethod::Bolt11Invoice => 1,
8998                crate::model::PaymentMethod::Bolt12Offer => 2,
8999                crate::model::PaymentMethod::BitcoinAddress => 3,
9000                crate::model::PaymentMethod::LiquidAddress => 4,
9001                _ => {
9002                    unimplemented!("");
9003                }
9004            },
9005            serializer,
9006        );
9007    }
9008}
9009
9010impl SseEncode for crate::model::PaymentState {
9011    // Codec=Sse (Serialization based), see doc to use other codecs
9012    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9013        <i32>::sse_encode(
9014            match self {
9015                crate::model::PaymentState::Created => 0,
9016                crate::model::PaymentState::Pending => 1,
9017                crate::model::PaymentState::Complete => 2,
9018                crate::model::PaymentState::Failed => 3,
9019                crate::model::PaymentState::TimedOut => 4,
9020                crate::model::PaymentState::Refundable => 5,
9021                crate::model::PaymentState::RefundPending => 6,
9022                crate::model::PaymentState::WaitingFeeAcceptance => 7,
9023                _ => {
9024                    unimplemented!("");
9025                }
9026            },
9027            serializer,
9028        );
9029    }
9030}
9031
9032impl SseEncode for crate::model::PaymentType {
9033    // Codec=Sse (Serialization based), see doc to use other codecs
9034    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9035        <i32>::sse_encode(
9036            match self {
9037                crate::model::PaymentType::Receive => 0,
9038                crate::model::PaymentType::Send => 1,
9039                _ => {
9040                    unimplemented!("");
9041                }
9042            },
9043            serializer,
9044        );
9045    }
9046}
9047
9048impl SseEncode for crate::model::PrepareBuyBitcoinRequest {
9049    // Codec=Sse (Serialization based), see doc to use other codecs
9050    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9051        <crate::model::BuyBitcoinProvider>::sse_encode(self.provider, serializer);
9052        <u64>::sse_encode(self.amount_sat, serializer);
9053    }
9054}
9055
9056impl SseEncode for crate::model::PrepareBuyBitcoinResponse {
9057    // Codec=Sse (Serialization based), see doc to use other codecs
9058    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9059        <crate::model::BuyBitcoinProvider>::sse_encode(self.provider, serializer);
9060        <u64>::sse_encode(self.amount_sat, serializer);
9061        <u64>::sse_encode(self.fees_sat, serializer);
9062    }
9063}
9064
9065impl SseEncode for crate::model::PrepareLnUrlPayRequest {
9066    // Codec=Sse (Serialization based), see doc to use other codecs
9067    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9068        <crate::bindings::LnUrlPayRequestData>::sse_encode(self.data, serializer);
9069        <crate::model::PayAmount>::sse_encode(self.amount, serializer);
9070        <Option<String>>::sse_encode(self.bip353_address, serializer);
9071        <Option<String>>::sse_encode(self.comment, serializer);
9072        <Option<bool>>::sse_encode(self.validate_success_action_url, serializer);
9073    }
9074}
9075
9076impl SseEncode for crate::model::PrepareLnUrlPayResponse {
9077    // Codec=Sse (Serialization based), see doc to use other codecs
9078    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9079        <crate::model::SendDestination>::sse_encode(self.destination, serializer);
9080        <u64>::sse_encode(self.fees_sat, serializer);
9081        <crate::bindings::LnUrlPayRequestData>::sse_encode(self.data, serializer);
9082        <Option<String>>::sse_encode(self.comment, serializer);
9083        <Option<crate::bindings::SuccessAction>>::sse_encode(self.success_action, serializer);
9084    }
9085}
9086
9087impl SseEncode for crate::model::PreparePayOnchainRequest {
9088    // Codec=Sse (Serialization based), see doc to use other codecs
9089    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9090        <crate::model::PayAmount>::sse_encode(self.amount, serializer);
9091        <Option<u32>>::sse_encode(self.fee_rate_sat_per_vbyte, serializer);
9092    }
9093}
9094
9095impl SseEncode for crate::model::PreparePayOnchainResponse {
9096    // Codec=Sse (Serialization based), see doc to use other codecs
9097    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9098        <u64>::sse_encode(self.receiver_amount_sat, serializer);
9099        <u64>::sse_encode(self.claim_fees_sat, serializer);
9100        <u64>::sse_encode(self.total_fees_sat, serializer);
9101    }
9102}
9103
9104impl SseEncode for crate::model::PrepareReceiveRequest {
9105    // Codec=Sse (Serialization based), see doc to use other codecs
9106    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9107        <crate::model::PaymentMethod>::sse_encode(self.payment_method, serializer);
9108        <Option<crate::model::ReceiveAmount>>::sse_encode(self.amount, serializer);
9109    }
9110}
9111
9112impl SseEncode for crate::model::PrepareReceiveResponse {
9113    // Codec=Sse (Serialization based), see doc to use other codecs
9114    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9115        <crate::model::PaymentMethod>::sse_encode(self.payment_method, serializer);
9116        <u64>::sse_encode(self.fees_sat, serializer);
9117        <Option<crate::model::ReceiveAmount>>::sse_encode(self.amount, serializer);
9118        <Option<u64>>::sse_encode(self.min_payer_amount_sat, serializer);
9119        <Option<u64>>::sse_encode(self.max_payer_amount_sat, serializer);
9120        <Option<f64>>::sse_encode(self.swapper_feerate, serializer);
9121    }
9122}
9123
9124impl SseEncode for crate::model::PrepareRefundRequest {
9125    // Codec=Sse (Serialization based), see doc to use other codecs
9126    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9127        <String>::sse_encode(self.swap_address, serializer);
9128        <String>::sse_encode(self.refund_address, serializer);
9129        <u32>::sse_encode(self.fee_rate_sat_per_vbyte, serializer);
9130    }
9131}
9132
9133impl SseEncode for crate::model::PrepareRefundResponse {
9134    // Codec=Sse (Serialization based), see doc to use other codecs
9135    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9136        <u32>::sse_encode(self.tx_vsize, serializer);
9137        <u64>::sse_encode(self.tx_fee_sat, serializer);
9138        <Option<String>>::sse_encode(self.last_refund_tx_id, serializer);
9139    }
9140}
9141
9142impl SseEncode for crate::model::PrepareSendRequest {
9143    // Codec=Sse (Serialization based), see doc to use other codecs
9144    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9145        <String>::sse_encode(self.destination, serializer);
9146        <Option<crate::model::PayAmount>>::sse_encode(self.amount, serializer);
9147    }
9148}
9149
9150impl SseEncode for crate::model::PrepareSendResponse {
9151    // Codec=Sse (Serialization based), see doc to use other codecs
9152    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9153        <crate::model::SendDestination>::sse_encode(self.destination, serializer);
9154        <Option<u64>>::sse_encode(self.fees_sat, serializer);
9155        <Option<f64>>::sse_encode(self.estimated_asset_fees, serializer);
9156    }
9157}
9158
9159impl SseEncode for crate::bindings::Rate {
9160    // Codec=Sse (Serialization based), see doc to use other codecs
9161    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9162        <String>::sse_encode(self.coin, serializer);
9163        <f64>::sse_encode(self.value, serializer);
9164    }
9165}
9166
9167impl SseEncode for crate::model::ReceiveAmount {
9168    // Codec=Sse (Serialization based), see doc to use other codecs
9169    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9170        match self {
9171            crate::model::ReceiveAmount::Bitcoin { payer_amount_sat } => {
9172                <i32>::sse_encode(0, serializer);
9173                <u64>::sse_encode(payer_amount_sat, serializer);
9174            }
9175            crate::model::ReceiveAmount::Asset {
9176                asset_id,
9177                payer_amount,
9178            } => {
9179                <i32>::sse_encode(1, serializer);
9180                <String>::sse_encode(asset_id, serializer);
9181                <Option<f64>>::sse_encode(payer_amount, serializer);
9182            }
9183            _ => {
9184                unimplemented!("");
9185            }
9186        }
9187    }
9188}
9189
9190impl SseEncode for crate::model::ReceivePaymentRequest {
9191    // Codec=Sse (Serialization based), see doc to use other codecs
9192    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9193        <crate::model::PrepareReceiveResponse>::sse_encode(self.prepare_response, serializer);
9194        <Option<String>>::sse_encode(self.description, serializer);
9195        <Option<bool>>::sse_encode(self.use_description_hash, serializer);
9196    }
9197}
9198
9199impl SseEncode for crate::model::ReceivePaymentResponse {
9200    // Codec=Sse (Serialization based), see doc to use other codecs
9201    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9202        <String>::sse_encode(self.destination, serializer);
9203    }
9204}
9205
9206impl SseEncode for crate::model::RecommendedFees {
9207    // Codec=Sse (Serialization based), see doc to use other codecs
9208    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9209        <u64>::sse_encode(self.fastest_fee, serializer);
9210        <u64>::sse_encode(self.half_hour_fee, serializer);
9211        <u64>::sse_encode(self.hour_fee, serializer);
9212        <u64>::sse_encode(self.economy_fee, serializer);
9213        <u64>::sse_encode(self.minimum_fee, serializer);
9214    }
9215}
9216
9217impl SseEncode for crate::model::RefundRequest {
9218    // Codec=Sse (Serialization based), see doc to use other codecs
9219    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9220        <String>::sse_encode(self.swap_address, serializer);
9221        <String>::sse_encode(self.refund_address, serializer);
9222        <u32>::sse_encode(self.fee_rate_sat_per_vbyte, serializer);
9223    }
9224}
9225
9226impl SseEncode for crate::model::RefundResponse {
9227    // Codec=Sse (Serialization based), see doc to use other codecs
9228    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9229        <String>::sse_encode(self.refund_tx_id, serializer);
9230    }
9231}
9232
9233impl SseEncode for crate::model::RefundableSwap {
9234    // Codec=Sse (Serialization based), see doc to use other codecs
9235    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9236        <String>::sse_encode(self.swap_address, serializer);
9237        <u32>::sse_encode(self.timestamp, serializer);
9238        <u64>::sse_encode(self.amount_sat, serializer);
9239        <Option<String>>::sse_encode(self.last_refund_tx_id, serializer);
9240    }
9241}
9242
9243impl SseEncode for crate::model::RestoreRequest {
9244    // Codec=Sse (Serialization based), see doc to use other codecs
9245    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9246        <Option<String>>::sse_encode(self.backup_path, serializer);
9247    }
9248}
9249
9250impl SseEncode for crate::bindings::RouteHint {
9251    // Codec=Sse (Serialization based), see doc to use other codecs
9252    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9253        <Vec<crate::bindings::RouteHintHop>>::sse_encode(self.hops, serializer);
9254    }
9255}
9256
9257impl SseEncode for crate::bindings::RouteHintHop {
9258    // Codec=Sse (Serialization based), see doc to use other codecs
9259    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9260        <String>::sse_encode(self.src_node_id, serializer);
9261        <String>::sse_encode(self.short_channel_id, serializer);
9262        <u32>::sse_encode(self.fees_base_msat, serializer);
9263        <u32>::sse_encode(self.fees_proportional_millionths, serializer);
9264        <u64>::sse_encode(self.cltv_expiry_delta, serializer);
9265        <Option<u64>>::sse_encode(self.htlc_minimum_msat, serializer);
9266        <Option<u64>>::sse_encode(self.htlc_maximum_msat, serializer);
9267    }
9268}
9269
9270impl SseEncode for crate::error::SdkError {
9271    // Codec=Sse (Serialization based), see doc to use other codecs
9272    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9273        match self {
9274            crate::error::SdkError::AlreadyStarted => {
9275                <i32>::sse_encode(0, serializer);
9276            }
9277            crate::error::SdkError::Generic { err } => {
9278                <i32>::sse_encode(1, serializer);
9279                <String>::sse_encode(err, serializer);
9280            }
9281            crate::error::SdkError::NotStarted => {
9282                <i32>::sse_encode(2, serializer);
9283            }
9284            crate::error::SdkError::ServiceConnectivity { err } => {
9285                <i32>::sse_encode(3, serializer);
9286                <String>::sse_encode(err, serializer);
9287            }
9288            _ => {
9289                unimplemented!("");
9290            }
9291        }
9292    }
9293}
9294
9295impl SseEncode for crate::model::SdkEvent {
9296    // Codec=Sse (Serialization based), see doc to use other codecs
9297    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9298        match self {
9299            crate::model::SdkEvent::PaymentFailed { details } => {
9300                <i32>::sse_encode(0, serializer);
9301                <crate::model::Payment>::sse_encode(details, serializer);
9302            }
9303            crate::model::SdkEvent::PaymentPending { details } => {
9304                <i32>::sse_encode(1, serializer);
9305                <crate::model::Payment>::sse_encode(details, serializer);
9306            }
9307            crate::model::SdkEvent::PaymentRefundable { details } => {
9308                <i32>::sse_encode(2, serializer);
9309                <crate::model::Payment>::sse_encode(details, serializer);
9310            }
9311            crate::model::SdkEvent::PaymentRefunded { details } => {
9312                <i32>::sse_encode(3, serializer);
9313                <crate::model::Payment>::sse_encode(details, serializer);
9314            }
9315            crate::model::SdkEvent::PaymentRefundPending { details } => {
9316                <i32>::sse_encode(4, serializer);
9317                <crate::model::Payment>::sse_encode(details, serializer);
9318            }
9319            crate::model::SdkEvent::PaymentSucceeded { details } => {
9320                <i32>::sse_encode(5, serializer);
9321                <crate::model::Payment>::sse_encode(details, serializer);
9322            }
9323            crate::model::SdkEvent::PaymentWaitingConfirmation { details } => {
9324                <i32>::sse_encode(6, serializer);
9325                <crate::model::Payment>::sse_encode(details, serializer);
9326            }
9327            crate::model::SdkEvent::PaymentWaitingFeeAcceptance { details } => {
9328                <i32>::sse_encode(7, serializer);
9329                <crate::model::Payment>::sse_encode(details, serializer);
9330            }
9331            crate::model::SdkEvent::Synced => {
9332                <i32>::sse_encode(8, serializer);
9333            }
9334            crate::model::SdkEvent::DataSynced {
9335                did_pull_new_records,
9336            } => {
9337                <i32>::sse_encode(9, serializer);
9338                <bool>::sse_encode(did_pull_new_records, serializer);
9339            }
9340            _ => {
9341                unimplemented!("");
9342            }
9343        }
9344    }
9345}
9346
9347impl SseEncode for crate::model::SendDestination {
9348    // Codec=Sse (Serialization based), see doc to use other codecs
9349    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9350        match self {
9351            crate::model::SendDestination::LiquidAddress {
9352                address_data,
9353                bip353_address,
9354            } => {
9355                <i32>::sse_encode(0, serializer);
9356                <crate::bindings::LiquidAddressData>::sse_encode(address_data, serializer);
9357                <Option<String>>::sse_encode(bip353_address, serializer);
9358            }
9359            crate::model::SendDestination::Bolt11 {
9360                invoice,
9361                bip353_address,
9362            } => {
9363                <i32>::sse_encode(1, serializer);
9364                <crate::bindings::LNInvoice>::sse_encode(invoice, serializer);
9365                <Option<String>>::sse_encode(bip353_address, serializer);
9366            }
9367            crate::model::SendDestination::Bolt12 {
9368                offer,
9369                receiver_amount_sat,
9370                bip353_address,
9371            } => {
9372                <i32>::sse_encode(2, serializer);
9373                <crate::bindings::LNOffer>::sse_encode(offer, serializer);
9374                <u64>::sse_encode(receiver_amount_sat, serializer);
9375                <Option<String>>::sse_encode(bip353_address, serializer);
9376            }
9377            _ => {
9378                unimplemented!("");
9379            }
9380        }
9381    }
9382}
9383
9384impl SseEncode for crate::model::SendPaymentRequest {
9385    // Codec=Sse (Serialization based), see doc to use other codecs
9386    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9387        <crate::model::PrepareSendResponse>::sse_encode(self.prepare_response, serializer);
9388        <Option<bool>>::sse_encode(self.use_asset_fees, serializer);
9389    }
9390}
9391
9392impl SseEncode for crate::model::SendPaymentResponse {
9393    // Codec=Sse (Serialization based), see doc to use other codecs
9394    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9395        <crate::model::Payment>::sse_encode(self.payment, serializer);
9396    }
9397}
9398
9399impl SseEncode for crate::model::SignMessageRequest {
9400    // Codec=Sse (Serialization based), see doc to use other codecs
9401    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9402        <String>::sse_encode(self.message, serializer);
9403    }
9404}
9405
9406impl SseEncode for crate::model::SignMessageResponse {
9407    // Codec=Sse (Serialization based), see doc to use other codecs
9408    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9409        <String>::sse_encode(self.signature, serializer);
9410    }
9411}
9412
9413impl SseEncode for crate::bindings::SuccessAction {
9414    // Codec=Sse (Serialization based), see doc to use other codecs
9415    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9416        match self {
9417            crate::bindings::SuccessAction::Aes { data } => {
9418                <i32>::sse_encode(0, serializer);
9419                <crate::bindings::AesSuccessActionData>::sse_encode(data, serializer);
9420            }
9421            crate::bindings::SuccessAction::Message { data } => {
9422                <i32>::sse_encode(1, serializer);
9423                <crate::bindings::MessageSuccessActionData>::sse_encode(data, serializer);
9424            }
9425            crate::bindings::SuccessAction::Url { data } => {
9426                <i32>::sse_encode(2, serializer);
9427                <crate::bindings::UrlSuccessActionData>::sse_encode(data, serializer);
9428            }
9429            _ => {
9430                unimplemented!("");
9431            }
9432        }
9433    }
9434}
9435
9436impl SseEncode for crate::bindings::SuccessActionProcessed {
9437    // Codec=Sse (Serialization based), see doc to use other codecs
9438    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9439        match self {
9440            crate::bindings::SuccessActionProcessed::Aes { result } => {
9441                <i32>::sse_encode(0, serializer);
9442                <crate::bindings::AesSuccessActionDataResult>::sse_encode(result, serializer);
9443            }
9444            crate::bindings::SuccessActionProcessed::Message { data } => {
9445                <i32>::sse_encode(1, serializer);
9446                <crate::bindings::MessageSuccessActionData>::sse_encode(data, serializer);
9447            }
9448            crate::bindings::SuccessActionProcessed::Url { data } => {
9449                <i32>::sse_encode(2, serializer);
9450                <crate::bindings::UrlSuccessActionData>::sse_encode(data, serializer);
9451            }
9452            _ => {
9453                unimplemented!("");
9454            }
9455        }
9456    }
9457}
9458
9459impl SseEncode for crate::bindings::Symbol {
9460    // Codec=Sse (Serialization based), see doc to use other codecs
9461    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9462        <Option<String>>::sse_encode(self.grapheme, serializer);
9463        <Option<String>>::sse_encode(self.template, serializer);
9464        <Option<bool>>::sse_encode(self.rtl, serializer);
9465        <Option<u32>>::sse_encode(self.position, serializer);
9466    }
9467}
9468
9469impl SseEncode for u16 {
9470    // Codec=Sse (Serialization based), see doc to use other codecs
9471    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9472        serializer.cursor.write_u16::<NativeEndian>(self).unwrap();
9473    }
9474}
9475
9476impl SseEncode for u32 {
9477    // Codec=Sse (Serialization based), see doc to use other codecs
9478    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9479        serializer.cursor.write_u32::<NativeEndian>(self).unwrap();
9480    }
9481}
9482
9483impl SseEncode for u64 {
9484    // Codec=Sse (Serialization based), see doc to use other codecs
9485    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9486        serializer.cursor.write_u64::<NativeEndian>(self).unwrap();
9487    }
9488}
9489
9490impl SseEncode for u8 {
9491    // Codec=Sse (Serialization based), see doc to use other codecs
9492    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9493        serializer.cursor.write_u8(self).unwrap();
9494    }
9495}
9496
9497impl SseEncode for () {
9498    // Codec=Sse (Serialization based), see doc to use other codecs
9499    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {}
9500}
9501
9502impl SseEncode for crate::bindings::UrlSuccessActionData {
9503    // Codec=Sse (Serialization based), see doc to use other codecs
9504    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9505        <String>::sse_encode(self.description, serializer);
9506        <String>::sse_encode(self.url, serializer);
9507        <bool>::sse_encode(self.matches_callback_domain, serializer);
9508    }
9509}
9510
9511impl SseEncode for usize {
9512    // Codec=Sse (Serialization based), see doc to use other codecs
9513    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9514        serializer
9515            .cursor
9516            .write_u64::<NativeEndian>(self as _)
9517            .unwrap();
9518    }
9519}
9520
9521impl SseEncode for crate::model::WalletInfo {
9522    // Codec=Sse (Serialization based), see doc to use other codecs
9523    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9524        <u64>::sse_encode(self.balance_sat, serializer);
9525        <u64>::sse_encode(self.pending_send_sat, serializer);
9526        <u64>::sse_encode(self.pending_receive_sat, serializer);
9527        <String>::sse_encode(self.fingerprint, serializer);
9528        <String>::sse_encode(self.pubkey, serializer);
9529        <Vec<crate::model::AssetBalance>>::sse_encode(self.asset_balances, serializer);
9530    }
9531}
9532
9533#[cfg(not(target_family = "wasm"))]
9534mod io {
9535    // This file is automatically generated, so please do not edit it.
9536    // @generated by `flutter_rust_bridge`@ 2.9.0.
9537
9538    // Section: imports
9539
9540    use super::*;
9541    use crate::bindings::*;
9542    use crate::model::EventListener;
9543    use flutter_rust_bridge::for_generated::byteorder::{
9544        NativeEndian, ReadBytesExt, WriteBytesExt,
9545    };
9546    use flutter_rust_bridge::for_generated::{transform_result_dco, Lifetimeable, Lockable};
9547    use flutter_rust_bridge::{Handler, IntoIntoDart};
9548
9549    // Section: boilerplate
9550
9551    flutter_rust_bridge::frb_generated_boilerplate_io!();
9552
9553    // Section: dart2rust
9554
9555    impl CstDecode<flutter_rust_bridge::for_generated::anyhow::Error>
9556        for *mut wire_cst_list_prim_u_8_strict
9557    {
9558        // Codec=Cst (C-struct based), see doc to use other codecs
9559        fn cst_decode(self) -> flutter_rust_bridge::for_generated::anyhow::Error {
9560            unimplemented!()
9561        }
9562    }
9563    impl CstDecode<BindingLiquidSdk> for usize {
9564        // Codec=Cst (C-struct based), see doc to use other codecs
9565        fn cst_decode(self) -> BindingLiquidSdk {
9566            flutter_rust_bridge::for_generated::rust_auto_opaque_decode_owned(CstDecode::<
9567                RustOpaqueNom<
9568                    flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>,
9569                >,
9570            >::cst_decode(
9571                self
9572            ))
9573        }
9574    }
9575    impl
9576        CstDecode<
9577            RustOpaqueNom<
9578                flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>,
9579            >,
9580        > for usize
9581    {
9582        // Codec=Cst (C-struct based), see doc to use other codecs
9583        fn cst_decode(
9584            self,
9585        ) -> RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>
9586        {
9587            unsafe { decode_rust_opaque_nom(self as _) }
9588        }
9589    }
9590    impl CstDecode<StreamSink<crate::model::LogEntry, flutter_rust_bridge::for_generated::DcoCodec>>
9591        for *mut wire_cst_list_prim_u_8_strict
9592    {
9593        // Codec=Cst (C-struct based), see doc to use other codecs
9594        fn cst_decode(
9595            self,
9596        ) -> StreamSink<crate::model::LogEntry, flutter_rust_bridge::for_generated::DcoCodec>
9597        {
9598            let raw: String = self.cst_decode();
9599            StreamSink::deserialize(raw)
9600        }
9601    }
9602    impl CstDecode<StreamSink<crate::model::SdkEvent, flutter_rust_bridge::for_generated::DcoCodec>>
9603        for *mut wire_cst_list_prim_u_8_strict
9604    {
9605        // Codec=Cst (C-struct based), see doc to use other codecs
9606        fn cst_decode(
9607            self,
9608        ) -> StreamSink<crate::model::SdkEvent, flutter_rust_bridge::for_generated::DcoCodec>
9609        {
9610            let raw: String = self.cst_decode();
9611            StreamSink::deserialize(raw)
9612        }
9613    }
9614    impl CstDecode<String> for *mut wire_cst_list_prim_u_8_strict {
9615        // Codec=Cst (C-struct based), see doc to use other codecs
9616        fn cst_decode(self) -> String {
9617            let vec: Vec<u8> = self.cst_decode();
9618            String::from_utf8(vec).unwrap()
9619        }
9620    }
9621    impl CstDecode<crate::model::AcceptPaymentProposedFeesRequest>
9622        for wire_cst_accept_payment_proposed_fees_request
9623    {
9624        // Codec=Cst (C-struct based), see doc to use other codecs
9625        fn cst_decode(self) -> crate::model::AcceptPaymentProposedFeesRequest {
9626            crate::model::AcceptPaymentProposedFeesRequest {
9627                response: self.response.cst_decode(),
9628            }
9629        }
9630    }
9631    impl CstDecode<crate::bindings::AesSuccessActionData> for wire_cst_aes_success_action_data {
9632        // Codec=Cst (C-struct based), see doc to use other codecs
9633        fn cst_decode(self) -> crate::bindings::AesSuccessActionData {
9634            crate::bindings::AesSuccessActionData {
9635                description: self.description.cst_decode(),
9636                ciphertext: self.ciphertext.cst_decode(),
9637                iv: self.iv.cst_decode(),
9638            }
9639        }
9640    }
9641    impl CstDecode<crate::bindings::AesSuccessActionDataDecrypted>
9642        for wire_cst_aes_success_action_data_decrypted
9643    {
9644        // Codec=Cst (C-struct based), see doc to use other codecs
9645        fn cst_decode(self) -> crate::bindings::AesSuccessActionDataDecrypted {
9646            crate::bindings::AesSuccessActionDataDecrypted {
9647                description: self.description.cst_decode(),
9648                plaintext: self.plaintext.cst_decode(),
9649            }
9650        }
9651    }
9652    impl CstDecode<crate::bindings::AesSuccessActionDataResult>
9653        for wire_cst_aes_success_action_data_result
9654    {
9655        // Codec=Cst (C-struct based), see doc to use other codecs
9656        fn cst_decode(self) -> crate::bindings::AesSuccessActionDataResult {
9657            match self.tag {
9658                0 => {
9659                    let ans = unsafe { self.kind.Decrypted };
9660                    crate::bindings::AesSuccessActionDataResult::Decrypted {
9661                        data: ans.data.cst_decode(),
9662                    }
9663                }
9664                1 => {
9665                    let ans = unsafe { self.kind.ErrorStatus };
9666                    crate::bindings::AesSuccessActionDataResult::ErrorStatus {
9667                        reason: ans.reason.cst_decode(),
9668                    }
9669                }
9670                _ => unreachable!(),
9671            }
9672        }
9673    }
9674    impl CstDecode<crate::bindings::Amount> for wire_cst_amount {
9675        // Codec=Cst (C-struct based), see doc to use other codecs
9676        fn cst_decode(self) -> crate::bindings::Amount {
9677            match self.tag {
9678                0 => {
9679                    let ans = unsafe { self.kind.Bitcoin };
9680                    crate::bindings::Amount::Bitcoin {
9681                        amount_msat: ans.amount_msat.cst_decode(),
9682                    }
9683                }
9684                1 => {
9685                    let ans = unsafe { self.kind.Currency };
9686                    crate::bindings::Amount::Currency {
9687                        iso4217_code: ans.iso4217_code.cst_decode(),
9688                        fractional_amount: ans.fractional_amount.cst_decode(),
9689                    }
9690                }
9691                _ => unreachable!(),
9692            }
9693        }
9694    }
9695    impl CstDecode<crate::model::AssetBalance> for wire_cst_asset_balance {
9696        // Codec=Cst (C-struct based), see doc to use other codecs
9697        fn cst_decode(self) -> crate::model::AssetBalance {
9698            crate::model::AssetBalance {
9699                asset_id: self.asset_id.cst_decode(),
9700                balance_sat: self.balance_sat.cst_decode(),
9701                name: self.name.cst_decode(),
9702                ticker: self.ticker.cst_decode(),
9703                balance: self.balance.cst_decode(),
9704            }
9705        }
9706    }
9707    impl CstDecode<crate::model::AssetInfo> for wire_cst_asset_info {
9708        // Codec=Cst (C-struct based), see doc to use other codecs
9709        fn cst_decode(self) -> crate::model::AssetInfo {
9710            crate::model::AssetInfo {
9711                name: self.name.cst_decode(),
9712                ticker: self.ticker.cst_decode(),
9713                amount: self.amount.cst_decode(),
9714                fees: self.fees.cst_decode(),
9715            }
9716        }
9717    }
9718    impl CstDecode<crate::model::AssetMetadata> for wire_cst_asset_metadata {
9719        // Codec=Cst (C-struct based), see doc to use other codecs
9720        fn cst_decode(self) -> crate::model::AssetMetadata {
9721            crate::model::AssetMetadata {
9722                asset_id: self.asset_id.cst_decode(),
9723                name: self.name.cst_decode(),
9724                ticker: self.ticker.cst_decode(),
9725                precision: self.precision.cst_decode(),
9726                fiat_id: self.fiat_id.cst_decode(),
9727            }
9728        }
9729    }
9730    impl CstDecode<crate::model::BackupRequest> for wire_cst_backup_request {
9731        // Codec=Cst (C-struct based), see doc to use other codecs
9732        fn cst_decode(self) -> crate::model::BackupRequest {
9733            crate::model::BackupRequest {
9734                backup_path: self.backup_path.cst_decode(),
9735            }
9736        }
9737    }
9738    impl CstDecode<crate::bindings::BindingEventListener> for wire_cst_binding_event_listener {
9739        // Codec=Cst (C-struct based), see doc to use other codecs
9740        fn cst_decode(self) -> crate::bindings::BindingEventListener {
9741            crate::bindings::BindingEventListener {
9742                stream: self.stream.cst_decode(),
9743            }
9744        }
9745    }
9746    impl CstDecode<crate::bindings::BitcoinAddressData> for wire_cst_bitcoin_address_data {
9747        // Codec=Cst (C-struct based), see doc to use other codecs
9748        fn cst_decode(self) -> crate::bindings::BitcoinAddressData {
9749            crate::bindings::BitcoinAddressData {
9750                address: self.address.cst_decode(),
9751                network: self.network.cst_decode(),
9752                amount_sat: self.amount_sat.cst_decode(),
9753                label: self.label.cst_decode(),
9754                message: self.message.cst_decode(),
9755            }
9756        }
9757    }
9758    impl CstDecode<crate::model::BlockchainExplorer> for wire_cst_blockchain_explorer {
9759        // Codec=Cst (C-struct based), see doc to use other codecs
9760        fn cst_decode(self) -> crate::model::BlockchainExplorer {
9761            match self.tag {
9762                0 => {
9763                    let ans = unsafe { self.kind.Electrum };
9764                    crate::model::BlockchainExplorer::Electrum {
9765                        url: ans.url.cst_decode(),
9766                    }
9767                }
9768                1 => {
9769                    let ans = unsafe { self.kind.Esplora };
9770                    crate::model::BlockchainExplorer::Esplora {
9771                        url: ans.url.cst_decode(),
9772                        use_waterfalls: ans.use_waterfalls.cst_decode(),
9773                    }
9774                }
9775                _ => unreachable!(),
9776            }
9777        }
9778    }
9779    impl CstDecode<crate::model::BlockchainInfo> for wire_cst_blockchain_info {
9780        // Codec=Cst (C-struct based), see doc to use other codecs
9781        fn cst_decode(self) -> crate::model::BlockchainInfo {
9782            crate::model::BlockchainInfo {
9783                liquid_tip: self.liquid_tip.cst_decode(),
9784                bitcoin_tip: self.bitcoin_tip.cst_decode(),
9785            }
9786        }
9787    }
9788    impl CstDecode<crate::model::AcceptPaymentProposedFeesRequest>
9789        for *mut wire_cst_accept_payment_proposed_fees_request
9790    {
9791        // Codec=Cst (C-struct based), see doc to use other codecs
9792        fn cst_decode(self) -> crate::model::AcceptPaymentProposedFeesRequest {
9793            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9794            CstDecode::<crate::model::AcceptPaymentProposedFeesRequest>::cst_decode(*wrap).into()
9795        }
9796    }
9797    impl CstDecode<crate::bindings::AesSuccessActionData> for *mut wire_cst_aes_success_action_data {
9798        // Codec=Cst (C-struct based), see doc to use other codecs
9799        fn cst_decode(self) -> crate::bindings::AesSuccessActionData {
9800            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9801            CstDecode::<crate::bindings::AesSuccessActionData>::cst_decode(*wrap).into()
9802        }
9803    }
9804    impl CstDecode<crate::bindings::AesSuccessActionDataDecrypted>
9805        for *mut wire_cst_aes_success_action_data_decrypted
9806    {
9807        // Codec=Cst (C-struct based), see doc to use other codecs
9808        fn cst_decode(self) -> crate::bindings::AesSuccessActionDataDecrypted {
9809            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9810            CstDecode::<crate::bindings::AesSuccessActionDataDecrypted>::cst_decode(*wrap).into()
9811        }
9812    }
9813    impl CstDecode<crate::bindings::AesSuccessActionDataResult>
9814        for *mut wire_cst_aes_success_action_data_result
9815    {
9816        // Codec=Cst (C-struct based), see doc to use other codecs
9817        fn cst_decode(self) -> crate::bindings::AesSuccessActionDataResult {
9818            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9819            CstDecode::<crate::bindings::AesSuccessActionDataResult>::cst_decode(*wrap).into()
9820        }
9821    }
9822    impl CstDecode<crate::bindings::Amount> for *mut wire_cst_amount {
9823        // Codec=Cst (C-struct based), see doc to use other codecs
9824        fn cst_decode(self) -> crate::bindings::Amount {
9825            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9826            CstDecode::<crate::bindings::Amount>::cst_decode(*wrap).into()
9827        }
9828    }
9829    impl CstDecode<crate::model::AssetInfo> for *mut wire_cst_asset_info {
9830        // Codec=Cst (C-struct based), see doc to use other codecs
9831        fn cst_decode(self) -> crate::model::AssetInfo {
9832            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9833            CstDecode::<crate::model::AssetInfo>::cst_decode(*wrap).into()
9834        }
9835    }
9836    impl CstDecode<crate::model::BackupRequest> for *mut wire_cst_backup_request {
9837        // Codec=Cst (C-struct based), see doc to use other codecs
9838        fn cst_decode(self) -> crate::model::BackupRequest {
9839            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9840            CstDecode::<crate::model::BackupRequest>::cst_decode(*wrap).into()
9841        }
9842    }
9843    impl CstDecode<crate::bindings::BindingEventListener> for *mut wire_cst_binding_event_listener {
9844        // Codec=Cst (C-struct based), see doc to use other codecs
9845        fn cst_decode(self) -> crate::bindings::BindingEventListener {
9846            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9847            CstDecode::<crate::bindings::BindingEventListener>::cst_decode(*wrap).into()
9848        }
9849    }
9850    impl CstDecode<crate::bindings::BitcoinAddressData> for *mut wire_cst_bitcoin_address_data {
9851        // Codec=Cst (C-struct based), see doc to use other codecs
9852        fn cst_decode(self) -> crate::bindings::BitcoinAddressData {
9853            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9854            CstDecode::<crate::bindings::BitcoinAddressData>::cst_decode(*wrap).into()
9855        }
9856    }
9857    impl CstDecode<bool> for *mut bool {
9858        // Codec=Cst (C-struct based), see doc to use other codecs
9859        fn cst_decode(self) -> bool {
9860            unsafe { *flutter_rust_bridge::for_generated::box_from_leak_ptr(self) }
9861        }
9862    }
9863    impl CstDecode<crate::model::BuyBitcoinRequest> for *mut wire_cst_buy_bitcoin_request {
9864        // Codec=Cst (C-struct based), see doc to use other codecs
9865        fn cst_decode(self) -> crate::model::BuyBitcoinRequest {
9866            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9867            CstDecode::<crate::model::BuyBitcoinRequest>::cst_decode(*wrap).into()
9868        }
9869    }
9870    impl CstDecode<crate::model::CheckMessageRequest> for *mut wire_cst_check_message_request {
9871        // Codec=Cst (C-struct based), see doc to use other codecs
9872        fn cst_decode(self) -> crate::model::CheckMessageRequest {
9873            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9874            CstDecode::<crate::model::CheckMessageRequest>::cst_decode(*wrap).into()
9875        }
9876    }
9877    impl CstDecode<crate::model::ConnectRequest> for *mut wire_cst_connect_request {
9878        // Codec=Cst (C-struct based), see doc to use other codecs
9879        fn cst_decode(self) -> crate::model::ConnectRequest {
9880            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9881            CstDecode::<crate::model::ConnectRequest>::cst_decode(*wrap).into()
9882        }
9883    }
9884    impl CstDecode<crate::model::CreateBolt12InvoiceRequest>
9885        for *mut wire_cst_create_bolt_12_invoice_request
9886    {
9887        // Codec=Cst (C-struct based), see doc to use other codecs
9888        fn cst_decode(self) -> crate::model::CreateBolt12InvoiceRequest {
9889            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9890            CstDecode::<crate::model::CreateBolt12InvoiceRequest>::cst_decode(*wrap).into()
9891        }
9892    }
9893    impl CstDecode<f64> for *mut f64 {
9894        // Codec=Cst (C-struct based), see doc to use other codecs
9895        fn cst_decode(self) -> f64 {
9896            unsafe { *flutter_rust_bridge::for_generated::box_from_leak_ptr(self) }
9897        }
9898    }
9899    impl CstDecode<crate::model::FetchPaymentProposedFeesRequest>
9900        for *mut wire_cst_fetch_payment_proposed_fees_request
9901    {
9902        // Codec=Cst (C-struct based), see doc to use other codecs
9903        fn cst_decode(self) -> crate::model::FetchPaymentProposedFeesRequest {
9904            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9905            CstDecode::<crate::model::FetchPaymentProposedFeesRequest>::cst_decode(*wrap).into()
9906        }
9907    }
9908    impl CstDecode<crate::model::GetPaymentRequest> for *mut wire_cst_get_payment_request {
9909        // Codec=Cst (C-struct based), see doc to use other codecs
9910        fn cst_decode(self) -> crate::model::GetPaymentRequest {
9911            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9912            CstDecode::<crate::model::GetPaymentRequest>::cst_decode(*wrap).into()
9913        }
9914    }
9915    impl CstDecode<i64> for *mut i64 {
9916        // Codec=Cst (C-struct based), see doc to use other codecs
9917        fn cst_decode(self) -> i64 {
9918            unsafe { *flutter_rust_bridge::for_generated::box_from_leak_ptr(self) }
9919        }
9920    }
9921    impl CstDecode<crate::bindings::LiquidAddressData> for *mut wire_cst_liquid_address_data {
9922        // Codec=Cst (C-struct based), see doc to use other codecs
9923        fn cst_decode(self) -> crate::bindings::LiquidAddressData {
9924            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9925            CstDecode::<crate::bindings::LiquidAddressData>::cst_decode(*wrap).into()
9926        }
9927    }
9928    impl CstDecode<crate::model::ListPaymentDetails> for *mut wire_cst_list_payment_details {
9929        // Codec=Cst (C-struct based), see doc to use other codecs
9930        fn cst_decode(self) -> crate::model::ListPaymentDetails {
9931            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9932            CstDecode::<crate::model::ListPaymentDetails>::cst_decode(*wrap).into()
9933        }
9934    }
9935    impl CstDecode<crate::model::ListPaymentsRequest> for *mut wire_cst_list_payments_request {
9936        // Codec=Cst (C-struct based), see doc to use other codecs
9937        fn cst_decode(self) -> crate::model::ListPaymentsRequest {
9938            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9939            CstDecode::<crate::model::ListPaymentsRequest>::cst_decode(*wrap).into()
9940        }
9941    }
9942    impl CstDecode<crate::bindings::LNInvoice> for *mut wire_cst_ln_invoice {
9943        // Codec=Cst (C-struct based), see doc to use other codecs
9944        fn cst_decode(self) -> crate::bindings::LNInvoice {
9945            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9946            CstDecode::<crate::bindings::LNInvoice>::cst_decode(*wrap).into()
9947        }
9948    }
9949    impl CstDecode<crate::bindings::LNOffer> for *mut wire_cst_ln_offer {
9950        // Codec=Cst (C-struct based), see doc to use other codecs
9951        fn cst_decode(self) -> crate::bindings::LNOffer {
9952            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9953            CstDecode::<crate::bindings::LNOffer>::cst_decode(*wrap).into()
9954        }
9955    }
9956    impl CstDecode<crate::bindings::LnUrlAuthRequestData> for *mut wire_cst_ln_url_auth_request_data {
9957        // Codec=Cst (C-struct based), see doc to use other codecs
9958        fn cst_decode(self) -> crate::bindings::LnUrlAuthRequestData {
9959            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9960            CstDecode::<crate::bindings::LnUrlAuthRequestData>::cst_decode(*wrap).into()
9961        }
9962    }
9963    impl CstDecode<crate::bindings::LnUrlErrorData> for *mut wire_cst_ln_url_error_data {
9964        // Codec=Cst (C-struct based), see doc to use other codecs
9965        fn cst_decode(self) -> crate::bindings::LnUrlErrorData {
9966            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9967            CstDecode::<crate::bindings::LnUrlErrorData>::cst_decode(*wrap).into()
9968        }
9969    }
9970    impl CstDecode<crate::model::LnUrlInfo> for *mut wire_cst_ln_url_info {
9971        // Codec=Cst (C-struct based), see doc to use other codecs
9972        fn cst_decode(self) -> crate::model::LnUrlInfo {
9973            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9974            CstDecode::<crate::model::LnUrlInfo>::cst_decode(*wrap).into()
9975        }
9976    }
9977    impl CstDecode<crate::bindings::LnUrlPayErrorData> for *mut wire_cst_ln_url_pay_error_data {
9978        // Codec=Cst (C-struct based), see doc to use other codecs
9979        fn cst_decode(self) -> crate::bindings::LnUrlPayErrorData {
9980            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9981            CstDecode::<crate::bindings::LnUrlPayErrorData>::cst_decode(*wrap).into()
9982        }
9983    }
9984    impl CstDecode<crate::model::LnUrlPayRequest> for *mut wire_cst_ln_url_pay_request {
9985        // Codec=Cst (C-struct based), see doc to use other codecs
9986        fn cst_decode(self) -> crate::model::LnUrlPayRequest {
9987            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9988            CstDecode::<crate::model::LnUrlPayRequest>::cst_decode(*wrap).into()
9989        }
9990    }
9991    impl CstDecode<crate::bindings::LnUrlPayRequestData> for *mut wire_cst_ln_url_pay_request_data {
9992        // Codec=Cst (C-struct based), see doc to use other codecs
9993        fn cst_decode(self) -> crate::bindings::LnUrlPayRequestData {
9994            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9995            CstDecode::<crate::bindings::LnUrlPayRequestData>::cst_decode(*wrap).into()
9996        }
9997    }
9998    impl CstDecode<crate::model::LnUrlPaySuccessData> for *mut wire_cst_ln_url_pay_success_data {
9999        // Codec=Cst (C-struct based), see doc to use other codecs
10000        fn cst_decode(self) -> crate::model::LnUrlPaySuccessData {
10001            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10002            CstDecode::<crate::model::LnUrlPaySuccessData>::cst_decode(*wrap).into()
10003        }
10004    }
10005    impl CstDecode<crate::bindings::LnUrlWithdrawRequest> for *mut wire_cst_ln_url_withdraw_request {
10006        // Codec=Cst (C-struct based), see doc to use other codecs
10007        fn cst_decode(self) -> crate::bindings::LnUrlWithdrawRequest {
10008            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10009            CstDecode::<crate::bindings::LnUrlWithdrawRequest>::cst_decode(*wrap).into()
10010        }
10011    }
10012    impl CstDecode<crate::bindings::LnUrlWithdrawRequestData>
10013        for *mut wire_cst_ln_url_withdraw_request_data
10014    {
10015        // Codec=Cst (C-struct based), see doc to use other codecs
10016        fn cst_decode(self) -> crate::bindings::LnUrlWithdrawRequestData {
10017            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10018            CstDecode::<crate::bindings::LnUrlWithdrawRequestData>::cst_decode(*wrap).into()
10019        }
10020    }
10021    impl CstDecode<crate::bindings::duplicates::LnUrlWithdrawSuccessData>
10022        for *mut wire_cst_ln_url_withdraw_success_data
10023    {
10024        // Codec=Cst (C-struct based), see doc to use other codecs
10025        fn cst_decode(self) -> crate::bindings::duplicates::LnUrlWithdrawSuccessData {
10026            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10027            CstDecode::<crate::bindings::duplicates::LnUrlWithdrawSuccessData>::cst_decode(*wrap)
10028                .into()
10029        }
10030    }
10031    impl CstDecode<crate::bindings::MessageSuccessActionData>
10032        for *mut wire_cst_message_success_action_data
10033    {
10034        // Codec=Cst (C-struct based), see doc to use other codecs
10035        fn cst_decode(self) -> crate::bindings::MessageSuccessActionData {
10036            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10037            CstDecode::<crate::bindings::MessageSuccessActionData>::cst_decode(*wrap).into()
10038        }
10039    }
10040    impl CstDecode<crate::model::PayAmount> for *mut wire_cst_pay_amount {
10041        // Codec=Cst (C-struct based), see doc to use other codecs
10042        fn cst_decode(self) -> crate::model::PayAmount {
10043            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10044            CstDecode::<crate::model::PayAmount>::cst_decode(*wrap).into()
10045        }
10046    }
10047    impl CstDecode<crate::model::PayOnchainRequest> for *mut wire_cst_pay_onchain_request {
10048        // Codec=Cst (C-struct based), see doc to use other codecs
10049        fn cst_decode(self) -> crate::model::PayOnchainRequest {
10050            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10051            CstDecode::<crate::model::PayOnchainRequest>::cst_decode(*wrap).into()
10052        }
10053    }
10054    impl CstDecode<crate::model::Payment> for *mut wire_cst_payment {
10055        // Codec=Cst (C-struct based), see doc to use other codecs
10056        fn cst_decode(self) -> crate::model::Payment {
10057            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10058            CstDecode::<crate::model::Payment>::cst_decode(*wrap).into()
10059        }
10060    }
10061    impl CstDecode<crate::model::PrepareBuyBitcoinRequest>
10062        for *mut wire_cst_prepare_buy_bitcoin_request
10063    {
10064        // Codec=Cst (C-struct based), see doc to use other codecs
10065        fn cst_decode(self) -> crate::model::PrepareBuyBitcoinRequest {
10066            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10067            CstDecode::<crate::model::PrepareBuyBitcoinRequest>::cst_decode(*wrap).into()
10068        }
10069    }
10070    impl CstDecode<crate::model::PrepareLnUrlPayRequest> for *mut wire_cst_prepare_ln_url_pay_request {
10071        // Codec=Cst (C-struct based), see doc to use other codecs
10072        fn cst_decode(self) -> crate::model::PrepareLnUrlPayRequest {
10073            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10074            CstDecode::<crate::model::PrepareLnUrlPayRequest>::cst_decode(*wrap).into()
10075        }
10076    }
10077    impl CstDecode<crate::model::PreparePayOnchainRequest>
10078        for *mut wire_cst_prepare_pay_onchain_request
10079    {
10080        // Codec=Cst (C-struct based), see doc to use other codecs
10081        fn cst_decode(self) -> crate::model::PreparePayOnchainRequest {
10082            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10083            CstDecode::<crate::model::PreparePayOnchainRequest>::cst_decode(*wrap).into()
10084        }
10085    }
10086    impl CstDecode<crate::model::PrepareReceiveRequest> for *mut wire_cst_prepare_receive_request {
10087        // Codec=Cst (C-struct based), see doc to use other codecs
10088        fn cst_decode(self) -> crate::model::PrepareReceiveRequest {
10089            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10090            CstDecode::<crate::model::PrepareReceiveRequest>::cst_decode(*wrap).into()
10091        }
10092    }
10093    impl CstDecode<crate::model::PrepareRefundRequest> for *mut wire_cst_prepare_refund_request {
10094        // Codec=Cst (C-struct based), see doc to use other codecs
10095        fn cst_decode(self) -> crate::model::PrepareRefundRequest {
10096            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10097            CstDecode::<crate::model::PrepareRefundRequest>::cst_decode(*wrap).into()
10098        }
10099    }
10100    impl CstDecode<crate::model::PrepareSendRequest> for *mut wire_cst_prepare_send_request {
10101        // Codec=Cst (C-struct based), see doc to use other codecs
10102        fn cst_decode(self) -> crate::model::PrepareSendRequest {
10103            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10104            CstDecode::<crate::model::PrepareSendRequest>::cst_decode(*wrap).into()
10105        }
10106    }
10107    impl CstDecode<crate::model::ReceiveAmount> for *mut wire_cst_receive_amount {
10108        // Codec=Cst (C-struct based), see doc to use other codecs
10109        fn cst_decode(self) -> crate::model::ReceiveAmount {
10110            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10111            CstDecode::<crate::model::ReceiveAmount>::cst_decode(*wrap).into()
10112        }
10113    }
10114    impl CstDecode<crate::model::ReceivePaymentRequest> for *mut wire_cst_receive_payment_request {
10115        // Codec=Cst (C-struct based), see doc to use other codecs
10116        fn cst_decode(self) -> crate::model::ReceivePaymentRequest {
10117            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10118            CstDecode::<crate::model::ReceivePaymentRequest>::cst_decode(*wrap).into()
10119        }
10120    }
10121    impl CstDecode<crate::model::RefundRequest> for *mut wire_cst_refund_request {
10122        // Codec=Cst (C-struct based), see doc to use other codecs
10123        fn cst_decode(self) -> crate::model::RefundRequest {
10124            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10125            CstDecode::<crate::model::RefundRequest>::cst_decode(*wrap).into()
10126        }
10127    }
10128    impl CstDecode<crate::model::RestoreRequest> for *mut wire_cst_restore_request {
10129        // Codec=Cst (C-struct based), see doc to use other codecs
10130        fn cst_decode(self) -> crate::model::RestoreRequest {
10131            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10132            CstDecode::<crate::model::RestoreRequest>::cst_decode(*wrap).into()
10133        }
10134    }
10135    impl CstDecode<crate::model::SdkEvent> for *mut wire_cst_sdk_event {
10136        // Codec=Cst (C-struct based), see doc to use other codecs
10137        fn cst_decode(self) -> crate::model::SdkEvent {
10138            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10139            CstDecode::<crate::model::SdkEvent>::cst_decode(*wrap).into()
10140        }
10141    }
10142    impl CstDecode<crate::model::SendPaymentRequest> for *mut wire_cst_send_payment_request {
10143        // Codec=Cst (C-struct based), see doc to use other codecs
10144        fn cst_decode(self) -> crate::model::SendPaymentRequest {
10145            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10146            CstDecode::<crate::model::SendPaymentRequest>::cst_decode(*wrap).into()
10147        }
10148    }
10149    impl CstDecode<crate::model::SignMessageRequest> for *mut wire_cst_sign_message_request {
10150        // Codec=Cst (C-struct based), see doc to use other codecs
10151        fn cst_decode(self) -> crate::model::SignMessageRequest {
10152            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10153            CstDecode::<crate::model::SignMessageRequest>::cst_decode(*wrap).into()
10154        }
10155    }
10156    impl CstDecode<crate::bindings::SuccessAction> for *mut wire_cst_success_action {
10157        // Codec=Cst (C-struct based), see doc to use other codecs
10158        fn cst_decode(self) -> crate::bindings::SuccessAction {
10159            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10160            CstDecode::<crate::bindings::SuccessAction>::cst_decode(*wrap).into()
10161        }
10162    }
10163    impl CstDecode<crate::bindings::SuccessActionProcessed> for *mut wire_cst_success_action_processed {
10164        // Codec=Cst (C-struct based), see doc to use other codecs
10165        fn cst_decode(self) -> crate::bindings::SuccessActionProcessed {
10166            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10167            CstDecode::<crate::bindings::SuccessActionProcessed>::cst_decode(*wrap).into()
10168        }
10169    }
10170    impl CstDecode<crate::bindings::Symbol> for *mut wire_cst_symbol {
10171        // Codec=Cst (C-struct based), see doc to use other codecs
10172        fn cst_decode(self) -> crate::bindings::Symbol {
10173            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10174            CstDecode::<crate::bindings::Symbol>::cst_decode(*wrap).into()
10175        }
10176    }
10177    impl CstDecode<u32> for *mut u32 {
10178        // Codec=Cst (C-struct based), see doc to use other codecs
10179        fn cst_decode(self) -> u32 {
10180            unsafe { *flutter_rust_bridge::for_generated::box_from_leak_ptr(self) }
10181        }
10182    }
10183    impl CstDecode<u64> for *mut u64 {
10184        // Codec=Cst (C-struct based), see doc to use other codecs
10185        fn cst_decode(self) -> u64 {
10186            unsafe { *flutter_rust_bridge::for_generated::box_from_leak_ptr(self) }
10187        }
10188    }
10189    impl CstDecode<crate::bindings::UrlSuccessActionData> for *mut wire_cst_url_success_action_data {
10190        // Codec=Cst (C-struct based), see doc to use other codecs
10191        fn cst_decode(self) -> crate::bindings::UrlSuccessActionData {
10192            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10193            CstDecode::<crate::bindings::UrlSuccessActionData>::cst_decode(*wrap).into()
10194        }
10195    }
10196    impl CstDecode<crate::model::BuyBitcoinRequest> for wire_cst_buy_bitcoin_request {
10197        // Codec=Cst (C-struct based), see doc to use other codecs
10198        fn cst_decode(self) -> crate::model::BuyBitcoinRequest {
10199            crate::model::BuyBitcoinRequest {
10200                prepare_response: self.prepare_response.cst_decode(),
10201                redirect_url: self.redirect_url.cst_decode(),
10202            }
10203        }
10204    }
10205    impl CstDecode<crate::model::CheckMessageRequest> for wire_cst_check_message_request {
10206        // Codec=Cst (C-struct based), see doc to use other codecs
10207        fn cst_decode(self) -> crate::model::CheckMessageRequest {
10208            crate::model::CheckMessageRequest {
10209                message: self.message.cst_decode(),
10210                pubkey: self.pubkey.cst_decode(),
10211                signature: self.signature.cst_decode(),
10212            }
10213        }
10214    }
10215    impl CstDecode<crate::model::CheckMessageResponse> for wire_cst_check_message_response {
10216        // Codec=Cst (C-struct based), see doc to use other codecs
10217        fn cst_decode(self) -> crate::model::CheckMessageResponse {
10218            crate::model::CheckMessageResponse {
10219                is_valid: self.is_valid.cst_decode(),
10220            }
10221        }
10222    }
10223    impl CstDecode<crate::model::Config> for wire_cst_config {
10224        // Codec=Cst (C-struct based), see doc to use other codecs
10225        fn cst_decode(self) -> crate::model::Config {
10226            crate::model::Config {
10227                liquid_explorer: self.liquid_explorer.cst_decode(),
10228                bitcoin_explorer: self.bitcoin_explorer.cst_decode(),
10229                working_dir: self.working_dir.cst_decode(),
10230                cache_dir: self.cache_dir.cst_decode(),
10231                network: self.network.cst_decode(),
10232                payment_timeout_sec: self.payment_timeout_sec.cst_decode(),
10233                sync_service_url: self.sync_service_url.cst_decode(),
10234                zero_conf_max_amount_sat: self.zero_conf_max_amount_sat.cst_decode(),
10235                breez_api_key: self.breez_api_key.cst_decode(),
10236                external_input_parsers: self.external_input_parsers.cst_decode(),
10237                use_default_external_input_parsers: self
10238                    .use_default_external_input_parsers
10239                    .cst_decode(),
10240                onchain_fee_rate_leeway_sat_per_vbyte: self
10241                    .onchain_fee_rate_leeway_sat_per_vbyte
10242                    .cst_decode(),
10243                asset_metadata: self.asset_metadata.cst_decode(),
10244                sideswap_api_key: self.sideswap_api_key.cst_decode(),
10245            }
10246        }
10247    }
10248    impl CstDecode<crate::model::ConnectRequest> for wire_cst_connect_request {
10249        // Codec=Cst (C-struct based), see doc to use other codecs
10250        fn cst_decode(self) -> crate::model::ConnectRequest {
10251            crate::model::ConnectRequest {
10252                config: self.config.cst_decode(),
10253                mnemonic: self.mnemonic.cst_decode(),
10254                passphrase: self.passphrase.cst_decode(),
10255                seed: self.seed.cst_decode(),
10256            }
10257        }
10258    }
10259    impl CstDecode<crate::model::CreateBolt12InvoiceRequest>
10260        for wire_cst_create_bolt_12_invoice_request
10261    {
10262        // Codec=Cst (C-struct based), see doc to use other codecs
10263        fn cst_decode(self) -> crate::model::CreateBolt12InvoiceRequest {
10264            crate::model::CreateBolt12InvoiceRequest {
10265                offer: self.offer.cst_decode(),
10266                invoice_request: self.invoice_request.cst_decode(),
10267            }
10268        }
10269    }
10270    impl CstDecode<crate::model::CreateBolt12InvoiceResponse>
10271        for wire_cst_create_bolt_12_invoice_response
10272    {
10273        // Codec=Cst (C-struct based), see doc to use other codecs
10274        fn cst_decode(self) -> crate::model::CreateBolt12InvoiceResponse {
10275            crate::model::CreateBolt12InvoiceResponse {
10276                invoice: self.invoice.cst_decode(),
10277            }
10278        }
10279    }
10280    impl CstDecode<crate::bindings::CurrencyInfo> for wire_cst_currency_info {
10281        // Codec=Cst (C-struct based), see doc to use other codecs
10282        fn cst_decode(self) -> crate::bindings::CurrencyInfo {
10283            crate::bindings::CurrencyInfo {
10284                name: self.name.cst_decode(),
10285                fraction_size: self.fraction_size.cst_decode(),
10286                spacing: self.spacing.cst_decode(),
10287                symbol: self.symbol.cst_decode(),
10288                uniq_symbol: self.uniq_symbol.cst_decode(),
10289                localized_name: self.localized_name.cst_decode(),
10290                locale_overrides: self.locale_overrides.cst_decode(),
10291            }
10292        }
10293    }
10294    impl CstDecode<crate::bindings::ExternalInputParser> for wire_cst_external_input_parser {
10295        // Codec=Cst (C-struct based), see doc to use other codecs
10296        fn cst_decode(self) -> crate::bindings::ExternalInputParser {
10297            crate::bindings::ExternalInputParser {
10298                provider_id: self.provider_id.cst_decode(),
10299                input_regex: self.input_regex.cst_decode(),
10300                parser_url: self.parser_url.cst_decode(),
10301            }
10302        }
10303    }
10304    impl CstDecode<crate::model::FetchPaymentProposedFeesRequest>
10305        for wire_cst_fetch_payment_proposed_fees_request
10306    {
10307        // Codec=Cst (C-struct based), see doc to use other codecs
10308        fn cst_decode(self) -> crate::model::FetchPaymentProposedFeesRequest {
10309            crate::model::FetchPaymentProposedFeesRequest {
10310                swap_id: self.swap_id.cst_decode(),
10311            }
10312        }
10313    }
10314    impl CstDecode<crate::model::FetchPaymentProposedFeesResponse>
10315        for wire_cst_fetch_payment_proposed_fees_response
10316    {
10317        // Codec=Cst (C-struct based), see doc to use other codecs
10318        fn cst_decode(self) -> crate::model::FetchPaymentProposedFeesResponse {
10319            crate::model::FetchPaymentProposedFeesResponse {
10320                swap_id: self.swap_id.cst_decode(),
10321                fees_sat: self.fees_sat.cst_decode(),
10322                payer_amount_sat: self.payer_amount_sat.cst_decode(),
10323                receiver_amount_sat: self.receiver_amount_sat.cst_decode(),
10324            }
10325        }
10326    }
10327    impl CstDecode<crate::bindings::FiatCurrency> for wire_cst_fiat_currency {
10328        // Codec=Cst (C-struct based), see doc to use other codecs
10329        fn cst_decode(self) -> crate::bindings::FiatCurrency {
10330            crate::bindings::FiatCurrency {
10331                id: self.id.cst_decode(),
10332                info: self.info.cst_decode(),
10333            }
10334        }
10335    }
10336    impl CstDecode<crate::model::GetInfoResponse> for wire_cst_get_info_response {
10337        // Codec=Cst (C-struct based), see doc to use other codecs
10338        fn cst_decode(self) -> crate::model::GetInfoResponse {
10339            crate::model::GetInfoResponse {
10340                wallet_info: self.wallet_info.cst_decode(),
10341                blockchain_info: self.blockchain_info.cst_decode(),
10342            }
10343        }
10344    }
10345    impl CstDecode<crate::model::GetPaymentRequest> for wire_cst_get_payment_request {
10346        // Codec=Cst (C-struct based), see doc to use other codecs
10347        fn cst_decode(self) -> crate::model::GetPaymentRequest {
10348            match self.tag {
10349                0 => {
10350                    let ans = unsafe { self.kind.PaymentHash };
10351                    crate::model::GetPaymentRequest::PaymentHash {
10352                        payment_hash: ans.payment_hash.cst_decode(),
10353                    }
10354                }
10355                1 => {
10356                    let ans = unsafe { self.kind.SwapId };
10357                    crate::model::GetPaymentRequest::SwapId {
10358                        swap_id: ans.swap_id.cst_decode(),
10359                    }
10360                }
10361                _ => unreachable!(),
10362            }
10363        }
10364    }
10365    impl CstDecode<crate::bindings::InputType> for wire_cst_input_type {
10366        // Codec=Cst (C-struct based), see doc to use other codecs
10367        fn cst_decode(self) -> crate::bindings::InputType {
10368            match self.tag {
10369                0 => {
10370                    let ans = unsafe { self.kind.BitcoinAddress };
10371                    crate::bindings::InputType::BitcoinAddress {
10372                        address: ans.address.cst_decode(),
10373                    }
10374                }
10375                1 => {
10376                    let ans = unsafe { self.kind.LiquidAddress };
10377                    crate::bindings::InputType::LiquidAddress {
10378                        address: ans.address.cst_decode(),
10379                    }
10380                }
10381                2 => {
10382                    let ans = unsafe { self.kind.Bolt11 };
10383                    crate::bindings::InputType::Bolt11 {
10384                        invoice: ans.invoice.cst_decode(),
10385                    }
10386                }
10387                3 => {
10388                    let ans = unsafe { self.kind.Bolt12Offer };
10389                    crate::bindings::InputType::Bolt12Offer {
10390                        offer: ans.offer.cst_decode(),
10391                        bip353_address: ans.bip353_address.cst_decode(),
10392                    }
10393                }
10394                4 => {
10395                    let ans = unsafe { self.kind.NodeId };
10396                    crate::bindings::InputType::NodeId {
10397                        node_id: ans.node_id.cst_decode(),
10398                    }
10399                }
10400                5 => {
10401                    let ans = unsafe { self.kind.Url };
10402                    crate::bindings::InputType::Url {
10403                        url: ans.url.cst_decode(),
10404                    }
10405                }
10406                6 => {
10407                    let ans = unsafe { self.kind.LnUrlPay };
10408                    crate::bindings::InputType::LnUrlPay {
10409                        data: ans.data.cst_decode(),
10410                        bip353_address: ans.bip353_address.cst_decode(),
10411                    }
10412                }
10413                7 => {
10414                    let ans = unsafe { self.kind.LnUrlWithdraw };
10415                    crate::bindings::InputType::LnUrlWithdraw {
10416                        data: ans.data.cst_decode(),
10417                    }
10418                }
10419                8 => {
10420                    let ans = unsafe { self.kind.LnUrlAuth };
10421                    crate::bindings::InputType::LnUrlAuth {
10422                        data: ans.data.cst_decode(),
10423                    }
10424                }
10425                9 => {
10426                    let ans = unsafe { self.kind.LnUrlError };
10427                    crate::bindings::InputType::LnUrlError {
10428                        data: ans.data.cst_decode(),
10429                    }
10430                }
10431                _ => unreachable!(),
10432            }
10433        }
10434    }
10435    impl CstDecode<crate::model::LightningPaymentLimitsResponse>
10436        for wire_cst_lightning_payment_limits_response
10437    {
10438        // Codec=Cst (C-struct based), see doc to use other codecs
10439        fn cst_decode(self) -> crate::model::LightningPaymentLimitsResponse {
10440            crate::model::LightningPaymentLimitsResponse {
10441                send: self.send.cst_decode(),
10442                receive: self.receive.cst_decode(),
10443            }
10444        }
10445    }
10446    impl CstDecode<crate::model::Limits> for wire_cst_limits {
10447        // Codec=Cst (C-struct based), see doc to use other codecs
10448        fn cst_decode(self) -> crate::model::Limits {
10449            crate::model::Limits {
10450                min_sat: self.min_sat.cst_decode(),
10451                max_sat: self.max_sat.cst_decode(),
10452                max_zero_conf_sat: self.max_zero_conf_sat.cst_decode(),
10453            }
10454        }
10455    }
10456    impl CstDecode<crate::bindings::LiquidAddressData> for wire_cst_liquid_address_data {
10457        // Codec=Cst (C-struct based), see doc to use other codecs
10458        fn cst_decode(self) -> crate::bindings::LiquidAddressData {
10459            crate::bindings::LiquidAddressData {
10460                address: self.address.cst_decode(),
10461                network: self.network.cst_decode(),
10462                asset_id: self.asset_id.cst_decode(),
10463                amount: self.amount.cst_decode(),
10464                amount_sat: self.amount_sat.cst_decode(),
10465                label: self.label.cst_decode(),
10466                message: self.message.cst_decode(),
10467            }
10468        }
10469    }
10470    impl CstDecode<Vec<String>> for *mut wire_cst_list_String {
10471        // Codec=Cst (C-struct based), see doc to use other codecs
10472        fn cst_decode(self) -> Vec<String> {
10473            let vec = unsafe {
10474                let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10475                flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10476            };
10477            vec.into_iter().map(CstDecode::cst_decode).collect()
10478        }
10479    }
10480    impl CstDecode<Vec<crate::model::AssetBalance>> for *mut wire_cst_list_asset_balance {
10481        // Codec=Cst (C-struct based), see doc to use other codecs
10482        fn cst_decode(self) -> Vec<crate::model::AssetBalance> {
10483            let vec = unsafe {
10484                let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10485                flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10486            };
10487            vec.into_iter().map(CstDecode::cst_decode).collect()
10488        }
10489    }
10490    impl CstDecode<Vec<crate::model::AssetMetadata>> for *mut wire_cst_list_asset_metadata {
10491        // Codec=Cst (C-struct based), see doc to use other codecs
10492        fn cst_decode(self) -> Vec<crate::model::AssetMetadata> {
10493            let vec = unsafe {
10494                let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10495                flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10496            };
10497            vec.into_iter().map(CstDecode::cst_decode).collect()
10498        }
10499    }
10500    impl CstDecode<Vec<crate::bindings::ExternalInputParser>>
10501        for *mut wire_cst_list_external_input_parser
10502    {
10503        // Codec=Cst (C-struct based), see doc to use other codecs
10504        fn cst_decode(self) -> Vec<crate::bindings::ExternalInputParser> {
10505            let vec = unsafe {
10506                let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10507                flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10508            };
10509            vec.into_iter().map(CstDecode::cst_decode).collect()
10510        }
10511    }
10512    impl CstDecode<Vec<crate::bindings::FiatCurrency>> for *mut wire_cst_list_fiat_currency {
10513        // Codec=Cst (C-struct based), see doc to use other codecs
10514        fn cst_decode(self) -> Vec<crate::bindings::FiatCurrency> {
10515            let vec = unsafe {
10516                let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10517                flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10518            };
10519            vec.into_iter().map(CstDecode::cst_decode).collect()
10520        }
10521    }
10522    impl CstDecode<Vec<crate::bindings::LnOfferBlindedPath>>
10523        for *mut wire_cst_list_ln_offer_blinded_path
10524    {
10525        // Codec=Cst (C-struct based), see doc to use other codecs
10526        fn cst_decode(self) -> Vec<crate::bindings::LnOfferBlindedPath> {
10527            let vec = unsafe {
10528                let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10529                flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10530            };
10531            vec.into_iter().map(CstDecode::cst_decode).collect()
10532        }
10533    }
10534    impl CstDecode<Vec<crate::bindings::LocaleOverrides>> for *mut wire_cst_list_locale_overrides {
10535        // Codec=Cst (C-struct based), see doc to use other codecs
10536        fn cst_decode(self) -> Vec<crate::bindings::LocaleOverrides> {
10537            let vec = unsafe {
10538                let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10539                flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10540            };
10541            vec.into_iter().map(CstDecode::cst_decode).collect()
10542        }
10543    }
10544    impl CstDecode<Vec<crate::bindings::LocalizedName>> for *mut wire_cst_list_localized_name {
10545        // Codec=Cst (C-struct based), see doc to use other codecs
10546        fn cst_decode(self) -> Vec<crate::bindings::LocalizedName> {
10547            let vec = unsafe {
10548                let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10549                flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10550            };
10551            vec.into_iter().map(CstDecode::cst_decode).collect()
10552        }
10553    }
10554    impl CstDecode<Vec<crate::model::Payment>> for *mut wire_cst_list_payment {
10555        // Codec=Cst (C-struct based), see doc to use other codecs
10556        fn cst_decode(self) -> Vec<crate::model::Payment> {
10557            let vec = unsafe {
10558                let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10559                flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10560            };
10561            vec.into_iter().map(CstDecode::cst_decode).collect()
10562        }
10563    }
10564    impl CstDecode<crate::model::ListPaymentDetails> for wire_cst_list_payment_details {
10565        // Codec=Cst (C-struct based), see doc to use other codecs
10566        fn cst_decode(self) -> crate::model::ListPaymentDetails {
10567            match self.tag {
10568                0 => {
10569                    let ans = unsafe { self.kind.Liquid };
10570                    crate::model::ListPaymentDetails::Liquid {
10571                        asset_id: ans.asset_id.cst_decode(),
10572                        destination: ans.destination.cst_decode(),
10573                    }
10574                }
10575                1 => {
10576                    let ans = unsafe { self.kind.Bitcoin };
10577                    crate::model::ListPaymentDetails::Bitcoin {
10578                        address: ans.address.cst_decode(),
10579                    }
10580                }
10581                _ => unreachable!(),
10582            }
10583        }
10584    }
10585    impl CstDecode<Vec<crate::model::PaymentState>> for *mut wire_cst_list_payment_state {
10586        // Codec=Cst (C-struct based), see doc to use other codecs
10587        fn cst_decode(self) -> Vec<crate::model::PaymentState> {
10588            let vec = unsafe {
10589                let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10590                flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10591            };
10592            vec.into_iter().map(CstDecode::cst_decode).collect()
10593        }
10594    }
10595    impl CstDecode<Vec<crate::model::PaymentType>> for *mut wire_cst_list_payment_type {
10596        // Codec=Cst (C-struct based), see doc to use other codecs
10597        fn cst_decode(self) -> Vec<crate::model::PaymentType> {
10598            let vec = unsafe {
10599                let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10600                flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10601            };
10602            vec.into_iter().map(CstDecode::cst_decode).collect()
10603        }
10604    }
10605    impl CstDecode<crate::model::ListPaymentsRequest> for wire_cst_list_payments_request {
10606        // Codec=Cst (C-struct based), see doc to use other codecs
10607        fn cst_decode(self) -> crate::model::ListPaymentsRequest {
10608            crate::model::ListPaymentsRequest {
10609                filters: self.filters.cst_decode(),
10610                states: self.states.cst_decode(),
10611                from_timestamp: self.from_timestamp.cst_decode(),
10612                to_timestamp: self.to_timestamp.cst_decode(),
10613                offset: self.offset.cst_decode(),
10614                limit: self.limit.cst_decode(),
10615                details: self.details.cst_decode(),
10616                sort_ascending: self.sort_ascending.cst_decode(),
10617            }
10618        }
10619    }
10620    impl CstDecode<Vec<u8>> for *mut wire_cst_list_prim_u_8_strict {
10621        // Codec=Cst (C-struct based), see doc to use other codecs
10622        fn cst_decode(self) -> Vec<u8> {
10623            unsafe {
10624                let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10625                flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10626            }
10627        }
10628    }
10629    impl CstDecode<Vec<crate::bindings::Rate>> for *mut wire_cst_list_rate {
10630        // Codec=Cst (C-struct based), see doc to use other codecs
10631        fn cst_decode(self) -> Vec<crate::bindings::Rate> {
10632            let vec = unsafe {
10633                let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10634                flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10635            };
10636            vec.into_iter().map(CstDecode::cst_decode).collect()
10637        }
10638    }
10639    impl CstDecode<Vec<crate::model::RefundableSwap>> for *mut wire_cst_list_refundable_swap {
10640        // Codec=Cst (C-struct based), see doc to use other codecs
10641        fn cst_decode(self) -> Vec<crate::model::RefundableSwap> {
10642            let vec = unsafe {
10643                let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10644                flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10645            };
10646            vec.into_iter().map(CstDecode::cst_decode).collect()
10647        }
10648    }
10649    impl CstDecode<Vec<crate::bindings::RouteHint>> for *mut wire_cst_list_route_hint {
10650        // Codec=Cst (C-struct based), see doc to use other codecs
10651        fn cst_decode(self) -> Vec<crate::bindings::RouteHint> {
10652            let vec = unsafe {
10653                let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10654                flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10655            };
10656            vec.into_iter().map(CstDecode::cst_decode).collect()
10657        }
10658    }
10659    impl CstDecode<Vec<crate::bindings::RouteHintHop>> for *mut wire_cst_list_route_hint_hop {
10660        // Codec=Cst (C-struct based), see doc to use other codecs
10661        fn cst_decode(self) -> Vec<crate::bindings::RouteHintHop> {
10662            let vec = unsafe {
10663                let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10664                flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10665            };
10666            vec.into_iter().map(CstDecode::cst_decode).collect()
10667        }
10668    }
10669    impl CstDecode<crate::bindings::LNInvoice> for wire_cst_ln_invoice {
10670        // Codec=Cst (C-struct based), see doc to use other codecs
10671        fn cst_decode(self) -> crate::bindings::LNInvoice {
10672            crate::bindings::LNInvoice {
10673                bolt11: self.bolt11.cst_decode(),
10674                network: self.network.cst_decode(),
10675                payee_pubkey: self.payee_pubkey.cst_decode(),
10676                payment_hash: self.payment_hash.cst_decode(),
10677                description: self.description.cst_decode(),
10678                description_hash: self.description_hash.cst_decode(),
10679                amount_msat: self.amount_msat.cst_decode(),
10680                timestamp: self.timestamp.cst_decode(),
10681                expiry: self.expiry.cst_decode(),
10682                routing_hints: self.routing_hints.cst_decode(),
10683                payment_secret: self.payment_secret.cst_decode(),
10684                min_final_cltv_expiry_delta: self.min_final_cltv_expiry_delta.cst_decode(),
10685            }
10686        }
10687    }
10688    impl CstDecode<crate::bindings::LNOffer> for wire_cst_ln_offer {
10689        // Codec=Cst (C-struct based), see doc to use other codecs
10690        fn cst_decode(self) -> crate::bindings::LNOffer {
10691            crate::bindings::LNOffer {
10692                offer: self.offer.cst_decode(),
10693                chains: self.chains.cst_decode(),
10694                min_amount: self.min_amount.cst_decode(),
10695                description: self.description.cst_decode(),
10696                absolute_expiry: self.absolute_expiry.cst_decode(),
10697                issuer: self.issuer.cst_decode(),
10698                signing_pubkey: self.signing_pubkey.cst_decode(),
10699                paths: self.paths.cst_decode(),
10700            }
10701        }
10702    }
10703    impl CstDecode<crate::bindings::LnOfferBlindedPath> for wire_cst_ln_offer_blinded_path {
10704        // Codec=Cst (C-struct based), see doc to use other codecs
10705        fn cst_decode(self) -> crate::bindings::LnOfferBlindedPath {
10706            crate::bindings::LnOfferBlindedPath {
10707                blinded_hops: self.blinded_hops.cst_decode(),
10708            }
10709        }
10710    }
10711    impl CstDecode<crate::bindings::duplicates::LnUrlAuthError> for wire_cst_ln_url_auth_error {
10712        // Codec=Cst (C-struct based), see doc to use other codecs
10713        fn cst_decode(self) -> crate::bindings::duplicates::LnUrlAuthError {
10714            match self.tag {
10715                0 => {
10716                    let ans = unsafe { self.kind.Generic };
10717                    crate::bindings::duplicates::LnUrlAuthError::Generic {
10718                        err: ans.err.cst_decode(),
10719                    }
10720                }
10721                1 => {
10722                    let ans = unsafe { self.kind.InvalidUri };
10723                    crate::bindings::duplicates::LnUrlAuthError::InvalidUri {
10724                        err: ans.err.cst_decode(),
10725                    }
10726                }
10727                2 => {
10728                    let ans = unsafe { self.kind.ServiceConnectivity };
10729                    crate::bindings::duplicates::LnUrlAuthError::ServiceConnectivity {
10730                        err: ans.err.cst_decode(),
10731                    }
10732                }
10733                _ => unreachable!(),
10734            }
10735        }
10736    }
10737    impl CstDecode<crate::bindings::LnUrlAuthRequestData> for wire_cst_ln_url_auth_request_data {
10738        // Codec=Cst (C-struct based), see doc to use other codecs
10739        fn cst_decode(self) -> crate::bindings::LnUrlAuthRequestData {
10740            crate::bindings::LnUrlAuthRequestData {
10741                k1: self.k1.cst_decode(),
10742                action: self.action.cst_decode(),
10743                domain: self.domain.cst_decode(),
10744                url: self.url.cst_decode(),
10745            }
10746        }
10747    }
10748    impl CstDecode<crate::bindings::duplicates::LnUrlCallbackStatus>
10749        for wire_cst_ln_url_callback_status
10750    {
10751        // Codec=Cst (C-struct based), see doc to use other codecs
10752        fn cst_decode(self) -> crate::bindings::duplicates::LnUrlCallbackStatus {
10753            match self.tag {
10754                0 => crate::bindings::duplicates::LnUrlCallbackStatus::Ok,
10755                1 => {
10756                    let ans = unsafe { self.kind.ErrorStatus };
10757                    crate::bindings::duplicates::LnUrlCallbackStatus::ErrorStatus {
10758                        data: ans.data.cst_decode(),
10759                    }
10760                }
10761                _ => unreachable!(),
10762            }
10763        }
10764    }
10765    impl CstDecode<crate::bindings::LnUrlErrorData> for wire_cst_ln_url_error_data {
10766        // Codec=Cst (C-struct based), see doc to use other codecs
10767        fn cst_decode(self) -> crate::bindings::LnUrlErrorData {
10768            crate::bindings::LnUrlErrorData {
10769                reason: self.reason.cst_decode(),
10770            }
10771        }
10772    }
10773    impl CstDecode<crate::model::LnUrlInfo> for wire_cst_ln_url_info {
10774        // Codec=Cst (C-struct based), see doc to use other codecs
10775        fn cst_decode(self) -> crate::model::LnUrlInfo {
10776            crate::model::LnUrlInfo {
10777                ln_address: self.ln_address.cst_decode(),
10778                lnurl_pay_comment: self.lnurl_pay_comment.cst_decode(),
10779                lnurl_pay_domain: self.lnurl_pay_domain.cst_decode(),
10780                lnurl_pay_metadata: self.lnurl_pay_metadata.cst_decode(),
10781                lnurl_pay_success_action: self.lnurl_pay_success_action.cst_decode(),
10782                lnurl_pay_unprocessed_success_action: self
10783                    .lnurl_pay_unprocessed_success_action
10784                    .cst_decode(),
10785                lnurl_withdraw_endpoint: self.lnurl_withdraw_endpoint.cst_decode(),
10786            }
10787        }
10788    }
10789    impl CstDecode<crate::bindings::duplicates::LnUrlPayError> for wire_cst_ln_url_pay_error {
10790        // Codec=Cst (C-struct based), see doc to use other codecs
10791        fn cst_decode(self) -> crate::bindings::duplicates::LnUrlPayError {
10792            match self.tag {
10793                0 => crate::bindings::duplicates::LnUrlPayError::AlreadyPaid,
10794                1 => {
10795                    let ans = unsafe { self.kind.Generic };
10796                    crate::bindings::duplicates::LnUrlPayError::Generic {
10797                        err: ans.err.cst_decode(),
10798                    }
10799                }
10800                2 => {
10801                    let ans = unsafe { self.kind.InsufficientBalance };
10802                    crate::bindings::duplicates::LnUrlPayError::InsufficientBalance {
10803                        err: ans.err.cst_decode(),
10804                    }
10805                }
10806                3 => {
10807                    let ans = unsafe { self.kind.InvalidAmount };
10808                    crate::bindings::duplicates::LnUrlPayError::InvalidAmount {
10809                        err: ans.err.cst_decode(),
10810                    }
10811                }
10812                4 => {
10813                    let ans = unsafe { self.kind.InvalidInvoice };
10814                    crate::bindings::duplicates::LnUrlPayError::InvalidInvoice {
10815                        err: ans.err.cst_decode(),
10816                    }
10817                }
10818                5 => {
10819                    let ans = unsafe { self.kind.InvalidNetwork };
10820                    crate::bindings::duplicates::LnUrlPayError::InvalidNetwork {
10821                        err: ans.err.cst_decode(),
10822                    }
10823                }
10824                6 => {
10825                    let ans = unsafe { self.kind.InvalidUri };
10826                    crate::bindings::duplicates::LnUrlPayError::InvalidUri {
10827                        err: ans.err.cst_decode(),
10828                    }
10829                }
10830                7 => {
10831                    let ans = unsafe { self.kind.InvoiceExpired };
10832                    crate::bindings::duplicates::LnUrlPayError::InvoiceExpired {
10833                        err: ans.err.cst_decode(),
10834                    }
10835                }
10836                8 => {
10837                    let ans = unsafe { self.kind.PaymentFailed };
10838                    crate::bindings::duplicates::LnUrlPayError::PaymentFailed {
10839                        err: ans.err.cst_decode(),
10840                    }
10841                }
10842                9 => {
10843                    let ans = unsafe { self.kind.PaymentTimeout };
10844                    crate::bindings::duplicates::LnUrlPayError::PaymentTimeout {
10845                        err: ans.err.cst_decode(),
10846                    }
10847                }
10848                10 => {
10849                    let ans = unsafe { self.kind.RouteNotFound };
10850                    crate::bindings::duplicates::LnUrlPayError::RouteNotFound {
10851                        err: ans.err.cst_decode(),
10852                    }
10853                }
10854                11 => {
10855                    let ans = unsafe { self.kind.RouteTooExpensive };
10856                    crate::bindings::duplicates::LnUrlPayError::RouteTooExpensive {
10857                        err: ans.err.cst_decode(),
10858                    }
10859                }
10860                12 => {
10861                    let ans = unsafe { self.kind.ServiceConnectivity };
10862                    crate::bindings::duplicates::LnUrlPayError::ServiceConnectivity {
10863                        err: ans.err.cst_decode(),
10864                    }
10865                }
10866                _ => unreachable!(),
10867            }
10868        }
10869    }
10870    impl CstDecode<crate::bindings::LnUrlPayErrorData> for wire_cst_ln_url_pay_error_data {
10871        // Codec=Cst (C-struct based), see doc to use other codecs
10872        fn cst_decode(self) -> crate::bindings::LnUrlPayErrorData {
10873            crate::bindings::LnUrlPayErrorData {
10874                payment_hash: self.payment_hash.cst_decode(),
10875                reason: self.reason.cst_decode(),
10876            }
10877        }
10878    }
10879    impl CstDecode<crate::model::LnUrlPayRequest> for wire_cst_ln_url_pay_request {
10880        // Codec=Cst (C-struct based), see doc to use other codecs
10881        fn cst_decode(self) -> crate::model::LnUrlPayRequest {
10882            crate::model::LnUrlPayRequest {
10883                prepare_response: self.prepare_response.cst_decode(),
10884            }
10885        }
10886    }
10887    impl CstDecode<crate::bindings::LnUrlPayRequestData> for wire_cst_ln_url_pay_request_data {
10888        // Codec=Cst (C-struct based), see doc to use other codecs
10889        fn cst_decode(self) -> crate::bindings::LnUrlPayRequestData {
10890            crate::bindings::LnUrlPayRequestData {
10891                callback: self.callback.cst_decode(),
10892                min_sendable: self.min_sendable.cst_decode(),
10893                max_sendable: self.max_sendable.cst_decode(),
10894                metadata_str: self.metadata_str.cst_decode(),
10895                comment_allowed: self.comment_allowed.cst_decode(),
10896                domain: self.domain.cst_decode(),
10897                allows_nostr: self.allows_nostr.cst_decode(),
10898                nostr_pubkey: self.nostr_pubkey.cst_decode(),
10899                ln_address: self.ln_address.cst_decode(),
10900            }
10901        }
10902    }
10903    impl CstDecode<crate::model::LnUrlPayResult> for wire_cst_ln_url_pay_result {
10904        // Codec=Cst (C-struct based), see doc to use other codecs
10905        fn cst_decode(self) -> crate::model::LnUrlPayResult {
10906            match self.tag {
10907                0 => {
10908                    let ans = unsafe { self.kind.EndpointSuccess };
10909                    crate::model::LnUrlPayResult::EndpointSuccess {
10910                        data: ans.data.cst_decode(),
10911                    }
10912                }
10913                1 => {
10914                    let ans = unsafe { self.kind.EndpointError };
10915                    crate::model::LnUrlPayResult::EndpointError {
10916                        data: ans.data.cst_decode(),
10917                    }
10918                }
10919                2 => {
10920                    let ans = unsafe { self.kind.PayError };
10921                    crate::model::LnUrlPayResult::PayError {
10922                        data: ans.data.cst_decode(),
10923                    }
10924                }
10925                _ => unreachable!(),
10926            }
10927        }
10928    }
10929    impl CstDecode<crate::model::LnUrlPaySuccessData> for wire_cst_ln_url_pay_success_data {
10930        // Codec=Cst (C-struct based), see doc to use other codecs
10931        fn cst_decode(self) -> crate::model::LnUrlPaySuccessData {
10932            crate::model::LnUrlPaySuccessData {
10933                payment: self.payment.cst_decode(),
10934                success_action: self.success_action.cst_decode(),
10935            }
10936        }
10937    }
10938    impl CstDecode<crate::bindings::duplicates::LnUrlWithdrawError> for wire_cst_ln_url_withdraw_error {
10939        // Codec=Cst (C-struct based), see doc to use other codecs
10940        fn cst_decode(self) -> crate::bindings::duplicates::LnUrlWithdrawError {
10941            match self.tag {
10942                0 => {
10943                    let ans = unsafe { self.kind.Generic };
10944                    crate::bindings::duplicates::LnUrlWithdrawError::Generic {
10945                        err: ans.err.cst_decode(),
10946                    }
10947                }
10948                1 => {
10949                    let ans = unsafe { self.kind.InvalidAmount };
10950                    crate::bindings::duplicates::LnUrlWithdrawError::InvalidAmount {
10951                        err: ans.err.cst_decode(),
10952                    }
10953                }
10954                2 => {
10955                    let ans = unsafe { self.kind.InvalidInvoice };
10956                    crate::bindings::duplicates::LnUrlWithdrawError::InvalidInvoice {
10957                        err: ans.err.cst_decode(),
10958                    }
10959                }
10960                3 => {
10961                    let ans = unsafe { self.kind.InvalidUri };
10962                    crate::bindings::duplicates::LnUrlWithdrawError::InvalidUri {
10963                        err: ans.err.cst_decode(),
10964                    }
10965                }
10966                4 => {
10967                    let ans = unsafe { self.kind.InvoiceNoRoutingHints };
10968                    crate::bindings::duplicates::LnUrlWithdrawError::InvoiceNoRoutingHints {
10969                        err: ans.err.cst_decode(),
10970                    }
10971                }
10972                5 => {
10973                    let ans = unsafe { self.kind.ServiceConnectivity };
10974                    crate::bindings::duplicates::LnUrlWithdrawError::ServiceConnectivity {
10975                        err: ans.err.cst_decode(),
10976                    }
10977                }
10978                _ => unreachable!(),
10979            }
10980        }
10981    }
10982    impl CstDecode<crate::bindings::LnUrlWithdrawRequest> for wire_cst_ln_url_withdraw_request {
10983        // Codec=Cst (C-struct based), see doc to use other codecs
10984        fn cst_decode(self) -> crate::bindings::LnUrlWithdrawRequest {
10985            crate::bindings::LnUrlWithdrawRequest {
10986                data: self.data.cst_decode(),
10987                amount_msat: self.amount_msat.cst_decode(),
10988                description: self.description.cst_decode(),
10989            }
10990        }
10991    }
10992    impl CstDecode<crate::bindings::LnUrlWithdrawRequestData>
10993        for wire_cst_ln_url_withdraw_request_data
10994    {
10995        // Codec=Cst (C-struct based), see doc to use other codecs
10996        fn cst_decode(self) -> crate::bindings::LnUrlWithdrawRequestData {
10997            crate::bindings::LnUrlWithdrawRequestData {
10998                callback: self.callback.cst_decode(),
10999                k1: self.k1.cst_decode(),
11000                default_description: self.default_description.cst_decode(),
11001                min_withdrawable: self.min_withdrawable.cst_decode(),
11002                max_withdrawable: self.max_withdrawable.cst_decode(),
11003            }
11004        }
11005    }
11006    impl CstDecode<crate::bindings::duplicates::LnUrlWithdrawResult>
11007        for wire_cst_ln_url_withdraw_result
11008    {
11009        // Codec=Cst (C-struct based), see doc to use other codecs
11010        fn cst_decode(self) -> crate::bindings::duplicates::LnUrlWithdrawResult {
11011            match self.tag {
11012                0 => {
11013                    let ans = unsafe { self.kind.Ok };
11014                    crate::bindings::duplicates::LnUrlWithdrawResult::Ok {
11015                        data: ans.data.cst_decode(),
11016                    }
11017                }
11018                1 => {
11019                    let ans = unsafe { self.kind.Timeout };
11020                    crate::bindings::duplicates::LnUrlWithdrawResult::Timeout {
11021                        data: ans.data.cst_decode(),
11022                    }
11023                }
11024                2 => {
11025                    let ans = unsafe { self.kind.ErrorStatus };
11026                    crate::bindings::duplicates::LnUrlWithdrawResult::ErrorStatus {
11027                        data: ans.data.cst_decode(),
11028                    }
11029                }
11030                _ => unreachable!(),
11031            }
11032        }
11033    }
11034    impl CstDecode<crate::bindings::duplicates::LnUrlWithdrawSuccessData>
11035        for wire_cst_ln_url_withdraw_success_data
11036    {
11037        // Codec=Cst (C-struct based), see doc to use other codecs
11038        fn cst_decode(self) -> crate::bindings::duplicates::LnUrlWithdrawSuccessData {
11039            crate::bindings::duplicates::LnUrlWithdrawSuccessData {
11040                invoice: self.invoice.cst_decode(),
11041            }
11042        }
11043    }
11044    impl CstDecode<crate::bindings::LocaleOverrides> for wire_cst_locale_overrides {
11045        // Codec=Cst (C-struct based), see doc to use other codecs
11046        fn cst_decode(self) -> crate::bindings::LocaleOverrides {
11047            crate::bindings::LocaleOverrides {
11048                locale: self.locale.cst_decode(),
11049                spacing: self.spacing.cst_decode(),
11050                symbol: self.symbol.cst_decode(),
11051            }
11052        }
11053    }
11054    impl CstDecode<crate::bindings::LocalizedName> for wire_cst_localized_name {
11055        // Codec=Cst (C-struct based), see doc to use other codecs
11056        fn cst_decode(self) -> crate::bindings::LocalizedName {
11057            crate::bindings::LocalizedName {
11058                locale: self.locale.cst_decode(),
11059                name: self.name.cst_decode(),
11060            }
11061        }
11062    }
11063    impl CstDecode<crate::model::LogEntry> for wire_cst_log_entry {
11064        // Codec=Cst (C-struct based), see doc to use other codecs
11065        fn cst_decode(self) -> crate::model::LogEntry {
11066            crate::model::LogEntry {
11067                line: self.line.cst_decode(),
11068                level: self.level.cst_decode(),
11069            }
11070        }
11071    }
11072    impl CstDecode<crate::bindings::MessageSuccessActionData> for wire_cst_message_success_action_data {
11073        // Codec=Cst (C-struct based), see doc to use other codecs
11074        fn cst_decode(self) -> crate::bindings::MessageSuccessActionData {
11075            crate::bindings::MessageSuccessActionData {
11076                message: self.message.cst_decode(),
11077            }
11078        }
11079    }
11080    impl CstDecode<crate::model::OnchainPaymentLimitsResponse>
11081        for wire_cst_onchain_payment_limits_response
11082    {
11083        // Codec=Cst (C-struct based), see doc to use other codecs
11084        fn cst_decode(self) -> crate::model::OnchainPaymentLimitsResponse {
11085            crate::model::OnchainPaymentLimitsResponse {
11086                send: self.send.cst_decode(),
11087                receive: self.receive.cst_decode(),
11088            }
11089        }
11090    }
11091    impl CstDecode<crate::model::PayAmount> for wire_cst_pay_amount {
11092        // Codec=Cst (C-struct based), see doc to use other codecs
11093        fn cst_decode(self) -> crate::model::PayAmount {
11094            match self.tag {
11095                0 => {
11096                    let ans = unsafe { self.kind.Bitcoin };
11097                    crate::model::PayAmount::Bitcoin {
11098                        receiver_amount_sat: ans.receiver_amount_sat.cst_decode(),
11099                    }
11100                }
11101                1 => {
11102                    let ans = unsafe { self.kind.Asset };
11103                    crate::model::PayAmount::Asset {
11104                        asset_id: ans.asset_id.cst_decode(),
11105                        receiver_amount: ans.receiver_amount.cst_decode(),
11106                        estimate_asset_fees: ans.estimate_asset_fees.cst_decode(),
11107                    }
11108                }
11109                2 => crate::model::PayAmount::Drain,
11110                _ => unreachable!(),
11111            }
11112        }
11113    }
11114    impl CstDecode<crate::model::PayOnchainRequest> for wire_cst_pay_onchain_request {
11115        // Codec=Cst (C-struct based), see doc to use other codecs
11116        fn cst_decode(self) -> crate::model::PayOnchainRequest {
11117            crate::model::PayOnchainRequest {
11118                address: self.address.cst_decode(),
11119                prepare_response: self.prepare_response.cst_decode(),
11120            }
11121        }
11122    }
11123    impl CstDecode<crate::model::Payment> for wire_cst_payment {
11124        // Codec=Cst (C-struct based), see doc to use other codecs
11125        fn cst_decode(self) -> crate::model::Payment {
11126            crate::model::Payment {
11127                destination: self.destination.cst_decode(),
11128                tx_id: self.tx_id.cst_decode(),
11129                unblinding_data: self.unblinding_data.cst_decode(),
11130                timestamp: self.timestamp.cst_decode(),
11131                amount_sat: self.amount_sat.cst_decode(),
11132                fees_sat: self.fees_sat.cst_decode(),
11133                swapper_fees_sat: self.swapper_fees_sat.cst_decode(),
11134                payment_type: self.payment_type.cst_decode(),
11135                status: self.status.cst_decode(),
11136                details: self.details.cst_decode(),
11137            }
11138        }
11139    }
11140    impl CstDecode<crate::model::PaymentDetails> for wire_cst_payment_details {
11141        // Codec=Cst (C-struct based), see doc to use other codecs
11142        fn cst_decode(self) -> crate::model::PaymentDetails {
11143            match self.tag {
11144                0 => {
11145                    let ans = unsafe { self.kind.Lightning };
11146                    crate::model::PaymentDetails::Lightning {
11147                        swap_id: ans.swap_id.cst_decode(),
11148                        description: ans.description.cst_decode(),
11149                        liquid_expiration_blockheight: ans
11150                            .liquid_expiration_blockheight
11151                            .cst_decode(),
11152                        preimage: ans.preimage.cst_decode(),
11153                        invoice: ans.invoice.cst_decode(),
11154                        bolt12_offer: ans.bolt12_offer.cst_decode(),
11155                        payment_hash: ans.payment_hash.cst_decode(),
11156                        destination_pubkey: ans.destination_pubkey.cst_decode(),
11157                        lnurl_info: ans.lnurl_info.cst_decode(),
11158                        bip353_address: ans.bip353_address.cst_decode(),
11159                        claim_tx_id: ans.claim_tx_id.cst_decode(),
11160                        refund_tx_id: ans.refund_tx_id.cst_decode(),
11161                        refund_tx_amount_sat: ans.refund_tx_amount_sat.cst_decode(),
11162                    }
11163                }
11164                1 => {
11165                    let ans = unsafe { self.kind.Liquid };
11166                    crate::model::PaymentDetails::Liquid {
11167                        destination: ans.destination.cst_decode(),
11168                        description: ans.description.cst_decode(),
11169                        asset_id: ans.asset_id.cst_decode(),
11170                        asset_info: ans.asset_info.cst_decode(),
11171                        lnurl_info: ans.lnurl_info.cst_decode(),
11172                        bip353_address: ans.bip353_address.cst_decode(),
11173                    }
11174                }
11175                2 => {
11176                    let ans = unsafe { self.kind.Bitcoin };
11177                    crate::model::PaymentDetails::Bitcoin {
11178                        swap_id: ans.swap_id.cst_decode(),
11179                        description: ans.description.cst_decode(),
11180                        auto_accepted_fees: ans.auto_accepted_fees.cst_decode(),
11181                        liquid_expiration_blockheight: ans
11182                            .liquid_expiration_blockheight
11183                            .cst_decode(),
11184                        bitcoin_expiration_blockheight: ans
11185                            .bitcoin_expiration_blockheight
11186                            .cst_decode(),
11187                        claim_tx_id: ans.claim_tx_id.cst_decode(),
11188                        refund_tx_id: ans.refund_tx_id.cst_decode(),
11189                        refund_tx_amount_sat: ans.refund_tx_amount_sat.cst_decode(),
11190                    }
11191                }
11192                _ => unreachable!(),
11193            }
11194        }
11195    }
11196    impl CstDecode<crate::error::PaymentError> for wire_cst_payment_error {
11197        // Codec=Cst (C-struct based), see doc to use other codecs
11198        fn cst_decode(self) -> crate::error::PaymentError {
11199            match self.tag {
11200                0 => crate::error::PaymentError::AlreadyClaimed,
11201                1 => crate::error::PaymentError::AlreadyPaid,
11202                2 => crate::error::PaymentError::PaymentInProgress,
11203                3 => {
11204                    let ans = unsafe { self.kind.AmountOutOfRange };
11205                    crate::error::PaymentError::AmountOutOfRange {
11206                        min: ans.min.cst_decode(),
11207                        max: ans.max.cst_decode(),
11208                    }
11209                }
11210                4 => {
11211                    let ans = unsafe { self.kind.AmountMissing };
11212                    crate::error::PaymentError::AmountMissing {
11213                        err: ans.err.cst_decode(),
11214                    }
11215                }
11216                5 => {
11217                    let ans = unsafe { self.kind.AssetError };
11218                    crate::error::PaymentError::AssetError {
11219                        err: ans.err.cst_decode(),
11220                    }
11221                }
11222                6 => {
11223                    let ans = unsafe { self.kind.InvalidNetwork };
11224                    crate::error::PaymentError::InvalidNetwork {
11225                        err: ans.err.cst_decode(),
11226                    }
11227                }
11228                7 => {
11229                    let ans = unsafe { self.kind.Generic };
11230                    crate::error::PaymentError::Generic {
11231                        err: ans.err.cst_decode(),
11232                    }
11233                }
11234                8 => crate::error::PaymentError::InvalidOrExpiredFees,
11235                9 => crate::error::PaymentError::InsufficientFunds,
11236                10 => {
11237                    let ans = unsafe { self.kind.InvalidDescription };
11238                    crate::error::PaymentError::InvalidDescription {
11239                        err: ans.err.cst_decode(),
11240                    }
11241                }
11242                11 => {
11243                    let ans = unsafe { self.kind.InvalidInvoice };
11244                    crate::error::PaymentError::InvalidInvoice {
11245                        err: ans.err.cst_decode(),
11246                    }
11247                }
11248                12 => crate::error::PaymentError::InvalidPreimage,
11249                13 => crate::error::PaymentError::PairsNotFound,
11250                14 => crate::error::PaymentError::PaymentTimeout,
11251                15 => crate::error::PaymentError::PersistError,
11252                16 => {
11253                    let ans = unsafe { self.kind.ReceiveError };
11254                    crate::error::PaymentError::ReceiveError {
11255                        err: ans.err.cst_decode(),
11256                    }
11257                }
11258                17 => {
11259                    let ans = unsafe { self.kind.Refunded };
11260                    crate::error::PaymentError::Refunded {
11261                        err: ans.err.cst_decode(),
11262                        refund_tx_id: ans.refund_tx_id.cst_decode(),
11263                    }
11264                }
11265                18 => crate::error::PaymentError::SelfTransferNotSupported,
11266                19 => {
11267                    let ans = unsafe { self.kind.SendError };
11268                    crate::error::PaymentError::SendError {
11269                        err: ans.err.cst_decode(),
11270                    }
11271                }
11272                20 => {
11273                    let ans = unsafe { self.kind.SignerError };
11274                    crate::error::PaymentError::SignerError {
11275                        err: ans.err.cst_decode(),
11276                    }
11277                }
11278                _ => unreachable!(),
11279            }
11280        }
11281    }
11282    impl CstDecode<crate::model::PrepareBuyBitcoinRequest> for wire_cst_prepare_buy_bitcoin_request {
11283        // Codec=Cst (C-struct based), see doc to use other codecs
11284        fn cst_decode(self) -> crate::model::PrepareBuyBitcoinRequest {
11285            crate::model::PrepareBuyBitcoinRequest {
11286                provider: self.provider.cst_decode(),
11287                amount_sat: self.amount_sat.cst_decode(),
11288            }
11289        }
11290    }
11291    impl CstDecode<crate::model::PrepareBuyBitcoinResponse> for wire_cst_prepare_buy_bitcoin_response {
11292        // Codec=Cst (C-struct based), see doc to use other codecs
11293        fn cst_decode(self) -> crate::model::PrepareBuyBitcoinResponse {
11294            crate::model::PrepareBuyBitcoinResponse {
11295                provider: self.provider.cst_decode(),
11296                amount_sat: self.amount_sat.cst_decode(),
11297                fees_sat: self.fees_sat.cst_decode(),
11298            }
11299        }
11300    }
11301    impl CstDecode<crate::model::PrepareLnUrlPayRequest> for wire_cst_prepare_ln_url_pay_request {
11302        // Codec=Cst (C-struct based), see doc to use other codecs
11303        fn cst_decode(self) -> crate::model::PrepareLnUrlPayRequest {
11304            crate::model::PrepareLnUrlPayRequest {
11305                data: self.data.cst_decode(),
11306                amount: self.amount.cst_decode(),
11307                bip353_address: self.bip353_address.cst_decode(),
11308                comment: self.comment.cst_decode(),
11309                validate_success_action_url: self.validate_success_action_url.cst_decode(),
11310            }
11311        }
11312    }
11313    impl CstDecode<crate::model::PrepareLnUrlPayResponse> for wire_cst_prepare_ln_url_pay_response {
11314        // Codec=Cst (C-struct based), see doc to use other codecs
11315        fn cst_decode(self) -> crate::model::PrepareLnUrlPayResponse {
11316            crate::model::PrepareLnUrlPayResponse {
11317                destination: self.destination.cst_decode(),
11318                fees_sat: self.fees_sat.cst_decode(),
11319                data: self.data.cst_decode(),
11320                comment: self.comment.cst_decode(),
11321                success_action: self.success_action.cst_decode(),
11322            }
11323        }
11324    }
11325    impl CstDecode<crate::model::PreparePayOnchainRequest> for wire_cst_prepare_pay_onchain_request {
11326        // Codec=Cst (C-struct based), see doc to use other codecs
11327        fn cst_decode(self) -> crate::model::PreparePayOnchainRequest {
11328            crate::model::PreparePayOnchainRequest {
11329                amount: self.amount.cst_decode(),
11330                fee_rate_sat_per_vbyte: self.fee_rate_sat_per_vbyte.cst_decode(),
11331            }
11332        }
11333    }
11334    impl CstDecode<crate::model::PreparePayOnchainResponse> for wire_cst_prepare_pay_onchain_response {
11335        // Codec=Cst (C-struct based), see doc to use other codecs
11336        fn cst_decode(self) -> crate::model::PreparePayOnchainResponse {
11337            crate::model::PreparePayOnchainResponse {
11338                receiver_amount_sat: self.receiver_amount_sat.cst_decode(),
11339                claim_fees_sat: self.claim_fees_sat.cst_decode(),
11340                total_fees_sat: self.total_fees_sat.cst_decode(),
11341            }
11342        }
11343    }
11344    impl CstDecode<crate::model::PrepareReceiveRequest> for wire_cst_prepare_receive_request {
11345        // Codec=Cst (C-struct based), see doc to use other codecs
11346        fn cst_decode(self) -> crate::model::PrepareReceiveRequest {
11347            crate::model::PrepareReceiveRequest {
11348                payment_method: self.payment_method.cst_decode(),
11349                amount: self.amount.cst_decode(),
11350            }
11351        }
11352    }
11353    impl CstDecode<crate::model::PrepareReceiveResponse> for wire_cst_prepare_receive_response {
11354        // Codec=Cst (C-struct based), see doc to use other codecs
11355        fn cst_decode(self) -> crate::model::PrepareReceiveResponse {
11356            crate::model::PrepareReceiveResponse {
11357                payment_method: self.payment_method.cst_decode(),
11358                fees_sat: self.fees_sat.cst_decode(),
11359                amount: self.amount.cst_decode(),
11360                min_payer_amount_sat: self.min_payer_amount_sat.cst_decode(),
11361                max_payer_amount_sat: self.max_payer_amount_sat.cst_decode(),
11362                swapper_feerate: self.swapper_feerate.cst_decode(),
11363            }
11364        }
11365    }
11366    impl CstDecode<crate::model::PrepareRefundRequest> for wire_cst_prepare_refund_request {
11367        // Codec=Cst (C-struct based), see doc to use other codecs
11368        fn cst_decode(self) -> crate::model::PrepareRefundRequest {
11369            crate::model::PrepareRefundRequest {
11370                swap_address: self.swap_address.cst_decode(),
11371                refund_address: self.refund_address.cst_decode(),
11372                fee_rate_sat_per_vbyte: self.fee_rate_sat_per_vbyte.cst_decode(),
11373            }
11374        }
11375    }
11376    impl CstDecode<crate::model::PrepareRefundResponse> for wire_cst_prepare_refund_response {
11377        // Codec=Cst (C-struct based), see doc to use other codecs
11378        fn cst_decode(self) -> crate::model::PrepareRefundResponse {
11379            crate::model::PrepareRefundResponse {
11380                tx_vsize: self.tx_vsize.cst_decode(),
11381                tx_fee_sat: self.tx_fee_sat.cst_decode(),
11382                last_refund_tx_id: self.last_refund_tx_id.cst_decode(),
11383            }
11384        }
11385    }
11386    impl CstDecode<crate::model::PrepareSendRequest> for wire_cst_prepare_send_request {
11387        // Codec=Cst (C-struct based), see doc to use other codecs
11388        fn cst_decode(self) -> crate::model::PrepareSendRequest {
11389            crate::model::PrepareSendRequest {
11390                destination: self.destination.cst_decode(),
11391                amount: self.amount.cst_decode(),
11392            }
11393        }
11394    }
11395    impl CstDecode<crate::model::PrepareSendResponse> for wire_cst_prepare_send_response {
11396        // Codec=Cst (C-struct based), see doc to use other codecs
11397        fn cst_decode(self) -> crate::model::PrepareSendResponse {
11398            crate::model::PrepareSendResponse {
11399                destination: self.destination.cst_decode(),
11400                fees_sat: self.fees_sat.cst_decode(),
11401                estimated_asset_fees: self.estimated_asset_fees.cst_decode(),
11402            }
11403        }
11404    }
11405    impl CstDecode<crate::bindings::Rate> for wire_cst_rate {
11406        // Codec=Cst (C-struct based), see doc to use other codecs
11407        fn cst_decode(self) -> crate::bindings::Rate {
11408            crate::bindings::Rate {
11409                coin: self.coin.cst_decode(),
11410                value: self.value.cst_decode(),
11411            }
11412        }
11413    }
11414    impl CstDecode<crate::model::ReceiveAmount> for wire_cst_receive_amount {
11415        // Codec=Cst (C-struct based), see doc to use other codecs
11416        fn cst_decode(self) -> crate::model::ReceiveAmount {
11417            match self.tag {
11418                0 => {
11419                    let ans = unsafe { self.kind.Bitcoin };
11420                    crate::model::ReceiveAmount::Bitcoin {
11421                        payer_amount_sat: ans.payer_amount_sat.cst_decode(),
11422                    }
11423                }
11424                1 => {
11425                    let ans = unsafe { self.kind.Asset };
11426                    crate::model::ReceiveAmount::Asset {
11427                        asset_id: ans.asset_id.cst_decode(),
11428                        payer_amount: ans.payer_amount.cst_decode(),
11429                    }
11430                }
11431                _ => unreachable!(),
11432            }
11433        }
11434    }
11435    impl CstDecode<crate::model::ReceivePaymentRequest> for wire_cst_receive_payment_request {
11436        // Codec=Cst (C-struct based), see doc to use other codecs
11437        fn cst_decode(self) -> crate::model::ReceivePaymentRequest {
11438            crate::model::ReceivePaymentRequest {
11439                prepare_response: self.prepare_response.cst_decode(),
11440                description: self.description.cst_decode(),
11441                use_description_hash: self.use_description_hash.cst_decode(),
11442            }
11443        }
11444    }
11445    impl CstDecode<crate::model::ReceivePaymentResponse> for wire_cst_receive_payment_response {
11446        // Codec=Cst (C-struct based), see doc to use other codecs
11447        fn cst_decode(self) -> crate::model::ReceivePaymentResponse {
11448            crate::model::ReceivePaymentResponse {
11449                destination: self.destination.cst_decode(),
11450            }
11451        }
11452    }
11453    impl CstDecode<crate::model::RecommendedFees> for wire_cst_recommended_fees {
11454        // Codec=Cst (C-struct based), see doc to use other codecs
11455        fn cst_decode(self) -> crate::model::RecommendedFees {
11456            crate::model::RecommendedFees {
11457                fastest_fee: self.fastest_fee.cst_decode(),
11458                half_hour_fee: self.half_hour_fee.cst_decode(),
11459                hour_fee: self.hour_fee.cst_decode(),
11460                economy_fee: self.economy_fee.cst_decode(),
11461                minimum_fee: self.minimum_fee.cst_decode(),
11462            }
11463        }
11464    }
11465    impl CstDecode<crate::model::RefundRequest> for wire_cst_refund_request {
11466        // Codec=Cst (C-struct based), see doc to use other codecs
11467        fn cst_decode(self) -> crate::model::RefundRequest {
11468            crate::model::RefundRequest {
11469                swap_address: self.swap_address.cst_decode(),
11470                refund_address: self.refund_address.cst_decode(),
11471                fee_rate_sat_per_vbyte: self.fee_rate_sat_per_vbyte.cst_decode(),
11472            }
11473        }
11474    }
11475    impl CstDecode<crate::model::RefundResponse> for wire_cst_refund_response {
11476        // Codec=Cst (C-struct based), see doc to use other codecs
11477        fn cst_decode(self) -> crate::model::RefundResponse {
11478            crate::model::RefundResponse {
11479                refund_tx_id: self.refund_tx_id.cst_decode(),
11480            }
11481        }
11482    }
11483    impl CstDecode<crate::model::RefundableSwap> for wire_cst_refundable_swap {
11484        // Codec=Cst (C-struct based), see doc to use other codecs
11485        fn cst_decode(self) -> crate::model::RefundableSwap {
11486            crate::model::RefundableSwap {
11487                swap_address: self.swap_address.cst_decode(),
11488                timestamp: self.timestamp.cst_decode(),
11489                amount_sat: self.amount_sat.cst_decode(),
11490                last_refund_tx_id: self.last_refund_tx_id.cst_decode(),
11491            }
11492        }
11493    }
11494    impl CstDecode<crate::model::RestoreRequest> for wire_cst_restore_request {
11495        // Codec=Cst (C-struct based), see doc to use other codecs
11496        fn cst_decode(self) -> crate::model::RestoreRequest {
11497            crate::model::RestoreRequest {
11498                backup_path: self.backup_path.cst_decode(),
11499            }
11500        }
11501    }
11502    impl CstDecode<crate::bindings::RouteHint> for wire_cst_route_hint {
11503        // Codec=Cst (C-struct based), see doc to use other codecs
11504        fn cst_decode(self) -> crate::bindings::RouteHint {
11505            crate::bindings::RouteHint {
11506                hops: self.hops.cst_decode(),
11507            }
11508        }
11509    }
11510    impl CstDecode<crate::bindings::RouteHintHop> for wire_cst_route_hint_hop {
11511        // Codec=Cst (C-struct based), see doc to use other codecs
11512        fn cst_decode(self) -> crate::bindings::RouteHintHop {
11513            crate::bindings::RouteHintHop {
11514                src_node_id: self.src_node_id.cst_decode(),
11515                short_channel_id: self.short_channel_id.cst_decode(),
11516                fees_base_msat: self.fees_base_msat.cst_decode(),
11517                fees_proportional_millionths: self.fees_proportional_millionths.cst_decode(),
11518                cltv_expiry_delta: self.cltv_expiry_delta.cst_decode(),
11519                htlc_minimum_msat: self.htlc_minimum_msat.cst_decode(),
11520                htlc_maximum_msat: self.htlc_maximum_msat.cst_decode(),
11521            }
11522        }
11523    }
11524    impl CstDecode<crate::error::SdkError> for wire_cst_sdk_error {
11525        // Codec=Cst (C-struct based), see doc to use other codecs
11526        fn cst_decode(self) -> crate::error::SdkError {
11527            match self.tag {
11528                0 => crate::error::SdkError::AlreadyStarted,
11529                1 => {
11530                    let ans = unsafe { self.kind.Generic };
11531                    crate::error::SdkError::Generic {
11532                        err: ans.err.cst_decode(),
11533                    }
11534                }
11535                2 => crate::error::SdkError::NotStarted,
11536                3 => {
11537                    let ans = unsafe { self.kind.ServiceConnectivity };
11538                    crate::error::SdkError::ServiceConnectivity {
11539                        err: ans.err.cst_decode(),
11540                    }
11541                }
11542                _ => unreachable!(),
11543            }
11544        }
11545    }
11546    impl CstDecode<crate::model::SdkEvent> for wire_cst_sdk_event {
11547        // Codec=Cst (C-struct based), see doc to use other codecs
11548        fn cst_decode(self) -> crate::model::SdkEvent {
11549            match self.tag {
11550                0 => {
11551                    let ans = unsafe { self.kind.PaymentFailed };
11552                    crate::model::SdkEvent::PaymentFailed {
11553                        details: ans.details.cst_decode(),
11554                    }
11555                }
11556                1 => {
11557                    let ans = unsafe { self.kind.PaymentPending };
11558                    crate::model::SdkEvent::PaymentPending {
11559                        details: ans.details.cst_decode(),
11560                    }
11561                }
11562                2 => {
11563                    let ans = unsafe { self.kind.PaymentRefundable };
11564                    crate::model::SdkEvent::PaymentRefundable {
11565                        details: ans.details.cst_decode(),
11566                    }
11567                }
11568                3 => {
11569                    let ans = unsafe { self.kind.PaymentRefunded };
11570                    crate::model::SdkEvent::PaymentRefunded {
11571                        details: ans.details.cst_decode(),
11572                    }
11573                }
11574                4 => {
11575                    let ans = unsafe { self.kind.PaymentRefundPending };
11576                    crate::model::SdkEvent::PaymentRefundPending {
11577                        details: ans.details.cst_decode(),
11578                    }
11579                }
11580                5 => {
11581                    let ans = unsafe { self.kind.PaymentSucceeded };
11582                    crate::model::SdkEvent::PaymentSucceeded {
11583                        details: ans.details.cst_decode(),
11584                    }
11585                }
11586                6 => {
11587                    let ans = unsafe { self.kind.PaymentWaitingConfirmation };
11588                    crate::model::SdkEvent::PaymentWaitingConfirmation {
11589                        details: ans.details.cst_decode(),
11590                    }
11591                }
11592                7 => {
11593                    let ans = unsafe { self.kind.PaymentWaitingFeeAcceptance };
11594                    crate::model::SdkEvent::PaymentWaitingFeeAcceptance {
11595                        details: ans.details.cst_decode(),
11596                    }
11597                }
11598                8 => crate::model::SdkEvent::Synced,
11599                9 => {
11600                    let ans = unsafe { self.kind.DataSynced };
11601                    crate::model::SdkEvent::DataSynced {
11602                        did_pull_new_records: ans.did_pull_new_records.cst_decode(),
11603                    }
11604                }
11605                _ => unreachable!(),
11606            }
11607        }
11608    }
11609    impl CstDecode<crate::model::SendDestination> for wire_cst_send_destination {
11610        // Codec=Cst (C-struct based), see doc to use other codecs
11611        fn cst_decode(self) -> crate::model::SendDestination {
11612            match self.tag {
11613                0 => {
11614                    let ans = unsafe { self.kind.LiquidAddress };
11615                    crate::model::SendDestination::LiquidAddress {
11616                        address_data: ans.address_data.cst_decode(),
11617                        bip353_address: ans.bip353_address.cst_decode(),
11618                    }
11619                }
11620                1 => {
11621                    let ans = unsafe { self.kind.Bolt11 };
11622                    crate::model::SendDestination::Bolt11 {
11623                        invoice: ans.invoice.cst_decode(),
11624                        bip353_address: ans.bip353_address.cst_decode(),
11625                    }
11626                }
11627                2 => {
11628                    let ans = unsafe { self.kind.Bolt12 };
11629                    crate::model::SendDestination::Bolt12 {
11630                        offer: ans.offer.cst_decode(),
11631                        receiver_amount_sat: ans.receiver_amount_sat.cst_decode(),
11632                        bip353_address: ans.bip353_address.cst_decode(),
11633                    }
11634                }
11635                _ => unreachable!(),
11636            }
11637        }
11638    }
11639    impl CstDecode<crate::model::SendPaymentRequest> for wire_cst_send_payment_request {
11640        // Codec=Cst (C-struct based), see doc to use other codecs
11641        fn cst_decode(self) -> crate::model::SendPaymentRequest {
11642            crate::model::SendPaymentRequest {
11643                prepare_response: self.prepare_response.cst_decode(),
11644                use_asset_fees: self.use_asset_fees.cst_decode(),
11645            }
11646        }
11647    }
11648    impl CstDecode<crate::model::SendPaymentResponse> for wire_cst_send_payment_response {
11649        // Codec=Cst (C-struct based), see doc to use other codecs
11650        fn cst_decode(self) -> crate::model::SendPaymentResponse {
11651            crate::model::SendPaymentResponse {
11652                payment: self.payment.cst_decode(),
11653            }
11654        }
11655    }
11656    impl CstDecode<crate::model::SignMessageRequest> for wire_cst_sign_message_request {
11657        // Codec=Cst (C-struct based), see doc to use other codecs
11658        fn cst_decode(self) -> crate::model::SignMessageRequest {
11659            crate::model::SignMessageRequest {
11660                message: self.message.cst_decode(),
11661            }
11662        }
11663    }
11664    impl CstDecode<crate::model::SignMessageResponse> for wire_cst_sign_message_response {
11665        // Codec=Cst (C-struct based), see doc to use other codecs
11666        fn cst_decode(self) -> crate::model::SignMessageResponse {
11667            crate::model::SignMessageResponse {
11668                signature: self.signature.cst_decode(),
11669            }
11670        }
11671    }
11672    impl CstDecode<crate::bindings::SuccessAction> for wire_cst_success_action {
11673        // Codec=Cst (C-struct based), see doc to use other codecs
11674        fn cst_decode(self) -> crate::bindings::SuccessAction {
11675            match self.tag {
11676                0 => {
11677                    let ans = unsafe { self.kind.Aes };
11678                    crate::bindings::SuccessAction::Aes {
11679                        data: ans.data.cst_decode(),
11680                    }
11681                }
11682                1 => {
11683                    let ans = unsafe { self.kind.Message };
11684                    crate::bindings::SuccessAction::Message {
11685                        data: ans.data.cst_decode(),
11686                    }
11687                }
11688                2 => {
11689                    let ans = unsafe { self.kind.Url };
11690                    crate::bindings::SuccessAction::Url {
11691                        data: ans.data.cst_decode(),
11692                    }
11693                }
11694                _ => unreachable!(),
11695            }
11696        }
11697    }
11698    impl CstDecode<crate::bindings::SuccessActionProcessed> for wire_cst_success_action_processed {
11699        // Codec=Cst (C-struct based), see doc to use other codecs
11700        fn cst_decode(self) -> crate::bindings::SuccessActionProcessed {
11701            match self.tag {
11702                0 => {
11703                    let ans = unsafe { self.kind.Aes };
11704                    crate::bindings::SuccessActionProcessed::Aes {
11705                        result: ans.result.cst_decode(),
11706                    }
11707                }
11708                1 => {
11709                    let ans = unsafe { self.kind.Message };
11710                    crate::bindings::SuccessActionProcessed::Message {
11711                        data: ans.data.cst_decode(),
11712                    }
11713                }
11714                2 => {
11715                    let ans = unsafe { self.kind.Url };
11716                    crate::bindings::SuccessActionProcessed::Url {
11717                        data: ans.data.cst_decode(),
11718                    }
11719                }
11720                _ => unreachable!(),
11721            }
11722        }
11723    }
11724    impl CstDecode<crate::bindings::Symbol> for wire_cst_symbol {
11725        // Codec=Cst (C-struct based), see doc to use other codecs
11726        fn cst_decode(self) -> crate::bindings::Symbol {
11727            crate::bindings::Symbol {
11728                grapheme: self.grapheme.cst_decode(),
11729                template: self.template.cst_decode(),
11730                rtl: self.rtl.cst_decode(),
11731                position: self.position.cst_decode(),
11732            }
11733        }
11734    }
11735    impl CstDecode<crate::bindings::UrlSuccessActionData> for wire_cst_url_success_action_data {
11736        // Codec=Cst (C-struct based), see doc to use other codecs
11737        fn cst_decode(self) -> crate::bindings::UrlSuccessActionData {
11738            crate::bindings::UrlSuccessActionData {
11739                description: self.description.cst_decode(),
11740                url: self.url.cst_decode(),
11741                matches_callback_domain: self.matches_callback_domain.cst_decode(),
11742            }
11743        }
11744    }
11745    impl CstDecode<crate::model::WalletInfo> for wire_cst_wallet_info {
11746        // Codec=Cst (C-struct based), see doc to use other codecs
11747        fn cst_decode(self) -> crate::model::WalletInfo {
11748            crate::model::WalletInfo {
11749                balance_sat: self.balance_sat.cst_decode(),
11750                pending_send_sat: self.pending_send_sat.cst_decode(),
11751                pending_receive_sat: self.pending_receive_sat.cst_decode(),
11752                fingerprint: self.fingerprint.cst_decode(),
11753                pubkey: self.pubkey.cst_decode(),
11754                asset_balances: self.asset_balances.cst_decode(),
11755            }
11756        }
11757    }
11758    impl NewWithNullPtr for wire_cst_accept_payment_proposed_fees_request {
11759        fn new_with_null_ptr() -> Self {
11760            Self {
11761                response: Default::default(),
11762            }
11763        }
11764    }
11765    impl Default for wire_cst_accept_payment_proposed_fees_request {
11766        fn default() -> Self {
11767            Self::new_with_null_ptr()
11768        }
11769    }
11770    impl NewWithNullPtr for wire_cst_aes_success_action_data {
11771        fn new_with_null_ptr() -> Self {
11772            Self {
11773                description: core::ptr::null_mut(),
11774                ciphertext: core::ptr::null_mut(),
11775                iv: core::ptr::null_mut(),
11776            }
11777        }
11778    }
11779    impl Default for wire_cst_aes_success_action_data {
11780        fn default() -> Self {
11781            Self::new_with_null_ptr()
11782        }
11783    }
11784    impl NewWithNullPtr for wire_cst_aes_success_action_data_decrypted {
11785        fn new_with_null_ptr() -> Self {
11786            Self {
11787                description: core::ptr::null_mut(),
11788                plaintext: core::ptr::null_mut(),
11789            }
11790        }
11791    }
11792    impl Default for wire_cst_aes_success_action_data_decrypted {
11793        fn default() -> Self {
11794            Self::new_with_null_ptr()
11795        }
11796    }
11797    impl NewWithNullPtr for wire_cst_aes_success_action_data_result {
11798        fn new_with_null_ptr() -> Self {
11799            Self {
11800                tag: -1,
11801                kind: AesSuccessActionDataResultKind { nil__: () },
11802            }
11803        }
11804    }
11805    impl Default for wire_cst_aes_success_action_data_result {
11806        fn default() -> Self {
11807            Self::new_with_null_ptr()
11808        }
11809    }
11810    impl NewWithNullPtr for wire_cst_amount {
11811        fn new_with_null_ptr() -> Self {
11812            Self {
11813                tag: -1,
11814                kind: AmountKind { nil__: () },
11815            }
11816        }
11817    }
11818    impl Default for wire_cst_amount {
11819        fn default() -> Self {
11820            Self::new_with_null_ptr()
11821        }
11822    }
11823    impl NewWithNullPtr for wire_cst_asset_balance {
11824        fn new_with_null_ptr() -> Self {
11825            Self {
11826                asset_id: core::ptr::null_mut(),
11827                balance_sat: Default::default(),
11828                name: core::ptr::null_mut(),
11829                ticker: core::ptr::null_mut(),
11830                balance: core::ptr::null_mut(),
11831            }
11832        }
11833    }
11834    impl Default for wire_cst_asset_balance {
11835        fn default() -> Self {
11836            Self::new_with_null_ptr()
11837        }
11838    }
11839    impl NewWithNullPtr for wire_cst_asset_info {
11840        fn new_with_null_ptr() -> Self {
11841            Self {
11842                name: core::ptr::null_mut(),
11843                ticker: core::ptr::null_mut(),
11844                amount: Default::default(),
11845                fees: core::ptr::null_mut(),
11846            }
11847        }
11848    }
11849    impl Default for wire_cst_asset_info {
11850        fn default() -> Self {
11851            Self::new_with_null_ptr()
11852        }
11853    }
11854    impl NewWithNullPtr for wire_cst_asset_metadata {
11855        fn new_with_null_ptr() -> Self {
11856            Self {
11857                asset_id: core::ptr::null_mut(),
11858                name: core::ptr::null_mut(),
11859                ticker: core::ptr::null_mut(),
11860                precision: Default::default(),
11861                fiat_id: core::ptr::null_mut(),
11862            }
11863        }
11864    }
11865    impl Default for wire_cst_asset_metadata {
11866        fn default() -> Self {
11867            Self::new_with_null_ptr()
11868        }
11869    }
11870    impl NewWithNullPtr for wire_cst_backup_request {
11871        fn new_with_null_ptr() -> Self {
11872            Self {
11873                backup_path: core::ptr::null_mut(),
11874            }
11875        }
11876    }
11877    impl Default for wire_cst_backup_request {
11878        fn default() -> Self {
11879            Self::new_with_null_ptr()
11880        }
11881    }
11882    impl NewWithNullPtr for wire_cst_binding_event_listener {
11883        fn new_with_null_ptr() -> Self {
11884            Self {
11885                stream: core::ptr::null_mut(),
11886            }
11887        }
11888    }
11889    impl Default for wire_cst_binding_event_listener {
11890        fn default() -> Self {
11891            Self::new_with_null_ptr()
11892        }
11893    }
11894    impl NewWithNullPtr for wire_cst_bitcoin_address_data {
11895        fn new_with_null_ptr() -> Self {
11896            Self {
11897                address: core::ptr::null_mut(),
11898                network: Default::default(),
11899                amount_sat: core::ptr::null_mut(),
11900                label: core::ptr::null_mut(),
11901                message: core::ptr::null_mut(),
11902            }
11903        }
11904    }
11905    impl Default for wire_cst_bitcoin_address_data {
11906        fn default() -> Self {
11907            Self::new_with_null_ptr()
11908        }
11909    }
11910    impl NewWithNullPtr for wire_cst_blockchain_explorer {
11911        fn new_with_null_ptr() -> Self {
11912            Self {
11913                tag: -1,
11914                kind: BlockchainExplorerKind { nil__: () },
11915            }
11916        }
11917    }
11918    impl Default for wire_cst_blockchain_explorer {
11919        fn default() -> Self {
11920            Self::new_with_null_ptr()
11921        }
11922    }
11923    impl NewWithNullPtr for wire_cst_blockchain_info {
11924        fn new_with_null_ptr() -> Self {
11925            Self {
11926                liquid_tip: Default::default(),
11927                bitcoin_tip: Default::default(),
11928            }
11929        }
11930    }
11931    impl Default for wire_cst_blockchain_info {
11932        fn default() -> Self {
11933            Self::new_with_null_ptr()
11934        }
11935    }
11936    impl NewWithNullPtr for wire_cst_buy_bitcoin_request {
11937        fn new_with_null_ptr() -> Self {
11938            Self {
11939                prepare_response: Default::default(),
11940                redirect_url: core::ptr::null_mut(),
11941            }
11942        }
11943    }
11944    impl Default for wire_cst_buy_bitcoin_request {
11945        fn default() -> Self {
11946            Self::new_with_null_ptr()
11947        }
11948    }
11949    impl NewWithNullPtr for wire_cst_check_message_request {
11950        fn new_with_null_ptr() -> Self {
11951            Self {
11952                message: core::ptr::null_mut(),
11953                pubkey: core::ptr::null_mut(),
11954                signature: core::ptr::null_mut(),
11955            }
11956        }
11957    }
11958    impl Default for wire_cst_check_message_request {
11959        fn default() -> Self {
11960            Self::new_with_null_ptr()
11961        }
11962    }
11963    impl NewWithNullPtr for wire_cst_check_message_response {
11964        fn new_with_null_ptr() -> Self {
11965            Self {
11966                is_valid: Default::default(),
11967            }
11968        }
11969    }
11970    impl Default for wire_cst_check_message_response {
11971        fn default() -> Self {
11972            Self::new_with_null_ptr()
11973        }
11974    }
11975    impl NewWithNullPtr for wire_cst_config {
11976        fn new_with_null_ptr() -> Self {
11977            Self {
11978                liquid_explorer: Default::default(),
11979                bitcoin_explorer: Default::default(),
11980                working_dir: core::ptr::null_mut(),
11981                cache_dir: core::ptr::null_mut(),
11982                network: Default::default(),
11983                payment_timeout_sec: Default::default(),
11984                sync_service_url: core::ptr::null_mut(),
11985                zero_conf_max_amount_sat: core::ptr::null_mut(),
11986                breez_api_key: core::ptr::null_mut(),
11987                external_input_parsers: core::ptr::null_mut(),
11988                use_default_external_input_parsers: Default::default(),
11989                onchain_fee_rate_leeway_sat_per_vbyte: core::ptr::null_mut(),
11990                asset_metadata: core::ptr::null_mut(),
11991                sideswap_api_key: core::ptr::null_mut(),
11992            }
11993        }
11994    }
11995    impl Default for wire_cst_config {
11996        fn default() -> Self {
11997            Self::new_with_null_ptr()
11998        }
11999    }
12000    impl NewWithNullPtr for wire_cst_connect_request {
12001        fn new_with_null_ptr() -> Self {
12002            Self {
12003                config: Default::default(),
12004                mnemonic: core::ptr::null_mut(),
12005                passphrase: core::ptr::null_mut(),
12006                seed: core::ptr::null_mut(),
12007            }
12008        }
12009    }
12010    impl Default for wire_cst_connect_request {
12011        fn default() -> Self {
12012            Self::new_with_null_ptr()
12013        }
12014    }
12015    impl NewWithNullPtr for wire_cst_create_bolt_12_invoice_request {
12016        fn new_with_null_ptr() -> Self {
12017            Self {
12018                offer: core::ptr::null_mut(),
12019                invoice_request: core::ptr::null_mut(),
12020            }
12021        }
12022    }
12023    impl Default for wire_cst_create_bolt_12_invoice_request {
12024        fn default() -> Self {
12025            Self::new_with_null_ptr()
12026        }
12027    }
12028    impl NewWithNullPtr for wire_cst_create_bolt_12_invoice_response {
12029        fn new_with_null_ptr() -> Self {
12030            Self {
12031                invoice: core::ptr::null_mut(),
12032            }
12033        }
12034    }
12035    impl Default for wire_cst_create_bolt_12_invoice_response {
12036        fn default() -> Self {
12037            Self::new_with_null_ptr()
12038        }
12039    }
12040    impl NewWithNullPtr for wire_cst_currency_info {
12041        fn new_with_null_ptr() -> Self {
12042            Self {
12043                name: core::ptr::null_mut(),
12044                fraction_size: Default::default(),
12045                spacing: core::ptr::null_mut(),
12046                symbol: core::ptr::null_mut(),
12047                uniq_symbol: core::ptr::null_mut(),
12048                localized_name: core::ptr::null_mut(),
12049                locale_overrides: core::ptr::null_mut(),
12050            }
12051        }
12052    }
12053    impl Default for wire_cst_currency_info {
12054        fn default() -> Self {
12055            Self::new_with_null_ptr()
12056        }
12057    }
12058    impl NewWithNullPtr for wire_cst_external_input_parser {
12059        fn new_with_null_ptr() -> Self {
12060            Self {
12061                provider_id: core::ptr::null_mut(),
12062                input_regex: core::ptr::null_mut(),
12063                parser_url: core::ptr::null_mut(),
12064            }
12065        }
12066    }
12067    impl Default for wire_cst_external_input_parser {
12068        fn default() -> Self {
12069            Self::new_with_null_ptr()
12070        }
12071    }
12072    impl NewWithNullPtr for wire_cst_fetch_payment_proposed_fees_request {
12073        fn new_with_null_ptr() -> Self {
12074            Self {
12075                swap_id: core::ptr::null_mut(),
12076            }
12077        }
12078    }
12079    impl Default for wire_cst_fetch_payment_proposed_fees_request {
12080        fn default() -> Self {
12081            Self::new_with_null_ptr()
12082        }
12083    }
12084    impl NewWithNullPtr for wire_cst_fetch_payment_proposed_fees_response {
12085        fn new_with_null_ptr() -> Self {
12086            Self {
12087                swap_id: core::ptr::null_mut(),
12088                fees_sat: Default::default(),
12089                payer_amount_sat: Default::default(),
12090                receiver_amount_sat: Default::default(),
12091            }
12092        }
12093    }
12094    impl Default for wire_cst_fetch_payment_proposed_fees_response {
12095        fn default() -> Self {
12096            Self::new_with_null_ptr()
12097        }
12098    }
12099    impl NewWithNullPtr for wire_cst_fiat_currency {
12100        fn new_with_null_ptr() -> Self {
12101            Self {
12102                id: core::ptr::null_mut(),
12103                info: Default::default(),
12104            }
12105        }
12106    }
12107    impl Default for wire_cst_fiat_currency {
12108        fn default() -> Self {
12109            Self::new_with_null_ptr()
12110        }
12111    }
12112    impl NewWithNullPtr for wire_cst_get_info_response {
12113        fn new_with_null_ptr() -> Self {
12114            Self {
12115                wallet_info: Default::default(),
12116                blockchain_info: Default::default(),
12117            }
12118        }
12119    }
12120    impl Default for wire_cst_get_info_response {
12121        fn default() -> Self {
12122            Self::new_with_null_ptr()
12123        }
12124    }
12125    impl NewWithNullPtr for wire_cst_get_payment_request {
12126        fn new_with_null_ptr() -> Self {
12127            Self {
12128                tag: -1,
12129                kind: GetPaymentRequestKind { nil__: () },
12130            }
12131        }
12132    }
12133    impl Default for wire_cst_get_payment_request {
12134        fn default() -> Self {
12135            Self::new_with_null_ptr()
12136        }
12137    }
12138    impl NewWithNullPtr for wire_cst_input_type {
12139        fn new_with_null_ptr() -> Self {
12140            Self {
12141                tag: -1,
12142                kind: InputTypeKind { nil__: () },
12143            }
12144        }
12145    }
12146    impl Default for wire_cst_input_type {
12147        fn default() -> Self {
12148            Self::new_with_null_ptr()
12149        }
12150    }
12151    impl NewWithNullPtr for wire_cst_lightning_payment_limits_response {
12152        fn new_with_null_ptr() -> Self {
12153            Self {
12154                send: Default::default(),
12155                receive: Default::default(),
12156            }
12157        }
12158    }
12159    impl Default for wire_cst_lightning_payment_limits_response {
12160        fn default() -> Self {
12161            Self::new_with_null_ptr()
12162        }
12163    }
12164    impl NewWithNullPtr for wire_cst_limits {
12165        fn new_with_null_ptr() -> Self {
12166            Self {
12167                min_sat: Default::default(),
12168                max_sat: Default::default(),
12169                max_zero_conf_sat: Default::default(),
12170            }
12171        }
12172    }
12173    impl Default for wire_cst_limits {
12174        fn default() -> Self {
12175            Self::new_with_null_ptr()
12176        }
12177    }
12178    impl NewWithNullPtr for wire_cst_liquid_address_data {
12179        fn new_with_null_ptr() -> Self {
12180            Self {
12181                address: core::ptr::null_mut(),
12182                network: Default::default(),
12183                asset_id: core::ptr::null_mut(),
12184                amount: core::ptr::null_mut(),
12185                amount_sat: core::ptr::null_mut(),
12186                label: core::ptr::null_mut(),
12187                message: core::ptr::null_mut(),
12188            }
12189        }
12190    }
12191    impl Default for wire_cst_liquid_address_data {
12192        fn default() -> Self {
12193            Self::new_with_null_ptr()
12194        }
12195    }
12196    impl NewWithNullPtr for wire_cst_list_payment_details {
12197        fn new_with_null_ptr() -> Self {
12198            Self {
12199                tag: -1,
12200                kind: ListPaymentDetailsKind { nil__: () },
12201            }
12202        }
12203    }
12204    impl Default for wire_cst_list_payment_details {
12205        fn default() -> Self {
12206            Self::new_with_null_ptr()
12207        }
12208    }
12209    impl NewWithNullPtr for wire_cst_list_payments_request {
12210        fn new_with_null_ptr() -> Self {
12211            Self {
12212                filters: core::ptr::null_mut(),
12213                states: core::ptr::null_mut(),
12214                from_timestamp: core::ptr::null_mut(),
12215                to_timestamp: core::ptr::null_mut(),
12216                offset: core::ptr::null_mut(),
12217                limit: core::ptr::null_mut(),
12218                details: core::ptr::null_mut(),
12219                sort_ascending: core::ptr::null_mut(),
12220            }
12221        }
12222    }
12223    impl Default for wire_cst_list_payments_request {
12224        fn default() -> Self {
12225            Self::new_with_null_ptr()
12226        }
12227    }
12228    impl NewWithNullPtr for wire_cst_ln_invoice {
12229        fn new_with_null_ptr() -> Self {
12230            Self {
12231                bolt11: core::ptr::null_mut(),
12232                network: Default::default(),
12233                payee_pubkey: core::ptr::null_mut(),
12234                payment_hash: core::ptr::null_mut(),
12235                description: core::ptr::null_mut(),
12236                description_hash: core::ptr::null_mut(),
12237                amount_msat: core::ptr::null_mut(),
12238                timestamp: Default::default(),
12239                expiry: Default::default(),
12240                routing_hints: core::ptr::null_mut(),
12241                payment_secret: core::ptr::null_mut(),
12242                min_final_cltv_expiry_delta: Default::default(),
12243            }
12244        }
12245    }
12246    impl Default for wire_cst_ln_invoice {
12247        fn default() -> Self {
12248            Self::new_with_null_ptr()
12249        }
12250    }
12251    impl NewWithNullPtr for wire_cst_ln_offer {
12252        fn new_with_null_ptr() -> Self {
12253            Self {
12254                offer: core::ptr::null_mut(),
12255                chains: core::ptr::null_mut(),
12256                min_amount: core::ptr::null_mut(),
12257                description: core::ptr::null_mut(),
12258                absolute_expiry: core::ptr::null_mut(),
12259                issuer: core::ptr::null_mut(),
12260                signing_pubkey: core::ptr::null_mut(),
12261                paths: core::ptr::null_mut(),
12262            }
12263        }
12264    }
12265    impl Default for wire_cst_ln_offer {
12266        fn default() -> Self {
12267            Self::new_with_null_ptr()
12268        }
12269    }
12270    impl NewWithNullPtr for wire_cst_ln_offer_blinded_path {
12271        fn new_with_null_ptr() -> Self {
12272            Self {
12273                blinded_hops: core::ptr::null_mut(),
12274            }
12275        }
12276    }
12277    impl Default for wire_cst_ln_offer_blinded_path {
12278        fn default() -> Self {
12279            Self::new_with_null_ptr()
12280        }
12281    }
12282    impl NewWithNullPtr for wire_cst_ln_url_auth_error {
12283        fn new_with_null_ptr() -> Self {
12284            Self {
12285                tag: -1,
12286                kind: LnUrlAuthErrorKind { nil__: () },
12287            }
12288        }
12289    }
12290    impl Default for wire_cst_ln_url_auth_error {
12291        fn default() -> Self {
12292            Self::new_with_null_ptr()
12293        }
12294    }
12295    impl NewWithNullPtr for wire_cst_ln_url_auth_request_data {
12296        fn new_with_null_ptr() -> Self {
12297            Self {
12298                k1: core::ptr::null_mut(),
12299                action: core::ptr::null_mut(),
12300                domain: core::ptr::null_mut(),
12301                url: core::ptr::null_mut(),
12302            }
12303        }
12304    }
12305    impl Default for wire_cst_ln_url_auth_request_data {
12306        fn default() -> Self {
12307            Self::new_with_null_ptr()
12308        }
12309    }
12310    impl NewWithNullPtr for wire_cst_ln_url_callback_status {
12311        fn new_with_null_ptr() -> Self {
12312            Self {
12313                tag: -1,
12314                kind: LnUrlCallbackStatusKind { nil__: () },
12315            }
12316        }
12317    }
12318    impl Default for wire_cst_ln_url_callback_status {
12319        fn default() -> Self {
12320            Self::new_with_null_ptr()
12321        }
12322    }
12323    impl NewWithNullPtr for wire_cst_ln_url_error_data {
12324        fn new_with_null_ptr() -> Self {
12325            Self {
12326                reason: core::ptr::null_mut(),
12327            }
12328        }
12329    }
12330    impl Default for wire_cst_ln_url_error_data {
12331        fn default() -> Self {
12332            Self::new_with_null_ptr()
12333        }
12334    }
12335    impl NewWithNullPtr for wire_cst_ln_url_info {
12336        fn new_with_null_ptr() -> Self {
12337            Self {
12338                ln_address: core::ptr::null_mut(),
12339                lnurl_pay_comment: core::ptr::null_mut(),
12340                lnurl_pay_domain: core::ptr::null_mut(),
12341                lnurl_pay_metadata: core::ptr::null_mut(),
12342                lnurl_pay_success_action: core::ptr::null_mut(),
12343                lnurl_pay_unprocessed_success_action: core::ptr::null_mut(),
12344                lnurl_withdraw_endpoint: core::ptr::null_mut(),
12345            }
12346        }
12347    }
12348    impl Default for wire_cst_ln_url_info {
12349        fn default() -> Self {
12350            Self::new_with_null_ptr()
12351        }
12352    }
12353    impl NewWithNullPtr for wire_cst_ln_url_pay_error {
12354        fn new_with_null_ptr() -> Self {
12355            Self {
12356                tag: -1,
12357                kind: LnUrlPayErrorKind { nil__: () },
12358            }
12359        }
12360    }
12361    impl Default for wire_cst_ln_url_pay_error {
12362        fn default() -> Self {
12363            Self::new_with_null_ptr()
12364        }
12365    }
12366    impl NewWithNullPtr for wire_cst_ln_url_pay_error_data {
12367        fn new_with_null_ptr() -> Self {
12368            Self {
12369                payment_hash: core::ptr::null_mut(),
12370                reason: core::ptr::null_mut(),
12371            }
12372        }
12373    }
12374    impl Default for wire_cst_ln_url_pay_error_data {
12375        fn default() -> Self {
12376            Self::new_with_null_ptr()
12377        }
12378    }
12379    impl NewWithNullPtr for wire_cst_ln_url_pay_request {
12380        fn new_with_null_ptr() -> Self {
12381            Self {
12382                prepare_response: Default::default(),
12383            }
12384        }
12385    }
12386    impl Default for wire_cst_ln_url_pay_request {
12387        fn default() -> Self {
12388            Self::new_with_null_ptr()
12389        }
12390    }
12391    impl NewWithNullPtr for wire_cst_ln_url_pay_request_data {
12392        fn new_with_null_ptr() -> Self {
12393            Self {
12394                callback: core::ptr::null_mut(),
12395                min_sendable: Default::default(),
12396                max_sendable: Default::default(),
12397                metadata_str: core::ptr::null_mut(),
12398                comment_allowed: Default::default(),
12399                domain: core::ptr::null_mut(),
12400                allows_nostr: Default::default(),
12401                nostr_pubkey: core::ptr::null_mut(),
12402                ln_address: core::ptr::null_mut(),
12403            }
12404        }
12405    }
12406    impl Default for wire_cst_ln_url_pay_request_data {
12407        fn default() -> Self {
12408            Self::new_with_null_ptr()
12409        }
12410    }
12411    impl NewWithNullPtr for wire_cst_ln_url_pay_result {
12412        fn new_with_null_ptr() -> Self {
12413            Self {
12414                tag: -1,
12415                kind: LnUrlPayResultKind { nil__: () },
12416            }
12417        }
12418    }
12419    impl Default for wire_cst_ln_url_pay_result {
12420        fn default() -> Self {
12421            Self::new_with_null_ptr()
12422        }
12423    }
12424    impl NewWithNullPtr for wire_cst_ln_url_pay_success_data {
12425        fn new_with_null_ptr() -> Self {
12426            Self {
12427                payment: Default::default(),
12428                success_action: core::ptr::null_mut(),
12429            }
12430        }
12431    }
12432    impl Default for wire_cst_ln_url_pay_success_data {
12433        fn default() -> Self {
12434            Self::new_with_null_ptr()
12435        }
12436    }
12437    impl NewWithNullPtr for wire_cst_ln_url_withdraw_error {
12438        fn new_with_null_ptr() -> Self {
12439            Self {
12440                tag: -1,
12441                kind: LnUrlWithdrawErrorKind { nil__: () },
12442            }
12443        }
12444    }
12445    impl Default for wire_cst_ln_url_withdraw_error {
12446        fn default() -> Self {
12447            Self::new_with_null_ptr()
12448        }
12449    }
12450    impl NewWithNullPtr for wire_cst_ln_url_withdraw_request {
12451        fn new_with_null_ptr() -> Self {
12452            Self {
12453                data: Default::default(),
12454                amount_msat: Default::default(),
12455                description: core::ptr::null_mut(),
12456            }
12457        }
12458    }
12459    impl Default for wire_cst_ln_url_withdraw_request {
12460        fn default() -> Self {
12461            Self::new_with_null_ptr()
12462        }
12463    }
12464    impl NewWithNullPtr for wire_cst_ln_url_withdraw_request_data {
12465        fn new_with_null_ptr() -> Self {
12466            Self {
12467                callback: core::ptr::null_mut(),
12468                k1: core::ptr::null_mut(),
12469                default_description: core::ptr::null_mut(),
12470                min_withdrawable: Default::default(),
12471                max_withdrawable: Default::default(),
12472            }
12473        }
12474    }
12475    impl Default for wire_cst_ln_url_withdraw_request_data {
12476        fn default() -> Self {
12477            Self::new_with_null_ptr()
12478        }
12479    }
12480    impl NewWithNullPtr for wire_cst_ln_url_withdraw_result {
12481        fn new_with_null_ptr() -> Self {
12482            Self {
12483                tag: -1,
12484                kind: LnUrlWithdrawResultKind { nil__: () },
12485            }
12486        }
12487    }
12488    impl Default for wire_cst_ln_url_withdraw_result {
12489        fn default() -> Self {
12490            Self::new_with_null_ptr()
12491        }
12492    }
12493    impl NewWithNullPtr for wire_cst_ln_url_withdraw_success_data {
12494        fn new_with_null_ptr() -> Self {
12495            Self {
12496                invoice: Default::default(),
12497            }
12498        }
12499    }
12500    impl Default for wire_cst_ln_url_withdraw_success_data {
12501        fn default() -> Self {
12502            Self::new_with_null_ptr()
12503        }
12504    }
12505    impl NewWithNullPtr for wire_cst_locale_overrides {
12506        fn new_with_null_ptr() -> Self {
12507            Self {
12508                locale: core::ptr::null_mut(),
12509                spacing: core::ptr::null_mut(),
12510                symbol: Default::default(),
12511            }
12512        }
12513    }
12514    impl Default for wire_cst_locale_overrides {
12515        fn default() -> Self {
12516            Self::new_with_null_ptr()
12517        }
12518    }
12519    impl NewWithNullPtr for wire_cst_localized_name {
12520        fn new_with_null_ptr() -> Self {
12521            Self {
12522                locale: core::ptr::null_mut(),
12523                name: core::ptr::null_mut(),
12524            }
12525        }
12526    }
12527    impl Default for wire_cst_localized_name {
12528        fn default() -> Self {
12529            Self::new_with_null_ptr()
12530        }
12531    }
12532    impl NewWithNullPtr for wire_cst_log_entry {
12533        fn new_with_null_ptr() -> Self {
12534            Self {
12535                line: core::ptr::null_mut(),
12536                level: core::ptr::null_mut(),
12537            }
12538        }
12539    }
12540    impl Default for wire_cst_log_entry {
12541        fn default() -> Self {
12542            Self::new_with_null_ptr()
12543        }
12544    }
12545    impl NewWithNullPtr for wire_cst_message_success_action_data {
12546        fn new_with_null_ptr() -> Self {
12547            Self {
12548                message: core::ptr::null_mut(),
12549            }
12550        }
12551    }
12552    impl Default for wire_cst_message_success_action_data {
12553        fn default() -> Self {
12554            Self::new_with_null_ptr()
12555        }
12556    }
12557    impl NewWithNullPtr for wire_cst_onchain_payment_limits_response {
12558        fn new_with_null_ptr() -> Self {
12559            Self {
12560                send: Default::default(),
12561                receive: Default::default(),
12562            }
12563        }
12564    }
12565    impl Default for wire_cst_onchain_payment_limits_response {
12566        fn default() -> Self {
12567            Self::new_with_null_ptr()
12568        }
12569    }
12570    impl NewWithNullPtr for wire_cst_pay_amount {
12571        fn new_with_null_ptr() -> Self {
12572            Self {
12573                tag: -1,
12574                kind: PayAmountKind { nil__: () },
12575            }
12576        }
12577    }
12578    impl Default for wire_cst_pay_amount {
12579        fn default() -> Self {
12580            Self::new_with_null_ptr()
12581        }
12582    }
12583    impl NewWithNullPtr for wire_cst_pay_onchain_request {
12584        fn new_with_null_ptr() -> Self {
12585            Self {
12586                address: core::ptr::null_mut(),
12587                prepare_response: Default::default(),
12588            }
12589        }
12590    }
12591    impl Default for wire_cst_pay_onchain_request {
12592        fn default() -> Self {
12593            Self::new_with_null_ptr()
12594        }
12595    }
12596    impl NewWithNullPtr for wire_cst_payment {
12597        fn new_with_null_ptr() -> Self {
12598            Self {
12599                destination: core::ptr::null_mut(),
12600                tx_id: core::ptr::null_mut(),
12601                unblinding_data: core::ptr::null_mut(),
12602                timestamp: Default::default(),
12603                amount_sat: Default::default(),
12604                fees_sat: Default::default(),
12605                swapper_fees_sat: core::ptr::null_mut(),
12606                payment_type: Default::default(),
12607                status: Default::default(),
12608                details: Default::default(),
12609            }
12610        }
12611    }
12612    impl Default for wire_cst_payment {
12613        fn default() -> Self {
12614            Self::new_with_null_ptr()
12615        }
12616    }
12617    impl NewWithNullPtr for wire_cst_payment_details {
12618        fn new_with_null_ptr() -> Self {
12619            Self {
12620                tag: -1,
12621                kind: PaymentDetailsKind { nil__: () },
12622            }
12623        }
12624    }
12625    impl Default for wire_cst_payment_details {
12626        fn default() -> Self {
12627            Self::new_with_null_ptr()
12628        }
12629    }
12630    impl NewWithNullPtr for wire_cst_payment_error {
12631        fn new_with_null_ptr() -> Self {
12632            Self {
12633                tag: -1,
12634                kind: PaymentErrorKind { nil__: () },
12635            }
12636        }
12637    }
12638    impl Default for wire_cst_payment_error {
12639        fn default() -> Self {
12640            Self::new_with_null_ptr()
12641        }
12642    }
12643    impl NewWithNullPtr for wire_cst_prepare_buy_bitcoin_request {
12644        fn new_with_null_ptr() -> Self {
12645            Self {
12646                provider: Default::default(),
12647                amount_sat: Default::default(),
12648            }
12649        }
12650    }
12651    impl Default for wire_cst_prepare_buy_bitcoin_request {
12652        fn default() -> Self {
12653            Self::new_with_null_ptr()
12654        }
12655    }
12656    impl NewWithNullPtr for wire_cst_prepare_buy_bitcoin_response {
12657        fn new_with_null_ptr() -> Self {
12658            Self {
12659                provider: Default::default(),
12660                amount_sat: Default::default(),
12661                fees_sat: Default::default(),
12662            }
12663        }
12664    }
12665    impl Default for wire_cst_prepare_buy_bitcoin_response {
12666        fn default() -> Self {
12667            Self::new_with_null_ptr()
12668        }
12669    }
12670    impl NewWithNullPtr for wire_cst_prepare_ln_url_pay_request {
12671        fn new_with_null_ptr() -> Self {
12672            Self {
12673                data: Default::default(),
12674                amount: Default::default(),
12675                bip353_address: core::ptr::null_mut(),
12676                comment: core::ptr::null_mut(),
12677                validate_success_action_url: core::ptr::null_mut(),
12678            }
12679        }
12680    }
12681    impl Default for wire_cst_prepare_ln_url_pay_request {
12682        fn default() -> Self {
12683            Self::new_with_null_ptr()
12684        }
12685    }
12686    impl NewWithNullPtr for wire_cst_prepare_ln_url_pay_response {
12687        fn new_with_null_ptr() -> Self {
12688            Self {
12689                destination: Default::default(),
12690                fees_sat: Default::default(),
12691                data: Default::default(),
12692                comment: core::ptr::null_mut(),
12693                success_action: core::ptr::null_mut(),
12694            }
12695        }
12696    }
12697    impl Default for wire_cst_prepare_ln_url_pay_response {
12698        fn default() -> Self {
12699            Self::new_with_null_ptr()
12700        }
12701    }
12702    impl NewWithNullPtr for wire_cst_prepare_pay_onchain_request {
12703        fn new_with_null_ptr() -> Self {
12704            Self {
12705                amount: Default::default(),
12706                fee_rate_sat_per_vbyte: core::ptr::null_mut(),
12707            }
12708        }
12709    }
12710    impl Default for wire_cst_prepare_pay_onchain_request {
12711        fn default() -> Self {
12712            Self::new_with_null_ptr()
12713        }
12714    }
12715    impl NewWithNullPtr for wire_cst_prepare_pay_onchain_response {
12716        fn new_with_null_ptr() -> Self {
12717            Self {
12718                receiver_amount_sat: Default::default(),
12719                claim_fees_sat: Default::default(),
12720                total_fees_sat: Default::default(),
12721            }
12722        }
12723    }
12724    impl Default for wire_cst_prepare_pay_onchain_response {
12725        fn default() -> Self {
12726            Self::new_with_null_ptr()
12727        }
12728    }
12729    impl NewWithNullPtr for wire_cst_prepare_receive_request {
12730        fn new_with_null_ptr() -> Self {
12731            Self {
12732                payment_method: Default::default(),
12733                amount: core::ptr::null_mut(),
12734            }
12735        }
12736    }
12737    impl Default for wire_cst_prepare_receive_request {
12738        fn default() -> Self {
12739            Self::new_with_null_ptr()
12740        }
12741    }
12742    impl NewWithNullPtr for wire_cst_prepare_receive_response {
12743        fn new_with_null_ptr() -> Self {
12744            Self {
12745                payment_method: Default::default(),
12746                fees_sat: Default::default(),
12747                amount: core::ptr::null_mut(),
12748                min_payer_amount_sat: core::ptr::null_mut(),
12749                max_payer_amount_sat: core::ptr::null_mut(),
12750                swapper_feerate: core::ptr::null_mut(),
12751            }
12752        }
12753    }
12754    impl Default for wire_cst_prepare_receive_response {
12755        fn default() -> Self {
12756            Self::new_with_null_ptr()
12757        }
12758    }
12759    impl NewWithNullPtr for wire_cst_prepare_refund_request {
12760        fn new_with_null_ptr() -> Self {
12761            Self {
12762                swap_address: core::ptr::null_mut(),
12763                refund_address: core::ptr::null_mut(),
12764                fee_rate_sat_per_vbyte: Default::default(),
12765            }
12766        }
12767    }
12768    impl Default for wire_cst_prepare_refund_request {
12769        fn default() -> Self {
12770            Self::new_with_null_ptr()
12771        }
12772    }
12773    impl NewWithNullPtr for wire_cst_prepare_refund_response {
12774        fn new_with_null_ptr() -> Self {
12775            Self {
12776                tx_vsize: Default::default(),
12777                tx_fee_sat: Default::default(),
12778                last_refund_tx_id: core::ptr::null_mut(),
12779            }
12780        }
12781    }
12782    impl Default for wire_cst_prepare_refund_response {
12783        fn default() -> Self {
12784            Self::new_with_null_ptr()
12785        }
12786    }
12787    impl NewWithNullPtr for wire_cst_prepare_send_request {
12788        fn new_with_null_ptr() -> Self {
12789            Self {
12790                destination: core::ptr::null_mut(),
12791                amount: core::ptr::null_mut(),
12792            }
12793        }
12794    }
12795    impl Default for wire_cst_prepare_send_request {
12796        fn default() -> Self {
12797            Self::new_with_null_ptr()
12798        }
12799    }
12800    impl NewWithNullPtr for wire_cst_prepare_send_response {
12801        fn new_with_null_ptr() -> Self {
12802            Self {
12803                destination: Default::default(),
12804                fees_sat: core::ptr::null_mut(),
12805                estimated_asset_fees: core::ptr::null_mut(),
12806            }
12807        }
12808    }
12809    impl Default for wire_cst_prepare_send_response {
12810        fn default() -> Self {
12811            Self::new_with_null_ptr()
12812        }
12813    }
12814    impl NewWithNullPtr for wire_cst_rate {
12815        fn new_with_null_ptr() -> Self {
12816            Self {
12817                coin: core::ptr::null_mut(),
12818                value: Default::default(),
12819            }
12820        }
12821    }
12822    impl Default for wire_cst_rate {
12823        fn default() -> Self {
12824            Self::new_with_null_ptr()
12825        }
12826    }
12827    impl NewWithNullPtr for wire_cst_receive_amount {
12828        fn new_with_null_ptr() -> Self {
12829            Self {
12830                tag: -1,
12831                kind: ReceiveAmountKind { nil__: () },
12832            }
12833        }
12834    }
12835    impl Default for wire_cst_receive_amount {
12836        fn default() -> Self {
12837            Self::new_with_null_ptr()
12838        }
12839    }
12840    impl NewWithNullPtr for wire_cst_receive_payment_request {
12841        fn new_with_null_ptr() -> Self {
12842            Self {
12843                prepare_response: Default::default(),
12844                description: core::ptr::null_mut(),
12845                use_description_hash: core::ptr::null_mut(),
12846            }
12847        }
12848    }
12849    impl Default for wire_cst_receive_payment_request {
12850        fn default() -> Self {
12851            Self::new_with_null_ptr()
12852        }
12853    }
12854    impl NewWithNullPtr for wire_cst_receive_payment_response {
12855        fn new_with_null_ptr() -> Self {
12856            Self {
12857                destination: core::ptr::null_mut(),
12858            }
12859        }
12860    }
12861    impl Default for wire_cst_receive_payment_response {
12862        fn default() -> Self {
12863            Self::new_with_null_ptr()
12864        }
12865    }
12866    impl NewWithNullPtr for wire_cst_recommended_fees {
12867        fn new_with_null_ptr() -> Self {
12868            Self {
12869                fastest_fee: Default::default(),
12870                half_hour_fee: Default::default(),
12871                hour_fee: Default::default(),
12872                economy_fee: Default::default(),
12873                minimum_fee: Default::default(),
12874            }
12875        }
12876    }
12877    impl Default for wire_cst_recommended_fees {
12878        fn default() -> Self {
12879            Self::new_with_null_ptr()
12880        }
12881    }
12882    impl NewWithNullPtr for wire_cst_refund_request {
12883        fn new_with_null_ptr() -> Self {
12884            Self {
12885                swap_address: core::ptr::null_mut(),
12886                refund_address: core::ptr::null_mut(),
12887                fee_rate_sat_per_vbyte: Default::default(),
12888            }
12889        }
12890    }
12891    impl Default for wire_cst_refund_request {
12892        fn default() -> Self {
12893            Self::new_with_null_ptr()
12894        }
12895    }
12896    impl NewWithNullPtr for wire_cst_refund_response {
12897        fn new_with_null_ptr() -> Self {
12898            Self {
12899                refund_tx_id: core::ptr::null_mut(),
12900            }
12901        }
12902    }
12903    impl Default for wire_cst_refund_response {
12904        fn default() -> Self {
12905            Self::new_with_null_ptr()
12906        }
12907    }
12908    impl NewWithNullPtr for wire_cst_refundable_swap {
12909        fn new_with_null_ptr() -> Self {
12910            Self {
12911                swap_address: core::ptr::null_mut(),
12912                timestamp: Default::default(),
12913                amount_sat: Default::default(),
12914                last_refund_tx_id: core::ptr::null_mut(),
12915            }
12916        }
12917    }
12918    impl Default for wire_cst_refundable_swap {
12919        fn default() -> Self {
12920            Self::new_with_null_ptr()
12921        }
12922    }
12923    impl NewWithNullPtr for wire_cst_restore_request {
12924        fn new_with_null_ptr() -> Self {
12925            Self {
12926                backup_path: core::ptr::null_mut(),
12927            }
12928        }
12929    }
12930    impl Default for wire_cst_restore_request {
12931        fn default() -> Self {
12932            Self::new_with_null_ptr()
12933        }
12934    }
12935    impl NewWithNullPtr for wire_cst_route_hint {
12936        fn new_with_null_ptr() -> Self {
12937            Self {
12938                hops: core::ptr::null_mut(),
12939            }
12940        }
12941    }
12942    impl Default for wire_cst_route_hint {
12943        fn default() -> Self {
12944            Self::new_with_null_ptr()
12945        }
12946    }
12947    impl NewWithNullPtr for wire_cst_route_hint_hop {
12948        fn new_with_null_ptr() -> Self {
12949            Self {
12950                src_node_id: core::ptr::null_mut(),
12951                short_channel_id: core::ptr::null_mut(),
12952                fees_base_msat: Default::default(),
12953                fees_proportional_millionths: Default::default(),
12954                cltv_expiry_delta: Default::default(),
12955                htlc_minimum_msat: core::ptr::null_mut(),
12956                htlc_maximum_msat: core::ptr::null_mut(),
12957            }
12958        }
12959    }
12960    impl Default for wire_cst_route_hint_hop {
12961        fn default() -> Self {
12962            Self::new_with_null_ptr()
12963        }
12964    }
12965    impl NewWithNullPtr for wire_cst_sdk_error {
12966        fn new_with_null_ptr() -> Self {
12967            Self {
12968                tag: -1,
12969                kind: SdkErrorKind { nil__: () },
12970            }
12971        }
12972    }
12973    impl Default for wire_cst_sdk_error {
12974        fn default() -> Self {
12975            Self::new_with_null_ptr()
12976        }
12977    }
12978    impl NewWithNullPtr for wire_cst_sdk_event {
12979        fn new_with_null_ptr() -> Self {
12980            Self {
12981                tag: -1,
12982                kind: SdkEventKind { nil__: () },
12983            }
12984        }
12985    }
12986    impl Default for wire_cst_sdk_event {
12987        fn default() -> Self {
12988            Self::new_with_null_ptr()
12989        }
12990    }
12991    impl NewWithNullPtr for wire_cst_send_destination {
12992        fn new_with_null_ptr() -> Self {
12993            Self {
12994                tag: -1,
12995                kind: SendDestinationKind { nil__: () },
12996            }
12997        }
12998    }
12999    impl Default for wire_cst_send_destination {
13000        fn default() -> Self {
13001            Self::new_with_null_ptr()
13002        }
13003    }
13004    impl NewWithNullPtr for wire_cst_send_payment_request {
13005        fn new_with_null_ptr() -> Self {
13006            Self {
13007                prepare_response: Default::default(),
13008                use_asset_fees: core::ptr::null_mut(),
13009            }
13010        }
13011    }
13012    impl Default for wire_cst_send_payment_request {
13013        fn default() -> Self {
13014            Self::new_with_null_ptr()
13015        }
13016    }
13017    impl NewWithNullPtr for wire_cst_send_payment_response {
13018        fn new_with_null_ptr() -> Self {
13019            Self {
13020                payment: Default::default(),
13021            }
13022        }
13023    }
13024    impl Default for wire_cst_send_payment_response {
13025        fn default() -> Self {
13026            Self::new_with_null_ptr()
13027        }
13028    }
13029    impl NewWithNullPtr for wire_cst_sign_message_request {
13030        fn new_with_null_ptr() -> Self {
13031            Self {
13032                message: core::ptr::null_mut(),
13033            }
13034        }
13035    }
13036    impl Default for wire_cst_sign_message_request {
13037        fn default() -> Self {
13038            Self::new_with_null_ptr()
13039        }
13040    }
13041    impl NewWithNullPtr for wire_cst_sign_message_response {
13042        fn new_with_null_ptr() -> Self {
13043            Self {
13044                signature: core::ptr::null_mut(),
13045            }
13046        }
13047    }
13048    impl Default for wire_cst_sign_message_response {
13049        fn default() -> Self {
13050            Self::new_with_null_ptr()
13051        }
13052    }
13053    impl NewWithNullPtr for wire_cst_success_action {
13054        fn new_with_null_ptr() -> Self {
13055            Self {
13056                tag: -1,
13057                kind: SuccessActionKind { nil__: () },
13058            }
13059        }
13060    }
13061    impl Default for wire_cst_success_action {
13062        fn default() -> Self {
13063            Self::new_with_null_ptr()
13064        }
13065    }
13066    impl NewWithNullPtr for wire_cst_success_action_processed {
13067        fn new_with_null_ptr() -> Self {
13068            Self {
13069                tag: -1,
13070                kind: SuccessActionProcessedKind { nil__: () },
13071            }
13072        }
13073    }
13074    impl Default for wire_cst_success_action_processed {
13075        fn default() -> Self {
13076            Self::new_with_null_ptr()
13077        }
13078    }
13079    impl NewWithNullPtr for wire_cst_symbol {
13080        fn new_with_null_ptr() -> Self {
13081            Self {
13082                grapheme: core::ptr::null_mut(),
13083                template: core::ptr::null_mut(),
13084                rtl: core::ptr::null_mut(),
13085                position: core::ptr::null_mut(),
13086            }
13087        }
13088    }
13089    impl Default for wire_cst_symbol {
13090        fn default() -> Self {
13091            Self::new_with_null_ptr()
13092        }
13093    }
13094    impl NewWithNullPtr for wire_cst_url_success_action_data {
13095        fn new_with_null_ptr() -> Self {
13096            Self {
13097                description: core::ptr::null_mut(),
13098                url: core::ptr::null_mut(),
13099                matches_callback_domain: Default::default(),
13100            }
13101        }
13102    }
13103    impl Default for wire_cst_url_success_action_data {
13104        fn default() -> Self {
13105            Self::new_with_null_ptr()
13106        }
13107    }
13108    impl NewWithNullPtr for wire_cst_wallet_info {
13109        fn new_with_null_ptr() -> Self {
13110            Self {
13111                balance_sat: Default::default(),
13112                pending_send_sat: Default::default(),
13113                pending_receive_sat: Default::default(),
13114                fingerprint: core::ptr::null_mut(),
13115                pubkey: core::ptr::null_mut(),
13116                asset_balances: core::ptr::null_mut(),
13117            }
13118        }
13119    }
13120    impl Default for wire_cst_wallet_info {
13121        fn default() -> Self {
13122            Self::new_with_null_ptr()
13123        }
13124    }
13125
13126    #[unsafe(no_mangle)]
13127    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_accept_payment_proposed_fees(
13128        port_: i64,
13129        that: usize,
13130        req: *mut wire_cst_accept_payment_proposed_fees_request,
13131    ) {
13132        wire__crate__bindings__BindingLiquidSdk_accept_payment_proposed_fees_impl(port_, that, req)
13133    }
13134
13135    #[unsafe(no_mangle)]
13136    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_add_event_listener(
13137        port_: i64,
13138        that: usize,
13139        listener: *mut wire_cst_list_prim_u_8_strict,
13140    ) {
13141        wire__crate__bindings__BindingLiquidSdk_add_event_listener_impl(port_, that, listener)
13142    }
13143
13144    #[unsafe(no_mangle)]
13145    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_backup(
13146        that: usize,
13147        req: *mut wire_cst_backup_request,
13148    ) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
13149        wire__crate__bindings__BindingLiquidSdk_backup_impl(that, req)
13150    }
13151
13152    #[unsafe(no_mangle)]
13153    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_buy_bitcoin(
13154        port_: i64,
13155        that: usize,
13156        req: *mut wire_cst_buy_bitcoin_request,
13157    ) {
13158        wire__crate__bindings__BindingLiquidSdk_buy_bitcoin_impl(port_, that, req)
13159    }
13160
13161    #[unsafe(no_mangle)]
13162    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_check_message(
13163        that: usize,
13164        req: *mut wire_cst_check_message_request,
13165    ) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
13166        wire__crate__bindings__BindingLiquidSdk_check_message_impl(that, req)
13167    }
13168
13169    #[unsafe(no_mangle)]
13170    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_create_bolt12_invoice(
13171        port_: i64,
13172        that: usize,
13173        req: *mut wire_cst_create_bolt_12_invoice_request,
13174    ) {
13175        wire__crate__bindings__BindingLiquidSdk_create_bolt12_invoice_impl(port_, that, req)
13176    }
13177
13178    #[unsafe(no_mangle)]
13179    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_disconnect(
13180        port_: i64,
13181        that: usize,
13182    ) {
13183        wire__crate__bindings__BindingLiquidSdk_disconnect_impl(port_, that)
13184    }
13185
13186    #[unsafe(no_mangle)]
13187    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_empty_wallet_cache(
13188        that: usize,
13189    ) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
13190        wire__crate__bindings__BindingLiquidSdk_empty_wallet_cache_impl(that)
13191    }
13192
13193    #[unsafe(no_mangle)]
13194    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_fetch_fiat_rates(
13195        port_: i64,
13196        that: usize,
13197    ) {
13198        wire__crate__bindings__BindingLiquidSdk_fetch_fiat_rates_impl(port_, that)
13199    }
13200
13201    #[unsafe(no_mangle)]
13202    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_fetch_lightning_limits(
13203        port_: i64,
13204        that: usize,
13205    ) {
13206        wire__crate__bindings__BindingLiquidSdk_fetch_lightning_limits_impl(port_, that)
13207    }
13208
13209    #[unsafe(no_mangle)]
13210    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_fetch_onchain_limits(
13211        port_: i64,
13212        that: usize,
13213    ) {
13214        wire__crate__bindings__BindingLiquidSdk_fetch_onchain_limits_impl(port_, that)
13215    }
13216
13217    #[unsafe(no_mangle)]
13218    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_fetch_payment_proposed_fees(
13219        port_: i64,
13220        that: usize,
13221        req: *mut wire_cst_fetch_payment_proposed_fees_request,
13222    ) {
13223        wire__crate__bindings__BindingLiquidSdk_fetch_payment_proposed_fees_impl(port_, that, req)
13224    }
13225
13226    #[unsafe(no_mangle)]
13227    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_get_info(
13228        port_: i64,
13229        that: usize,
13230    ) {
13231        wire__crate__bindings__BindingLiquidSdk_get_info_impl(port_, that)
13232    }
13233
13234    #[unsafe(no_mangle)]
13235    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_get_payment(
13236        port_: i64,
13237        that: usize,
13238        req: *mut wire_cst_get_payment_request,
13239    ) {
13240        wire__crate__bindings__BindingLiquidSdk_get_payment_impl(port_, that, req)
13241    }
13242
13243    #[unsafe(no_mangle)]
13244    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_list_fiat_currencies(
13245        port_: i64,
13246        that: usize,
13247    ) {
13248        wire__crate__bindings__BindingLiquidSdk_list_fiat_currencies_impl(port_, that)
13249    }
13250
13251    #[unsafe(no_mangle)]
13252    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_list_payments(
13253        port_: i64,
13254        that: usize,
13255        req: *mut wire_cst_list_payments_request,
13256    ) {
13257        wire__crate__bindings__BindingLiquidSdk_list_payments_impl(port_, that, req)
13258    }
13259
13260    #[unsafe(no_mangle)]
13261    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_list_refundables(
13262        port_: i64,
13263        that: usize,
13264    ) {
13265        wire__crate__bindings__BindingLiquidSdk_list_refundables_impl(port_, that)
13266    }
13267
13268    #[unsafe(no_mangle)]
13269    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_lnurl_auth(
13270        port_: i64,
13271        that: usize,
13272        req_data: *mut wire_cst_ln_url_auth_request_data,
13273    ) {
13274        wire__crate__bindings__BindingLiquidSdk_lnurl_auth_impl(port_, that, req_data)
13275    }
13276
13277    #[unsafe(no_mangle)]
13278    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_lnurl_pay(
13279        port_: i64,
13280        that: usize,
13281        req: *mut wire_cst_ln_url_pay_request,
13282    ) {
13283        wire__crate__bindings__BindingLiquidSdk_lnurl_pay_impl(port_, that, req)
13284    }
13285
13286    #[unsafe(no_mangle)]
13287    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_lnurl_withdraw(
13288        port_: i64,
13289        that: usize,
13290        req: *mut wire_cst_ln_url_withdraw_request,
13291    ) {
13292        wire__crate__bindings__BindingLiquidSdk_lnurl_withdraw_impl(port_, that, req)
13293    }
13294
13295    #[unsafe(no_mangle)]
13296    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_parse(
13297        port_: i64,
13298        that: usize,
13299        input: *mut wire_cst_list_prim_u_8_strict,
13300    ) {
13301        wire__crate__bindings__BindingLiquidSdk_parse_impl(port_, that, input)
13302    }
13303
13304    #[unsafe(no_mangle)]
13305    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_pay_onchain(
13306        port_: i64,
13307        that: usize,
13308        req: *mut wire_cst_pay_onchain_request,
13309    ) {
13310        wire__crate__bindings__BindingLiquidSdk_pay_onchain_impl(port_, that, req)
13311    }
13312
13313    #[unsafe(no_mangle)]
13314    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_prepare_buy_bitcoin(
13315        port_: i64,
13316        that: usize,
13317        req: *mut wire_cst_prepare_buy_bitcoin_request,
13318    ) {
13319        wire__crate__bindings__BindingLiquidSdk_prepare_buy_bitcoin_impl(port_, that, req)
13320    }
13321
13322    #[unsafe(no_mangle)]
13323    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_prepare_lnurl_pay(
13324        port_: i64,
13325        that: usize,
13326        req: *mut wire_cst_prepare_ln_url_pay_request,
13327    ) {
13328        wire__crate__bindings__BindingLiquidSdk_prepare_lnurl_pay_impl(port_, that, req)
13329    }
13330
13331    #[unsafe(no_mangle)]
13332    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_prepare_pay_onchain(
13333        port_: i64,
13334        that: usize,
13335        req: *mut wire_cst_prepare_pay_onchain_request,
13336    ) {
13337        wire__crate__bindings__BindingLiquidSdk_prepare_pay_onchain_impl(port_, that, req)
13338    }
13339
13340    #[unsafe(no_mangle)]
13341    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_prepare_receive_payment(
13342        port_: i64,
13343        that: usize,
13344        req: *mut wire_cst_prepare_receive_request,
13345    ) {
13346        wire__crate__bindings__BindingLiquidSdk_prepare_receive_payment_impl(port_, that, req)
13347    }
13348
13349    #[unsafe(no_mangle)]
13350    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_prepare_refund(
13351        port_: i64,
13352        that: usize,
13353        req: *mut wire_cst_prepare_refund_request,
13354    ) {
13355        wire__crate__bindings__BindingLiquidSdk_prepare_refund_impl(port_, that, req)
13356    }
13357
13358    #[unsafe(no_mangle)]
13359    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_prepare_send_payment(
13360        port_: i64,
13361        that: usize,
13362        req: *mut wire_cst_prepare_send_request,
13363    ) {
13364        wire__crate__bindings__BindingLiquidSdk_prepare_send_payment_impl(port_, that, req)
13365    }
13366
13367    #[unsafe(no_mangle)]
13368    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_receive_payment(
13369        port_: i64,
13370        that: usize,
13371        req: *mut wire_cst_receive_payment_request,
13372    ) {
13373        wire__crate__bindings__BindingLiquidSdk_receive_payment_impl(port_, that, req)
13374    }
13375
13376    #[unsafe(no_mangle)]
13377    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_recommended_fees(
13378        port_: i64,
13379        that: usize,
13380    ) {
13381        wire__crate__bindings__BindingLiquidSdk_recommended_fees_impl(port_, that)
13382    }
13383
13384    #[unsafe(no_mangle)]
13385    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_refund(
13386        port_: i64,
13387        that: usize,
13388        req: *mut wire_cst_refund_request,
13389    ) {
13390        wire__crate__bindings__BindingLiquidSdk_refund_impl(port_, that, req)
13391    }
13392
13393    #[unsafe(no_mangle)]
13394    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_register_webhook(
13395        port_: i64,
13396        that: usize,
13397        webhook_url: *mut wire_cst_list_prim_u_8_strict,
13398    ) {
13399        wire__crate__bindings__BindingLiquidSdk_register_webhook_impl(port_, that, webhook_url)
13400    }
13401
13402    #[unsafe(no_mangle)]
13403    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_rescan_onchain_swaps(
13404        port_: i64,
13405        that: usize,
13406    ) {
13407        wire__crate__bindings__BindingLiquidSdk_rescan_onchain_swaps_impl(port_, that)
13408    }
13409
13410    #[unsafe(no_mangle)]
13411    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_restore(
13412        that: usize,
13413        req: *mut wire_cst_restore_request,
13414    ) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
13415        wire__crate__bindings__BindingLiquidSdk_restore_impl(that, req)
13416    }
13417
13418    #[unsafe(no_mangle)]
13419    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_send_payment(
13420        port_: i64,
13421        that: usize,
13422        req: *mut wire_cst_send_payment_request,
13423    ) {
13424        wire__crate__bindings__BindingLiquidSdk_send_payment_impl(port_, that, req)
13425    }
13426
13427    #[unsafe(no_mangle)]
13428    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_sign_message(
13429        that: usize,
13430        req: *mut wire_cst_sign_message_request,
13431    ) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
13432        wire__crate__bindings__BindingLiquidSdk_sign_message_impl(that, req)
13433    }
13434
13435    #[unsafe(no_mangle)]
13436    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_sync(
13437        port_: i64,
13438        that: usize,
13439    ) {
13440        wire__crate__bindings__BindingLiquidSdk_sync_impl(port_, that)
13441    }
13442
13443    #[unsafe(no_mangle)]
13444    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_unregister_webhook(
13445        port_: i64,
13446        that: usize,
13447    ) {
13448        wire__crate__bindings__BindingLiquidSdk_unregister_webhook_impl(port_, that)
13449    }
13450
13451    #[unsafe(no_mangle)]
13452    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__binding_event_listener_on_event(
13453        port_: i64,
13454        that: *mut wire_cst_binding_event_listener,
13455        e: *mut wire_cst_sdk_event,
13456    ) {
13457        wire__crate__bindings__binding_event_listener_on_event_impl(port_, that, e)
13458    }
13459
13460    #[unsafe(no_mangle)]
13461    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__breez_log_stream(
13462        port_: i64,
13463        s: *mut wire_cst_list_prim_u_8_strict,
13464    ) {
13465        wire__crate__bindings__breez_log_stream_impl(port_, s)
13466    }
13467
13468    #[unsafe(no_mangle)]
13469    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__connect(
13470        port_: i64,
13471        req: *mut wire_cst_connect_request,
13472    ) {
13473        wire__crate__bindings__connect_impl(port_, req)
13474    }
13475
13476    #[unsafe(no_mangle)]
13477    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__default_config(
13478        network: i32,
13479        breez_api_key: *mut wire_cst_list_prim_u_8_strict,
13480    ) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
13481        wire__crate__bindings__default_config_impl(network, breez_api_key)
13482    }
13483
13484    #[unsafe(no_mangle)]
13485    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__parse_invoice(
13486        input: *mut wire_cst_list_prim_u_8_strict,
13487    ) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
13488        wire__crate__bindings__parse_invoice_impl(input)
13489    }
13490
13491    #[unsafe(no_mangle)]
13492    pub extern "C" fn frbgen_breez_liquid_rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerBindingLiquidSdk(
13493        ptr: *const std::ffi::c_void,
13494    ) {
13495        unsafe {
13496            StdArc::<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>::increment_strong_count(ptr as _);
13497        }
13498    }
13499
13500    #[unsafe(no_mangle)]
13501    pub extern "C" fn frbgen_breez_liquid_rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerBindingLiquidSdk(
13502        ptr: *const std::ffi::c_void,
13503    ) {
13504        unsafe {
13505            StdArc::<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>::decrement_strong_count(ptr as _);
13506        }
13507    }
13508
13509    #[unsafe(no_mangle)]
13510    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_accept_payment_proposed_fees_request(
13511    ) -> *mut wire_cst_accept_payment_proposed_fees_request {
13512        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13513            wire_cst_accept_payment_proposed_fees_request::new_with_null_ptr(),
13514        )
13515    }
13516
13517    #[unsafe(no_mangle)]
13518    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_aes_success_action_data(
13519    ) -> *mut wire_cst_aes_success_action_data {
13520        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13521            wire_cst_aes_success_action_data::new_with_null_ptr(),
13522        )
13523    }
13524
13525    #[unsafe(no_mangle)]
13526    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_aes_success_action_data_decrypted(
13527    ) -> *mut wire_cst_aes_success_action_data_decrypted {
13528        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13529            wire_cst_aes_success_action_data_decrypted::new_with_null_ptr(),
13530        )
13531    }
13532
13533    #[unsafe(no_mangle)]
13534    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_aes_success_action_data_result(
13535    ) -> *mut wire_cst_aes_success_action_data_result {
13536        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13537            wire_cst_aes_success_action_data_result::new_with_null_ptr(),
13538        )
13539    }
13540
13541    #[unsafe(no_mangle)]
13542    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_amount() -> *mut wire_cst_amount {
13543        flutter_rust_bridge::for_generated::new_leak_box_ptr(wire_cst_amount::new_with_null_ptr())
13544    }
13545
13546    #[unsafe(no_mangle)]
13547    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_asset_info(
13548    ) -> *mut wire_cst_asset_info {
13549        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13550            wire_cst_asset_info::new_with_null_ptr(),
13551        )
13552    }
13553
13554    #[unsafe(no_mangle)]
13555    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_backup_request(
13556    ) -> *mut wire_cst_backup_request {
13557        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13558            wire_cst_backup_request::new_with_null_ptr(),
13559        )
13560    }
13561
13562    #[unsafe(no_mangle)]
13563    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_binding_event_listener(
13564    ) -> *mut wire_cst_binding_event_listener {
13565        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13566            wire_cst_binding_event_listener::new_with_null_ptr(),
13567        )
13568    }
13569
13570    #[unsafe(no_mangle)]
13571    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_bitcoin_address_data(
13572    ) -> *mut wire_cst_bitcoin_address_data {
13573        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13574            wire_cst_bitcoin_address_data::new_with_null_ptr(),
13575        )
13576    }
13577
13578    #[unsafe(no_mangle)]
13579    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_bool(value: bool) -> *mut bool {
13580        flutter_rust_bridge::for_generated::new_leak_box_ptr(value)
13581    }
13582
13583    #[unsafe(no_mangle)]
13584    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_buy_bitcoin_request(
13585    ) -> *mut wire_cst_buy_bitcoin_request {
13586        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13587            wire_cst_buy_bitcoin_request::new_with_null_ptr(),
13588        )
13589    }
13590
13591    #[unsafe(no_mangle)]
13592    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_check_message_request(
13593    ) -> *mut wire_cst_check_message_request {
13594        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13595            wire_cst_check_message_request::new_with_null_ptr(),
13596        )
13597    }
13598
13599    #[unsafe(no_mangle)]
13600    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_connect_request(
13601    ) -> *mut wire_cst_connect_request {
13602        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13603            wire_cst_connect_request::new_with_null_ptr(),
13604        )
13605    }
13606
13607    #[unsafe(no_mangle)]
13608    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_create_bolt_12_invoice_request(
13609    ) -> *mut wire_cst_create_bolt_12_invoice_request {
13610        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13611            wire_cst_create_bolt_12_invoice_request::new_with_null_ptr(),
13612        )
13613    }
13614
13615    #[unsafe(no_mangle)]
13616    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_f_64(value: f64) -> *mut f64 {
13617        flutter_rust_bridge::for_generated::new_leak_box_ptr(value)
13618    }
13619
13620    #[unsafe(no_mangle)]
13621    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_fetch_payment_proposed_fees_request(
13622    ) -> *mut wire_cst_fetch_payment_proposed_fees_request {
13623        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13624            wire_cst_fetch_payment_proposed_fees_request::new_with_null_ptr(),
13625        )
13626    }
13627
13628    #[unsafe(no_mangle)]
13629    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_get_payment_request(
13630    ) -> *mut wire_cst_get_payment_request {
13631        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13632            wire_cst_get_payment_request::new_with_null_ptr(),
13633        )
13634    }
13635
13636    #[unsafe(no_mangle)]
13637    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_i_64(value: i64) -> *mut i64 {
13638        flutter_rust_bridge::for_generated::new_leak_box_ptr(value)
13639    }
13640
13641    #[unsafe(no_mangle)]
13642    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_liquid_address_data(
13643    ) -> *mut wire_cst_liquid_address_data {
13644        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13645            wire_cst_liquid_address_data::new_with_null_ptr(),
13646        )
13647    }
13648
13649    #[unsafe(no_mangle)]
13650    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_list_payment_details(
13651    ) -> *mut wire_cst_list_payment_details {
13652        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13653            wire_cst_list_payment_details::new_with_null_ptr(),
13654        )
13655    }
13656
13657    #[unsafe(no_mangle)]
13658    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_list_payments_request(
13659    ) -> *mut wire_cst_list_payments_request {
13660        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13661            wire_cst_list_payments_request::new_with_null_ptr(),
13662        )
13663    }
13664
13665    #[unsafe(no_mangle)]
13666    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_invoice(
13667    ) -> *mut wire_cst_ln_invoice {
13668        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13669            wire_cst_ln_invoice::new_with_null_ptr(),
13670        )
13671    }
13672
13673    #[unsafe(no_mangle)]
13674    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_offer() -> *mut wire_cst_ln_offer {
13675        flutter_rust_bridge::for_generated::new_leak_box_ptr(wire_cst_ln_offer::new_with_null_ptr())
13676    }
13677
13678    #[unsafe(no_mangle)]
13679    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_url_auth_request_data(
13680    ) -> *mut wire_cst_ln_url_auth_request_data {
13681        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13682            wire_cst_ln_url_auth_request_data::new_with_null_ptr(),
13683        )
13684    }
13685
13686    #[unsafe(no_mangle)]
13687    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_url_error_data(
13688    ) -> *mut wire_cst_ln_url_error_data {
13689        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13690            wire_cst_ln_url_error_data::new_with_null_ptr(),
13691        )
13692    }
13693
13694    #[unsafe(no_mangle)]
13695    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_url_info(
13696    ) -> *mut wire_cst_ln_url_info {
13697        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13698            wire_cst_ln_url_info::new_with_null_ptr(),
13699        )
13700    }
13701
13702    #[unsafe(no_mangle)]
13703    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_url_pay_error_data(
13704    ) -> *mut wire_cst_ln_url_pay_error_data {
13705        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13706            wire_cst_ln_url_pay_error_data::new_with_null_ptr(),
13707        )
13708    }
13709
13710    #[unsafe(no_mangle)]
13711    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_url_pay_request(
13712    ) -> *mut wire_cst_ln_url_pay_request {
13713        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13714            wire_cst_ln_url_pay_request::new_with_null_ptr(),
13715        )
13716    }
13717
13718    #[unsafe(no_mangle)]
13719    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_url_pay_request_data(
13720    ) -> *mut wire_cst_ln_url_pay_request_data {
13721        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13722            wire_cst_ln_url_pay_request_data::new_with_null_ptr(),
13723        )
13724    }
13725
13726    #[unsafe(no_mangle)]
13727    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_url_pay_success_data(
13728    ) -> *mut wire_cst_ln_url_pay_success_data {
13729        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13730            wire_cst_ln_url_pay_success_data::new_with_null_ptr(),
13731        )
13732    }
13733
13734    #[unsafe(no_mangle)]
13735    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_url_withdraw_request(
13736    ) -> *mut wire_cst_ln_url_withdraw_request {
13737        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13738            wire_cst_ln_url_withdraw_request::new_with_null_ptr(),
13739        )
13740    }
13741
13742    #[unsafe(no_mangle)]
13743    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_url_withdraw_request_data(
13744    ) -> *mut wire_cst_ln_url_withdraw_request_data {
13745        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13746            wire_cst_ln_url_withdraw_request_data::new_with_null_ptr(),
13747        )
13748    }
13749
13750    #[unsafe(no_mangle)]
13751    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_url_withdraw_success_data(
13752    ) -> *mut wire_cst_ln_url_withdraw_success_data {
13753        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13754            wire_cst_ln_url_withdraw_success_data::new_with_null_ptr(),
13755        )
13756    }
13757
13758    #[unsafe(no_mangle)]
13759    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_message_success_action_data(
13760    ) -> *mut wire_cst_message_success_action_data {
13761        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13762            wire_cst_message_success_action_data::new_with_null_ptr(),
13763        )
13764    }
13765
13766    #[unsafe(no_mangle)]
13767    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_pay_amount(
13768    ) -> *mut wire_cst_pay_amount {
13769        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13770            wire_cst_pay_amount::new_with_null_ptr(),
13771        )
13772    }
13773
13774    #[unsafe(no_mangle)]
13775    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_pay_onchain_request(
13776    ) -> *mut wire_cst_pay_onchain_request {
13777        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13778            wire_cst_pay_onchain_request::new_with_null_ptr(),
13779        )
13780    }
13781
13782    #[unsafe(no_mangle)]
13783    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_payment() -> *mut wire_cst_payment {
13784        flutter_rust_bridge::for_generated::new_leak_box_ptr(wire_cst_payment::new_with_null_ptr())
13785    }
13786
13787    #[unsafe(no_mangle)]
13788    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_prepare_buy_bitcoin_request(
13789    ) -> *mut wire_cst_prepare_buy_bitcoin_request {
13790        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13791            wire_cst_prepare_buy_bitcoin_request::new_with_null_ptr(),
13792        )
13793    }
13794
13795    #[unsafe(no_mangle)]
13796    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_prepare_ln_url_pay_request(
13797    ) -> *mut wire_cst_prepare_ln_url_pay_request {
13798        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13799            wire_cst_prepare_ln_url_pay_request::new_with_null_ptr(),
13800        )
13801    }
13802
13803    #[unsafe(no_mangle)]
13804    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_prepare_pay_onchain_request(
13805    ) -> *mut wire_cst_prepare_pay_onchain_request {
13806        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13807            wire_cst_prepare_pay_onchain_request::new_with_null_ptr(),
13808        )
13809    }
13810
13811    #[unsafe(no_mangle)]
13812    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_prepare_receive_request(
13813    ) -> *mut wire_cst_prepare_receive_request {
13814        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13815            wire_cst_prepare_receive_request::new_with_null_ptr(),
13816        )
13817    }
13818
13819    #[unsafe(no_mangle)]
13820    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_prepare_refund_request(
13821    ) -> *mut wire_cst_prepare_refund_request {
13822        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13823            wire_cst_prepare_refund_request::new_with_null_ptr(),
13824        )
13825    }
13826
13827    #[unsafe(no_mangle)]
13828    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_prepare_send_request(
13829    ) -> *mut wire_cst_prepare_send_request {
13830        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13831            wire_cst_prepare_send_request::new_with_null_ptr(),
13832        )
13833    }
13834
13835    #[unsafe(no_mangle)]
13836    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_receive_amount(
13837    ) -> *mut wire_cst_receive_amount {
13838        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13839            wire_cst_receive_amount::new_with_null_ptr(),
13840        )
13841    }
13842
13843    #[unsafe(no_mangle)]
13844    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_receive_payment_request(
13845    ) -> *mut wire_cst_receive_payment_request {
13846        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13847            wire_cst_receive_payment_request::new_with_null_ptr(),
13848        )
13849    }
13850
13851    #[unsafe(no_mangle)]
13852    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_refund_request(
13853    ) -> *mut wire_cst_refund_request {
13854        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13855            wire_cst_refund_request::new_with_null_ptr(),
13856        )
13857    }
13858
13859    #[unsafe(no_mangle)]
13860    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_restore_request(
13861    ) -> *mut wire_cst_restore_request {
13862        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13863            wire_cst_restore_request::new_with_null_ptr(),
13864        )
13865    }
13866
13867    #[unsafe(no_mangle)]
13868    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_sdk_event() -> *mut wire_cst_sdk_event
13869    {
13870        flutter_rust_bridge::for_generated::new_leak_box_ptr(wire_cst_sdk_event::new_with_null_ptr())
13871    }
13872
13873    #[unsafe(no_mangle)]
13874    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_send_payment_request(
13875    ) -> *mut wire_cst_send_payment_request {
13876        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13877            wire_cst_send_payment_request::new_with_null_ptr(),
13878        )
13879    }
13880
13881    #[unsafe(no_mangle)]
13882    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_sign_message_request(
13883    ) -> *mut wire_cst_sign_message_request {
13884        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13885            wire_cst_sign_message_request::new_with_null_ptr(),
13886        )
13887    }
13888
13889    #[unsafe(no_mangle)]
13890    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_success_action(
13891    ) -> *mut wire_cst_success_action {
13892        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13893            wire_cst_success_action::new_with_null_ptr(),
13894        )
13895    }
13896
13897    #[unsafe(no_mangle)]
13898    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_success_action_processed(
13899    ) -> *mut wire_cst_success_action_processed {
13900        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13901            wire_cst_success_action_processed::new_with_null_ptr(),
13902        )
13903    }
13904
13905    #[unsafe(no_mangle)]
13906    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_symbol() -> *mut wire_cst_symbol {
13907        flutter_rust_bridge::for_generated::new_leak_box_ptr(wire_cst_symbol::new_with_null_ptr())
13908    }
13909
13910    #[unsafe(no_mangle)]
13911    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_u_32(value: u32) -> *mut u32 {
13912        flutter_rust_bridge::for_generated::new_leak_box_ptr(value)
13913    }
13914
13915    #[unsafe(no_mangle)]
13916    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_u_64(value: u64) -> *mut u64 {
13917        flutter_rust_bridge::for_generated::new_leak_box_ptr(value)
13918    }
13919
13920    #[unsafe(no_mangle)]
13921    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_url_success_action_data(
13922    ) -> *mut wire_cst_url_success_action_data {
13923        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13924            wire_cst_url_success_action_data::new_with_null_ptr(),
13925        )
13926    }
13927
13928    #[unsafe(no_mangle)]
13929    pub extern "C" fn frbgen_breez_liquid_cst_new_list_String(
13930        len: i32,
13931    ) -> *mut wire_cst_list_String {
13932        let wrap = wire_cst_list_String {
13933            ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
13934                <*mut wire_cst_list_prim_u_8_strict>::new_with_null_ptr(),
13935                len,
13936            ),
13937            len,
13938        };
13939        flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
13940    }
13941
13942    #[unsafe(no_mangle)]
13943    pub extern "C" fn frbgen_breez_liquid_cst_new_list_asset_balance(
13944        len: i32,
13945    ) -> *mut wire_cst_list_asset_balance {
13946        let wrap = wire_cst_list_asset_balance {
13947            ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
13948                <wire_cst_asset_balance>::new_with_null_ptr(),
13949                len,
13950            ),
13951            len,
13952        };
13953        flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
13954    }
13955
13956    #[unsafe(no_mangle)]
13957    pub extern "C" fn frbgen_breez_liquid_cst_new_list_asset_metadata(
13958        len: i32,
13959    ) -> *mut wire_cst_list_asset_metadata {
13960        let wrap = wire_cst_list_asset_metadata {
13961            ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
13962                <wire_cst_asset_metadata>::new_with_null_ptr(),
13963                len,
13964            ),
13965            len,
13966        };
13967        flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
13968    }
13969
13970    #[unsafe(no_mangle)]
13971    pub extern "C" fn frbgen_breez_liquid_cst_new_list_external_input_parser(
13972        len: i32,
13973    ) -> *mut wire_cst_list_external_input_parser {
13974        let wrap = wire_cst_list_external_input_parser {
13975            ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
13976                <wire_cst_external_input_parser>::new_with_null_ptr(),
13977                len,
13978            ),
13979            len,
13980        };
13981        flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
13982    }
13983
13984    #[unsafe(no_mangle)]
13985    pub extern "C" fn frbgen_breez_liquid_cst_new_list_fiat_currency(
13986        len: i32,
13987    ) -> *mut wire_cst_list_fiat_currency {
13988        let wrap = wire_cst_list_fiat_currency {
13989            ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
13990                <wire_cst_fiat_currency>::new_with_null_ptr(),
13991                len,
13992            ),
13993            len,
13994        };
13995        flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
13996    }
13997
13998    #[unsafe(no_mangle)]
13999    pub extern "C" fn frbgen_breez_liquid_cst_new_list_ln_offer_blinded_path(
14000        len: i32,
14001    ) -> *mut wire_cst_list_ln_offer_blinded_path {
14002        let wrap = wire_cst_list_ln_offer_blinded_path {
14003            ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
14004                <wire_cst_ln_offer_blinded_path>::new_with_null_ptr(),
14005                len,
14006            ),
14007            len,
14008        };
14009        flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14010    }
14011
14012    #[unsafe(no_mangle)]
14013    pub extern "C" fn frbgen_breez_liquid_cst_new_list_locale_overrides(
14014        len: i32,
14015    ) -> *mut wire_cst_list_locale_overrides {
14016        let wrap = wire_cst_list_locale_overrides {
14017            ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
14018                <wire_cst_locale_overrides>::new_with_null_ptr(),
14019                len,
14020            ),
14021            len,
14022        };
14023        flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14024    }
14025
14026    #[unsafe(no_mangle)]
14027    pub extern "C" fn frbgen_breez_liquid_cst_new_list_localized_name(
14028        len: i32,
14029    ) -> *mut wire_cst_list_localized_name {
14030        let wrap = wire_cst_list_localized_name {
14031            ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
14032                <wire_cst_localized_name>::new_with_null_ptr(),
14033                len,
14034            ),
14035            len,
14036        };
14037        flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14038    }
14039
14040    #[unsafe(no_mangle)]
14041    pub extern "C" fn frbgen_breez_liquid_cst_new_list_payment(
14042        len: i32,
14043    ) -> *mut wire_cst_list_payment {
14044        let wrap = wire_cst_list_payment {
14045            ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
14046                <wire_cst_payment>::new_with_null_ptr(),
14047                len,
14048            ),
14049            len,
14050        };
14051        flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14052    }
14053
14054    #[unsafe(no_mangle)]
14055    pub extern "C" fn frbgen_breez_liquid_cst_new_list_payment_state(
14056        len: i32,
14057    ) -> *mut wire_cst_list_payment_state {
14058        let wrap = wire_cst_list_payment_state {
14059            ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(Default::default(), len),
14060            len,
14061        };
14062        flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14063    }
14064
14065    #[unsafe(no_mangle)]
14066    pub extern "C" fn frbgen_breez_liquid_cst_new_list_payment_type(
14067        len: i32,
14068    ) -> *mut wire_cst_list_payment_type {
14069        let wrap = wire_cst_list_payment_type {
14070            ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(Default::default(), len),
14071            len,
14072        };
14073        flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14074    }
14075
14076    #[unsafe(no_mangle)]
14077    pub extern "C" fn frbgen_breez_liquid_cst_new_list_prim_u_8_strict(
14078        len: i32,
14079    ) -> *mut wire_cst_list_prim_u_8_strict {
14080        let ans = wire_cst_list_prim_u_8_strict {
14081            ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(Default::default(), len),
14082            len,
14083        };
14084        flutter_rust_bridge::for_generated::new_leak_box_ptr(ans)
14085    }
14086
14087    #[unsafe(no_mangle)]
14088    pub extern "C" fn frbgen_breez_liquid_cst_new_list_rate(len: i32) -> *mut wire_cst_list_rate {
14089        let wrap = wire_cst_list_rate {
14090            ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
14091                <wire_cst_rate>::new_with_null_ptr(),
14092                len,
14093            ),
14094            len,
14095        };
14096        flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14097    }
14098
14099    #[unsafe(no_mangle)]
14100    pub extern "C" fn frbgen_breez_liquid_cst_new_list_refundable_swap(
14101        len: i32,
14102    ) -> *mut wire_cst_list_refundable_swap {
14103        let wrap = wire_cst_list_refundable_swap {
14104            ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
14105                <wire_cst_refundable_swap>::new_with_null_ptr(),
14106                len,
14107            ),
14108            len,
14109        };
14110        flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14111    }
14112
14113    #[unsafe(no_mangle)]
14114    pub extern "C" fn frbgen_breez_liquid_cst_new_list_route_hint(
14115        len: i32,
14116    ) -> *mut wire_cst_list_route_hint {
14117        let wrap = wire_cst_list_route_hint {
14118            ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
14119                <wire_cst_route_hint>::new_with_null_ptr(),
14120                len,
14121            ),
14122            len,
14123        };
14124        flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14125    }
14126
14127    #[unsafe(no_mangle)]
14128    pub extern "C" fn frbgen_breez_liquid_cst_new_list_route_hint_hop(
14129        len: i32,
14130    ) -> *mut wire_cst_list_route_hint_hop {
14131        let wrap = wire_cst_list_route_hint_hop {
14132            ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
14133                <wire_cst_route_hint_hop>::new_with_null_ptr(),
14134                len,
14135            ),
14136            len,
14137        };
14138        flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14139    }
14140
14141    #[repr(C)]
14142    #[derive(Clone, Copy)]
14143    pub struct wire_cst_accept_payment_proposed_fees_request {
14144        response: wire_cst_fetch_payment_proposed_fees_response,
14145    }
14146    #[repr(C)]
14147    #[derive(Clone, Copy)]
14148    pub struct wire_cst_aes_success_action_data {
14149        description: *mut wire_cst_list_prim_u_8_strict,
14150        ciphertext: *mut wire_cst_list_prim_u_8_strict,
14151        iv: *mut wire_cst_list_prim_u_8_strict,
14152    }
14153    #[repr(C)]
14154    #[derive(Clone, Copy)]
14155    pub struct wire_cst_aes_success_action_data_decrypted {
14156        description: *mut wire_cst_list_prim_u_8_strict,
14157        plaintext: *mut wire_cst_list_prim_u_8_strict,
14158    }
14159    #[repr(C)]
14160    #[derive(Clone, Copy)]
14161    pub struct wire_cst_aes_success_action_data_result {
14162        tag: i32,
14163        kind: AesSuccessActionDataResultKind,
14164    }
14165    #[repr(C)]
14166    #[derive(Clone, Copy)]
14167    pub union AesSuccessActionDataResultKind {
14168        Decrypted: wire_cst_AesSuccessActionDataResult_Decrypted,
14169        ErrorStatus: wire_cst_AesSuccessActionDataResult_ErrorStatus,
14170        nil__: (),
14171    }
14172    #[repr(C)]
14173    #[derive(Clone, Copy)]
14174    pub struct wire_cst_AesSuccessActionDataResult_Decrypted {
14175        data: *mut wire_cst_aes_success_action_data_decrypted,
14176    }
14177    #[repr(C)]
14178    #[derive(Clone, Copy)]
14179    pub struct wire_cst_AesSuccessActionDataResult_ErrorStatus {
14180        reason: *mut wire_cst_list_prim_u_8_strict,
14181    }
14182    #[repr(C)]
14183    #[derive(Clone, Copy)]
14184    pub struct wire_cst_amount {
14185        tag: i32,
14186        kind: AmountKind,
14187    }
14188    #[repr(C)]
14189    #[derive(Clone, Copy)]
14190    pub union AmountKind {
14191        Bitcoin: wire_cst_Amount_Bitcoin,
14192        Currency: wire_cst_Amount_Currency,
14193        nil__: (),
14194    }
14195    #[repr(C)]
14196    #[derive(Clone, Copy)]
14197    pub struct wire_cst_Amount_Bitcoin {
14198        amount_msat: u64,
14199    }
14200    #[repr(C)]
14201    #[derive(Clone, Copy)]
14202    pub struct wire_cst_Amount_Currency {
14203        iso4217_code: *mut wire_cst_list_prim_u_8_strict,
14204        fractional_amount: u64,
14205    }
14206    #[repr(C)]
14207    #[derive(Clone, Copy)]
14208    pub struct wire_cst_asset_balance {
14209        asset_id: *mut wire_cst_list_prim_u_8_strict,
14210        balance_sat: u64,
14211        name: *mut wire_cst_list_prim_u_8_strict,
14212        ticker: *mut wire_cst_list_prim_u_8_strict,
14213        balance: *mut f64,
14214    }
14215    #[repr(C)]
14216    #[derive(Clone, Copy)]
14217    pub struct wire_cst_asset_info {
14218        name: *mut wire_cst_list_prim_u_8_strict,
14219        ticker: *mut wire_cst_list_prim_u_8_strict,
14220        amount: f64,
14221        fees: *mut f64,
14222    }
14223    #[repr(C)]
14224    #[derive(Clone, Copy)]
14225    pub struct wire_cst_asset_metadata {
14226        asset_id: *mut wire_cst_list_prim_u_8_strict,
14227        name: *mut wire_cst_list_prim_u_8_strict,
14228        ticker: *mut wire_cst_list_prim_u_8_strict,
14229        precision: u8,
14230        fiat_id: *mut wire_cst_list_prim_u_8_strict,
14231    }
14232    #[repr(C)]
14233    #[derive(Clone, Copy)]
14234    pub struct wire_cst_backup_request {
14235        backup_path: *mut wire_cst_list_prim_u_8_strict,
14236    }
14237    #[repr(C)]
14238    #[derive(Clone, Copy)]
14239    pub struct wire_cst_binding_event_listener {
14240        stream: *mut wire_cst_list_prim_u_8_strict,
14241    }
14242    #[repr(C)]
14243    #[derive(Clone, Copy)]
14244    pub struct wire_cst_bitcoin_address_data {
14245        address: *mut wire_cst_list_prim_u_8_strict,
14246        network: i32,
14247        amount_sat: *mut u64,
14248        label: *mut wire_cst_list_prim_u_8_strict,
14249        message: *mut wire_cst_list_prim_u_8_strict,
14250    }
14251    #[repr(C)]
14252    #[derive(Clone, Copy)]
14253    pub struct wire_cst_blockchain_explorer {
14254        tag: i32,
14255        kind: BlockchainExplorerKind,
14256    }
14257    #[repr(C)]
14258    #[derive(Clone, Copy)]
14259    pub union BlockchainExplorerKind {
14260        Electrum: wire_cst_BlockchainExplorer_Electrum,
14261        Esplora: wire_cst_BlockchainExplorer_Esplora,
14262        nil__: (),
14263    }
14264    #[repr(C)]
14265    #[derive(Clone, Copy)]
14266    pub struct wire_cst_BlockchainExplorer_Electrum {
14267        url: *mut wire_cst_list_prim_u_8_strict,
14268    }
14269    #[repr(C)]
14270    #[derive(Clone, Copy)]
14271    pub struct wire_cst_BlockchainExplorer_Esplora {
14272        url: *mut wire_cst_list_prim_u_8_strict,
14273        use_waterfalls: bool,
14274    }
14275    #[repr(C)]
14276    #[derive(Clone, Copy)]
14277    pub struct wire_cst_blockchain_info {
14278        liquid_tip: u32,
14279        bitcoin_tip: u32,
14280    }
14281    #[repr(C)]
14282    #[derive(Clone, Copy)]
14283    pub struct wire_cst_buy_bitcoin_request {
14284        prepare_response: wire_cst_prepare_buy_bitcoin_response,
14285        redirect_url: *mut wire_cst_list_prim_u_8_strict,
14286    }
14287    #[repr(C)]
14288    #[derive(Clone, Copy)]
14289    pub struct wire_cst_check_message_request {
14290        message: *mut wire_cst_list_prim_u_8_strict,
14291        pubkey: *mut wire_cst_list_prim_u_8_strict,
14292        signature: *mut wire_cst_list_prim_u_8_strict,
14293    }
14294    #[repr(C)]
14295    #[derive(Clone, Copy)]
14296    pub struct wire_cst_check_message_response {
14297        is_valid: bool,
14298    }
14299    #[repr(C)]
14300    #[derive(Clone, Copy)]
14301    pub struct wire_cst_config {
14302        liquid_explorer: wire_cst_blockchain_explorer,
14303        bitcoin_explorer: wire_cst_blockchain_explorer,
14304        working_dir: *mut wire_cst_list_prim_u_8_strict,
14305        cache_dir: *mut wire_cst_list_prim_u_8_strict,
14306        network: i32,
14307        payment_timeout_sec: u64,
14308        sync_service_url: *mut wire_cst_list_prim_u_8_strict,
14309        zero_conf_max_amount_sat: *mut u64,
14310        breez_api_key: *mut wire_cst_list_prim_u_8_strict,
14311        external_input_parsers: *mut wire_cst_list_external_input_parser,
14312        use_default_external_input_parsers: bool,
14313        onchain_fee_rate_leeway_sat_per_vbyte: *mut u32,
14314        asset_metadata: *mut wire_cst_list_asset_metadata,
14315        sideswap_api_key: *mut wire_cst_list_prim_u_8_strict,
14316    }
14317    #[repr(C)]
14318    #[derive(Clone, Copy)]
14319    pub struct wire_cst_connect_request {
14320        config: wire_cst_config,
14321        mnemonic: *mut wire_cst_list_prim_u_8_strict,
14322        passphrase: *mut wire_cst_list_prim_u_8_strict,
14323        seed: *mut wire_cst_list_prim_u_8_strict,
14324    }
14325    #[repr(C)]
14326    #[derive(Clone, Copy)]
14327    pub struct wire_cst_create_bolt_12_invoice_request {
14328        offer: *mut wire_cst_list_prim_u_8_strict,
14329        invoice_request: *mut wire_cst_list_prim_u_8_strict,
14330    }
14331    #[repr(C)]
14332    #[derive(Clone, Copy)]
14333    pub struct wire_cst_create_bolt_12_invoice_response {
14334        invoice: *mut wire_cst_list_prim_u_8_strict,
14335    }
14336    #[repr(C)]
14337    #[derive(Clone, Copy)]
14338    pub struct wire_cst_currency_info {
14339        name: *mut wire_cst_list_prim_u_8_strict,
14340        fraction_size: u32,
14341        spacing: *mut u32,
14342        symbol: *mut wire_cst_symbol,
14343        uniq_symbol: *mut wire_cst_symbol,
14344        localized_name: *mut wire_cst_list_localized_name,
14345        locale_overrides: *mut wire_cst_list_locale_overrides,
14346    }
14347    #[repr(C)]
14348    #[derive(Clone, Copy)]
14349    pub struct wire_cst_external_input_parser {
14350        provider_id: *mut wire_cst_list_prim_u_8_strict,
14351        input_regex: *mut wire_cst_list_prim_u_8_strict,
14352        parser_url: *mut wire_cst_list_prim_u_8_strict,
14353    }
14354    #[repr(C)]
14355    #[derive(Clone, Copy)]
14356    pub struct wire_cst_fetch_payment_proposed_fees_request {
14357        swap_id: *mut wire_cst_list_prim_u_8_strict,
14358    }
14359    #[repr(C)]
14360    #[derive(Clone, Copy)]
14361    pub struct wire_cst_fetch_payment_proposed_fees_response {
14362        swap_id: *mut wire_cst_list_prim_u_8_strict,
14363        fees_sat: u64,
14364        payer_amount_sat: u64,
14365        receiver_amount_sat: u64,
14366    }
14367    #[repr(C)]
14368    #[derive(Clone, Copy)]
14369    pub struct wire_cst_fiat_currency {
14370        id: *mut wire_cst_list_prim_u_8_strict,
14371        info: wire_cst_currency_info,
14372    }
14373    #[repr(C)]
14374    #[derive(Clone, Copy)]
14375    pub struct wire_cst_get_info_response {
14376        wallet_info: wire_cst_wallet_info,
14377        blockchain_info: wire_cst_blockchain_info,
14378    }
14379    #[repr(C)]
14380    #[derive(Clone, Copy)]
14381    pub struct wire_cst_get_payment_request {
14382        tag: i32,
14383        kind: GetPaymentRequestKind,
14384    }
14385    #[repr(C)]
14386    #[derive(Clone, Copy)]
14387    pub union GetPaymentRequestKind {
14388        PaymentHash: wire_cst_GetPaymentRequest_PaymentHash,
14389        SwapId: wire_cst_GetPaymentRequest_SwapId,
14390        nil__: (),
14391    }
14392    #[repr(C)]
14393    #[derive(Clone, Copy)]
14394    pub struct wire_cst_GetPaymentRequest_PaymentHash {
14395        payment_hash: *mut wire_cst_list_prim_u_8_strict,
14396    }
14397    #[repr(C)]
14398    #[derive(Clone, Copy)]
14399    pub struct wire_cst_GetPaymentRequest_SwapId {
14400        swap_id: *mut wire_cst_list_prim_u_8_strict,
14401    }
14402    #[repr(C)]
14403    #[derive(Clone, Copy)]
14404    pub struct wire_cst_input_type {
14405        tag: i32,
14406        kind: InputTypeKind,
14407    }
14408    #[repr(C)]
14409    #[derive(Clone, Copy)]
14410    pub union InputTypeKind {
14411        BitcoinAddress: wire_cst_InputType_BitcoinAddress,
14412        LiquidAddress: wire_cst_InputType_LiquidAddress,
14413        Bolt11: wire_cst_InputType_Bolt11,
14414        Bolt12Offer: wire_cst_InputType_Bolt12Offer,
14415        NodeId: wire_cst_InputType_NodeId,
14416        Url: wire_cst_InputType_Url,
14417        LnUrlPay: wire_cst_InputType_LnUrlPay,
14418        LnUrlWithdraw: wire_cst_InputType_LnUrlWithdraw,
14419        LnUrlAuth: wire_cst_InputType_LnUrlAuth,
14420        LnUrlError: wire_cst_InputType_LnUrlError,
14421        nil__: (),
14422    }
14423    #[repr(C)]
14424    #[derive(Clone, Copy)]
14425    pub struct wire_cst_InputType_BitcoinAddress {
14426        address: *mut wire_cst_bitcoin_address_data,
14427    }
14428    #[repr(C)]
14429    #[derive(Clone, Copy)]
14430    pub struct wire_cst_InputType_LiquidAddress {
14431        address: *mut wire_cst_liquid_address_data,
14432    }
14433    #[repr(C)]
14434    #[derive(Clone, Copy)]
14435    pub struct wire_cst_InputType_Bolt11 {
14436        invoice: *mut wire_cst_ln_invoice,
14437    }
14438    #[repr(C)]
14439    #[derive(Clone, Copy)]
14440    pub struct wire_cst_InputType_Bolt12Offer {
14441        offer: *mut wire_cst_ln_offer,
14442        bip353_address: *mut wire_cst_list_prim_u_8_strict,
14443    }
14444    #[repr(C)]
14445    #[derive(Clone, Copy)]
14446    pub struct wire_cst_InputType_NodeId {
14447        node_id: *mut wire_cst_list_prim_u_8_strict,
14448    }
14449    #[repr(C)]
14450    #[derive(Clone, Copy)]
14451    pub struct wire_cst_InputType_Url {
14452        url: *mut wire_cst_list_prim_u_8_strict,
14453    }
14454    #[repr(C)]
14455    #[derive(Clone, Copy)]
14456    pub struct wire_cst_InputType_LnUrlPay {
14457        data: *mut wire_cst_ln_url_pay_request_data,
14458        bip353_address: *mut wire_cst_list_prim_u_8_strict,
14459    }
14460    #[repr(C)]
14461    #[derive(Clone, Copy)]
14462    pub struct wire_cst_InputType_LnUrlWithdraw {
14463        data: *mut wire_cst_ln_url_withdraw_request_data,
14464    }
14465    #[repr(C)]
14466    #[derive(Clone, Copy)]
14467    pub struct wire_cst_InputType_LnUrlAuth {
14468        data: *mut wire_cst_ln_url_auth_request_data,
14469    }
14470    #[repr(C)]
14471    #[derive(Clone, Copy)]
14472    pub struct wire_cst_InputType_LnUrlError {
14473        data: *mut wire_cst_ln_url_error_data,
14474    }
14475    #[repr(C)]
14476    #[derive(Clone, Copy)]
14477    pub struct wire_cst_lightning_payment_limits_response {
14478        send: wire_cst_limits,
14479        receive: wire_cst_limits,
14480    }
14481    #[repr(C)]
14482    #[derive(Clone, Copy)]
14483    pub struct wire_cst_limits {
14484        min_sat: u64,
14485        max_sat: u64,
14486        max_zero_conf_sat: u64,
14487    }
14488    #[repr(C)]
14489    #[derive(Clone, Copy)]
14490    pub struct wire_cst_liquid_address_data {
14491        address: *mut wire_cst_list_prim_u_8_strict,
14492        network: i32,
14493        asset_id: *mut wire_cst_list_prim_u_8_strict,
14494        amount: *mut f64,
14495        amount_sat: *mut u64,
14496        label: *mut wire_cst_list_prim_u_8_strict,
14497        message: *mut wire_cst_list_prim_u_8_strict,
14498    }
14499    #[repr(C)]
14500    #[derive(Clone, Copy)]
14501    pub struct wire_cst_list_String {
14502        ptr: *mut *mut wire_cst_list_prim_u_8_strict,
14503        len: i32,
14504    }
14505    #[repr(C)]
14506    #[derive(Clone, Copy)]
14507    pub struct wire_cst_list_asset_balance {
14508        ptr: *mut wire_cst_asset_balance,
14509        len: i32,
14510    }
14511    #[repr(C)]
14512    #[derive(Clone, Copy)]
14513    pub struct wire_cst_list_asset_metadata {
14514        ptr: *mut wire_cst_asset_metadata,
14515        len: i32,
14516    }
14517    #[repr(C)]
14518    #[derive(Clone, Copy)]
14519    pub struct wire_cst_list_external_input_parser {
14520        ptr: *mut wire_cst_external_input_parser,
14521        len: i32,
14522    }
14523    #[repr(C)]
14524    #[derive(Clone, Copy)]
14525    pub struct wire_cst_list_fiat_currency {
14526        ptr: *mut wire_cst_fiat_currency,
14527        len: i32,
14528    }
14529    #[repr(C)]
14530    #[derive(Clone, Copy)]
14531    pub struct wire_cst_list_ln_offer_blinded_path {
14532        ptr: *mut wire_cst_ln_offer_blinded_path,
14533        len: i32,
14534    }
14535    #[repr(C)]
14536    #[derive(Clone, Copy)]
14537    pub struct wire_cst_list_locale_overrides {
14538        ptr: *mut wire_cst_locale_overrides,
14539        len: i32,
14540    }
14541    #[repr(C)]
14542    #[derive(Clone, Copy)]
14543    pub struct wire_cst_list_localized_name {
14544        ptr: *mut wire_cst_localized_name,
14545        len: i32,
14546    }
14547    #[repr(C)]
14548    #[derive(Clone, Copy)]
14549    pub struct wire_cst_list_payment {
14550        ptr: *mut wire_cst_payment,
14551        len: i32,
14552    }
14553    #[repr(C)]
14554    #[derive(Clone, Copy)]
14555    pub struct wire_cst_list_payment_details {
14556        tag: i32,
14557        kind: ListPaymentDetailsKind,
14558    }
14559    #[repr(C)]
14560    #[derive(Clone, Copy)]
14561    pub union ListPaymentDetailsKind {
14562        Liquid: wire_cst_ListPaymentDetails_Liquid,
14563        Bitcoin: wire_cst_ListPaymentDetails_Bitcoin,
14564        nil__: (),
14565    }
14566    #[repr(C)]
14567    #[derive(Clone, Copy)]
14568    pub struct wire_cst_ListPaymentDetails_Liquid {
14569        asset_id: *mut wire_cst_list_prim_u_8_strict,
14570        destination: *mut wire_cst_list_prim_u_8_strict,
14571    }
14572    #[repr(C)]
14573    #[derive(Clone, Copy)]
14574    pub struct wire_cst_ListPaymentDetails_Bitcoin {
14575        address: *mut wire_cst_list_prim_u_8_strict,
14576    }
14577    #[repr(C)]
14578    #[derive(Clone, Copy)]
14579    pub struct wire_cst_list_payment_state {
14580        ptr: *mut i32,
14581        len: i32,
14582    }
14583    #[repr(C)]
14584    #[derive(Clone, Copy)]
14585    pub struct wire_cst_list_payment_type {
14586        ptr: *mut i32,
14587        len: i32,
14588    }
14589    #[repr(C)]
14590    #[derive(Clone, Copy)]
14591    pub struct wire_cst_list_payments_request {
14592        filters: *mut wire_cst_list_payment_type,
14593        states: *mut wire_cst_list_payment_state,
14594        from_timestamp: *mut i64,
14595        to_timestamp: *mut i64,
14596        offset: *mut u32,
14597        limit: *mut u32,
14598        details: *mut wire_cst_list_payment_details,
14599        sort_ascending: *mut bool,
14600    }
14601    #[repr(C)]
14602    #[derive(Clone, Copy)]
14603    pub struct wire_cst_list_prim_u_8_strict {
14604        ptr: *mut u8,
14605        len: i32,
14606    }
14607    #[repr(C)]
14608    #[derive(Clone, Copy)]
14609    pub struct wire_cst_list_rate {
14610        ptr: *mut wire_cst_rate,
14611        len: i32,
14612    }
14613    #[repr(C)]
14614    #[derive(Clone, Copy)]
14615    pub struct wire_cst_list_refundable_swap {
14616        ptr: *mut wire_cst_refundable_swap,
14617        len: i32,
14618    }
14619    #[repr(C)]
14620    #[derive(Clone, Copy)]
14621    pub struct wire_cst_list_route_hint {
14622        ptr: *mut wire_cst_route_hint,
14623        len: i32,
14624    }
14625    #[repr(C)]
14626    #[derive(Clone, Copy)]
14627    pub struct wire_cst_list_route_hint_hop {
14628        ptr: *mut wire_cst_route_hint_hop,
14629        len: i32,
14630    }
14631    #[repr(C)]
14632    #[derive(Clone, Copy)]
14633    pub struct wire_cst_ln_invoice {
14634        bolt11: *mut wire_cst_list_prim_u_8_strict,
14635        network: i32,
14636        payee_pubkey: *mut wire_cst_list_prim_u_8_strict,
14637        payment_hash: *mut wire_cst_list_prim_u_8_strict,
14638        description: *mut wire_cst_list_prim_u_8_strict,
14639        description_hash: *mut wire_cst_list_prim_u_8_strict,
14640        amount_msat: *mut u64,
14641        timestamp: u64,
14642        expiry: u64,
14643        routing_hints: *mut wire_cst_list_route_hint,
14644        payment_secret: *mut wire_cst_list_prim_u_8_strict,
14645        min_final_cltv_expiry_delta: u64,
14646    }
14647    #[repr(C)]
14648    #[derive(Clone, Copy)]
14649    pub struct wire_cst_ln_offer {
14650        offer: *mut wire_cst_list_prim_u_8_strict,
14651        chains: *mut wire_cst_list_String,
14652        min_amount: *mut wire_cst_amount,
14653        description: *mut wire_cst_list_prim_u_8_strict,
14654        absolute_expiry: *mut u64,
14655        issuer: *mut wire_cst_list_prim_u_8_strict,
14656        signing_pubkey: *mut wire_cst_list_prim_u_8_strict,
14657        paths: *mut wire_cst_list_ln_offer_blinded_path,
14658    }
14659    #[repr(C)]
14660    #[derive(Clone, Copy)]
14661    pub struct wire_cst_ln_offer_blinded_path {
14662        blinded_hops: *mut wire_cst_list_String,
14663    }
14664    #[repr(C)]
14665    #[derive(Clone, Copy)]
14666    pub struct wire_cst_ln_url_auth_error {
14667        tag: i32,
14668        kind: LnUrlAuthErrorKind,
14669    }
14670    #[repr(C)]
14671    #[derive(Clone, Copy)]
14672    pub union LnUrlAuthErrorKind {
14673        Generic: wire_cst_LnUrlAuthError_Generic,
14674        InvalidUri: wire_cst_LnUrlAuthError_InvalidUri,
14675        ServiceConnectivity: wire_cst_LnUrlAuthError_ServiceConnectivity,
14676        nil__: (),
14677    }
14678    #[repr(C)]
14679    #[derive(Clone, Copy)]
14680    pub struct wire_cst_LnUrlAuthError_Generic {
14681        err: *mut wire_cst_list_prim_u_8_strict,
14682    }
14683    #[repr(C)]
14684    #[derive(Clone, Copy)]
14685    pub struct wire_cst_LnUrlAuthError_InvalidUri {
14686        err: *mut wire_cst_list_prim_u_8_strict,
14687    }
14688    #[repr(C)]
14689    #[derive(Clone, Copy)]
14690    pub struct wire_cst_LnUrlAuthError_ServiceConnectivity {
14691        err: *mut wire_cst_list_prim_u_8_strict,
14692    }
14693    #[repr(C)]
14694    #[derive(Clone, Copy)]
14695    pub struct wire_cst_ln_url_auth_request_data {
14696        k1: *mut wire_cst_list_prim_u_8_strict,
14697        action: *mut wire_cst_list_prim_u_8_strict,
14698        domain: *mut wire_cst_list_prim_u_8_strict,
14699        url: *mut wire_cst_list_prim_u_8_strict,
14700    }
14701    #[repr(C)]
14702    #[derive(Clone, Copy)]
14703    pub struct wire_cst_ln_url_callback_status {
14704        tag: i32,
14705        kind: LnUrlCallbackStatusKind,
14706    }
14707    #[repr(C)]
14708    #[derive(Clone, Copy)]
14709    pub union LnUrlCallbackStatusKind {
14710        ErrorStatus: wire_cst_LnUrlCallbackStatus_ErrorStatus,
14711        nil__: (),
14712    }
14713    #[repr(C)]
14714    #[derive(Clone, Copy)]
14715    pub struct wire_cst_LnUrlCallbackStatus_ErrorStatus {
14716        data: *mut wire_cst_ln_url_error_data,
14717    }
14718    #[repr(C)]
14719    #[derive(Clone, Copy)]
14720    pub struct wire_cst_ln_url_error_data {
14721        reason: *mut wire_cst_list_prim_u_8_strict,
14722    }
14723    #[repr(C)]
14724    #[derive(Clone, Copy)]
14725    pub struct wire_cst_ln_url_info {
14726        ln_address: *mut wire_cst_list_prim_u_8_strict,
14727        lnurl_pay_comment: *mut wire_cst_list_prim_u_8_strict,
14728        lnurl_pay_domain: *mut wire_cst_list_prim_u_8_strict,
14729        lnurl_pay_metadata: *mut wire_cst_list_prim_u_8_strict,
14730        lnurl_pay_success_action: *mut wire_cst_success_action_processed,
14731        lnurl_pay_unprocessed_success_action: *mut wire_cst_success_action,
14732        lnurl_withdraw_endpoint: *mut wire_cst_list_prim_u_8_strict,
14733    }
14734    #[repr(C)]
14735    #[derive(Clone, Copy)]
14736    pub struct wire_cst_ln_url_pay_error {
14737        tag: i32,
14738        kind: LnUrlPayErrorKind,
14739    }
14740    #[repr(C)]
14741    #[derive(Clone, Copy)]
14742    pub union LnUrlPayErrorKind {
14743        Generic: wire_cst_LnUrlPayError_Generic,
14744        InsufficientBalance: wire_cst_LnUrlPayError_InsufficientBalance,
14745        InvalidAmount: wire_cst_LnUrlPayError_InvalidAmount,
14746        InvalidInvoice: wire_cst_LnUrlPayError_InvalidInvoice,
14747        InvalidNetwork: wire_cst_LnUrlPayError_InvalidNetwork,
14748        InvalidUri: wire_cst_LnUrlPayError_InvalidUri,
14749        InvoiceExpired: wire_cst_LnUrlPayError_InvoiceExpired,
14750        PaymentFailed: wire_cst_LnUrlPayError_PaymentFailed,
14751        PaymentTimeout: wire_cst_LnUrlPayError_PaymentTimeout,
14752        RouteNotFound: wire_cst_LnUrlPayError_RouteNotFound,
14753        RouteTooExpensive: wire_cst_LnUrlPayError_RouteTooExpensive,
14754        ServiceConnectivity: wire_cst_LnUrlPayError_ServiceConnectivity,
14755        nil__: (),
14756    }
14757    #[repr(C)]
14758    #[derive(Clone, Copy)]
14759    pub struct wire_cst_LnUrlPayError_Generic {
14760        err: *mut wire_cst_list_prim_u_8_strict,
14761    }
14762    #[repr(C)]
14763    #[derive(Clone, Copy)]
14764    pub struct wire_cst_LnUrlPayError_InsufficientBalance {
14765        err: *mut wire_cst_list_prim_u_8_strict,
14766    }
14767    #[repr(C)]
14768    #[derive(Clone, Copy)]
14769    pub struct wire_cst_LnUrlPayError_InvalidAmount {
14770        err: *mut wire_cst_list_prim_u_8_strict,
14771    }
14772    #[repr(C)]
14773    #[derive(Clone, Copy)]
14774    pub struct wire_cst_LnUrlPayError_InvalidInvoice {
14775        err: *mut wire_cst_list_prim_u_8_strict,
14776    }
14777    #[repr(C)]
14778    #[derive(Clone, Copy)]
14779    pub struct wire_cst_LnUrlPayError_InvalidNetwork {
14780        err: *mut wire_cst_list_prim_u_8_strict,
14781    }
14782    #[repr(C)]
14783    #[derive(Clone, Copy)]
14784    pub struct wire_cst_LnUrlPayError_InvalidUri {
14785        err: *mut wire_cst_list_prim_u_8_strict,
14786    }
14787    #[repr(C)]
14788    #[derive(Clone, Copy)]
14789    pub struct wire_cst_LnUrlPayError_InvoiceExpired {
14790        err: *mut wire_cst_list_prim_u_8_strict,
14791    }
14792    #[repr(C)]
14793    #[derive(Clone, Copy)]
14794    pub struct wire_cst_LnUrlPayError_PaymentFailed {
14795        err: *mut wire_cst_list_prim_u_8_strict,
14796    }
14797    #[repr(C)]
14798    #[derive(Clone, Copy)]
14799    pub struct wire_cst_LnUrlPayError_PaymentTimeout {
14800        err: *mut wire_cst_list_prim_u_8_strict,
14801    }
14802    #[repr(C)]
14803    #[derive(Clone, Copy)]
14804    pub struct wire_cst_LnUrlPayError_RouteNotFound {
14805        err: *mut wire_cst_list_prim_u_8_strict,
14806    }
14807    #[repr(C)]
14808    #[derive(Clone, Copy)]
14809    pub struct wire_cst_LnUrlPayError_RouteTooExpensive {
14810        err: *mut wire_cst_list_prim_u_8_strict,
14811    }
14812    #[repr(C)]
14813    #[derive(Clone, Copy)]
14814    pub struct wire_cst_LnUrlPayError_ServiceConnectivity {
14815        err: *mut wire_cst_list_prim_u_8_strict,
14816    }
14817    #[repr(C)]
14818    #[derive(Clone, Copy)]
14819    pub struct wire_cst_ln_url_pay_error_data {
14820        payment_hash: *mut wire_cst_list_prim_u_8_strict,
14821        reason: *mut wire_cst_list_prim_u_8_strict,
14822    }
14823    #[repr(C)]
14824    #[derive(Clone, Copy)]
14825    pub struct wire_cst_ln_url_pay_request {
14826        prepare_response: wire_cst_prepare_ln_url_pay_response,
14827    }
14828    #[repr(C)]
14829    #[derive(Clone, Copy)]
14830    pub struct wire_cst_ln_url_pay_request_data {
14831        callback: *mut wire_cst_list_prim_u_8_strict,
14832        min_sendable: u64,
14833        max_sendable: u64,
14834        metadata_str: *mut wire_cst_list_prim_u_8_strict,
14835        comment_allowed: u16,
14836        domain: *mut wire_cst_list_prim_u_8_strict,
14837        allows_nostr: bool,
14838        nostr_pubkey: *mut wire_cst_list_prim_u_8_strict,
14839        ln_address: *mut wire_cst_list_prim_u_8_strict,
14840    }
14841    #[repr(C)]
14842    #[derive(Clone, Copy)]
14843    pub struct wire_cst_ln_url_pay_result {
14844        tag: i32,
14845        kind: LnUrlPayResultKind,
14846    }
14847    #[repr(C)]
14848    #[derive(Clone, Copy)]
14849    pub union LnUrlPayResultKind {
14850        EndpointSuccess: wire_cst_LnUrlPayResult_EndpointSuccess,
14851        EndpointError: wire_cst_LnUrlPayResult_EndpointError,
14852        PayError: wire_cst_LnUrlPayResult_PayError,
14853        nil__: (),
14854    }
14855    #[repr(C)]
14856    #[derive(Clone, Copy)]
14857    pub struct wire_cst_LnUrlPayResult_EndpointSuccess {
14858        data: *mut wire_cst_ln_url_pay_success_data,
14859    }
14860    #[repr(C)]
14861    #[derive(Clone, Copy)]
14862    pub struct wire_cst_LnUrlPayResult_EndpointError {
14863        data: *mut wire_cst_ln_url_error_data,
14864    }
14865    #[repr(C)]
14866    #[derive(Clone, Copy)]
14867    pub struct wire_cst_LnUrlPayResult_PayError {
14868        data: *mut wire_cst_ln_url_pay_error_data,
14869    }
14870    #[repr(C)]
14871    #[derive(Clone, Copy)]
14872    pub struct wire_cst_ln_url_pay_success_data {
14873        payment: wire_cst_payment,
14874        success_action: *mut wire_cst_success_action_processed,
14875    }
14876    #[repr(C)]
14877    #[derive(Clone, Copy)]
14878    pub struct wire_cst_ln_url_withdraw_error {
14879        tag: i32,
14880        kind: LnUrlWithdrawErrorKind,
14881    }
14882    #[repr(C)]
14883    #[derive(Clone, Copy)]
14884    pub union LnUrlWithdrawErrorKind {
14885        Generic: wire_cst_LnUrlWithdrawError_Generic,
14886        InvalidAmount: wire_cst_LnUrlWithdrawError_InvalidAmount,
14887        InvalidInvoice: wire_cst_LnUrlWithdrawError_InvalidInvoice,
14888        InvalidUri: wire_cst_LnUrlWithdrawError_InvalidUri,
14889        InvoiceNoRoutingHints: wire_cst_LnUrlWithdrawError_InvoiceNoRoutingHints,
14890        ServiceConnectivity: wire_cst_LnUrlWithdrawError_ServiceConnectivity,
14891        nil__: (),
14892    }
14893    #[repr(C)]
14894    #[derive(Clone, Copy)]
14895    pub struct wire_cst_LnUrlWithdrawError_Generic {
14896        err: *mut wire_cst_list_prim_u_8_strict,
14897    }
14898    #[repr(C)]
14899    #[derive(Clone, Copy)]
14900    pub struct wire_cst_LnUrlWithdrawError_InvalidAmount {
14901        err: *mut wire_cst_list_prim_u_8_strict,
14902    }
14903    #[repr(C)]
14904    #[derive(Clone, Copy)]
14905    pub struct wire_cst_LnUrlWithdrawError_InvalidInvoice {
14906        err: *mut wire_cst_list_prim_u_8_strict,
14907    }
14908    #[repr(C)]
14909    #[derive(Clone, Copy)]
14910    pub struct wire_cst_LnUrlWithdrawError_InvalidUri {
14911        err: *mut wire_cst_list_prim_u_8_strict,
14912    }
14913    #[repr(C)]
14914    #[derive(Clone, Copy)]
14915    pub struct wire_cst_LnUrlWithdrawError_InvoiceNoRoutingHints {
14916        err: *mut wire_cst_list_prim_u_8_strict,
14917    }
14918    #[repr(C)]
14919    #[derive(Clone, Copy)]
14920    pub struct wire_cst_LnUrlWithdrawError_ServiceConnectivity {
14921        err: *mut wire_cst_list_prim_u_8_strict,
14922    }
14923    #[repr(C)]
14924    #[derive(Clone, Copy)]
14925    pub struct wire_cst_ln_url_withdraw_request {
14926        data: wire_cst_ln_url_withdraw_request_data,
14927        amount_msat: u64,
14928        description: *mut wire_cst_list_prim_u_8_strict,
14929    }
14930    #[repr(C)]
14931    #[derive(Clone, Copy)]
14932    pub struct wire_cst_ln_url_withdraw_request_data {
14933        callback: *mut wire_cst_list_prim_u_8_strict,
14934        k1: *mut wire_cst_list_prim_u_8_strict,
14935        default_description: *mut wire_cst_list_prim_u_8_strict,
14936        min_withdrawable: u64,
14937        max_withdrawable: u64,
14938    }
14939    #[repr(C)]
14940    #[derive(Clone, Copy)]
14941    pub struct wire_cst_ln_url_withdraw_result {
14942        tag: i32,
14943        kind: LnUrlWithdrawResultKind,
14944    }
14945    #[repr(C)]
14946    #[derive(Clone, Copy)]
14947    pub union LnUrlWithdrawResultKind {
14948        Ok: wire_cst_LnUrlWithdrawResult_Ok,
14949        Timeout: wire_cst_LnUrlWithdrawResult_Timeout,
14950        ErrorStatus: wire_cst_LnUrlWithdrawResult_ErrorStatus,
14951        nil__: (),
14952    }
14953    #[repr(C)]
14954    #[derive(Clone, Copy)]
14955    pub struct wire_cst_LnUrlWithdrawResult_Ok {
14956        data: *mut wire_cst_ln_url_withdraw_success_data,
14957    }
14958    #[repr(C)]
14959    #[derive(Clone, Copy)]
14960    pub struct wire_cst_LnUrlWithdrawResult_Timeout {
14961        data: *mut wire_cst_ln_url_withdraw_success_data,
14962    }
14963    #[repr(C)]
14964    #[derive(Clone, Copy)]
14965    pub struct wire_cst_LnUrlWithdrawResult_ErrorStatus {
14966        data: *mut wire_cst_ln_url_error_data,
14967    }
14968    #[repr(C)]
14969    #[derive(Clone, Copy)]
14970    pub struct wire_cst_ln_url_withdraw_success_data {
14971        invoice: wire_cst_ln_invoice,
14972    }
14973    #[repr(C)]
14974    #[derive(Clone, Copy)]
14975    pub struct wire_cst_locale_overrides {
14976        locale: *mut wire_cst_list_prim_u_8_strict,
14977        spacing: *mut u32,
14978        symbol: wire_cst_symbol,
14979    }
14980    #[repr(C)]
14981    #[derive(Clone, Copy)]
14982    pub struct wire_cst_localized_name {
14983        locale: *mut wire_cst_list_prim_u_8_strict,
14984        name: *mut wire_cst_list_prim_u_8_strict,
14985    }
14986    #[repr(C)]
14987    #[derive(Clone, Copy)]
14988    pub struct wire_cst_log_entry {
14989        line: *mut wire_cst_list_prim_u_8_strict,
14990        level: *mut wire_cst_list_prim_u_8_strict,
14991    }
14992    #[repr(C)]
14993    #[derive(Clone, Copy)]
14994    pub struct wire_cst_message_success_action_data {
14995        message: *mut wire_cst_list_prim_u_8_strict,
14996    }
14997    #[repr(C)]
14998    #[derive(Clone, Copy)]
14999    pub struct wire_cst_onchain_payment_limits_response {
15000        send: wire_cst_limits,
15001        receive: wire_cst_limits,
15002    }
15003    #[repr(C)]
15004    #[derive(Clone, Copy)]
15005    pub struct wire_cst_pay_amount {
15006        tag: i32,
15007        kind: PayAmountKind,
15008    }
15009    #[repr(C)]
15010    #[derive(Clone, Copy)]
15011    pub union PayAmountKind {
15012        Bitcoin: wire_cst_PayAmount_Bitcoin,
15013        Asset: wire_cst_PayAmount_Asset,
15014        nil__: (),
15015    }
15016    #[repr(C)]
15017    #[derive(Clone, Copy)]
15018    pub struct wire_cst_PayAmount_Bitcoin {
15019        receiver_amount_sat: u64,
15020    }
15021    #[repr(C)]
15022    #[derive(Clone, Copy)]
15023    pub struct wire_cst_PayAmount_Asset {
15024        asset_id: *mut wire_cst_list_prim_u_8_strict,
15025        receiver_amount: f64,
15026        estimate_asset_fees: *mut bool,
15027    }
15028    #[repr(C)]
15029    #[derive(Clone, Copy)]
15030    pub struct wire_cst_pay_onchain_request {
15031        address: *mut wire_cst_list_prim_u_8_strict,
15032        prepare_response: wire_cst_prepare_pay_onchain_response,
15033    }
15034    #[repr(C)]
15035    #[derive(Clone, Copy)]
15036    pub struct wire_cst_payment {
15037        destination: *mut wire_cst_list_prim_u_8_strict,
15038        tx_id: *mut wire_cst_list_prim_u_8_strict,
15039        unblinding_data: *mut wire_cst_list_prim_u_8_strict,
15040        timestamp: u32,
15041        amount_sat: u64,
15042        fees_sat: u64,
15043        swapper_fees_sat: *mut u64,
15044        payment_type: i32,
15045        status: i32,
15046        details: wire_cst_payment_details,
15047    }
15048    #[repr(C)]
15049    #[derive(Clone, Copy)]
15050    pub struct wire_cst_payment_details {
15051        tag: i32,
15052        kind: PaymentDetailsKind,
15053    }
15054    #[repr(C)]
15055    #[derive(Clone, Copy)]
15056    pub union PaymentDetailsKind {
15057        Lightning: wire_cst_PaymentDetails_Lightning,
15058        Liquid: wire_cst_PaymentDetails_Liquid,
15059        Bitcoin: wire_cst_PaymentDetails_Bitcoin,
15060        nil__: (),
15061    }
15062    #[repr(C)]
15063    #[derive(Clone, Copy)]
15064    pub struct wire_cst_PaymentDetails_Lightning {
15065        swap_id: *mut wire_cst_list_prim_u_8_strict,
15066        description: *mut wire_cst_list_prim_u_8_strict,
15067        liquid_expiration_blockheight: u32,
15068        preimage: *mut wire_cst_list_prim_u_8_strict,
15069        invoice: *mut wire_cst_list_prim_u_8_strict,
15070        bolt12_offer: *mut wire_cst_list_prim_u_8_strict,
15071        payment_hash: *mut wire_cst_list_prim_u_8_strict,
15072        destination_pubkey: *mut wire_cst_list_prim_u_8_strict,
15073        lnurl_info: *mut wire_cst_ln_url_info,
15074        bip353_address: *mut wire_cst_list_prim_u_8_strict,
15075        claim_tx_id: *mut wire_cst_list_prim_u_8_strict,
15076        refund_tx_id: *mut wire_cst_list_prim_u_8_strict,
15077        refund_tx_amount_sat: *mut u64,
15078    }
15079    #[repr(C)]
15080    #[derive(Clone, Copy)]
15081    pub struct wire_cst_PaymentDetails_Liquid {
15082        destination: *mut wire_cst_list_prim_u_8_strict,
15083        description: *mut wire_cst_list_prim_u_8_strict,
15084        asset_id: *mut wire_cst_list_prim_u_8_strict,
15085        asset_info: *mut wire_cst_asset_info,
15086        lnurl_info: *mut wire_cst_ln_url_info,
15087        bip353_address: *mut wire_cst_list_prim_u_8_strict,
15088    }
15089    #[repr(C)]
15090    #[derive(Clone, Copy)]
15091    pub struct wire_cst_PaymentDetails_Bitcoin {
15092        swap_id: *mut wire_cst_list_prim_u_8_strict,
15093        description: *mut wire_cst_list_prim_u_8_strict,
15094        auto_accepted_fees: bool,
15095        liquid_expiration_blockheight: *mut u32,
15096        bitcoin_expiration_blockheight: *mut u32,
15097        claim_tx_id: *mut wire_cst_list_prim_u_8_strict,
15098        refund_tx_id: *mut wire_cst_list_prim_u_8_strict,
15099        refund_tx_amount_sat: *mut u64,
15100    }
15101    #[repr(C)]
15102    #[derive(Clone, Copy)]
15103    pub struct wire_cst_payment_error {
15104        tag: i32,
15105        kind: PaymentErrorKind,
15106    }
15107    #[repr(C)]
15108    #[derive(Clone, Copy)]
15109    pub union PaymentErrorKind {
15110        AmountOutOfRange: wire_cst_PaymentError_AmountOutOfRange,
15111        AmountMissing: wire_cst_PaymentError_AmountMissing,
15112        AssetError: wire_cst_PaymentError_AssetError,
15113        InvalidNetwork: wire_cst_PaymentError_InvalidNetwork,
15114        Generic: wire_cst_PaymentError_Generic,
15115        InvalidDescription: wire_cst_PaymentError_InvalidDescription,
15116        InvalidInvoice: wire_cst_PaymentError_InvalidInvoice,
15117        ReceiveError: wire_cst_PaymentError_ReceiveError,
15118        Refunded: wire_cst_PaymentError_Refunded,
15119        SendError: wire_cst_PaymentError_SendError,
15120        SignerError: wire_cst_PaymentError_SignerError,
15121        nil__: (),
15122    }
15123    #[repr(C)]
15124    #[derive(Clone, Copy)]
15125    pub struct wire_cst_PaymentError_AmountOutOfRange {
15126        min: u64,
15127        max: u64,
15128    }
15129    #[repr(C)]
15130    #[derive(Clone, Copy)]
15131    pub struct wire_cst_PaymentError_AmountMissing {
15132        err: *mut wire_cst_list_prim_u_8_strict,
15133    }
15134    #[repr(C)]
15135    #[derive(Clone, Copy)]
15136    pub struct wire_cst_PaymentError_AssetError {
15137        err: *mut wire_cst_list_prim_u_8_strict,
15138    }
15139    #[repr(C)]
15140    #[derive(Clone, Copy)]
15141    pub struct wire_cst_PaymentError_InvalidNetwork {
15142        err: *mut wire_cst_list_prim_u_8_strict,
15143    }
15144    #[repr(C)]
15145    #[derive(Clone, Copy)]
15146    pub struct wire_cst_PaymentError_Generic {
15147        err: *mut wire_cst_list_prim_u_8_strict,
15148    }
15149    #[repr(C)]
15150    #[derive(Clone, Copy)]
15151    pub struct wire_cst_PaymentError_InvalidDescription {
15152        err: *mut wire_cst_list_prim_u_8_strict,
15153    }
15154    #[repr(C)]
15155    #[derive(Clone, Copy)]
15156    pub struct wire_cst_PaymentError_InvalidInvoice {
15157        err: *mut wire_cst_list_prim_u_8_strict,
15158    }
15159    #[repr(C)]
15160    #[derive(Clone, Copy)]
15161    pub struct wire_cst_PaymentError_ReceiveError {
15162        err: *mut wire_cst_list_prim_u_8_strict,
15163    }
15164    #[repr(C)]
15165    #[derive(Clone, Copy)]
15166    pub struct wire_cst_PaymentError_Refunded {
15167        err: *mut wire_cst_list_prim_u_8_strict,
15168        refund_tx_id: *mut wire_cst_list_prim_u_8_strict,
15169    }
15170    #[repr(C)]
15171    #[derive(Clone, Copy)]
15172    pub struct wire_cst_PaymentError_SendError {
15173        err: *mut wire_cst_list_prim_u_8_strict,
15174    }
15175    #[repr(C)]
15176    #[derive(Clone, Copy)]
15177    pub struct wire_cst_PaymentError_SignerError {
15178        err: *mut wire_cst_list_prim_u_8_strict,
15179    }
15180    #[repr(C)]
15181    #[derive(Clone, Copy)]
15182    pub struct wire_cst_prepare_buy_bitcoin_request {
15183        provider: i32,
15184        amount_sat: u64,
15185    }
15186    #[repr(C)]
15187    #[derive(Clone, Copy)]
15188    pub struct wire_cst_prepare_buy_bitcoin_response {
15189        provider: i32,
15190        amount_sat: u64,
15191        fees_sat: u64,
15192    }
15193    #[repr(C)]
15194    #[derive(Clone, Copy)]
15195    pub struct wire_cst_prepare_ln_url_pay_request {
15196        data: wire_cst_ln_url_pay_request_data,
15197        amount: wire_cst_pay_amount,
15198        bip353_address: *mut wire_cst_list_prim_u_8_strict,
15199        comment: *mut wire_cst_list_prim_u_8_strict,
15200        validate_success_action_url: *mut bool,
15201    }
15202    #[repr(C)]
15203    #[derive(Clone, Copy)]
15204    pub struct wire_cst_prepare_ln_url_pay_response {
15205        destination: wire_cst_send_destination,
15206        fees_sat: u64,
15207        data: wire_cst_ln_url_pay_request_data,
15208        comment: *mut wire_cst_list_prim_u_8_strict,
15209        success_action: *mut wire_cst_success_action,
15210    }
15211    #[repr(C)]
15212    #[derive(Clone, Copy)]
15213    pub struct wire_cst_prepare_pay_onchain_request {
15214        amount: wire_cst_pay_amount,
15215        fee_rate_sat_per_vbyte: *mut u32,
15216    }
15217    #[repr(C)]
15218    #[derive(Clone, Copy)]
15219    pub struct wire_cst_prepare_pay_onchain_response {
15220        receiver_amount_sat: u64,
15221        claim_fees_sat: u64,
15222        total_fees_sat: u64,
15223    }
15224    #[repr(C)]
15225    #[derive(Clone, Copy)]
15226    pub struct wire_cst_prepare_receive_request {
15227        payment_method: i32,
15228        amount: *mut wire_cst_receive_amount,
15229    }
15230    #[repr(C)]
15231    #[derive(Clone, Copy)]
15232    pub struct wire_cst_prepare_receive_response {
15233        payment_method: i32,
15234        fees_sat: u64,
15235        amount: *mut wire_cst_receive_amount,
15236        min_payer_amount_sat: *mut u64,
15237        max_payer_amount_sat: *mut u64,
15238        swapper_feerate: *mut f64,
15239    }
15240    #[repr(C)]
15241    #[derive(Clone, Copy)]
15242    pub struct wire_cst_prepare_refund_request {
15243        swap_address: *mut wire_cst_list_prim_u_8_strict,
15244        refund_address: *mut wire_cst_list_prim_u_8_strict,
15245        fee_rate_sat_per_vbyte: u32,
15246    }
15247    #[repr(C)]
15248    #[derive(Clone, Copy)]
15249    pub struct wire_cst_prepare_refund_response {
15250        tx_vsize: u32,
15251        tx_fee_sat: u64,
15252        last_refund_tx_id: *mut wire_cst_list_prim_u_8_strict,
15253    }
15254    #[repr(C)]
15255    #[derive(Clone, Copy)]
15256    pub struct wire_cst_prepare_send_request {
15257        destination: *mut wire_cst_list_prim_u_8_strict,
15258        amount: *mut wire_cst_pay_amount,
15259    }
15260    #[repr(C)]
15261    #[derive(Clone, Copy)]
15262    pub struct wire_cst_prepare_send_response {
15263        destination: wire_cst_send_destination,
15264        fees_sat: *mut u64,
15265        estimated_asset_fees: *mut f64,
15266    }
15267    #[repr(C)]
15268    #[derive(Clone, Copy)]
15269    pub struct wire_cst_rate {
15270        coin: *mut wire_cst_list_prim_u_8_strict,
15271        value: f64,
15272    }
15273    #[repr(C)]
15274    #[derive(Clone, Copy)]
15275    pub struct wire_cst_receive_amount {
15276        tag: i32,
15277        kind: ReceiveAmountKind,
15278    }
15279    #[repr(C)]
15280    #[derive(Clone, Copy)]
15281    pub union ReceiveAmountKind {
15282        Bitcoin: wire_cst_ReceiveAmount_Bitcoin,
15283        Asset: wire_cst_ReceiveAmount_Asset,
15284        nil__: (),
15285    }
15286    #[repr(C)]
15287    #[derive(Clone, Copy)]
15288    pub struct wire_cst_ReceiveAmount_Bitcoin {
15289        payer_amount_sat: u64,
15290    }
15291    #[repr(C)]
15292    #[derive(Clone, Copy)]
15293    pub struct wire_cst_ReceiveAmount_Asset {
15294        asset_id: *mut wire_cst_list_prim_u_8_strict,
15295        payer_amount: *mut f64,
15296    }
15297    #[repr(C)]
15298    #[derive(Clone, Copy)]
15299    pub struct wire_cst_receive_payment_request {
15300        prepare_response: wire_cst_prepare_receive_response,
15301        description: *mut wire_cst_list_prim_u_8_strict,
15302        use_description_hash: *mut bool,
15303    }
15304    #[repr(C)]
15305    #[derive(Clone, Copy)]
15306    pub struct wire_cst_receive_payment_response {
15307        destination: *mut wire_cst_list_prim_u_8_strict,
15308    }
15309    #[repr(C)]
15310    #[derive(Clone, Copy)]
15311    pub struct wire_cst_recommended_fees {
15312        fastest_fee: u64,
15313        half_hour_fee: u64,
15314        hour_fee: u64,
15315        economy_fee: u64,
15316        minimum_fee: u64,
15317    }
15318    #[repr(C)]
15319    #[derive(Clone, Copy)]
15320    pub struct wire_cst_refund_request {
15321        swap_address: *mut wire_cst_list_prim_u_8_strict,
15322        refund_address: *mut wire_cst_list_prim_u_8_strict,
15323        fee_rate_sat_per_vbyte: u32,
15324    }
15325    #[repr(C)]
15326    #[derive(Clone, Copy)]
15327    pub struct wire_cst_refund_response {
15328        refund_tx_id: *mut wire_cst_list_prim_u_8_strict,
15329    }
15330    #[repr(C)]
15331    #[derive(Clone, Copy)]
15332    pub struct wire_cst_refundable_swap {
15333        swap_address: *mut wire_cst_list_prim_u_8_strict,
15334        timestamp: u32,
15335        amount_sat: u64,
15336        last_refund_tx_id: *mut wire_cst_list_prim_u_8_strict,
15337    }
15338    #[repr(C)]
15339    #[derive(Clone, Copy)]
15340    pub struct wire_cst_restore_request {
15341        backup_path: *mut wire_cst_list_prim_u_8_strict,
15342    }
15343    #[repr(C)]
15344    #[derive(Clone, Copy)]
15345    pub struct wire_cst_route_hint {
15346        hops: *mut wire_cst_list_route_hint_hop,
15347    }
15348    #[repr(C)]
15349    #[derive(Clone, Copy)]
15350    pub struct wire_cst_route_hint_hop {
15351        src_node_id: *mut wire_cst_list_prim_u_8_strict,
15352        short_channel_id: *mut wire_cst_list_prim_u_8_strict,
15353        fees_base_msat: u32,
15354        fees_proportional_millionths: u32,
15355        cltv_expiry_delta: u64,
15356        htlc_minimum_msat: *mut u64,
15357        htlc_maximum_msat: *mut u64,
15358    }
15359    #[repr(C)]
15360    #[derive(Clone, Copy)]
15361    pub struct wire_cst_sdk_error {
15362        tag: i32,
15363        kind: SdkErrorKind,
15364    }
15365    #[repr(C)]
15366    #[derive(Clone, Copy)]
15367    pub union SdkErrorKind {
15368        Generic: wire_cst_SdkError_Generic,
15369        ServiceConnectivity: wire_cst_SdkError_ServiceConnectivity,
15370        nil__: (),
15371    }
15372    #[repr(C)]
15373    #[derive(Clone, Copy)]
15374    pub struct wire_cst_SdkError_Generic {
15375        err: *mut wire_cst_list_prim_u_8_strict,
15376    }
15377    #[repr(C)]
15378    #[derive(Clone, Copy)]
15379    pub struct wire_cst_SdkError_ServiceConnectivity {
15380        err: *mut wire_cst_list_prim_u_8_strict,
15381    }
15382    #[repr(C)]
15383    #[derive(Clone, Copy)]
15384    pub struct wire_cst_sdk_event {
15385        tag: i32,
15386        kind: SdkEventKind,
15387    }
15388    #[repr(C)]
15389    #[derive(Clone, Copy)]
15390    pub union SdkEventKind {
15391        PaymentFailed: wire_cst_SdkEvent_PaymentFailed,
15392        PaymentPending: wire_cst_SdkEvent_PaymentPending,
15393        PaymentRefundable: wire_cst_SdkEvent_PaymentRefundable,
15394        PaymentRefunded: wire_cst_SdkEvent_PaymentRefunded,
15395        PaymentRefundPending: wire_cst_SdkEvent_PaymentRefundPending,
15396        PaymentSucceeded: wire_cst_SdkEvent_PaymentSucceeded,
15397        PaymentWaitingConfirmation: wire_cst_SdkEvent_PaymentWaitingConfirmation,
15398        PaymentWaitingFeeAcceptance: wire_cst_SdkEvent_PaymentWaitingFeeAcceptance,
15399        DataSynced: wire_cst_SdkEvent_DataSynced,
15400        nil__: (),
15401    }
15402    #[repr(C)]
15403    #[derive(Clone, Copy)]
15404    pub struct wire_cst_SdkEvent_PaymentFailed {
15405        details: *mut wire_cst_payment,
15406    }
15407    #[repr(C)]
15408    #[derive(Clone, Copy)]
15409    pub struct wire_cst_SdkEvent_PaymentPending {
15410        details: *mut wire_cst_payment,
15411    }
15412    #[repr(C)]
15413    #[derive(Clone, Copy)]
15414    pub struct wire_cst_SdkEvent_PaymentRefundable {
15415        details: *mut wire_cst_payment,
15416    }
15417    #[repr(C)]
15418    #[derive(Clone, Copy)]
15419    pub struct wire_cst_SdkEvent_PaymentRefunded {
15420        details: *mut wire_cst_payment,
15421    }
15422    #[repr(C)]
15423    #[derive(Clone, Copy)]
15424    pub struct wire_cst_SdkEvent_PaymentRefundPending {
15425        details: *mut wire_cst_payment,
15426    }
15427    #[repr(C)]
15428    #[derive(Clone, Copy)]
15429    pub struct wire_cst_SdkEvent_PaymentSucceeded {
15430        details: *mut wire_cst_payment,
15431    }
15432    #[repr(C)]
15433    #[derive(Clone, Copy)]
15434    pub struct wire_cst_SdkEvent_PaymentWaitingConfirmation {
15435        details: *mut wire_cst_payment,
15436    }
15437    #[repr(C)]
15438    #[derive(Clone, Copy)]
15439    pub struct wire_cst_SdkEvent_PaymentWaitingFeeAcceptance {
15440        details: *mut wire_cst_payment,
15441    }
15442    #[repr(C)]
15443    #[derive(Clone, Copy)]
15444    pub struct wire_cst_SdkEvent_DataSynced {
15445        did_pull_new_records: bool,
15446    }
15447    #[repr(C)]
15448    #[derive(Clone, Copy)]
15449    pub struct wire_cst_send_destination {
15450        tag: i32,
15451        kind: SendDestinationKind,
15452    }
15453    #[repr(C)]
15454    #[derive(Clone, Copy)]
15455    pub union SendDestinationKind {
15456        LiquidAddress: wire_cst_SendDestination_LiquidAddress,
15457        Bolt11: wire_cst_SendDestination_Bolt11,
15458        Bolt12: wire_cst_SendDestination_Bolt12,
15459        nil__: (),
15460    }
15461    #[repr(C)]
15462    #[derive(Clone, Copy)]
15463    pub struct wire_cst_SendDestination_LiquidAddress {
15464        address_data: *mut wire_cst_liquid_address_data,
15465        bip353_address: *mut wire_cst_list_prim_u_8_strict,
15466    }
15467    #[repr(C)]
15468    #[derive(Clone, Copy)]
15469    pub struct wire_cst_SendDestination_Bolt11 {
15470        invoice: *mut wire_cst_ln_invoice,
15471        bip353_address: *mut wire_cst_list_prim_u_8_strict,
15472    }
15473    #[repr(C)]
15474    #[derive(Clone, Copy)]
15475    pub struct wire_cst_SendDestination_Bolt12 {
15476        offer: *mut wire_cst_ln_offer,
15477        receiver_amount_sat: u64,
15478        bip353_address: *mut wire_cst_list_prim_u_8_strict,
15479    }
15480    #[repr(C)]
15481    #[derive(Clone, Copy)]
15482    pub struct wire_cst_send_payment_request {
15483        prepare_response: wire_cst_prepare_send_response,
15484        use_asset_fees: *mut bool,
15485    }
15486    #[repr(C)]
15487    #[derive(Clone, Copy)]
15488    pub struct wire_cst_send_payment_response {
15489        payment: wire_cst_payment,
15490    }
15491    #[repr(C)]
15492    #[derive(Clone, Copy)]
15493    pub struct wire_cst_sign_message_request {
15494        message: *mut wire_cst_list_prim_u_8_strict,
15495    }
15496    #[repr(C)]
15497    #[derive(Clone, Copy)]
15498    pub struct wire_cst_sign_message_response {
15499        signature: *mut wire_cst_list_prim_u_8_strict,
15500    }
15501    #[repr(C)]
15502    #[derive(Clone, Copy)]
15503    pub struct wire_cst_success_action {
15504        tag: i32,
15505        kind: SuccessActionKind,
15506    }
15507    #[repr(C)]
15508    #[derive(Clone, Copy)]
15509    pub union SuccessActionKind {
15510        Aes: wire_cst_SuccessAction_Aes,
15511        Message: wire_cst_SuccessAction_Message,
15512        Url: wire_cst_SuccessAction_Url,
15513        nil__: (),
15514    }
15515    #[repr(C)]
15516    #[derive(Clone, Copy)]
15517    pub struct wire_cst_SuccessAction_Aes {
15518        data: *mut wire_cst_aes_success_action_data,
15519    }
15520    #[repr(C)]
15521    #[derive(Clone, Copy)]
15522    pub struct wire_cst_SuccessAction_Message {
15523        data: *mut wire_cst_message_success_action_data,
15524    }
15525    #[repr(C)]
15526    #[derive(Clone, Copy)]
15527    pub struct wire_cst_SuccessAction_Url {
15528        data: *mut wire_cst_url_success_action_data,
15529    }
15530    #[repr(C)]
15531    #[derive(Clone, Copy)]
15532    pub struct wire_cst_success_action_processed {
15533        tag: i32,
15534        kind: SuccessActionProcessedKind,
15535    }
15536    #[repr(C)]
15537    #[derive(Clone, Copy)]
15538    pub union SuccessActionProcessedKind {
15539        Aes: wire_cst_SuccessActionProcessed_Aes,
15540        Message: wire_cst_SuccessActionProcessed_Message,
15541        Url: wire_cst_SuccessActionProcessed_Url,
15542        nil__: (),
15543    }
15544    #[repr(C)]
15545    #[derive(Clone, Copy)]
15546    pub struct wire_cst_SuccessActionProcessed_Aes {
15547        result: *mut wire_cst_aes_success_action_data_result,
15548    }
15549    #[repr(C)]
15550    #[derive(Clone, Copy)]
15551    pub struct wire_cst_SuccessActionProcessed_Message {
15552        data: *mut wire_cst_message_success_action_data,
15553    }
15554    #[repr(C)]
15555    #[derive(Clone, Copy)]
15556    pub struct wire_cst_SuccessActionProcessed_Url {
15557        data: *mut wire_cst_url_success_action_data,
15558    }
15559    #[repr(C)]
15560    #[derive(Clone, Copy)]
15561    pub struct wire_cst_symbol {
15562        grapheme: *mut wire_cst_list_prim_u_8_strict,
15563        template: *mut wire_cst_list_prim_u_8_strict,
15564        rtl: *mut bool,
15565        position: *mut u32,
15566    }
15567    #[repr(C)]
15568    #[derive(Clone, Copy)]
15569    pub struct wire_cst_url_success_action_data {
15570        description: *mut wire_cst_list_prim_u_8_strict,
15571        url: *mut wire_cst_list_prim_u_8_strict,
15572        matches_callback_domain: bool,
15573    }
15574    #[repr(C)]
15575    #[derive(Clone, Copy)]
15576    pub struct wire_cst_wallet_info {
15577        balance_sat: u64,
15578        pending_send_sat: u64,
15579        pending_receive_sat: u64,
15580        fingerprint: *mut wire_cst_list_prim_u_8_strict,
15581        pubkey: *mut wire_cst_list_prim_u_8_strict,
15582        asset_balances: *mut wire_cst_list_asset_balance,
15583    }
15584}
15585#[cfg(not(target_family = "wasm"))]
15586pub use io::*;