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_network = <crate::model::LiquidNetwork>::sse_decode(deserializer);
2632        let mut var_paymentTimeoutSec = <u64>::sse_decode(deserializer);
2633        let mut var_syncServiceUrl = <Option<String>>::sse_decode(deserializer);
2634        let mut var_zeroConfMaxAmountSat = <Option<u64>>::sse_decode(deserializer);
2635        let mut var_breezApiKey = <Option<String>>::sse_decode(deserializer);
2636        let mut var_externalInputParsers =
2637            <Option<Vec<crate::bindings::ExternalInputParser>>>::sse_decode(deserializer);
2638        let mut var_useDefaultExternalInputParsers = <bool>::sse_decode(deserializer);
2639        let mut var_onchainFeeRateLeewaySat = <Option<u64>>::sse_decode(deserializer);
2640        let mut var_assetMetadata =
2641            <Option<Vec<crate::model::AssetMetadata>>>::sse_decode(deserializer);
2642        let mut var_sideswapApiKey = <Option<String>>::sse_decode(deserializer);
2643        return crate::model::Config {
2644            liquid_explorer: var_liquidExplorer,
2645            bitcoin_explorer: var_bitcoinExplorer,
2646            working_dir: var_workingDir,
2647            network: var_network,
2648            payment_timeout_sec: var_paymentTimeoutSec,
2649            sync_service_url: var_syncServiceUrl,
2650            zero_conf_max_amount_sat: var_zeroConfMaxAmountSat,
2651            breez_api_key: var_breezApiKey,
2652            external_input_parsers: var_externalInputParsers,
2653            use_default_external_input_parsers: var_useDefaultExternalInputParsers,
2654            onchain_fee_rate_leeway_sat: var_onchainFeeRateLeewaySat,
2655            asset_metadata: var_assetMetadata,
2656            sideswap_api_key: var_sideswapApiKey,
2657        };
2658    }
2659}
2660
2661impl SseDecode for crate::model::ConnectRequest {
2662    // Codec=Sse (Serialization based), see doc to use other codecs
2663    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2664        let mut var_config = <crate::model::Config>::sse_decode(deserializer);
2665        let mut var_mnemonic = <Option<String>>::sse_decode(deserializer);
2666        let mut var_passphrase = <Option<String>>::sse_decode(deserializer);
2667        let mut var_seed = <Option<Vec<u8>>>::sse_decode(deserializer);
2668        return crate::model::ConnectRequest {
2669            config: var_config,
2670            mnemonic: var_mnemonic,
2671            passphrase: var_passphrase,
2672            seed: var_seed,
2673        };
2674    }
2675}
2676
2677impl SseDecode for crate::model::CreateBolt12InvoiceRequest {
2678    // Codec=Sse (Serialization based), see doc to use other codecs
2679    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2680        let mut var_offer = <String>::sse_decode(deserializer);
2681        let mut var_invoiceRequest = <String>::sse_decode(deserializer);
2682        return crate::model::CreateBolt12InvoiceRequest {
2683            offer: var_offer,
2684            invoice_request: var_invoiceRequest,
2685        };
2686    }
2687}
2688
2689impl SseDecode for crate::model::CreateBolt12InvoiceResponse {
2690    // Codec=Sse (Serialization based), see doc to use other codecs
2691    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2692        let mut var_invoice = <String>::sse_decode(deserializer);
2693        return crate::model::CreateBolt12InvoiceResponse {
2694            invoice: var_invoice,
2695        };
2696    }
2697}
2698
2699impl SseDecode for crate::bindings::CurrencyInfo {
2700    // Codec=Sse (Serialization based), see doc to use other codecs
2701    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2702        let mut var_name = <String>::sse_decode(deserializer);
2703        let mut var_fractionSize = <u32>::sse_decode(deserializer);
2704        let mut var_spacing = <Option<u32>>::sse_decode(deserializer);
2705        let mut var_symbol = <Option<crate::bindings::Symbol>>::sse_decode(deserializer);
2706        let mut var_uniqSymbol = <Option<crate::bindings::Symbol>>::sse_decode(deserializer);
2707        let mut var_localizedName = <Vec<crate::bindings::LocalizedName>>::sse_decode(deserializer);
2708        let mut var_localeOverrides =
2709            <Vec<crate::bindings::LocaleOverrides>>::sse_decode(deserializer);
2710        return crate::bindings::CurrencyInfo {
2711            name: var_name,
2712            fraction_size: var_fractionSize,
2713            spacing: var_spacing,
2714            symbol: var_symbol,
2715            uniq_symbol: var_uniqSymbol,
2716            localized_name: var_localizedName,
2717            locale_overrides: var_localeOverrides,
2718        };
2719    }
2720}
2721
2722impl SseDecode for crate::bindings::ExternalInputParser {
2723    // Codec=Sse (Serialization based), see doc to use other codecs
2724    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2725        let mut var_providerId = <String>::sse_decode(deserializer);
2726        let mut var_inputRegex = <String>::sse_decode(deserializer);
2727        let mut var_parserUrl = <String>::sse_decode(deserializer);
2728        return crate::bindings::ExternalInputParser {
2729            provider_id: var_providerId,
2730            input_regex: var_inputRegex,
2731            parser_url: var_parserUrl,
2732        };
2733    }
2734}
2735
2736impl SseDecode for f64 {
2737    // Codec=Sse (Serialization based), see doc to use other codecs
2738    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2739        deserializer.cursor.read_f64::<NativeEndian>().unwrap()
2740    }
2741}
2742
2743impl SseDecode for crate::model::FetchPaymentProposedFeesRequest {
2744    // Codec=Sse (Serialization based), see doc to use other codecs
2745    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2746        let mut var_swapId = <String>::sse_decode(deserializer);
2747        return crate::model::FetchPaymentProposedFeesRequest {
2748            swap_id: var_swapId,
2749        };
2750    }
2751}
2752
2753impl SseDecode for crate::model::FetchPaymentProposedFeesResponse {
2754    // Codec=Sse (Serialization based), see doc to use other codecs
2755    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2756        let mut var_swapId = <String>::sse_decode(deserializer);
2757        let mut var_feesSat = <u64>::sse_decode(deserializer);
2758        let mut var_payerAmountSat = <u64>::sse_decode(deserializer);
2759        let mut var_receiverAmountSat = <u64>::sse_decode(deserializer);
2760        return crate::model::FetchPaymentProposedFeesResponse {
2761            swap_id: var_swapId,
2762            fees_sat: var_feesSat,
2763            payer_amount_sat: var_payerAmountSat,
2764            receiver_amount_sat: var_receiverAmountSat,
2765        };
2766    }
2767}
2768
2769impl SseDecode for crate::bindings::FiatCurrency {
2770    // Codec=Sse (Serialization based), see doc to use other codecs
2771    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2772        let mut var_id = <String>::sse_decode(deserializer);
2773        let mut var_info = <crate::bindings::CurrencyInfo>::sse_decode(deserializer);
2774        return crate::bindings::FiatCurrency {
2775            id: var_id,
2776            info: var_info,
2777        };
2778    }
2779}
2780
2781impl SseDecode for crate::model::GetInfoResponse {
2782    // Codec=Sse (Serialization based), see doc to use other codecs
2783    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2784        let mut var_walletInfo = <crate::model::WalletInfo>::sse_decode(deserializer);
2785        let mut var_blockchainInfo = <crate::model::BlockchainInfo>::sse_decode(deserializer);
2786        return crate::model::GetInfoResponse {
2787            wallet_info: var_walletInfo,
2788            blockchain_info: var_blockchainInfo,
2789        };
2790    }
2791}
2792
2793impl SseDecode for crate::model::GetPaymentRequest {
2794    // Codec=Sse (Serialization based), see doc to use other codecs
2795    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2796        let mut tag_ = <i32>::sse_decode(deserializer);
2797        match tag_ {
2798            0 => {
2799                let mut var_paymentHash = <String>::sse_decode(deserializer);
2800                return crate::model::GetPaymentRequest::PaymentHash {
2801                    payment_hash: var_paymentHash,
2802                };
2803            }
2804            1 => {
2805                let mut var_swapId = <String>::sse_decode(deserializer);
2806                return crate::model::GetPaymentRequest::SwapId {
2807                    swap_id: var_swapId,
2808                };
2809            }
2810            _ => {
2811                unimplemented!("");
2812            }
2813        }
2814    }
2815}
2816
2817impl SseDecode for i32 {
2818    // Codec=Sse (Serialization based), see doc to use other codecs
2819    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2820        deserializer.cursor.read_i32::<NativeEndian>().unwrap()
2821    }
2822}
2823
2824impl SseDecode for i64 {
2825    // Codec=Sse (Serialization based), see doc to use other codecs
2826    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2827        deserializer.cursor.read_i64::<NativeEndian>().unwrap()
2828    }
2829}
2830
2831impl SseDecode for crate::bindings::InputType {
2832    // Codec=Sse (Serialization based), see doc to use other codecs
2833    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2834        let mut tag_ = <i32>::sse_decode(deserializer);
2835        match tag_ {
2836            0 => {
2837                let mut var_address =
2838                    <crate::bindings::BitcoinAddressData>::sse_decode(deserializer);
2839                return crate::bindings::InputType::BitcoinAddress {
2840                    address: var_address,
2841                };
2842            }
2843            1 => {
2844                let mut var_address =
2845                    <crate::bindings::LiquidAddressData>::sse_decode(deserializer);
2846                return crate::bindings::InputType::LiquidAddress {
2847                    address: var_address,
2848                };
2849            }
2850            2 => {
2851                let mut var_invoice = <crate::bindings::LNInvoice>::sse_decode(deserializer);
2852                return crate::bindings::InputType::Bolt11 {
2853                    invoice: var_invoice,
2854                };
2855            }
2856            3 => {
2857                let mut var_offer = <crate::bindings::LNOffer>::sse_decode(deserializer);
2858                let mut var_bip353Address = <Option<String>>::sse_decode(deserializer);
2859                return crate::bindings::InputType::Bolt12Offer {
2860                    offer: var_offer,
2861                    bip353_address: var_bip353Address,
2862                };
2863            }
2864            4 => {
2865                let mut var_nodeId = <String>::sse_decode(deserializer);
2866                return crate::bindings::InputType::NodeId {
2867                    node_id: var_nodeId,
2868                };
2869            }
2870            5 => {
2871                let mut var_url = <String>::sse_decode(deserializer);
2872                return crate::bindings::InputType::Url { url: var_url };
2873            }
2874            6 => {
2875                let mut var_data = <crate::bindings::LnUrlPayRequestData>::sse_decode(deserializer);
2876                let mut var_bip353Address = <Option<String>>::sse_decode(deserializer);
2877                return crate::bindings::InputType::LnUrlPay {
2878                    data: var_data,
2879                    bip353_address: var_bip353Address,
2880                };
2881            }
2882            7 => {
2883                let mut var_data =
2884                    <crate::bindings::LnUrlWithdrawRequestData>::sse_decode(deserializer);
2885                return crate::bindings::InputType::LnUrlWithdraw { data: var_data };
2886            }
2887            8 => {
2888                let mut var_data =
2889                    <crate::bindings::LnUrlAuthRequestData>::sse_decode(deserializer);
2890                return crate::bindings::InputType::LnUrlAuth { data: var_data };
2891            }
2892            9 => {
2893                let mut var_data = <crate::bindings::LnUrlErrorData>::sse_decode(deserializer);
2894                return crate::bindings::InputType::LnUrlError { data: var_data };
2895            }
2896            _ => {
2897                unimplemented!("");
2898            }
2899        }
2900    }
2901}
2902
2903impl SseDecode for crate::model::LightningPaymentLimitsResponse {
2904    // Codec=Sse (Serialization based), see doc to use other codecs
2905    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2906        let mut var_send = <crate::model::Limits>::sse_decode(deserializer);
2907        let mut var_receive = <crate::model::Limits>::sse_decode(deserializer);
2908        return crate::model::LightningPaymentLimitsResponse {
2909            send: var_send,
2910            receive: var_receive,
2911        };
2912    }
2913}
2914
2915impl SseDecode for crate::model::Limits {
2916    // Codec=Sse (Serialization based), see doc to use other codecs
2917    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2918        let mut var_minSat = <u64>::sse_decode(deserializer);
2919        let mut var_maxSat = <u64>::sse_decode(deserializer);
2920        let mut var_maxZeroConfSat = <u64>::sse_decode(deserializer);
2921        return crate::model::Limits {
2922            min_sat: var_minSat,
2923            max_sat: var_maxSat,
2924            max_zero_conf_sat: var_maxZeroConfSat,
2925        };
2926    }
2927}
2928
2929impl SseDecode for crate::bindings::LiquidAddressData {
2930    // Codec=Sse (Serialization based), see doc to use other codecs
2931    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2932        let mut var_address = <String>::sse_decode(deserializer);
2933        let mut var_network = <crate::bindings::Network>::sse_decode(deserializer);
2934        let mut var_assetId = <Option<String>>::sse_decode(deserializer);
2935        let mut var_amount = <Option<f64>>::sse_decode(deserializer);
2936        let mut var_amountSat = <Option<u64>>::sse_decode(deserializer);
2937        let mut var_label = <Option<String>>::sse_decode(deserializer);
2938        let mut var_message = <Option<String>>::sse_decode(deserializer);
2939        return crate::bindings::LiquidAddressData {
2940            address: var_address,
2941            network: var_network,
2942            asset_id: var_assetId,
2943            amount: var_amount,
2944            amount_sat: var_amountSat,
2945            label: var_label,
2946            message: var_message,
2947        };
2948    }
2949}
2950
2951impl SseDecode for crate::model::LiquidNetwork {
2952    // Codec=Sse (Serialization based), see doc to use other codecs
2953    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2954        let mut inner = <i32>::sse_decode(deserializer);
2955        return match inner {
2956            0 => crate::model::LiquidNetwork::Mainnet,
2957            1 => crate::model::LiquidNetwork::Testnet,
2958            2 => crate::model::LiquidNetwork::Regtest,
2959            _ => unreachable!("Invalid variant for LiquidNetwork: {}", inner),
2960        };
2961    }
2962}
2963
2964impl SseDecode for Vec<String> {
2965    // Codec=Sse (Serialization based), see doc to use other codecs
2966    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2967        let mut len_ = <i32>::sse_decode(deserializer);
2968        let mut ans_ = vec![];
2969        for idx_ in 0..len_ {
2970            ans_.push(<String>::sse_decode(deserializer));
2971        }
2972        return ans_;
2973    }
2974}
2975
2976impl SseDecode for Vec<crate::model::AssetBalance> {
2977    // Codec=Sse (Serialization based), see doc to use other codecs
2978    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2979        let mut len_ = <i32>::sse_decode(deserializer);
2980        let mut ans_ = vec![];
2981        for idx_ in 0..len_ {
2982            ans_.push(<crate::model::AssetBalance>::sse_decode(deserializer));
2983        }
2984        return ans_;
2985    }
2986}
2987
2988impl SseDecode for Vec<crate::model::AssetMetadata> {
2989    // Codec=Sse (Serialization based), see doc to use other codecs
2990    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2991        let mut len_ = <i32>::sse_decode(deserializer);
2992        let mut ans_ = vec![];
2993        for idx_ in 0..len_ {
2994            ans_.push(<crate::model::AssetMetadata>::sse_decode(deserializer));
2995        }
2996        return ans_;
2997    }
2998}
2999
3000impl SseDecode for Vec<crate::bindings::ExternalInputParser> {
3001    // Codec=Sse (Serialization based), see doc to use other codecs
3002    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3003        let mut len_ = <i32>::sse_decode(deserializer);
3004        let mut ans_ = vec![];
3005        for idx_ in 0..len_ {
3006            ans_.push(<crate::bindings::ExternalInputParser>::sse_decode(
3007                deserializer,
3008            ));
3009        }
3010        return ans_;
3011    }
3012}
3013
3014impl SseDecode for Vec<crate::bindings::FiatCurrency> {
3015    // Codec=Sse (Serialization based), see doc to use other codecs
3016    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3017        let mut len_ = <i32>::sse_decode(deserializer);
3018        let mut ans_ = vec![];
3019        for idx_ in 0..len_ {
3020            ans_.push(<crate::bindings::FiatCurrency>::sse_decode(deserializer));
3021        }
3022        return ans_;
3023    }
3024}
3025
3026impl SseDecode for Vec<crate::bindings::LnOfferBlindedPath> {
3027    // Codec=Sse (Serialization based), see doc to use other codecs
3028    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3029        let mut len_ = <i32>::sse_decode(deserializer);
3030        let mut ans_ = vec![];
3031        for idx_ in 0..len_ {
3032            ans_.push(<crate::bindings::LnOfferBlindedPath>::sse_decode(
3033                deserializer,
3034            ));
3035        }
3036        return ans_;
3037    }
3038}
3039
3040impl SseDecode for Vec<crate::bindings::LocaleOverrides> {
3041    // Codec=Sse (Serialization based), see doc to use other codecs
3042    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3043        let mut len_ = <i32>::sse_decode(deserializer);
3044        let mut ans_ = vec![];
3045        for idx_ in 0..len_ {
3046            ans_.push(<crate::bindings::LocaleOverrides>::sse_decode(deserializer));
3047        }
3048        return ans_;
3049    }
3050}
3051
3052impl SseDecode for Vec<crate::bindings::LocalizedName> {
3053    // Codec=Sse (Serialization based), see doc to use other codecs
3054    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3055        let mut len_ = <i32>::sse_decode(deserializer);
3056        let mut ans_ = vec![];
3057        for idx_ in 0..len_ {
3058            ans_.push(<crate::bindings::LocalizedName>::sse_decode(deserializer));
3059        }
3060        return ans_;
3061    }
3062}
3063
3064impl SseDecode for Vec<crate::model::Payment> {
3065    // Codec=Sse (Serialization based), see doc to use other codecs
3066    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3067        let mut len_ = <i32>::sse_decode(deserializer);
3068        let mut ans_ = vec![];
3069        for idx_ in 0..len_ {
3070            ans_.push(<crate::model::Payment>::sse_decode(deserializer));
3071        }
3072        return ans_;
3073    }
3074}
3075
3076impl SseDecode for crate::model::ListPaymentDetails {
3077    // Codec=Sse (Serialization based), see doc to use other codecs
3078    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3079        let mut tag_ = <i32>::sse_decode(deserializer);
3080        match tag_ {
3081            0 => {
3082                let mut var_assetId = <Option<String>>::sse_decode(deserializer);
3083                let mut var_destination = <Option<String>>::sse_decode(deserializer);
3084                return crate::model::ListPaymentDetails::Liquid {
3085                    asset_id: var_assetId,
3086                    destination: var_destination,
3087                };
3088            }
3089            1 => {
3090                let mut var_address = <Option<String>>::sse_decode(deserializer);
3091                return crate::model::ListPaymentDetails::Bitcoin {
3092                    address: var_address,
3093                };
3094            }
3095            _ => {
3096                unimplemented!("");
3097            }
3098        }
3099    }
3100}
3101
3102impl SseDecode for Vec<crate::model::PaymentState> {
3103    // Codec=Sse (Serialization based), see doc to use other codecs
3104    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3105        let mut len_ = <i32>::sse_decode(deserializer);
3106        let mut ans_ = vec![];
3107        for idx_ in 0..len_ {
3108            ans_.push(<crate::model::PaymentState>::sse_decode(deserializer));
3109        }
3110        return ans_;
3111    }
3112}
3113
3114impl SseDecode for Vec<crate::model::PaymentType> {
3115    // Codec=Sse (Serialization based), see doc to use other codecs
3116    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3117        let mut len_ = <i32>::sse_decode(deserializer);
3118        let mut ans_ = vec![];
3119        for idx_ in 0..len_ {
3120            ans_.push(<crate::model::PaymentType>::sse_decode(deserializer));
3121        }
3122        return ans_;
3123    }
3124}
3125
3126impl SseDecode for crate::model::ListPaymentsRequest {
3127    // Codec=Sse (Serialization based), see doc to use other codecs
3128    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3129        let mut var_filters = <Option<Vec<crate::model::PaymentType>>>::sse_decode(deserializer);
3130        let mut var_states = <Option<Vec<crate::model::PaymentState>>>::sse_decode(deserializer);
3131        let mut var_fromTimestamp = <Option<i64>>::sse_decode(deserializer);
3132        let mut var_toTimestamp = <Option<i64>>::sse_decode(deserializer);
3133        let mut var_offset = <Option<u32>>::sse_decode(deserializer);
3134        let mut var_limit = <Option<u32>>::sse_decode(deserializer);
3135        let mut var_details = <Option<crate::model::ListPaymentDetails>>::sse_decode(deserializer);
3136        let mut var_sortAscending = <Option<bool>>::sse_decode(deserializer);
3137        return crate::model::ListPaymentsRequest {
3138            filters: var_filters,
3139            states: var_states,
3140            from_timestamp: var_fromTimestamp,
3141            to_timestamp: var_toTimestamp,
3142            offset: var_offset,
3143            limit: var_limit,
3144            details: var_details,
3145            sort_ascending: var_sortAscending,
3146        };
3147    }
3148}
3149
3150impl SseDecode for Vec<u8> {
3151    // Codec=Sse (Serialization based), see doc to use other codecs
3152    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3153        let mut len_ = <i32>::sse_decode(deserializer);
3154        let mut ans_ = vec![];
3155        for idx_ in 0..len_ {
3156            ans_.push(<u8>::sse_decode(deserializer));
3157        }
3158        return ans_;
3159    }
3160}
3161
3162impl SseDecode for Vec<crate::bindings::Rate> {
3163    // Codec=Sse (Serialization based), see doc to use other codecs
3164    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3165        let mut len_ = <i32>::sse_decode(deserializer);
3166        let mut ans_ = vec![];
3167        for idx_ in 0..len_ {
3168            ans_.push(<crate::bindings::Rate>::sse_decode(deserializer));
3169        }
3170        return ans_;
3171    }
3172}
3173
3174impl SseDecode for Vec<crate::model::RefundableSwap> {
3175    // Codec=Sse (Serialization based), see doc to use other codecs
3176    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3177        let mut len_ = <i32>::sse_decode(deserializer);
3178        let mut ans_ = vec![];
3179        for idx_ in 0..len_ {
3180            ans_.push(<crate::model::RefundableSwap>::sse_decode(deserializer));
3181        }
3182        return ans_;
3183    }
3184}
3185
3186impl SseDecode for Vec<crate::bindings::RouteHint> {
3187    // Codec=Sse (Serialization based), see doc to use other codecs
3188    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3189        let mut len_ = <i32>::sse_decode(deserializer);
3190        let mut ans_ = vec![];
3191        for idx_ in 0..len_ {
3192            ans_.push(<crate::bindings::RouteHint>::sse_decode(deserializer));
3193        }
3194        return ans_;
3195    }
3196}
3197
3198impl SseDecode for Vec<crate::bindings::RouteHintHop> {
3199    // Codec=Sse (Serialization based), see doc to use other codecs
3200    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3201        let mut len_ = <i32>::sse_decode(deserializer);
3202        let mut ans_ = vec![];
3203        for idx_ in 0..len_ {
3204            ans_.push(<crate::bindings::RouteHintHop>::sse_decode(deserializer));
3205        }
3206        return ans_;
3207    }
3208}
3209
3210impl SseDecode for crate::bindings::LNInvoice {
3211    // Codec=Sse (Serialization based), see doc to use other codecs
3212    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3213        let mut var_bolt11 = <String>::sse_decode(deserializer);
3214        let mut var_network = <crate::bindings::Network>::sse_decode(deserializer);
3215        let mut var_payeePubkey = <String>::sse_decode(deserializer);
3216        let mut var_paymentHash = <String>::sse_decode(deserializer);
3217        let mut var_description = <Option<String>>::sse_decode(deserializer);
3218        let mut var_descriptionHash = <Option<String>>::sse_decode(deserializer);
3219        let mut var_amountMsat = <Option<u64>>::sse_decode(deserializer);
3220        let mut var_timestamp = <u64>::sse_decode(deserializer);
3221        let mut var_expiry = <u64>::sse_decode(deserializer);
3222        let mut var_routingHints = <Vec<crate::bindings::RouteHint>>::sse_decode(deserializer);
3223        let mut var_paymentSecret = <Vec<u8>>::sse_decode(deserializer);
3224        let mut var_minFinalCltvExpiryDelta = <u64>::sse_decode(deserializer);
3225        return crate::bindings::LNInvoice {
3226            bolt11: var_bolt11,
3227            network: var_network,
3228            payee_pubkey: var_payeePubkey,
3229            payment_hash: var_paymentHash,
3230            description: var_description,
3231            description_hash: var_descriptionHash,
3232            amount_msat: var_amountMsat,
3233            timestamp: var_timestamp,
3234            expiry: var_expiry,
3235            routing_hints: var_routingHints,
3236            payment_secret: var_paymentSecret,
3237            min_final_cltv_expiry_delta: var_minFinalCltvExpiryDelta,
3238        };
3239    }
3240}
3241
3242impl SseDecode for crate::bindings::LNOffer {
3243    // Codec=Sse (Serialization based), see doc to use other codecs
3244    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3245        let mut var_offer = <String>::sse_decode(deserializer);
3246        let mut var_chains = <Vec<String>>::sse_decode(deserializer);
3247        let mut var_minAmount = <Option<crate::bindings::Amount>>::sse_decode(deserializer);
3248        let mut var_description = <Option<String>>::sse_decode(deserializer);
3249        let mut var_absoluteExpiry = <Option<u64>>::sse_decode(deserializer);
3250        let mut var_issuer = <Option<String>>::sse_decode(deserializer);
3251        let mut var_signingPubkey = <Option<String>>::sse_decode(deserializer);
3252        let mut var_paths = <Vec<crate::bindings::LnOfferBlindedPath>>::sse_decode(deserializer);
3253        return crate::bindings::LNOffer {
3254            offer: var_offer,
3255            chains: var_chains,
3256            min_amount: var_minAmount,
3257            description: var_description,
3258            absolute_expiry: var_absoluteExpiry,
3259            issuer: var_issuer,
3260            signing_pubkey: var_signingPubkey,
3261            paths: var_paths,
3262        };
3263    }
3264}
3265
3266impl SseDecode for crate::bindings::LnOfferBlindedPath {
3267    // Codec=Sse (Serialization based), see doc to use other codecs
3268    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3269        let mut var_blindedHops = <Vec<String>>::sse_decode(deserializer);
3270        return crate::bindings::LnOfferBlindedPath {
3271            blinded_hops: var_blindedHops,
3272        };
3273    }
3274}
3275
3276impl SseDecode for crate::bindings::duplicates::LnUrlAuthError {
3277    // Codec=Sse (Serialization based), see doc to use other codecs
3278    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3279        let mut tag_ = <i32>::sse_decode(deserializer);
3280        match tag_ {
3281            0 => {
3282                let mut var_err = <String>::sse_decode(deserializer);
3283                return crate::bindings::duplicates::LnUrlAuthError::Generic { err: var_err };
3284            }
3285            1 => {
3286                let mut var_err = <String>::sse_decode(deserializer);
3287                return crate::bindings::duplicates::LnUrlAuthError::InvalidUri { err: var_err };
3288            }
3289            2 => {
3290                let mut var_err = <String>::sse_decode(deserializer);
3291                return crate::bindings::duplicates::LnUrlAuthError::ServiceConnectivity {
3292                    err: var_err,
3293                };
3294            }
3295            _ => {
3296                unimplemented!("");
3297            }
3298        }
3299    }
3300}
3301
3302impl SseDecode for crate::bindings::LnUrlAuthRequestData {
3303    // Codec=Sse (Serialization based), see doc to use other codecs
3304    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3305        let mut var_k1 = <String>::sse_decode(deserializer);
3306        let mut var_action = <Option<String>>::sse_decode(deserializer);
3307        let mut var_domain = <String>::sse_decode(deserializer);
3308        let mut var_url = <String>::sse_decode(deserializer);
3309        return crate::bindings::LnUrlAuthRequestData {
3310            k1: var_k1,
3311            action: var_action,
3312            domain: var_domain,
3313            url: var_url,
3314        };
3315    }
3316}
3317
3318impl SseDecode for crate::bindings::duplicates::LnUrlCallbackStatus {
3319    // Codec=Sse (Serialization based), see doc to use other codecs
3320    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3321        let mut tag_ = <i32>::sse_decode(deserializer);
3322        match tag_ {
3323            0 => {
3324                return crate::bindings::duplicates::LnUrlCallbackStatus::Ok;
3325            }
3326            1 => {
3327                let mut var_data = <crate::bindings::LnUrlErrorData>::sse_decode(deserializer);
3328                return crate::bindings::duplicates::LnUrlCallbackStatus::ErrorStatus {
3329                    data: var_data,
3330                };
3331            }
3332            _ => {
3333                unimplemented!("");
3334            }
3335        }
3336    }
3337}
3338
3339impl SseDecode for crate::bindings::LnUrlErrorData {
3340    // Codec=Sse (Serialization based), see doc to use other codecs
3341    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3342        let mut var_reason = <String>::sse_decode(deserializer);
3343        return crate::bindings::LnUrlErrorData { reason: var_reason };
3344    }
3345}
3346
3347impl SseDecode for crate::model::LnUrlInfo {
3348    // Codec=Sse (Serialization based), see doc to use other codecs
3349    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3350        let mut var_lnAddress = <Option<String>>::sse_decode(deserializer);
3351        let mut var_lnurlPayComment = <Option<String>>::sse_decode(deserializer);
3352        let mut var_lnurlPayDomain = <Option<String>>::sse_decode(deserializer);
3353        let mut var_lnurlPayMetadata = <Option<String>>::sse_decode(deserializer);
3354        let mut var_lnurlPaySuccessAction =
3355            <Option<crate::bindings::SuccessActionProcessed>>::sse_decode(deserializer);
3356        let mut var_lnurlPayUnprocessedSuccessAction =
3357            <Option<crate::bindings::SuccessAction>>::sse_decode(deserializer);
3358        let mut var_lnurlWithdrawEndpoint = <Option<String>>::sse_decode(deserializer);
3359        return crate::model::LnUrlInfo {
3360            ln_address: var_lnAddress,
3361            lnurl_pay_comment: var_lnurlPayComment,
3362            lnurl_pay_domain: var_lnurlPayDomain,
3363            lnurl_pay_metadata: var_lnurlPayMetadata,
3364            lnurl_pay_success_action: var_lnurlPaySuccessAction,
3365            lnurl_pay_unprocessed_success_action: var_lnurlPayUnprocessedSuccessAction,
3366            lnurl_withdraw_endpoint: var_lnurlWithdrawEndpoint,
3367        };
3368    }
3369}
3370
3371impl SseDecode for crate::bindings::duplicates::LnUrlPayError {
3372    // Codec=Sse (Serialization based), see doc to use other codecs
3373    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3374        let mut tag_ = <i32>::sse_decode(deserializer);
3375        match tag_ {
3376            0 => {
3377                return crate::bindings::duplicates::LnUrlPayError::AlreadyPaid;
3378            }
3379            1 => {
3380                let mut var_err = <String>::sse_decode(deserializer);
3381                return crate::bindings::duplicates::LnUrlPayError::Generic { err: var_err };
3382            }
3383            2 => {
3384                let mut var_err = <String>::sse_decode(deserializer);
3385                return crate::bindings::duplicates::LnUrlPayError::InsufficientBalance {
3386                    err: var_err,
3387                };
3388            }
3389            3 => {
3390                let mut var_err = <String>::sse_decode(deserializer);
3391                return crate::bindings::duplicates::LnUrlPayError::InvalidAmount { err: var_err };
3392            }
3393            4 => {
3394                let mut var_err = <String>::sse_decode(deserializer);
3395                return crate::bindings::duplicates::LnUrlPayError::InvalidInvoice { err: var_err };
3396            }
3397            5 => {
3398                let mut var_err = <String>::sse_decode(deserializer);
3399                return crate::bindings::duplicates::LnUrlPayError::InvalidNetwork { err: var_err };
3400            }
3401            6 => {
3402                let mut var_err = <String>::sse_decode(deserializer);
3403                return crate::bindings::duplicates::LnUrlPayError::InvalidUri { err: var_err };
3404            }
3405            7 => {
3406                let mut var_err = <String>::sse_decode(deserializer);
3407                return crate::bindings::duplicates::LnUrlPayError::InvoiceExpired { err: var_err };
3408            }
3409            8 => {
3410                let mut var_err = <String>::sse_decode(deserializer);
3411                return crate::bindings::duplicates::LnUrlPayError::PaymentFailed { err: var_err };
3412            }
3413            9 => {
3414                let mut var_err = <String>::sse_decode(deserializer);
3415                return crate::bindings::duplicates::LnUrlPayError::PaymentTimeout { err: var_err };
3416            }
3417            10 => {
3418                let mut var_err = <String>::sse_decode(deserializer);
3419                return crate::bindings::duplicates::LnUrlPayError::RouteNotFound { err: var_err };
3420            }
3421            11 => {
3422                let mut var_err = <String>::sse_decode(deserializer);
3423                return crate::bindings::duplicates::LnUrlPayError::RouteTooExpensive {
3424                    err: var_err,
3425                };
3426            }
3427            12 => {
3428                let mut var_err = <String>::sse_decode(deserializer);
3429                return crate::bindings::duplicates::LnUrlPayError::ServiceConnectivity {
3430                    err: var_err,
3431                };
3432            }
3433            _ => {
3434                unimplemented!("");
3435            }
3436        }
3437    }
3438}
3439
3440impl SseDecode for crate::bindings::LnUrlPayErrorData {
3441    // Codec=Sse (Serialization based), see doc to use other codecs
3442    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3443        let mut var_paymentHash = <String>::sse_decode(deserializer);
3444        let mut var_reason = <String>::sse_decode(deserializer);
3445        return crate::bindings::LnUrlPayErrorData {
3446            payment_hash: var_paymentHash,
3447            reason: var_reason,
3448        };
3449    }
3450}
3451
3452impl SseDecode for crate::model::LnUrlPayRequest {
3453    // Codec=Sse (Serialization based), see doc to use other codecs
3454    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3455        let mut var_prepareResponse =
3456            <crate::model::PrepareLnUrlPayResponse>::sse_decode(deserializer);
3457        return crate::model::LnUrlPayRequest {
3458            prepare_response: var_prepareResponse,
3459        };
3460    }
3461}
3462
3463impl SseDecode for crate::bindings::LnUrlPayRequestData {
3464    // Codec=Sse (Serialization based), see doc to use other codecs
3465    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3466        let mut var_callback = <String>::sse_decode(deserializer);
3467        let mut var_minSendable = <u64>::sse_decode(deserializer);
3468        let mut var_maxSendable = <u64>::sse_decode(deserializer);
3469        let mut var_metadataStr = <String>::sse_decode(deserializer);
3470        let mut var_commentAllowed = <u16>::sse_decode(deserializer);
3471        let mut var_domain = <String>::sse_decode(deserializer);
3472        let mut var_allowsNostr = <bool>::sse_decode(deserializer);
3473        let mut var_nostrPubkey = <Option<String>>::sse_decode(deserializer);
3474        let mut var_lnAddress = <Option<String>>::sse_decode(deserializer);
3475        return crate::bindings::LnUrlPayRequestData {
3476            callback: var_callback,
3477            min_sendable: var_minSendable,
3478            max_sendable: var_maxSendable,
3479            metadata_str: var_metadataStr,
3480            comment_allowed: var_commentAllowed,
3481            domain: var_domain,
3482            allows_nostr: var_allowsNostr,
3483            nostr_pubkey: var_nostrPubkey,
3484            ln_address: var_lnAddress,
3485        };
3486    }
3487}
3488
3489impl SseDecode for crate::model::LnUrlPayResult {
3490    // Codec=Sse (Serialization based), see doc to use other codecs
3491    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3492        let mut tag_ = <i32>::sse_decode(deserializer);
3493        match tag_ {
3494            0 => {
3495                let mut var_data = <crate::model::LnUrlPaySuccessData>::sse_decode(deserializer);
3496                return crate::model::LnUrlPayResult::EndpointSuccess { data: var_data };
3497            }
3498            1 => {
3499                let mut var_data = <crate::bindings::LnUrlErrorData>::sse_decode(deserializer);
3500                return crate::model::LnUrlPayResult::EndpointError { data: var_data };
3501            }
3502            2 => {
3503                let mut var_data = <crate::bindings::LnUrlPayErrorData>::sse_decode(deserializer);
3504                return crate::model::LnUrlPayResult::PayError { data: var_data };
3505            }
3506            _ => {
3507                unimplemented!("");
3508            }
3509        }
3510    }
3511}
3512
3513impl SseDecode for crate::model::LnUrlPaySuccessData {
3514    // Codec=Sse (Serialization based), see doc to use other codecs
3515    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3516        let mut var_payment = <crate::model::Payment>::sse_decode(deserializer);
3517        let mut var_successAction =
3518            <Option<crate::bindings::SuccessActionProcessed>>::sse_decode(deserializer);
3519        return crate::model::LnUrlPaySuccessData {
3520            payment: var_payment,
3521            success_action: var_successAction,
3522        };
3523    }
3524}
3525
3526impl SseDecode for crate::bindings::duplicates::LnUrlWithdrawError {
3527    // Codec=Sse (Serialization based), see doc to use other codecs
3528    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3529        let mut tag_ = <i32>::sse_decode(deserializer);
3530        match tag_ {
3531            0 => {
3532                let mut var_err = <String>::sse_decode(deserializer);
3533                return crate::bindings::duplicates::LnUrlWithdrawError::Generic { err: var_err };
3534            }
3535            1 => {
3536                let mut var_err = <String>::sse_decode(deserializer);
3537                return crate::bindings::duplicates::LnUrlWithdrawError::InvalidAmount {
3538                    err: var_err,
3539                };
3540            }
3541            2 => {
3542                let mut var_err = <String>::sse_decode(deserializer);
3543                return crate::bindings::duplicates::LnUrlWithdrawError::InvalidInvoice {
3544                    err: var_err,
3545                };
3546            }
3547            3 => {
3548                let mut var_err = <String>::sse_decode(deserializer);
3549                return crate::bindings::duplicates::LnUrlWithdrawError::InvalidUri {
3550                    err: var_err,
3551                };
3552            }
3553            4 => {
3554                let mut var_err = <String>::sse_decode(deserializer);
3555                return crate::bindings::duplicates::LnUrlWithdrawError::InvoiceNoRoutingHints {
3556                    err: var_err,
3557                };
3558            }
3559            5 => {
3560                let mut var_err = <String>::sse_decode(deserializer);
3561                return crate::bindings::duplicates::LnUrlWithdrawError::ServiceConnectivity {
3562                    err: var_err,
3563                };
3564            }
3565            _ => {
3566                unimplemented!("");
3567            }
3568        }
3569    }
3570}
3571
3572impl SseDecode for crate::bindings::LnUrlWithdrawRequest {
3573    // Codec=Sse (Serialization based), see doc to use other codecs
3574    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3575        let mut var_data = <crate::bindings::LnUrlWithdrawRequestData>::sse_decode(deserializer);
3576        let mut var_amountMsat = <u64>::sse_decode(deserializer);
3577        let mut var_description = <Option<String>>::sse_decode(deserializer);
3578        return crate::bindings::LnUrlWithdrawRequest {
3579            data: var_data,
3580            amount_msat: var_amountMsat,
3581            description: var_description,
3582        };
3583    }
3584}
3585
3586impl SseDecode for crate::bindings::LnUrlWithdrawRequestData {
3587    // Codec=Sse (Serialization based), see doc to use other codecs
3588    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3589        let mut var_callback = <String>::sse_decode(deserializer);
3590        let mut var_k1 = <String>::sse_decode(deserializer);
3591        let mut var_defaultDescription = <String>::sse_decode(deserializer);
3592        let mut var_minWithdrawable = <u64>::sse_decode(deserializer);
3593        let mut var_maxWithdrawable = <u64>::sse_decode(deserializer);
3594        return crate::bindings::LnUrlWithdrawRequestData {
3595            callback: var_callback,
3596            k1: var_k1,
3597            default_description: var_defaultDescription,
3598            min_withdrawable: var_minWithdrawable,
3599            max_withdrawable: var_maxWithdrawable,
3600        };
3601    }
3602}
3603
3604impl SseDecode for crate::bindings::duplicates::LnUrlWithdrawResult {
3605    // Codec=Sse (Serialization based), see doc to use other codecs
3606    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3607        let mut tag_ = <i32>::sse_decode(deserializer);
3608        match tag_ {
3609            0 => {
3610                let mut var_data =
3611                    <crate::bindings::duplicates::LnUrlWithdrawSuccessData>::sse_decode(
3612                        deserializer,
3613                    );
3614                return crate::bindings::duplicates::LnUrlWithdrawResult::Ok { data: var_data };
3615            }
3616            1 => {
3617                let mut var_data =
3618                    <crate::bindings::duplicates::LnUrlWithdrawSuccessData>::sse_decode(
3619                        deserializer,
3620                    );
3621                return crate::bindings::duplicates::LnUrlWithdrawResult::Timeout {
3622                    data: var_data,
3623                };
3624            }
3625            2 => {
3626                let mut var_data = <crate::bindings::LnUrlErrorData>::sse_decode(deserializer);
3627                return crate::bindings::duplicates::LnUrlWithdrawResult::ErrorStatus {
3628                    data: var_data,
3629                };
3630            }
3631            _ => {
3632                unimplemented!("");
3633            }
3634        }
3635    }
3636}
3637
3638impl SseDecode for crate::bindings::duplicates::LnUrlWithdrawSuccessData {
3639    // Codec=Sse (Serialization based), see doc to use other codecs
3640    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3641        let mut var_invoice = <crate::bindings::LNInvoice>::sse_decode(deserializer);
3642        return crate::bindings::duplicates::LnUrlWithdrawSuccessData {
3643            invoice: var_invoice,
3644        };
3645    }
3646}
3647
3648impl SseDecode for crate::bindings::LocaleOverrides {
3649    // Codec=Sse (Serialization based), see doc to use other codecs
3650    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3651        let mut var_locale = <String>::sse_decode(deserializer);
3652        let mut var_spacing = <Option<u32>>::sse_decode(deserializer);
3653        let mut var_symbol = <crate::bindings::Symbol>::sse_decode(deserializer);
3654        return crate::bindings::LocaleOverrides {
3655            locale: var_locale,
3656            spacing: var_spacing,
3657            symbol: var_symbol,
3658        };
3659    }
3660}
3661
3662impl SseDecode for crate::bindings::LocalizedName {
3663    // Codec=Sse (Serialization based), see doc to use other codecs
3664    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3665        let mut var_locale = <String>::sse_decode(deserializer);
3666        let mut var_name = <String>::sse_decode(deserializer);
3667        return crate::bindings::LocalizedName {
3668            locale: var_locale,
3669            name: var_name,
3670        };
3671    }
3672}
3673
3674impl SseDecode for crate::model::LogEntry {
3675    // Codec=Sse (Serialization based), see doc to use other codecs
3676    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3677        let mut var_line = <String>::sse_decode(deserializer);
3678        let mut var_level = <String>::sse_decode(deserializer);
3679        return crate::model::LogEntry {
3680            line: var_line,
3681            level: var_level,
3682        };
3683    }
3684}
3685
3686impl SseDecode for crate::bindings::MessageSuccessActionData {
3687    // Codec=Sse (Serialization based), see doc to use other codecs
3688    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3689        let mut var_message = <String>::sse_decode(deserializer);
3690        return crate::bindings::MessageSuccessActionData {
3691            message: var_message,
3692        };
3693    }
3694}
3695
3696impl SseDecode for crate::bindings::Network {
3697    // Codec=Sse (Serialization based), see doc to use other codecs
3698    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3699        let mut inner = <i32>::sse_decode(deserializer);
3700        return match inner {
3701            0 => crate::bindings::Network::Bitcoin,
3702            1 => crate::bindings::Network::Testnet,
3703            2 => crate::bindings::Network::Signet,
3704            3 => crate::bindings::Network::Regtest,
3705            _ => unreachable!("Invalid variant for Network: {}", inner),
3706        };
3707    }
3708}
3709
3710impl SseDecode for crate::model::OnchainPaymentLimitsResponse {
3711    // Codec=Sse (Serialization based), see doc to use other codecs
3712    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3713        let mut var_send = <crate::model::Limits>::sse_decode(deserializer);
3714        let mut var_receive = <crate::model::Limits>::sse_decode(deserializer);
3715        return crate::model::OnchainPaymentLimitsResponse {
3716            send: var_send,
3717            receive: var_receive,
3718        };
3719    }
3720}
3721
3722impl SseDecode for Option<String> {
3723    // Codec=Sse (Serialization based), see doc to use other codecs
3724    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3725        if (<bool>::sse_decode(deserializer)) {
3726            return Some(<String>::sse_decode(deserializer));
3727        } else {
3728            return None;
3729        }
3730    }
3731}
3732
3733impl SseDecode for Option<crate::bindings::Amount> {
3734    // Codec=Sse (Serialization based), see doc to use other codecs
3735    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3736        if (<bool>::sse_decode(deserializer)) {
3737            return Some(<crate::bindings::Amount>::sse_decode(deserializer));
3738        } else {
3739            return None;
3740        }
3741    }
3742}
3743
3744impl SseDecode for Option<crate::model::AssetInfo> {
3745    // Codec=Sse (Serialization based), see doc to use other codecs
3746    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3747        if (<bool>::sse_decode(deserializer)) {
3748            return Some(<crate::model::AssetInfo>::sse_decode(deserializer));
3749        } else {
3750            return None;
3751        }
3752    }
3753}
3754
3755impl SseDecode for Option<bool> {
3756    // Codec=Sse (Serialization based), see doc to use other codecs
3757    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3758        if (<bool>::sse_decode(deserializer)) {
3759            return Some(<bool>::sse_decode(deserializer));
3760        } else {
3761            return None;
3762        }
3763    }
3764}
3765
3766impl SseDecode for Option<f64> {
3767    // Codec=Sse (Serialization based), see doc to use other codecs
3768    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3769        if (<bool>::sse_decode(deserializer)) {
3770            return Some(<f64>::sse_decode(deserializer));
3771        } else {
3772            return None;
3773        }
3774    }
3775}
3776
3777impl SseDecode for Option<i64> {
3778    // Codec=Sse (Serialization based), see doc to use other codecs
3779    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3780        if (<bool>::sse_decode(deserializer)) {
3781            return Some(<i64>::sse_decode(deserializer));
3782        } else {
3783            return None;
3784        }
3785    }
3786}
3787
3788impl SseDecode for Option<crate::model::ListPaymentDetails> {
3789    // Codec=Sse (Serialization based), see doc to use other codecs
3790    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3791        if (<bool>::sse_decode(deserializer)) {
3792            return Some(<crate::model::ListPaymentDetails>::sse_decode(deserializer));
3793        } else {
3794            return None;
3795        }
3796    }
3797}
3798
3799impl SseDecode for Option<crate::model::LnUrlInfo> {
3800    // Codec=Sse (Serialization based), see doc to use other codecs
3801    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3802        if (<bool>::sse_decode(deserializer)) {
3803            return Some(<crate::model::LnUrlInfo>::sse_decode(deserializer));
3804        } else {
3805            return None;
3806        }
3807    }
3808}
3809
3810impl SseDecode for Option<crate::model::PayAmount> {
3811    // Codec=Sse (Serialization based), see doc to use other codecs
3812    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3813        if (<bool>::sse_decode(deserializer)) {
3814            return Some(<crate::model::PayAmount>::sse_decode(deserializer));
3815        } else {
3816            return None;
3817        }
3818    }
3819}
3820
3821impl SseDecode for Option<crate::model::Payment> {
3822    // Codec=Sse (Serialization based), see doc to use other codecs
3823    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3824        if (<bool>::sse_decode(deserializer)) {
3825            return Some(<crate::model::Payment>::sse_decode(deserializer));
3826        } else {
3827            return None;
3828        }
3829    }
3830}
3831
3832impl SseDecode for Option<crate::model::ReceiveAmount> {
3833    // Codec=Sse (Serialization based), see doc to use other codecs
3834    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3835        if (<bool>::sse_decode(deserializer)) {
3836            return Some(<crate::model::ReceiveAmount>::sse_decode(deserializer));
3837        } else {
3838            return None;
3839        }
3840    }
3841}
3842
3843impl SseDecode for Option<crate::bindings::SuccessAction> {
3844    // Codec=Sse (Serialization based), see doc to use other codecs
3845    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3846        if (<bool>::sse_decode(deserializer)) {
3847            return Some(<crate::bindings::SuccessAction>::sse_decode(deserializer));
3848        } else {
3849            return None;
3850        }
3851    }
3852}
3853
3854impl SseDecode for Option<crate::bindings::SuccessActionProcessed> {
3855    // Codec=Sse (Serialization based), see doc to use other codecs
3856    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3857        if (<bool>::sse_decode(deserializer)) {
3858            return Some(<crate::bindings::SuccessActionProcessed>::sse_decode(
3859                deserializer,
3860            ));
3861        } else {
3862            return None;
3863        }
3864    }
3865}
3866
3867impl SseDecode for Option<crate::bindings::Symbol> {
3868    // Codec=Sse (Serialization based), see doc to use other codecs
3869    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3870        if (<bool>::sse_decode(deserializer)) {
3871            return Some(<crate::bindings::Symbol>::sse_decode(deserializer));
3872        } else {
3873            return None;
3874        }
3875    }
3876}
3877
3878impl SseDecode for Option<u32> {
3879    // Codec=Sse (Serialization based), see doc to use other codecs
3880    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3881        if (<bool>::sse_decode(deserializer)) {
3882            return Some(<u32>::sse_decode(deserializer));
3883        } else {
3884            return None;
3885        }
3886    }
3887}
3888
3889impl SseDecode for Option<u64> {
3890    // Codec=Sse (Serialization based), see doc to use other codecs
3891    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3892        if (<bool>::sse_decode(deserializer)) {
3893            return Some(<u64>::sse_decode(deserializer));
3894        } else {
3895            return None;
3896        }
3897    }
3898}
3899
3900impl SseDecode for Option<Vec<crate::model::AssetMetadata>> {
3901    // Codec=Sse (Serialization based), see doc to use other codecs
3902    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3903        if (<bool>::sse_decode(deserializer)) {
3904            return Some(<Vec<crate::model::AssetMetadata>>::sse_decode(deserializer));
3905        } else {
3906            return None;
3907        }
3908    }
3909}
3910
3911impl SseDecode for Option<Vec<crate::bindings::ExternalInputParser>> {
3912    // Codec=Sse (Serialization based), see doc to use other codecs
3913    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3914        if (<bool>::sse_decode(deserializer)) {
3915            return Some(<Vec<crate::bindings::ExternalInputParser>>::sse_decode(
3916                deserializer,
3917            ));
3918        } else {
3919            return None;
3920        }
3921    }
3922}
3923
3924impl SseDecode for Option<Vec<crate::model::PaymentState>> {
3925    // Codec=Sse (Serialization based), see doc to use other codecs
3926    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3927        if (<bool>::sse_decode(deserializer)) {
3928            return Some(<Vec<crate::model::PaymentState>>::sse_decode(deserializer));
3929        } else {
3930            return None;
3931        }
3932    }
3933}
3934
3935impl SseDecode for Option<Vec<crate::model::PaymentType>> {
3936    // Codec=Sse (Serialization based), see doc to use other codecs
3937    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3938        if (<bool>::sse_decode(deserializer)) {
3939            return Some(<Vec<crate::model::PaymentType>>::sse_decode(deserializer));
3940        } else {
3941            return None;
3942        }
3943    }
3944}
3945
3946impl SseDecode for Option<Vec<u8>> {
3947    // Codec=Sse (Serialization based), see doc to use other codecs
3948    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3949        if (<bool>::sse_decode(deserializer)) {
3950            return Some(<Vec<u8>>::sse_decode(deserializer));
3951        } else {
3952            return None;
3953        }
3954    }
3955}
3956
3957impl SseDecode for crate::model::PayAmount {
3958    // Codec=Sse (Serialization based), see doc to use other codecs
3959    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3960        let mut tag_ = <i32>::sse_decode(deserializer);
3961        match tag_ {
3962            0 => {
3963                let mut var_receiverAmountSat = <u64>::sse_decode(deserializer);
3964                return crate::model::PayAmount::Bitcoin {
3965                    receiver_amount_sat: var_receiverAmountSat,
3966                };
3967            }
3968            1 => {
3969                let mut var_assetId = <String>::sse_decode(deserializer);
3970                let mut var_receiverAmount = <f64>::sse_decode(deserializer);
3971                let mut var_estimateAssetFees = <Option<bool>>::sse_decode(deserializer);
3972                let mut var_payWithBitcoin = <Option<bool>>::sse_decode(deserializer);
3973                return crate::model::PayAmount::Asset {
3974                    asset_id: var_assetId,
3975                    receiver_amount: var_receiverAmount,
3976                    estimate_asset_fees: var_estimateAssetFees,
3977                    pay_with_bitcoin: var_payWithBitcoin,
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_payerNote = <Option<String>>::sse_decode(deserializer);
4048                let mut var_claimTxId = <Option<String>>::sse_decode(deserializer);
4049                let mut var_refundTxId = <Option<String>>::sse_decode(deserializer);
4050                let mut var_refundTxAmountSat = <Option<u64>>::sse_decode(deserializer);
4051                return crate::model::PaymentDetails::Lightning {
4052                    swap_id: var_swapId,
4053                    description: var_description,
4054                    liquid_expiration_blockheight: var_liquidExpirationBlockheight,
4055                    preimage: var_preimage,
4056                    invoice: var_invoice,
4057                    bolt12_offer: var_bolt12Offer,
4058                    payment_hash: var_paymentHash,
4059                    destination_pubkey: var_destinationPubkey,
4060                    lnurl_info: var_lnurlInfo,
4061                    bip353_address: var_bip353Address,
4062                    payer_note: var_payerNote,
4063                    claim_tx_id: var_claimTxId,
4064                    refund_tx_id: var_refundTxId,
4065                    refund_tx_amount_sat: var_refundTxAmountSat,
4066                };
4067            }
4068            1 => {
4069                let mut var_destination = <String>::sse_decode(deserializer);
4070                let mut var_description = <String>::sse_decode(deserializer);
4071                let mut var_assetId = <String>::sse_decode(deserializer);
4072                let mut var_assetInfo = <Option<crate::model::AssetInfo>>::sse_decode(deserializer);
4073                let mut var_lnurlInfo = <Option<crate::model::LnUrlInfo>>::sse_decode(deserializer);
4074                let mut var_bip353Address = <Option<String>>::sse_decode(deserializer);
4075                let mut var_payerNote = <Option<String>>::sse_decode(deserializer);
4076                return crate::model::PaymentDetails::Liquid {
4077                    destination: var_destination,
4078                    description: var_description,
4079                    asset_id: var_assetId,
4080                    asset_info: var_assetInfo,
4081                    lnurl_info: var_lnurlInfo,
4082                    bip353_address: var_bip353Address,
4083                    payer_note: var_payerNote,
4084                };
4085            }
4086            2 => {
4087                let mut var_swapId = <String>::sse_decode(deserializer);
4088                let mut var_bitcoinAddress = <String>::sse_decode(deserializer);
4089                let mut var_description = <String>::sse_decode(deserializer);
4090                let mut var_autoAcceptedFees = <bool>::sse_decode(deserializer);
4091                let mut var_liquidExpirationBlockheight = <Option<u32>>::sse_decode(deserializer);
4092                let mut var_bitcoinExpirationBlockheight = <Option<u32>>::sse_decode(deserializer);
4093                let mut var_lockupTxId = <Option<String>>::sse_decode(deserializer);
4094                let mut var_claimTxId = <Option<String>>::sse_decode(deserializer);
4095                let mut var_refundTxId = <Option<String>>::sse_decode(deserializer);
4096                let mut var_refundTxAmountSat = <Option<u64>>::sse_decode(deserializer);
4097                return crate::model::PaymentDetails::Bitcoin {
4098                    swap_id: var_swapId,
4099                    bitcoin_address: var_bitcoinAddress,
4100                    description: var_description,
4101                    auto_accepted_fees: var_autoAcceptedFees,
4102                    liquid_expiration_blockheight: var_liquidExpirationBlockheight,
4103                    bitcoin_expiration_blockheight: var_bitcoinExpirationBlockheight,
4104                    lockup_tx_id: var_lockupTxId,
4105                    claim_tx_id: var_claimTxId,
4106                    refund_tx_id: var_refundTxId,
4107                    refund_tx_amount_sat: var_refundTxAmountSat,
4108                };
4109            }
4110            _ => {
4111                unimplemented!("");
4112            }
4113        }
4114    }
4115}
4116
4117impl SseDecode for crate::error::PaymentError {
4118    // Codec=Sse (Serialization based), see doc to use other codecs
4119    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4120        let mut tag_ = <i32>::sse_decode(deserializer);
4121        match tag_ {
4122            0 => {
4123                return crate::error::PaymentError::AlreadyClaimed;
4124            }
4125            1 => {
4126                return crate::error::PaymentError::AlreadyPaid;
4127            }
4128            2 => {
4129                return crate::error::PaymentError::PaymentInProgress;
4130            }
4131            3 => {
4132                let mut var_min = <u64>::sse_decode(deserializer);
4133                let mut var_max = <u64>::sse_decode(deserializer);
4134                return crate::error::PaymentError::AmountOutOfRange {
4135                    min: var_min,
4136                    max: var_max,
4137                };
4138            }
4139            4 => {
4140                let mut var_err = <String>::sse_decode(deserializer);
4141                return crate::error::PaymentError::AmountMissing { err: var_err };
4142            }
4143            5 => {
4144                let mut var_err = <String>::sse_decode(deserializer);
4145                return crate::error::PaymentError::AssetError { err: var_err };
4146            }
4147            6 => {
4148                let mut var_err = <String>::sse_decode(deserializer);
4149                return crate::error::PaymentError::InvalidNetwork { err: var_err };
4150            }
4151            7 => {
4152                let mut var_err = <String>::sse_decode(deserializer);
4153                return crate::error::PaymentError::Generic { err: var_err };
4154            }
4155            8 => {
4156                return crate::error::PaymentError::InvalidOrExpiredFees;
4157            }
4158            9 => {
4159                return crate::error::PaymentError::InsufficientFunds;
4160            }
4161            10 => {
4162                let mut var_err = <String>::sse_decode(deserializer);
4163                return crate::error::PaymentError::InvalidDescription { err: var_err };
4164            }
4165            11 => {
4166                let mut var_err = <String>::sse_decode(deserializer);
4167                return crate::error::PaymentError::InvalidInvoice { err: var_err };
4168            }
4169            12 => {
4170                return crate::error::PaymentError::InvalidPreimage;
4171            }
4172            13 => {
4173                return crate::error::PaymentError::PairsNotFound;
4174            }
4175            14 => {
4176                return crate::error::PaymentError::PaymentTimeout;
4177            }
4178            15 => {
4179                return crate::error::PaymentError::PersistError;
4180            }
4181            16 => {
4182                let mut var_err = <String>::sse_decode(deserializer);
4183                return crate::error::PaymentError::ReceiveError { err: var_err };
4184            }
4185            17 => {
4186                let mut var_err = <String>::sse_decode(deserializer);
4187                let mut var_refundTxId = <String>::sse_decode(deserializer);
4188                return crate::error::PaymentError::Refunded {
4189                    err: var_err,
4190                    refund_tx_id: var_refundTxId,
4191                };
4192            }
4193            18 => {
4194                return crate::error::PaymentError::SelfTransferNotSupported;
4195            }
4196            19 => {
4197                let mut var_err = <String>::sse_decode(deserializer);
4198                return crate::error::PaymentError::SendError { err: var_err };
4199            }
4200            20 => {
4201                let mut var_err = <String>::sse_decode(deserializer);
4202                return crate::error::PaymentError::SignerError { err: var_err };
4203            }
4204            _ => {
4205                unimplemented!("");
4206            }
4207        }
4208    }
4209}
4210
4211impl SseDecode for crate::model::PaymentMethod {
4212    // Codec=Sse (Serialization based), see doc to use other codecs
4213    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4214        let mut inner = <i32>::sse_decode(deserializer);
4215        return match inner {
4216            0 => crate::model::PaymentMethod::Lightning,
4217            1 => crate::model::PaymentMethod::Bolt11Invoice,
4218            2 => crate::model::PaymentMethod::Bolt12Offer,
4219            3 => crate::model::PaymentMethod::BitcoinAddress,
4220            4 => crate::model::PaymentMethod::LiquidAddress,
4221            _ => unreachable!("Invalid variant for PaymentMethod: {}", inner),
4222        };
4223    }
4224}
4225
4226impl SseDecode for crate::model::PaymentState {
4227    // Codec=Sse (Serialization based), see doc to use other codecs
4228    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4229        let mut inner = <i32>::sse_decode(deserializer);
4230        return match inner {
4231            0 => crate::model::PaymentState::Created,
4232            1 => crate::model::PaymentState::Pending,
4233            2 => crate::model::PaymentState::Complete,
4234            3 => crate::model::PaymentState::Failed,
4235            4 => crate::model::PaymentState::TimedOut,
4236            5 => crate::model::PaymentState::Refundable,
4237            6 => crate::model::PaymentState::RefundPending,
4238            7 => crate::model::PaymentState::WaitingFeeAcceptance,
4239            _ => unreachable!("Invalid variant for PaymentState: {}", inner),
4240        };
4241    }
4242}
4243
4244impl SseDecode for crate::model::PaymentType {
4245    // Codec=Sse (Serialization based), see doc to use other codecs
4246    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4247        let mut inner = <i32>::sse_decode(deserializer);
4248        return match inner {
4249            0 => crate::model::PaymentType::Receive,
4250            1 => crate::model::PaymentType::Send,
4251            _ => unreachable!("Invalid variant for PaymentType: {}", inner),
4252        };
4253    }
4254}
4255
4256impl SseDecode for crate::model::PrepareBuyBitcoinRequest {
4257    // Codec=Sse (Serialization based), see doc to use other codecs
4258    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4259        let mut var_provider = <crate::model::BuyBitcoinProvider>::sse_decode(deserializer);
4260        let mut var_amountSat = <u64>::sse_decode(deserializer);
4261        return crate::model::PrepareBuyBitcoinRequest {
4262            provider: var_provider,
4263            amount_sat: var_amountSat,
4264        };
4265    }
4266}
4267
4268impl SseDecode for crate::model::PrepareBuyBitcoinResponse {
4269    // Codec=Sse (Serialization based), see doc to use other codecs
4270    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4271        let mut var_provider = <crate::model::BuyBitcoinProvider>::sse_decode(deserializer);
4272        let mut var_amountSat = <u64>::sse_decode(deserializer);
4273        let mut var_feesSat = <u64>::sse_decode(deserializer);
4274        return crate::model::PrepareBuyBitcoinResponse {
4275            provider: var_provider,
4276            amount_sat: var_amountSat,
4277            fees_sat: var_feesSat,
4278        };
4279    }
4280}
4281
4282impl SseDecode for crate::model::PrepareLnUrlPayRequest {
4283    // Codec=Sse (Serialization based), see doc to use other codecs
4284    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4285        let mut var_data = <crate::bindings::LnUrlPayRequestData>::sse_decode(deserializer);
4286        let mut var_amount = <crate::model::PayAmount>::sse_decode(deserializer);
4287        let mut var_bip353Address = <Option<String>>::sse_decode(deserializer);
4288        let mut var_comment = <Option<String>>::sse_decode(deserializer);
4289        let mut var_validateSuccessActionUrl = <Option<bool>>::sse_decode(deserializer);
4290        return crate::model::PrepareLnUrlPayRequest {
4291            data: var_data,
4292            amount: var_amount,
4293            bip353_address: var_bip353Address,
4294            comment: var_comment,
4295            validate_success_action_url: var_validateSuccessActionUrl,
4296        };
4297    }
4298}
4299
4300impl SseDecode for crate::model::PrepareLnUrlPayResponse {
4301    // Codec=Sse (Serialization based), see doc to use other codecs
4302    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4303        let mut var_destination = <crate::model::SendDestination>::sse_decode(deserializer);
4304        let mut var_feesSat = <u64>::sse_decode(deserializer);
4305        let mut var_data = <crate::bindings::LnUrlPayRequestData>::sse_decode(deserializer);
4306        let mut var_amount = <crate::model::PayAmount>::sse_decode(deserializer);
4307        let mut var_comment = <Option<String>>::sse_decode(deserializer);
4308        let mut var_successAction =
4309            <Option<crate::bindings::SuccessAction>>::sse_decode(deserializer);
4310        return crate::model::PrepareLnUrlPayResponse {
4311            destination: var_destination,
4312            fees_sat: var_feesSat,
4313            data: var_data,
4314            amount: var_amount,
4315            comment: var_comment,
4316            success_action: var_successAction,
4317        };
4318    }
4319}
4320
4321impl SseDecode for crate::model::PreparePayOnchainRequest {
4322    // Codec=Sse (Serialization based), see doc to use other codecs
4323    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4324        let mut var_amount = <crate::model::PayAmount>::sse_decode(deserializer);
4325        let mut var_feeRateSatPerVbyte = <Option<u32>>::sse_decode(deserializer);
4326        return crate::model::PreparePayOnchainRequest {
4327            amount: var_amount,
4328            fee_rate_sat_per_vbyte: var_feeRateSatPerVbyte,
4329        };
4330    }
4331}
4332
4333impl SseDecode for crate::model::PreparePayOnchainResponse {
4334    // Codec=Sse (Serialization based), see doc to use other codecs
4335    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4336        let mut var_receiverAmountSat = <u64>::sse_decode(deserializer);
4337        let mut var_claimFeesSat = <u64>::sse_decode(deserializer);
4338        let mut var_totalFeesSat = <u64>::sse_decode(deserializer);
4339        return crate::model::PreparePayOnchainResponse {
4340            receiver_amount_sat: var_receiverAmountSat,
4341            claim_fees_sat: var_claimFeesSat,
4342            total_fees_sat: var_totalFeesSat,
4343        };
4344    }
4345}
4346
4347impl SseDecode for crate::model::PrepareReceiveRequest {
4348    // Codec=Sse (Serialization based), see doc to use other codecs
4349    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4350        let mut var_paymentMethod = <crate::model::PaymentMethod>::sse_decode(deserializer);
4351        let mut var_amount = <Option<crate::model::ReceiveAmount>>::sse_decode(deserializer);
4352        return crate::model::PrepareReceiveRequest {
4353            payment_method: var_paymentMethod,
4354            amount: var_amount,
4355        };
4356    }
4357}
4358
4359impl SseDecode for crate::model::PrepareReceiveResponse {
4360    // Codec=Sse (Serialization based), see doc to use other codecs
4361    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4362        let mut var_paymentMethod = <crate::model::PaymentMethod>::sse_decode(deserializer);
4363        let mut var_feesSat = <u64>::sse_decode(deserializer);
4364        let mut var_amount = <Option<crate::model::ReceiveAmount>>::sse_decode(deserializer);
4365        let mut var_minPayerAmountSat = <Option<u64>>::sse_decode(deserializer);
4366        let mut var_maxPayerAmountSat = <Option<u64>>::sse_decode(deserializer);
4367        let mut var_swapperFeerate = <Option<f64>>::sse_decode(deserializer);
4368        return crate::model::PrepareReceiveResponse {
4369            payment_method: var_paymentMethod,
4370            fees_sat: var_feesSat,
4371            amount: var_amount,
4372            min_payer_amount_sat: var_minPayerAmountSat,
4373            max_payer_amount_sat: var_maxPayerAmountSat,
4374            swapper_feerate: var_swapperFeerate,
4375        };
4376    }
4377}
4378
4379impl SseDecode for crate::model::PrepareRefundRequest {
4380    // Codec=Sse (Serialization based), see doc to use other codecs
4381    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4382        let mut var_swapAddress = <String>::sse_decode(deserializer);
4383        let mut var_refundAddress = <String>::sse_decode(deserializer);
4384        let mut var_feeRateSatPerVbyte = <u32>::sse_decode(deserializer);
4385        return crate::model::PrepareRefundRequest {
4386            swap_address: var_swapAddress,
4387            refund_address: var_refundAddress,
4388            fee_rate_sat_per_vbyte: var_feeRateSatPerVbyte,
4389        };
4390    }
4391}
4392
4393impl SseDecode for crate::model::PrepareRefundResponse {
4394    // Codec=Sse (Serialization based), see doc to use other codecs
4395    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4396        let mut var_txVsize = <u32>::sse_decode(deserializer);
4397        let mut var_txFeeSat = <u64>::sse_decode(deserializer);
4398        let mut var_lastRefundTxId = <Option<String>>::sse_decode(deserializer);
4399        return crate::model::PrepareRefundResponse {
4400            tx_vsize: var_txVsize,
4401            tx_fee_sat: var_txFeeSat,
4402            last_refund_tx_id: var_lastRefundTxId,
4403        };
4404    }
4405}
4406
4407impl SseDecode for crate::model::PrepareSendRequest {
4408    // Codec=Sse (Serialization based), see doc to use other codecs
4409    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4410        let mut var_destination = <String>::sse_decode(deserializer);
4411        let mut var_amount = <Option<crate::model::PayAmount>>::sse_decode(deserializer);
4412        return crate::model::PrepareSendRequest {
4413            destination: var_destination,
4414            amount: var_amount,
4415        };
4416    }
4417}
4418
4419impl SseDecode for crate::model::PrepareSendResponse {
4420    // Codec=Sse (Serialization based), see doc to use other codecs
4421    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4422        let mut var_destination = <crate::model::SendDestination>::sse_decode(deserializer);
4423        let mut var_amount = <Option<crate::model::PayAmount>>::sse_decode(deserializer);
4424        let mut var_feesSat = <Option<u64>>::sse_decode(deserializer);
4425        let mut var_estimatedAssetFees = <Option<f64>>::sse_decode(deserializer);
4426        return crate::model::PrepareSendResponse {
4427            destination: var_destination,
4428            amount: var_amount,
4429            fees_sat: var_feesSat,
4430            estimated_asset_fees: var_estimatedAssetFees,
4431        };
4432    }
4433}
4434
4435impl SseDecode for crate::bindings::Rate {
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 var_coin = <String>::sse_decode(deserializer);
4439        let mut var_value = <f64>::sse_decode(deserializer);
4440        return crate::bindings::Rate {
4441            coin: var_coin,
4442            value: var_value,
4443        };
4444    }
4445}
4446
4447impl SseDecode for crate::model::ReceiveAmount {
4448    // Codec=Sse (Serialization based), see doc to use other codecs
4449    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4450        let mut tag_ = <i32>::sse_decode(deserializer);
4451        match tag_ {
4452            0 => {
4453                let mut var_payerAmountSat = <u64>::sse_decode(deserializer);
4454                return crate::model::ReceiveAmount::Bitcoin {
4455                    payer_amount_sat: var_payerAmountSat,
4456                };
4457            }
4458            1 => {
4459                let mut var_assetId = <String>::sse_decode(deserializer);
4460                let mut var_payerAmount = <Option<f64>>::sse_decode(deserializer);
4461                return crate::model::ReceiveAmount::Asset {
4462                    asset_id: var_assetId,
4463                    payer_amount: var_payerAmount,
4464                };
4465            }
4466            _ => {
4467                unimplemented!("");
4468            }
4469        }
4470    }
4471}
4472
4473impl SseDecode for crate::model::ReceivePaymentRequest {
4474    // Codec=Sse (Serialization based), see doc to use other codecs
4475    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4476        let mut var_prepareResponse =
4477            <crate::model::PrepareReceiveResponse>::sse_decode(deserializer);
4478        let mut var_description = <Option<String>>::sse_decode(deserializer);
4479        let mut var_useDescriptionHash = <Option<bool>>::sse_decode(deserializer);
4480        let mut var_payerNote = <Option<String>>::sse_decode(deserializer);
4481        return crate::model::ReceivePaymentRequest {
4482            prepare_response: var_prepareResponse,
4483            description: var_description,
4484            use_description_hash: var_useDescriptionHash,
4485            payer_note: var_payerNote,
4486        };
4487    }
4488}
4489
4490impl SseDecode for crate::model::ReceivePaymentResponse {
4491    // Codec=Sse (Serialization based), see doc to use other codecs
4492    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4493        let mut var_destination = <String>::sse_decode(deserializer);
4494        return crate::model::ReceivePaymentResponse {
4495            destination: var_destination,
4496        };
4497    }
4498}
4499
4500impl SseDecode for crate::model::RecommendedFees {
4501    // Codec=Sse (Serialization based), see doc to use other codecs
4502    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4503        let mut var_fastestFee = <u64>::sse_decode(deserializer);
4504        let mut var_halfHourFee = <u64>::sse_decode(deserializer);
4505        let mut var_hourFee = <u64>::sse_decode(deserializer);
4506        let mut var_economyFee = <u64>::sse_decode(deserializer);
4507        let mut var_minimumFee = <u64>::sse_decode(deserializer);
4508        return crate::model::RecommendedFees {
4509            fastest_fee: var_fastestFee,
4510            half_hour_fee: var_halfHourFee,
4511            hour_fee: var_hourFee,
4512            economy_fee: var_economyFee,
4513            minimum_fee: var_minimumFee,
4514        };
4515    }
4516}
4517
4518impl SseDecode for crate::model::RefundRequest {
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_swapAddress = <String>::sse_decode(deserializer);
4522        let mut var_refundAddress = <String>::sse_decode(deserializer);
4523        let mut var_feeRateSatPerVbyte = <u32>::sse_decode(deserializer);
4524        return crate::model::RefundRequest {
4525            swap_address: var_swapAddress,
4526            refund_address: var_refundAddress,
4527            fee_rate_sat_per_vbyte: var_feeRateSatPerVbyte,
4528        };
4529    }
4530}
4531
4532impl SseDecode for crate::model::RefundResponse {
4533    // Codec=Sse (Serialization based), see doc to use other codecs
4534    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4535        let mut var_refundTxId = <String>::sse_decode(deserializer);
4536        return crate::model::RefundResponse {
4537            refund_tx_id: var_refundTxId,
4538        };
4539    }
4540}
4541
4542impl SseDecode for crate::model::RefundableSwap {
4543    // Codec=Sse (Serialization based), see doc to use other codecs
4544    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4545        let mut var_swapAddress = <String>::sse_decode(deserializer);
4546        let mut var_timestamp = <u32>::sse_decode(deserializer);
4547        let mut var_amountSat = <u64>::sse_decode(deserializer);
4548        let mut var_lastRefundTxId = <Option<String>>::sse_decode(deserializer);
4549        return crate::model::RefundableSwap {
4550            swap_address: var_swapAddress,
4551            timestamp: var_timestamp,
4552            amount_sat: var_amountSat,
4553            last_refund_tx_id: var_lastRefundTxId,
4554        };
4555    }
4556}
4557
4558impl SseDecode for crate::model::RestoreRequest {
4559    // Codec=Sse (Serialization based), see doc to use other codecs
4560    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4561        let mut var_backupPath = <Option<String>>::sse_decode(deserializer);
4562        return crate::model::RestoreRequest {
4563            backup_path: var_backupPath,
4564        };
4565    }
4566}
4567
4568impl SseDecode for crate::bindings::RouteHint {
4569    // Codec=Sse (Serialization based), see doc to use other codecs
4570    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4571        let mut var_hops = <Vec<crate::bindings::RouteHintHop>>::sse_decode(deserializer);
4572        return crate::bindings::RouteHint { hops: var_hops };
4573    }
4574}
4575
4576impl SseDecode for crate::bindings::RouteHintHop {
4577    // Codec=Sse (Serialization based), see doc to use other codecs
4578    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4579        let mut var_srcNodeId = <String>::sse_decode(deserializer);
4580        let mut var_shortChannelId = <String>::sse_decode(deserializer);
4581        let mut var_feesBaseMsat = <u32>::sse_decode(deserializer);
4582        let mut var_feesProportionalMillionths = <u32>::sse_decode(deserializer);
4583        let mut var_cltvExpiryDelta = <u64>::sse_decode(deserializer);
4584        let mut var_htlcMinimumMsat = <Option<u64>>::sse_decode(deserializer);
4585        let mut var_htlcMaximumMsat = <Option<u64>>::sse_decode(deserializer);
4586        return crate::bindings::RouteHintHop {
4587            src_node_id: var_srcNodeId,
4588            short_channel_id: var_shortChannelId,
4589            fees_base_msat: var_feesBaseMsat,
4590            fees_proportional_millionths: var_feesProportionalMillionths,
4591            cltv_expiry_delta: var_cltvExpiryDelta,
4592            htlc_minimum_msat: var_htlcMinimumMsat,
4593            htlc_maximum_msat: var_htlcMaximumMsat,
4594        };
4595    }
4596}
4597
4598impl SseDecode for crate::error::SdkError {
4599    // Codec=Sse (Serialization based), see doc to use other codecs
4600    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4601        let mut tag_ = <i32>::sse_decode(deserializer);
4602        match tag_ {
4603            0 => {
4604                return crate::error::SdkError::AlreadyStarted;
4605            }
4606            1 => {
4607                let mut var_err = <String>::sse_decode(deserializer);
4608                return crate::error::SdkError::Generic { err: var_err };
4609            }
4610            2 => {
4611                return crate::error::SdkError::NotStarted;
4612            }
4613            3 => {
4614                let mut var_err = <String>::sse_decode(deserializer);
4615                return crate::error::SdkError::ServiceConnectivity { err: var_err };
4616            }
4617            _ => {
4618                unimplemented!("");
4619            }
4620        }
4621    }
4622}
4623
4624impl SseDecode for crate::model::SdkEvent {
4625    // Codec=Sse (Serialization based), see doc to use other codecs
4626    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4627        let mut tag_ = <i32>::sse_decode(deserializer);
4628        match tag_ {
4629            0 => {
4630                let mut var_details = <crate::model::Payment>::sse_decode(deserializer);
4631                return crate::model::SdkEvent::PaymentFailed {
4632                    details: var_details,
4633                };
4634            }
4635            1 => {
4636                let mut var_details = <crate::model::Payment>::sse_decode(deserializer);
4637                return crate::model::SdkEvent::PaymentPending {
4638                    details: var_details,
4639                };
4640            }
4641            2 => {
4642                let mut var_details = <crate::model::Payment>::sse_decode(deserializer);
4643                return crate::model::SdkEvent::PaymentRefundable {
4644                    details: var_details,
4645                };
4646            }
4647            3 => {
4648                let mut var_details = <crate::model::Payment>::sse_decode(deserializer);
4649                return crate::model::SdkEvent::PaymentRefunded {
4650                    details: var_details,
4651                };
4652            }
4653            4 => {
4654                let mut var_details = <crate::model::Payment>::sse_decode(deserializer);
4655                return crate::model::SdkEvent::PaymentRefundPending {
4656                    details: var_details,
4657                };
4658            }
4659            5 => {
4660                let mut var_details = <crate::model::Payment>::sse_decode(deserializer);
4661                return crate::model::SdkEvent::PaymentSucceeded {
4662                    details: var_details,
4663                };
4664            }
4665            6 => {
4666                let mut var_details = <crate::model::Payment>::sse_decode(deserializer);
4667                return crate::model::SdkEvent::PaymentWaitingConfirmation {
4668                    details: var_details,
4669                };
4670            }
4671            7 => {
4672                let mut var_details = <crate::model::Payment>::sse_decode(deserializer);
4673                return crate::model::SdkEvent::PaymentWaitingFeeAcceptance {
4674                    details: var_details,
4675                };
4676            }
4677            8 => {
4678                return crate::model::SdkEvent::Synced;
4679            }
4680            9 => {
4681                let mut var_didPullNewRecords = <bool>::sse_decode(deserializer);
4682                return crate::model::SdkEvent::DataSynced {
4683                    did_pull_new_records: var_didPullNewRecords,
4684                };
4685            }
4686            _ => {
4687                unimplemented!("");
4688            }
4689        }
4690    }
4691}
4692
4693impl SseDecode for crate::model::SendDestination {
4694    // Codec=Sse (Serialization based), see doc to use other codecs
4695    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4696        let mut tag_ = <i32>::sse_decode(deserializer);
4697        match tag_ {
4698            0 => {
4699                let mut var_addressData =
4700                    <crate::bindings::LiquidAddressData>::sse_decode(deserializer);
4701                let mut var_bip353Address = <Option<String>>::sse_decode(deserializer);
4702                return crate::model::SendDestination::LiquidAddress {
4703                    address_data: var_addressData,
4704                    bip353_address: var_bip353Address,
4705                };
4706            }
4707            1 => {
4708                let mut var_invoice = <crate::bindings::LNInvoice>::sse_decode(deserializer);
4709                let mut var_bip353Address = <Option<String>>::sse_decode(deserializer);
4710                return crate::model::SendDestination::Bolt11 {
4711                    invoice: var_invoice,
4712                    bip353_address: var_bip353Address,
4713                };
4714            }
4715            2 => {
4716                let mut var_offer = <crate::bindings::LNOffer>::sse_decode(deserializer);
4717                let mut var_receiverAmountSat = <u64>::sse_decode(deserializer);
4718                let mut var_bip353Address = <Option<String>>::sse_decode(deserializer);
4719                return crate::model::SendDestination::Bolt12 {
4720                    offer: var_offer,
4721                    receiver_amount_sat: var_receiverAmountSat,
4722                    bip353_address: var_bip353Address,
4723                };
4724            }
4725            _ => {
4726                unimplemented!("");
4727            }
4728        }
4729    }
4730}
4731
4732impl SseDecode for crate::model::SendPaymentRequest {
4733    // Codec=Sse (Serialization based), see doc to use other codecs
4734    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4735        let mut var_prepareResponse = <crate::model::PrepareSendResponse>::sse_decode(deserializer);
4736        let mut var_useAssetFees = <Option<bool>>::sse_decode(deserializer);
4737        let mut var_payerNote = <Option<String>>::sse_decode(deserializer);
4738        return crate::model::SendPaymentRequest {
4739            prepare_response: var_prepareResponse,
4740            use_asset_fees: var_useAssetFees,
4741            payer_note: var_payerNote,
4742        };
4743    }
4744}
4745
4746impl SseDecode for crate::model::SendPaymentResponse {
4747    // Codec=Sse (Serialization based), see doc to use other codecs
4748    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4749        let mut var_payment = <crate::model::Payment>::sse_decode(deserializer);
4750        return crate::model::SendPaymentResponse {
4751            payment: var_payment,
4752        };
4753    }
4754}
4755
4756impl SseDecode for crate::model::SignMessageRequest {
4757    // Codec=Sse (Serialization based), see doc to use other codecs
4758    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4759        let mut var_message = <String>::sse_decode(deserializer);
4760        return crate::model::SignMessageRequest {
4761            message: var_message,
4762        };
4763    }
4764}
4765
4766impl SseDecode for crate::model::SignMessageResponse {
4767    // Codec=Sse (Serialization based), see doc to use other codecs
4768    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4769        let mut var_signature = <String>::sse_decode(deserializer);
4770        return crate::model::SignMessageResponse {
4771            signature: var_signature,
4772        };
4773    }
4774}
4775
4776impl SseDecode for crate::bindings::SuccessAction {
4777    // Codec=Sse (Serialization based), see doc to use other codecs
4778    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4779        let mut tag_ = <i32>::sse_decode(deserializer);
4780        match tag_ {
4781            0 => {
4782                let mut var_data =
4783                    <crate::bindings::AesSuccessActionData>::sse_decode(deserializer);
4784                return crate::bindings::SuccessAction::Aes { data: var_data };
4785            }
4786            1 => {
4787                let mut var_data =
4788                    <crate::bindings::MessageSuccessActionData>::sse_decode(deserializer);
4789                return crate::bindings::SuccessAction::Message { data: var_data };
4790            }
4791            2 => {
4792                let mut var_data =
4793                    <crate::bindings::UrlSuccessActionData>::sse_decode(deserializer);
4794                return crate::bindings::SuccessAction::Url { data: var_data };
4795            }
4796            _ => {
4797                unimplemented!("");
4798            }
4799        }
4800    }
4801}
4802
4803impl SseDecode for crate::bindings::SuccessActionProcessed {
4804    // Codec=Sse (Serialization based), see doc to use other codecs
4805    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4806        let mut tag_ = <i32>::sse_decode(deserializer);
4807        match tag_ {
4808            0 => {
4809                let mut var_result =
4810                    <crate::bindings::AesSuccessActionDataResult>::sse_decode(deserializer);
4811                return crate::bindings::SuccessActionProcessed::Aes { result: var_result };
4812            }
4813            1 => {
4814                let mut var_data =
4815                    <crate::bindings::MessageSuccessActionData>::sse_decode(deserializer);
4816                return crate::bindings::SuccessActionProcessed::Message { data: var_data };
4817            }
4818            2 => {
4819                let mut var_data =
4820                    <crate::bindings::UrlSuccessActionData>::sse_decode(deserializer);
4821                return crate::bindings::SuccessActionProcessed::Url { data: var_data };
4822            }
4823            _ => {
4824                unimplemented!("");
4825            }
4826        }
4827    }
4828}
4829
4830impl SseDecode for crate::bindings::Symbol {
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        let mut var_grapheme = <Option<String>>::sse_decode(deserializer);
4834        let mut var_template = <Option<String>>::sse_decode(deserializer);
4835        let mut var_rtl = <Option<bool>>::sse_decode(deserializer);
4836        let mut var_position = <Option<u32>>::sse_decode(deserializer);
4837        return crate::bindings::Symbol {
4838            grapheme: var_grapheme,
4839            template: var_template,
4840            rtl: var_rtl,
4841            position: var_position,
4842        };
4843    }
4844}
4845
4846impl SseDecode for u16 {
4847    // Codec=Sse (Serialization based), see doc to use other codecs
4848    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4849        deserializer.cursor.read_u16::<NativeEndian>().unwrap()
4850    }
4851}
4852
4853impl SseDecode for u32 {
4854    // Codec=Sse (Serialization based), see doc to use other codecs
4855    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4856        deserializer.cursor.read_u32::<NativeEndian>().unwrap()
4857    }
4858}
4859
4860impl SseDecode for u64 {
4861    // Codec=Sse (Serialization based), see doc to use other codecs
4862    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4863        deserializer.cursor.read_u64::<NativeEndian>().unwrap()
4864    }
4865}
4866
4867impl SseDecode for u8 {
4868    // Codec=Sse (Serialization based), see doc to use other codecs
4869    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4870        deserializer.cursor.read_u8().unwrap()
4871    }
4872}
4873
4874impl SseDecode for () {
4875    // Codec=Sse (Serialization based), see doc to use other codecs
4876    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {}
4877}
4878
4879impl SseDecode for crate::bindings::UrlSuccessActionData {
4880    // Codec=Sse (Serialization based), see doc to use other codecs
4881    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4882        let mut var_description = <String>::sse_decode(deserializer);
4883        let mut var_url = <String>::sse_decode(deserializer);
4884        let mut var_matchesCallbackDomain = <bool>::sse_decode(deserializer);
4885        return crate::bindings::UrlSuccessActionData {
4886            description: var_description,
4887            url: var_url,
4888            matches_callback_domain: var_matchesCallbackDomain,
4889        };
4890    }
4891}
4892
4893impl SseDecode for usize {
4894    // Codec=Sse (Serialization based), see doc to use other codecs
4895    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4896        deserializer.cursor.read_u64::<NativeEndian>().unwrap() as _
4897    }
4898}
4899
4900impl SseDecode for crate::model::WalletInfo {
4901    // Codec=Sse (Serialization based), see doc to use other codecs
4902    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4903        let mut var_balanceSat = <u64>::sse_decode(deserializer);
4904        let mut var_pendingSendSat = <u64>::sse_decode(deserializer);
4905        let mut var_pendingReceiveSat = <u64>::sse_decode(deserializer);
4906        let mut var_fingerprint = <String>::sse_decode(deserializer);
4907        let mut var_pubkey = <String>::sse_decode(deserializer);
4908        let mut var_assetBalances = <Vec<crate::model::AssetBalance>>::sse_decode(deserializer);
4909        return crate::model::WalletInfo {
4910            balance_sat: var_balanceSat,
4911            pending_send_sat: var_pendingSendSat,
4912            pending_receive_sat: var_pendingReceiveSat,
4913            fingerprint: var_fingerprint,
4914            pubkey: var_pubkey,
4915            asset_balances: var_assetBalances,
4916        };
4917    }
4918}
4919
4920fn pde_ffi_dispatcher_primary_impl(
4921    func_id: i32,
4922    port: flutter_rust_bridge::for_generated::MessagePort,
4923    ptr: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
4924    rust_vec_len: i32,
4925    data_len: i32,
4926) {
4927    // Codec=Pde (Serialization + dispatch), see doc to use other codecs
4928    match func_id {
4929        _ => unreachable!(),
4930    }
4931}
4932
4933fn pde_ffi_dispatcher_sync_impl(
4934    func_id: i32,
4935    ptr: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
4936    rust_vec_len: i32,
4937    data_len: i32,
4938) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
4939    // Codec=Pde (Serialization + dispatch), see doc to use other codecs
4940    match func_id {
4941        _ => unreachable!(),
4942    }
4943}
4944
4945// Section: rust2dart
4946
4947// Codec=Dco (DartCObject based), see doc to use other codecs
4948impl flutter_rust_bridge::IntoDart for FrbWrapper<BindingLiquidSdk> {
4949    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
4950        flutter_rust_bridge::for_generated::rust_auto_opaque_encode::<_, StdArc<_>>(self.0)
4951            .into_dart()
4952    }
4953}
4954impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for FrbWrapper<BindingLiquidSdk> {}
4955
4956impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<BindingLiquidSdk>> for BindingLiquidSdk {
4957    fn into_into_dart(self) -> FrbWrapper<BindingLiquidSdk> {
4958        self.into()
4959    }
4960}
4961
4962// Codec=Dco (DartCObject based), see doc to use other codecs
4963impl flutter_rust_bridge::IntoDart for crate::model::AcceptPaymentProposedFeesRequest {
4964    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
4965        [self.response.into_into_dart().into_dart()].into_dart()
4966    }
4967}
4968impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
4969    for crate::model::AcceptPaymentProposedFeesRequest
4970{
4971}
4972impl flutter_rust_bridge::IntoIntoDart<crate::model::AcceptPaymentProposedFeesRequest>
4973    for crate::model::AcceptPaymentProposedFeesRequest
4974{
4975    fn into_into_dart(self) -> crate::model::AcceptPaymentProposedFeesRequest {
4976        self
4977    }
4978}
4979// Codec=Dco (DartCObject based), see doc to use other codecs
4980impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::AesSuccessActionData> {
4981    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
4982        [
4983            self.0.description.into_into_dart().into_dart(),
4984            self.0.ciphertext.into_into_dart().into_dart(),
4985            self.0.iv.into_into_dart().into_dart(),
4986        ]
4987        .into_dart()
4988    }
4989}
4990impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
4991    for FrbWrapper<crate::bindings::AesSuccessActionData>
4992{
4993}
4994impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::AesSuccessActionData>>
4995    for crate::bindings::AesSuccessActionData
4996{
4997    fn into_into_dart(self) -> FrbWrapper<crate::bindings::AesSuccessActionData> {
4998        self.into()
4999    }
5000}
5001// Codec=Dco (DartCObject based), see doc to use other codecs
5002impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::AesSuccessActionDataDecrypted> {
5003    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5004        [
5005            self.0.description.into_into_dart().into_dart(),
5006            self.0.plaintext.into_into_dart().into_dart(),
5007        ]
5008        .into_dart()
5009    }
5010}
5011impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5012    for FrbWrapper<crate::bindings::AesSuccessActionDataDecrypted>
5013{
5014}
5015impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::AesSuccessActionDataDecrypted>>
5016    for crate::bindings::AesSuccessActionDataDecrypted
5017{
5018    fn into_into_dart(self) -> FrbWrapper<crate::bindings::AesSuccessActionDataDecrypted> {
5019        self.into()
5020    }
5021}
5022// Codec=Dco (DartCObject based), see doc to use other codecs
5023impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::AesSuccessActionDataResult> {
5024    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5025        match self.0 {
5026            crate::bindings::AesSuccessActionDataResult::Decrypted { data } => {
5027                [0.into_dart(), data.into_into_dart().into_dart()].into_dart()
5028            }
5029            crate::bindings::AesSuccessActionDataResult::ErrorStatus { reason } => {
5030                [1.into_dart(), reason.into_into_dart().into_dart()].into_dart()
5031            }
5032            _ => {
5033                unimplemented!("");
5034            }
5035        }
5036    }
5037}
5038impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5039    for FrbWrapper<crate::bindings::AesSuccessActionDataResult>
5040{
5041}
5042impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::AesSuccessActionDataResult>>
5043    for crate::bindings::AesSuccessActionDataResult
5044{
5045    fn into_into_dart(self) -> FrbWrapper<crate::bindings::AesSuccessActionDataResult> {
5046        self.into()
5047    }
5048}
5049// Codec=Dco (DartCObject based), see doc to use other codecs
5050impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::Amount> {
5051    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5052        match self.0 {
5053            crate::bindings::Amount::Bitcoin { amount_msat } => {
5054                [0.into_dart(), amount_msat.into_into_dart().into_dart()].into_dart()
5055            }
5056            crate::bindings::Amount::Currency {
5057                iso4217_code,
5058                fractional_amount,
5059            } => [
5060                1.into_dart(),
5061                iso4217_code.into_into_dart().into_dart(),
5062                fractional_amount.into_into_dart().into_dart(),
5063            ]
5064            .into_dart(),
5065            _ => {
5066                unimplemented!("");
5067            }
5068        }
5069    }
5070}
5071impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5072    for FrbWrapper<crate::bindings::Amount>
5073{
5074}
5075impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::Amount>>
5076    for crate::bindings::Amount
5077{
5078    fn into_into_dart(self) -> FrbWrapper<crate::bindings::Amount> {
5079        self.into()
5080    }
5081}
5082// Codec=Dco (DartCObject based), see doc to use other codecs
5083impl flutter_rust_bridge::IntoDart for crate::model::AssetBalance {
5084    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5085        [
5086            self.asset_id.into_into_dart().into_dart(),
5087            self.balance_sat.into_into_dart().into_dart(),
5088            self.name.into_into_dart().into_dart(),
5089            self.ticker.into_into_dart().into_dart(),
5090            self.balance.into_into_dart().into_dart(),
5091        ]
5092        .into_dart()
5093    }
5094}
5095impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::AssetBalance {}
5096impl flutter_rust_bridge::IntoIntoDart<crate::model::AssetBalance> for crate::model::AssetBalance {
5097    fn into_into_dart(self) -> crate::model::AssetBalance {
5098        self
5099    }
5100}
5101// Codec=Dco (DartCObject based), see doc to use other codecs
5102impl flutter_rust_bridge::IntoDart for crate::model::AssetInfo {
5103    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5104        [
5105            self.name.into_into_dart().into_dart(),
5106            self.ticker.into_into_dart().into_dart(),
5107            self.amount.into_into_dart().into_dart(),
5108            self.fees.into_into_dart().into_dart(),
5109        ]
5110        .into_dart()
5111    }
5112}
5113impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::AssetInfo {}
5114impl flutter_rust_bridge::IntoIntoDart<crate::model::AssetInfo> for crate::model::AssetInfo {
5115    fn into_into_dart(self) -> crate::model::AssetInfo {
5116        self
5117    }
5118}
5119// Codec=Dco (DartCObject based), see doc to use other codecs
5120impl flutter_rust_bridge::IntoDart for crate::model::AssetMetadata {
5121    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5122        [
5123            self.asset_id.into_into_dart().into_dart(),
5124            self.name.into_into_dart().into_dart(),
5125            self.ticker.into_into_dart().into_dart(),
5126            self.precision.into_into_dart().into_dart(),
5127            self.fiat_id.into_into_dart().into_dart(),
5128        ]
5129        .into_dart()
5130    }
5131}
5132impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::AssetMetadata {}
5133impl flutter_rust_bridge::IntoIntoDart<crate::model::AssetMetadata>
5134    for crate::model::AssetMetadata
5135{
5136    fn into_into_dart(self) -> crate::model::AssetMetadata {
5137        self
5138    }
5139}
5140// Codec=Dco (DartCObject based), see doc to use other codecs
5141impl flutter_rust_bridge::IntoDart for crate::model::BackupRequest {
5142    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5143        [self.backup_path.into_into_dart().into_dart()].into_dart()
5144    }
5145}
5146impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::BackupRequest {}
5147impl flutter_rust_bridge::IntoIntoDart<crate::model::BackupRequest>
5148    for crate::model::BackupRequest
5149{
5150    fn into_into_dart(self) -> crate::model::BackupRequest {
5151        self
5152    }
5153}
5154// Codec=Dco (DartCObject based), see doc to use other codecs
5155impl flutter_rust_bridge::IntoDart for crate::bindings::BindingEventListener {
5156    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5157        [self.stream.into_into_dart().into_dart()].into_dart()
5158    }
5159}
5160impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5161    for crate::bindings::BindingEventListener
5162{
5163}
5164impl flutter_rust_bridge::IntoIntoDart<crate::bindings::BindingEventListener>
5165    for crate::bindings::BindingEventListener
5166{
5167    fn into_into_dart(self) -> crate::bindings::BindingEventListener {
5168        self
5169    }
5170}
5171// Codec=Dco (DartCObject based), see doc to use other codecs
5172impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::BitcoinAddressData> {
5173    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5174        [
5175            self.0.address.into_into_dart().into_dart(),
5176            self.0.network.into_into_dart().into_dart(),
5177            self.0.amount_sat.into_into_dart().into_dart(),
5178            self.0.label.into_into_dart().into_dart(),
5179            self.0.message.into_into_dart().into_dart(),
5180        ]
5181        .into_dart()
5182    }
5183}
5184impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5185    for FrbWrapper<crate::bindings::BitcoinAddressData>
5186{
5187}
5188impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::BitcoinAddressData>>
5189    for crate::bindings::BitcoinAddressData
5190{
5191    fn into_into_dart(self) -> FrbWrapper<crate::bindings::BitcoinAddressData> {
5192        self.into()
5193    }
5194}
5195// Codec=Dco (DartCObject based), see doc to use other codecs
5196impl flutter_rust_bridge::IntoDart for crate::model::BlockchainExplorer {
5197    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5198        match self {
5199            crate::model::BlockchainExplorer::Electrum { url } => {
5200                [0.into_dart(), url.into_into_dart().into_dart()].into_dart()
5201            }
5202            crate::model::BlockchainExplorer::Esplora {
5203                url,
5204                use_waterfalls,
5205            } => [
5206                1.into_dart(),
5207                url.into_into_dart().into_dart(),
5208                use_waterfalls.into_into_dart().into_dart(),
5209            ]
5210            .into_dart(),
5211            _ => {
5212                unimplemented!("");
5213            }
5214        }
5215    }
5216}
5217impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5218    for crate::model::BlockchainExplorer
5219{
5220}
5221impl flutter_rust_bridge::IntoIntoDart<crate::model::BlockchainExplorer>
5222    for crate::model::BlockchainExplorer
5223{
5224    fn into_into_dart(self) -> crate::model::BlockchainExplorer {
5225        self
5226    }
5227}
5228// Codec=Dco (DartCObject based), see doc to use other codecs
5229impl flutter_rust_bridge::IntoDart for crate::model::BlockchainInfo {
5230    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5231        [
5232            self.liquid_tip.into_into_dart().into_dart(),
5233            self.bitcoin_tip.into_into_dart().into_dart(),
5234        ]
5235        .into_dart()
5236    }
5237}
5238impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::BlockchainInfo {}
5239impl flutter_rust_bridge::IntoIntoDart<crate::model::BlockchainInfo>
5240    for crate::model::BlockchainInfo
5241{
5242    fn into_into_dart(self) -> crate::model::BlockchainInfo {
5243        self
5244    }
5245}
5246// Codec=Dco (DartCObject based), see doc to use other codecs
5247impl flutter_rust_bridge::IntoDart for crate::model::BuyBitcoinProvider {
5248    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5249        match self {
5250            Self::Moonpay => 0.into_dart(),
5251            _ => unreachable!(),
5252        }
5253    }
5254}
5255impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5256    for crate::model::BuyBitcoinProvider
5257{
5258}
5259impl flutter_rust_bridge::IntoIntoDart<crate::model::BuyBitcoinProvider>
5260    for crate::model::BuyBitcoinProvider
5261{
5262    fn into_into_dart(self) -> crate::model::BuyBitcoinProvider {
5263        self
5264    }
5265}
5266// Codec=Dco (DartCObject based), see doc to use other codecs
5267impl flutter_rust_bridge::IntoDart for crate::model::BuyBitcoinRequest {
5268    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5269        [
5270            self.prepare_response.into_into_dart().into_dart(),
5271            self.redirect_url.into_into_dart().into_dart(),
5272        ]
5273        .into_dart()
5274    }
5275}
5276impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5277    for crate::model::BuyBitcoinRequest
5278{
5279}
5280impl flutter_rust_bridge::IntoIntoDart<crate::model::BuyBitcoinRequest>
5281    for crate::model::BuyBitcoinRequest
5282{
5283    fn into_into_dart(self) -> crate::model::BuyBitcoinRequest {
5284        self
5285    }
5286}
5287// Codec=Dco (DartCObject based), see doc to use other codecs
5288impl flutter_rust_bridge::IntoDart for crate::model::CheckMessageRequest {
5289    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5290        [
5291            self.message.into_into_dart().into_dart(),
5292            self.pubkey.into_into_dart().into_dart(),
5293            self.signature.into_into_dart().into_dart(),
5294        ]
5295        .into_dart()
5296    }
5297}
5298impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5299    for crate::model::CheckMessageRequest
5300{
5301}
5302impl flutter_rust_bridge::IntoIntoDart<crate::model::CheckMessageRequest>
5303    for crate::model::CheckMessageRequest
5304{
5305    fn into_into_dart(self) -> crate::model::CheckMessageRequest {
5306        self
5307    }
5308}
5309// Codec=Dco (DartCObject based), see doc to use other codecs
5310impl flutter_rust_bridge::IntoDart for crate::model::CheckMessageResponse {
5311    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5312        [self.is_valid.into_into_dart().into_dart()].into_dart()
5313    }
5314}
5315impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5316    for crate::model::CheckMessageResponse
5317{
5318}
5319impl flutter_rust_bridge::IntoIntoDart<crate::model::CheckMessageResponse>
5320    for crate::model::CheckMessageResponse
5321{
5322    fn into_into_dart(self) -> crate::model::CheckMessageResponse {
5323        self
5324    }
5325}
5326// Codec=Dco (DartCObject based), see doc to use other codecs
5327impl flutter_rust_bridge::IntoDart for crate::model::Config {
5328    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5329        [
5330            self.liquid_explorer.into_into_dart().into_dart(),
5331            self.bitcoin_explorer.into_into_dart().into_dart(),
5332            self.working_dir.into_into_dart().into_dart(),
5333            self.network.into_into_dart().into_dart(),
5334            self.payment_timeout_sec.into_into_dart().into_dart(),
5335            self.sync_service_url.into_into_dart().into_dart(),
5336            self.zero_conf_max_amount_sat.into_into_dart().into_dart(),
5337            self.breez_api_key.into_into_dart().into_dart(),
5338            self.external_input_parsers.into_into_dart().into_dart(),
5339            self.use_default_external_input_parsers
5340                .into_into_dart()
5341                .into_dart(),
5342            self.onchain_fee_rate_leeway_sat
5343                .into_into_dart()
5344                .into_dart(),
5345            self.asset_metadata.into_into_dart().into_dart(),
5346            self.sideswap_api_key.into_into_dart().into_dart(),
5347        ]
5348        .into_dart()
5349    }
5350}
5351impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::Config {}
5352impl flutter_rust_bridge::IntoIntoDart<crate::model::Config> for crate::model::Config {
5353    fn into_into_dart(self) -> crate::model::Config {
5354        self
5355    }
5356}
5357// Codec=Dco (DartCObject based), see doc to use other codecs
5358impl flutter_rust_bridge::IntoDart for crate::model::ConnectRequest {
5359    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5360        [
5361            self.config.into_into_dart().into_dart(),
5362            self.mnemonic.into_into_dart().into_dart(),
5363            self.passphrase.into_into_dart().into_dart(),
5364            self.seed.into_into_dart().into_dart(),
5365        ]
5366        .into_dart()
5367    }
5368}
5369impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::ConnectRequest {}
5370impl flutter_rust_bridge::IntoIntoDart<crate::model::ConnectRequest>
5371    for crate::model::ConnectRequest
5372{
5373    fn into_into_dart(self) -> crate::model::ConnectRequest {
5374        self
5375    }
5376}
5377// Codec=Dco (DartCObject based), see doc to use other codecs
5378impl flutter_rust_bridge::IntoDart for crate::model::CreateBolt12InvoiceRequest {
5379    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5380        [
5381            self.offer.into_into_dart().into_dart(),
5382            self.invoice_request.into_into_dart().into_dart(),
5383        ]
5384        .into_dart()
5385    }
5386}
5387impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5388    for crate::model::CreateBolt12InvoiceRequest
5389{
5390}
5391impl flutter_rust_bridge::IntoIntoDart<crate::model::CreateBolt12InvoiceRequest>
5392    for crate::model::CreateBolt12InvoiceRequest
5393{
5394    fn into_into_dart(self) -> crate::model::CreateBolt12InvoiceRequest {
5395        self
5396    }
5397}
5398// Codec=Dco (DartCObject based), see doc to use other codecs
5399impl flutter_rust_bridge::IntoDart for crate::model::CreateBolt12InvoiceResponse {
5400    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5401        [self.invoice.into_into_dart().into_dart()].into_dart()
5402    }
5403}
5404impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5405    for crate::model::CreateBolt12InvoiceResponse
5406{
5407}
5408impl flutter_rust_bridge::IntoIntoDart<crate::model::CreateBolt12InvoiceResponse>
5409    for crate::model::CreateBolt12InvoiceResponse
5410{
5411    fn into_into_dart(self) -> crate::model::CreateBolt12InvoiceResponse {
5412        self
5413    }
5414}
5415// Codec=Dco (DartCObject based), see doc to use other codecs
5416impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::CurrencyInfo> {
5417    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5418        [
5419            self.0.name.into_into_dart().into_dart(),
5420            self.0.fraction_size.into_into_dart().into_dart(),
5421            self.0.spacing.into_into_dart().into_dart(),
5422            self.0.symbol.into_into_dart().into_dart(),
5423            self.0.uniq_symbol.into_into_dart().into_dart(),
5424            self.0.localized_name.into_into_dart().into_dart(),
5425            self.0.locale_overrides.into_into_dart().into_dart(),
5426        ]
5427        .into_dart()
5428    }
5429}
5430impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5431    for FrbWrapper<crate::bindings::CurrencyInfo>
5432{
5433}
5434impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::CurrencyInfo>>
5435    for crate::bindings::CurrencyInfo
5436{
5437    fn into_into_dart(self) -> FrbWrapper<crate::bindings::CurrencyInfo> {
5438        self.into()
5439    }
5440}
5441// Codec=Dco (DartCObject based), see doc to use other codecs
5442impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::ExternalInputParser> {
5443    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5444        [
5445            self.0.provider_id.into_into_dart().into_dart(),
5446            self.0.input_regex.into_into_dart().into_dart(),
5447            self.0.parser_url.into_into_dart().into_dart(),
5448        ]
5449        .into_dart()
5450    }
5451}
5452impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5453    for FrbWrapper<crate::bindings::ExternalInputParser>
5454{
5455}
5456impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::ExternalInputParser>>
5457    for crate::bindings::ExternalInputParser
5458{
5459    fn into_into_dart(self) -> FrbWrapper<crate::bindings::ExternalInputParser> {
5460        self.into()
5461    }
5462}
5463// Codec=Dco (DartCObject based), see doc to use other codecs
5464impl flutter_rust_bridge::IntoDart for crate::model::FetchPaymentProposedFeesRequest {
5465    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5466        [self.swap_id.into_into_dart().into_dart()].into_dart()
5467    }
5468}
5469impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5470    for crate::model::FetchPaymentProposedFeesRequest
5471{
5472}
5473impl flutter_rust_bridge::IntoIntoDart<crate::model::FetchPaymentProposedFeesRequest>
5474    for crate::model::FetchPaymentProposedFeesRequest
5475{
5476    fn into_into_dart(self) -> crate::model::FetchPaymentProposedFeesRequest {
5477        self
5478    }
5479}
5480// Codec=Dco (DartCObject based), see doc to use other codecs
5481impl flutter_rust_bridge::IntoDart for crate::model::FetchPaymentProposedFeesResponse {
5482    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5483        [
5484            self.swap_id.into_into_dart().into_dart(),
5485            self.fees_sat.into_into_dart().into_dart(),
5486            self.payer_amount_sat.into_into_dart().into_dart(),
5487            self.receiver_amount_sat.into_into_dart().into_dart(),
5488        ]
5489        .into_dart()
5490    }
5491}
5492impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5493    for crate::model::FetchPaymentProposedFeesResponse
5494{
5495}
5496impl flutter_rust_bridge::IntoIntoDart<crate::model::FetchPaymentProposedFeesResponse>
5497    for crate::model::FetchPaymentProposedFeesResponse
5498{
5499    fn into_into_dart(self) -> crate::model::FetchPaymentProposedFeesResponse {
5500        self
5501    }
5502}
5503// Codec=Dco (DartCObject based), see doc to use other codecs
5504impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::FiatCurrency> {
5505    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5506        [
5507            self.0.id.into_into_dart().into_dart(),
5508            self.0.info.into_into_dart().into_dart(),
5509        ]
5510        .into_dart()
5511    }
5512}
5513impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5514    for FrbWrapper<crate::bindings::FiatCurrency>
5515{
5516}
5517impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::FiatCurrency>>
5518    for crate::bindings::FiatCurrency
5519{
5520    fn into_into_dart(self) -> FrbWrapper<crate::bindings::FiatCurrency> {
5521        self.into()
5522    }
5523}
5524// Codec=Dco (DartCObject based), see doc to use other codecs
5525impl flutter_rust_bridge::IntoDart for crate::model::GetInfoResponse {
5526    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5527        [
5528            self.wallet_info.into_into_dart().into_dart(),
5529            self.blockchain_info.into_into_dart().into_dart(),
5530        ]
5531        .into_dart()
5532    }
5533}
5534impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::GetInfoResponse {}
5535impl flutter_rust_bridge::IntoIntoDart<crate::model::GetInfoResponse>
5536    for crate::model::GetInfoResponse
5537{
5538    fn into_into_dart(self) -> crate::model::GetInfoResponse {
5539        self
5540    }
5541}
5542// Codec=Dco (DartCObject based), see doc to use other codecs
5543impl flutter_rust_bridge::IntoDart for crate::model::GetPaymentRequest {
5544    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5545        match self {
5546            crate::model::GetPaymentRequest::PaymentHash { payment_hash } => {
5547                [0.into_dart(), payment_hash.into_into_dart().into_dart()].into_dart()
5548            }
5549            crate::model::GetPaymentRequest::SwapId { swap_id } => {
5550                [1.into_dart(), swap_id.into_into_dart().into_dart()].into_dart()
5551            }
5552            _ => {
5553                unimplemented!("");
5554            }
5555        }
5556    }
5557}
5558impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5559    for crate::model::GetPaymentRequest
5560{
5561}
5562impl flutter_rust_bridge::IntoIntoDart<crate::model::GetPaymentRequest>
5563    for crate::model::GetPaymentRequest
5564{
5565    fn into_into_dart(self) -> crate::model::GetPaymentRequest {
5566        self
5567    }
5568}
5569// Codec=Dco (DartCObject based), see doc to use other codecs
5570impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::InputType> {
5571    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5572        match self.0 {
5573            crate::bindings::InputType::BitcoinAddress { address } => {
5574                [0.into_dart(), address.into_into_dart().into_dart()].into_dart()
5575            }
5576            crate::bindings::InputType::LiquidAddress { address } => {
5577                [1.into_dart(), address.into_into_dart().into_dart()].into_dart()
5578            }
5579            crate::bindings::InputType::Bolt11 { invoice } => {
5580                [2.into_dart(), invoice.into_into_dart().into_dart()].into_dart()
5581            }
5582            crate::bindings::InputType::Bolt12Offer {
5583                offer,
5584                bip353_address,
5585            } => [
5586                3.into_dart(),
5587                offer.into_into_dart().into_dart(),
5588                bip353_address.into_into_dart().into_dart(),
5589            ]
5590            .into_dart(),
5591            crate::bindings::InputType::NodeId { node_id } => {
5592                [4.into_dart(), node_id.into_into_dart().into_dart()].into_dart()
5593            }
5594            crate::bindings::InputType::Url { url } => {
5595                [5.into_dart(), url.into_into_dart().into_dart()].into_dart()
5596            }
5597            crate::bindings::InputType::LnUrlPay {
5598                data,
5599                bip353_address,
5600            } => [
5601                6.into_dart(),
5602                data.into_into_dart().into_dart(),
5603                bip353_address.into_into_dart().into_dart(),
5604            ]
5605            .into_dart(),
5606            crate::bindings::InputType::LnUrlWithdraw { data } => {
5607                [7.into_dart(), data.into_into_dart().into_dart()].into_dart()
5608            }
5609            crate::bindings::InputType::LnUrlAuth { data } => {
5610                [8.into_dart(), data.into_into_dart().into_dart()].into_dart()
5611            }
5612            crate::bindings::InputType::LnUrlError { data } => {
5613                [9.into_dart(), data.into_into_dart().into_dart()].into_dart()
5614            }
5615            _ => {
5616                unimplemented!("");
5617            }
5618        }
5619    }
5620}
5621impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5622    for FrbWrapper<crate::bindings::InputType>
5623{
5624}
5625impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::InputType>>
5626    for crate::bindings::InputType
5627{
5628    fn into_into_dart(self) -> FrbWrapper<crate::bindings::InputType> {
5629        self.into()
5630    }
5631}
5632// Codec=Dco (DartCObject based), see doc to use other codecs
5633impl flutter_rust_bridge::IntoDart for crate::model::LightningPaymentLimitsResponse {
5634    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5635        [
5636            self.send.into_into_dart().into_dart(),
5637            self.receive.into_into_dart().into_dart(),
5638        ]
5639        .into_dart()
5640    }
5641}
5642impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5643    for crate::model::LightningPaymentLimitsResponse
5644{
5645}
5646impl flutter_rust_bridge::IntoIntoDart<crate::model::LightningPaymentLimitsResponse>
5647    for crate::model::LightningPaymentLimitsResponse
5648{
5649    fn into_into_dart(self) -> crate::model::LightningPaymentLimitsResponse {
5650        self
5651    }
5652}
5653// Codec=Dco (DartCObject based), see doc to use other codecs
5654impl flutter_rust_bridge::IntoDart for crate::model::Limits {
5655    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5656        [
5657            self.min_sat.into_into_dart().into_dart(),
5658            self.max_sat.into_into_dart().into_dart(),
5659            self.max_zero_conf_sat.into_into_dart().into_dart(),
5660        ]
5661        .into_dart()
5662    }
5663}
5664impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::Limits {}
5665impl flutter_rust_bridge::IntoIntoDart<crate::model::Limits> for crate::model::Limits {
5666    fn into_into_dart(self) -> crate::model::Limits {
5667        self
5668    }
5669}
5670// Codec=Dco (DartCObject based), see doc to use other codecs
5671impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LiquidAddressData> {
5672    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5673        [
5674            self.0.address.into_into_dart().into_dart(),
5675            self.0.network.into_into_dart().into_dart(),
5676            self.0.asset_id.into_into_dart().into_dart(),
5677            self.0.amount.into_into_dart().into_dart(),
5678            self.0.amount_sat.into_into_dart().into_dart(),
5679            self.0.label.into_into_dart().into_dart(),
5680            self.0.message.into_into_dart().into_dart(),
5681        ]
5682        .into_dart()
5683    }
5684}
5685impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5686    for FrbWrapper<crate::bindings::LiquidAddressData>
5687{
5688}
5689impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LiquidAddressData>>
5690    for crate::bindings::LiquidAddressData
5691{
5692    fn into_into_dart(self) -> FrbWrapper<crate::bindings::LiquidAddressData> {
5693        self.into()
5694    }
5695}
5696// Codec=Dco (DartCObject based), see doc to use other codecs
5697impl flutter_rust_bridge::IntoDart for crate::model::LiquidNetwork {
5698    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5699        match self {
5700            Self::Mainnet => 0.into_dart(),
5701            Self::Testnet => 1.into_dart(),
5702            Self::Regtest => 2.into_dart(),
5703            _ => unreachable!(),
5704        }
5705    }
5706}
5707impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::LiquidNetwork {}
5708impl flutter_rust_bridge::IntoIntoDart<crate::model::LiquidNetwork>
5709    for crate::model::LiquidNetwork
5710{
5711    fn into_into_dart(self) -> crate::model::LiquidNetwork {
5712        self
5713    }
5714}
5715// Codec=Dco (DartCObject based), see doc to use other codecs
5716impl flutter_rust_bridge::IntoDart for crate::model::ListPaymentDetails {
5717    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5718        match self {
5719            crate::model::ListPaymentDetails::Liquid {
5720                asset_id,
5721                destination,
5722            } => [
5723                0.into_dart(),
5724                asset_id.into_into_dart().into_dart(),
5725                destination.into_into_dart().into_dart(),
5726            ]
5727            .into_dart(),
5728            crate::model::ListPaymentDetails::Bitcoin { address } => {
5729                [1.into_dart(), address.into_into_dart().into_dart()].into_dart()
5730            }
5731            _ => {
5732                unimplemented!("");
5733            }
5734        }
5735    }
5736}
5737impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5738    for crate::model::ListPaymentDetails
5739{
5740}
5741impl flutter_rust_bridge::IntoIntoDart<crate::model::ListPaymentDetails>
5742    for crate::model::ListPaymentDetails
5743{
5744    fn into_into_dart(self) -> crate::model::ListPaymentDetails {
5745        self
5746    }
5747}
5748// Codec=Dco (DartCObject based), see doc to use other codecs
5749impl flutter_rust_bridge::IntoDart for crate::model::ListPaymentsRequest {
5750    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5751        [
5752            self.filters.into_into_dart().into_dart(),
5753            self.states.into_into_dart().into_dart(),
5754            self.from_timestamp.into_into_dart().into_dart(),
5755            self.to_timestamp.into_into_dart().into_dart(),
5756            self.offset.into_into_dart().into_dart(),
5757            self.limit.into_into_dart().into_dart(),
5758            self.details.into_into_dart().into_dart(),
5759            self.sort_ascending.into_into_dart().into_dart(),
5760        ]
5761        .into_dart()
5762    }
5763}
5764impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5765    for crate::model::ListPaymentsRequest
5766{
5767}
5768impl flutter_rust_bridge::IntoIntoDart<crate::model::ListPaymentsRequest>
5769    for crate::model::ListPaymentsRequest
5770{
5771    fn into_into_dart(self) -> crate::model::ListPaymentsRequest {
5772        self
5773    }
5774}
5775// Codec=Dco (DartCObject based), see doc to use other codecs
5776impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LNInvoice> {
5777    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5778        [
5779            self.0.bolt11.into_into_dart().into_dart(),
5780            self.0.network.into_into_dart().into_dart(),
5781            self.0.payee_pubkey.into_into_dart().into_dart(),
5782            self.0.payment_hash.into_into_dart().into_dart(),
5783            self.0.description.into_into_dart().into_dart(),
5784            self.0.description_hash.into_into_dart().into_dart(),
5785            self.0.amount_msat.into_into_dart().into_dart(),
5786            self.0.timestamp.into_into_dart().into_dart(),
5787            self.0.expiry.into_into_dart().into_dart(),
5788            self.0.routing_hints.into_into_dart().into_dart(),
5789            self.0.payment_secret.into_into_dart().into_dart(),
5790            self.0
5791                .min_final_cltv_expiry_delta
5792                .into_into_dart()
5793                .into_dart(),
5794        ]
5795        .into_dart()
5796    }
5797}
5798impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5799    for FrbWrapper<crate::bindings::LNInvoice>
5800{
5801}
5802impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LNInvoice>>
5803    for crate::bindings::LNInvoice
5804{
5805    fn into_into_dart(self) -> FrbWrapper<crate::bindings::LNInvoice> {
5806        self.into()
5807    }
5808}
5809// Codec=Dco (DartCObject based), see doc to use other codecs
5810impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LNOffer> {
5811    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5812        [
5813            self.0.offer.into_into_dart().into_dart(),
5814            self.0.chains.into_into_dart().into_dart(),
5815            self.0.min_amount.into_into_dart().into_dart(),
5816            self.0.description.into_into_dart().into_dart(),
5817            self.0.absolute_expiry.into_into_dart().into_dart(),
5818            self.0.issuer.into_into_dart().into_dart(),
5819            self.0.signing_pubkey.into_into_dart().into_dart(),
5820            self.0.paths.into_into_dart().into_dart(),
5821        ]
5822        .into_dart()
5823    }
5824}
5825impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5826    for FrbWrapper<crate::bindings::LNOffer>
5827{
5828}
5829impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LNOffer>>
5830    for crate::bindings::LNOffer
5831{
5832    fn into_into_dart(self) -> FrbWrapper<crate::bindings::LNOffer> {
5833        self.into()
5834    }
5835}
5836// Codec=Dco (DartCObject based), see doc to use other codecs
5837impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LnOfferBlindedPath> {
5838    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5839        [self.0.blinded_hops.into_into_dart().into_dart()].into_dart()
5840    }
5841}
5842impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5843    for FrbWrapper<crate::bindings::LnOfferBlindedPath>
5844{
5845}
5846impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LnOfferBlindedPath>>
5847    for crate::bindings::LnOfferBlindedPath
5848{
5849    fn into_into_dart(self) -> FrbWrapper<crate::bindings::LnOfferBlindedPath> {
5850        self.into()
5851    }
5852}
5853// Codec=Dco (DartCObject based), see doc to use other codecs
5854impl flutter_rust_bridge::IntoDart for crate::bindings::duplicates::LnUrlAuthError {
5855    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5856        match self {
5857            crate::bindings::duplicates::LnUrlAuthError::Generic { err } => {
5858                [0.into_dart(), err.into_into_dart().into_dart()].into_dart()
5859            }
5860            crate::bindings::duplicates::LnUrlAuthError::InvalidUri { err } => {
5861                [1.into_dart(), err.into_into_dart().into_dart()].into_dart()
5862            }
5863            crate::bindings::duplicates::LnUrlAuthError::ServiceConnectivity { err } => {
5864                [2.into_dart(), err.into_into_dart().into_dart()].into_dart()
5865            }
5866            _ => {
5867                unimplemented!("");
5868            }
5869        }
5870    }
5871}
5872impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5873    for crate::bindings::duplicates::LnUrlAuthError
5874{
5875}
5876impl flutter_rust_bridge::IntoIntoDart<crate::bindings::duplicates::LnUrlAuthError>
5877    for crate::bindings::duplicates::LnUrlAuthError
5878{
5879    fn into_into_dart(self) -> crate::bindings::duplicates::LnUrlAuthError {
5880        self
5881    }
5882}
5883// Codec=Dco (DartCObject based), see doc to use other codecs
5884impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LnUrlAuthRequestData> {
5885    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5886        [
5887            self.0.k1.into_into_dart().into_dart(),
5888            self.0.action.into_into_dart().into_dart(),
5889            self.0.domain.into_into_dart().into_dart(),
5890            self.0.url.into_into_dart().into_dart(),
5891        ]
5892        .into_dart()
5893    }
5894}
5895impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5896    for FrbWrapper<crate::bindings::LnUrlAuthRequestData>
5897{
5898}
5899impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LnUrlAuthRequestData>>
5900    for crate::bindings::LnUrlAuthRequestData
5901{
5902    fn into_into_dart(self) -> FrbWrapper<crate::bindings::LnUrlAuthRequestData> {
5903        self.into()
5904    }
5905}
5906// Codec=Dco (DartCObject based), see doc to use other codecs
5907impl flutter_rust_bridge::IntoDart for crate::bindings::duplicates::LnUrlCallbackStatus {
5908    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5909        match self {
5910            crate::bindings::duplicates::LnUrlCallbackStatus::Ok => [0.into_dart()].into_dart(),
5911            crate::bindings::duplicates::LnUrlCallbackStatus::ErrorStatus { data } => {
5912                [1.into_dart(), data.into_into_dart().into_dart()].into_dart()
5913            }
5914            _ => {
5915                unimplemented!("");
5916            }
5917        }
5918    }
5919}
5920impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5921    for crate::bindings::duplicates::LnUrlCallbackStatus
5922{
5923}
5924impl flutter_rust_bridge::IntoIntoDart<crate::bindings::duplicates::LnUrlCallbackStatus>
5925    for crate::bindings::duplicates::LnUrlCallbackStatus
5926{
5927    fn into_into_dart(self) -> crate::bindings::duplicates::LnUrlCallbackStatus {
5928        self
5929    }
5930}
5931// Codec=Dco (DartCObject based), see doc to use other codecs
5932impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LnUrlErrorData> {
5933    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5934        [self.0.reason.into_into_dart().into_dart()].into_dart()
5935    }
5936}
5937impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5938    for FrbWrapper<crate::bindings::LnUrlErrorData>
5939{
5940}
5941impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LnUrlErrorData>>
5942    for crate::bindings::LnUrlErrorData
5943{
5944    fn into_into_dart(self) -> FrbWrapper<crate::bindings::LnUrlErrorData> {
5945        self.into()
5946    }
5947}
5948// Codec=Dco (DartCObject based), see doc to use other codecs
5949impl flutter_rust_bridge::IntoDart for crate::model::LnUrlInfo {
5950    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5951        [
5952            self.ln_address.into_into_dart().into_dart(),
5953            self.lnurl_pay_comment.into_into_dart().into_dart(),
5954            self.lnurl_pay_domain.into_into_dart().into_dart(),
5955            self.lnurl_pay_metadata.into_into_dart().into_dart(),
5956            self.lnurl_pay_success_action.into_into_dart().into_dart(),
5957            self.lnurl_pay_unprocessed_success_action
5958                .into_into_dart()
5959                .into_dart(),
5960            self.lnurl_withdraw_endpoint.into_into_dart().into_dart(),
5961        ]
5962        .into_dart()
5963    }
5964}
5965impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::LnUrlInfo {}
5966impl flutter_rust_bridge::IntoIntoDart<crate::model::LnUrlInfo> for crate::model::LnUrlInfo {
5967    fn into_into_dart(self) -> crate::model::LnUrlInfo {
5968        self
5969    }
5970}
5971// Codec=Dco (DartCObject based), see doc to use other codecs
5972impl flutter_rust_bridge::IntoDart for crate::bindings::duplicates::LnUrlPayError {
5973    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5974        match self {
5975            crate::bindings::duplicates::LnUrlPayError::AlreadyPaid => [0.into_dart()].into_dart(),
5976            crate::bindings::duplicates::LnUrlPayError::Generic { err } => {
5977                [1.into_dart(), err.into_into_dart().into_dart()].into_dart()
5978            }
5979            crate::bindings::duplicates::LnUrlPayError::InsufficientBalance { err } => {
5980                [2.into_dart(), err.into_into_dart().into_dart()].into_dart()
5981            }
5982            crate::bindings::duplicates::LnUrlPayError::InvalidAmount { err } => {
5983                [3.into_dart(), err.into_into_dart().into_dart()].into_dart()
5984            }
5985            crate::bindings::duplicates::LnUrlPayError::InvalidInvoice { err } => {
5986                [4.into_dart(), err.into_into_dart().into_dart()].into_dart()
5987            }
5988            crate::bindings::duplicates::LnUrlPayError::InvalidNetwork { err } => {
5989                [5.into_dart(), err.into_into_dart().into_dart()].into_dart()
5990            }
5991            crate::bindings::duplicates::LnUrlPayError::InvalidUri { err } => {
5992                [6.into_dart(), err.into_into_dart().into_dart()].into_dart()
5993            }
5994            crate::bindings::duplicates::LnUrlPayError::InvoiceExpired { err } => {
5995                [7.into_dart(), err.into_into_dart().into_dart()].into_dart()
5996            }
5997            crate::bindings::duplicates::LnUrlPayError::PaymentFailed { err } => {
5998                [8.into_dart(), err.into_into_dart().into_dart()].into_dart()
5999            }
6000            crate::bindings::duplicates::LnUrlPayError::PaymentTimeout { err } => {
6001                [9.into_dart(), err.into_into_dart().into_dart()].into_dart()
6002            }
6003            crate::bindings::duplicates::LnUrlPayError::RouteNotFound { err } => {
6004                [10.into_dart(), err.into_into_dart().into_dart()].into_dart()
6005            }
6006            crate::bindings::duplicates::LnUrlPayError::RouteTooExpensive { err } => {
6007                [11.into_dart(), err.into_into_dart().into_dart()].into_dart()
6008            }
6009            crate::bindings::duplicates::LnUrlPayError::ServiceConnectivity { err } => {
6010                [12.into_dart(), err.into_into_dart().into_dart()].into_dart()
6011            }
6012            _ => {
6013                unimplemented!("");
6014            }
6015        }
6016    }
6017}
6018impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6019    for crate::bindings::duplicates::LnUrlPayError
6020{
6021}
6022impl flutter_rust_bridge::IntoIntoDart<crate::bindings::duplicates::LnUrlPayError>
6023    for crate::bindings::duplicates::LnUrlPayError
6024{
6025    fn into_into_dart(self) -> crate::bindings::duplicates::LnUrlPayError {
6026        self
6027    }
6028}
6029// Codec=Dco (DartCObject based), see doc to use other codecs
6030impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LnUrlPayErrorData> {
6031    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6032        [
6033            self.0.payment_hash.into_into_dart().into_dart(),
6034            self.0.reason.into_into_dart().into_dart(),
6035        ]
6036        .into_dart()
6037    }
6038}
6039impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6040    for FrbWrapper<crate::bindings::LnUrlPayErrorData>
6041{
6042}
6043impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LnUrlPayErrorData>>
6044    for crate::bindings::LnUrlPayErrorData
6045{
6046    fn into_into_dart(self) -> FrbWrapper<crate::bindings::LnUrlPayErrorData> {
6047        self.into()
6048    }
6049}
6050// Codec=Dco (DartCObject based), see doc to use other codecs
6051impl flutter_rust_bridge::IntoDart for crate::model::LnUrlPayRequest {
6052    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6053        [self.prepare_response.into_into_dart().into_dart()].into_dart()
6054    }
6055}
6056impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::LnUrlPayRequest {}
6057impl flutter_rust_bridge::IntoIntoDart<crate::model::LnUrlPayRequest>
6058    for crate::model::LnUrlPayRequest
6059{
6060    fn into_into_dart(self) -> crate::model::LnUrlPayRequest {
6061        self
6062    }
6063}
6064// Codec=Dco (DartCObject based), see doc to use other codecs
6065impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LnUrlPayRequestData> {
6066    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6067        [
6068            self.0.callback.into_into_dart().into_dart(),
6069            self.0.min_sendable.into_into_dart().into_dart(),
6070            self.0.max_sendable.into_into_dart().into_dart(),
6071            self.0.metadata_str.into_into_dart().into_dart(),
6072            self.0.comment_allowed.into_into_dart().into_dart(),
6073            self.0.domain.into_into_dart().into_dart(),
6074            self.0.allows_nostr.into_into_dart().into_dart(),
6075            self.0.nostr_pubkey.into_into_dart().into_dart(),
6076            self.0.ln_address.into_into_dart().into_dart(),
6077        ]
6078        .into_dart()
6079    }
6080}
6081impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6082    for FrbWrapper<crate::bindings::LnUrlPayRequestData>
6083{
6084}
6085impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LnUrlPayRequestData>>
6086    for crate::bindings::LnUrlPayRequestData
6087{
6088    fn into_into_dart(self) -> FrbWrapper<crate::bindings::LnUrlPayRequestData> {
6089        self.into()
6090    }
6091}
6092// Codec=Dco (DartCObject based), see doc to use other codecs
6093impl flutter_rust_bridge::IntoDart for crate::model::LnUrlPayResult {
6094    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6095        match self {
6096            crate::model::LnUrlPayResult::EndpointSuccess { data } => {
6097                [0.into_dart(), data.into_into_dart().into_dart()].into_dart()
6098            }
6099            crate::model::LnUrlPayResult::EndpointError { data } => {
6100                [1.into_dart(), data.into_into_dart().into_dart()].into_dart()
6101            }
6102            crate::model::LnUrlPayResult::PayError { data } => {
6103                [2.into_dart(), data.into_into_dart().into_dart()].into_dart()
6104            }
6105            _ => {
6106                unimplemented!("");
6107            }
6108        }
6109    }
6110}
6111impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::LnUrlPayResult {}
6112impl flutter_rust_bridge::IntoIntoDart<crate::model::LnUrlPayResult>
6113    for crate::model::LnUrlPayResult
6114{
6115    fn into_into_dart(self) -> crate::model::LnUrlPayResult {
6116        self
6117    }
6118}
6119// Codec=Dco (DartCObject based), see doc to use other codecs
6120impl flutter_rust_bridge::IntoDart for crate::model::LnUrlPaySuccessData {
6121    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6122        [
6123            self.payment.into_into_dart().into_dart(),
6124            self.success_action.into_into_dart().into_dart(),
6125        ]
6126        .into_dart()
6127    }
6128}
6129impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6130    for crate::model::LnUrlPaySuccessData
6131{
6132}
6133impl flutter_rust_bridge::IntoIntoDart<crate::model::LnUrlPaySuccessData>
6134    for crate::model::LnUrlPaySuccessData
6135{
6136    fn into_into_dart(self) -> crate::model::LnUrlPaySuccessData {
6137        self
6138    }
6139}
6140// Codec=Dco (DartCObject based), see doc to use other codecs
6141impl flutter_rust_bridge::IntoDart for crate::bindings::duplicates::LnUrlWithdrawError {
6142    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6143        match self {
6144            crate::bindings::duplicates::LnUrlWithdrawError::Generic { err } => {
6145                [0.into_dart(), err.into_into_dart().into_dart()].into_dart()
6146            }
6147            crate::bindings::duplicates::LnUrlWithdrawError::InvalidAmount { err } => {
6148                [1.into_dart(), err.into_into_dart().into_dart()].into_dart()
6149            }
6150            crate::bindings::duplicates::LnUrlWithdrawError::InvalidInvoice { err } => {
6151                [2.into_dart(), err.into_into_dart().into_dart()].into_dart()
6152            }
6153            crate::bindings::duplicates::LnUrlWithdrawError::InvalidUri { err } => {
6154                [3.into_dart(), err.into_into_dart().into_dart()].into_dart()
6155            }
6156            crate::bindings::duplicates::LnUrlWithdrawError::InvoiceNoRoutingHints { err } => {
6157                [4.into_dart(), err.into_into_dart().into_dart()].into_dart()
6158            }
6159            crate::bindings::duplicates::LnUrlWithdrawError::ServiceConnectivity { err } => {
6160                [5.into_dart(), err.into_into_dart().into_dart()].into_dart()
6161            }
6162            _ => {
6163                unimplemented!("");
6164            }
6165        }
6166    }
6167}
6168impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6169    for crate::bindings::duplicates::LnUrlWithdrawError
6170{
6171}
6172impl flutter_rust_bridge::IntoIntoDart<crate::bindings::duplicates::LnUrlWithdrawError>
6173    for crate::bindings::duplicates::LnUrlWithdrawError
6174{
6175    fn into_into_dart(self) -> crate::bindings::duplicates::LnUrlWithdrawError {
6176        self
6177    }
6178}
6179// Codec=Dco (DartCObject based), see doc to use other codecs
6180impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LnUrlWithdrawRequest> {
6181    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6182        [
6183            self.0.data.into_into_dart().into_dart(),
6184            self.0.amount_msat.into_into_dart().into_dart(),
6185            self.0.description.into_into_dart().into_dart(),
6186        ]
6187        .into_dart()
6188    }
6189}
6190impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6191    for FrbWrapper<crate::bindings::LnUrlWithdrawRequest>
6192{
6193}
6194impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LnUrlWithdrawRequest>>
6195    for crate::bindings::LnUrlWithdrawRequest
6196{
6197    fn into_into_dart(self) -> FrbWrapper<crate::bindings::LnUrlWithdrawRequest> {
6198        self.into()
6199    }
6200}
6201// Codec=Dco (DartCObject based), see doc to use other codecs
6202impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LnUrlWithdrawRequestData> {
6203    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6204        [
6205            self.0.callback.into_into_dart().into_dart(),
6206            self.0.k1.into_into_dart().into_dart(),
6207            self.0.default_description.into_into_dart().into_dart(),
6208            self.0.min_withdrawable.into_into_dart().into_dart(),
6209            self.0.max_withdrawable.into_into_dart().into_dart(),
6210        ]
6211        .into_dart()
6212    }
6213}
6214impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6215    for FrbWrapper<crate::bindings::LnUrlWithdrawRequestData>
6216{
6217}
6218impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LnUrlWithdrawRequestData>>
6219    for crate::bindings::LnUrlWithdrawRequestData
6220{
6221    fn into_into_dart(self) -> FrbWrapper<crate::bindings::LnUrlWithdrawRequestData> {
6222        self.into()
6223    }
6224}
6225// Codec=Dco (DartCObject based), see doc to use other codecs
6226impl flutter_rust_bridge::IntoDart for crate::bindings::duplicates::LnUrlWithdrawResult {
6227    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6228        match self {
6229            crate::bindings::duplicates::LnUrlWithdrawResult::Ok { data } => {
6230                [0.into_dart(), data.into_into_dart().into_dart()].into_dart()
6231            }
6232            crate::bindings::duplicates::LnUrlWithdrawResult::Timeout { data } => {
6233                [1.into_dart(), data.into_into_dart().into_dart()].into_dart()
6234            }
6235            crate::bindings::duplicates::LnUrlWithdrawResult::ErrorStatus { data } => {
6236                [2.into_dart(), data.into_into_dart().into_dart()].into_dart()
6237            }
6238            _ => {
6239                unimplemented!("");
6240            }
6241        }
6242    }
6243}
6244impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6245    for crate::bindings::duplicates::LnUrlWithdrawResult
6246{
6247}
6248impl flutter_rust_bridge::IntoIntoDart<crate::bindings::duplicates::LnUrlWithdrawResult>
6249    for crate::bindings::duplicates::LnUrlWithdrawResult
6250{
6251    fn into_into_dart(self) -> crate::bindings::duplicates::LnUrlWithdrawResult {
6252        self
6253    }
6254}
6255// Codec=Dco (DartCObject based), see doc to use other codecs
6256impl flutter_rust_bridge::IntoDart for crate::bindings::duplicates::LnUrlWithdrawSuccessData {
6257    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6258        [self.invoice.into_into_dart().into_dart()].into_dart()
6259    }
6260}
6261impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6262    for crate::bindings::duplicates::LnUrlWithdrawSuccessData
6263{
6264}
6265impl flutter_rust_bridge::IntoIntoDart<crate::bindings::duplicates::LnUrlWithdrawSuccessData>
6266    for crate::bindings::duplicates::LnUrlWithdrawSuccessData
6267{
6268    fn into_into_dart(self) -> crate::bindings::duplicates::LnUrlWithdrawSuccessData {
6269        self
6270    }
6271}
6272// Codec=Dco (DartCObject based), see doc to use other codecs
6273impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LocaleOverrides> {
6274    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6275        [
6276            self.0.locale.into_into_dart().into_dart(),
6277            self.0.spacing.into_into_dart().into_dart(),
6278            self.0.symbol.into_into_dart().into_dart(),
6279        ]
6280        .into_dart()
6281    }
6282}
6283impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6284    for FrbWrapper<crate::bindings::LocaleOverrides>
6285{
6286}
6287impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LocaleOverrides>>
6288    for crate::bindings::LocaleOverrides
6289{
6290    fn into_into_dart(self) -> FrbWrapper<crate::bindings::LocaleOverrides> {
6291        self.into()
6292    }
6293}
6294// Codec=Dco (DartCObject based), see doc to use other codecs
6295impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LocalizedName> {
6296    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6297        [
6298            self.0.locale.into_into_dart().into_dart(),
6299            self.0.name.into_into_dart().into_dart(),
6300        ]
6301        .into_dart()
6302    }
6303}
6304impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6305    for FrbWrapper<crate::bindings::LocalizedName>
6306{
6307}
6308impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LocalizedName>>
6309    for crate::bindings::LocalizedName
6310{
6311    fn into_into_dart(self) -> FrbWrapper<crate::bindings::LocalizedName> {
6312        self.into()
6313    }
6314}
6315// Codec=Dco (DartCObject based), see doc to use other codecs
6316impl flutter_rust_bridge::IntoDart for crate::model::LogEntry {
6317    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6318        [
6319            self.line.into_into_dart().into_dart(),
6320            self.level.into_into_dart().into_dart(),
6321        ]
6322        .into_dart()
6323    }
6324}
6325impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::LogEntry {}
6326impl flutter_rust_bridge::IntoIntoDart<crate::model::LogEntry> for crate::model::LogEntry {
6327    fn into_into_dart(self) -> crate::model::LogEntry {
6328        self
6329    }
6330}
6331// Codec=Dco (DartCObject based), see doc to use other codecs
6332impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::MessageSuccessActionData> {
6333    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6334        [self.0.message.into_into_dart().into_dart()].into_dart()
6335    }
6336}
6337impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6338    for FrbWrapper<crate::bindings::MessageSuccessActionData>
6339{
6340}
6341impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::MessageSuccessActionData>>
6342    for crate::bindings::MessageSuccessActionData
6343{
6344    fn into_into_dart(self) -> FrbWrapper<crate::bindings::MessageSuccessActionData> {
6345        self.into()
6346    }
6347}
6348// Codec=Dco (DartCObject based), see doc to use other codecs
6349impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::Network> {
6350    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6351        match self.0 {
6352            crate::bindings::Network::Bitcoin => 0.into_dart(),
6353            crate::bindings::Network::Testnet => 1.into_dart(),
6354            crate::bindings::Network::Signet => 2.into_dart(),
6355            crate::bindings::Network::Regtest => 3.into_dart(),
6356            _ => unreachable!(),
6357        }
6358    }
6359}
6360impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6361    for FrbWrapper<crate::bindings::Network>
6362{
6363}
6364impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::Network>>
6365    for crate::bindings::Network
6366{
6367    fn into_into_dart(self) -> FrbWrapper<crate::bindings::Network> {
6368        self.into()
6369    }
6370}
6371// Codec=Dco (DartCObject based), see doc to use other codecs
6372impl flutter_rust_bridge::IntoDart for crate::model::OnchainPaymentLimitsResponse {
6373    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6374        [
6375            self.send.into_into_dart().into_dart(),
6376            self.receive.into_into_dart().into_dart(),
6377        ]
6378        .into_dart()
6379    }
6380}
6381impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6382    for crate::model::OnchainPaymentLimitsResponse
6383{
6384}
6385impl flutter_rust_bridge::IntoIntoDart<crate::model::OnchainPaymentLimitsResponse>
6386    for crate::model::OnchainPaymentLimitsResponse
6387{
6388    fn into_into_dart(self) -> crate::model::OnchainPaymentLimitsResponse {
6389        self
6390    }
6391}
6392// Codec=Dco (DartCObject based), see doc to use other codecs
6393impl flutter_rust_bridge::IntoDart for crate::model::PayAmount {
6394    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6395        match self {
6396            crate::model::PayAmount::Bitcoin {
6397                receiver_amount_sat,
6398            } => [
6399                0.into_dart(),
6400                receiver_amount_sat.into_into_dart().into_dart(),
6401            ]
6402            .into_dart(),
6403            crate::model::PayAmount::Asset {
6404                asset_id,
6405                receiver_amount,
6406                estimate_asset_fees,
6407                pay_with_bitcoin,
6408            } => [
6409                1.into_dart(),
6410                asset_id.into_into_dart().into_dart(),
6411                receiver_amount.into_into_dart().into_dart(),
6412                estimate_asset_fees.into_into_dart().into_dart(),
6413                pay_with_bitcoin.into_into_dart().into_dart(),
6414            ]
6415            .into_dart(),
6416            crate::model::PayAmount::Drain => [2.into_dart()].into_dart(),
6417            _ => {
6418                unimplemented!("");
6419            }
6420        }
6421    }
6422}
6423impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::PayAmount {}
6424impl flutter_rust_bridge::IntoIntoDart<crate::model::PayAmount> for crate::model::PayAmount {
6425    fn into_into_dart(self) -> crate::model::PayAmount {
6426        self
6427    }
6428}
6429// Codec=Dco (DartCObject based), see doc to use other codecs
6430impl flutter_rust_bridge::IntoDart for crate::model::PayOnchainRequest {
6431    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6432        [
6433            self.address.into_into_dart().into_dart(),
6434            self.prepare_response.into_into_dart().into_dart(),
6435        ]
6436        .into_dart()
6437    }
6438}
6439impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6440    for crate::model::PayOnchainRequest
6441{
6442}
6443impl flutter_rust_bridge::IntoIntoDart<crate::model::PayOnchainRequest>
6444    for crate::model::PayOnchainRequest
6445{
6446    fn into_into_dart(self) -> crate::model::PayOnchainRequest {
6447        self
6448    }
6449}
6450// Codec=Dco (DartCObject based), see doc to use other codecs
6451impl flutter_rust_bridge::IntoDart for crate::model::Payment {
6452    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6453        [
6454            self.destination.into_into_dart().into_dart(),
6455            self.tx_id.into_into_dart().into_dart(),
6456            self.unblinding_data.into_into_dart().into_dart(),
6457            self.timestamp.into_into_dart().into_dart(),
6458            self.amount_sat.into_into_dart().into_dart(),
6459            self.fees_sat.into_into_dart().into_dart(),
6460            self.swapper_fees_sat.into_into_dart().into_dart(),
6461            self.payment_type.into_into_dart().into_dart(),
6462            self.status.into_into_dart().into_dart(),
6463            self.details.into_into_dart().into_dart(),
6464        ]
6465        .into_dart()
6466    }
6467}
6468impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::Payment {}
6469impl flutter_rust_bridge::IntoIntoDart<crate::model::Payment> for crate::model::Payment {
6470    fn into_into_dart(self) -> crate::model::Payment {
6471        self
6472    }
6473}
6474// Codec=Dco (DartCObject based), see doc to use other codecs
6475impl flutter_rust_bridge::IntoDart for crate::model::PaymentDetails {
6476    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6477        match self {
6478            crate::model::PaymentDetails::Lightning {
6479                swap_id,
6480                description,
6481                liquid_expiration_blockheight,
6482                preimage,
6483                invoice,
6484                bolt12_offer,
6485                payment_hash,
6486                destination_pubkey,
6487                lnurl_info,
6488                bip353_address,
6489                payer_note,
6490                claim_tx_id,
6491                refund_tx_id,
6492                refund_tx_amount_sat,
6493            } => [
6494                0.into_dart(),
6495                swap_id.into_into_dart().into_dart(),
6496                description.into_into_dart().into_dart(),
6497                liquid_expiration_blockheight.into_into_dart().into_dart(),
6498                preimage.into_into_dart().into_dart(),
6499                invoice.into_into_dart().into_dart(),
6500                bolt12_offer.into_into_dart().into_dart(),
6501                payment_hash.into_into_dart().into_dart(),
6502                destination_pubkey.into_into_dart().into_dart(),
6503                lnurl_info.into_into_dart().into_dart(),
6504                bip353_address.into_into_dart().into_dart(),
6505                payer_note.into_into_dart().into_dart(),
6506                claim_tx_id.into_into_dart().into_dart(),
6507                refund_tx_id.into_into_dart().into_dart(),
6508                refund_tx_amount_sat.into_into_dart().into_dart(),
6509            ]
6510            .into_dart(),
6511            crate::model::PaymentDetails::Liquid {
6512                destination,
6513                description,
6514                asset_id,
6515                asset_info,
6516                lnurl_info,
6517                bip353_address,
6518                payer_note,
6519            } => [
6520                1.into_dart(),
6521                destination.into_into_dart().into_dart(),
6522                description.into_into_dart().into_dart(),
6523                asset_id.into_into_dart().into_dart(),
6524                asset_info.into_into_dart().into_dart(),
6525                lnurl_info.into_into_dart().into_dart(),
6526                bip353_address.into_into_dart().into_dart(),
6527                payer_note.into_into_dart().into_dart(),
6528            ]
6529            .into_dart(),
6530            crate::model::PaymentDetails::Bitcoin {
6531                swap_id,
6532                bitcoin_address,
6533                description,
6534                auto_accepted_fees,
6535                liquid_expiration_blockheight,
6536                bitcoin_expiration_blockheight,
6537                lockup_tx_id,
6538                claim_tx_id,
6539                refund_tx_id,
6540                refund_tx_amount_sat,
6541            } => [
6542                2.into_dart(),
6543                swap_id.into_into_dart().into_dart(),
6544                bitcoin_address.into_into_dart().into_dart(),
6545                description.into_into_dart().into_dart(),
6546                auto_accepted_fees.into_into_dart().into_dart(),
6547                liquid_expiration_blockheight.into_into_dart().into_dart(),
6548                bitcoin_expiration_blockheight.into_into_dart().into_dart(),
6549                lockup_tx_id.into_into_dart().into_dart(),
6550                claim_tx_id.into_into_dart().into_dart(),
6551                refund_tx_id.into_into_dart().into_dart(),
6552                refund_tx_amount_sat.into_into_dart().into_dart(),
6553            ]
6554            .into_dart(),
6555            _ => {
6556                unimplemented!("");
6557            }
6558        }
6559    }
6560}
6561impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::PaymentDetails {}
6562impl flutter_rust_bridge::IntoIntoDart<crate::model::PaymentDetails>
6563    for crate::model::PaymentDetails
6564{
6565    fn into_into_dart(self) -> crate::model::PaymentDetails {
6566        self
6567    }
6568}
6569// Codec=Dco (DartCObject based), see doc to use other codecs
6570impl flutter_rust_bridge::IntoDart for crate::error::PaymentError {
6571    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6572        match self {
6573            crate::error::PaymentError::AlreadyClaimed => [0.into_dart()].into_dart(),
6574            crate::error::PaymentError::AlreadyPaid => [1.into_dart()].into_dart(),
6575            crate::error::PaymentError::PaymentInProgress => [2.into_dart()].into_dart(),
6576            crate::error::PaymentError::AmountOutOfRange { min, max } => [
6577                3.into_dart(),
6578                min.into_into_dart().into_dart(),
6579                max.into_into_dart().into_dart(),
6580            ]
6581            .into_dart(),
6582            crate::error::PaymentError::AmountMissing { err } => {
6583                [4.into_dart(), err.into_into_dart().into_dart()].into_dart()
6584            }
6585            crate::error::PaymentError::AssetError { err } => {
6586                [5.into_dart(), err.into_into_dart().into_dart()].into_dart()
6587            }
6588            crate::error::PaymentError::InvalidNetwork { err } => {
6589                [6.into_dart(), err.into_into_dart().into_dart()].into_dart()
6590            }
6591            crate::error::PaymentError::Generic { err } => {
6592                [7.into_dart(), err.into_into_dart().into_dart()].into_dart()
6593            }
6594            crate::error::PaymentError::InvalidOrExpiredFees => [8.into_dart()].into_dart(),
6595            crate::error::PaymentError::InsufficientFunds => [9.into_dart()].into_dart(),
6596            crate::error::PaymentError::InvalidDescription { err } => {
6597                [10.into_dart(), err.into_into_dart().into_dart()].into_dart()
6598            }
6599            crate::error::PaymentError::InvalidInvoice { err } => {
6600                [11.into_dart(), err.into_into_dart().into_dart()].into_dart()
6601            }
6602            crate::error::PaymentError::InvalidPreimage => [12.into_dart()].into_dart(),
6603            crate::error::PaymentError::PairsNotFound => [13.into_dart()].into_dart(),
6604            crate::error::PaymentError::PaymentTimeout => [14.into_dart()].into_dart(),
6605            crate::error::PaymentError::PersistError => [15.into_dart()].into_dart(),
6606            crate::error::PaymentError::ReceiveError { err } => {
6607                [16.into_dart(), err.into_into_dart().into_dart()].into_dart()
6608            }
6609            crate::error::PaymentError::Refunded { err, refund_tx_id } => [
6610                17.into_dart(),
6611                err.into_into_dart().into_dart(),
6612                refund_tx_id.into_into_dart().into_dart(),
6613            ]
6614            .into_dart(),
6615            crate::error::PaymentError::SelfTransferNotSupported => [18.into_dart()].into_dart(),
6616            crate::error::PaymentError::SendError { err } => {
6617                [19.into_dart(), err.into_into_dart().into_dart()].into_dart()
6618            }
6619            crate::error::PaymentError::SignerError { err } => {
6620                [20.into_dart(), err.into_into_dart().into_dart()].into_dart()
6621            }
6622            _ => {
6623                unimplemented!("");
6624            }
6625        }
6626    }
6627}
6628impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::error::PaymentError {}
6629impl flutter_rust_bridge::IntoIntoDart<crate::error::PaymentError> for crate::error::PaymentError {
6630    fn into_into_dart(self) -> crate::error::PaymentError {
6631        self
6632    }
6633}
6634// Codec=Dco (DartCObject based), see doc to use other codecs
6635impl flutter_rust_bridge::IntoDart for crate::model::PaymentMethod {
6636    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6637        match self {
6638            Self::Lightning => 0.into_dart(),
6639            Self::Bolt11Invoice => 1.into_dart(),
6640            Self::Bolt12Offer => 2.into_dart(),
6641            Self::BitcoinAddress => 3.into_dart(),
6642            Self::LiquidAddress => 4.into_dart(),
6643            _ => unreachable!(),
6644        }
6645    }
6646}
6647impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::PaymentMethod {}
6648impl flutter_rust_bridge::IntoIntoDart<crate::model::PaymentMethod>
6649    for crate::model::PaymentMethod
6650{
6651    fn into_into_dart(self) -> crate::model::PaymentMethod {
6652        self
6653    }
6654}
6655// Codec=Dco (DartCObject based), see doc to use other codecs
6656impl flutter_rust_bridge::IntoDart for crate::model::PaymentState {
6657    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6658        match self {
6659            Self::Created => 0.into_dart(),
6660            Self::Pending => 1.into_dart(),
6661            Self::Complete => 2.into_dart(),
6662            Self::Failed => 3.into_dart(),
6663            Self::TimedOut => 4.into_dart(),
6664            Self::Refundable => 5.into_dart(),
6665            Self::RefundPending => 6.into_dart(),
6666            Self::WaitingFeeAcceptance => 7.into_dart(),
6667            _ => unreachable!(),
6668        }
6669    }
6670}
6671impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::PaymentState {}
6672impl flutter_rust_bridge::IntoIntoDart<crate::model::PaymentState> for crate::model::PaymentState {
6673    fn into_into_dart(self) -> crate::model::PaymentState {
6674        self
6675    }
6676}
6677// Codec=Dco (DartCObject based), see doc to use other codecs
6678impl flutter_rust_bridge::IntoDart for crate::model::PaymentType {
6679    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6680        match self {
6681            Self::Receive => 0.into_dart(),
6682            Self::Send => 1.into_dart(),
6683            _ => unreachable!(),
6684        }
6685    }
6686}
6687impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::PaymentType {}
6688impl flutter_rust_bridge::IntoIntoDart<crate::model::PaymentType> for crate::model::PaymentType {
6689    fn into_into_dart(self) -> crate::model::PaymentType {
6690        self
6691    }
6692}
6693// Codec=Dco (DartCObject based), see doc to use other codecs
6694impl flutter_rust_bridge::IntoDart for crate::model::PrepareBuyBitcoinRequest {
6695    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6696        [
6697            self.provider.into_into_dart().into_dart(),
6698            self.amount_sat.into_into_dart().into_dart(),
6699        ]
6700        .into_dart()
6701    }
6702}
6703impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6704    for crate::model::PrepareBuyBitcoinRequest
6705{
6706}
6707impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareBuyBitcoinRequest>
6708    for crate::model::PrepareBuyBitcoinRequest
6709{
6710    fn into_into_dart(self) -> crate::model::PrepareBuyBitcoinRequest {
6711        self
6712    }
6713}
6714// Codec=Dco (DartCObject based), see doc to use other codecs
6715impl flutter_rust_bridge::IntoDart for crate::model::PrepareBuyBitcoinResponse {
6716    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6717        [
6718            self.provider.into_into_dart().into_dart(),
6719            self.amount_sat.into_into_dart().into_dart(),
6720            self.fees_sat.into_into_dart().into_dart(),
6721        ]
6722        .into_dart()
6723    }
6724}
6725impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6726    for crate::model::PrepareBuyBitcoinResponse
6727{
6728}
6729impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareBuyBitcoinResponse>
6730    for crate::model::PrepareBuyBitcoinResponse
6731{
6732    fn into_into_dart(self) -> crate::model::PrepareBuyBitcoinResponse {
6733        self
6734    }
6735}
6736// Codec=Dco (DartCObject based), see doc to use other codecs
6737impl flutter_rust_bridge::IntoDart for crate::model::PrepareLnUrlPayRequest {
6738    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6739        [
6740            self.data.into_into_dart().into_dart(),
6741            self.amount.into_into_dart().into_dart(),
6742            self.bip353_address.into_into_dart().into_dart(),
6743            self.comment.into_into_dart().into_dart(),
6744            self.validate_success_action_url
6745                .into_into_dart()
6746                .into_dart(),
6747        ]
6748        .into_dart()
6749    }
6750}
6751impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6752    for crate::model::PrepareLnUrlPayRequest
6753{
6754}
6755impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareLnUrlPayRequest>
6756    for crate::model::PrepareLnUrlPayRequest
6757{
6758    fn into_into_dart(self) -> crate::model::PrepareLnUrlPayRequest {
6759        self
6760    }
6761}
6762// Codec=Dco (DartCObject based), see doc to use other codecs
6763impl flutter_rust_bridge::IntoDart for crate::model::PrepareLnUrlPayResponse {
6764    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6765        [
6766            self.destination.into_into_dart().into_dart(),
6767            self.fees_sat.into_into_dart().into_dart(),
6768            self.data.into_into_dart().into_dart(),
6769            self.amount.into_into_dart().into_dart(),
6770            self.comment.into_into_dart().into_dart(),
6771            self.success_action.into_into_dart().into_dart(),
6772        ]
6773        .into_dart()
6774    }
6775}
6776impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6777    for crate::model::PrepareLnUrlPayResponse
6778{
6779}
6780impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareLnUrlPayResponse>
6781    for crate::model::PrepareLnUrlPayResponse
6782{
6783    fn into_into_dart(self) -> crate::model::PrepareLnUrlPayResponse {
6784        self
6785    }
6786}
6787// Codec=Dco (DartCObject based), see doc to use other codecs
6788impl flutter_rust_bridge::IntoDart for crate::model::PreparePayOnchainRequest {
6789    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6790        [
6791            self.amount.into_into_dart().into_dart(),
6792            self.fee_rate_sat_per_vbyte.into_into_dart().into_dart(),
6793        ]
6794        .into_dart()
6795    }
6796}
6797impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6798    for crate::model::PreparePayOnchainRequest
6799{
6800}
6801impl flutter_rust_bridge::IntoIntoDart<crate::model::PreparePayOnchainRequest>
6802    for crate::model::PreparePayOnchainRequest
6803{
6804    fn into_into_dart(self) -> crate::model::PreparePayOnchainRequest {
6805        self
6806    }
6807}
6808// Codec=Dco (DartCObject based), see doc to use other codecs
6809impl flutter_rust_bridge::IntoDart for crate::model::PreparePayOnchainResponse {
6810    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6811        [
6812            self.receiver_amount_sat.into_into_dart().into_dart(),
6813            self.claim_fees_sat.into_into_dart().into_dart(),
6814            self.total_fees_sat.into_into_dart().into_dart(),
6815        ]
6816        .into_dart()
6817    }
6818}
6819impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6820    for crate::model::PreparePayOnchainResponse
6821{
6822}
6823impl flutter_rust_bridge::IntoIntoDart<crate::model::PreparePayOnchainResponse>
6824    for crate::model::PreparePayOnchainResponse
6825{
6826    fn into_into_dart(self) -> crate::model::PreparePayOnchainResponse {
6827        self
6828    }
6829}
6830// Codec=Dco (DartCObject based), see doc to use other codecs
6831impl flutter_rust_bridge::IntoDart for crate::model::PrepareReceiveRequest {
6832    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6833        [
6834            self.payment_method.into_into_dart().into_dart(),
6835            self.amount.into_into_dart().into_dart(),
6836        ]
6837        .into_dart()
6838    }
6839}
6840impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6841    for crate::model::PrepareReceiveRequest
6842{
6843}
6844impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareReceiveRequest>
6845    for crate::model::PrepareReceiveRequest
6846{
6847    fn into_into_dart(self) -> crate::model::PrepareReceiveRequest {
6848        self
6849    }
6850}
6851// Codec=Dco (DartCObject based), see doc to use other codecs
6852impl flutter_rust_bridge::IntoDart for crate::model::PrepareReceiveResponse {
6853    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6854        [
6855            self.payment_method.into_into_dart().into_dart(),
6856            self.fees_sat.into_into_dart().into_dart(),
6857            self.amount.into_into_dart().into_dart(),
6858            self.min_payer_amount_sat.into_into_dart().into_dart(),
6859            self.max_payer_amount_sat.into_into_dart().into_dart(),
6860            self.swapper_feerate.into_into_dart().into_dart(),
6861        ]
6862        .into_dart()
6863    }
6864}
6865impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6866    for crate::model::PrepareReceiveResponse
6867{
6868}
6869impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareReceiveResponse>
6870    for crate::model::PrepareReceiveResponse
6871{
6872    fn into_into_dart(self) -> crate::model::PrepareReceiveResponse {
6873        self
6874    }
6875}
6876// Codec=Dco (DartCObject based), see doc to use other codecs
6877impl flutter_rust_bridge::IntoDart for crate::model::PrepareRefundRequest {
6878    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6879        [
6880            self.swap_address.into_into_dart().into_dart(),
6881            self.refund_address.into_into_dart().into_dart(),
6882            self.fee_rate_sat_per_vbyte.into_into_dart().into_dart(),
6883        ]
6884        .into_dart()
6885    }
6886}
6887impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6888    for crate::model::PrepareRefundRequest
6889{
6890}
6891impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareRefundRequest>
6892    for crate::model::PrepareRefundRequest
6893{
6894    fn into_into_dart(self) -> crate::model::PrepareRefundRequest {
6895        self
6896    }
6897}
6898// Codec=Dco (DartCObject based), see doc to use other codecs
6899impl flutter_rust_bridge::IntoDart for crate::model::PrepareRefundResponse {
6900    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6901        [
6902            self.tx_vsize.into_into_dart().into_dart(),
6903            self.tx_fee_sat.into_into_dart().into_dart(),
6904            self.last_refund_tx_id.into_into_dart().into_dart(),
6905        ]
6906        .into_dart()
6907    }
6908}
6909impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6910    for crate::model::PrepareRefundResponse
6911{
6912}
6913impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareRefundResponse>
6914    for crate::model::PrepareRefundResponse
6915{
6916    fn into_into_dart(self) -> crate::model::PrepareRefundResponse {
6917        self
6918    }
6919}
6920// Codec=Dco (DartCObject based), see doc to use other codecs
6921impl flutter_rust_bridge::IntoDart for crate::model::PrepareSendRequest {
6922    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6923        [
6924            self.destination.into_into_dart().into_dart(),
6925            self.amount.into_into_dart().into_dart(),
6926        ]
6927        .into_dart()
6928    }
6929}
6930impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6931    for crate::model::PrepareSendRequest
6932{
6933}
6934impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareSendRequest>
6935    for crate::model::PrepareSendRequest
6936{
6937    fn into_into_dart(self) -> crate::model::PrepareSendRequest {
6938        self
6939    }
6940}
6941// Codec=Dco (DartCObject based), see doc to use other codecs
6942impl flutter_rust_bridge::IntoDart for crate::model::PrepareSendResponse {
6943    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6944        [
6945            self.destination.into_into_dart().into_dart(),
6946            self.amount.into_into_dart().into_dart(),
6947            self.fees_sat.into_into_dart().into_dart(),
6948            self.estimated_asset_fees.into_into_dart().into_dart(),
6949        ]
6950        .into_dart()
6951    }
6952}
6953impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6954    for crate::model::PrepareSendResponse
6955{
6956}
6957impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareSendResponse>
6958    for crate::model::PrepareSendResponse
6959{
6960    fn into_into_dart(self) -> crate::model::PrepareSendResponse {
6961        self
6962    }
6963}
6964// Codec=Dco (DartCObject based), see doc to use other codecs
6965impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::Rate> {
6966    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6967        [
6968            self.0.coin.into_into_dart().into_dart(),
6969            self.0.value.into_into_dart().into_dart(),
6970        ]
6971        .into_dart()
6972    }
6973}
6974impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6975    for FrbWrapper<crate::bindings::Rate>
6976{
6977}
6978impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::Rate>>
6979    for crate::bindings::Rate
6980{
6981    fn into_into_dart(self) -> FrbWrapper<crate::bindings::Rate> {
6982        self.into()
6983    }
6984}
6985// Codec=Dco (DartCObject based), see doc to use other codecs
6986impl flutter_rust_bridge::IntoDart for crate::model::ReceiveAmount {
6987    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6988        match self {
6989            crate::model::ReceiveAmount::Bitcoin { payer_amount_sat } => {
6990                [0.into_dart(), payer_amount_sat.into_into_dart().into_dart()].into_dart()
6991            }
6992            crate::model::ReceiveAmount::Asset {
6993                asset_id,
6994                payer_amount,
6995            } => [
6996                1.into_dart(),
6997                asset_id.into_into_dart().into_dart(),
6998                payer_amount.into_into_dart().into_dart(),
6999            ]
7000            .into_dart(),
7001            _ => {
7002                unimplemented!("");
7003            }
7004        }
7005    }
7006}
7007impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::ReceiveAmount {}
7008impl flutter_rust_bridge::IntoIntoDart<crate::model::ReceiveAmount>
7009    for crate::model::ReceiveAmount
7010{
7011    fn into_into_dart(self) -> crate::model::ReceiveAmount {
7012        self
7013    }
7014}
7015// Codec=Dco (DartCObject based), see doc to use other codecs
7016impl flutter_rust_bridge::IntoDart for crate::model::ReceivePaymentRequest {
7017    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7018        [
7019            self.prepare_response.into_into_dart().into_dart(),
7020            self.description.into_into_dart().into_dart(),
7021            self.use_description_hash.into_into_dart().into_dart(),
7022            self.payer_note.into_into_dart().into_dart(),
7023        ]
7024        .into_dart()
7025    }
7026}
7027impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7028    for crate::model::ReceivePaymentRequest
7029{
7030}
7031impl flutter_rust_bridge::IntoIntoDart<crate::model::ReceivePaymentRequest>
7032    for crate::model::ReceivePaymentRequest
7033{
7034    fn into_into_dart(self) -> crate::model::ReceivePaymentRequest {
7035        self
7036    }
7037}
7038// Codec=Dco (DartCObject based), see doc to use other codecs
7039impl flutter_rust_bridge::IntoDart for crate::model::ReceivePaymentResponse {
7040    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7041        [self.destination.into_into_dart().into_dart()].into_dart()
7042    }
7043}
7044impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7045    for crate::model::ReceivePaymentResponse
7046{
7047}
7048impl flutter_rust_bridge::IntoIntoDart<crate::model::ReceivePaymentResponse>
7049    for crate::model::ReceivePaymentResponse
7050{
7051    fn into_into_dart(self) -> crate::model::ReceivePaymentResponse {
7052        self
7053    }
7054}
7055// Codec=Dco (DartCObject based), see doc to use other codecs
7056impl flutter_rust_bridge::IntoDart for crate::model::RecommendedFees {
7057    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7058        [
7059            self.fastest_fee.into_into_dart().into_dart(),
7060            self.half_hour_fee.into_into_dart().into_dart(),
7061            self.hour_fee.into_into_dart().into_dart(),
7062            self.economy_fee.into_into_dart().into_dart(),
7063            self.minimum_fee.into_into_dart().into_dart(),
7064        ]
7065        .into_dart()
7066    }
7067}
7068impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::RecommendedFees {}
7069impl flutter_rust_bridge::IntoIntoDart<crate::model::RecommendedFees>
7070    for crate::model::RecommendedFees
7071{
7072    fn into_into_dart(self) -> crate::model::RecommendedFees {
7073        self
7074    }
7075}
7076// Codec=Dco (DartCObject based), see doc to use other codecs
7077impl flutter_rust_bridge::IntoDart for crate::model::RefundRequest {
7078    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7079        [
7080            self.swap_address.into_into_dart().into_dart(),
7081            self.refund_address.into_into_dart().into_dart(),
7082            self.fee_rate_sat_per_vbyte.into_into_dart().into_dart(),
7083        ]
7084        .into_dart()
7085    }
7086}
7087impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::RefundRequest {}
7088impl flutter_rust_bridge::IntoIntoDart<crate::model::RefundRequest>
7089    for crate::model::RefundRequest
7090{
7091    fn into_into_dart(self) -> crate::model::RefundRequest {
7092        self
7093    }
7094}
7095// Codec=Dco (DartCObject based), see doc to use other codecs
7096impl flutter_rust_bridge::IntoDart for crate::model::RefundResponse {
7097    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7098        [self.refund_tx_id.into_into_dart().into_dart()].into_dart()
7099    }
7100}
7101impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::RefundResponse {}
7102impl flutter_rust_bridge::IntoIntoDart<crate::model::RefundResponse>
7103    for crate::model::RefundResponse
7104{
7105    fn into_into_dart(self) -> crate::model::RefundResponse {
7106        self
7107    }
7108}
7109// Codec=Dco (DartCObject based), see doc to use other codecs
7110impl flutter_rust_bridge::IntoDart for crate::model::RefundableSwap {
7111    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7112        [
7113            self.swap_address.into_into_dart().into_dart(),
7114            self.timestamp.into_into_dart().into_dart(),
7115            self.amount_sat.into_into_dart().into_dart(),
7116            self.last_refund_tx_id.into_into_dart().into_dart(),
7117        ]
7118        .into_dart()
7119    }
7120}
7121impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::RefundableSwap {}
7122impl flutter_rust_bridge::IntoIntoDart<crate::model::RefundableSwap>
7123    for crate::model::RefundableSwap
7124{
7125    fn into_into_dart(self) -> crate::model::RefundableSwap {
7126        self
7127    }
7128}
7129// Codec=Dco (DartCObject based), see doc to use other codecs
7130impl flutter_rust_bridge::IntoDart for crate::model::RestoreRequest {
7131    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7132        [self.backup_path.into_into_dart().into_dart()].into_dart()
7133    }
7134}
7135impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::RestoreRequest {}
7136impl flutter_rust_bridge::IntoIntoDart<crate::model::RestoreRequest>
7137    for crate::model::RestoreRequest
7138{
7139    fn into_into_dart(self) -> crate::model::RestoreRequest {
7140        self
7141    }
7142}
7143// Codec=Dco (DartCObject based), see doc to use other codecs
7144impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::RouteHint> {
7145    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7146        [self.0.hops.into_into_dart().into_dart()].into_dart()
7147    }
7148}
7149impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7150    for FrbWrapper<crate::bindings::RouteHint>
7151{
7152}
7153impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::RouteHint>>
7154    for crate::bindings::RouteHint
7155{
7156    fn into_into_dart(self) -> FrbWrapper<crate::bindings::RouteHint> {
7157        self.into()
7158    }
7159}
7160// Codec=Dco (DartCObject based), see doc to use other codecs
7161impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::RouteHintHop> {
7162    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7163        [
7164            self.0.src_node_id.into_into_dart().into_dart(),
7165            self.0.short_channel_id.into_into_dart().into_dart(),
7166            self.0.fees_base_msat.into_into_dart().into_dart(),
7167            self.0
7168                .fees_proportional_millionths
7169                .into_into_dart()
7170                .into_dart(),
7171            self.0.cltv_expiry_delta.into_into_dart().into_dart(),
7172            self.0.htlc_minimum_msat.into_into_dart().into_dart(),
7173            self.0.htlc_maximum_msat.into_into_dart().into_dart(),
7174        ]
7175        .into_dart()
7176    }
7177}
7178impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7179    for FrbWrapper<crate::bindings::RouteHintHop>
7180{
7181}
7182impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::RouteHintHop>>
7183    for crate::bindings::RouteHintHop
7184{
7185    fn into_into_dart(self) -> FrbWrapper<crate::bindings::RouteHintHop> {
7186        self.into()
7187    }
7188}
7189// Codec=Dco (DartCObject based), see doc to use other codecs
7190impl flutter_rust_bridge::IntoDart for crate::error::SdkError {
7191    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7192        match self {
7193            crate::error::SdkError::AlreadyStarted => [0.into_dart()].into_dart(),
7194            crate::error::SdkError::Generic { err } => {
7195                [1.into_dart(), err.into_into_dart().into_dart()].into_dart()
7196            }
7197            crate::error::SdkError::NotStarted => [2.into_dart()].into_dart(),
7198            crate::error::SdkError::ServiceConnectivity { err } => {
7199                [3.into_dart(), err.into_into_dart().into_dart()].into_dart()
7200            }
7201            _ => {
7202                unimplemented!("");
7203            }
7204        }
7205    }
7206}
7207impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::error::SdkError {}
7208impl flutter_rust_bridge::IntoIntoDart<crate::error::SdkError> for crate::error::SdkError {
7209    fn into_into_dart(self) -> crate::error::SdkError {
7210        self
7211    }
7212}
7213// Codec=Dco (DartCObject based), see doc to use other codecs
7214impl flutter_rust_bridge::IntoDart for crate::model::SdkEvent {
7215    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7216        match self {
7217            crate::model::SdkEvent::PaymentFailed { details } => {
7218                [0.into_dart(), details.into_into_dart().into_dart()].into_dart()
7219            }
7220            crate::model::SdkEvent::PaymentPending { details } => {
7221                [1.into_dart(), details.into_into_dart().into_dart()].into_dart()
7222            }
7223            crate::model::SdkEvent::PaymentRefundable { details } => {
7224                [2.into_dart(), details.into_into_dart().into_dart()].into_dart()
7225            }
7226            crate::model::SdkEvent::PaymentRefunded { details } => {
7227                [3.into_dart(), details.into_into_dart().into_dart()].into_dart()
7228            }
7229            crate::model::SdkEvent::PaymentRefundPending { details } => {
7230                [4.into_dart(), details.into_into_dart().into_dart()].into_dart()
7231            }
7232            crate::model::SdkEvent::PaymentSucceeded { details } => {
7233                [5.into_dart(), details.into_into_dart().into_dart()].into_dart()
7234            }
7235            crate::model::SdkEvent::PaymentWaitingConfirmation { details } => {
7236                [6.into_dart(), details.into_into_dart().into_dart()].into_dart()
7237            }
7238            crate::model::SdkEvent::PaymentWaitingFeeAcceptance { details } => {
7239                [7.into_dart(), details.into_into_dart().into_dart()].into_dart()
7240            }
7241            crate::model::SdkEvent::Synced => [8.into_dart()].into_dart(),
7242            crate::model::SdkEvent::DataSynced {
7243                did_pull_new_records,
7244            } => [
7245                9.into_dart(),
7246                did_pull_new_records.into_into_dart().into_dart(),
7247            ]
7248            .into_dart(),
7249            _ => {
7250                unimplemented!("");
7251            }
7252        }
7253    }
7254}
7255impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::SdkEvent {}
7256impl flutter_rust_bridge::IntoIntoDart<crate::model::SdkEvent> for crate::model::SdkEvent {
7257    fn into_into_dart(self) -> crate::model::SdkEvent {
7258        self
7259    }
7260}
7261// Codec=Dco (DartCObject based), see doc to use other codecs
7262impl flutter_rust_bridge::IntoDart for crate::model::SendDestination {
7263    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7264        match self {
7265            crate::model::SendDestination::LiquidAddress {
7266                address_data,
7267                bip353_address,
7268            } => [
7269                0.into_dart(),
7270                address_data.into_into_dart().into_dart(),
7271                bip353_address.into_into_dart().into_dart(),
7272            ]
7273            .into_dart(),
7274            crate::model::SendDestination::Bolt11 {
7275                invoice,
7276                bip353_address,
7277            } => [
7278                1.into_dart(),
7279                invoice.into_into_dart().into_dart(),
7280                bip353_address.into_into_dart().into_dart(),
7281            ]
7282            .into_dart(),
7283            crate::model::SendDestination::Bolt12 {
7284                offer,
7285                receiver_amount_sat,
7286                bip353_address,
7287            } => [
7288                2.into_dart(),
7289                offer.into_into_dart().into_dart(),
7290                receiver_amount_sat.into_into_dart().into_dart(),
7291                bip353_address.into_into_dart().into_dart(),
7292            ]
7293            .into_dart(),
7294            _ => {
7295                unimplemented!("");
7296            }
7297        }
7298    }
7299}
7300impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::SendDestination {}
7301impl flutter_rust_bridge::IntoIntoDart<crate::model::SendDestination>
7302    for crate::model::SendDestination
7303{
7304    fn into_into_dart(self) -> crate::model::SendDestination {
7305        self
7306    }
7307}
7308// Codec=Dco (DartCObject based), see doc to use other codecs
7309impl flutter_rust_bridge::IntoDart for crate::model::SendPaymentRequest {
7310    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7311        [
7312            self.prepare_response.into_into_dart().into_dart(),
7313            self.use_asset_fees.into_into_dart().into_dart(),
7314            self.payer_note.into_into_dart().into_dart(),
7315        ]
7316        .into_dart()
7317    }
7318}
7319impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7320    for crate::model::SendPaymentRequest
7321{
7322}
7323impl flutter_rust_bridge::IntoIntoDart<crate::model::SendPaymentRequest>
7324    for crate::model::SendPaymentRequest
7325{
7326    fn into_into_dart(self) -> crate::model::SendPaymentRequest {
7327        self
7328    }
7329}
7330// Codec=Dco (DartCObject based), see doc to use other codecs
7331impl flutter_rust_bridge::IntoDart for crate::model::SendPaymentResponse {
7332    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7333        [self.payment.into_into_dart().into_dart()].into_dart()
7334    }
7335}
7336impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7337    for crate::model::SendPaymentResponse
7338{
7339}
7340impl flutter_rust_bridge::IntoIntoDart<crate::model::SendPaymentResponse>
7341    for crate::model::SendPaymentResponse
7342{
7343    fn into_into_dart(self) -> crate::model::SendPaymentResponse {
7344        self
7345    }
7346}
7347// Codec=Dco (DartCObject based), see doc to use other codecs
7348impl flutter_rust_bridge::IntoDart for crate::model::SignMessageRequest {
7349    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7350        [self.message.into_into_dart().into_dart()].into_dart()
7351    }
7352}
7353impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7354    for crate::model::SignMessageRequest
7355{
7356}
7357impl flutter_rust_bridge::IntoIntoDart<crate::model::SignMessageRequest>
7358    for crate::model::SignMessageRequest
7359{
7360    fn into_into_dart(self) -> crate::model::SignMessageRequest {
7361        self
7362    }
7363}
7364// Codec=Dco (DartCObject based), see doc to use other codecs
7365impl flutter_rust_bridge::IntoDart for crate::model::SignMessageResponse {
7366    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7367        [self.signature.into_into_dart().into_dart()].into_dart()
7368    }
7369}
7370impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7371    for crate::model::SignMessageResponse
7372{
7373}
7374impl flutter_rust_bridge::IntoIntoDart<crate::model::SignMessageResponse>
7375    for crate::model::SignMessageResponse
7376{
7377    fn into_into_dart(self) -> crate::model::SignMessageResponse {
7378        self
7379    }
7380}
7381// Codec=Dco (DartCObject based), see doc to use other codecs
7382impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::SuccessAction> {
7383    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7384        match self.0 {
7385            crate::bindings::SuccessAction::Aes { data } => {
7386                [0.into_dart(), data.into_into_dart().into_dart()].into_dart()
7387            }
7388            crate::bindings::SuccessAction::Message { data } => {
7389                [1.into_dart(), data.into_into_dart().into_dart()].into_dart()
7390            }
7391            crate::bindings::SuccessAction::Url { data } => {
7392                [2.into_dart(), data.into_into_dart().into_dart()].into_dart()
7393            }
7394            _ => {
7395                unimplemented!("");
7396            }
7397        }
7398    }
7399}
7400impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7401    for FrbWrapper<crate::bindings::SuccessAction>
7402{
7403}
7404impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::SuccessAction>>
7405    for crate::bindings::SuccessAction
7406{
7407    fn into_into_dart(self) -> FrbWrapper<crate::bindings::SuccessAction> {
7408        self.into()
7409    }
7410}
7411// Codec=Dco (DartCObject based), see doc to use other codecs
7412impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::SuccessActionProcessed> {
7413    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7414        match self.0 {
7415            crate::bindings::SuccessActionProcessed::Aes { result } => {
7416                [0.into_dart(), result.into_into_dart().into_dart()].into_dart()
7417            }
7418            crate::bindings::SuccessActionProcessed::Message { data } => {
7419                [1.into_dart(), data.into_into_dart().into_dart()].into_dart()
7420            }
7421            crate::bindings::SuccessActionProcessed::Url { data } => {
7422                [2.into_dart(), data.into_into_dart().into_dart()].into_dart()
7423            }
7424            _ => {
7425                unimplemented!("");
7426            }
7427        }
7428    }
7429}
7430impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7431    for FrbWrapper<crate::bindings::SuccessActionProcessed>
7432{
7433}
7434impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::SuccessActionProcessed>>
7435    for crate::bindings::SuccessActionProcessed
7436{
7437    fn into_into_dart(self) -> FrbWrapper<crate::bindings::SuccessActionProcessed> {
7438        self.into()
7439    }
7440}
7441// Codec=Dco (DartCObject based), see doc to use other codecs
7442impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::Symbol> {
7443    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7444        [
7445            self.0.grapheme.into_into_dart().into_dart(),
7446            self.0.template.into_into_dart().into_dart(),
7447            self.0.rtl.into_into_dart().into_dart(),
7448            self.0.position.into_into_dart().into_dart(),
7449        ]
7450        .into_dart()
7451    }
7452}
7453impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7454    for FrbWrapper<crate::bindings::Symbol>
7455{
7456}
7457impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::Symbol>>
7458    for crate::bindings::Symbol
7459{
7460    fn into_into_dart(self) -> FrbWrapper<crate::bindings::Symbol> {
7461        self.into()
7462    }
7463}
7464// Codec=Dco (DartCObject based), see doc to use other codecs
7465impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::UrlSuccessActionData> {
7466    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7467        [
7468            self.0.description.into_into_dart().into_dart(),
7469            self.0.url.into_into_dart().into_dart(),
7470            self.0.matches_callback_domain.into_into_dart().into_dart(),
7471        ]
7472        .into_dart()
7473    }
7474}
7475impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7476    for FrbWrapper<crate::bindings::UrlSuccessActionData>
7477{
7478}
7479impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::UrlSuccessActionData>>
7480    for crate::bindings::UrlSuccessActionData
7481{
7482    fn into_into_dart(self) -> FrbWrapper<crate::bindings::UrlSuccessActionData> {
7483        self.into()
7484    }
7485}
7486// Codec=Dco (DartCObject based), see doc to use other codecs
7487impl flutter_rust_bridge::IntoDart for crate::model::WalletInfo {
7488    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7489        [
7490            self.balance_sat.into_into_dart().into_dart(),
7491            self.pending_send_sat.into_into_dart().into_dart(),
7492            self.pending_receive_sat.into_into_dart().into_dart(),
7493            self.fingerprint.into_into_dart().into_dart(),
7494            self.pubkey.into_into_dart().into_dart(),
7495            self.asset_balances.into_into_dart().into_dart(),
7496        ]
7497        .into_dart()
7498    }
7499}
7500impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::WalletInfo {}
7501impl flutter_rust_bridge::IntoIntoDart<crate::model::WalletInfo> for crate::model::WalletInfo {
7502    fn into_into_dart(self) -> crate::model::WalletInfo {
7503        self
7504    }
7505}
7506
7507impl SseEncode for flutter_rust_bridge::for_generated::anyhow::Error {
7508    // Codec=Sse (Serialization based), see doc to use other codecs
7509    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7510        <String>::sse_encode(format!("{:?}", self), serializer);
7511    }
7512}
7513
7514impl SseEncode for BindingLiquidSdk {
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        <RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>>::sse_encode(flutter_rust_bridge::for_generated::rust_auto_opaque_encode::<_, StdArc<_>>(self), serializer);
7518    }
7519}
7520
7521impl SseEncode
7522    for RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>
7523{
7524    // Codec=Sse (Serialization based), see doc to use other codecs
7525    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7526        let (ptr, size) = self.sse_encode_raw();
7527        <usize>::sse_encode(ptr, serializer);
7528        <i32>::sse_encode(size, serializer);
7529    }
7530}
7531
7532impl SseEncode
7533    for StreamSink<crate::model::LogEntry, flutter_rust_bridge::for_generated::DcoCodec>
7534{
7535    // Codec=Sse (Serialization based), see doc to use other codecs
7536    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7537        unimplemented!("")
7538    }
7539}
7540
7541impl SseEncode
7542    for StreamSink<crate::model::SdkEvent, flutter_rust_bridge::for_generated::DcoCodec>
7543{
7544    // Codec=Sse (Serialization based), see doc to use other codecs
7545    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7546        unimplemented!("")
7547    }
7548}
7549
7550impl SseEncode for String {
7551    // Codec=Sse (Serialization based), see doc to use other codecs
7552    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7553        <Vec<u8>>::sse_encode(self.into_bytes(), serializer);
7554    }
7555}
7556
7557impl SseEncode for crate::model::AcceptPaymentProposedFeesRequest {
7558    // Codec=Sse (Serialization based), see doc to use other codecs
7559    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7560        <crate::model::FetchPaymentProposedFeesResponse>::sse_encode(self.response, serializer);
7561    }
7562}
7563
7564impl SseEncode for crate::bindings::AesSuccessActionData {
7565    // Codec=Sse (Serialization based), see doc to use other codecs
7566    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7567        <String>::sse_encode(self.description, serializer);
7568        <String>::sse_encode(self.ciphertext, serializer);
7569        <String>::sse_encode(self.iv, serializer);
7570    }
7571}
7572
7573impl SseEncode for crate::bindings::AesSuccessActionDataDecrypted {
7574    // Codec=Sse (Serialization based), see doc to use other codecs
7575    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7576        <String>::sse_encode(self.description, serializer);
7577        <String>::sse_encode(self.plaintext, serializer);
7578    }
7579}
7580
7581impl SseEncode for crate::bindings::AesSuccessActionDataResult {
7582    // Codec=Sse (Serialization based), see doc to use other codecs
7583    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7584        match self {
7585            crate::bindings::AesSuccessActionDataResult::Decrypted { data } => {
7586                <i32>::sse_encode(0, serializer);
7587                <crate::bindings::AesSuccessActionDataDecrypted>::sse_encode(data, serializer);
7588            }
7589            crate::bindings::AesSuccessActionDataResult::ErrorStatus { reason } => {
7590                <i32>::sse_encode(1, serializer);
7591                <String>::sse_encode(reason, serializer);
7592            }
7593            _ => {
7594                unimplemented!("");
7595            }
7596        }
7597    }
7598}
7599
7600impl SseEncode for crate::bindings::Amount {
7601    // Codec=Sse (Serialization based), see doc to use other codecs
7602    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7603        match self {
7604            crate::bindings::Amount::Bitcoin { amount_msat } => {
7605                <i32>::sse_encode(0, serializer);
7606                <u64>::sse_encode(amount_msat, serializer);
7607            }
7608            crate::bindings::Amount::Currency {
7609                iso4217_code,
7610                fractional_amount,
7611            } => {
7612                <i32>::sse_encode(1, serializer);
7613                <String>::sse_encode(iso4217_code, serializer);
7614                <u64>::sse_encode(fractional_amount, serializer);
7615            }
7616            _ => {
7617                unimplemented!("");
7618            }
7619        }
7620    }
7621}
7622
7623impl SseEncode for crate::model::AssetBalance {
7624    // Codec=Sse (Serialization based), see doc to use other codecs
7625    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7626        <String>::sse_encode(self.asset_id, serializer);
7627        <u64>::sse_encode(self.balance_sat, serializer);
7628        <Option<String>>::sse_encode(self.name, serializer);
7629        <Option<String>>::sse_encode(self.ticker, serializer);
7630        <Option<f64>>::sse_encode(self.balance, serializer);
7631    }
7632}
7633
7634impl SseEncode for crate::model::AssetInfo {
7635    // Codec=Sse (Serialization based), see doc to use other codecs
7636    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7637        <String>::sse_encode(self.name, serializer);
7638        <String>::sse_encode(self.ticker, serializer);
7639        <f64>::sse_encode(self.amount, serializer);
7640        <Option<f64>>::sse_encode(self.fees, serializer);
7641    }
7642}
7643
7644impl SseEncode for crate::model::AssetMetadata {
7645    // Codec=Sse (Serialization based), see doc to use other codecs
7646    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7647        <String>::sse_encode(self.asset_id, serializer);
7648        <String>::sse_encode(self.name, serializer);
7649        <String>::sse_encode(self.ticker, serializer);
7650        <u8>::sse_encode(self.precision, serializer);
7651        <Option<String>>::sse_encode(self.fiat_id, serializer);
7652    }
7653}
7654
7655impl SseEncode for crate::model::BackupRequest {
7656    // Codec=Sse (Serialization based), see doc to use other codecs
7657    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7658        <Option<String>>::sse_encode(self.backup_path, serializer);
7659    }
7660}
7661
7662impl SseEncode for crate::bindings::BindingEventListener {
7663    // Codec=Sse (Serialization based), see doc to use other codecs
7664    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7665        <StreamSink<crate::model::SdkEvent,flutter_rust_bridge::for_generated::DcoCodec>>::sse_encode(self.stream, serializer);
7666    }
7667}
7668
7669impl SseEncode for crate::bindings::BitcoinAddressData {
7670    // Codec=Sse (Serialization based), see doc to use other codecs
7671    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7672        <String>::sse_encode(self.address, serializer);
7673        <crate::bindings::Network>::sse_encode(self.network, serializer);
7674        <Option<u64>>::sse_encode(self.amount_sat, serializer);
7675        <Option<String>>::sse_encode(self.label, serializer);
7676        <Option<String>>::sse_encode(self.message, serializer);
7677    }
7678}
7679
7680impl SseEncode for crate::model::BlockchainExplorer {
7681    // Codec=Sse (Serialization based), see doc to use other codecs
7682    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7683        match self {
7684            crate::model::BlockchainExplorer::Electrum { url } => {
7685                <i32>::sse_encode(0, serializer);
7686                <String>::sse_encode(url, serializer);
7687            }
7688            crate::model::BlockchainExplorer::Esplora {
7689                url,
7690                use_waterfalls,
7691            } => {
7692                <i32>::sse_encode(1, serializer);
7693                <String>::sse_encode(url, serializer);
7694                <bool>::sse_encode(use_waterfalls, serializer);
7695            }
7696            _ => {
7697                unimplemented!("");
7698            }
7699        }
7700    }
7701}
7702
7703impl SseEncode for crate::model::BlockchainInfo {
7704    // Codec=Sse (Serialization based), see doc to use other codecs
7705    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7706        <u32>::sse_encode(self.liquid_tip, serializer);
7707        <u32>::sse_encode(self.bitcoin_tip, serializer);
7708    }
7709}
7710
7711impl SseEncode for bool {
7712    // Codec=Sse (Serialization based), see doc to use other codecs
7713    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7714        serializer.cursor.write_u8(self as _).unwrap();
7715    }
7716}
7717
7718impl SseEncode for crate::model::BuyBitcoinProvider {
7719    // Codec=Sse (Serialization based), see doc to use other codecs
7720    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7721        <i32>::sse_encode(
7722            match self {
7723                crate::model::BuyBitcoinProvider::Moonpay => 0,
7724                _ => {
7725                    unimplemented!("");
7726                }
7727            },
7728            serializer,
7729        );
7730    }
7731}
7732
7733impl SseEncode for crate::model::BuyBitcoinRequest {
7734    // Codec=Sse (Serialization based), see doc to use other codecs
7735    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7736        <crate::model::PrepareBuyBitcoinResponse>::sse_encode(self.prepare_response, serializer);
7737        <Option<String>>::sse_encode(self.redirect_url, serializer);
7738    }
7739}
7740
7741impl SseEncode for crate::model::CheckMessageRequest {
7742    // Codec=Sse (Serialization based), see doc to use other codecs
7743    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7744        <String>::sse_encode(self.message, serializer);
7745        <String>::sse_encode(self.pubkey, serializer);
7746        <String>::sse_encode(self.signature, serializer);
7747    }
7748}
7749
7750impl SseEncode for crate::model::CheckMessageResponse {
7751    // Codec=Sse (Serialization based), see doc to use other codecs
7752    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7753        <bool>::sse_encode(self.is_valid, serializer);
7754    }
7755}
7756
7757impl SseEncode for crate::model::Config {
7758    // Codec=Sse (Serialization based), see doc to use other codecs
7759    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7760        <crate::model::BlockchainExplorer>::sse_encode(self.liquid_explorer, serializer);
7761        <crate::model::BlockchainExplorer>::sse_encode(self.bitcoin_explorer, serializer);
7762        <String>::sse_encode(self.working_dir, serializer);
7763        <crate::model::LiquidNetwork>::sse_encode(self.network, serializer);
7764        <u64>::sse_encode(self.payment_timeout_sec, serializer);
7765        <Option<String>>::sse_encode(self.sync_service_url, serializer);
7766        <Option<u64>>::sse_encode(self.zero_conf_max_amount_sat, serializer);
7767        <Option<String>>::sse_encode(self.breez_api_key, serializer);
7768        <Option<Vec<crate::bindings::ExternalInputParser>>>::sse_encode(
7769            self.external_input_parsers,
7770            serializer,
7771        );
7772        <bool>::sse_encode(self.use_default_external_input_parsers, serializer);
7773        <Option<u64>>::sse_encode(self.onchain_fee_rate_leeway_sat, serializer);
7774        <Option<Vec<crate::model::AssetMetadata>>>::sse_encode(self.asset_metadata, serializer);
7775        <Option<String>>::sse_encode(self.sideswap_api_key, serializer);
7776    }
7777}
7778
7779impl SseEncode for crate::model::ConnectRequest {
7780    // Codec=Sse (Serialization based), see doc to use other codecs
7781    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7782        <crate::model::Config>::sse_encode(self.config, serializer);
7783        <Option<String>>::sse_encode(self.mnemonic, serializer);
7784        <Option<String>>::sse_encode(self.passphrase, serializer);
7785        <Option<Vec<u8>>>::sse_encode(self.seed, serializer);
7786    }
7787}
7788
7789impl SseEncode for crate::model::CreateBolt12InvoiceRequest {
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.offer, serializer);
7793        <String>::sse_encode(self.invoice_request, serializer);
7794    }
7795}
7796
7797impl SseEncode for crate::model::CreateBolt12InvoiceResponse {
7798    // Codec=Sse (Serialization based), see doc to use other codecs
7799    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7800        <String>::sse_encode(self.invoice, serializer);
7801    }
7802}
7803
7804impl SseEncode for crate::bindings::CurrencyInfo {
7805    // Codec=Sse (Serialization based), see doc to use other codecs
7806    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7807        <String>::sse_encode(self.name, serializer);
7808        <u32>::sse_encode(self.fraction_size, serializer);
7809        <Option<u32>>::sse_encode(self.spacing, serializer);
7810        <Option<crate::bindings::Symbol>>::sse_encode(self.symbol, serializer);
7811        <Option<crate::bindings::Symbol>>::sse_encode(self.uniq_symbol, serializer);
7812        <Vec<crate::bindings::LocalizedName>>::sse_encode(self.localized_name, serializer);
7813        <Vec<crate::bindings::LocaleOverrides>>::sse_encode(self.locale_overrides, serializer);
7814    }
7815}
7816
7817impl SseEncode for crate::bindings::ExternalInputParser {
7818    // Codec=Sse (Serialization based), see doc to use other codecs
7819    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7820        <String>::sse_encode(self.provider_id, serializer);
7821        <String>::sse_encode(self.input_regex, serializer);
7822        <String>::sse_encode(self.parser_url, serializer);
7823    }
7824}
7825
7826impl SseEncode for f64 {
7827    // Codec=Sse (Serialization based), see doc to use other codecs
7828    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7829        serializer.cursor.write_f64::<NativeEndian>(self).unwrap();
7830    }
7831}
7832
7833impl SseEncode for crate::model::FetchPaymentProposedFeesRequest {
7834    // Codec=Sse (Serialization based), see doc to use other codecs
7835    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7836        <String>::sse_encode(self.swap_id, serializer);
7837    }
7838}
7839
7840impl SseEncode for crate::model::FetchPaymentProposedFeesResponse {
7841    // Codec=Sse (Serialization based), see doc to use other codecs
7842    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7843        <String>::sse_encode(self.swap_id, serializer);
7844        <u64>::sse_encode(self.fees_sat, serializer);
7845        <u64>::sse_encode(self.payer_amount_sat, serializer);
7846        <u64>::sse_encode(self.receiver_amount_sat, serializer);
7847    }
7848}
7849
7850impl SseEncode for crate::bindings::FiatCurrency {
7851    // Codec=Sse (Serialization based), see doc to use other codecs
7852    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7853        <String>::sse_encode(self.id, serializer);
7854        <crate::bindings::CurrencyInfo>::sse_encode(self.info, serializer);
7855    }
7856}
7857
7858impl SseEncode for crate::model::GetInfoResponse {
7859    // Codec=Sse (Serialization based), see doc to use other codecs
7860    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7861        <crate::model::WalletInfo>::sse_encode(self.wallet_info, serializer);
7862        <crate::model::BlockchainInfo>::sse_encode(self.blockchain_info, serializer);
7863    }
7864}
7865
7866impl SseEncode for crate::model::GetPaymentRequest {
7867    // Codec=Sse (Serialization based), see doc to use other codecs
7868    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7869        match self {
7870            crate::model::GetPaymentRequest::PaymentHash { payment_hash } => {
7871                <i32>::sse_encode(0, serializer);
7872                <String>::sse_encode(payment_hash, serializer);
7873            }
7874            crate::model::GetPaymentRequest::SwapId { swap_id } => {
7875                <i32>::sse_encode(1, serializer);
7876                <String>::sse_encode(swap_id, serializer);
7877            }
7878            _ => {
7879                unimplemented!("");
7880            }
7881        }
7882    }
7883}
7884
7885impl SseEncode for i32 {
7886    // Codec=Sse (Serialization based), see doc to use other codecs
7887    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7888        serializer.cursor.write_i32::<NativeEndian>(self).unwrap();
7889    }
7890}
7891
7892impl SseEncode for i64 {
7893    // Codec=Sse (Serialization based), see doc to use other codecs
7894    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7895        serializer.cursor.write_i64::<NativeEndian>(self).unwrap();
7896    }
7897}
7898
7899impl SseEncode for crate::bindings::InputType {
7900    // Codec=Sse (Serialization based), see doc to use other codecs
7901    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7902        match self {
7903            crate::bindings::InputType::BitcoinAddress { address } => {
7904                <i32>::sse_encode(0, serializer);
7905                <crate::bindings::BitcoinAddressData>::sse_encode(address, serializer);
7906            }
7907            crate::bindings::InputType::LiquidAddress { address } => {
7908                <i32>::sse_encode(1, serializer);
7909                <crate::bindings::LiquidAddressData>::sse_encode(address, serializer);
7910            }
7911            crate::bindings::InputType::Bolt11 { invoice } => {
7912                <i32>::sse_encode(2, serializer);
7913                <crate::bindings::LNInvoice>::sse_encode(invoice, serializer);
7914            }
7915            crate::bindings::InputType::Bolt12Offer {
7916                offer,
7917                bip353_address,
7918            } => {
7919                <i32>::sse_encode(3, serializer);
7920                <crate::bindings::LNOffer>::sse_encode(offer, serializer);
7921                <Option<String>>::sse_encode(bip353_address, serializer);
7922            }
7923            crate::bindings::InputType::NodeId { node_id } => {
7924                <i32>::sse_encode(4, serializer);
7925                <String>::sse_encode(node_id, serializer);
7926            }
7927            crate::bindings::InputType::Url { url } => {
7928                <i32>::sse_encode(5, serializer);
7929                <String>::sse_encode(url, serializer);
7930            }
7931            crate::bindings::InputType::LnUrlPay {
7932                data,
7933                bip353_address,
7934            } => {
7935                <i32>::sse_encode(6, serializer);
7936                <crate::bindings::LnUrlPayRequestData>::sse_encode(data, serializer);
7937                <Option<String>>::sse_encode(bip353_address, serializer);
7938            }
7939            crate::bindings::InputType::LnUrlWithdraw { data } => {
7940                <i32>::sse_encode(7, serializer);
7941                <crate::bindings::LnUrlWithdrawRequestData>::sse_encode(data, serializer);
7942            }
7943            crate::bindings::InputType::LnUrlAuth { data } => {
7944                <i32>::sse_encode(8, serializer);
7945                <crate::bindings::LnUrlAuthRequestData>::sse_encode(data, serializer);
7946            }
7947            crate::bindings::InputType::LnUrlError { data } => {
7948                <i32>::sse_encode(9, serializer);
7949                <crate::bindings::LnUrlErrorData>::sse_encode(data, serializer);
7950            }
7951            _ => {
7952                unimplemented!("");
7953            }
7954        }
7955    }
7956}
7957
7958impl SseEncode for crate::model::LightningPaymentLimitsResponse {
7959    // Codec=Sse (Serialization based), see doc to use other codecs
7960    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7961        <crate::model::Limits>::sse_encode(self.send, serializer);
7962        <crate::model::Limits>::sse_encode(self.receive, serializer);
7963    }
7964}
7965
7966impl SseEncode for crate::model::Limits {
7967    // Codec=Sse (Serialization based), see doc to use other codecs
7968    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7969        <u64>::sse_encode(self.min_sat, serializer);
7970        <u64>::sse_encode(self.max_sat, serializer);
7971        <u64>::sse_encode(self.max_zero_conf_sat, serializer);
7972    }
7973}
7974
7975impl SseEncode for crate::bindings::LiquidAddressData {
7976    // Codec=Sse (Serialization based), see doc to use other codecs
7977    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7978        <String>::sse_encode(self.address, serializer);
7979        <crate::bindings::Network>::sse_encode(self.network, serializer);
7980        <Option<String>>::sse_encode(self.asset_id, serializer);
7981        <Option<f64>>::sse_encode(self.amount, serializer);
7982        <Option<u64>>::sse_encode(self.amount_sat, serializer);
7983        <Option<String>>::sse_encode(self.label, serializer);
7984        <Option<String>>::sse_encode(self.message, serializer);
7985    }
7986}
7987
7988impl SseEncode for crate::model::LiquidNetwork {
7989    // Codec=Sse (Serialization based), see doc to use other codecs
7990    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7991        <i32>::sse_encode(
7992            match self {
7993                crate::model::LiquidNetwork::Mainnet => 0,
7994                crate::model::LiquidNetwork::Testnet => 1,
7995                crate::model::LiquidNetwork::Regtest => 2,
7996                _ => {
7997                    unimplemented!("");
7998                }
7999            },
8000            serializer,
8001        );
8002    }
8003}
8004
8005impl SseEncode for Vec<String> {
8006    // Codec=Sse (Serialization based), see doc to use other codecs
8007    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8008        <i32>::sse_encode(self.len() as _, serializer);
8009        for item in self {
8010            <String>::sse_encode(item, serializer);
8011        }
8012    }
8013}
8014
8015impl SseEncode for Vec<crate::model::AssetBalance> {
8016    // Codec=Sse (Serialization based), see doc to use other codecs
8017    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8018        <i32>::sse_encode(self.len() as _, serializer);
8019        for item in self {
8020            <crate::model::AssetBalance>::sse_encode(item, serializer);
8021        }
8022    }
8023}
8024
8025impl SseEncode for Vec<crate::model::AssetMetadata> {
8026    // Codec=Sse (Serialization based), see doc to use other codecs
8027    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8028        <i32>::sse_encode(self.len() as _, serializer);
8029        for item in self {
8030            <crate::model::AssetMetadata>::sse_encode(item, serializer);
8031        }
8032    }
8033}
8034
8035impl SseEncode for Vec<crate::bindings::ExternalInputParser> {
8036    // Codec=Sse (Serialization based), see doc to use other codecs
8037    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8038        <i32>::sse_encode(self.len() as _, serializer);
8039        for item in self {
8040            <crate::bindings::ExternalInputParser>::sse_encode(item, serializer);
8041        }
8042    }
8043}
8044
8045impl SseEncode for Vec<crate::bindings::FiatCurrency> {
8046    // Codec=Sse (Serialization based), see doc to use other codecs
8047    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8048        <i32>::sse_encode(self.len() as _, serializer);
8049        for item in self {
8050            <crate::bindings::FiatCurrency>::sse_encode(item, serializer);
8051        }
8052    }
8053}
8054
8055impl SseEncode for Vec<crate::bindings::LnOfferBlindedPath> {
8056    // Codec=Sse (Serialization based), see doc to use other codecs
8057    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8058        <i32>::sse_encode(self.len() as _, serializer);
8059        for item in self {
8060            <crate::bindings::LnOfferBlindedPath>::sse_encode(item, serializer);
8061        }
8062    }
8063}
8064
8065impl SseEncode for Vec<crate::bindings::LocaleOverrides> {
8066    // Codec=Sse (Serialization based), see doc to use other codecs
8067    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8068        <i32>::sse_encode(self.len() as _, serializer);
8069        for item in self {
8070            <crate::bindings::LocaleOverrides>::sse_encode(item, serializer);
8071        }
8072    }
8073}
8074
8075impl SseEncode for Vec<crate::bindings::LocalizedName> {
8076    // Codec=Sse (Serialization based), see doc to use other codecs
8077    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8078        <i32>::sse_encode(self.len() as _, serializer);
8079        for item in self {
8080            <crate::bindings::LocalizedName>::sse_encode(item, serializer);
8081        }
8082    }
8083}
8084
8085impl SseEncode for Vec<crate::model::Payment> {
8086    // Codec=Sse (Serialization based), see doc to use other codecs
8087    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8088        <i32>::sse_encode(self.len() as _, serializer);
8089        for item in self {
8090            <crate::model::Payment>::sse_encode(item, serializer);
8091        }
8092    }
8093}
8094
8095impl SseEncode for crate::model::ListPaymentDetails {
8096    // Codec=Sse (Serialization based), see doc to use other codecs
8097    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8098        match self {
8099            crate::model::ListPaymentDetails::Liquid {
8100                asset_id,
8101                destination,
8102            } => {
8103                <i32>::sse_encode(0, serializer);
8104                <Option<String>>::sse_encode(asset_id, serializer);
8105                <Option<String>>::sse_encode(destination, serializer);
8106            }
8107            crate::model::ListPaymentDetails::Bitcoin { address } => {
8108                <i32>::sse_encode(1, serializer);
8109                <Option<String>>::sse_encode(address, serializer);
8110            }
8111            _ => {
8112                unimplemented!("");
8113            }
8114        }
8115    }
8116}
8117
8118impl SseEncode for Vec<crate::model::PaymentState> {
8119    // Codec=Sse (Serialization based), see doc to use other codecs
8120    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8121        <i32>::sse_encode(self.len() as _, serializer);
8122        for item in self {
8123            <crate::model::PaymentState>::sse_encode(item, serializer);
8124        }
8125    }
8126}
8127
8128impl SseEncode for Vec<crate::model::PaymentType> {
8129    // Codec=Sse (Serialization based), see doc to use other codecs
8130    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8131        <i32>::sse_encode(self.len() as _, serializer);
8132        for item in self {
8133            <crate::model::PaymentType>::sse_encode(item, serializer);
8134        }
8135    }
8136}
8137
8138impl SseEncode for crate::model::ListPaymentsRequest {
8139    // Codec=Sse (Serialization based), see doc to use other codecs
8140    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8141        <Option<Vec<crate::model::PaymentType>>>::sse_encode(self.filters, serializer);
8142        <Option<Vec<crate::model::PaymentState>>>::sse_encode(self.states, serializer);
8143        <Option<i64>>::sse_encode(self.from_timestamp, serializer);
8144        <Option<i64>>::sse_encode(self.to_timestamp, serializer);
8145        <Option<u32>>::sse_encode(self.offset, serializer);
8146        <Option<u32>>::sse_encode(self.limit, serializer);
8147        <Option<crate::model::ListPaymentDetails>>::sse_encode(self.details, serializer);
8148        <Option<bool>>::sse_encode(self.sort_ascending, serializer);
8149    }
8150}
8151
8152impl SseEncode for Vec<u8> {
8153    // Codec=Sse (Serialization based), see doc to use other codecs
8154    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8155        <i32>::sse_encode(self.len() as _, serializer);
8156        for item in self {
8157            <u8>::sse_encode(item, serializer);
8158        }
8159    }
8160}
8161
8162impl SseEncode for Vec<crate::bindings::Rate> {
8163    // Codec=Sse (Serialization based), see doc to use other codecs
8164    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8165        <i32>::sse_encode(self.len() as _, serializer);
8166        for item in self {
8167            <crate::bindings::Rate>::sse_encode(item, serializer);
8168        }
8169    }
8170}
8171
8172impl SseEncode for Vec<crate::model::RefundableSwap> {
8173    // Codec=Sse (Serialization based), see doc to use other codecs
8174    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8175        <i32>::sse_encode(self.len() as _, serializer);
8176        for item in self {
8177            <crate::model::RefundableSwap>::sse_encode(item, serializer);
8178        }
8179    }
8180}
8181
8182impl SseEncode for Vec<crate::bindings::RouteHint> {
8183    // Codec=Sse (Serialization based), see doc to use other codecs
8184    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8185        <i32>::sse_encode(self.len() as _, serializer);
8186        for item in self {
8187            <crate::bindings::RouteHint>::sse_encode(item, serializer);
8188        }
8189    }
8190}
8191
8192impl SseEncode for Vec<crate::bindings::RouteHintHop> {
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        <i32>::sse_encode(self.len() as _, serializer);
8196        for item in self {
8197            <crate::bindings::RouteHintHop>::sse_encode(item, serializer);
8198        }
8199    }
8200}
8201
8202impl SseEncode for crate::bindings::LNInvoice {
8203    // Codec=Sse (Serialization based), see doc to use other codecs
8204    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8205        <String>::sse_encode(self.bolt11, serializer);
8206        <crate::bindings::Network>::sse_encode(self.network, serializer);
8207        <String>::sse_encode(self.payee_pubkey, serializer);
8208        <String>::sse_encode(self.payment_hash, serializer);
8209        <Option<String>>::sse_encode(self.description, serializer);
8210        <Option<String>>::sse_encode(self.description_hash, serializer);
8211        <Option<u64>>::sse_encode(self.amount_msat, serializer);
8212        <u64>::sse_encode(self.timestamp, serializer);
8213        <u64>::sse_encode(self.expiry, serializer);
8214        <Vec<crate::bindings::RouteHint>>::sse_encode(self.routing_hints, serializer);
8215        <Vec<u8>>::sse_encode(self.payment_secret, serializer);
8216        <u64>::sse_encode(self.min_final_cltv_expiry_delta, serializer);
8217    }
8218}
8219
8220impl SseEncode for crate::bindings::LNOffer {
8221    // Codec=Sse (Serialization based), see doc to use other codecs
8222    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8223        <String>::sse_encode(self.offer, serializer);
8224        <Vec<String>>::sse_encode(self.chains, serializer);
8225        <Option<crate::bindings::Amount>>::sse_encode(self.min_amount, serializer);
8226        <Option<String>>::sse_encode(self.description, serializer);
8227        <Option<u64>>::sse_encode(self.absolute_expiry, serializer);
8228        <Option<String>>::sse_encode(self.issuer, serializer);
8229        <Option<String>>::sse_encode(self.signing_pubkey, serializer);
8230        <Vec<crate::bindings::LnOfferBlindedPath>>::sse_encode(self.paths, serializer);
8231    }
8232}
8233
8234impl SseEncode for crate::bindings::LnOfferBlindedPath {
8235    // Codec=Sse (Serialization based), see doc to use other codecs
8236    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8237        <Vec<String>>::sse_encode(self.blinded_hops, serializer);
8238    }
8239}
8240
8241impl SseEncode for crate::bindings::duplicates::LnUrlAuthError {
8242    // Codec=Sse (Serialization based), see doc to use other codecs
8243    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8244        match self {
8245            crate::bindings::duplicates::LnUrlAuthError::Generic { err } => {
8246                <i32>::sse_encode(0, serializer);
8247                <String>::sse_encode(err, serializer);
8248            }
8249            crate::bindings::duplicates::LnUrlAuthError::InvalidUri { err } => {
8250                <i32>::sse_encode(1, serializer);
8251                <String>::sse_encode(err, serializer);
8252            }
8253            crate::bindings::duplicates::LnUrlAuthError::ServiceConnectivity { err } => {
8254                <i32>::sse_encode(2, serializer);
8255                <String>::sse_encode(err, serializer);
8256            }
8257            _ => {
8258                unimplemented!("");
8259            }
8260        }
8261    }
8262}
8263
8264impl SseEncode for crate::bindings::LnUrlAuthRequestData {
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.k1, serializer);
8268        <Option<String>>::sse_encode(self.action, serializer);
8269        <String>::sse_encode(self.domain, serializer);
8270        <String>::sse_encode(self.url, serializer);
8271    }
8272}
8273
8274impl SseEncode for crate::bindings::duplicates::LnUrlCallbackStatus {
8275    // Codec=Sse (Serialization based), see doc to use other codecs
8276    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8277        match self {
8278            crate::bindings::duplicates::LnUrlCallbackStatus::Ok => {
8279                <i32>::sse_encode(0, serializer);
8280            }
8281            crate::bindings::duplicates::LnUrlCallbackStatus::ErrorStatus { data } => {
8282                <i32>::sse_encode(1, serializer);
8283                <crate::bindings::LnUrlErrorData>::sse_encode(data, serializer);
8284            }
8285            _ => {
8286                unimplemented!("");
8287            }
8288        }
8289    }
8290}
8291
8292impl SseEncode for crate::bindings::LnUrlErrorData {
8293    // Codec=Sse (Serialization based), see doc to use other codecs
8294    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8295        <String>::sse_encode(self.reason, serializer);
8296    }
8297}
8298
8299impl SseEncode for crate::model::LnUrlInfo {
8300    // Codec=Sse (Serialization based), see doc to use other codecs
8301    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8302        <Option<String>>::sse_encode(self.ln_address, serializer);
8303        <Option<String>>::sse_encode(self.lnurl_pay_comment, serializer);
8304        <Option<String>>::sse_encode(self.lnurl_pay_domain, serializer);
8305        <Option<String>>::sse_encode(self.lnurl_pay_metadata, serializer);
8306        <Option<crate::bindings::SuccessActionProcessed>>::sse_encode(
8307            self.lnurl_pay_success_action,
8308            serializer,
8309        );
8310        <Option<crate::bindings::SuccessAction>>::sse_encode(
8311            self.lnurl_pay_unprocessed_success_action,
8312            serializer,
8313        );
8314        <Option<String>>::sse_encode(self.lnurl_withdraw_endpoint, serializer);
8315    }
8316}
8317
8318impl SseEncode for crate::bindings::duplicates::LnUrlPayError {
8319    // Codec=Sse (Serialization based), see doc to use other codecs
8320    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8321        match self {
8322            crate::bindings::duplicates::LnUrlPayError::AlreadyPaid => {
8323                <i32>::sse_encode(0, serializer);
8324            }
8325            crate::bindings::duplicates::LnUrlPayError::Generic { err } => {
8326                <i32>::sse_encode(1, serializer);
8327                <String>::sse_encode(err, serializer);
8328            }
8329            crate::bindings::duplicates::LnUrlPayError::InsufficientBalance { err } => {
8330                <i32>::sse_encode(2, serializer);
8331                <String>::sse_encode(err, serializer);
8332            }
8333            crate::bindings::duplicates::LnUrlPayError::InvalidAmount { err } => {
8334                <i32>::sse_encode(3, serializer);
8335                <String>::sse_encode(err, serializer);
8336            }
8337            crate::bindings::duplicates::LnUrlPayError::InvalidInvoice { err } => {
8338                <i32>::sse_encode(4, serializer);
8339                <String>::sse_encode(err, serializer);
8340            }
8341            crate::bindings::duplicates::LnUrlPayError::InvalidNetwork { err } => {
8342                <i32>::sse_encode(5, serializer);
8343                <String>::sse_encode(err, serializer);
8344            }
8345            crate::bindings::duplicates::LnUrlPayError::InvalidUri { err } => {
8346                <i32>::sse_encode(6, serializer);
8347                <String>::sse_encode(err, serializer);
8348            }
8349            crate::bindings::duplicates::LnUrlPayError::InvoiceExpired { err } => {
8350                <i32>::sse_encode(7, serializer);
8351                <String>::sse_encode(err, serializer);
8352            }
8353            crate::bindings::duplicates::LnUrlPayError::PaymentFailed { err } => {
8354                <i32>::sse_encode(8, serializer);
8355                <String>::sse_encode(err, serializer);
8356            }
8357            crate::bindings::duplicates::LnUrlPayError::PaymentTimeout { err } => {
8358                <i32>::sse_encode(9, serializer);
8359                <String>::sse_encode(err, serializer);
8360            }
8361            crate::bindings::duplicates::LnUrlPayError::RouteNotFound { err } => {
8362                <i32>::sse_encode(10, serializer);
8363                <String>::sse_encode(err, serializer);
8364            }
8365            crate::bindings::duplicates::LnUrlPayError::RouteTooExpensive { err } => {
8366                <i32>::sse_encode(11, serializer);
8367                <String>::sse_encode(err, serializer);
8368            }
8369            crate::bindings::duplicates::LnUrlPayError::ServiceConnectivity { err } => {
8370                <i32>::sse_encode(12, serializer);
8371                <String>::sse_encode(err, serializer);
8372            }
8373            _ => {
8374                unimplemented!("");
8375            }
8376        }
8377    }
8378}
8379
8380impl SseEncode for crate::bindings::LnUrlPayErrorData {
8381    // Codec=Sse (Serialization based), see doc to use other codecs
8382    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8383        <String>::sse_encode(self.payment_hash, serializer);
8384        <String>::sse_encode(self.reason, serializer);
8385    }
8386}
8387
8388impl SseEncode for crate::model::LnUrlPayRequest {
8389    // Codec=Sse (Serialization based), see doc to use other codecs
8390    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8391        <crate::model::PrepareLnUrlPayResponse>::sse_encode(self.prepare_response, serializer);
8392    }
8393}
8394
8395impl SseEncode for crate::bindings::LnUrlPayRequestData {
8396    // Codec=Sse (Serialization based), see doc to use other codecs
8397    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8398        <String>::sse_encode(self.callback, serializer);
8399        <u64>::sse_encode(self.min_sendable, serializer);
8400        <u64>::sse_encode(self.max_sendable, serializer);
8401        <String>::sse_encode(self.metadata_str, serializer);
8402        <u16>::sse_encode(self.comment_allowed, serializer);
8403        <String>::sse_encode(self.domain, serializer);
8404        <bool>::sse_encode(self.allows_nostr, serializer);
8405        <Option<String>>::sse_encode(self.nostr_pubkey, serializer);
8406        <Option<String>>::sse_encode(self.ln_address, serializer);
8407    }
8408}
8409
8410impl SseEncode for crate::model::LnUrlPayResult {
8411    // Codec=Sse (Serialization based), see doc to use other codecs
8412    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8413        match self {
8414            crate::model::LnUrlPayResult::EndpointSuccess { data } => {
8415                <i32>::sse_encode(0, serializer);
8416                <crate::model::LnUrlPaySuccessData>::sse_encode(data, serializer);
8417            }
8418            crate::model::LnUrlPayResult::EndpointError { data } => {
8419                <i32>::sse_encode(1, serializer);
8420                <crate::bindings::LnUrlErrorData>::sse_encode(data, serializer);
8421            }
8422            crate::model::LnUrlPayResult::PayError { data } => {
8423                <i32>::sse_encode(2, serializer);
8424                <crate::bindings::LnUrlPayErrorData>::sse_encode(data, serializer);
8425            }
8426            _ => {
8427                unimplemented!("");
8428            }
8429        }
8430    }
8431}
8432
8433impl SseEncode for crate::model::LnUrlPaySuccessData {
8434    // Codec=Sse (Serialization based), see doc to use other codecs
8435    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8436        <crate::model::Payment>::sse_encode(self.payment, serializer);
8437        <Option<crate::bindings::SuccessActionProcessed>>::sse_encode(
8438            self.success_action,
8439            serializer,
8440        );
8441    }
8442}
8443
8444impl SseEncode for crate::bindings::duplicates::LnUrlWithdrawError {
8445    // Codec=Sse (Serialization based), see doc to use other codecs
8446    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8447        match self {
8448            crate::bindings::duplicates::LnUrlWithdrawError::Generic { err } => {
8449                <i32>::sse_encode(0, serializer);
8450                <String>::sse_encode(err, serializer);
8451            }
8452            crate::bindings::duplicates::LnUrlWithdrawError::InvalidAmount { err } => {
8453                <i32>::sse_encode(1, serializer);
8454                <String>::sse_encode(err, serializer);
8455            }
8456            crate::bindings::duplicates::LnUrlWithdrawError::InvalidInvoice { err } => {
8457                <i32>::sse_encode(2, serializer);
8458                <String>::sse_encode(err, serializer);
8459            }
8460            crate::bindings::duplicates::LnUrlWithdrawError::InvalidUri { err } => {
8461                <i32>::sse_encode(3, serializer);
8462                <String>::sse_encode(err, serializer);
8463            }
8464            crate::bindings::duplicates::LnUrlWithdrawError::InvoiceNoRoutingHints { err } => {
8465                <i32>::sse_encode(4, serializer);
8466                <String>::sse_encode(err, serializer);
8467            }
8468            crate::bindings::duplicates::LnUrlWithdrawError::ServiceConnectivity { err } => {
8469                <i32>::sse_encode(5, serializer);
8470                <String>::sse_encode(err, serializer);
8471            }
8472            _ => {
8473                unimplemented!("");
8474            }
8475        }
8476    }
8477}
8478
8479impl SseEncode for crate::bindings::LnUrlWithdrawRequest {
8480    // Codec=Sse (Serialization based), see doc to use other codecs
8481    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8482        <crate::bindings::LnUrlWithdrawRequestData>::sse_encode(self.data, serializer);
8483        <u64>::sse_encode(self.amount_msat, serializer);
8484        <Option<String>>::sse_encode(self.description, serializer);
8485    }
8486}
8487
8488impl SseEncode for crate::bindings::LnUrlWithdrawRequestData {
8489    // Codec=Sse (Serialization based), see doc to use other codecs
8490    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8491        <String>::sse_encode(self.callback, serializer);
8492        <String>::sse_encode(self.k1, serializer);
8493        <String>::sse_encode(self.default_description, serializer);
8494        <u64>::sse_encode(self.min_withdrawable, serializer);
8495        <u64>::sse_encode(self.max_withdrawable, serializer);
8496    }
8497}
8498
8499impl SseEncode for crate::bindings::duplicates::LnUrlWithdrawResult {
8500    // Codec=Sse (Serialization based), see doc to use other codecs
8501    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8502        match self {
8503            crate::bindings::duplicates::LnUrlWithdrawResult::Ok { data } => {
8504                <i32>::sse_encode(0, serializer);
8505                <crate::bindings::duplicates::LnUrlWithdrawSuccessData>::sse_encode(
8506                    data, serializer,
8507                );
8508            }
8509            crate::bindings::duplicates::LnUrlWithdrawResult::Timeout { data } => {
8510                <i32>::sse_encode(1, serializer);
8511                <crate::bindings::duplicates::LnUrlWithdrawSuccessData>::sse_encode(
8512                    data, serializer,
8513                );
8514            }
8515            crate::bindings::duplicates::LnUrlWithdrawResult::ErrorStatus { data } => {
8516                <i32>::sse_encode(2, serializer);
8517                <crate::bindings::LnUrlErrorData>::sse_encode(data, serializer);
8518            }
8519            _ => {
8520                unimplemented!("");
8521            }
8522        }
8523    }
8524}
8525
8526impl SseEncode for crate::bindings::duplicates::LnUrlWithdrawSuccessData {
8527    // Codec=Sse (Serialization based), see doc to use other codecs
8528    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8529        <crate::bindings::LNInvoice>::sse_encode(self.invoice, serializer);
8530    }
8531}
8532
8533impl SseEncode for crate::bindings::LocaleOverrides {
8534    // Codec=Sse (Serialization based), see doc to use other codecs
8535    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8536        <String>::sse_encode(self.locale, serializer);
8537        <Option<u32>>::sse_encode(self.spacing, serializer);
8538        <crate::bindings::Symbol>::sse_encode(self.symbol, serializer);
8539    }
8540}
8541
8542impl SseEncode for crate::bindings::LocalizedName {
8543    // Codec=Sse (Serialization based), see doc to use other codecs
8544    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8545        <String>::sse_encode(self.locale, serializer);
8546        <String>::sse_encode(self.name, serializer);
8547    }
8548}
8549
8550impl SseEncode for crate::model::LogEntry {
8551    // Codec=Sse (Serialization based), see doc to use other codecs
8552    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8553        <String>::sse_encode(self.line, serializer);
8554        <String>::sse_encode(self.level, serializer);
8555    }
8556}
8557
8558impl SseEncode for crate::bindings::MessageSuccessActionData {
8559    // Codec=Sse (Serialization based), see doc to use other codecs
8560    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8561        <String>::sse_encode(self.message, serializer);
8562    }
8563}
8564
8565impl SseEncode for crate::bindings::Network {
8566    // Codec=Sse (Serialization based), see doc to use other codecs
8567    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8568        <i32>::sse_encode(
8569            match self {
8570                crate::bindings::Network::Bitcoin => 0,
8571                crate::bindings::Network::Testnet => 1,
8572                crate::bindings::Network::Signet => 2,
8573                crate::bindings::Network::Regtest => 3,
8574                _ => {
8575                    unimplemented!("");
8576                }
8577            },
8578            serializer,
8579        );
8580    }
8581}
8582
8583impl SseEncode for crate::model::OnchainPaymentLimitsResponse {
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        <crate::model::Limits>::sse_encode(self.send, serializer);
8587        <crate::model::Limits>::sse_encode(self.receive, serializer);
8588    }
8589}
8590
8591impl SseEncode for Option<String> {
8592    // Codec=Sse (Serialization based), see doc to use other codecs
8593    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8594        <bool>::sse_encode(self.is_some(), serializer);
8595        if let Some(value) = self {
8596            <String>::sse_encode(value, serializer);
8597        }
8598    }
8599}
8600
8601impl SseEncode for Option<crate::bindings::Amount> {
8602    // Codec=Sse (Serialization based), see doc to use other codecs
8603    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8604        <bool>::sse_encode(self.is_some(), serializer);
8605        if let Some(value) = self {
8606            <crate::bindings::Amount>::sse_encode(value, serializer);
8607        }
8608    }
8609}
8610
8611impl SseEncode for Option<crate::model::AssetInfo> {
8612    // Codec=Sse (Serialization based), see doc to use other codecs
8613    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8614        <bool>::sse_encode(self.is_some(), serializer);
8615        if let Some(value) = self {
8616            <crate::model::AssetInfo>::sse_encode(value, serializer);
8617        }
8618    }
8619}
8620
8621impl SseEncode for Option<bool> {
8622    // Codec=Sse (Serialization based), see doc to use other codecs
8623    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8624        <bool>::sse_encode(self.is_some(), serializer);
8625        if let Some(value) = self {
8626            <bool>::sse_encode(value, serializer);
8627        }
8628    }
8629}
8630
8631impl SseEncode for Option<f64> {
8632    // Codec=Sse (Serialization based), see doc to use other codecs
8633    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8634        <bool>::sse_encode(self.is_some(), serializer);
8635        if let Some(value) = self {
8636            <f64>::sse_encode(value, serializer);
8637        }
8638    }
8639}
8640
8641impl SseEncode for Option<i64> {
8642    // Codec=Sse (Serialization based), see doc to use other codecs
8643    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8644        <bool>::sse_encode(self.is_some(), serializer);
8645        if let Some(value) = self {
8646            <i64>::sse_encode(value, serializer);
8647        }
8648    }
8649}
8650
8651impl SseEncode for Option<crate::model::ListPaymentDetails> {
8652    // Codec=Sse (Serialization based), see doc to use other codecs
8653    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8654        <bool>::sse_encode(self.is_some(), serializer);
8655        if let Some(value) = self {
8656            <crate::model::ListPaymentDetails>::sse_encode(value, serializer);
8657        }
8658    }
8659}
8660
8661impl SseEncode for Option<crate::model::LnUrlInfo> {
8662    // Codec=Sse (Serialization based), see doc to use other codecs
8663    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8664        <bool>::sse_encode(self.is_some(), serializer);
8665        if let Some(value) = self {
8666            <crate::model::LnUrlInfo>::sse_encode(value, serializer);
8667        }
8668    }
8669}
8670
8671impl SseEncode for Option<crate::model::PayAmount> {
8672    // Codec=Sse (Serialization based), see doc to use other codecs
8673    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8674        <bool>::sse_encode(self.is_some(), serializer);
8675        if let Some(value) = self {
8676            <crate::model::PayAmount>::sse_encode(value, serializer);
8677        }
8678    }
8679}
8680
8681impl SseEncode for Option<crate::model::Payment> {
8682    // Codec=Sse (Serialization based), see doc to use other codecs
8683    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8684        <bool>::sse_encode(self.is_some(), serializer);
8685        if let Some(value) = self {
8686            <crate::model::Payment>::sse_encode(value, serializer);
8687        }
8688    }
8689}
8690
8691impl SseEncode for Option<crate::model::ReceiveAmount> {
8692    // Codec=Sse (Serialization based), see doc to use other codecs
8693    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8694        <bool>::sse_encode(self.is_some(), serializer);
8695        if let Some(value) = self {
8696            <crate::model::ReceiveAmount>::sse_encode(value, serializer);
8697        }
8698    }
8699}
8700
8701impl SseEncode for Option<crate::bindings::SuccessAction> {
8702    // Codec=Sse (Serialization based), see doc to use other codecs
8703    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8704        <bool>::sse_encode(self.is_some(), serializer);
8705        if let Some(value) = self {
8706            <crate::bindings::SuccessAction>::sse_encode(value, serializer);
8707        }
8708    }
8709}
8710
8711impl SseEncode for Option<crate::bindings::SuccessActionProcessed> {
8712    // Codec=Sse (Serialization based), see doc to use other codecs
8713    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8714        <bool>::sse_encode(self.is_some(), serializer);
8715        if let Some(value) = self {
8716            <crate::bindings::SuccessActionProcessed>::sse_encode(value, serializer);
8717        }
8718    }
8719}
8720
8721impl SseEncode for Option<crate::bindings::Symbol> {
8722    // Codec=Sse (Serialization based), see doc to use other codecs
8723    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8724        <bool>::sse_encode(self.is_some(), serializer);
8725        if let Some(value) = self {
8726            <crate::bindings::Symbol>::sse_encode(value, serializer);
8727        }
8728    }
8729}
8730
8731impl SseEncode for Option<u32> {
8732    // Codec=Sse (Serialization based), see doc to use other codecs
8733    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8734        <bool>::sse_encode(self.is_some(), serializer);
8735        if let Some(value) = self {
8736            <u32>::sse_encode(value, serializer);
8737        }
8738    }
8739}
8740
8741impl SseEncode for Option<u64> {
8742    // Codec=Sse (Serialization based), see doc to use other codecs
8743    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8744        <bool>::sse_encode(self.is_some(), serializer);
8745        if let Some(value) = self {
8746            <u64>::sse_encode(value, serializer);
8747        }
8748    }
8749}
8750
8751impl SseEncode for Option<Vec<crate::model::AssetMetadata>> {
8752    // Codec=Sse (Serialization based), see doc to use other codecs
8753    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8754        <bool>::sse_encode(self.is_some(), serializer);
8755        if let Some(value) = self {
8756            <Vec<crate::model::AssetMetadata>>::sse_encode(value, serializer);
8757        }
8758    }
8759}
8760
8761impl SseEncode for Option<Vec<crate::bindings::ExternalInputParser>> {
8762    // Codec=Sse (Serialization based), see doc to use other codecs
8763    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8764        <bool>::sse_encode(self.is_some(), serializer);
8765        if let Some(value) = self {
8766            <Vec<crate::bindings::ExternalInputParser>>::sse_encode(value, serializer);
8767        }
8768    }
8769}
8770
8771impl SseEncode for Option<Vec<crate::model::PaymentState>> {
8772    // Codec=Sse (Serialization based), see doc to use other codecs
8773    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8774        <bool>::sse_encode(self.is_some(), serializer);
8775        if let Some(value) = self {
8776            <Vec<crate::model::PaymentState>>::sse_encode(value, serializer);
8777        }
8778    }
8779}
8780
8781impl SseEncode for Option<Vec<crate::model::PaymentType>> {
8782    // Codec=Sse (Serialization based), see doc to use other codecs
8783    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8784        <bool>::sse_encode(self.is_some(), serializer);
8785        if let Some(value) = self {
8786            <Vec<crate::model::PaymentType>>::sse_encode(value, serializer);
8787        }
8788    }
8789}
8790
8791impl SseEncode for Option<Vec<u8>> {
8792    // Codec=Sse (Serialization based), see doc to use other codecs
8793    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8794        <bool>::sse_encode(self.is_some(), serializer);
8795        if let Some(value) = self {
8796            <Vec<u8>>::sse_encode(value, serializer);
8797        }
8798    }
8799}
8800
8801impl SseEncode for crate::model::PayAmount {
8802    // Codec=Sse (Serialization based), see doc to use other codecs
8803    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8804        match self {
8805            crate::model::PayAmount::Bitcoin {
8806                receiver_amount_sat,
8807            } => {
8808                <i32>::sse_encode(0, serializer);
8809                <u64>::sse_encode(receiver_amount_sat, serializer);
8810            }
8811            crate::model::PayAmount::Asset {
8812                asset_id,
8813                receiver_amount,
8814                estimate_asset_fees,
8815                pay_with_bitcoin,
8816            } => {
8817                <i32>::sse_encode(1, serializer);
8818                <String>::sse_encode(asset_id, serializer);
8819                <f64>::sse_encode(receiver_amount, serializer);
8820                <Option<bool>>::sse_encode(estimate_asset_fees, serializer);
8821                <Option<bool>>::sse_encode(pay_with_bitcoin, serializer);
8822            }
8823            crate::model::PayAmount::Drain => {
8824                <i32>::sse_encode(2, serializer);
8825            }
8826            _ => {
8827                unimplemented!("");
8828            }
8829        }
8830    }
8831}
8832
8833impl SseEncode for crate::model::PayOnchainRequest {
8834    // Codec=Sse (Serialization based), see doc to use other codecs
8835    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8836        <String>::sse_encode(self.address, serializer);
8837        <crate::model::PreparePayOnchainResponse>::sse_encode(self.prepare_response, serializer);
8838    }
8839}
8840
8841impl SseEncode for crate::model::Payment {
8842    // Codec=Sse (Serialization based), see doc to use other codecs
8843    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8844        <Option<String>>::sse_encode(self.destination, serializer);
8845        <Option<String>>::sse_encode(self.tx_id, serializer);
8846        <Option<String>>::sse_encode(self.unblinding_data, serializer);
8847        <u32>::sse_encode(self.timestamp, serializer);
8848        <u64>::sse_encode(self.amount_sat, serializer);
8849        <u64>::sse_encode(self.fees_sat, serializer);
8850        <Option<u64>>::sse_encode(self.swapper_fees_sat, serializer);
8851        <crate::model::PaymentType>::sse_encode(self.payment_type, serializer);
8852        <crate::model::PaymentState>::sse_encode(self.status, serializer);
8853        <crate::model::PaymentDetails>::sse_encode(self.details, serializer);
8854    }
8855}
8856
8857impl SseEncode for crate::model::PaymentDetails {
8858    // Codec=Sse (Serialization based), see doc to use other codecs
8859    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8860        match self {
8861            crate::model::PaymentDetails::Lightning {
8862                swap_id,
8863                description,
8864                liquid_expiration_blockheight,
8865                preimage,
8866                invoice,
8867                bolt12_offer,
8868                payment_hash,
8869                destination_pubkey,
8870                lnurl_info,
8871                bip353_address,
8872                payer_note,
8873                claim_tx_id,
8874                refund_tx_id,
8875                refund_tx_amount_sat,
8876            } => {
8877                <i32>::sse_encode(0, serializer);
8878                <String>::sse_encode(swap_id, serializer);
8879                <String>::sse_encode(description, serializer);
8880                <u32>::sse_encode(liquid_expiration_blockheight, serializer);
8881                <Option<String>>::sse_encode(preimage, serializer);
8882                <Option<String>>::sse_encode(invoice, serializer);
8883                <Option<String>>::sse_encode(bolt12_offer, serializer);
8884                <Option<String>>::sse_encode(payment_hash, serializer);
8885                <Option<String>>::sse_encode(destination_pubkey, serializer);
8886                <Option<crate::model::LnUrlInfo>>::sse_encode(lnurl_info, serializer);
8887                <Option<String>>::sse_encode(bip353_address, serializer);
8888                <Option<String>>::sse_encode(payer_note, serializer);
8889                <Option<String>>::sse_encode(claim_tx_id, serializer);
8890                <Option<String>>::sse_encode(refund_tx_id, serializer);
8891                <Option<u64>>::sse_encode(refund_tx_amount_sat, serializer);
8892            }
8893            crate::model::PaymentDetails::Liquid {
8894                destination,
8895                description,
8896                asset_id,
8897                asset_info,
8898                lnurl_info,
8899                bip353_address,
8900                payer_note,
8901            } => {
8902                <i32>::sse_encode(1, serializer);
8903                <String>::sse_encode(destination, serializer);
8904                <String>::sse_encode(description, serializer);
8905                <String>::sse_encode(asset_id, serializer);
8906                <Option<crate::model::AssetInfo>>::sse_encode(asset_info, serializer);
8907                <Option<crate::model::LnUrlInfo>>::sse_encode(lnurl_info, serializer);
8908                <Option<String>>::sse_encode(bip353_address, serializer);
8909                <Option<String>>::sse_encode(payer_note, serializer);
8910            }
8911            crate::model::PaymentDetails::Bitcoin {
8912                swap_id,
8913                bitcoin_address,
8914                description,
8915                auto_accepted_fees,
8916                liquid_expiration_blockheight,
8917                bitcoin_expiration_blockheight,
8918                lockup_tx_id,
8919                claim_tx_id,
8920                refund_tx_id,
8921                refund_tx_amount_sat,
8922            } => {
8923                <i32>::sse_encode(2, serializer);
8924                <String>::sse_encode(swap_id, serializer);
8925                <String>::sse_encode(bitcoin_address, serializer);
8926                <String>::sse_encode(description, serializer);
8927                <bool>::sse_encode(auto_accepted_fees, serializer);
8928                <Option<u32>>::sse_encode(liquid_expiration_blockheight, serializer);
8929                <Option<u32>>::sse_encode(bitcoin_expiration_blockheight, serializer);
8930                <Option<String>>::sse_encode(lockup_tx_id, serializer);
8931                <Option<String>>::sse_encode(claim_tx_id, serializer);
8932                <Option<String>>::sse_encode(refund_tx_id, serializer);
8933                <Option<u64>>::sse_encode(refund_tx_amount_sat, serializer);
8934            }
8935            _ => {
8936                unimplemented!("");
8937            }
8938        }
8939    }
8940}
8941
8942impl SseEncode for crate::error::PaymentError {
8943    // Codec=Sse (Serialization based), see doc to use other codecs
8944    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8945        match self {
8946            crate::error::PaymentError::AlreadyClaimed => {
8947                <i32>::sse_encode(0, serializer);
8948            }
8949            crate::error::PaymentError::AlreadyPaid => {
8950                <i32>::sse_encode(1, serializer);
8951            }
8952            crate::error::PaymentError::PaymentInProgress => {
8953                <i32>::sse_encode(2, serializer);
8954            }
8955            crate::error::PaymentError::AmountOutOfRange { min, max } => {
8956                <i32>::sse_encode(3, serializer);
8957                <u64>::sse_encode(min, serializer);
8958                <u64>::sse_encode(max, serializer);
8959            }
8960            crate::error::PaymentError::AmountMissing { err } => {
8961                <i32>::sse_encode(4, serializer);
8962                <String>::sse_encode(err, serializer);
8963            }
8964            crate::error::PaymentError::AssetError { err } => {
8965                <i32>::sse_encode(5, serializer);
8966                <String>::sse_encode(err, serializer);
8967            }
8968            crate::error::PaymentError::InvalidNetwork { err } => {
8969                <i32>::sse_encode(6, serializer);
8970                <String>::sse_encode(err, serializer);
8971            }
8972            crate::error::PaymentError::Generic { err } => {
8973                <i32>::sse_encode(7, serializer);
8974                <String>::sse_encode(err, serializer);
8975            }
8976            crate::error::PaymentError::InvalidOrExpiredFees => {
8977                <i32>::sse_encode(8, serializer);
8978            }
8979            crate::error::PaymentError::InsufficientFunds => {
8980                <i32>::sse_encode(9, serializer);
8981            }
8982            crate::error::PaymentError::InvalidDescription { err } => {
8983                <i32>::sse_encode(10, serializer);
8984                <String>::sse_encode(err, serializer);
8985            }
8986            crate::error::PaymentError::InvalidInvoice { err } => {
8987                <i32>::sse_encode(11, serializer);
8988                <String>::sse_encode(err, serializer);
8989            }
8990            crate::error::PaymentError::InvalidPreimage => {
8991                <i32>::sse_encode(12, serializer);
8992            }
8993            crate::error::PaymentError::PairsNotFound => {
8994                <i32>::sse_encode(13, serializer);
8995            }
8996            crate::error::PaymentError::PaymentTimeout => {
8997                <i32>::sse_encode(14, serializer);
8998            }
8999            crate::error::PaymentError::PersistError => {
9000                <i32>::sse_encode(15, serializer);
9001            }
9002            crate::error::PaymentError::ReceiveError { err } => {
9003                <i32>::sse_encode(16, serializer);
9004                <String>::sse_encode(err, serializer);
9005            }
9006            crate::error::PaymentError::Refunded { err, refund_tx_id } => {
9007                <i32>::sse_encode(17, serializer);
9008                <String>::sse_encode(err, serializer);
9009                <String>::sse_encode(refund_tx_id, serializer);
9010            }
9011            crate::error::PaymentError::SelfTransferNotSupported => {
9012                <i32>::sse_encode(18, serializer);
9013            }
9014            crate::error::PaymentError::SendError { err } => {
9015                <i32>::sse_encode(19, serializer);
9016                <String>::sse_encode(err, serializer);
9017            }
9018            crate::error::PaymentError::SignerError { err } => {
9019                <i32>::sse_encode(20, serializer);
9020                <String>::sse_encode(err, serializer);
9021            }
9022            _ => {
9023                unimplemented!("");
9024            }
9025        }
9026    }
9027}
9028
9029impl SseEncode for crate::model::PaymentMethod {
9030    // Codec=Sse (Serialization based), see doc to use other codecs
9031    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9032        <i32>::sse_encode(
9033            match self {
9034                crate::model::PaymentMethod::Lightning => 0,
9035                crate::model::PaymentMethod::Bolt11Invoice => 1,
9036                crate::model::PaymentMethod::Bolt12Offer => 2,
9037                crate::model::PaymentMethod::BitcoinAddress => 3,
9038                crate::model::PaymentMethod::LiquidAddress => 4,
9039                _ => {
9040                    unimplemented!("");
9041                }
9042            },
9043            serializer,
9044        );
9045    }
9046}
9047
9048impl SseEncode for crate::model::PaymentState {
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        <i32>::sse_encode(
9052            match self {
9053                crate::model::PaymentState::Created => 0,
9054                crate::model::PaymentState::Pending => 1,
9055                crate::model::PaymentState::Complete => 2,
9056                crate::model::PaymentState::Failed => 3,
9057                crate::model::PaymentState::TimedOut => 4,
9058                crate::model::PaymentState::Refundable => 5,
9059                crate::model::PaymentState::RefundPending => 6,
9060                crate::model::PaymentState::WaitingFeeAcceptance => 7,
9061                _ => {
9062                    unimplemented!("");
9063                }
9064            },
9065            serializer,
9066        );
9067    }
9068}
9069
9070impl SseEncode for crate::model::PaymentType {
9071    // Codec=Sse (Serialization based), see doc to use other codecs
9072    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9073        <i32>::sse_encode(
9074            match self {
9075                crate::model::PaymentType::Receive => 0,
9076                crate::model::PaymentType::Send => 1,
9077                _ => {
9078                    unimplemented!("");
9079                }
9080            },
9081            serializer,
9082        );
9083    }
9084}
9085
9086impl SseEncode for crate::model::PrepareBuyBitcoinRequest {
9087    // Codec=Sse (Serialization based), see doc to use other codecs
9088    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9089        <crate::model::BuyBitcoinProvider>::sse_encode(self.provider, serializer);
9090        <u64>::sse_encode(self.amount_sat, serializer);
9091    }
9092}
9093
9094impl SseEncode for crate::model::PrepareBuyBitcoinResponse {
9095    // Codec=Sse (Serialization based), see doc to use other codecs
9096    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9097        <crate::model::BuyBitcoinProvider>::sse_encode(self.provider, serializer);
9098        <u64>::sse_encode(self.amount_sat, serializer);
9099        <u64>::sse_encode(self.fees_sat, serializer);
9100    }
9101}
9102
9103impl SseEncode for crate::model::PrepareLnUrlPayRequest {
9104    // Codec=Sse (Serialization based), see doc to use other codecs
9105    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9106        <crate::bindings::LnUrlPayRequestData>::sse_encode(self.data, serializer);
9107        <crate::model::PayAmount>::sse_encode(self.amount, serializer);
9108        <Option<String>>::sse_encode(self.bip353_address, serializer);
9109        <Option<String>>::sse_encode(self.comment, serializer);
9110        <Option<bool>>::sse_encode(self.validate_success_action_url, serializer);
9111    }
9112}
9113
9114impl SseEncode for crate::model::PrepareLnUrlPayResponse {
9115    // Codec=Sse (Serialization based), see doc to use other codecs
9116    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9117        <crate::model::SendDestination>::sse_encode(self.destination, serializer);
9118        <u64>::sse_encode(self.fees_sat, serializer);
9119        <crate::bindings::LnUrlPayRequestData>::sse_encode(self.data, serializer);
9120        <crate::model::PayAmount>::sse_encode(self.amount, serializer);
9121        <Option<String>>::sse_encode(self.comment, serializer);
9122        <Option<crate::bindings::SuccessAction>>::sse_encode(self.success_action, serializer);
9123    }
9124}
9125
9126impl SseEncode for crate::model::PreparePayOnchainRequest {
9127    // Codec=Sse (Serialization based), see doc to use other codecs
9128    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9129        <crate::model::PayAmount>::sse_encode(self.amount, serializer);
9130        <Option<u32>>::sse_encode(self.fee_rate_sat_per_vbyte, serializer);
9131    }
9132}
9133
9134impl SseEncode for crate::model::PreparePayOnchainResponse {
9135    // Codec=Sse (Serialization based), see doc to use other codecs
9136    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9137        <u64>::sse_encode(self.receiver_amount_sat, serializer);
9138        <u64>::sse_encode(self.claim_fees_sat, serializer);
9139        <u64>::sse_encode(self.total_fees_sat, serializer);
9140    }
9141}
9142
9143impl SseEncode for crate::model::PrepareReceiveRequest {
9144    // Codec=Sse (Serialization based), see doc to use other codecs
9145    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9146        <crate::model::PaymentMethod>::sse_encode(self.payment_method, serializer);
9147        <Option<crate::model::ReceiveAmount>>::sse_encode(self.amount, serializer);
9148    }
9149}
9150
9151impl SseEncode for crate::model::PrepareReceiveResponse {
9152    // Codec=Sse (Serialization based), see doc to use other codecs
9153    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9154        <crate::model::PaymentMethod>::sse_encode(self.payment_method, serializer);
9155        <u64>::sse_encode(self.fees_sat, serializer);
9156        <Option<crate::model::ReceiveAmount>>::sse_encode(self.amount, serializer);
9157        <Option<u64>>::sse_encode(self.min_payer_amount_sat, serializer);
9158        <Option<u64>>::sse_encode(self.max_payer_amount_sat, serializer);
9159        <Option<f64>>::sse_encode(self.swapper_feerate, serializer);
9160    }
9161}
9162
9163impl SseEncode for crate::model::PrepareRefundRequest {
9164    // Codec=Sse (Serialization based), see doc to use other codecs
9165    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9166        <String>::sse_encode(self.swap_address, serializer);
9167        <String>::sse_encode(self.refund_address, serializer);
9168        <u32>::sse_encode(self.fee_rate_sat_per_vbyte, serializer);
9169    }
9170}
9171
9172impl SseEncode for crate::model::PrepareRefundResponse {
9173    // Codec=Sse (Serialization based), see doc to use other codecs
9174    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9175        <u32>::sse_encode(self.tx_vsize, serializer);
9176        <u64>::sse_encode(self.tx_fee_sat, serializer);
9177        <Option<String>>::sse_encode(self.last_refund_tx_id, serializer);
9178    }
9179}
9180
9181impl SseEncode for crate::model::PrepareSendRequest {
9182    // Codec=Sse (Serialization based), see doc to use other codecs
9183    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9184        <String>::sse_encode(self.destination, serializer);
9185        <Option<crate::model::PayAmount>>::sse_encode(self.amount, serializer);
9186    }
9187}
9188
9189impl SseEncode for crate::model::PrepareSendResponse {
9190    // Codec=Sse (Serialization based), see doc to use other codecs
9191    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9192        <crate::model::SendDestination>::sse_encode(self.destination, serializer);
9193        <Option<crate::model::PayAmount>>::sse_encode(self.amount, serializer);
9194        <Option<u64>>::sse_encode(self.fees_sat, serializer);
9195        <Option<f64>>::sse_encode(self.estimated_asset_fees, serializer);
9196    }
9197}
9198
9199impl SseEncode for crate::bindings::Rate {
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.coin, serializer);
9203        <f64>::sse_encode(self.value, serializer);
9204    }
9205}
9206
9207impl SseEncode for crate::model::ReceiveAmount {
9208    // Codec=Sse (Serialization based), see doc to use other codecs
9209    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9210        match self {
9211            crate::model::ReceiveAmount::Bitcoin { payer_amount_sat } => {
9212                <i32>::sse_encode(0, serializer);
9213                <u64>::sse_encode(payer_amount_sat, serializer);
9214            }
9215            crate::model::ReceiveAmount::Asset {
9216                asset_id,
9217                payer_amount,
9218            } => {
9219                <i32>::sse_encode(1, serializer);
9220                <String>::sse_encode(asset_id, serializer);
9221                <Option<f64>>::sse_encode(payer_amount, serializer);
9222            }
9223            _ => {
9224                unimplemented!("");
9225            }
9226        }
9227    }
9228}
9229
9230impl SseEncode for crate::model::ReceivePaymentRequest {
9231    // Codec=Sse (Serialization based), see doc to use other codecs
9232    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9233        <crate::model::PrepareReceiveResponse>::sse_encode(self.prepare_response, serializer);
9234        <Option<String>>::sse_encode(self.description, serializer);
9235        <Option<bool>>::sse_encode(self.use_description_hash, serializer);
9236        <Option<String>>::sse_encode(self.payer_note, serializer);
9237    }
9238}
9239
9240impl SseEncode for crate::model::ReceivePaymentResponse {
9241    // Codec=Sse (Serialization based), see doc to use other codecs
9242    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9243        <String>::sse_encode(self.destination, serializer);
9244    }
9245}
9246
9247impl SseEncode for crate::model::RecommendedFees {
9248    // Codec=Sse (Serialization based), see doc to use other codecs
9249    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9250        <u64>::sse_encode(self.fastest_fee, serializer);
9251        <u64>::sse_encode(self.half_hour_fee, serializer);
9252        <u64>::sse_encode(self.hour_fee, serializer);
9253        <u64>::sse_encode(self.economy_fee, serializer);
9254        <u64>::sse_encode(self.minimum_fee, serializer);
9255    }
9256}
9257
9258impl SseEncode for crate::model::RefundRequest {
9259    // Codec=Sse (Serialization based), see doc to use other codecs
9260    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9261        <String>::sse_encode(self.swap_address, serializer);
9262        <String>::sse_encode(self.refund_address, serializer);
9263        <u32>::sse_encode(self.fee_rate_sat_per_vbyte, serializer);
9264    }
9265}
9266
9267impl SseEncode for crate::model::RefundResponse {
9268    // Codec=Sse (Serialization based), see doc to use other codecs
9269    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9270        <String>::sse_encode(self.refund_tx_id, serializer);
9271    }
9272}
9273
9274impl SseEncode for crate::model::RefundableSwap {
9275    // Codec=Sse (Serialization based), see doc to use other codecs
9276    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9277        <String>::sse_encode(self.swap_address, serializer);
9278        <u32>::sse_encode(self.timestamp, serializer);
9279        <u64>::sse_encode(self.amount_sat, serializer);
9280        <Option<String>>::sse_encode(self.last_refund_tx_id, serializer);
9281    }
9282}
9283
9284impl SseEncode for crate::model::RestoreRequest {
9285    // Codec=Sse (Serialization based), see doc to use other codecs
9286    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9287        <Option<String>>::sse_encode(self.backup_path, serializer);
9288    }
9289}
9290
9291impl SseEncode for crate::bindings::RouteHint {
9292    // Codec=Sse (Serialization based), see doc to use other codecs
9293    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9294        <Vec<crate::bindings::RouteHintHop>>::sse_encode(self.hops, serializer);
9295    }
9296}
9297
9298impl SseEncode for crate::bindings::RouteHintHop {
9299    // Codec=Sse (Serialization based), see doc to use other codecs
9300    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9301        <String>::sse_encode(self.src_node_id, serializer);
9302        <String>::sse_encode(self.short_channel_id, serializer);
9303        <u32>::sse_encode(self.fees_base_msat, serializer);
9304        <u32>::sse_encode(self.fees_proportional_millionths, serializer);
9305        <u64>::sse_encode(self.cltv_expiry_delta, serializer);
9306        <Option<u64>>::sse_encode(self.htlc_minimum_msat, serializer);
9307        <Option<u64>>::sse_encode(self.htlc_maximum_msat, serializer);
9308    }
9309}
9310
9311impl SseEncode for crate::error::SdkError {
9312    // Codec=Sse (Serialization based), see doc to use other codecs
9313    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9314        match self {
9315            crate::error::SdkError::AlreadyStarted => {
9316                <i32>::sse_encode(0, serializer);
9317            }
9318            crate::error::SdkError::Generic { err } => {
9319                <i32>::sse_encode(1, serializer);
9320                <String>::sse_encode(err, serializer);
9321            }
9322            crate::error::SdkError::NotStarted => {
9323                <i32>::sse_encode(2, serializer);
9324            }
9325            crate::error::SdkError::ServiceConnectivity { err } => {
9326                <i32>::sse_encode(3, serializer);
9327                <String>::sse_encode(err, serializer);
9328            }
9329            _ => {
9330                unimplemented!("");
9331            }
9332        }
9333    }
9334}
9335
9336impl SseEncode for crate::model::SdkEvent {
9337    // Codec=Sse (Serialization based), see doc to use other codecs
9338    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9339        match self {
9340            crate::model::SdkEvent::PaymentFailed { details } => {
9341                <i32>::sse_encode(0, serializer);
9342                <crate::model::Payment>::sse_encode(details, serializer);
9343            }
9344            crate::model::SdkEvent::PaymentPending { details } => {
9345                <i32>::sse_encode(1, serializer);
9346                <crate::model::Payment>::sse_encode(details, serializer);
9347            }
9348            crate::model::SdkEvent::PaymentRefundable { details } => {
9349                <i32>::sse_encode(2, serializer);
9350                <crate::model::Payment>::sse_encode(details, serializer);
9351            }
9352            crate::model::SdkEvent::PaymentRefunded { details } => {
9353                <i32>::sse_encode(3, serializer);
9354                <crate::model::Payment>::sse_encode(details, serializer);
9355            }
9356            crate::model::SdkEvent::PaymentRefundPending { details } => {
9357                <i32>::sse_encode(4, serializer);
9358                <crate::model::Payment>::sse_encode(details, serializer);
9359            }
9360            crate::model::SdkEvent::PaymentSucceeded { details } => {
9361                <i32>::sse_encode(5, serializer);
9362                <crate::model::Payment>::sse_encode(details, serializer);
9363            }
9364            crate::model::SdkEvent::PaymentWaitingConfirmation { details } => {
9365                <i32>::sse_encode(6, serializer);
9366                <crate::model::Payment>::sse_encode(details, serializer);
9367            }
9368            crate::model::SdkEvent::PaymentWaitingFeeAcceptance { details } => {
9369                <i32>::sse_encode(7, serializer);
9370                <crate::model::Payment>::sse_encode(details, serializer);
9371            }
9372            crate::model::SdkEvent::Synced => {
9373                <i32>::sse_encode(8, serializer);
9374            }
9375            crate::model::SdkEvent::DataSynced {
9376                did_pull_new_records,
9377            } => {
9378                <i32>::sse_encode(9, serializer);
9379                <bool>::sse_encode(did_pull_new_records, serializer);
9380            }
9381            _ => {
9382                unimplemented!("");
9383            }
9384        }
9385    }
9386}
9387
9388impl SseEncode for crate::model::SendDestination {
9389    // Codec=Sse (Serialization based), see doc to use other codecs
9390    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9391        match self {
9392            crate::model::SendDestination::LiquidAddress {
9393                address_data,
9394                bip353_address,
9395            } => {
9396                <i32>::sse_encode(0, serializer);
9397                <crate::bindings::LiquidAddressData>::sse_encode(address_data, serializer);
9398                <Option<String>>::sse_encode(bip353_address, serializer);
9399            }
9400            crate::model::SendDestination::Bolt11 {
9401                invoice,
9402                bip353_address,
9403            } => {
9404                <i32>::sse_encode(1, serializer);
9405                <crate::bindings::LNInvoice>::sse_encode(invoice, serializer);
9406                <Option<String>>::sse_encode(bip353_address, serializer);
9407            }
9408            crate::model::SendDestination::Bolt12 {
9409                offer,
9410                receiver_amount_sat,
9411                bip353_address,
9412            } => {
9413                <i32>::sse_encode(2, serializer);
9414                <crate::bindings::LNOffer>::sse_encode(offer, serializer);
9415                <u64>::sse_encode(receiver_amount_sat, serializer);
9416                <Option<String>>::sse_encode(bip353_address, serializer);
9417            }
9418            _ => {
9419                unimplemented!("");
9420            }
9421        }
9422    }
9423}
9424
9425impl SseEncode for crate::model::SendPaymentRequest {
9426    // Codec=Sse (Serialization based), see doc to use other codecs
9427    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9428        <crate::model::PrepareSendResponse>::sse_encode(self.prepare_response, serializer);
9429        <Option<bool>>::sse_encode(self.use_asset_fees, serializer);
9430        <Option<String>>::sse_encode(self.payer_note, serializer);
9431    }
9432}
9433
9434impl SseEncode for crate::model::SendPaymentResponse {
9435    // Codec=Sse (Serialization based), see doc to use other codecs
9436    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9437        <crate::model::Payment>::sse_encode(self.payment, serializer);
9438    }
9439}
9440
9441impl SseEncode for crate::model::SignMessageRequest {
9442    // Codec=Sse (Serialization based), see doc to use other codecs
9443    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9444        <String>::sse_encode(self.message, serializer);
9445    }
9446}
9447
9448impl SseEncode for crate::model::SignMessageResponse {
9449    // Codec=Sse (Serialization based), see doc to use other codecs
9450    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9451        <String>::sse_encode(self.signature, serializer);
9452    }
9453}
9454
9455impl SseEncode for crate::bindings::SuccessAction {
9456    // Codec=Sse (Serialization based), see doc to use other codecs
9457    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9458        match self {
9459            crate::bindings::SuccessAction::Aes { data } => {
9460                <i32>::sse_encode(0, serializer);
9461                <crate::bindings::AesSuccessActionData>::sse_encode(data, serializer);
9462            }
9463            crate::bindings::SuccessAction::Message { data } => {
9464                <i32>::sse_encode(1, serializer);
9465                <crate::bindings::MessageSuccessActionData>::sse_encode(data, serializer);
9466            }
9467            crate::bindings::SuccessAction::Url { data } => {
9468                <i32>::sse_encode(2, serializer);
9469                <crate::bindings::UrlSuccessActionData>::sse_encode(data, serializer);
9470            }
9471            _ => {
9472                unimplemented!("");
9473            }
9474        }
9475    }
9476}
9477
9478impl SseEncode for crate::bindings::SuccessActionProcessed {
9479    // Codec=Sse (Serialization based), see doc to use other codecs
9480    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9481        match self {
9482            crate::bindings::SuccessActionProcessed::Aes { result } => {
9483                <i32>::sse_encode(0, serializer);
9484                <crate::bindings::AesSuccessActionDataResult>::sse_encode(result, serializer);
9485            }
9486            crate::bindings::SuccessActionProcessed::Message { data } => {
9487                <i32>::sse_encode(1, serializer);
9488                <crate::bindings::MessageSuccessActionData>::sse_encode(data, serializer);
9489            }
9490            crate::bindings::SuccessActionProcessed::Url { data } => {
9491                <i32>::sse_encode(2, serializer);
9492                <crate::bindings::UrlSuccessActionData>::sse_encode(data, serializer);
9493            }
9494            _ => {
9495                unimplemented!("");
9496            }
9497        }
9498    }
9499}
9500
9501impl SseEncode for crate::bindings::Symbol {
9502    // Codec=Sse (Serialization based), see doc to use other codecs
9503    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9504        <Option<String>>::sse_encode(self.grapheme, serializer);
9505        <Option<String>>::sse_encode(self.template, serializer);
9506        <Option<bool>>::sse_encode(self.rtl, serializer);
9507        <Option<u32>>::sse_encode(self.position, serializer);
9508    }
9509}
9510
9511impl SseEncode for u16 {
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.cursor.write_u16::<NativeEndian>(self).unwrap();
9515    }
9516}
9517
9518impl SseEncode for u32 {
9519    // Codec=Sse (Serialization based), see doc to use other codecs
9520    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9521        serializer.cursor.write_u32::<NativeEndian>(self).unwrap();
9522    }
9523}
9524
9525impl SseEncode for u64 {
9526    // Codec=Sse (Serialization based), see doc to use other codecs
9527    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9528        serializer.cursor.write_u64::<NativeEndian>(self).unwrap();
9529    }
9530}
9531
9532impl SseEncode for u8 {
9533    // Codec=Sse (Serialization based), see doc to use other codecs
9534    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9535        serializer.cursor.write_u8(self).unwrap();
9536    }
9537}
9538
9539impl SseEncode for () {
9540    // Codec=Sse (Serialization based), see doc to use other codecs
9541    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {}
9542}
9543
9544impl SseEncode for crate::bindings::UrlSuccessActionData {
9545    // Codec=Sse (Serialization based), see doc to use other codecs
9546    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9547        <String>::sse_encode(self.description, serializer);
9548        <String>::sse_encode(self.url, serializer);
9549        <bool>::sse_encode(self.matches_callback_domain, serializer);
9550    }
9551}
9552
9553impl SseEncode for usize {
9554    // Codec=Sse (Serialization based), see doc to use other codecs
9555    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9556        serializer
9557            .cursor
9558            .write_u64::<NativeEndian>(self as _)
9559            .unwrap();
9560    }
9561}
9562
9563impl SseEncode for crate::model::WalletInfo {
9564    // Codec=Sse (Serialization based), see doc to use other codecs
9565    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9566        <u64>::sse_encode(self.balance_sat, serializer);
9567        <u64>::sse_encode(self.pending_send_sat, serializer);
9568        <u64>::sse_encode(self.pending_receive_sat, serializer);
9569        <String>::sse_encode(self.fingerprint, serializer);
9570        <String>::sse_encode(self.pubkey, serializer);
9571        <Vec<crate::model::AssetBalance>>::sse_encode(self.asset_balances, serializer);
9572    }
9573}
9574
9575#[cfg(not(target_family = "wasm"))]
9576mod io {
9577    // This file is automatically generated, so please do not edit it.
9578    // @generated by `flutter_rust_bridge`@ 2.9.0.
9579
9580    // Section: imports
9581
9582    use super::*;
9583    use crate::bindings::*;
9584    use crate::model::EventListener;
9585    use flutter_rust_bridge::for_generated::byteorder::{
9586        NativeEndian, ReadBytesExt, WriteBytesExt,
9587    };
9588    use flutter_rust_bridge::for_generated::{transform_result_dco, Lifetimeable, Lockable};
9589    use flutter_rust_bridge::{Handler, IntoIntoDart};
9590
9591    // Section: boilerplate
9592
9593    flutter_rust_bridge::frb_generated_boilerplate_io!();
9594
9595    // Section: dart2rust
9596
9597    impl CstDecode<flutter_rust_bridge::for_generated::anyhow::Error>
9598        for *mut wire_cst_list_prim_u_8_strict
9599    {
9600        // Codec=Cst (C-struct based), see doc to use other codecs
9601        fn cst_decode(self) -> flutter_rust_bridge::for_generated::anyhow::Error {
9602            unimplemented!()
9603        }
9604    }
9605    impl CstDecode<BindingLiquidSdk> for usize {
9606        // Codec=Cst (C-struct based), see doc to use other codecs
9607        fn cst_decode(self) -> BindingLiquidSdk {
9608            flutter_rust_bridge::for_generated::rust_auto_opaque_decode_owned(CstDecode::<
9609                RustOpaqueNom<
9610                    flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>,
9611                >,
9612            >::cst_decode(
9613                self
9614            ))
9615        }
9616    }
9617    impl
9618        CstDecode<
9619            RustOpaqueNom<
9620                flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>,
9621            >,
9622        > for usize
9623    {
9624        // Codec=Cst (C-struct based), see doc to use other codecs
9625        fn cst_decode(
9626            self,
9627        ) -> RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>
9628        {
9629            unsafe { decode_rust_opaque_nom(self as _) }
9630        }
9631    }
9632    impl CstDecode<StreamSink<crate::model::LogEntry, flutter_rust_bridge::for_generated::DcoCodec>>
9633        for *mut wire_cst_list_prim_u_8_strict
9634    {
9635        // Codec=Cst (C-struct based), see doc to use other codecs
9636        fn cst_decode(
9637            self,
9638        ) -> StreamSink<crate::model::LogEntry, flutter_rust_bridge::for_generated::DcoCodec>
9639        {
9640            let raw: String = self.cst_decode();
9641            StreamSink::deserialize(raw)
9642        }
9643    }
9644    impl CstDecode<StreamSink<crate::model::SdkEvent, flutter_rust_bridge::for_generated::DcoCodec>>
9645        for *mut wire_cst_list_prim_u_8_strict
9646    {
9647        // Codec=Cst (C-struct based), see doc to use other codecs
9648        fn cst_decode(
9649            self,
9650        ) -> StreamSink<crate::model::SdkEvent, flutter_rust_bridge::for_generated::DcoCodec>
9651        {
9652            let raw: String = self.cst_decode();
9653            StreamSink::deserialize(raw)
9654        }
9655    }
9656    impl CstDecode<String> for *mut wire_cst_list_prim_u_8_strict {
9657        // Codec=Cst (C-struct based), see doc to use other codecs
9658        fn cst_decode(self) -> String {
9659            let vec: Vec<u8> = self.cst_decode();
9660            String::from_utf8(vec).unwrap()
9661        }
9662    }
9663    impl CstDecode<crate::model::AcceptPaymentProposedFeesRequest>
9664        for wire_cst_accept_payment_proposed_fees_request
9665    {
9666        // Codec=Cst (C-struct based), see doc to use other codecs
9667        fn cst_decode(self) -> crate::model::AcceptPaymentProposedFeesRequest {
9668            crate::model::AcceptPaymentProposedFeesRequest {
9669                response: self.response.cst_decode(),
9670            }
9671        }
9672    }
9673    impl CstDecode<crate::bindings::AesSuccessActionData> for wire_cst_aes_success_action_data {
9674        // Codec=Cst (C-struct based), see doc to use other codecs
9675        fn cst_decode(self) -> crate::bindings::AesSuccessActionData {
9676            crate::bindings::AesSuccessActionData {
9677                description: self.description.cst_decode(),
9678                ciphertext: self.ciphertext.cst_decode(),
9679                iv: self.iv.cst_decode(),
9680            }
9681        }
9682    }
9683    impl CstDecode<crate::bindings::AesSuccessActionDataDecrypted>
9684        for wire_cst_aes_success_action_data_decrypted
9685    {
9686        // Codec=Cst (C-struct based), see doc to use other codecs
9687        fn cst_decode(self) -> crate::bindings::AesSuccessActionDataDecrypted {
9688            crate::bindings::AesSuccessActionDataDecrypted {
9689                description: self.description.cst_decode(),
9690                plaintext: self.plaintext.cst_decode(),
9691            }
9692        }
9693    }
9694    impl CstDecode<crate::bindings::AesSuccessActionDataResult>
9695        for wire_cst_aes_success_action_data_result
9696    {
9697        // Codec=Cst (C-struct based), see doc to use other codecs
9698        fn cst_decode(self) -> crate::bindings::AesSuccessActionDataResult {
9699            match self.tag {
9700                0 => {
9701                    let ans = unsafe { self.kind.Decrypted };
9702                    crate::bindings::AesSuccessActionDataResult::Decrypted {
9703                        data: ans.data.cst_decode(),
9704                    }
9705                }
9706                1 => {
9707                    let ans = unsafe { self.kind.ErrorStatus };
9708                    crate::bindings::AesSuccessActionDataResult::ErrorStatus {
9709                        reason: ans.reason.cst_decode(),
9710                    }
9711                }
9712                _ => unreachable!(),
9713            }
9714        }
9715    }
9716    impl CstDecode<crate::bindings::Amount> for wire_cst_amount {
9717        // Codec=Cst (C-struct based), see doc to use other codecs
9718        fn cst_decode(self) -> crate::bindings::Amount {
9719            match self.tag {
9720                0 => {
9721                    let ans = unsafe { self.kind.Bitcoin };
9722                    crate::bindings::Amount::Bitcoin {
9723                        amount_msat: ans.amount_msat.cst_decode(),
9724                    }
9725                }
9726                1 => {
9727                    let ans = unsafe { self.kind.Currency };
9728                    crate::bindings::Amount::Currency {
9729                        iso4217_code: ans.iso4217_code.cst_decode(),
9730                        fractional_amount: ans.fractional_amount.cst_decode(),
9731                    }
9732                }
9733                _ => unreachable!(),
9734            }
9735        }
9736    }
9737    impl CstDecode<crate::model::AssetBalance> for wire_cst_asset_balance {
9738        // Codec=Cst (C-struct based), see doc to use other codecs
9739        fn cst_decode(self) -> crate::model::AssetBalance {
9740            crate::model::AssetBalance {
9741                asset_id: self.asset_id.cst_decode(),
9742                balance_sat: self.balance_sat.cst_decode(),
9743                name: self.name.cst_decode(),
9744                ticker: self.ticker.cst_decode(),
9745                balance: self.balance.cst_decode(),
9746            }
9747        }
9748    }
9749    impl CstDecode<crate::model::AssetInfo> for wire_cst_asset_info {
9750        // Codec=Cst (C-struct based), see doc to use other codecs
9751        fn cst_decode(self) -> crate::model::AssetInfo {
9752            crate::model::AssetInfo {
9753                name: self.name.cst_decode(),
9754                ticker: self.ticker.cst_decode(),
9755                amount: self.amount.cst_decode(),
9756                fees: self.fees.cst_decode(),
9757            }
9758        }
9759    }
9760    impl CstDecode<crate::model::AssetMetadata> for wire_cst_asset_metadata {
9761        // Codec=Cst (C-struct based), see doc to use other codecs
9762        fn cst_decode(self) -> crate::model::AssetMetadata {
9763            crate::model::AssetMetadata {
9764                asset_id: self.asset_id.cst_decode(),
9765                name: self.name.cst_decode(),
9766                ticker: self.ticker.cst_decode(),
9767                precision: self.precision.cst_decode(),
9768                fiat_id: self.fiat_id.cst_decode(),
9769            }
9770        }
9771    }
9772    impl CstDecode<crate::model::BackupRequest> for wire_cst_backup_request {
9773        // Codec=Cst (C-struct based), see doc to use other codecs
9774        fn cst_decode(self) -> crate::model::BackupRequest {
9775            crate::model::BackupRequest {
9776                backup_path: self.backup_path.cst_decode(),
9777            }
9778        }
9779    }
9780    impl CstDecode<crate::bindings::BindingEventListener> for wire_cst_binding_event_listener {
9781        // Codec=Cst (C-struct based), see doc to use other codecs
9782        fn cst_decode(self) -> crate::bindings::BindingEventListener {
9783            crate::bindings::BindingEventListener {
9784                stream: self.stream.cst_decode(),
9785            }
9786        }
9787    }
9788    impl CstDecode<crate::bindings::BitcoinAddressData> for wire_cst_bitcoin_address_data {
9789        // Codec=Cst (C-struct based), see doc to use other codecs
9790        fn cst_decode(self) -> crate::bindings::BitcoinAddressData {
9791            crate::bindings::BitcoinAddressData {
9792                address: self.address.cst_decode(),
9793                network: self.network.cst_decode(),
9794                amount_sat: self.amount_sat.cst_decode(),
9795                label: self.label.cst_decode(),
9796                message: self.message.cst_decode(),
9797            }
9798        }
9799    }
9800    impl CstDecode<crate::model::BlockchainExplorer> for wire_cst_blockchain_explorer {
9801        // Codec=Cst (C-struct based), see doc to use other codecs
9802        fn cst_decode(self) -> crate::model::BlockchainExplorer {
9803            match self.tag {
9804                0 => {
9805                    let ans = unsafe { self.kind.Electrum };
9806                    crate::model::BlockchainExplorer::Electrum {
9807                        url: ans.url.cst_decode(),
9808                    }
9809                }
9810                1 => {
9811                    let ans = unsafe { self.kind.Esplora };
9812                    crate::model::BlockchainExplorer::Esplora {
9813                        url: ans.url.cst_decode(),
9814                        use_waterfalls: ans.use_waterfalls.cst_decode(),
9815                    }
9816                }
9817                _ => unreachable!(),
9818            }
9819        }
9820    }
9821    impl CstDecode<crate::model::BlockchainInfo> for wire_cst_blockchain_info {
9822        // Codec=Cst (C-struct based), see doc to use other codecs
9823        fn cst_decode(self) -> crate::model::BlockchainInfo {
9824            crate::model::BlockchainInfo {
9825                liquid_tip: self.liquid_tip.cst_decode(),
9826                bitcoin_tip: self.bitcoin_tip.cst_decode(),
9827            }
9828        }
9829    }
9830    impl CstDecode<crate::model::AcceptPaymentProposedFeesRequest>
9831        for *mut wire_cst_accept_payment_proposed_fees_request
9832    {
9833        // Codec=Cst (C-struct based), see doc to use other codecs
9834        fn cst_decode(self) -> crate::model::AcceptPaymentProposedFeesRequest {
9835            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9836            CstDecode::<crate::model::AcceptPaymentProposedFeesRequest>::cst_decode(*wrap).into()
9837        }
9838    }
9839    impl CstDecode<crate::bindings::AesSuccessActionData> for *mut wire_cst_aes_success_action_data {
9840        // Codec=Cst (C-struct based), see doc to use other codecs
9841        fn cst_decode(self) -> crate::bindings::AesSuccessActionData {
9842            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9843            CstDecode::<crate::bindings::AesSuccessActionData>::cst_decode(*wrap).into()
9844        }
9845    }
9846    impl CstDecode<crate::bindings::AesSuccessActionDataDecrypted>
9847        for *mut wire_cst_aes_success_action_data_decrypted
9848    {
9849        // Codec=Cst (C-struct based), see doc to use other codecs
9850        fn cst_decode(self) -> crate::bindings::AesSuccessActionDataDecrypted {
9851            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9852            CstDecode::<crate::bindings::AesSuccessActionDataDecrypted>::cst_decode(*wrap).into()
9853        }
9854    }
9855    impl CstDecode<crate::bindings::AesSuccessActionDataResult>
9856        for *mut wire_cst_aes_success_action_data_result
9857    {
9858        // Codec=Cst (C-struct based), see doc to use other codecs
9859        fn cst_decode(self) -> crate::bindings::AesSuccessActionDataResult {
9860            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9861            CstDecode::<crate::bindings::AesSuccessActionDataResult>::cst_decode(*wrap).into()
9862        }
9863    }
9864    impl CstDecode<crate::bindings::Amount> for *mut wire_cst_amount {
9865        // Codec=Cst (C-struct based), see doc to use other codecs
9866        fn cst_decode(self) -> crate::bindings::Amount {
9867            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9868            CstDecode::<crate::bindings::Amount>::cst_decode(*wrap).into()
9869        }
9870    }
9871    impl CstDecode<crate::model::AssetInfo> for *mut wire_cst_asset_info {
9872        // Codec=Cst (C-struct based), see doc to use other codecs
9873        fn cst_decode(self) -> crate::model::AssetInfo {
9874            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9875            CstDecode::<crate::model::AssetInfo>::cst_decode(*wrap).into()
9876        }
9877    }
9878    impl CstDecode<crate::model::BackupRequest> for *mut wire_cst_backup_request {
9879        // Codec=Cst (C-struct based), see doc to use other codecs
9880        fn cst_decode(self) -> crate::model::BackupRequest {
9881            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9882            CstDecode::<crate::model::BackupRequest>::cst_decode(*wrap).into()
9883        }
9884    }
9885    impl CstDecode<crate::bindings::BindingEventListener> for *mut wire_cst_binding_event_listener {
9886        // Codec=Cst (C-struct based), see doc to use other codecs
9887        fn cst_decode(self) -> crate::bindings::BindingEventListener {
9888            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9889            CstDecode::<crate::bindings::BindingEventListener>::cst_decode(*wrap).into()
9890        }
9891    }
9892    impl CstDecode<crate::bindings::BitcoinAddressData> for *mut wire_cst_bitcoin_address_data {
9893        // Codec=Cst (C-struct based), see doc to use other codecs
9894        fn cst_decode(self) -> crate::bindings::BitcoinAddressData {
9895            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9896            CstDecode::<crate::bindings::BitcoinAddressData>::cst_decode(*wrap).into()
9897        }
9898    }
9899    impl CstDecode<bool> for *mut bool {
9900        // Codec=Cst (C-struct based), see doc to use other codecs
9901        fn cst_decode(self) -> bool {
9902            unsafe { *flutter_rust_bridge::for_generated::box_from_leak_ptr(self) }
9903        }
9904    }
9905    impl CstDecode<crate::model::BuyBitcoinRequest> for *mut wire_cst_buy_bitcoin_request {
9906        // Codec=Cst (C-struct based), see doc to use other codecs
9907        fn cst_decode(self) -> crate::model::BuyBitcoinRequest {
9908            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9909            CstDecode::<crate::model::BuyBitcoinRequest>::cst_decode(*wrap).into()
9910        }
9911    }
9912    impl CstDecode<crate::model::CheckMessageRequest> for *mut wire_cst_check_message_request {
9913        // Codec=Cst (C-struct based), see doc to use other codecs
9914        fn cst_decode(self) -> crate::model::CheckMessageRequest {
9915            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9916            CstDecode::<crate::model::CheckMessageRequest>::cst_decode(*wrap).into()
9917        }
9918    }
9919    impl CstDecode<crate::model::ConnectRequest> for *mut wire_cst_connect_request {
9920        // Codec=Cst (C-struct based), see doc to use other codecs
9921        fn cst_decode(self) -> crate::model::ConnectRequest {
9922            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9923            CstDecode::<crate::model::ConnectRequest>::cst_decode(*wrap).into()
9924        }
9925    }
9926    impl CstDecode<crate::model::CreateBolt12InvoiceRequest>
9927        for *mut wire_cst_create_bolt_12_invoice_request
9928    {
9929        // Codec=Cst (C-struct based), see doc to use other codecs
9930        fn cst_decode(self) -> crate::model::CreateBolt12InvoiceRequest {
9931            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9932            CstDecode::<crate::model::CreateBolt12InvoiceRequest>::cst_decode(*wrap).into()
9933        }
9934    }
9935    impl CstDecode<f64> for *mut f64 {
9936        // Codec=Cst (C-struct based), see doc to use other codecs
9937        fn cst_decode(self) -> f64 {
9938            unsafe { *flutter_rust_bridge::for_generated::box_from_leak_ptr(self) }
9939        }
9940    }
9941    impl CstDecode<crate::model::FetchPaymentProposedFeesRequest>
9942        for *mut wire_cst_fetch_payment_proposed_fees_request
9943    {
9944        // Codec=Cst (C-struct based), see doc to use other codecs
9945        fn cst_decode(self) -> crate::model::FetchPaymentProposedFeesRequest {
9946            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9947            CstDecode::<crate::model::FetchPaymentProposedFeesRequest>::cst_decode(*wrap).into()
9948        }
9949    }
9950    impl CstDecode<crate::model::GetPaymentRequest> for *mut wire_cst_get_payment_request {
9951        // Codec=Cst (C-struct based), see doc to use other codecs
9952        fn cst_decode(self) -> crate::model::GetPaymentRequest {
9953            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9954            CstDecode::<crate::model::GetPaymentRequest>::cst_decode(*wrap).into()
9955        }
9956    }
9957    impl CstDecode<i64> for *mut i64 {
9958        // Codec=Cst (C-struct based), see doc to use other codecs
9959        fn cst_decode(self) -> i64 {
9960            unsafe { *flutter_rust_bridge::for_generated::box_from_leak_ptr(self) }
9961        }
9962    }
9963    impl CstDecode<crate::bindings::LiquidAddressData> for *mut wire_cst_liquid_address_data {
9964        // Codec=Cst (C-struct based), see doc to use other codecs
9965        fn cst_decode(self) -> crate::bindings::LiquidAddressData {
9966            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9967            CstDecode::<crate::bindings::LiquidAddressData>::cst_decode(*wrap).into()
9968        }
9969    }
9970    impl CstDecode<crate::model::ListPaymentDetails> for *mut wire_cst_list_payment_details {
9971        // Codec=Cst (C-struct based), see doc to use other codecs
9972        fn cst_decode(self) -> crate::model::ListPaymentDetails {
9973            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9974            CstDecode::<crate::model::ListPaymentDetails>::cst_decode(*wrap).into()
9975        }
9976    }
9977    impl CstDecode<crate::model::ListPaymentsRequest> for *mut wire_cst_list_payments_request {
9978        // Codec=Cst (C-struct based), see doc to use other codecs
9979        fn cst_decode(self) -> crate::model::ListPaymentsRequest {
9980            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9981            CstDecode::<crate::model::ListPaymentsRequest>::cst_decode(*wrap).into()
9982        }
9983    }
9984    impl CstDecode<crate::bindings::LNInvoice> for *mut wire_cst_ln_invoice {
9985        // Codec=Cst (C-struct based), see doc to use other codecs
9986        fn cst_decode(self) -> crate::bindings::LNInvoice {
9987            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9988            CstDecode::<crate::bindings::LNInvoice>::cst_decode(*wrap).into()
9989        }
9990    }
9991    impl CstDecode<crate::bindings::LNOffer> for *mut wire_cst_ln_offer {
9992        // Codec=Cst (C-struct based), see doc to use other codecs
9993        fn cst_decode(self) -> crate::bindings::LNOffer {
9994            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9995            CstDecode::<crate::bindings::LNOffer>::cst_decode(*wrap).into()
9996        }
9997    }
9998    impl CstDecode<crate::bindings::LnUrlAuthRequestData> for *mut wire_cst_ln_url_auth_request_data {
9999        // Codec=Cst (C-struct based), see doc to use other codecs
10000        fn cst_decode(self) -> crate::bindings::LnUrlAuthRequestData {
10001            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10002            CstDecode::<crate::bindings::LnUrlAuthRequestData>::cst_decode(*wrap).into()
10003        }
10004    }
10005    impl CstDecode<crate::bindings::LnUrlErrorData> for *mut wire_cst_ln_url_error_data {
10006        // Codec=Cst (C-struct based), see doc to use other codecs
10007        fn cst_decode(self) -> crate::bindings::LnUrlErrorData {
10008            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10009            CstDecode::<crate::bindings::LnUrlErrorData>::cst_decode(*wrap).into()
10010        }
10011    }
10012    impl CstDecode<crate::model::LnUrlInfo> for *mut wire_cst_ln_url_info {
10013        // Codec=Cst (C-struct based), see doc to use other codecs
10014        fn cst_decode(self) -> crate::model::LnUrlInfo {
10015            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10016            CstDecode::<crate::model::LnUrlInfo>::cst_decode(*wrap).into()
10017        }
10018    }
10019    impl CstDecode<crate::bindings::LnUrlPayErrorData> for *mut wire_cst_ln_url_pay_error_data {
10020        // Codec=Cst (C-struct based), see doc to use other codecs
10021        fn cst_decode(self) -> crate::bindings::LnUrlPayErrorData {
10022            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10023            CstDecode::<crate::bindings::LnUrlPayErrorData>::cst_decode(*wrap).into()
10024        }
10025    }
10026    impl CstDecode<crate::model::LnUrlPayRequest> for *mut wire_cst_ln_url_pay_request {
10027        // Codec=Cst (C-struct based), see doc to use other codecs
10028        fn cst_decode(self) -> crate::model::LnUrlPayRequest {
10029            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10030            CstDecode::<crate::model::LnUrlPayRequest>::cst_decode(*wrap).into()
10031        }
10032    }
10033    impl CstDecode<crate::bindings::LnUrlPayRequestData> for *mut wire_cst_ln_url_pay_request_data {
10034        // Codec=Cst (C-struct based), see doc to use other codecs
10035        fn cst_decode(self) -> crate::bindings::LnUrlPayRequestData {
10036            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10037            CstDecode::<crate::bindings::LnUrlPayRequestData>::cst_decode(*wrap).into()
10038        }
10039    }
10040    impl CstDecode<crate::model::LnUrlPaySuccessData> for *mut wire_cst_ln_url_pay_success_data {
10041        // Codec=Cst (C-struct based), see doc to use other codecs
10042        fn cst_decode(self) -> crate::model::LnUrlPaySuccessData {
10043            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10044            CstDecode::<crate::model::LnUrlPaySuccessData>::cst_decode(*wrap).into()
10045        }
10046    }
10047    impl CstDecode<crate::bindings::LnUrlWithdrawRequest> for *mut wire_cst_ln_url_withdraw_request {
10048        // Codec=Cst (C-struct based), see doc to use other codecs
10049        fn cst_decode(self) -> crate::bindings::LnUrlWithdrawRequest {
10050            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10051            CstDecode::<crate::bindings::LnUrlWithdrawRequest>::cst_decode(*wrap).into()
10052        }
10053    }
10054    impl CstDecode<crate::bindings::LnUrlWithdrawRequestData>
10055        for *mut wire_cst_ln_url_withdraw_request_data
10056    {
10057        // Codec=Cst (C-struct based), see doc to use other codecs
10058        fn cst_decode(self) -> crate::bindings::LnUrlWithdrawRequestData {
10059            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10060            CstDecode::<crate::bindings::LnUrlWithdrawRequestData>::cst_decode(*wrap).into()
10061        }
10062    }
10063    impl CstDecode<crate::bindings::duplicates::LnUrlWithdrawSuccessData>
10064        for *mut wire_cst_ln_url_withdraw_success_data
10065    {
10066        // Codec=Cst (C-struct based), see doc to use other codecs
10067        fn cst_decode(self) -> crate::bindings::duplicates::LnUrlWithdrawSuccessData {
10068            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10069            CstDecode::<crate::bindings::duplicates::LnUrlWithdrawSuccessData>::cst_decode(*wrap)
10070                .into()
10071        }
10072    }
10073    impl CstDecode<crate::bindings::MessageSuccessActionData>
10074        for *mut wire_cst_message_success_action_data
10075    {
10076        // Codec=Cst (C-struct based), see doc to use other codecs
10077        fn cst_decode(self) -> crate::bindings::MessageSuccessActionData {
10078            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10079            CstDecode::<crate::bindings::MessageSuccessActionData>::cst_decode(*wrap).into()
10080        }
10081    }
10082    impl CstDecode<crate::model::PayAmount> for *mut wire_cst_pay_amount {
10083        // Codec=Cst (C-struct based), see doc to use other codecs
10084        fn cst_decode(self) -> crate::model::PayAmount {
10085            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10086            CstDecode::<crate::model::PayAmount>::cst_decode(*wrap).into()
10087        }
10088    }
10089    impl CstDecode<crate::model::PayOnchainRequest> for *mut wire_cst_pay_onchain_request {
10090        // Codec=Cst (C-struct based), see doc to use other codecs
10091        fn cst_decode(self) -> crate::model::PayOnchainRequest {
10092            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10093            CstDecode::<crate::model::PayOnchainRequest>::cst_decode(*wrap).into()
10094        }
10095    }
10096    impl CstDecode<crate::model::Payment> for *mut wire_cst_payment {
10097        // Codec=Cst (C-struct based), see doc to use other codecs
10098        fn cst_decode(self) -> crate::model::Payment {
10099            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10100            CstDecode::<crate::model::Payment>::cst_decode(*wrap).into()
10101        }
10102    }
10103    impl CstDecode<crate::model::PrepareBuyBitcoinRequest>
10104        for *mut wire_cst_prepare_buy_bitcoin_request
10105    {
10106        // Codec=Cst (C-struct based), see doc to use other codecs
10107        fn cst_decode(self) -> crate::model::PrepareBuyBitcoinRequest {
10108            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10109            CstDecode::<crate::model::PrepareBuyBitcoinRequest>::cst_decode(*wrap).into()
10110        }
10111    }
10112    impl CstDecode<crate::model::PrepareLnUrlPayRequest> for *mut wire_cst_prepare_ln_url_pay_request {
10113        // Codec=Cst (C-struct based), see doc to use other codecs
10114        fn cst_decode(self) -> crate::model::PrepareLnUrlPayRequest {
10115            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10116            CstDecode::<crate::model::PrepareLnUrlPayRequest>::cst_decode(*wrap).into()
10117        }
10118    }
10119    impl CstDecode<crate::model::PreparePayOnchainRequest>
10120        for *mut wire_cst_prepare_pay_onchain_request
10121    {
10122        // Codec=Cst (C-struct based), see doc to use other codecs
10123        fn cst_decode(self) -> crate::model::PreparePayOnchainRequest {
10124            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10125            CstDecode::<crate::model::PreparePayOnchainRequest>::cst_decode(*wrap).into()
10126        }
10127    }
10128    impl CstDecode<crate::model::PrepareReceiveRequest> for *mut wire_cst_prepare_receive_request {
10129        // Codec=Cst (C-struct based), see doc to use other codecs
10130        fn cst_decode(self) -> crate::model::PrepareReceiveRequest {
10131            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10132            CstDecode::<crate::model::PrepareReceiveRequest>::cst_decode(*wrap).into()
10133        }
10134    }
10135    impl CstDecode<crate::model::PrepareRefundRequest> for *mut wire_cst_prepare_refund_request {
10136        // Codec=Cst (C-struct based), see doc to use other codecs
10137        fn cst_decode(self) -> crate::model::PrepareRefundRequest {
10138            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10139            CstDecode::<crate::model::PrepareRefundRequest>::cst_decode(*wrap).into()
10140        }
10141    }
10142    impl CstDecode<crate::model::PrepareSendRequest> for *mut wire_cst_prepare_send_request {
10143        // Codec=Cst (C-struct based), see doc to use other codecs
10144        fn cst_decode(self) -> crate::model::PrepareSendRequest {
10145            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10146            CstDecode::<crate::model::PrepareSendRequest>::cst_decode(*wrap).into()
10147        }
10148    }
10149    impl CstDecode<crate::model::ReceiveAmount> for *mut wire_cst_receive_amount {
10150        // Codec=Cst (C-struct based), see doc to use other codecs
10151        fn cst_decode(self) -> crate::model::ReceiveAmount {
10152            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10153            CstDecode::<crate::model::ReceiveAmount>::cst_decode(*wrap).into()
10154        }
10155    }
10156    impl CstDecode<crate::model::ReceivePaymentRequest> for *mut wire_cst_receive_payment_request {
10157        // Codec=Cst (C-struct based), see doc to use other codecs
10158        fn cst_decode(self) -> crate::model::ReceivePaymentRequest {
10159            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10160            CstDecode::<crate::model::ReceivePaymentRequest>::cst_decode(*wrap).into()
10161        }
10162    }
10163    impl CstDecode<crate::model::RefundRequest> for *mut wire_cst_refund_request {
10164        // Codec=Cst (C-struct based), see doc to use other codecs
10165        fn cst_decode(self) -> crate::model::RefundRequest {
10166            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10167            CstDecode::<crate::model::RefundRequest>::cst_decode(*wrap).into()
10168        }
10169    }
10170    impl CstDecode<crate::model::RestoreRequest> for *mut wire_cst_restore_request {
10171        // Codec=Cst (C-struct based), see doc to use other codecs
10172        fn cst_decode(self) -> crate::model::RestoreRequest {
10173            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10174            CstDecode::<crate::model::RestoreRequest>::cst_decode(*wrap).into()
10175        }
10176    }
10177    impl CstDecode<crate::model::SdkEvent> for *mut wire_cst_sdk_event {
10178        // Codec=Cst (C-struct based), see doc to use other codecs
10179        fn cst_decode(self) -> crate::model::SdkEvent {
10180            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10181            CstDecode::<crate::model::SdkEvent>::cst_decode(*wrap).into()
10182        }
10183    }
10184    impl CstDecode<crate::model::SendPaymentRequest> for *mut wire_cst_send_payment_request {
10185        // Codec=Cst (C-struct based), see doc to use other codecs
10186        fn cst_decode(self) -> crate::model::SendPaymentRequest {
10187            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10188            CstDecode::<crate::model::SendPaymentRequest>::cst_decode(*wrap).into()
10189        }
10190    }
10191    impl CstDecode<crate::model::SignMessageRequest> for *mut wire_cst_sign_message_request {
10192        // Codec=Cst (C-struct based), see doc to use other codecs
10193        fn cst_decode(self) -> crate::model::SignMessageRequest {
10194            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10195            CstDecode::<crate::model::SignMessageRequest>::cst_decode(*wrap).into()
10196        }
10197    }
10198    impl CstDecode<crate::bindings::SuccessAction> for *mut wire_cst_success_action {
10199        // Codec=Cst (C-struct based), see doc to use other codecs
10200        fn cst_decode(self) -> crate::bindings::SuccessAction {
10201            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10202            CstDecode::<crate::bindings::SuccessAction>::cst_decode(*wrap).into()
10203        }
10204    }
10205    impl CstDecode<crate::bindings::SuccessActionProcessed> for *mut wire_cst_success_action_processed {
10206        // Codec=Cst (C-struct based), see doc to use other codecs
10207        fn cst_decode(self) -> crate::bindings::SuccessActionProcessed {
10208            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10209            CstDecode::<crate::bindings::SuccessActionProcessed>::cst_decode(*wrap).into()
10210        }
10211    }
10212    impl CstDecode<crate::bindings::Symbol> for *mut wire_cst_symbol {
10213        // Codec=Cst (C-struct based), see doc to use other codecs
10214        fn cst_decode(self) -> crate::bindings::Symbol {
10215            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10216            CstDecode::<crate::bindings::Symbol>::cst_decode(*wrap).into()
10217        }
10218    }
10219    impl CstDecode<u32> for *mut u32 {
10220        // Codec=Cst (C-struct based), see doc to use other codecs
10221        fn cst_decode(self) -> u32 {
10222            unsafe { *flutter_rust_bridge::for_generated::box_from_leak_ptr(self) }
10223        }
10224    }
10225    impl CstDecode<u64> for *mut u64 {
10226        // Codec=Cst (C-struct based), see doc to use other codecs
10227        fn cst_decode(self) -> u64 {
10228            unsafe { *flutter_rust_bridge::for_generated::box_from_leak_ptr(self) }
10229        }
10230    }
10231    impl CstDecode<crate::bindings::UrlSuccessActionData> for *mut wire_cst_url_success_action_data {
10232        // Codec=Cst (C-struct based), see doc to use other codecs
10233        fn cst_decode(self) -> crate::bindings::UrlSuccessActionData {
10234            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10235            CstDecode::<crate::bindings::UrlSuccessActionData>::cst_decode(*wrap).into()
10236        }
10237    }
10238    impl CstDecode<crate::model::BuyBitcoinRequest> for wire_cst_buy_bitcoin_request {
10239        // Codec=Cst (C-struct based), see doc to use other codecs
10240        fn cst_decode(self) -> crate::model::BuyBitcoinRequest {
10241            crate::model::BuyBitcoinRequest {
10242                prepare_response: self.prepare_response.cst_decode(),
10243                redirect_url: self.redirect_url.cst_decode(),
10244            }
10245        }
10246    }
10247    impl CstDecode<crate::model::CheckMessageRequest> for wire_cst_check_message_request {
10248        // Codec=Cst (C-struct based), see doc to use other codecs
10249        fn cst_decode(self) -> crate::model::CheckMessageRequest {
10250            crate::model::CheckMessageRequest {
10251                message: self.message.cst_decode(),
10252                pubkey: self.pubkey.cst_decode(),
10253                signature: self.signature.cst_decode(),
10254            }
10255        }
10256    }
10257    impl CstDecode<crate::model::CheckMessageResponse> for wire_cst_check_message_response {
10258        // Codec=Cst (C-struct based), see doc to use other codecs
10259        fn cst_decode(self) -> crate::model::CheckMessageResponse {
10260            crate::model::CheckMessageResponse {
10261                is_valid: self.is_valid.cst_decode(),
10262            }
10263        }
10264    }
10265    impl CstDecode<crate::model::Config> for wire_cst_config {
10266        // Codec=Cst (C-struct based), see doc to use other codecs
10267        fn cst_decode(self) -> crate::model::Config {
10268            crate::model::Config {
10269                liquid_explorer: self.liquid_explorer.cst_decode(),
10270                bitcoin_explorer: self.bitcoin_explorer.cst_decode(),
10271                working_dir: self.working_dir.cst_decode(),
10272                network: self.network.cst_decode(),
10273                payment_timeout_sec: self.payment_timeout_sec.cst_decode(),
10274                sync_service_url: self.sync_service_url.cst_decode(),
10275                zero_conf_max_amount_sat: self.zero_conf_max_amount_sat.cst_decode(),
10276                breez_api_key: self.breez_api_key.cst_decode(),
10277                external_input_parsers: self.external_input_parsers.cst_decode(),
10278                use_default_external_input_parsers: self
10279                    .use_default_external_input_parsers
10280                    .cst_decode(),
10281                onchain_fee_rate_leeway_sat: self.onchain_fee_rate_leeway_sat.cst_decode(),
10282                asset_metadata: self.asset_metadata.cst_decode(),
10283                sideswap_api_key: self.sideswap_api_key.cst_decode(),
10284            }
10285        }
10286    }
10287    impl CstDecode<crate::model::ConnectRequest> for wire_cst_connect_request {
10288        // Codec=Cst (C-struct based), see doc to use other codecs
10289        fn cst_decode(self) -> crate::model::ConnectRequest {
10290            crate::model::ConnectRequest {
10291                config: self.config.cst_decode(),
10292                mnemonic: self.mnemonic.cst_decode(),
10293                passphrase: self.passphrase.cst_decode(),
10294                seed: self.seed.cst_decode(),
10295            }
10296        }
10297    }
10298    impl CstDecode<crate::model::CreateBolt12InvoiceRequest>
10299        for wire_cst_create_bolt_12_invoice_request
10300    {
10301        // Codec=Cst (C-struct based), see doc to use other codecs
10302        fn cst_decode(self) -> crate::model::CreateBolt12InvoiceRequest {
10303            crate::model::CreateBolt12InvoiceRequest {
10304                offer: self.offer.cst_decode(),
10305                invoice_request: self.invoice_request.cst_decode(),
10306            }
10307        }
10308    }
10309    impl CstDecode<crate::model::CreateBolt12InvoiceResponse>
10310        for wire_cst_create_bolt_12_invoice_response
10311    {
10312        // Codec=Cst (C-struct based), see doc to use other codecs
10313        fn cst_decode(self) -> crate::model::CreateBolt12InvoiceResponse {
10314            crate::model::CreateBolt12InvoiceResponse {
10315                invoice: self.invoice.cst_decode(),
10316            }
10317        }
10318    }
10319    impl CstDecode<crate::bindings::CurrencyInfo> for wire_cst_currency_info {
10320        // Codec=Cst (C-struct based), see doc to use other codecs
10321        fn cst_decode(self) -> crate::bindings::CurrencyInfo {
10322            crate::bindings::CurrencyInfo {
10323                name: self.name.cst_decode(),
10324                fraction_size: self.fraction_size.cst_decode(),
10325                spacing: self.spacing.cst_decode(),
10326                symbol: self.symbol.cst_decode(),
10327                uniq_symbol: self.uniq_symbol.cst_decode(),
10328                localized_name: self.localized_name.cst_decode(),
10329                locale_overrides: self.locale_overrides.cst_decode(),
10330            }
10331        }
10332    }
10333    impl CstDecode<crate::bindings::ExternalInputParser> for wire_cst_external_input_parser {
10334        // Codec=Cst (C-struct based), see doc to use other codecs
10335        fn cst_decode(self) -> crate::bindings::ExternalInputParser {
10336            crate::bindings::ExternalInputParser {
10337                provider_id: self.provider_id.cst_decode(),
10338                input_regex: self.input_regex.cst_decode(),
10339                parser_url: self.parser_url.cst_decode(),
10340            }
10341        }
10342    }
10343    impl CstDecode<crate::model::FetchPaymentProposedFeesRequest>
10344        for wire_cst_fetch_payment_proposed_fees_request
10345    {
10346        // Codec=Cst (C-struct based), see doc to use other codecs
10347        fn cst_decode(self) -> crate::model::FetchPaymentProposedFeesRequest {
10348            crate::model::FetchPaymentProposedFeesRequest {
10349                swap_id: self.swap_id.cst_decode(),
10350            }
10351        }
10352    }
10353    impl CstDecode<crate::model::FetchPaymentProposedFeesResponse>
10354        for wire_cst_fetch_payment_proposed_fees_response
10355    {
10356        // Codec=Cst (C-struct based), see doc to use other codecs
10357        fn cst_decode(self) -> crate::model::FetchPaymentProposedFeesResponse {
10358            crate::model::FetchPaymentProposedFeesResponse {
10359                swap_id: self.swap_id.cst_decode(),
10360                fees_sat: self.fees_sat.cst_decode(),
10361                payer_amount_sat: self.payer_amount_sat.cst_decode(),
10362                receiver_amount_sat: self.receiver_amount_sat.cst_decode(),
10363            }
10364        }
10365    }
10366    impl CstDecode<crate::bindings::FiatCurrency> for wire_cst_fiat_currency {
10367        // Codec=Cst (C-struct based), see doc to use other codecs
10368        fn cst_decode(self) -> crate::bindings::FiatCurrency {
10369            crate::bindings::FiatCurrency {
10370                id: self.id.cst_decode(),
10371                info: self.info.cst_decode(),
10372            }
10373        }
10374    }
10375    impl CstDecode<crate::model::GetInfoResponse> for wire_cst_get_info_response {
10376        // Codec=Cst (C-struct based), see doc to use other codecs
10377        fn cst_decode(self) -> crate::model::GetInfoResponse {
10378            crate::model::GetInfoResponse {
10379                wallet_info: self.wallet_info.cst_decode(),
10380                blockchain_info: self.blockchain_info.cst_decode(),
10381            }
10382        }
10383    }
10384    impl CstDecode<crate::model::GetPaymentRequest> for wire_cst_get_payment_request {
10385        // Codec=Cst (C-struct based), see doc to use other codecs
10386        fn cst_decode(self) -> crate::model::GetPaymentRequest {
10387            match self.tag {
10388                0 => {
10389                    let ans = unsafe { self.kind.PaymentHash };
10390                    crate::model::GetPaymentRequest::PaymentHash {
10391                        payment_hash: ans.payment_hash.cst_decode(),
10392                    }
10393                }
10394                1 => {
10395                    let ans = unsafe { self.kind.SwapId };
10396                    crate::model::GetPaymentRequest::SwapId {
10397                        swap_id: ans.swap_id.cst_decode(),
10398                    }
10399                }
10400                _ => unreachable!(),
10401            }
10402        }
10403    }
10404    impl CstDecode<crate::bindings::InputType> for wire_cst_input_type {
10405        // Codec=Cst (C-struct based), see doc to use other codecs
10406        fn cst_decode(self) -> crate::bindings::InputType {
10407            match self.tag {
10408                0 => {
10409                    let ans = unsafe { self.kind.BitcoinAddress };
10410                    crate::bindings::InputType::BitcoinAddress {
10411                        address: ans.address.cst_decode(),
10412                    }
10413                }
10414                1 => {
10415                    let ans = unsafe { self.kind.LiquidAddress };
10416                    crate::bindings::InputType::LiquidAddress {
10417                        address: ans.address.cst_decode(),
10418                    }
10419                }
10420                2 => {
10421                    let ans = unsafe { self.kind.Bolt11 };
10422                    crate::bindings::InputType::Bolt11 {
10423                        invoice: ans.invoice.cst_decode(),
10424                    }
10425                }
10426                3 => {
10427                    let ans = unsafe { self.kind.Bolt12Offer };
10428                    crate::bindings::InputType::Bolt12Offer {
10429                        offer: ans.offer.cst_decode(),
10430                        bip353_address: ans.bip353_address.cst_decode(),
10431                    }
10432                }
10433                4 => {
10434                    let ans = unsafe { self.kind.NodeId };
10435                    crate::bindings::InputType::NodeId {
10436                        node_id: ans.node_id.cst_decode(),
10437                    }
10438                }
10439                5 => {
10440                    let ans = unsafe { self.kind.Url };
10441                    crate::bindings::InputType::Url {
10442                        url: ans.url.cst_decode(),
10443                    }
10444                }
10445                6 => {
10446                    let ans = unsafe { self.kind.LnUrlPay };
10447                    crate::bindings::InputType::LnUrlPay {
10448                        data: ans.data.cst_decode(),
10449                        bip353_address: ans.bip353_address.cst_decode(),
10450                    }
10451                }
10452                7 => {
10453                    let ans = unsafe { self.kind.LnUrlWithdraw };
10454                    crate::bindings::InputType::LnUrlWithdraw {
10455                        data: ans.data.cst_decode(),
10456                    }
10457                }
10458                8 => {
10459                    let ans = unsafe { self.kind.LnUrlAuth };
10460                    crate::bindings::InputType::LnUrlAuth {
10461                        data: ans.data.cst_decode(),
10462                    }
10463                }
10464                9 => {
10465                    let ans = unsafe { self.kind.LnUrlError };
10466                    crate::bindings::InputType::LnUrlError {
10467                        data: ans.data.cst_decode(),
10468                    }
10469                }
10470                _ => unreachable!(),
10471            }
10472        }
10473    }
10474    impl CstDecode<crate::model::LightningPaymentLimitsResponse>
10475        for wire_cst_lightning_payment_limits_response
10476    {
10477        // Codec=Cst (C-struct based), see doc to use other codecs
10478        fn cst_decode(self) -> crate::model::LightningPaymentLimitsResponse {
10479            crate::model::LightningPaymentLimitsResponse {
10480                send: self.send.cst_decode(),
10481                receive: self.receive.cst_decode(),
10482            }
10483        }
10484    }
10485    impl CstDecode<crate::model::Limits> for wire_cst_limits {
10486        // Codec=Cst (C-struct based), see doc to use other codecs
10487        fn cst_decode(self) -> crate::model::Limits {
10488            crate::model::Limits {
10489                min_sat: self.min_sat.cst_decode(),
10490                max_sat: self.max_sat.cst_decode(),
10491                max_zero_conf_sat: self.max_zero_conf_sat.cst_decode(),
10492            }
10493        }
10494    }
10495    impl CstDecode<crate::bindings::LiquidAddressData> for wire_cst_liquid_address_data {
10496        // Codec=Cst (C-struct based), see doc to use other codecs
10497        fn cst_decode(self) -> crate::bindings::LiquidAddressData {
10498            crate::bindings::LiquidAddressData {
10499                address: self.address.cst_decode(),
10500                network: self.network.cst_decode(),
10501                asset_id: self.asset_id.cst_decode(),
10502                amount: self.amount.cst_decode(),
10503                amount_sat: self.amount_sat.cst_decode(),
10504                label: self.label.cst_decode(),
10505                message: self.message.cst_decode(),
10506            }
10507        }
10508    }
10509    impl CstDecode<Vec<String>> for *mut wire_cst_list_String {
10510        // Codec=Cst (C-struct based), see doc to use other codecs
10511        fn cst_decode(self) -> Vec<String> {
10512            let vec = unsafe {
10513                let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10514                flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10515            };
10516            vec.into_iter().map(CstDecode::cst_decode).collect()
10517        }
10518    }
10519    impl CstDecode<Vec<crate::model::AssetBalance>> for *mut wire_cst_list_asset_balance {
10520        // Codec=Cst (C-struct based), see doc to use other codecs
10521        fn cst_decode(self) -> Vec<crate::model::AssetBalance> {
10522            let vec = unsafe {
10523                let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10524                flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10525            };
10526            vec.into_iter().map(CstDecode::cst_decode).collect()
10527        }
10528    }
10529    impl CstDecode<Vec<crate::model::AssetMetadata>> for *mut wire_cst_list_asset_metadata {
10530        // Codec=Cst (C-struct based), see doc to use other codecs
10531        fn cst_decode(self) -> Vec<crate::model::AssetMetadata> {
10532            let vec = unsafe {
10533                let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10534                flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10535            };
10536            vec.into_iter().map(CstDecode::cst_decode).collect()
10537        }
10538    }
10539    impl CstDecode<Vec<crate::bindings::ExternalInputParser>>
10540        for *mut wire_cst_list_external_input_parser
10541    {
10542        // Codec=Cst (C-struct based), see doc to use other codecs
10543        fn cst_decode(self) -> Vec<crate::bindings::ExternalInputParser> {
10544            let vec = unsafe {
10545                let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10546                flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10547            };
10548            vec.into_iter().map(CstDecode::cst_decode).collect()
10549        }
10550    }
10551    impl CstDecode<Vec<crate::bindings::FiatCurrency>> for *mut wire_cst_list_fiat_currency {
10552        // Codec=Cst (C-struct based), see doc to use other codecs
10553        fn cst_decode(self) -> Vec<crate::bindings::FiatCurrency> {
10554            let vec = unsafe {
10555                let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10556                flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10557            };
10558            vec.into_iter().map(CstDecode::cst_decode).collect()
10559        }
10560    }
10561    impl CstDecode<Vec<crate::bindings::LnOfferBlindedPath>>
10562        for *mut wire_cst_list_ln_offer_blinded_path
10563    {
10564        // Codec=Cst (C-struct based), see doc to use other codecs
10565        fn cst_decode(self) -> Vec<crate::bindings::LnOfferBlindedPath> {
10566            let vec = unsafe {
10567                let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10568                flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10569            };
10570            vec.into_iter().map(CstDecode::cst_decode).collect()
10571        }
10572    }
10573    impl CstDecode<Vec<crate::bindings::LocaleOverrides>> for *mut wire_cst_list_locale_overrides {
10574        // Codec=Cst (C-struct based), see doc to use other codecs
10575        fn cst_decode(self) -> Vec<crate::bindings::LocaleOverrides> {
10576            let vec = unsafe {
10577                let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10578                flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10579            };
10580            vec.into_iter().map(CstDecode::cst_decode).collect()
10581        }
10582    }
10583    impl CstDecode<Vec<crate::bindings::LocalizedName>> for *mut wire_cst_list_localized_name {
10584        // Codec=Cst (C-struct based), see doc to use other codecs
10585        fn cst_decode(self) -> Vec<crate::bindings::LocalizedName> {
10586            let vec = unsafe {
10587                let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10588                flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10589            };
10590            vec.into_iter().map(CstDecode::cst_decode).collect()
10591        }
10592    }
10593    impl CstDecode<Vec<crate::model::Payment>> for *mut wire_cst_list_payment {
10594        // Codec=Cst (C-struct based), see doc to use other codecs
10595        fn cst_decode(self) -> Vec<crate::model::Payment> {
10596            let vec = unsafe {
10597                let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10598                flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10599            };
10600            vec.into_iter().map(CstDecode::cst_decode).collect()
10601        }
10602    }
10603    impl CstDecode<crate::model::ListPaymentDetails> for wire_cst_list_payment_details {
10604        // Codec=Cst (C-struct based), see doc to use other codecs
10605        fn cst_decode(self) -> crate::model::ListPaymentDetails {
10606            match self.tag {
10607                0 => {
10608                    let ans = unsafe { self.kind.Liquid };
10609                    crate::model::ListPaymentDetails::Liquid {
10610                        asset_id: ans.asset_id.cst_decode(),
10611                        destination: ans.destination.cst_decode(),
10612                    }
10613                }
10614                1 => {
10615                    let ans = unsafe { self.kind.Bitcoin };
10616                    crate::model::ListPaymentDetails::Bitcoin {
10617                        address: ans.address.cst_decode(),
10618                    }
10619                }
10620                _ => unreachable!(),
10621            }
10622        }
10623    }
10624    impl CstDecode<Vec<crate::model::PaymentState>> for *mut wire_cst_list_payment_state {
10625        // Codec=Cst (C-struct based), see doc to use other codecs
10626        fn cst_decode(self) -> Vec<crate::model::PaymentState> {
10627            let vec = unsafe {
10628                let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10629                flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10630            };
10631            vec.into_iter().map(CstDecode::cst_decode).collect()
10632        }
10633    }
10634    impl CstDecode<Vec<crate::model::PaymentType>> for *mut wire_cst_list_payment_type {
10635        // Codec=Cst (C-struct based), see doc to use other codecs
10636        fn cst_decode(self) -> Vec<crate::model::PaymentType> {
10637            let vec = unsafe {
10638                let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10639                flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10640            };
10641            vec.into_iter().map(CstDecode::cst_decode).collect()
10642        }
10643    }
10644    impl CstDecode<crate::model::ListPaymentsRequest> for wire_cst_list_payments_request {
10645        // Codec=Cst (C-struct based), see doc to use other codecs
10646        fn cst_decode(self) -> crate::model::ListPaymentsRequest {
10647            crate::model::ListPaymentsRequest {
10648                filters: self.filters.cst_decode(),
10649                states: self.states.cst_decode(),
10650                from_timestamp: self.from_timestamp.cst_decode(),
10651                to_timestamp: self.to_timestamp.cst_decode(),
10652                offset: self.offset.cst_decode(),
10653                limit: self.limit.cst_decode(),
10654                details: self.details.cst_decode(),
10655                sort_ascending: self.sort_ascending.cst_decode(),
10656            }
10657        }
10658    }
10659    impl CstDecode<Vec<u8>> for *mut wire_cst_list_prim_u_8_strict {
10660        // Codec=Cst (C-struct based), see doc to use other codecs
10661        fn cst_decode(self) -> Vec<u8> {
10662            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        }
10667    }
10668    impl CstDecode<Vec<crate::bindings::Rate>> for *mut wire_cst_list_rate {
10669        // Codec=Cst (C-struct based), see doc to use other codecs
10670        fn cst_decode(self) -> Vec<crate::bindings::Rate> {
10671            let vec = unsafe {
10672                let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10673                flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10674            };
10675            vec.into_iter().map(CstDecode::cst_decode).collect()
10676        }
10677    }
10678    impl CstDecode<Vec<crate::model::RefundableSwap>> for *mut wire_cst_list_refundable_swap {
10679        // Codec=Cst (C-struct based), see doc to use other codecs
10680        fn cst_decode(self) -> Vec<crate::model::RefundableSwap> {
10681            let vec = unsafe {
10682                let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10683                flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10684            };
10685            vec.into_iter().map(CstDecode::cst_decode).collect()
10686        }
10687    }
10688    impl CstDecode<Vec<crate::bindings::RouteHint>> for *mut wire_cst_list_route_hint {
10689        // Codec=Cst (C-struct based), see doc to use other codecs
10690        fn cst_decode(self) -> Vec<crate::bindings::RouteHint> {
10691            let vec = unsafe {
10692                let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10693                flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10694            };
10695            vec.into_iter().map(CstDecode::cst_decode).collect()
10696        }
10697    }
10698    impl CstDecode<Vec<crate::bindings::RouteHintHop>> for *mut wire_cst_list_route_hint_hop {
10699        // Codec=Cst (C-struct based), see doc to use other codecs
10700        fn cst_decode(self) -> Vec<crate::bindings::RouteHintHop> {
10701            let vec = unsafe {
10702                let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10703                flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10704            };
10705            vec.into_iter().map(CstDecode::cst_decode).collect()
10706        }
10707    }
10708    impl CstDecode<crate::bindings::LNInvoice> for wire_cst_ln_invoice {
10709        // Codec=Cst (C-struct based), see doc to use other codecs
10710        fn cst_decode(self) -> crate::bindings::LNInvoice {
10711            crate::bindings::LNInvoice {
10712                bolt11: self.bolt11.cst_decode(),
10713                network: self.network.cst_decode(),
10714                payee_pubkey: self.payee_pubkey.cst_decode(),
10715                payment_hash: self.payment_hash.cst_decode(),
10716                description: self.description.cst_decode(),
10717                description_hash: self.description_hash.cst_decode(),
10718                amount_msat: self.amount_msat.cst_decode(),
10719                timestamp: self.timestamp.cst_decode(),
10720                expiry: self.expiry.cst_decode(),
10721                routing_hints: self.routing_hints.cst_decode(),
10722                payment_secret: self.payment_secret.cst_decode(),
10723                min_final_cltv_expiry_delta: self.min_final_cltv_expiry_delta.cst_decode(),
10724            }
10725        }
10726    }
10727    impl CstDecode<crate::bindings::LNOffer> for wire_cst_ln_offer {
10728        // Codec=Cst (C-struct based), see doc to use other codecs
10729        fn cst_decode(self) -> crate::bindings::LNOffer {
10730            crate::bindings::LNOffer {
10731                offer: self.offer.cst_decode(),
10732                chains: self.chains.cst_decode(),
10733                min_amount: self.min_amount.cst_decode(),
10734                description: self.description.cst_decode(),
10735                absolute_expiry: self.absolute_expiry.cst_decode(),
10736                issuer: self.issuer.cst_decode(),
10737                signing_pubkey: self.signing_pubkey.cst_decode(),
10738                paths: self.paths.cst_decode(),
10739            }
10740        }
10741    }
10742    impl CstDecode<crate::bindings::LnOfferBlindedPath> for wire_cst_ln_offer_blinded_path {
10743        // Codec=Cst (C-struct based), see doc to use other codecs
10744        fn cst_decode(self) -> crate::bindings::LnOfferBlindedPath {
10745            crate::bindings::LnOfferBlindedPath {
10746                blinded_hops: self.blinded_hops.cst_decode(),
10747            }
10748        }
10749    }
10750    impl CstDecode<crate::bindings::duplicates::LnUrlAuthError> for wire_cst_ln_url_auth_error {
10751        // Codec=Cst (C-struct based), see doc to use other codecs
10752        fn cst_decode(self) -> crate::bindings::duplicates::LnUrlAuthError {
10753            match self.tag {
10754                0 => {
10755                    let ans = unsafe { self.kind.Generic };
10756                    crate::bindings::duplicates::LnUrlAuthError::Generic {
10757                        err: ans.err.cst_decode(),
10758                    }
10759                }
10760                1 => {
10761                    let ans = unsafe { self.kind.InvalidUri };
10762                    crate::bindings::duplicates::LnUrlAuthError::InvalidUri {
10763                        err: ans.err.cst_decode(),
10764                    }
10765                }
10766                2 => {
10767                    let ans = unsafe { self.kind.ServiceConnectivity };
10768                    crate::bindings::duplicates::LnUrlAuthError::ServiceConnectivity {
10769                        err: ans.err.cst_decode(),
10770                    }
10771                }
10772                _ => unreachable!(),
10773            }
10774        }
10775    }
10776    impl CstDecode<crate::bindings::LnUrlAuthRequestData> for wire_cst_ln_url_auth_request_data {
10777        // Codec=Cst (C-struct based), see doc to use other codecs
10778        fn cst_decode(self) -> crate::bindings::LnUrlAuthRequestData {
10779            crate::bindings::LnUrlAuthRequestData {
10780                k1: self.k1.cst_decode(),
10781                action: self.action.cst_decode(),
10782                domain: self.domain.cst_decode(),
10783                url: self.url.cst_decode(),
10784            }
10785        }
10786    }
10787    impl CstDecode<crate::bindings::duplicates::LnUrlCallbackStatus>
10788        for wire_cst_ln_url_callback_status
10789    {
10790        // Codec=Cst (C-struct based), see doc to use other codecs
10791        fn cst_decode(self) -> crate::bindings::duplicates::LnUrlCallbackStatus {
10792            match self.tag {
10793                0 => crate::bindings::duplicates::LnUrlCallbackStatus::Ok,
10794                1 => {
10795                    let ans = unsafe { self.kind.ErrorStatus };
10796                    crate::bindings::duplicates::LnUrlCallbackStatus::ErrorStatus {
10797                        data: ans.data.cst_decode(),
10798                    }
10799                }
10800                _ => unreachable!(),
10801            }
10802        }
10803    }
10804    impl CstDecode<crate::bindings::LnUrlErrorData> for wire_cst_ln_url_error_data {
10805        // Codec=Cst (C-struct based), see doc to use other codecs
10806        fn cst_decode(self) -> crate::bindings::LnUrlErrorData {
10807            crate::bindings::LnUrlErrorData {
10808                reason: self.reason.cst_decode(),
10809            }
10810        }
10811    }
10812    impl CstDecode<crate::model::LnUrlInfo> for wire_cst_ln_url_info {
10813        // Codec=Cst (C-struct based), see doc to use other codecs
10814        fn cst_decode(self) -> crate::model::LnUrlInfo {
10815            crate::model::LnUrlInfo {
10816                ln_address: self.ln_address.cst_decode(),
10817                lnurl_pay_comment: self.lnurl_pay_comment.cst_decode(),
10818                lnurl_pay_domain: self.lnurl_pay_domain.cst_decode(),
10819                lnurl_pay_metadata: self.lnurl_pay_metadata.cst_decode(),
10820                lnurl_pay_success_action: self.lnurl_pay_success_action.cst_decode(),
10821                lnurl_pay_unprocessed_success_action: self
10822                    .lnurl_pay_unprocessed_success_action
10823                    .cst_decode(),
10824                lnurl_withdraw_endpoint: self.lnurl_withdraw_endpoint.cst_decode(),
10825            }
10826        }
10827    }
10828    impl CstDecode<crate::bindings::duplicates::LnUrlPayError> for wire_cst_ln_url_pay_error {
10829        // Codec=Cst (C-struct based), see doc to use other codecs
10830        fn cst_decode(self) -> crate::bindings::duplicates::LnUrlPayError {
10831            match self.tag {
10832                0 => crate::bindings::duplicates::LnUrlPayError::AlreadyPaid,
10833                1 => {
10834                    let ans = unsafe { self.kind.Generic };
10835                    crate::bindings::duplicates::LnUrlPayError::Generic {
10836                        err: ans.err.cst_decode(),
10837                    }
10838                }
10839                2 => {
10840                    let ans = unsafe { self.kind.InsufficientBalance };
10841                    crate::bindings::duplicates::LnUrlPayError::InsufficientBalance {
10842                        err: ans.err.cst_decode(),
10843                    }
10844                }
10845                3 => {
10846                    let ans = unsafe { self.kind.InvalidAmount };
10847                    crate::bindings::duplicates::LnUrlPayError::InvalidAmount {
10848                        err: ans.err.cst_decode(),
10849                    }
10850                }
10851                4 => {
10852                    let ans = unsafe { self.kind.InvalidInvoice };
10853                    crate::bindings::duplicates::LnUrlPayError::InvalidInvoice {
10854                        err: ans.err.cst_decode(),
10855                    }
10856                }
10857                5 => {
10858                    let ans = unsafe { self.kind.InvalidNetwork };
10859                    crate::bindings::duplicates::LnUrlPayError::InvalidNetwork {
10860                        err: ans.err.cst_decode(),
10861                    }
10862                }
10863                6 => {
10864                    let ans = unsafe { self.kind.InvalidUri };
10865                    crate::bindings::duplicates::LnUrlPayError::InvalidUri {
10866                        err: ans.err.cst_decode(),
10867                    }
10868                }
10869                7 => {
10870                    let ans = unsafe { self.kind.InvoiceExpired };
10871                    crate::bindings::duplicates::LnUrlPayError::InvoiceExpired {
10872                        err: ans.err.cst_decode(),
10873                    }
10874                }
10875                8 => {
10876                    let ans = unsafe { self.kind.PaymentFailed };
10877                    crate::bindings::duplicates::LnUrlPayError::PaymentFailed {
10878                        err: ans.err.cst_decode(),
10879                    }
10880                }
10881                9 => {
10882                    let ans = unsafe { self.kind.PaymentTimeout };
10883                    crate::bindings::duplicates::LnUrlPayError::PaymentTimeout {
10884                        err: ans.err.cst_decode(),
10885                    }
10886                }
10887                10 => {
10888                    let ans = unsafe { self.kind.RouteNotFound };
10889                    crate::bindings::duplicates::LnUrlPayError::RouteNotFound {
10890                        err: ans.err.cst_decode(),
10891                    }
10892                }
10893                11 => {
10894                    let ans = unsafe { self.kind.RouteTooExpensive };
10895                    crate::bindings::duplicates::LnUrlPayError::RouteTooExpensive {
10896                        err: ans.err.cst_decode(),
10897                    }
10898                }
10899                12 => {
10900                    let ans = unsafe { self.kind.ServiceConnectivity };
10901                    crate::bindings::duplicates::LnUrlPayError::ServiceConnectivity {
10902                        err: ans.err.cst_decode(),
10903                    }
10904                }
10905                _ => unreachable!(),
10906            }
10907        }
10908    }
10909    impl CstDecode<crate::bindings::LnUrlPayErrorData> for wire_cst_ln_url_pay_error_data {
10910        // Codec=Cst (C-struct based), see doc to use other codecs
10911        fn cst_decode(self) -> crate::bindings::LnUrlPayErrorData {
10912            crate::bindings::LnUrlPayErrorData {
10913                payment_hash: self.payment_hash.cst_decode(),
10914                reason: self.reason.cst_decode(),
10915            }
10916        }
10917    }
10918    impl CstDecode<crate::model::LnUrlPayRequest> for wire_cst_ln_url_pay_request {
10919        // Codec=Cst (C-struct based), see doc to use other codecs
10920        fn cst_decode(self) -> crate::model::LnUrlPayRequest {
10921            crate::model::LnUrlPayRequest {
10922                prepare_response: self.prepare_response.cst_decode(),
10923            }
10924        }
10925    }
10926    impl CstDecode<crate::bindings::LnUrlPayRequestData> for wire_cst_ln_url_pay_request_data {
10927        // Codec=Cst (C-struct based), see doc to use other codecs
10928        fn cst_decode(self) -> crate::bindings::LnUrlPayRequestData {
10929            crate::bindings::LnUrlPayRequestData {
10930                callback: self.callback.cst_decode(),
10931                min_sendable: self.min_sendable.cst_decode(),
10932                max_sendable: self.max_sendable.cst_decode(),
10933                metadata_str: self.metadata_str.cst_decode(),
10934                comment_allowed: self.comment_allowed.cst_decode(),
10935                domain: self.domain.cst_decode(),
10936                allows_nostr: self.allows_nostr.cst_decode(),
10937                nostr_pubkey: self.nostr_pubkey.cst_decode(),
10938                ln_address: self.ln_address.cst_decode(),
10939            }
10940        }
10941    }
10942    impl CstDecode<crate::model::LnUrlPayResult> for wire_cst_ln_url_pay_result {
10943        // Codec=Cst (C-struct based), see doc to use other codecs
10944        fn cst_decode(self) -> crate::model::LnUrlPayResult {
10945            match self.tag {
10946                0 => {
10947                    let ans = unsafe { self.kind.EndpointSuccess };
10948                    crate::model::LnUrlPayResult::EndpointSuccess {
10949                        data: ans.data.cst_decode(),
10950                    }
10951                }
10952                1 => {
10953                    let ans = unsafe { self.kind.EndpointError };
10954                    crate::model::LnUrlPayResult::EndpointError {
10955                        data: ans.data.cst_decode(),
10956                    }
10957                }
10958                2 => {
10959                    let ans = unsafe { self.kind.PayError };
10960                    crate::model::LnUrlPayResult::PayError {
10961                        data: ans.data.cst_decode(),
10962                    }
10963                }
10964                _ => unreachable!(),
10965            }
10966        }
10967    }
10968    impl CstDecode<crate::model::LnUrlPaySuccessData> for wire_cst_ln_url_pay_success_data {
10969        // Codec=Cst (C-struct based), see doc to use other codecs
10970        fn cst_decode(self) -> crate::model::LnUrlPaySuccessData {
10971            crate::model::LnUrlPaySuccessData {
10972                payment: self.payment.cst_decode(),
10973                success_action: self.success_action.cst_decode(),
10974            }
10975        }
10976    }
10977    impl CstDecode<crate::bindings::duplicates::LnUrlWithdrawError> for wire_cst_ln_url_withdraw_error {
10978        // Codec=Cst (C-struct based), see doc to use other codecs
10979        fn cst_decode(self) -> crate::bindings::duplicates::LnUrlWithdrawError {
10980            match self.tag {
10981                0 => {
10982                    let ans = unsafe { self.kind.Generic };
10983                    crate::bindings::duplicates::LnUrlWithdrawError::Generic {
10984                        err: ans.err.cst_decode(),
10985                    }
10986                }
10987                1 => {
10988                    let ans = unsafe { self.kind.InvalidAmount };
10989                    crate::bindings::duplicates::LnUrlWithdrawError::InvalidAmount {
10990                        err: ans.err.cst_decode(),
10991                    }
10992                }
10993                2 => {
10994                    let ans = unsafe { self.kind.InvalidInvoice };
10995                    crate::bindings::duplicates::LnUrlWithdrawError::InvalidInvoice {
10996                        err: ans.err.cst_decode(),
10997                    }
10998                }
10999                3 => {
11000                    let ans = unsafe { self.kind.InvalidUri };
11001                    crate::bindings::duplicates::LnUrlWithdrawError::InvalidUri {
11002                        err: ans.err.cst_decode(),
11003                    }
11004                }
11005                4 => {
11006                    let ans = unsafe { self.kind.InvoiceNoRoutingHints };
11007                    crate::bindings::duplicates::LnUrlWithdrawError::InvoiceNoRoutingHints {
11008                        err: ans.err.cst_decode(),
11009                    }
11010                }
11011                5 => {
11012                    let ans = unsafe { self.kind.ServiceConnectivity };
11013                    crate::bindings::duplicates::LnUrlWithdrawError::ServiceConnectivity {
11014                        err: ans.err.cst_decode(),
11015                    }
11016                }
11017                _ => unreachable!(),
11018            }
11019        }
11020    }
11021    impl CstDecode<crate::bindings::LnUrlWithdrawRequest> for wire_cst_ln_url_withdraw_request {
11022        // Codec=Cst (C-struct based), see doc to use other codecs
11023        fn cst_decode(self) -> crate::bindings::LnUrlWithdrawRequest {
11024            crate::bindings::LnUrlWithdrawRequest {
11025                data: self.data.cst_decode(),
11026                amount_msat: self.amount_msat.cst_decode(),
11027                description: self.description.cst_decode(),
11028            }
11029        }
11030    }
11031    impl CstDecode<crate::bindings::LnUrlWithdrawRequestData>
11032        for wire_cst_ln_url_withdraw_request_data
11033    {
11034        // Codec=Cst (C-struct based), see doc to use other codecs
11035        fn cst_decode(self) -> crate::bindings::LnUrlWithdrawRequestData {
11036            crate::bindings::LnUrlWithdrawRequestData {
11037                callback: self.callback.cst_decode(),
11038                k1: self.k1.cst_decode(),
11039                default_description: self.default_description.cst_decode(),
11040                min_withdrawable: self.min_withdrawable.cst_decode(),
11041                max_withdrawable: self.max_withdrawable.cst_decode(),
11042            }
11043        }
11044    }
11045    impl CstDecode<crate::bindings::duplicates::LnUrlWithdrawResult>
11046        for wire_cst_ln_url_withdraw_result
11047    {
11048        // Codec=Cst (C-struct based), see doc to use other codecs
11049        fn cst_decode(self) -> crate::bindings::duplicates::LnUrlWithdrawResult {
11050            match self.tag {
11051                0 => {
11052                    let ans = unsafe { self.kind.Ok };
11053                    crate::bindings::duplicates::LnUrlWithdrawResult::Ok {
11054                        data: ans.data.cst_decode(),
11055                    }
11056                }
11057                1 => {
11058                    let ans = unsafe { self.kind.Timeout };
11059                    crate::bindings::duplicates::LnUrlWithdrawResult::Timeout {
11060                        data: ans.data.cst_decode(),
11061                    }
11062                }
11063                2 => {
11064                    let ans = unsafe { self.kind.ErrorStatus };
11065                    crate::bindings::duplicates::LnUrlWithdrawResult::ErrorStatus {
11066                        data: ans.data.cst_decode(),
11067                    }
11068                }
11069                _ => unreachable!(),
11070            }
11071        }
11072    }
11073    impl CstDecode<crate::bindings::duplicates::LnUrlWithdrawSuccessData>
11074        for wire_cst_ln_url_withdraw_success_data
11075    {
11076        // Codec=Cst (C-struct based), see doc to use other codecs
11077        fn cst_decode(self) -> crate::bindings::duplicates::LnUrlWithdrawSuccessData {
11078            crate::bindings::duplicates::LnUrlWithdrawSuccessData {
11079                invoice: self.invoice.cst_decode(),
11080            }
11081        }
11082    }
11083    impl CstDecode<crate::bindings::LocaleOverrides> for wire_cst_locale_overrides {
11084        // Codec=Cst (C-struct based), see doc to use other codecs
11085        fn cst_decode(self) -> crate::bindings::LocaleOverrides {
11086            crate::bindings::LocaleOverrides {
11087                locale: self.locale.cst_decode(),
11088                spacing: self.spacing.cst_decode(),
11089                symbol: self.symbol.cst_decode(),
11090            }
11091        }
11092    }
11093    impl CstDecode<crate::bindings::LocalizedName> for wire_cst_localized_name {
11094        // Codec=Cst (C-struct based), see doc to use other codecs
11095        fn cst_decode(self) -> crate::bindings::LocalizedName {
11096            crate::bindings::LocalizedName {
11097                locale: self.locale.cst_decode(),
11098                name: self.name.cst_decode(),
11099            }
11100        }
11101    }
11102    impl CstDecode<crate::model::LogEntry> for wire_cst_log_entry {
11103        // Codec=Cst (C-struct based), see doc to use other codecs
11104        fn cst_decode(self) -> crate::model::LogEntry {
11105            crate::model::LogEntry {
11106                line: self.line.cst_decode(),
11107                level: self.level.cst_decode(),
11108            }
11109        }
11110    }
11111    impl CstDecode<crate::bindings::MessageSuccessActionData> for wire_cst_message_success_action_data {
11112        // Codec=Cst (C-struct based), see doc to use other codecs
11113        fn cst_decode(self) -> crate::bindings::MessageSuccessActionData {
11114            crate::bindings::MessageSuccessActionData {
11115                message: self.message.cst_decode(),
11116            }
11117        }
11118    }
11119    impl CstDecode<crate::model::OnchainPaymentLimitsResponse>
11120        for wire_cst_onchain_payment_limits_response
11121    {
11122        // Codec=Cst (C-struct based), see doc to use other codecs
11123        fn cst_decode(self) -> crate::model::OnchainPaymentLimitsResponse {
11124            crate::model::OnchainPaymentLimitsResponse {
11125                send: self.send.cst_decode(),
11126                receive: self.receive.cst_decode(),
11127            }
11128        }
11129    }
11130    impl CstDecode<crate::model::PayAmount> for wire_cst_pay_amount {
11131        // Codec=Cst (C-struct based), see doc to use other codecs
11132        fn cst_decode(self) -> crate::model::PayAmount {
11133            match self.tag {
11134                0 => {
11135                    let ans = unsafe { self.kind.Bitcoin };
11136                    crate::model::PayAmount::Bitcoin {
11137                        receiver_amount_sat: ans.receiver_amount_sat.cst_decode(),
11138                    }
11139                }
11140                1 => {
11141                    let ans = unsafe { self.kind.Asset };
11142                    crate::model::PayAmount::Asset {
11143                        asset_id: ans.asset_id.cst_decode(),
11144                        receiver_amount: ans.receiver_amount.cst_decode(),
11145                        estimate_asset_fees: ans.estimate_asset_fees.cst_decode(),
11146                        pay_with_bitcoin: ans.pay_with_bitcoin.cst_decode(),
11147                    }
11148                }
11149                2 => crate::model::PayAmount::Drain,
11150                _ => unreachable!(),
11151            }
11152        }
11153    }
11154    impl CstDecode<crate::model::PayOnchainRequest> for wire_cst_pay_onchain_request {
11155        // Codec=Cst (C-struct based), see doc to use other codecs
11156        fn cst_decode(self) -> crate::model::PayOnchainRequest {
11157            crate::model::PayOnchainRequest {
11158                address: self.address.cst_decode(),
11159                prepare_response: self.prepare_response.cst_decode(),
11160            }
11161        }
11162    }
11163    impl CstDecode<crate::model::Payment> for wire_cst_payment {
11164        // Codec=Cst (C-struct based), see doc to use other codecs
11165        fn cst_decode(self) -> crate::model::Payment {
11166            crate::model::Payment {
11167                destination: self.destination.cst_decode(),
11168                tx_id: self.tx_id.cst_decode(),
11169                unblinding_data: self.unblinding_data.cst_decode(),
11170                timestamp: self.timestamp.cst_decode(),
11171                amount_sat: self.amount_sat.cst_decode(),
11172                fees_sat: self.fees_sat.cst_decode(),
11173                swapper_fees_sat: self.swapper_fees_sat.cst_decode(),
11174                payment_type: self.payment_type.cst_decode(),
11175                status: self.status.cst_decode(),
11176                details: self.details.cst_decode(),
11177            }
11178        }
11179    }
11180    impl CstDecode<crate::model::PaymentDetails> for wire_cst_payment_details {
11181        // Codec=Cst (C-struct based), see doc to use other codecs
11182        fn cst_decode(self) -> crate::model::PaymentDetails {
11183            match self.tag {
11184                0 => {
11185                    let ans = unsafe { self.kind.Lightning };
11186                    crate::model::PaymentDetails::Lightning {
11187                        swap_id: ans.swap_id.cst_decode(),
11188                        description: ans.description.cst_decode(),
11189                        liquid_expiration_blockheight: ans
11190                            .liquid_expiration_blockheight
11191                            .cst_decode(),
11192                        preimage: ans.preimage.cst_decode(),
11193                        invoice: ans.invoice.cst_decode(),
11194                        bolt12_offer: ans.bolt12_offer.cst_decode(),
11195                        payment_hash: ans.payment_hash.cst_decode(),
11196                        destination_pubkey: ans.destination_pubkey.cst_decode(),
11197                        lnurl_info: ans.lnurl_info.cst_decode(),
11198                        bip353_address: ans.bip353_address.cst_decode(),
11199                        payer_note: ans.payer_note.cst_decode(),
11200                        claim_tx_id: ans.claim_tx_id.cst_decode(),
11201                        refund_tx_id: ans.refund_tx_id.cst_decode(),
11202                        refund_tx_amount_sat: ans.refund_tx_amount_sat.cst_decode(),
11203                    }
11204                }
11205                1 => {
11206                    let ans = unsafe { self.kind.Liquid };
11207                    crate::model::PaymentDetails::Liquid {
11208                        destination: ans.destination.cst_decode(),
11209                        description: ans.description.cst_decode(),
11210                        asset_id: ans.asset_id.cst_decode(),
11211                        asset_info: ans.asset_info.cst_decode(),
11212                        lnurl_info: ans.lnurl_info.cst_decode(),
11213                        bip353_address: ans.bip353_address.cst_decode(),
11214                        payer_note: ans.payer_note.cst_decode(),
11215                    }
11216                }
11217                2 => {
11218                    let ans = unsafe { self.kind.Bitcoin };
11219                    crate::model::PaymentDetails::Bitcoin {
11220                        swap_id: ans.swap_id.cst_decode(),
11221                        bitcoin_address: ans.bitcoin_address.cst_decode(),
11222                        description: ans.description.cst_decode(),
11223                        auto_accepted_fees: ans.auto_accepted_fees.cst_decode(),
11224                        liquid_expiration_blockheight: ans
11225                            .liquid_expiration_blockheight
11226                            .cst_decode(),
11227                        bitcoin_expiration_blockheight: ans
11228                            .bitcoin_expiration_blockheight
11229                            .cst_decode(),
11230                        lockup_tx_id: ans.lockup_tx_id.cst_decode(),
11231                        claim_tx_id: ans.claim_tx_id.cst_decode(),
11232                        refund_tx_id: ans.refund_tx_id.cst_decode(),
11233                        refund_tx_amount_sat: ans.refund_tx_amount_sat.cst_decode(),
11234                    }
11235                }
11236                _ => unreachable!(),
11237            }
11238        }
11239    }
11240    impl CstDecode<crate::error::PaymentError> for wire_cst_payment_error {
11241        // Codec=Cst (C-struct based), see doc to use other codecs
11242        fn cst_decode(self) -> crate::error::PaymentError {
11243            match self.tag {
11244                0 => crate::error::PaymentError::AlreadyClaimed,
11245                1 => crate::error::PaymentError::AlreadyPaid,
11246                2 => crate::error::PaymentError::PaymentInProgress,
11247                3 => {
11248                    let ans = unsafe { self.kind.AmountOutOfRange };
11249                    crate::error::PaymentError::AmountOutOfRange {
11250                        min: ans.min.cst_decode(),
11251                        max: ans.max.cst_decode(),
11252                    }
11253                }
11254                4 => {
11255                    let ans = unsafe { self.kind.AmountMissing };
11256                    crate::error::PaymentError::AmountMissing {
11257                        err: ans.err.cst_decode(),
11258                    }
11259                }
11260                5 => {
11261                    let ans = unsafe { self.kind.AssetError };
11262                    crate::error::PaymentError::AssetError {
11263                        err: ans.err.cst_decode(),
11264                    }
11265                }
11266                6 => {
11267                    let ans = unsafe { self.kind.InvalidNetwork };
11268                    crate::error::PaymentError::InvalidNetwork {
11269                        err: ans.err.cst_decode(),
11270                    }
11271                }
11272                7 => {
11273                    let ans = unsafe { self.kind.Generic };
11274                    crate::error::PaymentError::Generic {
11275                        err: ans.err.cst_decode(),
11276                    }
11277                }
11278                8 => crate::error::PaymentError::InvalidOrExpiredFees,
11279                9 => crate::error::PaymentError::InsufficientFunds,
11280                10 => {
11281                    let ans = unsafe { self.kind.InvalidDescription };
11282                    crate::error::PaymentError::InvalidDescription {
11283                        err: ans.err.cst_decode(),
11284                    }
11285                }
11286                11 => {
11287                    let ans = unsafe { self.kind.InvalidInvoice };
11288                    crate::error::PaymentError::InvalidInvoice {
11289                        err: ans.err.cst_decode(),
11290                    }
11291                }
11292                12 => crate::error::PaymentError::InvalidPreimage,
11293                13 => crate::error::PaymentError::PairsNotFound,
11294                14 => crate::error::PaymentError::PaymentTimeout,
11295                15 => crate::error::PaymentError::PersistError,
11296                16 => {
11297                    let ans = unsafe { self.kind.ReceiveError };
11298                    crate::error::PaymentError::ReceiveError {
11299                        err: ans.err.cst_decode(),
11300                    }
11301                }
11302                17 => {
11303                    let ans = unsafe { self.kind.Refunded };
11304                    crate::error::PaymentError::Refunded {
11305                        err: ans.err.cst_decode(),
11306                        refund_tx_id: ans.refund_tx_id.cst_decode(),
11307                    }
11308                }
11309                18 => crate::error::PaymentError::SelfTransferNotSupported,
11310                19 => {
11311                    let ans = unsafe { self.kind.SendError };
11312                    crate::error::PaymentError::SendError {
11313                        err: ans.err.cst_decode(),
11314                    }
11315                }
11316                20 => {
11317                    let ans = unsafe { self.kind.SignerError };
11318                    crate::error::PaymentError::SignerError {
11319                        err: ans.err.cst_decode(),
11320                    }
11321                }
11322                _ => unreachable!(),
11323            }
11324        }
11325    }
11326    impl CstDecode<crate::model::PrepareBuyBitcoinRequest> for wire_cst_prepare_buy_bitcoin_request {
11327        // Codec=Cst (C-struct based), see doc to use other codecs
11328        fn cst_decode(self) -> crate::model::PrepareBuyBitcoinRequest {
11329            crate::model::PrepareBuyBitcoinRequest {
11330                provider: self.provider.cst_decode(),
11331                amount_sat: self.amount_sat.cst_decode(),
11332            }
11333        }
11334    }
11335    impl CstDecode<crate::model::PrepareBuyBitcoinResponse> for wire_cst_prepare_buy_bitcoin_response {
11336        // Codec=Cst (C-struct based), see doc to use other codecs
11337        fn cst_decode(self) -> crate::model::PrepareBuyBitcoinResponse {
11338            crate::model::PrepareBuyBitcoinResponse {
11339                provider: self.provider.cst_decode(),
11340                amount_sat: self.amount_sat.cst_decode(),
11341                fees_sat: self.fees_sat.cst_decode(),
11342            }
11343        }
11344    }
11345    impl CstDecode<crate::model::PrepareLnUrlPayRequest> for wire_cst_prepare_ln_url_pay_request {
11346        // Codec=Cst (C-struct based), see doc to use other codecs
11347        fn cst_decode(self) -> crate::model::PrepareLnUrlPayRequest {
11348            crate::model::PrepareLnUrlPayRequest {
11349                data: self.data.cst_decode(),
11350                amount: self.amount.cst_decode(),
11351                bip353_address: self.bip353_address.cst_decode(),
11352                comment: self.comment.cst_decode(),
11353                validate_success_action_url: self.validate_success_action_url.cst_decode(),
11354            }
11355        }
11356    }
11357    impl CstDecode<crate::model::PrepareLnUrlPayResponse> for wire_cst_prepare_ln_url_pay_response {
11358        // Codec=Cst (C-struct based), see doc to use other codecs
11359        fn cst_decode(self) -> crate::model::PrepareLnUrlPayResponse {
11360            crate::model::PrepareLnUrlPayResponse {
11361                destination: self.destination.cst_decode(),
11362                fees_sat: self.fees_sat.cst_decode(),
11363                data: self.data.cst_decode(),
11364                amount: self.amount.cst_decode(),
11365                comment: self.comment.cst_decode(),
11366                success_action: self.success_action.cst_decode(),
11367            }
11368        }
11369    }
11370    impl CstDecode<crate::model::PreparePayOnchainRequest> for wire_cst_prepare_pay_onchain_request {
11371        // Codec=Cst (C-struct based), see doc to use other codecs
11372        fn cst_decode(self) -> crate::model::PreparePayOnchainRequest {
11373            crate::model::PreparePayOnchainRequest {
11374                amount: self.amount.cst_decode(),
11375                fee_rate_sat_per_vbyte: self.fee_rate_sat_per_vbyte.cst_decode(),
11376            }
11377        }
11378    }
11379    impl CstDecode<crate::model::PreparePayOnchainResponse> for wire_cst_prepare_pay_onchain_response {
11380        // Codec=Cst (C-struct based), see doc to use other codecs
11381        fn cst_decode(self) -> crate::model::PreparePayOnchainResponse {
11382            crate::model::PreparePayOnchainResponse {
11383                receiver_amount_sat: self.receiver_amount_sat.cst_decode(),
11384                claim_fees_sat: self.claim_fees_sat.cst_decode(),
11385                total_fees_sat: self.total_fees_sat.cst_decode(),
11386            }
11387        }
11388    }
11389    impl CstDecode<crate::model::PrepareReceiveRequest> for wire_cst_prepare_receive_request {
11390        // Codec=Cst (C-struct based), see doc to use other codecs
11391        fn cst_decode(self) -> crate::model::PrepareReceiveRequest {
11392            crate::model::PrepareReceiveRequest {
11393                payment_method: self.payment_method.cst_decode(),
11394                amount: self.amount.cst_decode(),
11395            }
11396        }
11397    }
11398    impl CstDecode<crate::model::PrepareReceiveResponse> for wire_cst_prepare_receive_response {
11399        // Codec=Cst (C-struct based), see doc to use other codecs
11400        fn cst_decode(self) -> crate::model::PrepareReceiveResponse {
11401            crate::model::PrepareReceiveResponse {
11402                payment_method: self.payment_method.cst_decode(),
11403                fees_sat: self.fees_sat.cst_decode(),
11404                amount: self.amount.cst_decode(),
11405                min_payer_amount_sat: self.min_payer_amount_sat.cst_decode(),
11406                max_payer_amount_sat: self.max_payer_amount_sat.cst_decode(),
11407                swapper_feerate: self.swapper_feerate.cst_decode(),
11408            }
11409        }
11410    }
11411    impl CstDecode<crate::model::PrepareRefundRequest> for wire_cst_prepare_refund_request {
11412        // Codec=Cst (C-struct based), see doc to use other codecs
11413        fn cst_decode(self) -> crate::model::PrepareRefundRequest {
11414            crate::model::PrepareRefundRequest {
11415                swap_address: self.swap_address.cst_decode(),
11416                refund_address: self.refund_address.cst_decode(),
11417                fee_rate_sat_per_vbyte: self.fee_rate_sat_per_vbyte.cst_decode(),
11418            }
11419        }
11420    }
11421    impl CstDecode<crate::model::PrepareRefundResponse> for wire_cst_prepare_refund_response {
11422        // Codec=Cst (C-struct based), see doc to use other codecs
11423        fn cst_decode(self) -> crate::model::PrepareRefundResponse {
11424            crate::model::PrepareRefundResponse {
11425                tx_vsize: self.tx_vsize.cst_decode(),
11426                tx_fee_sat: self.tx_fee_sat.cst_decode(),
11427                last_refund_tx_id: self.last_refund_tx_id.cst_decode(),
11428            }
11429        }
11430    }
11431    impl CstDecode<crate::model::PrepareSendRequest> for wire_cst_prepare_send_request {
11432        // Codec=Cst (C-struct based), see doc to use other codecs
11433        fn cst_decode(self) -> crate::model::PrepareSendRequest {
11434            crate::model::PrepareSendRequest {
11435                destination: self.destination.cst_decode(),
11436                amount: self.amount.cst_decode(),
11437            }
11438        }
11439    }
11440    impl CstDecode<crate::model::PrepareSendResponse> for wire_cst_prepare_send_response {
11441        // Codec=Cst (C-struct based), see doc to use other codecs
11442        fn cst_decode(self) -> crate::model::PrepareSendResponse {
11443            crate::model::PrepareSendResponse {
11444                destination: self.destination.cst_decode(),
11445                amount: self.amount.cst_decode(),
11446                fees_sat: self.fees_sat.cst_decode(),
11447                estimated_asset_fees: self.estimated_asset_fees.cst_decode(),
11448            }
11449        }
11450    }
11451    impl CstDecode<crate::bindings::Rate> for wire_cst_rate {
11452        // Codec=Cst (C-struct based), see doc to use other codecs
11453        fn cst_decode(self) -> crate::bindings::Rate {
11454            crate::bindings::Rate {
11455                coin: self.coin.cst_decode(),
11456                value: self.value.cst_decode(),
11457            }
11458        }
11459    }
11460    impl CstDecode<crate::model::ReceiveAmount> for wire_cst_receive_amount {
11461        // Codec=Cst (C-struct based), see doc to use other codecs
11462        fn cst_decode(self) -> crate::model::ReceiveAmount {
11463            match self.tag {
11464                0 => {
11465                    let ans = unsafe { self.kind.Bitcoin };
11466                    crate::model::ReceiveAmount::Bitcoin {
11467                        payer_amount_sat: ans.payer_amount_sat.cst_decode(),
11468                    }
11469                }
11470                1 => {
11471                    let ans = unsafe { self.kind.Asset };
11472                    crate::model::ReceiveAmount::Asset {
11473                        asset_id: ans.asset_id.cst_decode(),
11474                        payer_amount: ans.payer_amount.cst_decode(),
11475                    }
11476                }
11477                _ => unreachable!(),
11478            }
11479        }
11480    }
11481    impl CstDecode<crate::model::ReceivePaymentRequest> for wire_cst_receive_payment_request {
11482        // Codec=Cst (C-struct based), see doc to use other codecs
11483        fn cst_decode(self) -> crate::model::ReceivePaymentRequest {
11484            crate::model::ReceivePaymentRequest {
11485                prepare_response: self.prepare_response.cst_decode(),
11486                description: self.description.cst_decode(),
11487                use_description_hash: self.use_description_hash.cst_decode(),
11488                payer_note: self.payer_note.cst_decode(),
11489            }
11490        }
11491    }
11492    impl CstDecode<crate::model::ReceivePaymentResponse> for wire_cst_receive_payment_response {
11493        // Codec=Cst (C-struct based), see doc to use other codecs
11494        fn cst_decode(self) -> crate::model::ReceivePaymentResponse {
11495            crate::model::ReceivePaymentResponse {
11496                destination: self.destination.cst_decode(),
11497            }
11498        }
11499    }
11500    impl CstDecode<crate::model::RecommendedFees> for wire_cst_recommended_fees {
11501        // Codec=Cst (C-struct based), see doc to use other codecs
11502        fn cst_decode(self) -> crate::model::RecommendedFees {
11503            crate::model::RecommendedFees {
11504                fastest_fee: self.fastest_fee.cst_decode(),
11505                half_hour_fee: self.half_hour_fee.cst_decode(),
11506                hour_fee: self.hour_fee.cst_decode(),
11507                economy_fee: self.economy_fee.cst_decode(),
11508                minimum_fee: self.minimum_fee.cst_decode(),
11509            }
11510        }
11511    }
11512    impl CstDecode<crate::model::RefundRequest> for wire_cst_refund_request {
11513        // Codec=Cst (C-struct based), see doc to use other codecs
11514        fn cst_decode(self) -> crate::model::RefundRequest {
11515            crate::model::RefundRequest {
11516                swap_address: self.swap_address.cst_decode(),
11517                refund_address: self.refund_address.cst_decode(),
11518                fee_rate_sat_per_vbyte: self.fee_rate_sat_per_vbyte.cst_decode(),
11519            }
11520        }
11521    }
11522    impl CstDecode<crate::model::RefundResponse> for wire_cst_refund_response {
11523        // Codec=Cst (C-struct based), see doc to use other codecs
11524        fn cst_decode(self) -> crate::model::RefundResponse {
11525            crate::model::RefundResponse {
11526                refund_tx_id: self.refund_tx_id.cst_decode(),
11527            }
11528        }
11529    }
11530    impl CstDecode<crate::model::RefundableSwap> for wire_cst_refundable_swap {
11531        // Codec=Cst (C-struct based), see doc to use other codecs
11532        fn cst_decode(self) -> crate::model::RefundableSwap {
11533            crate::model::RefundableSwap {
11534                swap_address: self.swap_address.cst_decode(),
11535                timestamp: self.timestamp.cst_decode(),
11536                amount_sat: self.amount_sat.cst_decode(),
11537                last_refund_tx_id: self.last_refund_tx_id.cst_decode(),
11538            }
11539        }
11540    }
11541    impl CstDecode<crate::model::RestoreRequest> for wire_cst_restore_request {
11542        // Codec=Cst (C-struct based), see doc to use other codecs
11543        fn cst_decode(self) -> crate::model::RestoreRequest {
11544            crate::model::RestoreRequest {
11545                backup_path: self.backup_path.cst_decode(),
11546            }
11547        }
11548    }
11549    impl CstDecode<crate::bindings::RouteHint> for wire_cst_route_hint {
11550        // Codec=Cst (C-struct based), see doc to use other codecs
11551        fn cst_decode(self) -> crate::bindings::RouteHint {
11552            crate::bindings::RouteHint {
11553                hops: self.hops.cst_decode(),
11554            }
11555        }
11556    }
11557    impl CstDecode<crate::bindings::RouteHintHop> for wire_cst_route_hint_hop {
11558        // Codec=Cst (C-struct based), see doc to use other codecs
11559        fn cst_decode(self) -> crate::bindings::RouteHintHop {
11560            crate::bindings::RouteHintHop {
11561                src_node_id: self.src_node_id.cst_decode(),
11562                short_channel_id: self.short_channel_id.cst_decode(),
11563                fees_base_msat: self.fees_base_msat.cst_decode(),
11564                fees_proportional_millionths: self.fees_proportional_millionths.cst_decode(),
11565                cltv_expiry_delta: self.cltv_expiry_delta.cst_decode(),
11566                htlc_minimum_msat: self.htlc_minimum_msat.cst_decode(),
11567                htlc_maximum_msat: self.htlc_maximum_msat.cst_decode(),
11568            }
11569        }
11570    }
11571    impl CstDecode<crate::error::SdkError> for wire_cst_sdk_error {
11572        // Codec=Cst (C-struct based), see doc to use other codecs
11573        fn cst_decode(self) -> crate::error::SdkError {
11574            match self.tag {
11575                0 => crate::error::SdkError::AlreadyStarted,
11576                1 => {
11577                    let ans = unsafe { self.kind.Generic };
11578                    crate::error::SdkError::Generic {
11579                        err: ans.err.cst_decode(),
11580                    }
11581                }
11582                2 => crate::error::SdkError::NotStarted,
11583                3 => {
11584                    let ans = unsafe { self.kind.ServiceConnectivity };
11585                    crate::error::SdkError::ServiceConnectivity {
11586                        err: ans.err.cst_decode(),
11587                    }
11588                }
11589                _ => unreachable!(),
11590            }
11591        }
11592    }
11593    impl CstDecode<crate::model::SdkEvent> for wire_cst_sdk_event {
11594        // Codec=Cst (C-struct based), see doc to use other codecs
11595        fn cst_decode(self) -> crate::model::SdkEvent {
11596            match self.tag {
11597                0 => {
11598                    let ans = unsafe { self.kind.PaymentFailed };
11599                    crate::model::SdkEvent::PaymentFailed {
11600                        details: ans.details.cst_decode(),
11601                    }
11602                }
11603                1 => {
11604                    let ans = unsafe { self.kind.PaymentPending };
11605                    crate::model::SdkEvent::PaymentPending {
11606                        details: ans.details.cst_decode(),
11607                    }
11608                }
11609                2 => {
11610                    let ans = unsafe { self.kind.PaymentRefundable };
11611                    crate::model::SdkEvent::PaymentRefundable {
11612                        details: ans.details.cst_decode(),
11613                    }
11614                }
11615                3 => {
11616                    let ans = unsafe { self.kind.PaymentRefunded };
11617                    crate::model::SdkEvent::PaymentRefunded {
11618                        details: ans.details.cst_decode(),
11619                    }
11620                }
11621                4 => {
11622                    let ans = unsafe { self.kind.PaymentRefundPending };
11623                    crate::model::SdkEvent::PaymentRefundPending {
11624                        details: ans.details.cst_decode(),
11625                    }
11626                }
11627                5 => {
11628                    let ans = unsafe { self.kind.PaymentSucceeded };
11629                    crate::model::SdkEvent::PaymentSucceeded {
11630                        details: ans.details.cst_decode(),
11631                    }
11632                }
11633                6 => {
11634                    let ans = unsafe { self.kind.PaymentWaitingConfirmation };
11635                    crate::model::SdkEvent::PaymentWaitingConfirmation {
11636                        details: ans.details.cst_decode(),
11637                    }
11638                }
11639                7 => {
11640                    let ans = unsafe { self.kind.PaymentWaitingFeeAcceptance };
11641                    crate::model::SdkEvent::PaymentWaitingFeeAcceptance {
11642                        details: ans.details.cst_decode(),
11643                    }
11644                }
11645                8 => crate::model::SdkEvent::Synced,
11646                9 => {
11647                    let ans = unsafe { self.kind.DataSynced };
11648                    crate::model::SdkEvent::DataSynced {
11649                        did_pull_new_records: ans.did_pull_new_records.cst_decode(),
11650                    }
11651                }
11652                _ => unreachable!(),
11653            }
11654        }
11655    }
11656    impl CstDecode<crate::model::SendDestination> for wire_cst_send_destination {
11657        // Codec=Cst (C-struct based), see doc to use other codecs
11658        fn cst_decode(self) -> crate::model::SendDestination {
11659            match self.tag {
11660                0 => {
11661                    let ans = unsafe { self.kind.LiquidAddress };
11662                    crate::model::SendDestination::LiquidAddress {
11663                        address_data: ans.address_data.cst_decode(),
11664                        bip353_address: ans.bip353_address.cst_decode(),
11665                    }
11666                }
11667                1 => {
11668                    let ans = unsafe { self.kind.Bolt11 };
11669                    crate::model::SendDestination::Bolt11 {
11670                        invoice: ans.invoice.cst_decode(),
11671                        bip353_address: ans.bip353_address.cst_decode(),
11672                    }
11673                }
11674                2 => {
11675                    let ans = unsafe { self.kind.Bolt12 };
11676                    crate::model::SendDestination::Bolt12 {
11677                        offer: ans.offer.cst_decode(),
11678                        receiver_amount_sat: ans.receiver_amount_sat.cst_decode(),
11679                        bip353_address: ans.bip353_address.cst_decode(),
11680                    }
11681                }
11682                _ => unreachable!(),
11683            }
11684        }
11685    }
11686    impl CstDecode<crate::model::SendPaymentRequest> for wire_cst_send_payment_request {
11687        // Codec=Cst (C-struct based), see doc to use other codecs
11688        fn cst_decode(self) -> crate::model::SendPaymentRequest {
11689            crate::model::SendPaymentRequest {
11690                prepare_response: self.prepare_response.cst_decode(),
11691                use_asset_fees: self.use_asset_fees.cst_decode(),
11692                payer_note: self.payer_note.cst_decode(),
11693            }
11694        }
11695    }
11696    impl CstDecode<crate::model::SendPaymentResponse> for wire_cst_send_payment_response {
11697        // Codec=Cst (C-struct based), see doc to use other codecs
11698        fn cst_decode(self) -> crate::model::SendPaymentResponse {
11699            crate::model::SendPaymentResponse {
11700                payment: self.payment.cst_decode(),
11701            }
11702        }
11703    }
11704    impl CstDecode<crate::model::SignMessageRequest> for wire_cst_sign_message_request {
11705        // Codec=Cst (C-struct based), see doc to use other codecs
11706        fn cst_decode(self) -> crate::model::SignMessageRequest {
11707            crate::model::SignMessageRequest {
11708                message: self.message.cst_decode(),
11709            }
11710        }
11711    }
11712    impl CstDecode<crate::model::SignMessageResponse> for wire_cst_sign_message_response {
11713        // Codec=Cst (C-struct based), see doc to use other codecs
11714        fn cst_decode(self) -> crate::model::SignMessageResponse {
11715            crate::model::SignMessageResponse {
11716                signature: self.signature.cst_decode(),
11717            }
11718        }
11719    }
11720    impl CstDecode<crate::bindings::SuccessAction> for wire_cst_success_action {
11721        // Codec=Cst (C-struct based), see doc to use other codecs
11722        fn cst_decode(self) -> crate::bindings::SuccessAction {
11723            match self.tag {
11724                0 => {
11725                    let ans = unsafe { self.kind.Aes };
11726                    crate::bindings::SuccessAction::Aes {
11727                        data: ans.data.cst_decode(),
11728                    }
11729                }
11730                1 => {
11731                    let ans = unsafe { self.kind.Message };
11732                    crate::bindings::SuccessAction::Message {
11733                        data: ans.data.cst_decode(),
11734                    }
11735                }
11736                2 => {
11737                    let ans = unsafe { self.kind.Url };
11738                    crate::bindings::SuccessAction::Url {
11739                        data: ans.data.cst_decode(),
11740                    }
11741                }
11742                _ => unreachable!(),
11743            }
11744        }
11745    }
11746    impl CstDecode<crate::bindings::SuccessActionProcessed> for wire_cst_success_action_processed {
11747        // Codec=Cst (C-struct based), see doc to use other codecs
11748        fn cst_decode(self) -> crate::bindings::SuccessActionProcessed {
11749            match self.tag {
11750                0 => {
11751                    let ans = unsafe { self.kind.Aes };
11752                    crate::bindings::SuccessActionProcessed::Aes {
11753                        result: ans.result.cst_decode(),
11754                    }
11755                }
11756                1 => {
11757                    let ans = unsafe { self.kind.Message };
11758                    crate::bindings::SuccessActionProcessed::Message {
11759                        data: ans.data.cst_decode(),
11760                    }
11761                }
11762                2 => {
11763                    let ans = unsafe { self.kind.Url };
11764                    crate::bindings::SuccessActionProcessed::Url {
11765                        data: ans.data.cst_decode(),
11766                    }
11767                }
11768                _ => unreachable!(),
11769            }
11770        }
11771    }
11772    impl CstDecode<crate::bindings::Symbol> for wire_cst_symbol {
11773        // Codec=Cst (C-struct based), see doc to use other codecs
11774        fn cst_decode(self) -> crate::bindings::Symbol {
11775            crate::bindings::Symbol {
11776                grapheme: self.grapheme.cst_decode(),
11777                template: self.template.cst_decode(),
11778                rtl: self.rtl.cst_decode(),
11779                position: self.position.cst_decode(),
11780            }
11781        }
11782    }
11783    impl CstDecode<crate::bindings::UrlSuccessActionData> for wire_cst_url_success_action_data {
11784        // Codec=Cst (C-struct based), see doc to use other codecs
11785        fn cst_decode(self) -> crate::bindings::UrlSuccessActionData {
11786            crate::bindings::UrlSuccessActionData {
11787                description: self.description.cst_decode(),
11788                url: self.url.cst_decode(),
11789                matches_callback_domain: self.matches_callback_domain.cst_decode(),
11790            }
11791        }
11792    }
11793    impl CstDecode<crate::model::WalletInfo> for wire_cst_wallet_info {
11794        // Codec=Cst (C-struct based), see doc to use other codecs
11795        fn cst_decode(self) -> crate::model::WalletInfo {
11796            crate::model::WalletInfo {
11797                balance_sat: self.balance_sat.cst_decode(),
11798                pending_send_sat: self.pending_send_sat.cst_decode(),
11799                pending_receive_sat: self.pending_receive_sat.cst_decode(),
11800                fingerprint: self.fingerprint.cst_decode(),
11801                pubkey: self.pubkey.cst_decode(),
11802                asset_balances: self.asset_balances.cst_decode(),
11803            }
11804        }
11805    }
11806    impl NewWithNullPtr for wire_cst_accept_payment_proposed_fees_request {
11807        fn new_with_null_ptr() -> Self {
11808            Self {
11809                response: Default::default(),
11810            }
11811        }
11812    }
11813    impl Default for wire_cst_accept_payment_proposed_fees_request {
11814        fn default() -> Self {
11815            Self::new_with_null_ptr()
11816        }
11817    }
11818    impl NewWithNullPtr for wire_cst_aes_success_action_data {
11819        fn new_with_null_ptr() -> Self {
11820            Self {
11821                description: core::ptr::null_mut(),
11822                ciphertext: core::ptr::null_mut(),
11823                iv: core::ptr::null_mut(),
11824            }
11825        }
11826    }
11827    impl Default for wire_cst_aes_success_action_data {
11828        fn default() -> Self {
11829            Self::new_with_null_ptr()
11830        }
11831    }
11832    impl NewWithNullPtr for wire_cst_aes_success_action_data_decrypted {
11833        fn new_with_null_ptr() -> Self {
11834            Self {
11835                description: core::ptr::null_mut(),
11836                plaintext: core::ptr::null_mut(),
11837            }
11838        }
11839    }
11840    impl Default for wire_cst_aes_success_action_data_decrypted {
11841        fn default() -> Self {
11842            Self::new_with_null_ptr()
11843        }
11844    }
11845    impl NewWithNullPtr for wire_cst_aes_success_action_data_result {
11846        fn new_with_null_ptr() -> Self {
11847            Self {
11848                tag: -1,
11849                kind: AesSuccessActionDataResultKind { nil__: () },
11850            }
11851        }
11852    }
11853    impl Default for wire_cst_aes_success_action_data_result {
11854        fn default() -> Self {
11855            Self::new_with_null_ptr()
11856        }
11857    }
11858    impl NewWithNullPtr for wire_cst_amount {
11859        fn new_with_null_ptr() -> Self {
11860            Self {
11861                tag: -1,
11862                kind: AmountKind { nil__: () },
11863            }
11864        }
11865    }
11866    impl Default for wire_cst_amount {
11867        fn default() -> Self {
11868            Self::new_with_null_ptr()
11869        }
11870    }
11871    impl NewWithNullPtr for wire_cst_asset_balance {
11872        fn new_with_null_ptr() -> Self {
11873            Self {
11874                asset_id: core::ptr::null_mut(),
11875                balance_sat: Default::default(),
11876                name: core::ptr::null_mut(),
11877                ticker: core::ptr::null_mut(),
11878                balance: core::ptr::null_mut(),
11879            }
11880        }
11881    }
11882    impl Default for wire_cst_asset_balance {
11883        fn default() -> Self {
11884            Self::new_with_null_ptr()
11885        }
11886    }
11887    impl NewWithNullPtr for wire_cst_asset_info {
11888        fn new_with_null_ptr() -> Self {
11889            Self {
11890                name: core::ptr::null_mut(),
11891                ticker: core::ptr::null_mut(),
11892                amount: Default::default(),
11893                fees: core::ptr::null_mut(),
11894            }
11895        }
11896    }
11897    impl Default for wire_cst_asset_info {
11898        fn default() -> Self {
11899            Self::new_with_null_ptr()
11900        }
11901    }
11902    impl NewWithNullPtr for wire_cst_asset_metadata {
11903        fn new_with_null_ptr() -> Self {
11904            Self {
11905                asset_id: core::ptr::null_mut(),
11906                name: core::ptr::null_mut(),
11907                ticker: core::ptr::null_mut(),
11908                precision: Default::default(),
11909                fiat_id: core::ptr::null_mut(),
11910            }
11911        }
11912    }
11913    impl Default for wire_cst_asset_metadata {
11914        fn default() -> Self {
11915            Self::new_with_null_ptr()
11916        }
11917    }
11918    impl NewWithNullPtr for wire_cst_backup_request {
11919        fn new_with_null_ptr() -> Self {
11920            Self {
11921                backup_path: core::ptr::null_mut(),
11922            }
11923        }
11924    }
11925    impl Default for wire_cst_backup_request {
11926        fn default() -> Self {
11927            Self::new_with_null_ptr()
11928        }
11929    }
11930    impl NewWithNullPtr for wire_cst_binding_event_listener {
11931        fn new_with_null_ptr() -> Self {
11932            Self {
11933                stream: core::ptr::null_mut(),
11934            }
11935        }
11936    }
11937    impl Default for wire_cst_binding_event_listener {
11938        fn default() -> Self {
11939            Self::new_with_null_ptr()
11940        }
11941    }
11942    impl NewWithNullPtr for wire_cst_bitcoin_address_data {
11943        fn new_with_null_ptr() -> Self {
11944            Self {
11945                address: core::ptr::null_mut(),
11946                network: Default::default(),
11947                amount_sat: core::ptr::null_mut(),
11948                label: core::ptr::null_mut(),
11949                message: core::ptr::null_mut(),
11950            }
11951        }
11952    }
11953    impl Default for wire_cst_bitcoin_address_data {
11954        fn default() -> Self {
11955            Self::new_with_null_ptr()
11956        }
11957    }
11958    impl NewWithNullPtr for wire_cst_blockchain_explorer {
11959        fn new_with_null_ptr() -> Self {
11960            Self {
11961                tag: -1,
11962                kind: BlockchainExplorerKind { nil__: () },
11963            }
11964        }
11965    }
11966    impl Default for wire_cst_blockchain_explorer {
11967        fn default() -> Self {
11968            Self::new_with_null_ptr()
11969        }
11970    }
11971    impl NewWithNullPtr for wire_cst_blockchain_info {
11972        fn new_with_null_ptr() -> Self {
11973            Self {
11974                liquid_tip: Default::default(),
11975                bitcoin_tip: Default::default(),
11976            }
11977        }
11978    }
11979    impl Default for wire_cst_blockchain_info {
11980        fn default() -> Self {
11981            Self::new_with_null_ptr()
11982        }
11983    }
11984    impl NewWithNullPtr for wire_cst_buy_bitcoin_request {
11985        fn new_with_null_ptr() -> Self {
11986            Self {
11987                prepare_response: Default::default(),
11988                redirect_url: core::ptr::null_mut(),
11989            }
11990        }
11991    }
11992    impl Default for wire_cst_buy_bitcoin_request {
11993        fn default() -> Self {
11994            Self::new_with_null_ptr()
11995        }
11996    }
11997    impl NewWithNullPtr for wire_cst_check_message_request {
11998        fn new_with_null_ptr() -> Self {
11999            Self {
12000                message: core::ptr::null_mut(),
12001                pubkey: core::ptr::null_mut(),
12002                signature: core::ptr::null_mut(),
12003            }
12004        }
12005    }
12006    impl Default for wire_cst_check_message_request {
12007        fn default() -> Self {
12008            Self::new_with_null_ptr()
12009        }
12010    }
12011    impl NewWithNullPtr for wire_cst_check_message_response {
12012        fn new_with_null_ptr() -> Self {
12013            Self {
12014                is_valid: Default::default(),
12015            }
12016        }
12017    }
12018    impl Default for wire_cst_check_message_response {
12019        fn default() -> Self {
12020            Self::new_with_null_ptr()
12021        }
12022    }
12023    impl NewWithNullPtr for wire_cst_config {
12024        fn new_with_null_ptr() -> Self {
12025            Self {
12026                liquid_explorer: Default::default(),
12027                bitcoin_explorer: Default::default(),
12028                working_dir: core::ptr::null_mut(),
12029                network: Default::default(),
12030                payment_timeout_sec: Default::default(),
12031                sync_service_url: core::ptr::null_mut(),
12032                zero_conf_max_amount_sat: core::ptr::null_mut(),
12033                breez_api_key: core::ptr::null_mut(),
12034                external_input_parsers: core::ptr::null_mut(),
12035                use_default_external_input_parsers: Default::default(),
12036                onchain_fee_rate_leeway_sat: core::ptr::null_mut(),
12037                asset_metadata: core::ptr::null_mut(),
12038                sideswap_api_key: core::ptr::null_mut(),
12039            }
12040        }
12041    }
12042    impl Default for wire_cst_config {
12043        fn default() -> Self {
12044            Self::new_with_null_ptr()
12045        }
12046    }
12047    impl NewWithNullPtr for wire_cst_connect_request {
12048        fn new_with_null_ptr() -> Self {
12049            Self {
12050                config: Default::default(),
12051                mnemonic: core::ptr::null_mut(),
12052                passphrase: core::ptr::null_mut(),
12053                seed: core::ptr::null_mut(),
12054            }
12055        }
12056    }
12057    impl Default for wire_cst_connect_request {
12058        fn default() -> Self {
12059            Self::new_with_null_ptr()
12060        }
12061    }
12062    impl NewWithNullPtr for wire_cst_create_bolt_12_invoice_request {
12063        fn new_with_null_ptr() -> Self {
12064            Self {
12065                offer: core::ptr::null_mut(),
12066                invoice_request: core::ptr::null_mut(),
12067            }
12068        }
12069    }
12070    impl Default for wire_cst_create_bolt_12_invoice_request {
12071        fn default() -> Self {
12072            Self::new_with_null_ptr()
12073        }
12074    }
12075    impl NewWithNullPtr for wire_cst_create_bolt_12_invoice_response {
12076        fn new_with_null_ptr() -> Self {
12077            Self {
12078                invoice: core::ptr::null_mut(),
12079            }
12080        }
12081    }
12082    impl Default for wire_cst_create_bolt_12_invoice_response {
12083        fn default() -> Self {
12084            Self::new_with_null_ptr()
12085        }
12086    }
12087    impl NewWithNullPtr for wire_cst_currency_info {
12088        fn new_with_null_ptr() -> Self {
12089            Self {
12090                name: core::ptr::null_mut(),
12091                fraction_size: Default::default(),
12092                spacing: core::ptr::null_mut(),
12093                symbol: core::ptr::null_mut(),
12094                uniq_symbol: core::ptr::null_mut(),
12095                localized_name: core::ptr::null_mut(),
12096                locale_overrides: core::ptr::null_mut(),
12097            }
12098        }
12099    }
12100    impl Default for wire_cst_currency_info {
12101        fn default() -> Self {
12102            Self::new_with_null_ptr()
12103        }
12104    }
12105    impl NewWithNullPtr for wire_cst_external_input_parser {
12106        fn new_with_null_ptr() -> Self {
12107            Self {
12108                provider_id: core::ptr::null_mut(),
12109                input_regex: core::ptr::null_mut(),
12110                parser_url: core::ptr::null_mut(),
12111            }
12112        }
12113    }
12114    impl Default for wire_cst_external_input_parser {
12115        fn default() -> Self {
12116            Self::new_with_null_ptr()
12117        }
12118    }
12119    impl NewWithNullPtr for wire_cst_fetch_payment_proposed_fees_request {
12120        fn new_with_null_ptr() -> Self {
12121            Self {
12122                swap_id: core::ptr::null_mut(),
12123            }
12124        }
12125    }
12126    impl Default for wire_cst_fetch_payment_proposed_fees_request {
12127        fn default() -> Self {
12128            Self::new_with_null_ptr()
12129        }
12130    }
12131    impl NewWithNullPtr for wire_cst_fetch_payment_proposed_fees_response {
12132        fn new_with_null_ptr() -> Self {
12133            Self {
12134                swap_id: core::ptr::null_mut(),
12135                fees_sat: Default::default(),
12136                payer_amount_sat: Default::default(),
12137                receiver_amount_sat: Default::default(),
12138            }
12139        }
12140    }
12141    impl Default for wire_cst_fetch_payment_proposed_fees_response {
12142        fn default() -> Self {
12143            Self::new_with_null_ptr()
12144        }
12145    }
12146    impl NewWithNullPtr for wire_cst_fiat_currency {
12147        fn new_with_null_ptr() -> Self {
12148            Self {
12149                id: core::ptr::null_mut(),
12150                info: Default::default(),
12151            }
12152        }
12153    }
12154    impl Default for wire_cst_fiat_currency {
12155        fn default() -> Self {
12156            Self::new_with_null_ptr()
12157        }
12158    }
12159    impl NewWithNullPtr for wire_cst_get_info_response {
12160        fn new_with_null_ptr() -> Self {
12161            Self {
12162                wallet_info: Default::default(),
12163                blockchain_info: Default::default(),
12164            }
12165        }
12166    }
12167    impl Default for wire_cst_get_info_response {
12168        fn default() -> Self {
12169            Self::new_with_null_ptr()
12170        }
12171    }
12172    impl NewWithNullPtr for wire_cst_get_payment_request {
12173        fn new_with_null_ptr() -> Self {
12174            Self {
12175                tag: -1,
12176                kind: GetPaymentRequestKind { nil__: () },
12177            }
12178        }
12179    }
12180    impl Default for wire_cst_get_payment_request {
12181        fn default() -> Self {
12182            Self::new_with_null_ptr()
12183        }
12184    }
12185    impl NewWithNullPtr for wire_cst_input_type {
12186        fn new_with_null_ptr() -> Self {
12187            Self {
12188                tag: -1,
12189                kind: InputTypeKind { nil__: () },
12190            }
12191        }
12192    }
12193    impl Default for wire_cst_input_type {
12194        fn default() -> Self {
12195            Self::new_with_null_ptr()
12196        }
12197    }
12198    impl NewWithNullPtr for wire_cst_lightning_payment_limits_response {
12199        fn new_with_null_ptr() -> Self {
12200            Self {
12201                send: Default::default(),
12202                receive: Default::default(),
12203            }
12204        }
12205    }
12206    impl Default for wire_cst_lightning_payment_limits_response {
12207        fn default() -> Self {
12208            Self::new_with_null_ptr()
12209        }
12210    }
12211    impl NewWithNullPtr for wire_cst_limits {
12212        fn new_with_null_ptr() -> Self {
12213            Self {
12214                min_sat: Default::default(),
12215                max_sat: Default::default(),
12216                max_zero_conf_sat: Default::default(),
12217            }
12218        }
12219    }
12220    impl Default for wire_cst_limits {
12221        fn default() -> Self {
12222            Self::new_with_null_ptr()
12223        }
12224    }
12225    impl NewWithNullPtr for wire_cst_liquid_address_data {
12226        fn new_with_null_ptr() -> Self {
12227            Self {
12228                address: core::ptr::null_mut(),
12229                network: Default::default(),
12230                asset_id: core::ptr::null_mut(),
12231                amount: core::ptr::null_mut(),
12232                amount_sat: core::ptr::null_mut(),
12233                label: core::ptr::null_mut(),
12234                message: core::ptr::null_mut(),
12235            }
12236        }
12237    }
12238    impl Default for wire_cst_liquid_address_data {
12239        fn default() -> Self {
12240            Self::new_with_null_ptr()
12241        }
12242    }
12243    impl NewWithNullPtr for wire_cst_list_payment_details {
12244        fn new_with_null_ptr() -> Self {
12245            Self {
12246                tag: -1,
12247                kind: ListPaymentDetailsKind { nil__: () },
12248            }
12249        }
12250    }
12251    impl Default for wire_cst_list_payment_details {
12252        fn default() -> Self {
12253            Self::new_with_null_ptr()
12254        }
12255    }
12256    impl NewWithNullPtr for wire_cst_list_payments_request {
12257        fn new_with_null_ptr() -> Self {
12258            Self {
12259                filters: core::ptr::null_mut(),
12260                states: core::ptr::null_mut(),
12261                from_timestamp: core::ptr::null_mut(),
12262                to_timestamp: core::ptr::null_mut(),
12263                offset: core::ptr::null_mut(),
12264                limit: core::ptr::null_mut(),
12265                details: core::ptr::null_mut(),
12266                sort_ascending: core::ptr::null_mut(),
12267            }
12268        }
12269    }
12270    impl Default for wire_cst_list_payments_request {
12271        fn default() -> Self {
12272            Self::new_with_null_ptr()
12273        }
12274    }
12275    impl NewWithNullPtr for wire_cst_ln_invoice {
12276        fn new_with_null_ptr() -> Self {
12277            Self {
12278                bolt11: core::ptr::null_mut(),
12279                network: Default::default(),
12280                payee_pubkey: core::ptr::null_mut(),
12281                payment_hash: core::ptr::null_mut(),
12282                description: core::ptr::null_mut(),
12283                description_hash: core::ptr::null_mut(),
12284                amount_msat: core::ptr::null_mut(),
12285                timestamp: Default::default(),
12286                expiry: Default::default(),
12287                routing_hints: core::ptr::null_mut(),
12288                payment_secret: core::ptr::null_mut(),
12289                min_final_cltv_expiry_delta: Default::default(),
12290            }
12291        }
12292    }
12293    impl Default for wire_cst_ln_invoice {
12294        fn default() -> Self {
12295            Self::new_with_null_ptr()
12296        }
12297    }
12298    impl NewWithNullPtr for wire_cst_ln_offer {
12299        fn new_with_null_ptr() -> Self {
12300            Self {
12301                offer: core::ptr::null_mut(),
12302                chains: core::ptr::null_mut(),
12303                min_amount: core::ptr::null_mut(),
12304                description: core::ptr::null_mut(),
12305                absolute_expiry: core::ptr::null_mut(),
12306                issuer: core::ptr::null_mut(),
12307                signing_pubkey: core::ptr::null_mut(),
12308                paths: core::ptr::null_mut(),
12309            }
12310        }
12311    }
12312    impl Default for wire_cst_ln_offer {
12313        fn default() -> Self {
12314            Self::new_with_null_ptr()
12315        }
12316    }
12317    impl NewWithNullPtr for wire_cst_ln_offer_blinded_path {
12318        fn new_with_null_ptr() -> Self {
12319            Self {
12320                blinded_hops: core::ptr::null_mut(),
12321            }
12322        }
12323    }
12324    impl Default for wire_cst_ln_offer_blinded_path {
12325        fn default() -> Self {
12326            Self::new_with_null_ptr()
12327        }
12328    }
12329    impl NewWithNullPtr for wire_cst_ln_url_auth_error {
12330        fn new_with_null_ptr() -> Self {
12331            Self {
12332                tag: -1,
12333                kind: LnUrlAuthErrorKind { nil__: () },
12334            }
12335        }
12336    }
12337    impl Default for wire_cst_ln_url_auth_error {
12338        fn default() -> Self {
12339            Self::new_with_null_ptr()
12340        }
12341    }
12342    impl NewWithNullPtr for wire_cst_ln_url_auth_request_data {
12343        fn new_with_null_ptr() -> Self {
12344            Self {
12345                k1: core::ptr::null_mut(),
12346                action: core::ptr::null_mut(),
12347                domain: core::ptr::null_mut(),
12348                url: core::ptr::null_mut(),
12349            }
12350        }
12351    }
12352    impl Default for wire_cst_ln_url_auth_request_data {
12353        fn default() -> Self {
12354            Self::new_with_null_ptr()
12355        }
12356    }
12357    impl NewWithNullPtr for wire_cst_ln_url_callback_status {
12358        fn new_with_null_ptr() -> Self {
12359            Self {
12360                tag: -1,
12361                kind: LnUrlCallbackStatusKind { nil__: () },
12362            }
12363        }
12364    }
12365    impl Default for wire_cst_ln_url_callback_status {
12366        fn default() -> Self {
12367            Self::new_with_null_ptr()
12368        }
12369    }
12370    impl NewWithNullPtr for wire_cst_ln_url_error_data {
12371        fn new_with_null_ptr() -> Self {
12372            Self {
12373                reason: core::ptr::null_mut(),
12374            }
12375        }
12376    }
12377    impl Default for wire_cst_ln_url_error_data {
12378        fn default() -> Self {
12379            Self::new_with_null_ptr()
12380        }
12381    }
12382    impl NewWithNullPtr for wire_cst_ln_url_info {
12383        fn new_with_null_ptr() -> Self {
12384            Self {
12385                ln_address: core::ptr::null_mut(),
12386                lnurl_pay_comment: core::ptr::null_mut(),
12387                lnurl_pay_domain: core::ptr::null_mut(),
12388                lnurl_pay_metadata: core::ptr::null_mut(),
12389                lnurl_pay_success_action: core::ptr::null_mut(),
12390                lnurl_pay_unprocessed_success_action: core::ptr::null_mut(),
12391                lnurl_withdraw_endpoint: core::ptr::null_mut(),
12392            }
12393        }
12394    }
12395    impl Default for wire_cst_ln_url_info {
12396        fn default() -> Self {
12397            Self::new_with_null_ptr()
12398        }
12399    }
12400    impl NewWithNullPtr for wire_cst_ln_url_pay_error {
12401        fn new_with_null_ptr() -> Self {
12402            Self {
12403                tag: -1,
12404                kind: LnUrlPayErrorKind { nil__: () },
12405            }
12406        }
12407    }
12408    impl Default for wire_cst_ln_url_pay_error {
12409        fn default() -> Self {
12410            Self::new_with_null_ptr()
12411        }
12412    }
12413    impl NewWithNullPtr for wire_cst_ln_url_pay_error_data {
12414        fn new_with_null_ptr() -> Self {
12415            Self {
12416                payment_hash: core::ptr::null_mut(),
12417                reason: core::ptr::null_mut(),
12418            }
12419        }
12420    }
12421    impl Default for wire_cst_ln_url_pay_error_data {
12422        fn default() -> Self {
12423            Self::new_with_null_ptr()
12424        }
12425    }
12426    impl NewWithNullPtr for wire_cst_ln_url_pay_request {
12427        fn new_with_null_ptr() -> Self {
12428            Self {
12429                prepare_response: Default::default(),
12430            }
12431        }
12432    }
12433    impl Default for wire_cst_ln_url_pay_request {
12434        fn default() -> Self {
12435            Self::new_with_null_ptr()
12436        }
12437    }
12438    impl NewWithNullPtr for wire_cst_ln_url_pay_request_data {
12439        fn new_with_null_ptr() -> Self {
12440            Self {
12441                callback: core::ptr::null_mut(),
12442                min_sendable: Default::default(),
12443                max_sendable: Default::default(),
12444                metadata_str: core::ptr::null_mut(),
12445                comment_allowed: Default::default(),
12446                domain: core::ptr::null_mut(),
12447                allows_nostr: Default::default(),
12448                nostr_pubkey: core::ptr::null_mut(),
12449                ln_address: core::ptr::null_mut(),
12450            }
12451        }
12452    }
12453    impl Default for wire_cst_ln_url_pay_request_data {
12454        fn default() -> Self {
12455            Self::new_with_null_ptr()
12456        }
12457    }
12458    impl NewWithNullPtr for wire_cst_ln_url_pay_result {
12459        fn new_with_null_ptr() -> Self {
12460            Self {
12461                tag: -1,
12462                kind: LnUrlPayResultKind { nil__: () },
12463            }
12464        }
12465    }
12466    impl Default for wire_cst_ln_url_pay_result {
12467        fn default() -> Self {
12468            Self::new_with_null_ptr()
12469        }
12470    }
12471    impl NewWithNullPtr for wire_cst_ln_url_pay_success_data {
12472        fn new_with_null_ptr() -> Self {
12473            Self {
12474                payment: Default::default(),
12475                success_action: core::ptr::null_mut(),
12476            }
12477        }
12478    }
12479    impl Default for wire_cst_ln_url_pay_success_data {
12480        fn default() -> Self {
12481            Self::new_with_null_ptr()
12482        }
12483    }
12484    impl NewWithNullPtr for wire_cst_ln_url_withdraw_error {
12485        fn new_with_null_ptr() -> Self {
12486            Self {
12487                tag: -1,
12488                kind: LnUrlWithdrawErrorKind { nil__: () },
12489            }
12490        }
12491    }
12492    impl Default for wire_cst_ln_url_withdraw_error {
12493        fn default() -> Self {
12494            Self::new_with_null_ptr()
12495        }
12496    }
12497    impl NewWithNullPtr for wire_cst_ln_url_withdraw_request {
12498        fn new_with_null_ptr() -> Self {
12499            Self {
12500                data: Default::default(),
12501                amount_msat: Default::default(),
12502                description: core::ptr::null_mut(),
12503            }
12504        }
12505    }
12506    impl Default for wire_cst_ln_url_withdraw_request {
12507        fn default() -> Self {
12508            Self::new_with_null_ptr()
12509        }
12510    }
12511    impl NewWithNullPtr for wire_cst_ln_url_withdraw_request_data {
12512        fn new_with_null_ptr() -> Self {
12513            Self {
12514                callback: core::ptr::null_mut(),
12515                k1: core::ptr::null_mut(),
12516                default_description: core::ptr::null_mut(),
12517                min_withdrawable: Default::default(),
12518                max_withdrawable: Default::default(),
12519            }
12520        }
12521    }
12522    impl Default for wire_cst_ln_url_withdraw_request_data {
12523        fn default() -> Self {
12524            Self::new_with_null_ptr()
12525        }
12526    }
12527    impl NewWithNullPtr for wire_cst_ln_url_withdraw_result {
12528        fn new_with_null_ptr() -> Self {
12529            Self {
12530                tag: -1,
12531                kind: LnUrlWithdrawResultKind { nil__: () },
12532            }
12533        }
12534    }
12535    impl Default for wire_cst_ln_url_withdraw_result {
12536        fn default() -> Self {
12537            Self::new_with_null_ptr()
12538        }
12539    }
12540    impl NewWithNullPtr for wire_cst_ln_url_withdraw_success_data {
12541        fn new_with_null_ptr() -> Self {
12542            Self {
12543                invoice: Default::default(),
12544            }
12545        }
12546    }
12547    impl Default for wire_cst_ln_url_withdraw_success_data {
12548        fn default() -> Self {
12549            Self::new_with_null_ptr()
12550        }
12551    }
12552    impl NewWithNullPtr for wire_cst_locale_overrides {
12553        fn new_with_null_ptr() -> Self {
12554            Self {
12555                locale: core::ptr::null_mut(),
12556                spacing: core::ptr::null_mut(),
12557                symbol: Default::default(),
12558            }
12559        }
12560    }
12561    impl Default for wire_cst_locale_overrides {
12562        fn default() -> Self {
12563            Self::new_with_null_ptr()
12564        }
12565    }
12566    impl NewWithNullPtr for wire_cst_localized_name {
12567        fn new_with_null_ptr() -> Self {
12568            Self {
12569                locale: core::ptr::null_mut(),
12570                name: core::ptr::null_mut(),
12571            }
12572        }
12573    }
12574    impl Default for wire_cst_localized_name {
12575        fn default() -> Self {
12576            Self::new_with_null_ptr()
12577        }
12578    }
12579    impl NewWithNullPtr for wire_cst_log_entry {
12580        fn new_with_null_ptr() -> Self {
12581            Self {
12582                line: core::ptr::null_mut(),
12583                level: core::ptr::null_mut(),
12584            }
12585        }
12586    }
12587    impl Default for wire_cst_log_entry {
12588        fn default() -> Self {
12589            Self::new_with_null_ptr()
12590        }
12591    }
12592    impl NewWithNullPtr for wire_cst_message_success_action_data {
12593        fn new_with_null_ptr() -> Self {
12594            Self {
12595                message: core::ptr::null_mut(),
12596            }
12597        }
12598    }
12599    impl Default for wire_cst_message_success_action_data {
12600        fn default() -> Self {
12601            Self::new_with_null_ptr()
12602        }
12603    }
12604    impl NewWithNullPtr for wire_cst_onchain_payment_limits_response {
12605        fn new_with_null_ptr() -> Self {
12606            Self {
12607                send: Default::default(),
12608                receive: Default::default(),
12609            }
12610        }
12611    }
12612    impl Default for wire_cst_onchain_payment_limits_response {
12613        fn default() -> Self {
12614            Self::new_with_null_ptr()
12615        }
12616    }
12617    impl NewWithNullPtr for wire_cst_pay_amount {
12618        fn new_with_null_ptr() -> Self {
12619            Self {
12620                tag: -1,
12621                kind: PayAmountKind { nil__: () },
12622            }
12623        }
12624    }
12625    impl Default for wire_cst_pay_amount {
12626        fn default() -> Self {
12627            Self::new_with_null_ptr()
12628        }
12629    }
12630    impl NewWithNullPtr for wire_cst_pay_onchain_request {
12631        fn new_with_null_ptr() -> Self {
12632            Self {
12633                address: core::ptr::null_mut(),
12634                prepare_response: Default::default(),
12635            }
12636        }
12637    }
12638    impl Default for wire_cst_pay_onchain_request {
12639        fn default() -> Self {
12640            Self::new_with_null_ptr()
12641        }
12642    }
12643    impl NewWithNullPtr for wire_cst_payment {
12644        fn new_with_null_ptr() -> Self {
12645            Self {
12646                destination: core::ptr::null_mut(),
12647                tx_id: core::ptr::null_mut(),
12648                unblinding_data: core::ptr::null_mut(),
12649                timestamp: Default::default(),
12650                amount_sat: Default::default(),
12651                fees_sat: Default::default(),
12652                swapper_fees_sat: core::ptr::null_mut(),
12653                payment_type: Default::default(),
12654                status: Default::default(),
12655                details: Default::default(),
12656            }
12657        }
12658    }
12659    impl Default for wire_cst_payment {
12660        fn default() -> Self {
12661            Self::new_with_null_ptr()
12662        }
12663    }
12664    impl NewWithNullPtr for wire_cst_payment_details {
12665        fn new_with_null_ptr() -> Self {
12666            Self {
12667                tag: -1,
12668                kind: PaymentDetailsKind { nil__: () },
12669            }
12670        }
12671    }
12672    impl Default for wire_cst_payment_details {
12673        fn default() -> Self {
12674            Self::new_with_null_ptr()
12675        }
12676    }
12677    impl NewWithNullPtr for wire_cst_payment_error {
12678        fn new_with_null_ptr() -> Self {
12679            Self {
12680                tag: -1,
12681                kind: PaymentErrorKind { nil__: () },
12682            }
12683        }
12684    }
12685    impl Default for wire_cst_payment_error {
12686        fn default() -> Self {
12687            Self::new_with_null_ptr()
12688        }
12689    }
12690    impl NewWithNullPtr for wire_cst_prepare_buy_bitcoin_request {
12691        fn new_with_null_ptr() -> Self {
12692            Self {
12693                provider: Default::default(),
12694                amount_sat: Default::default(),
12695            }
12696        }
12697    }
12698    impl Default for wire_cst_prepare_buy_bitcoin_request {
12699        fn default() -> Self {
12700            Self::new_with_null_ptr()
12701        }
12702    }
12703    impl NewWithNullPtr for wire_cst_prepare_buy_bitcoin_response {
12704        fn new_with_null_ptr() -> Self {
12705            Self {
12706                provider: Default::default(),
12707                amount_sat: Default::default(),
12708                fees_sat: Default::default(),
12709            }
12710        }
12711    }
12712    impl Default for wire_cst_prepare_buy_bitcoin_response {
12713        fn default() -> Self {
12714            Self::new_with_null_ptr()
12715        }
12716    }
12717    impl NewWithNullPtr for wire_cst_prepare_ln_url_pay_request {
12718        fn new_with_null_ptr() -> Self {
12719            Self {
12720                data: Default::default(),
12721                amount: Default::default(),
12722                bip353_address: core::ptr::null_mut(),
12723                comment: core::ptr::null_mut(),
12724                validate_success_action_url: core::ptr::null_mut(),
12725            }
12726        }
12727    }
12728    impl Default for wire_cst_prepare_ln_url_pay_request {
12729        fn default() -> Self {
12730            Self::new_with_null_ptr()
12731        }
12732    }
12733    impl NewWithNullPtr for wire_cst_prepare_ln_url_pay_response {
12734        fn new_with_null_ptr() -> Self {
12735            Self {
12736                destination: Default::default(),
12737                fees_sat: Default::default(),
12738                data: Default::default(),
12739                amount: Default::default(),
12740                comment: core::ptr::null_mut(),
12741                success_action: core::ptr::null_mut(),
12742            }
12743        }
12744    }
12745    impl Default for wire_cst_prepare_ln_url_pay_response {
12746        fn default() -> Self {
12747            Self::new_with_null_ptr()
12748        }
12749    }
12750    impl NewWithNullPtr for wire_cst_prepare_pay_onchain_request {
12751        fn new_with_null_ptr() -> Self {
12752            Self {
12753                amount: Default::default(),
12754                fee_rate_sat_per_vbyte: core::ptr::null_mut(),
12755            }
12756        }
12757    }
12758    impl Default for wire_cst_prepare_pay_onchain_request {
12759        fn default() -> Self {
12760            Self::new_with_null_ptr()
12761        }
12762    }
12763    impl NewWithNullPtr for wire_cst_prepare_pay_onchain_response {
12764        fn new_with_null_ptr() -> Self {
12765            Self {
12766                receiver_amount_sat: Default::default(),
12767                claim_fees_sat: Default::default(),
12768                total_fees_sat: Default::default(),
12769            }
12770        }
12771    }
12772    impl Default for wire_cst_prepare_pay_onchain_response {
12773        fn default() -> Self {
12774            Self::new_with_null_ptr()
12775        }
12776    }
12777    impl NewWithNullPtr for wire_cst_prepare_receive_request {
12778        fn new_with_null_ptr() -> Self {
12779            Self {
12780                payment_method: Default::default(),
12781                amount: core::ptr::null_mut(),
12782            }
12783        }
12784    }
12785    impl Default for wire_cst_prepare_receive_request {
12786        fn default() -> Self {
12787            Self::new_with_null_ptr()
12788        }
12789    }
12790    impl NewWithNullPtr for wire_cst_prepare_receive_response {
12791        fn new_with_null_ptr() -> Self {
12792            Self {
12793                payment_method: Default::default(),
12794                fees_sat: Default::default(),
12795                amount: core::ptr::null_mut(),
12796                min_payer_amount_sat: core::ptr::null_mut(),
12797                max_payer_amount_sat: core::ptr::null_mut(),
12798                swapper_feerate: core::ptr::null_mut(),
12799            }
12800        }
12801    }
12802    impl Default for wire_cst_prepare_receive_response {
12803        fn default() -> Self {
12804            Self::new_with_null_ptr()
12805        }
12806    }
12807    impl NewWithNullPtr for wire_cst_prepare_refund_request {
12808        fn new_with_null_ptr() -> Self {
12809            Self {
12810                swap_address: core::ptr::null_mut(),
12811                refund_address: core::ptr::null_mut(),
12812                fee_rate_sat_per_vbyte: Default::default(),
12813            }
12814        }
12815    }
12816    impl Default for wire_cst_prepare_refund_request {
12817        fn default() -> Self {
12818            Self::new_with_null_ptr()
12819        }
12820    }
12821    impl NewWithNullPtr for wire_cst_prepare_refund_response {
12822        fn new_with_null_ptr() -> Self {
12823            Self {
12824                tx_vsize: Default::default(),
12825                tx_fee_sat: Default::default(),
12826                last_refund_tx_id: core::ptr::null_mut(),
12827            }
12828        }
12829    }
12830    impl Default for wire_cst_prepare_refund_response {
12831        fn default() -> Self {
12832            Self::new_with_null_ptr()
12833        }
12834    }
12835    impl NewWithNullPtr for wire_cst_prepare_send_request {
12836        fn new_with_null_ptr() -> Self {
12837            Self {
12838                destination: core::ptr::null_mut(),
12839                amount: core::ptr::null_mut(),
12840            }
12841        }
12842    }
12843    impl Default for wire_cst_prepare_send_request {
12844        fn default() -> Self {
12845            Self::new_with_null_ptr()
12846        }
12847    }
12848    impl NewWithNullPtr for wire_cst_prepare_send_response {
12849        fn new_with_null_ptr() -> Self {
12850            Self {
12851                destination: Default::default(),
12852                amount: core::ptr::null_mut(),
12853                fees_sat: core::ptr::null_mut(),
12854                estimated_asset_fees: core::ptr::null_mut(),
12855            }
12856        }
12857    }
12858    impl Default for wire_cst_prepare_send_response {
12859        fn default() -> Self {
12860            Self::new_with_null_ptr()
12861        }
12862    }
12863    impl NewWithNullPtr for wire_cst_rate {
12864        fn new_with_null_ptr() -> Self {
12865            Self {
12866                coin: core::ptr::null_mut(),
12867                value: Default::default(),
12868            }
12869        }
12870    }
12871    impl Default for wire_cst_rate {
12872        fn default() -> Self {
12873            Self::new_with_null_ptr()
12874        }
12875    }
12876    impl NewWithNullPtr for wire_cst_receive_amount {
12877        fn new_with_null_ptr() -> Self {
12878            Self {
12879                tag: -1,
12880                kind: ReceiveAmountKind { nil__: () },
12881            }
12882        }
12883    }
12884    impl Default for wire_cst_receive_amount {
12885        fn default() -> Self {
12886            Self::new_with_null_ptr()
12887        }
12888    }
12889    impl NewWithNullPtr for wire_cst_receive_payment_request {
12890        fn new_with_null_ptr() -> Self {
12891            Self {
12892                prepare_response: Default::default(),
12893                description: core::ptr::null_mut(),
12894                use_description_hash: core::ptr::null_mut(),
12895                payer_note: core::ptr::null_mut(),
12896            }
12897        }
12898    }
12899    impl Default for wire_cst_receive_payment_request {
12900        fn default() -> Self {
12901            Self::new_with_null_ptr()
12902        }
12903    }
12904    impl NewWithNullPtr for wire_cst_receive_payment_response {
12905        fn new_with_null_ptr() -> Self {
12906            Self {
12907                destination: core::ptr::null_mut(),
12908            }
12909        }
12910    }
12911    impl Default for wire_cst_receive_payment_response {
12912        fn default() -> Self {
12913            Self::new_with_null_ptr()
12914        }
12915    }
12916    impl NewWithNullPtr for wire_cst_recommended_fees {
12917        fn new_with_null_ptr() -> Self {
12918            Self {
12919                fastest_fee: Default::default(),
12920                half_hour_fee: Default::default(),
12921                hour_fee: Default::default(),
12922                economy_fee: Default::default(),
12923                minimum_fee: Default::default(),
12924            }
12925        }
12926    }
12927    impl Default for wire_cst_recommended_fees {
12928        fn default() -> Self {
12929            Self::new_with_null_ptr()
12930        }
12931    }
12932    impl NewWithNullPtr for wire_cst_refund_request {
12933        fn new_with_null_ptr() -> Self {
12934            Self {
12935                swap_address: core::ptr::null_mut(),
12936                refund_address: core::ptr::null_mut(),
12937                fee_rate_sat_per_vbyte: Default::default(),
12938            }
12939        }
12940    }
12941    impl Default for wire_cst_refund_request {
12942        fn default() -> Self {
12943            Self::new_with_null_ptr()
12944        }
12945    }
12946    impl NewWithNullPtr for wire_cst_refund_response {
12947        fn new_with_null_ptr() -> Self {
12948            Self {
12949                refund_tx_id: core::ptr::null_mut(),
12950            }
12951        }
12952    }
12953    impl Default for wire_cst_refund_response {
12954        fn default() -> Self {
12955            Self::new_with_null_ptr()
12956        }
12957    }
12958    impl NewWithNullPtr for wire_cst_refundable_swap {
12959        fn new_with_null_ptr() -> Self {
12960            Self {
12961                swap_address: core::ptr::null_mut(),
12962                timestamp: Default::default(),
12963                amount_sat: Default::default(),
12964                last_refund_tx_id: core::ptr::null_mut(),
12965            }
12966        }
12967    }
12968    impl Default for wire_cst_refundable_swap {
12969        fn default() -> Self {
12970            Self::new_with_null_ptr()
12971        }
12972    }
12973    impl NewWithNullPtr for wire_cst_restore_request {
12974        fn new_with_null_ptr() -> Self {
12975            Self {
12976                backup_path: core::ptr::null_mut(),
12977            }
12978        }
12979    }
12980    impl Default for wire_cst_restore_request {
12981        fn default() -> Self {
12982            Self::new_with_null_ptr()
12983        }
12984    }
12985    impl NewWithNullPtr for wire_cst_route_hint {
12986        fn new_with_null_ptr() -> Self {
12987            Self {
12988                hops: core::ptr::null_mut(),
12989            }
12990        }
12991    }
12992    impl Default for wire_cst_route_hint {
12993        fn default() -> Self {
12994            Self::new_with_null_ptr()
12995        }
12996    }
12997    impl NewWithNullPtr for wire_cst_route_hint_hop {
12998        fn new_with_null_ptr() -> Self {
12999            Self {
13000                src_node_id: core::ptr::null_mut(),
13001                short_channel_id: core::ptr::null_mut(),
13002                fees_base_msat: Default::default(),
13003                fees_proportional_millionths: Default::default(),
13004                cltv_expiry_delta: Default::default(),
13005                htlc_minimum_msat: core::ptr::null_mut(),
13006                htlc_maximum_msat: core::ptr::null_mut(),
13007            }
13008        }
13009    }
13010    impl Default for wire_cst_route_hint_hop {
13011        fn default() -> Self {
13012            Self::new_with_null_ptr()
13013        }
13014    }
13015    impl NewWithNullPtr for wire_cst_sdk_error {
13016        fn new_with_null_ptr() -> Self {
13017            Self {
13018                tag: -1,
13019                kind: SdkErrorKind { nil__: () },
13020            }
13021        }
13022    }
13023    impl Default for wire_cst_sdk_error {
13024        fn default() -> Self {
13025            Self::new_with_null_ptr()
13026        }
13027    }
13028    impl NewWithNullPtr for wire_cst_sdk_event {
13029        fn new_with_null_ptr() -> Self {
13030            Self {
13031                tag: -1,
13032                kind: SdkEventKind { nil__: () },
13033            }
13034        }
13035    }
13036    impl Default for wire_cst_sdk_event {
13037        fn default() -> Self {
13038            Self::new_with_null_ptr()
13039        }
13040    }
13041    impl NewWithNullPtr for wire_cst_send_destination {
13042        fn new_with_null_ptr() -> Self {
13043            Self {
13044                tag: -1,
13045                kind: SendDestinationKind { nil__: () },
13046            }
13047        }
13048    }
13049    impl Default for wire_cst_send_destination {
13050        fn default() -> Self {
13051            Self::new_with_null_ptr()
13052        }
13053    }
13054    impl NewWithNullPtr for wire_cst_send_payment_request {
13055        fn new_with_null_ptr() -> Self {
13056            Self {
13057                prepare_response: Default::default(),
13058                use_asset_fees: core::ptr::null_mut(),
13059                payer_note: core::ptr::null_mut(),
13060            }
13061        }
13062    }
13063    impl Default for wire_cst_send_payment_request {
13064        fn default() -> Self {
13065            Self::new_with_null_ptr()
13066        }
13067    }
13068    impl NewWithNullPtr for wire_cst_send_payment_response {
13069        fn new_with_null_ptr() -> Self {
13070            Self {
13071                payment: Default::default(),
13072            }
13073        }
13074    }
13075    impl Default for wire_cst_send_payment_response {
13076        fn default() -> Self {
13077            Self::new_with_null_ptr()
13078        }
13079    }
13080    impl NewWithNullPtr for wire_cst_sign_message_request {
13081        fn new_with_null_ptr() -> Self {
13082            Self {
13083                message: core::ptr::null_mut(),
13084            }
13085        }
13086    }
13087    impl Default for wire_cst_sign_message_request {
13088        fn default() -> Self {
13089            Self::new_with_null_ptr()
13090        }
13091    }
13092    impl NewWithNullPtr for wire_cst_sign_message_response {
13093        fn new_with_null_ptr() -> Self {
13094            Self {
13095                signature: core::ptr::null_mut(),
13096            }
13097        }
13098    }
13099    impl Default for wire_cst_sign_message_response {
13100        fn default() -> Self {
13101            Self::new_with_null_ptr()
13102        }
13103    }
13104    impl NewWithNullPtr for wire_cst_success_action {
13105        fn new_with_null_ptr() -> Self {
13106            Self {
13107                tag: -1,
13108                kind: SuccessActionKind { nil__: () },
13109            }
13110        }
13111    }
13112    impl Default for wire_cst_success_action {
13113        fn default() -> Self {
13114            Self::new_with_null_ptr()
13115        }
13116    }
13117    impl NewWithNullPtr for wire_cst_success_action_processed {
13118        fn new_with_null_ptr() -> Self {
13119            Self {
13120                tag: -1,
13121                kind: SuccessActionProcessedKind { nil__: () },
13122            }
13123        }
13124    }
13125    impl Default for wire_cst_success_action_processed {
13126        fn default() -> Self {
13127            Self::new_with_null_ptr()
13128        }
13129    }
13130    impl NewWithNullPtr for wire_cst_symbol {
13131        fn new_with_null_ptr() -> Self {
13132            Self {
13133                grapheme: core::ptr::null_mut(),
13134                template: core::ptr::null_mut(),
13135                rtl: core::ptr::null_mut(),
13136                position: core::ptr::null_mut(),
13137            }
13138        }
13139    }
13140    impl Default for wire_cst_symbol {
13141        fn default() -> Self {
13142            Self::new_with_null_ptr()
13143        }
13144    }
13145    impl NewWithNullPtr for wire_cst_url_success_action_data {
13146        fn new_with_null_ptr() -> Self {
13147            Self {
13148                description: core::ptr::null_mut(),
13149                url: core::ptr::null_mut(),
13150                matches_callback_domain: Default::default(),
13151            }
13152        }
13153    }
13154    impl Default for wire_cst_url_success_action_data {
13155        fn default() -> Self {
13156            Self::new_with_null_ptr()
13157        }
13158    }
13159    impl NewWithNullPtr for wire_cst_wallet_info {
13160        fn new_with_null_ptr() -> Self {
13161            Self {
13162                balance_sat: Default::default(),
13163                pending_send_sat: Default::default(),
13164                pending_receive_sat: Default::default(),
13165                fingerprint: core::ptr::null_mut(),
13166                pubkey: core::ptr::null_mut(),
13167                asset_balances: core::ptr::null_mut(),
13168            }
13169        }
13170    }
13171    impl Default for wire_cst_wallet_info {
13172        fn default() -> Self {
13173            Self::new_with_null_ptr()
13174        }
13175    }
13176
13177    #[unsafe(no_mangle)]
13178    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_accept_payment_proposed_fees(
13179        port_: i64,
13180        that: usize,
13181        req: *mut wire_cst_accept_payment_proposed_fees_request,
13182    ) {
13183        wire__crate__bindings__BindingLiquidSdk_accept_payment_proposed_fees_impl(port_, that, req)
13184    }
13185
13186    #[unsafe(no_mangle)]
13187    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_add_event_listener(
13188        port_: i64,
13189        that: usize,
13190        listener: *mut wire_cst_list_prim_u_8_strict,
13191    ) {
13192        wire__crate__bindings__BindingLiquidSdk_add_event_listener_impl(port_, that, listener)
13193    }
13194
13195    #[unsafe(no_mangle)]
13196    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_backup(
13197        that: usize,
13198        req: *mut wire_cst_backup_request,
13199    ) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
13200        wire__crate__bindings__BindingLiquidSdk_backup_impl(that, req)
13201    }
13202
13203    #[unsafe(no_mangle)]
13204    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_buy_bitcoin(
13205        port_: i64,
13206        that: usize,
13207        req: *mut wire_cst_buy_bitcoin_request,
13208    ) {
13209        wire__crate__bindings__BindingLiquidSdk_buy_bitcoin_impl(port_, that, req)
13210    }
13211
13212    #[unsafe(no_mangle)]
13213    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_check_message(
13214        that: usize,
13215        req: *mut wire_cst_check_message_request,
13216    ) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
13217        wire__crate__bindings__BindingLiquidSdk_check_message_impl(that, req)
13218    }
13219
13220    #[unsafe(no_mangle)]
13221    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_create_bolt12_invoice(
13222        port_: i64,
13223        that: usize,
13224        req: *mut wire_cst_create_bolt_12_invoice_request,
13225    ) {
13226        wire__crate__bindings__BindingLiquidSdk_create_bolt12_invoice_impl(port_, that, req)
13227    }
13228
13229    #[unsafe(no_mangle)]
13230    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_disconnect(
13231        port_: i64,
13232        that: usize,
13233    ) {
13234        wire__crate__bindings__BindingLiquidSdk_disconnect_impl(port_, that)
13235    }
13236
13237    #[unsafe(no_mangle)]
13238    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_empty_wallet_cache(
13239        that: usize,
13240    ) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
13241        wire__crate__bindings__BindingLiquidSdk_empty_wallet_cache_impl(that)
13242    }
13243
13244    #[unsafe(no_mangle)]
13245    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_fetch_fiat_rates(
13246        port_: i64,
13247        that: usize,
13248    ) {
13249        wire__crate__bindings__BindingLiquidSdk_fetch_fiat_rates_impl(port_, that)
13250    }
13251
13252    #[unsafe(no_mangle)]
13253    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_fetch_lightning_limits(
13254        port_: i64,
13255        that: usize,
13256    ) {
13257        wire__crate__bindings__BindingLiquidSdk_fetch_lightning_limits_impl(port_, that)
13258    }
13259
13260    #[unsafe(no_mangle)]
13261    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_fetch_onchain_limits(
13262        port_: i64,
13263        that: usize,
13264    ) {
13265        wire__crate__bindings__BindingLiquidSdk_fetch_onchain_limits_impl(port_, that)
13266    }
13267
13268    #[unsafe(no_mangle)]
13269    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_fetch_payment_proposed_fees(
13270        port_: i64,
13271        that: usize,
13272        req: *mut wire_cst_fetch_payment_proposed_fees_request,
13273    ) {
13274        wire__crate__bindings__BindingLiquidSdk_fetch_payment_proposed_fees_impl(port_, that, req)
13275    }
13276
13277    #[unsafe(no_mangle)]
13278    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_get_info(
13279        port_: i64,
13280        that: usize,
13281    ) {
13282        wire__crate__bindings__BindingLiquidSdk_get_info_impl(port_, that)
13283    }
13284
13285    #[unsafe(no_mangle)]
13286    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_get_payment(
13287        port_: i64,
13288        that: usize,
13289        req: *mut wire_cst_get_payment_request,
13290    ) {
13291        wire__crate__bindings__BindingLiquidSdk_get_payment_impl(port_, that, req)
13292    }
13293
13294    #[unsafe(no_mangle)]
13295    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_list_fiat_currencies(
13296        port_: i64,
13297        that: usize,
13298    ) {
13299        wire__crate__bindings__BindingLiquidSdk_list_fiat_currencies_impl(port_, that)
13300    }
13301
13302    #[unsafe(no_mangle)]
13303    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_list_payments(
13304        port_: i64,
13305        that: usize,
13306        req: *mut wire_cst_list_payments_request,
13307    ) {
13308        wire__crate__bindings__BindingLiquidSdk_list_payments_impl(port_, that, req)
13309    }
13310
13311    #[unsafe(no_mangle)]
13312    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_list_refundables(
13313        port_: i64,
13314        that: usize,
13315    ) {
13316        wire__crate__bindings__BindingLiquidSdk_list_refundables_impl(port_, that)
13317    }
13318
13319    #[unsafe(no_mangle)]
13320    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_lnurl_auth(
13321        port_: i64,
13322        that: usize,
13323        req_data: *mut wire_cst_ln_url_auth_request_data,
13324    ) {
13325        wire__crate__bindings__BindingLiquidSdk_lnurl_auth_impl(port_, that, req_data)
13326    }
13327
13328    #[unsafe(no_mangle)]
13329    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_lnurl_pay(
13330        port_: i64,
13331        that: usize,
13332        req: *mut wire_cst_ln_url_pay_request,
13333    ) {
13334        wire__crate__bindings__BindingLiquidSdk_lnurl_pay_impl(port_, that, req)
13335    }
13336
13337    #[unsafe(no_mangle)]
13338    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_lnurl_withdraw(
13339        port_: i64,
13340        that: usize,
13341        req: *mut wire_cst_ln_url_withdraw_request,
13342    ) {
13343        wire__crate__bindings__BindingLiquidSdk_lnurl_withdraw_impl(port_, that, req)
13344    }
13345
13346    #[unsafe(no_mangle)]
13347    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_parse(
13348        port_: i64,
13349        that: usize,
13350        input: *mut wire_cst_list_prim_u_8_strict,
13351    ) {
13352        wire__crate__bindings__BindingLiquidSdk_parse_impl(port_, that, input)
13353    }
13354
13355    #[unsafe(no_mangle)]
13356    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_pay_onchain(
13357        port_: i64,
13358        that: usize,
13359        req: *mut wire_cst_pay_onchain_request,
13360    ) {
13361        wire__crate__bindings__BindingLiquidSdk_pay_onchain_impl(port_, that, req)
13362    }
13363
13364    #[unsafe(no_mangle)]
13365    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_prepare_buy_bitcoin(
13366        port_: i64,
13367        that: usize,
13368        req: *mut wire_cst_prepare_buy_bitcoin_request,
13369    ) {
13370        wire__crate__bindings__BindingLiquidSdk_prepare_buy_bitcoin_impl(port_, that, req)
13371    }
13372
13373    #[unsafe(no_mangle)]
13374    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_prepare_lnurl_pay(
13375        port_: i64,
13376        that: usize,
13377        req: *mut wire_cst_prepare_ln_url_pay_request,
13378    ) {
13379        wire__crate__bindings__BindingLiquidSdk_prepare_lnurl_pay_impl(port_, that, req)
13380    }
13381
13382    #[unsafe(no_mangle)]
13383    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_prepare_pay_onchain(
13384        port_: i64,
13385        that: usize,
13386        req: *mut wire_cst_prepare_pay_onchain_request,
13387    ) {
13388        wire__crate__bindings__BindingLiquidSdk_prepare_pay_onchain_impl(port_, that, req)
13389    }
13390
13391    #[unsafe(no_mangle)]
13392    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_prepare_receive_payment(
13393        port_: i64,
13394        that: usize,
13395        req: *mut wire_cst_prepare_receive_request,
13396    ) {
13397        wire__crate__bindings__BindingLiquidSdk_prepare_receive_payment_impl(port_, that, req)
13398    }
13399
13400    #[unsafe(no_mangle)]
13401    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_prepare_refund(
13402        port_: i64,
13403        that: usize,
13404        req: *mut wire_cst_prepare_refund_request,
13405    ) {
13406        wire__crate__bindings__BindingLiquidSdk_prepare_refund_impl(port_, that, req)
13407    }
13408
13409    #[unsafe(no_mangle)]
13410    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_prepare_send_payment(
13411        port_: i64,
13412        that: usize,
13413        req: *mut wire_cst_prepare_send_request,
13414    ) {
13415        wire__crate__bindings__BindingLiquidSdk_prepare_send_payment_impl(port_, that, req)
13416    }
13417
13418    #[unsafe(no_mangle)]
13419    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_receive_payment(
13420        port_: i64,
13421        that: usize,
13422        req: *mut wire_cst_receive_payment_request,
13423    ) {
13424        wire__crate__bindings__BindingLiquidSdk_receive_payment_impl(port_, that, req)
13425    }
13426
13427    #[unsafe(no_mangle)]
13428    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_recommended_fees(
13429        port_: i64,
13430        that: usize,
13431    ) {
13432        wire__crate__bindings__BindingLiquidSdk_recommended_fees_impl(port_, that)
13433    }
13434
13435    #[unsafe(no_mangle)]
13436    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_refund(
13437        port_: i64,
13438        that: usize,
13439        req: *mut wire_cst_refund_request,
13440    ) {
13441        wire__crate__bindings__BindingLiquidSdk_refund_impl(port_, that, req)
13442    }
13443
13444    #[unsafe(no_mangle)]
13445    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_register_webhook(
13446        port_: i64,
13447        that: usize,
13448        webhook_url: *mut wire_cst_list_prim_u_8_strict,
13449    ) {
13450        wire__crate__bindings__BindingLiquidSdk_register_webhook_impl(port_, that, webhook_url)
13451    }
13452
13453    #[unsafe(no_mangle)]
13454    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_rescan_onchain_swaps(
13455        port_: i64,
13456        that: usize,
13457    ) {
13458        wire__crate__bindings__BindingLiquidSdk_rescan_onchain_swaps_impl(port_, that)
13459    }
13460
13461    #[unsafe(no_mangle)]
13462    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_restore(
13463        that: usize,
13464        req: *mut wire_cst_restore_request,
13465    ) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
13466        wire__crate__bindings__BindingLiquidSdk_restore_impl(that, req)
13467    }
13468
13469    #[unsafe(no_mangle)]
13470    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_send_payment(
13471        port_: i64,
13472        that: usize,
13473        req: *mut wire_cst_send_payment_request,
13474    ) {
13475        wire__crate__bindings__BindingLiquidSdk_send_payment_impl(port_, that, req)
13476    }
13477
13478    #[unsafe(no_mangle)]
13479    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_sign_message(
13480        that: usize,
13481        req: *mut wire_cst_sign_message_request,
13482    ) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
13483        wire__crate__bindings__BindingLiquidSdk_sign_message_impl(that, req)
13484    }
13485
13486    #[unsafe(no_mangle)]
13487    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_sync(
13488        port_: i64,
13489        that: usize,
13490    ) {
13491        wire__crate__bindings__BindingLiquidSdk_sync_impl(port_, that)
13492    }
13493
13494    #[unsafe(no_mangle)]
13495    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_unregister_webhook(
13496        port_: i64,
13497        that: usize,
13498    ) {
13499        wire__crate__bindings__BindingLiquidSdk_unregister_webhook_impl(port_, that)
13500    }
13501
13502    #[unsafe(no_mangle)]
13503    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__binding_event_listener_on_event(
13504        port_: i64,
13505        that: *mut wire_cst_binding_event_listener,
13506        e: *mut wire_cst_sdk_event,
13507    ) {
13508        wire__crate__bindings__binding_event_listener_on_event_impl(port_, that, e)
13509    }
13510
13511    #[unsafe(no_mangle)]
13512    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__breez_log_stream(
13513        port_: i64,
13514        s: *mut wire_cst_list_prim_u_8_strict,
13515    ) {
13516        wire__crate__bindings__breez_log_stream_impl(port_, s)
13517    }
13518
13519    #[unsafe(no_mangle)]
13520    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__connect(
13521        port_: i64,
13522        req: *mut wire_cst_connect_request,
13523    ) {
13524        wire__crate__bindings__connect_impl(port_, req)
13525    }
13526
13527    #[unsafe(no_mangle)]
13528    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__default_config(
13529        network: i32,
13530        breez_api_key: *mut wire_cst_list_prim_u_8_strict,
13531    ) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
13532        wire__crate__bindings__default_config_impl(network, breez_api_key)
13533    }
13534
13535    #[unsafe(no_mangle)]
13536    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__parse_invoice(
13537        input: *mut wire_cst_list_prim_u_8_strict,
13538    ) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
13539        wire__crate__bindings__parse_invoice_impl(input)
13540    }
13541
13542    #[unsafe(no_mangle)]
13543    pub extern "C" fn frbgen_breez_liquid_rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerBindingLiquidSdk(
13544        ptr: *const std::ffi::c_void,
13545    ) {
13546        unsafe {
13547            StdArc::<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>::increment_strong_count(ptr as _);
13548        }
13549    }
13550
13551    #[unsafe(no_mangle)]
13552    pub extern "C" fn frbgen_breez_liquid_rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerBindingLiquidSdk(
13553        ptr: *const std::ffi::c_void,
13554    ) {
13555        unsafe {
13556            StdArc::<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>::decrement_strong_count(ptr as _);
13557        }
13558    }
13559
13560    #[unsafe(no_mangle)]
13561    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_accept_payment_proposed_fees_request(
13562    ) -> *mut wire_cst_accept_payment_proposed_fees_request {
13563        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13564            wire_cst_accept_payment_proposed_fees_request::new_with_null_ptr(),
13565        )
13566    }
13567
13568    #[unsafe(no_mangle)]
13569    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_aes_success_action_data(
13570    ) -> *mut wire_cst_aes_success_action_data {
13571        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13572            wire_cst_aes_success_action_data::new_with_null_ptr(),
13573        )
13574    }
13575
13576    #[unsafe(no_mangle)]
13577    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_aes_success_action_data_decrypted(
13578    ) -> *mut wire_cst_aes_success_action_data_decrypted {
13579        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13580            wire_cst_aes_success_action_data_decrypted::new_with_null_ptr(),
13581        )
13582    }
13583
13584    #[unsafe(no_mangle)]
13585    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_aes_success_action_data_result(
13586    ) -> *mut wire_cst_aes_success_action_data_result {
13587        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13588            wire_cst_aes_success_action_data_result::new_with_null_ptr(),
13589        )
13590    }
13591
13592    #[unsafe(no_mangle)]
13593    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_amount() -> *mut wire_cst_amount {
13594        flutter_rust_bridge::for_generated::new_leak_box_ptr(wire_cst_amount::new_with_null_ptr())
13595    }
13596
13597    #[unsafe(no_mangle)]
13598    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_asset_info(
13599    ) -> *mut wire_cst_asset_info {
13600        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13601            wire_cst_asset_info::new_with_null_ptr(),
13602        )
13603    }
13604
13605    #[unsafe(no_mangle)]
13606    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_backup_request(
13607    ) -> *mut wire_cst_backup_request {
13608        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13609            wire_cst_backup_request::new_with_null_ptr(),
13610        )
13611    }
13612
13613    #[unsafe(no_mangle)]
13614    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_binding_event_listener(
13615    ) -> *mut wire_cst_binding_event_listener {
13616        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13617            wire_cst_binding_event_listener::new_with_null_ptr(),
13618        )
13619    }
13620
13621    #[unsafe(no_mangle)]
13622    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_bitcoin_address_data(
13623    ) -> *mut wire_cst_bitcoin_address_data {
13624        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13625            wire_cst_bitcoin_address_data::new_with_null_ptr(),
13626        )
13627    }
13628
13629    #[unsafe(no_mangle)]
13630    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_bool(value: bool) -> *mut bool {
13631        flutter_rust_bridge::for_generated::new_leak_box_ptr(value)
13632    }
13633
13634    #[unsafe(no_mangle)]
13635    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_buy_bitcoin_request(
13636    ) -> *mut wire_cst_buy_bitcoin_request {
13637        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13638            wire_cst_buy_bitcoin_request::new_with_null_ptr(),
13639        )
13640    }
13641
13642    #[unsafe(no_mangle)]
13643    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_check_message_request(
13644    ) -> *mut wire_cst_check_message_request {
13645        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13646            wire_cst_check_message_request::new_with_null_ptr(),
13647        )
13648    }
13649
13650    #[unsafe(no_mangle)]
13651    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_connect_request(
13652    ) -> *mut wire_cst_connect_request {
13653        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13654            wire_cst_connect_request::new_with_null_ptr(),
13655        )
13656    }
13657
13658    #[unsafe(no_mangle)]
13659    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_create_bolt_12_invoice_request(
13660    ) -> *mut wire_cst_create_bolt_12_invoice_request {
13661        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13662            wire_cst_create_bolt_12_invoice_request::new_with_null_ptr(),
13663        )
13664    }
13665
13666    #[unsafe(no_mangle)]
13667    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_f_64(value: f64) -> *mut f64 {
13668        flutter_rust_bridge::for_generated::new_leak_box_ptr(value)
13669    }
13670
13671    #[unsafe(no_mangle)]
13672    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_fetch_payment_proposed_fees_request(
13673    ) -> *mut wire_cst_fetch_payment_proposed_fees_request {
13674        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13675            wire_cst_fetch_payment_proposed_fees_request::new_with_null_ptr(),
13676        )
13677    }
13678
13679    #[unsafe(no_mangle)]
13680    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_get_payment_request(
13681    ) -> *mut wire_cst_get_payment_request {
13682        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13683            wire_cst_get_payment_request::new_with_null_ptr(),
13684        )
13685    }
13686
13687    #[unsafe(no_mangle)]
13688    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_i_64(value: i64) -> *mut i64 {
13689        flutter_rust_bridge::for_generated::new_leak_box_ptr(value)
13690    }
13691
13692    #[unsafe(no_mangle)]
13693    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_liquid_address_data(
13694    ) -> *mut wire_cst_liquid_address_data {
13695        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13696            wire_cst_liquid_address_data::new_with_null_ptr(),
13697        )
13698    }
13699
13700    #[unsafe(no_mangle)]
13701    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_list_payment_details(
13702    ) -> *mut wire_cst_list_payment_details {
13703        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13704            wire_cst_list_payment_details::new_with_null_ptr(),
13705        )
13706    }
13707
13708    #[unsafe(no_mangle)]
13709    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_list_payments_request(
13710    ) -> *mut wire_cst_list_payments_request {
13711        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13712            wire_cst_list_payments_request::new_with_null_ptr(),
13713        )
13714    }
13715
13716    #[unsafe(no_mangle)]
13717    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_invoice(
13718    ) -> *mut wire_cst_ln_invoice {
13719        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13720            wire_cst_ln_invoice::new_with_null_ptr(),
13721        )
13722    }
13723
13724    #[unsafe(no_mangle)]
13725    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_offer() -> *mut wire_cst_ln_offer {
13726        flutter_rust_bridge::for_generated::new_leak_box_ptr(wire_cst_ln_offer::new_with_null_ptr())
13727    }
13728
13729    #[unsafe(no_mangle)]
13730    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_url_auth_request_data(
13731    ) -> *mut wire_cst_ln_url_auth_request_data {
13732        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13733            wire_cst_ln_url_auth_request_data::new_with_null_ptr(),
13734        )
13735    }
13736
13737    #[unsafe(no_mangle)]
13738    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_url_error_data(
13739    ) -> *mut wire_cst_ln_url_error_data {
13740        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13741            wire_cst_ln_url_error_data::new_with_null_ptr(),
13742        )
13743    }
13744
13745    #[unsafe(no_mangle)]
13746    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_url_info(
13747    ) -> *mut wire_cst_ln_url_info {
13748        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13749            wire_cst_ln_url_info::new_with_null_ptr(),
13750        )
13751    }
13752
13753    #[unsafe(no_mangle)]
13754    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_url_pay_error_data(
13755    ) -> *mut wire_cst_ln_url_pay_error_data {
13756        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13757            wire_cst_ln_url_pay_error_data::new_with_null_ptr(),
13758        )
13759    }
13760
13761    #[unsafe(no_mangle)]
13762    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_url_pay_request(
13763    ) -> *mut wire_cst_ln_url_pay_request {
13764        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13765            wire_cst_ln_url_pay_request::new_with_null_ptr(),
13766        )
13767    }
13768
13769    #[unsafe(no_mangle)]
13770    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_url_pay_request_data(
13771    ) -> *mut wire_cst_ln_url_pay_request_data {
13772        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13773            wire_cst_ln_url_pay_request_data::new_with_null_ptr(),
13774        )
13775    }
13776
13777    #[unsafe(no_mangle)]
13778    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_url_pay_success_data(
13779    ) -> *mut wire_cst_ln_url_pay_success_data {
13780        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13781            wire_cst_ln_url_pay_success_data::new_with_null_ptr(),
13782        )
13783    }
13784
13785    #[unsafe(no_mangle)]
13786    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_url_withdraw_request(
13787    ) -> *mut wire_cst_ln_url_withdraw_request {
13788        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13789            wire_cst_ln_url_withdraw_request::new_with_null_ptr(),
13790        )
13791    }
13792
13793    #[unsafe(no_mangle)]
13794    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_url_withdraw_request_data(
13795    ) -> *mut wire_cst_ln_url_withdraw_request_data {
13796        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13797            wire_cst_ln_url_withdraw_request_data::new_with_null_ptr(),
13798        )
13799    }
13800
13801    #[unsafe(no_mangle)]
13802    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_url_withdraw_success_data(
13803    ) -> *mut wire_cst_ln_url_withdraw_success_data {
13804        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13805            wire_cst_ln_url_withdraw_success_data::new_with_null_ptr(),
13806        )
13807    }
13808
13809    #[unsafe(no_mangle)]
13810    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_message_success_action_data(
13811    ) -> *mut wire_cst_message_success_action_data {
13812        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13813            wire_cst_message_success_action_data::new_with_null_ptr(),
13814        )
13815    }
13816
13817    #[unsafe(no_mangle)]
13818    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_pay_amount(
13819    ) -> *mut wire_cst_pay_amount {
13820        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13821            wire_cst_pay_amount::new_with_null_ptr(),
13822        )
13823    }
13824
13825    #[unsafe(no_mangle)]
13826    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_pay_onchain_request(
13827    ) -> *mut wire_cst_pay_onchain_request {
13828        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13829            wire_cst_pay_onchain_request::new_with_null_ptr(),
13830        )
13831    }
13832
13833    #[unsafe(no_mangle)]
13834    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_payment() -> *mut wire_cst_payment {
13835        flutter_rust_bridge::for_generated::new_leak_box_ptr(wire_cst_payment::new_with_null_ptr())
13836    }
13837
13838    #[unsafe(no_mangle)]
13839    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_prepare_buy_bitcoin_request(
13840    ) -> *mut wire_cst_prepare_buy_bitcoin_request {
13841        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13842            wire_cst_prepare_buy_bitcoin_request::new_with_null_ptr(),
13843        )
13844    }
13845
13846    #[unsafe(no_mangle)]
13847    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_prepare_ln_url_pay_request(
13848    ) -> *mut wire_cst_prepare_ln_url_pay_request {
13849        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13850            wire_cst_prepare_ln_url_pay_request::new_with_null_ptr(),
13851        )
13852    }
13853
13854    #[unsafe(no_mangle)]
13855    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_prepare_pay_onchain_request(
13856    ) -> *mut wire_cst_prepare_pay_onchain_request {
13857        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13858            wire_cst_prepare_pay_onchain_request::new_with_null_ptr(),
13859        )
13860    }
13861
13862    #[unsafe(no_mangle)]
13863    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_prepare_receive_request(
13864    ) -> *mut wire_cst_prepare_receive_request {
13865        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13866            wire_cst_prepare_receive_request::new_with_null_ptr(),
13867        )
13868    }
13869
13870    #[unsafe(no_mangle)]
13871    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_prepare_refund_request(
13872    ) -> *mut wire_cst_prepare_refund_request {
13873        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13874            wire_cst_prepare_refund_request::new_with_null_ptr(),
13875        )
13876    }
13877
13878    #[unsafe(no_mangle)]
13879    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_prepare_send_request(
13880    ) -> *mut wire_cst_prepare_send_request {
13881        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13882            wire_cst_prepare_send_request::new_with_null_ptr(),
13883        )
13884    }
13885
13886    #[unsafe(no_mangle)]
13887    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_receive_amount(
13888    ) -> *mut wire_cst_receive_amount {
13889        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13890            wire_cst_receive_amount::new_with_null_ptr(),
13891        )
13892    }
13893
13894    #[unsafe(no_mangle)]
13895    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_receive_payment_request(
13896    ) -> *mut wire_cst_receive_payment_request {
13897        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13898            wire_cst_receive_payment_request::new_with_null_ptr(),
13899        )
13900    }
13901
13902    #[unsafe(no_mangle)]
13903    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_refund_request(
13904    ) -> *mut wire_cst_refund_request {
13905        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13906            wire_cst_refund_request::new_with_null_ptr(),
13907        )
13908    }
13909
13910    #[unsafe(no_mangle)]
13911    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_restore_request(
13912    ) -> *mut wire_cst_restore_request {
13913        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13914            wire_cst_restore_request::new_with_null_ptr(),
13915        )
13916    }
13917
13918    #[unsafe(no_mangle)]
13919    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_sdk_event() -> *mut wire_cst_sdk_event
13920    {
13921        flutter_rust_bridge::for_generated::new_leak_box_ptr(wire_cst_sdk_event::new_with_null_ptr())
13922    }
13923
13924    #[unsafe(no_mangle)]
13925    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_send_payment_request(
13926    ) -> *mut wire_cst_send_payment_request {
13927        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13928            wire_cst_send_payment_request::new_with_null_ptr(),
13929        )
13930    }
13931
13932    #[unsafe(no_mangle)]
13933    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_sign_message_request(
13934    ) -> *mut wire_cst_sign_message_request {
13935        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13936            wire_cst_sign_message_request::new_with_null_ptr(),
13937        )
13938    }
13939
13940    #[unsafe(no_mangle)]
13941    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_success_action(
13942    ) -> *mut wire_cst_success_action {
13943        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13944            wire_cst_success_action::new_with_null_ptr(),
13945        )
13946    }
13947
13948    #[unsafe(no_mangle)]
13949    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_success_action_processed(
13950    ) -> *mut wire_cst_success_action_processed {
13951        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13952            wire_cst_success_action_processed::new_with_null_ptr(),
13953        )
13954    }
13955
13956    #[unsafe(no_mangle)]
13957    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_symbol() -> *mut wire_cst_symbol {
13958        flutter_rust_bridge::for_generated::new_leak_box_ptr(wire_cst_symbol::new_with_null_ptr())
13959    }
13960
13961    #[unsafe(no_mangle)]
13962    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_u_32(value: u32) -> *mut u32 {
13963        flutter_rust_bridge::for_generated::new_leak_box_ptr(value)
13964    }
13965
13966    #[unsafe(no_mangle)]
13967    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_u_64(value: u64) -> *mut u64 {
13968        flutter_rust_bridge::for_generated::new_leak_box_ptr(value)
13969    }
13970
13971    #[unsafe(no_mangle)]
13972    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_url_success_action_data(
13973    ) -> *mut wire_cst_url_success_action_data {
13974        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13975            wire_cst_url_success_action_data::new_with_null_ptr(),
13976        )
13977    }
13978
13979    #[unsafe(no_mangle)]
13980    pub extern "C" fn frbgen_breez_liquid_cst_new_list_String(
13981        len: i32,
13982    ) -> *mut wire_cst_list_String {
13983        let wrap = wire_cst_list_String {
13984            ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
13985                <*mut wire_cst_list_prim_u_8_strict>::new_with_null_ptr(),
13986                len,
13987            ),
13988            len,
13989        };
13990        flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
13991    }
13992
13993    #[unsafe(no_mangle)]
13994    pub extern "C" fn frbgen_breez_liquid_cst_new_list_asset_balance(
13995        len: i32,
13996    ) -> *mut wire_cst_list_asset_balance {
13997        let wrap = wire_cst_list_asset_balance {
13998            ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
13999                <wire_cst_asset_balance>::new_with_null_ptr(),
14000                len,
14001            ),
14002            len,
14003        };
14004        flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14005    }
14006
14007    #[unsafe(no_mangle)]
14008    pub extern "C" fn frbgen_breez_liquid_cst_new_list_asset_metadata(
14009        len: i32,
14010    ) -> *mut wire_cst_list_asset_metadata {
14011        let wrap = wire_cst_list_asset_metadata {
14012            ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
14013                <wire_cst_asset_metadata>::new_with_null_ptr(),
14014                len,
14015            ),
14016            len,
14017        };
14018        flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14019    }
14020
14021    #[unsafe(no_mangle)]
14022    pub extern "C" fn frbgen_breez_liquid_cst_new_list_external_input_parser(
14023        len: i32,
14024    ) -> *mut wire_cst_list_external_input_parser {
14025        let wrap = wire_cst_list_external_input_parser {
14026            ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
14027                <wire_cst_external_input_parser>::new_with_null_ptr(),
14028                len,
14029            ),
14030            len,
14031        };
14032        flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14033    }
14034
14035    #[unsafe(no_mangle)]
14036    pub extern "C" fn frbgen_breez_liquid_cst_new_list_fiat_currency(
14037        len: i32,
14038    ) -> *mut wire_cst_list_fiat_currency {
14039        let wrap = wire_cst_list_fiat_currency {
14040            ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
14041                <wire_cst_fiat_currency>::new_with_null_ptr(),
14042                len,
14043            ),
14044            len,
14045        };
14046        flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14047    }
14048
14049    #[unsafe(no_mangle)]
14050    pub extern "C" fn frbgen_breez_liquid_cst_new_list_ln_offer_blinded_path(
14051        len: i32,
14052    ) -> *mut wire_cst_list_ln_offer_blinded_path {
14053        let wrap = wire_cst_list_ln_offer_blinded_path {
14054            ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
14055                <wire_cst_ln_offer_blinded_path>::new_with_null_ptr(),
14056                len,
14057            ),
14058            len,
14059        };
14060        flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14061    }
14062
14063    #[unsafe(no_mangle)]
14064    pub extern "C" fn frbgen_breez_liquid_cst_new_list_locale_overrides(
14065        len: i32,
14066    ) -> *mut wire_cst_list_locale_overrides {
14067        let wrap = wire_cst_list_locale_overrides {
14068            ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
14069                <wire_cst_locale_overrides>::new_with_null_ptr(),
14070                len,
14071            ),
14072            len,
14073        };
14074        flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14075    }
14076
14077    #[unsafe(no_mangle)]
14078    pub extern "C" fn frbgen_breez_liquid_cst_new_list_localized_name(
14079        len: i32,
14080    ) -> *mut wire_cst_list_localized_name {
14081        let wrap = wire_cst_list_localized_name {
14082            ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
14083                <wire_cst_localized_name>::new_with_null_ptr(),
14084                len,
14085            ),
14086            len,
14087        };
14088        flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14089    }
14090
14091    #[unsafe(no_mangle)]
14092    pub extern "C" fn frbgen_breez_liquid_cst_new_list_payment(
14093        len: i32,
14094    ) -> *mut wire_cst_list_payment {
14095        let wrap = wire_cst_list_payment {
14096            ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
14097                <wire_cst_payment>::new_with_null_ptr(),
14098                len,
14099            ),
14100            len,
14101        };
14102        flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14103    }
14104
14105    #[unsafe(no_mangle)]
14106    pub extern "C" fn frbgen_breez_liquid_cst_new_list_payment_state(
14107        len: i32,
14108    ) -> *mut wire_cst_list_payment_state {
14109        let wrap = wire_cst_list_payment_state {
14110            ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(Default::default(), len),
14111            len,
14112        };
14113        flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14114    }
14115
14116    #[unsafe(no_mangle)]
14117    pub extern "C" fn frbgen_breez_liquid_cst_new_list_payment_type(
14118        len: i32,
14119    ) -> *mut wire_cst_list_payment_type {
14120        let wrap = wire_cst_list_payment_type {
14121            ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(Default::default(), len),
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_prim_u_8_strict(
14129        len: i32,
14130    ) -> *mut wire_cst_list_prim_u_8_strict {
14131        let ans = wire_cst_list_prim_u_8_strict {
14132            ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(Default::default(), len),
14133            len,
14134        };
14135        flutter_rust_bridge::for_generated::new_leak_box_ptr(ans)
14136    }
14137
14138    #[unsafe(no_mangle)]
14139    pub extern "C" fn frbgen_breez_liquid_cst_new_list_rate(len: i32) -> *mut wire_cst_list_rate {
14140        let wrap = wire_cst_list_rate {
14141            ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
14142                <wire_cst_rate>::new_with_null_ptr(),
14143                len,
14144            ),
14145            len,
14146        };
14147        flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14148    }
14149
14150    #[unsafe(no_mangle)]
14151    pub extern "C" fn frbgen_breez_liquid_cst_new_list_refundable_swap(
14152        len: i32,
14153    ) -> *mut wire_cst_list_refundable_swap {
14154        let wrap = wire_cst_list_refundable_swap {
14155            ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
14156                <wire_cst_refundable_swap>::new_with_null_ptr(),
14157                len,
14158            ),
14159            len,
14160        };
14161        flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14162    }
14163
14164    #[unsafe(no_mangle)]
14165    pub extern "C" fn frbgen_breez_liquid_cst_new_list_route_hint(
14166        len: i32,
14167    ) -> *mut wire_cst_list_route_hint {
14168        let wrap = wire_cst_list_route_hint {
14169            ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
14170                <wire_cst_route_hint>::new_with_null_ptr(),
14171                len,
14172            ),
14173            len,
14174        };
14175        flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14176    }
14177
14178    #[unsafe(no_mangle)]
14179    pub extern "C" fn frbgen_breez_liquid_cst_new_list_route_hint_hop(
14180        len: i32,
14181    ) -> *mut wire_cst_list_route_hint_hop {
14182        let wrap = wire_cst_list_route_hint_hop {
14183            ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
14184                <wire_cst_route_hint_hop>::new_with_null_ptr(),
14185                len,
14186            ),
14187            len,
14188        };
14189        flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14190    }
14191
14192    #[repr(C)]
14193    #[derive(Clone, Copy)]
14194    pub struct wire_cst_accept_payment_proposed_fees_request {
14195        response: wire_cst_fetch_payment_proposed_fees_response,
14196    }
14197    #[repr(C)]
14198    #[derive(Clone, Copy)]
14199    pub struct wire_cst_aes_success_action_data {
14200        description: *mut wire_cst_list_prim_u_8_strict,
14201        ciphertext: *mut wire_cst_list_prim_u_8_strict,
14202        iv: *mut wire_cst_list_prim_u_8_strict,
14203    }
14204    #[repr(C)]
14205    #[derive(Clone, Copy)]
14206    pub struct wire_cst_aes_success_action_data_decrypted {
14207        description: *mut wire_cst_list_prim_u_8_strict,
14208        plaintext: *mut wire_cst_list_prim_u_8_strict,
14209    }
14210    #[repr(C)]
14211    #[derive(Clone, Copy)]
14212    pub struct wire_cst_aes_success_action_data_result {
14213        tag: i32,
14214        kind: AesSuccessActionDataResultKind,
14215    }
14216    #[repr(C)]
14217    #[derive(Clone, Copy)]
14218    pub union AesSuccessActionDataResultKind {
14219        Decrypted: wire_cst_AesSuccessActionDataResult_Decrypted,
14220        ErrorStatus: wire_cst_AesSuccessActionDataResult_ErrorStatus,
14221        nil__: (),
14222    }
14223    #[repr(C)]
14224    #[derive(Clone, Copy)]
14225    pub struct wire_cst_AesSuccessActionDataResult_Decrypted {
14226        data: *mut wire_cst_aes_success_action_data_decrypted,
14227    }
14228    #[repr(C)]
14229    #[derive(Clone, Copy)]
14230    pub struct wire_cst_AesSuccessActionDataResult_ErrorStatus {
14231        reason: *mut wire_cst_list_prim_u_8_strict,
14232    }
14233    #[repr(C)]
14234    #[derive(Clone, Copy)]
14235    pub struct wire_cst_amount {
14236        tag: i32,
14237        kind: AmountKind,
14238    }
14239    #[repr(C)]
14240    #[derive(Clone, Copy)]
14241    pub union AmountKind {
14242        Bitcoin: wire_cst_Amount_Bitcoin,
14243        Currency: wire_cst_Amount_Currency,
14244        nil__: (),
14245    }
14246    #[repr(C)]
14247    #[derive(Clone, Copy)]
14248    pub struct wire_cst_Amount_Bitcoin {
14249        amount_msat: u64,
14250    }
14251    #[repr(C)]
14252    #[derive(Clone, Copy)]
14253    pub struct wire_cst_Amount_Currency {
14254        iso4217_code: *mut wire_cst_list_prim_u_8_strict,
14255        fractional_amount: u64,
14256    }
14257    #[repr(C)]
14258    #[derive(Clone, Copy)]
14259    pub struct wire_cst_asset_balance {
14260        asset_id: *mut wire_cst_list_prim_u_8_strict,
14261        balance_sat: u64,
14262        name: *mut wire_cst_list_prim_u_8_strict,
14263        ticker: *mut wire_cst_list_prim_u_8_strict,
14264        balance: *mut f64,
14265    }
14266    #[repr(C)]
14267    #[derive(Clone, Copy)]
14268    pub struct wire_cst_asset_info {
14269        name: *mut wire_cst_list_prim_u_8_strict,
14270        ticker: *mut wire_cst_list_prim_u_8_strict,
14271        amount: f64,
14272        fees: *mut f64,
14273    }
14274    #[repr(C)]
14275    #[derive(Clone, Copy)]
14276    pub struct wire_cst_asset_metadata {
14277        asset_id: *mut wire_cst_list_prim_u_8_strict,
14278        name: *mut wire_cst_list_prim_u_8_strict,
14279        ticker: *mut wire_cst_list_prim_u_8_strict,
14280        precision: u8,
14281        fiat_id: *mut wire_cst_list_prim_u_8_strict,
14282    }
14283    #[repr(C)]
14284    #[derive(Clone, Copy)]
14285    pub struct wire_cst_backup_request {
14286        backup_path: *mut wire_cst_list_prim_u_8_strict,
14287    }
14288    #[repr(C)]
14289    #[derive(Clone, Copy)]
14290    pub struct wire_cst_binding_event_listener {
14291        stream: *mut wire_cst_list_prim_u_8_strict,
14292    }
14293    #[repr(C)]
14294    #[derive(Clone, Copy)]
14295    pub struct wire_cst_bitcoin_address_data {
14296        address: *mut wire_cst_list_prim_u_8_strict,
14297        network: i32,
14298        amount_sat: *mut u64,
14299        label: *mut wire_cst_list_prim_u_8_strict,
14300        message: *mut wire_cst_list_prim_u_8_strict,
14301    }
14302    #[repr(C)]
14303    #[derive(Clone, Copy)]
14304    pub struct wire_cst_blockchain_explorer {
14305        tag: i32,
14306        kind: BlockchainExplorerKind,
14307    }
14308    #[repr(C)]
14309    #[derive(Clone, Copy)]
14310    pub union BlockchainExplorerKind {
14311        Electrum: wire_cst_BlockchainExplorer_Electrum,
14312        Esplora: wire_cst_BlockchainExplorer_Esplora,
14313        nil__: (),
14314    }
14315    #[repr(C)]
14316    #[derive(Clone, Copy)]
14317    pub struct wire_cst_BlockchainExplorer_Electrum {
14318        url: *mut wire_cst_list_prim_u_8_strict,
14319    }
14320    #[repr(C)]
14321    #[derive(Clone, Copy)]
14322    pub struct wire_cst_BlockchainExplorer_Esplora {
14323        url: *mut wire_cst_list_prim_u_8_strict,
14324        use_waterfalls: bool,
14325    }
14326    #[repr(C)]
14327    #[derive(Clone, Copy)]
14328    pub struct wire_cst_blockchain_info {
14329        liquid_tip: u32,
14330        bitcoin_tip: u32,
14331    }
14332    #[repr(C)]
14333    #[derive(Clone, Copy)]
14334    pub struct wire_cst_buy_bitcoin_request {
14335        prepare_response: wire_cst_prepare_buy_bitcoin_response,
14336        redirect_url: *mut wire_cst_list_prim_u_8_strict,
14337    }
14338    #[repr(C)]
14339    #[derive(Clone, Copy)]
14340    pub struct wire_cst_check_message_request {
14341        message: *mut wire_cst_list_prim_u_8_strict,
14342        pubkey: *mut wire_cst_list_prim_u_8_strict,
14343        signature: *mut wire_cst_list_prim_u_8_strict,
14344    }
14345    #[repr(C)]
14346    #[derive(Clone, Copy)]
14347    pub struct wire_cst_check_message_response {
14348        is_valid: bool,
14349    }
14350    #[repr(C)]
14351    #[derive(Clone, Copy)]
14352    pub struct wire_cst_config {
14353        liquid_explorer: wire_cst_blockchain_explorer,
14354        bitcoin_explorer: wire_cst_blockchain_explorer,
14355        working_dir: *mut wire_cst_list_prim_u_8_strict,
14356        network: i32,
14357        payment_timeout_sec: u64,
14358        sync_service_url: *mut wire_cst_list_prim_u_8_strict,
14359        zero_conf_max_amount_sat: *mut u64,
14360        breez_api_key: *mut wire_cst_list_prim_u_8_strict,
14361        external_input_parsers: *mut wire_cst_list_external_input_parser,
14362        use_default_external_input_parsers: bool,
14363        onchain_fee_rate_leeway_sat: *mut u64,
14364        asset_metadata: *mut wire_cst_list_asset_metadata,
14365        sideswap_api_key: *mut wire_cst_list_prim_u_8_strict,
14366    }
14367    #[repr(C)]
14368    #[derive(Clone, Copy)]
14369    pub struct wire_cst_connect_request {
14370        config: wire_cst_config,
14371        mnemonic: *mut wire_cst_list_prim_u_8_strict,
14372        passphrase: *mut wire_cst_list_prim_u_8_strict,
14373        seed: *mut wire_cst_list_prim_u_8_strict,
14374    }
14375    #[repr(C)]
14376    #[derive(Clone, Copy)]
14377    pub struct wire_cst_create_bolt_12_invoice_request {
14378        offer: *mut wire_cst_list_prim_u_8_strict,
14379        invoice_request: *mut wire_cst_list_prim_u_8_strict,
14380    }
14381    #[repr(C)]
14382    #[derive(Clone, Copy)]
14383    pub struct wire_cst_create_bolt_12_invoice_response {
14384        invoice: *mut wire_cst_list_prim_u_8_strict,
14385    }
14386    #[repr(C)]
14387    #[derive(Clone, Copy)]
14388    pub struct wire_cst_currency_info {
14389        name: *mut wire_cst_list_prim_u_8_strict,
14390        fraction_size: u32,
14391        spacing: *mut u32,
14392        symbol: *mut wire_cst_symbol,
14393        uniq_symbol: *mut wire_cst_symbol,
14394        localized_name: *mut wire_cst_list_localized_name,
14395        locale_overrides: *mut wire_cst_list_locale_overrides,
14396    }
14397    #[repr(C)]
14398    #[derive(Clone, Copy)]
14399    pub struct wire_cst_external_input_parser {
14400        provider_id: *mut wire_cst_list_prim_u_8_strict,
14401        input_regex: *mut wire_cst_list_prim_u_8_strict,
14402        parser_url: *mut wire_cst_list_prim_u_8_strict,
14403    }
14404    #[repr(C)]
14405    #[derive(Clone, Copy)]
14406    pub struct wire_cst_fetch_payment_proposed_fees_request {
14407        swap_id: *mut wire_cst_list_prim_u_8_strict,
14408    }
14409    #[repr(C)]
14410    #[derive(Clone, Copy)]
14411    pub struct wire_cst_fetch_payment_proposed_fees_response {
14412        swap_id: *mut wire_cst_list_prim_u_8_strict,
14413        fees_sat: u64,
14414        payer_amount_sat: u64,
14415        receiver_amount_sat: u64,
14416    }
14417    #[repr(C)]
14418    #[derive(Clone, Copy)]
14419    pub struct wire_cst_fiat_currency {
14420        id: *mut wire_cst_list_prim_u_8_strict,
14421        info: wire_cst_currency_info,
14422    }
14423    #[repr(C)]
14424    #[derive(Clone, Copy)]
14425    pub struct wire_cst_get_info_response {
14426        wallet_info: wire_cst_wallet_info,
14427        blockchain_info: wire_cst_blockchain_info,
14428    }
14429    #[repr(C)]
14430    #[derive(Clone, Copy)]
14431    pub struct wire_cst_get_payment_request {
14432        tag: i32,
14433        kind: GetPaymentRequestKind,
14434    }
14435    #[repr(C)]
14436    #[derive(Clone, Copy)]
14437    pub union GetPaymentRequestKind {
14438        PaymentHash: wire_cst_GetPaymentRequest_PaymentHash,
14439        SwapId: wire_cst_GetPaymentRequest_SwapId,
14440        nil__: (),
14441    }
14442    #[repr(C)]
14443    #[derive(Clone, Copy)]
14444    pub struct wire_cst_GetPaymentRequest_PaymentHash {
14445        payment_hash: *mut wire_cst_list_prim_u_8_strict,
14446    }
14447    #[repr(C)]
14448    #[derive(Clone, Copy)]
14449    pub struct wire_cst_GetPaymentRequest_SwapId {
14450        swap_id: *mut wire_cst_list_prim_u_8_strict,
14451    }
14452    #[repr(C)]
14453    #[derive(Clone, Copy)]
14454    pub struct wire_cst_input_type {
14455        tag: i32,
14456        kind: InputTypeKind,
14457    }
14458    #[repr(C)]
14459    #[derive(Clone, Copy)]
14460    pub union InputTypeKind {
14461        BitcoinAddress: wire_cst_InputType_BitcoinAddress,
14462        LiquidAddress: wire_cst_InputType_LiquidAddress,
14463        Bolt11: wire_cst_InputType_Bolt11,
14464        Bolt12Offer: wire_cst_InputType_Bolt12Offer,
14465        NodeId: wire_cst_InputType_NodeId,
14466        Url: wire_cst_InputType_Url,
14467        LnUrlPay: wire_cst_InputType_LnUrlPay,
14468        LnUrlWithdraw: wire_cst_InputType_LnUrlWithdraw,
14469        LnUrlAuth: wire_cst_InputType_LnUrlAuth,
14470        LnUrlError: wire_cst_InputType_LnUrlError,
14471        nil__: (),
14472    }
14473    #[repr(C)]
14474    #[derive(Clone, Copy)]
14475    pub struct wire_cst_InputType_BitcoinAddress {
14476        address: *mut wire_cst_bitcoin_address_data,
14477    }
14478    #[repr(C)]
14479    #[derive(Clone, Copy)]
14480    pub struct wire_cst_InputType_LiquidAddress {
14481        address: *mut wire_cst_liquid_address_data,
14482    }
14483    #[repr(C)]
14484    #[derive(Clone, Copy)]
14485    pub struct wire_cst_InputType_Bolt11 {
14486        invoice: *mut wire_cst_ln_invoice,
14487    }
14488    #[repr(C)]
14489    #[derive(Clone, Copy)]
14490    pub struct wire_cst_InputType_Bolt12Offer {
14491        offer: *mut wire_cst_ln_offer,
14492        bip353_address: *mut wire_cst_list_prim_u_8_strict,
14493    }
14494    #[repr(C)]
14495    #[derive(Clone, Copy)]
14496    pub struct wire_cst_InputType_NodeId {
14497        node_id: *mut wire_cst_list_prim_u_8_strict,
14498    }
14499    #[repr(C)]
14500    #[derive(Clone, Copy)]
14501    pub struct wire_cst_InputType_Url {
14502        url: *mut wire_cst_list_prim_u_8_strict,
14503    }
14504    #[repr(C)]
14505    #[derive(Clone, Copy)]
14506    pub struct wire_cst_InputType_LnUrlPay {
14507        data: *mut wire_cst_ln_url_pay_request_data,
14508        bip353_address: *mut wire_cst_list_prim_u_8_strict,
14509    }
14510    #[repr(C)]
14511    #[derive(Clone, Copy)]
14512    pub struct wire_cst_InputType_LnUrlWithdraw {
14513        data: *mut wire_cst_ln_url_withdraw_request_data,
14514    }
14515    #[repr(C)]
14516    #[derive(Clone, Copy)]
14517    pub struct wire_cst_InputType_LnUrlAuth {
14518        data: *mut wire_cst_ln_url_auth_request_data,
14519    }
14520    #[repr(C)]
14521    #[derive(Clone, Copy)]
14522    pub struct wire_cst_InputType_LnUrlError {
14523        data: *mut wire_cst_ln_url_error_data,
14524    }
14525    #[repr(C)]
14526    #[derive(Clone, Copy)]
14527    pub struct wire_cst_lightning_payment_limits_response {
14528        send: wire_cst_limits,
14529        receive: wire_cst_limits,
14530    }
14531    #[repr(C)]
14532    #[derive(Clone, Copy)]
14533    pub struct wire_cst_limits {
14534        min_sat: u64,
14535        max_sat: u64,
14536        max_zero_conf_sat: u64,
14537    }
14538    #[repr(C)]
14539    #[derive(Clone, Copy)]
14540    pub struct wire_cst_liquid_address_data {
14541        address: *mut wire_cst_list_prim_u_8_strict,
14542        network: i32,
14543        asset_id: *mut wire_cst_list_prim_u_8_strict,
14544        amount: *mut f64,
14545        amount_sat: *mut u64,
14546        label: *mut wire_cst_list_prim_u_8_strict,
14547        message: *mut wire_cst_list_prim_u_8_strict,
14548    }
14549    #[repr(C)]
14550    #[derive(Clone, Copy)]
14551    pub struct wire_cst_list_String {
14552        ptr: *mut *mut wire_cst_list_prim_u_8_strict,
14553        len: i32,
14554    }
14555    #[repr(C)]
14556    #[derive(Clone, Copy)]
14557    pub struct wire_cst_list_asset_balance {
14558        ptr: *mut wire_cst_asset_balance,
14559        len: i32,
14560    }
14561    #[repr(C)]
14562    #[derive(Clone, Copy)]
14563    pub struct wire_cst_list_asset_metadata {
14564        ptr: *mut wire_cst_asset_metadata,
14565        len: i32,
14566    }
14567    #[repr(C)]
14568    #[derive(Clone, Copy)]
14569    pub struct wire_cst_list_external_input_parser {
14570        ptr: *mut wire_cst_external_input_parser,
14571        len: i32,
14572    }
14573    #[repr(C)]
14574    #[derive(Clone, Copy)]
14575    pub struct wire_cst_list_fiat_currency {
14576        ptr: *mut wire_cst_fiat_currency,
14577        len: i32,
14578    }
14579    #[repr(C)]
14580    #[derive(Clone, Copy)]
14581    pub struct wire_cst_list_ln_offer_blinded_path {
14582        ptr: *mut wire_cst_ln_offer_blinded_path,
14583        len: i32,
14584    }
14585    #[repr(C)]
14586    #[derive(Clone, Copy)]
14587    pub struct wire_cst_list_locale_overrides {
14588        ptr: *mut wire_cst_locale_overrides,
14589        len: i32,
14590    }
14591    #[repr(C)]
14592    #[derive(Clone, Copy)]
14593    pub struct wire_cst_list_localized_name {
14594        ptr: *mut wire_cst_localized_name,
14595        len: i32,
14596    }
14597    #[repr(C)]
14598    #[derive(Clone, Copy)]
14599    pub struct wire_cst_list_payment {
14600        ptr: *mut wire_cst_payment,
14601        len: i32,
14602    }
14603    #[repr(C)]
14604    #[derive(Clone, Copy)]
14605    pub struct wire_cst_list_payment_details {
14606        tag: i32,
14607        kind: ListPaymentDetailsKind,
14608    }
14609    #[repr(C)]
14610    #[derive(Clone, Copy)]
14611    pub union ListPaymentDetailsKind {
14612        Liquid: wire_cst_ListPaymentDetails_Liquid,
14613        Bitcoin: wire_cst_ListPaymentDetails_Bitcoin,
14614        nil__: (),
14615    }
14616    #[repr(C)]
14617    #[derive(Clone, Copy)]
14618    pub struct wire_cst_ListPaymentDetails_Liquid {
14619        asset_id: *mut wire_cst_list_prim_u_8_strict,
14620        destination: *mut wire_cst_list_prim_u_8_strict,
14621    }
14622    #[repr(C)]
14623    #[derive(Clone, Copy)]
14624    pub struct wire_cst_ListPaymentDetails_Bitcoin {
14625        address: *mut wire_cst_list_prim_u_8_strict,
14626    }
14627    #[repr(C)]
14628    #[derive(Clone, Copy)]
14629    pub struct wire_cst_list_payment_state {
14630        ptr: *mut i32,
14631        len: i32,
14632    }
14633    #[repr(C)]
14634    #[derive(Clone, Copy)]
14635    pub struct wire_cst_list_payment_type {
14636        ptr: *mut i32,
14637        len: i32,
14638    }
14639    #[repr(C)]
14640    #[derive(Clone, Copy)]
14641    pub struct wire_cst_list_payments_request {
14642        filters: *mut wire_cst_list_payment_type,
14643        states: *mut wire_cst_list_payment_state,
14644        from_timestamp: *mut i64,
14645        to_timestamp: *mut i64,
14646        offset: *mut u32,
14647        limit: *mut u32,
14648        details: *mut wire_cst_list_payment_details,
14649        sort_ascending: *mut bool,
14650    }
14651    #[repr(C)]
14652    #[derive(Clone, Copy)]
14653    pub struct wire_cst_list_prim_u_8_strict {
14654        ptr: *mut u8,
14655        len: i32,
14656    }
14657    #[repr(C)]
14658    #[derive(Clone, Copy)]
14659    pub struct wire_cst_list_rate {
14660        ptr: *mut wire_cst_rate,
14661        len: i32,
14662    }
14663    #[repr(C)]
14664    #[derive(Clone, Copy)]
14665    pub struct wire_cst_list_refundable_swap {
14666        ptr: *mut wire_cst_refundable_swap,
14667        len: i32,
14668    }
14669    #[repr(C)]
14670    #[derive(Clone, Copy)]
14671    pub struct wire_cst_list_route_hint {
14672        ptr: *mut wire_cst_route_hint,
14673        len: i32,
14674    }
14675    #[repr(C)]
14676    #[derive(Clone, Copy)]
14677    pub struct wire_cst_list_route_hint_hop {
14678        ptr: *mut wire_cst_route_hint_hop,
14679        len: i32,
14680    }
14681    #[repr(C)]
14682    #[derive(Clone, Copy)]
14683    pub struct wire_cst_ln_invoice {
14684        bolt11: *mut wire_cst_list_prim_u_8_strict,
14685        network: i32,
14686        payee_pubkey: *mut wire_cst_list_prim_u_8_strict,
14687        payment_hash: *mut wire_cst_list_prim_u_8_strict,
14688        description: *mut wire_cst_list_prim_u_8_strict,
14689        description_hash: *mut wire_cst_list_prim_u_8_strict,
14690        amount_msat: *mut u64,
14691        timestamp: u64,
14692        expiry: u64,
14693        routing_hints: *mut wire_cst_list_route_hint,
14694        payment_secret: *mut wire_cst_list_prim_u_8_strict,
14695        min_final_cltv_expiry_delta: u64,
14696    }
14697    #[repr(C)]
14698    #[derive(Clone, Copy)]
14699    pub struct wire_cst_ln_offer {
14700        offer: *mut wire_cst_list_prim_u_8_strict,
14701        chains: *mut wire_cst_list_String,
14702        min_amount: *mut wire_cst_amount,
14703        description: *mut wire_cst_list_prim_u_8_strict,
14704        absolute_expiry: *mut u64,
14705        issuer: *mut wire_cst_list_prim_u_8_strict,
14706        signing_pubkey: *mut wire_cst_list_prim_u_8_strict,
14707        paths: *mut wire_cst_list_ln_offer_blinded_path,
14708    }
14709    #[repr(C)]
14710    #[derive(Clone, Copy)]
14711    pub struct wire_cst_ln_offer_blinded_path {
14712        blinded_hops: *mut wire_cst_list_String,
14713    }
14714    #[repr(C)]
14715    #[derive(Clone, Copy)]
14716    pub struct wire_cst_ln_url_auth_error {
14717        tag: i32,
14718        kind: LnUrlAuthErrorKind,
14719    }
14720    #[repr(C)]
14721    #[derive(Clone, Copy)]
14722    pub union LnUrlAuthErrorKind {
14723        Generic: wire_cst_LnUrlAuthError_Generic,
14724        InvalidUri: wire_cst_LnUrlAuthError_InvalidUri,
14725        ServiceConnectivity: wire_cst_LnUrlAuthError_ServiceConnectivity,
14726        nil__: (),
14727    }
14728    #[repr(C)]
14729    #[derive(Clone, Copy)]
14730    pub struct wire_cst_LnUrlAuthError_Generic {
14731        err: *mut wire_cst_list_prim_u_8_strict,
14732    }
14733    #[repr(C)]
14734    #[derive(Clone, Copy)]
14735    pub struct wire_cst_LnUrlAuthError_InvalidUri {
14736        err: *mut wire_cst_list_prim_u_8_strict,
14737    }
14738    #[repr(C)]
14739    #[derive(Clone, Copy)]
14740    pub struct wire_cst_LnUrlAuthError_ServiceConnectivity {
14741        err: *mut wire_cst_list_prim_u_8_strict,
14742    }
14743    #[repr(C)]
14744    #[derive(Clone, Copy)]
14745    pub struct wire_cst_ln_url_auth_request_data {
14746        k1: *mut wire_cst_list_prim_u_8_strict,
14747        action: *mut wire_cst_list_prim_u_8_strict,
14748        domain: *mut wire_cst_list_prim_u_8_strict,
14749        url: *mut wire_cst_list_prim_u_8_strict,
14750    }
14751    #[repr(C)]
14752    #[derive(Clone, Copy)]
14753    pub struct wire_cst_ln_url_callback_status {
14754        tag: i32,
14755        kind: LnUrlCallbackStatusKind,
14756    }
14757    #[repr(C)]
14758    #[derive(Clone, Copy)]
14759    pub union LnUrlCallbackStatusKind {
14760        ErrorStatus: wire_cst_LnUrlCallbackStatus_ErrorStatus,
14761        nil__: (),
14762    }
14763    #[repr(C)]
14764    #[derive(Clone, Copy)]
14765    pub struct wire_cst_LnUrlCallbackStatus_ErrorStatus {
14766        data: *mut wire_cst_ln_url_error_data,
14767    }
14768    #[repr(C)]
14769    #[derive(Clone, Copy)]
14770    pub struct wire_cst_ln_url_error_data {
14771        reason: *mut wire_cst_list_prim_u_8_strict,
14772    }
14773    #[repr(C)]
14774    #[derive(Clone, Copy)]
14775    pub struct wire_cst_ln_url_info {
14776        ln_address: *mut wire_cst_list_prim_u_8_strict,
14777        lnurl_pay_comment: *mut wire_cst_list_prim_u_8_strict,
14778        lnurl_pay_domain: *mut wire_cst_list_prim_u_8_strict,
14779        lnurl_pay_metadata: *mut wire_cst_list_prim_u_8_strict,
14780        lnurl_pay_success_action: *mut wire_cst_success_action_processed,
14781        lnurl_pay_unprocessed_success_action: *mut wire_cst_success_action,
14782        lnurl_withdraw_endpoint: *mut wire_cst_list_prim_u_8_strict,
14783    }
14784    #[repr(C)]
14785    #[derive(Clone, Copy)]
14786    pub struct wire_cst_ln_url_pay_error {
14787        tag: i32,
14788        kind: LnUrlPayErrorKind,
14789    }
14790    #[repr(C)]
14791    #[derive(Clone, Copy)]
14792    pub union LnUrlPayErrorKind {
14793        Generic: wire_cst_LnUrlPayError_Generic,
14794        InsufficientBalance: wire_cst_LnUrlPayError_InsufficientBalance,
14795        InvalidAmount: wire_cst_LnUrlPayError_InvalidAmount,
14796        InvalidInvoice: wire_cst_LnUrlPayError_InvalidInvoice,
14797        InvalidNetwork: wire_cst_LnUrlPayError_InvalidNetwork,
14798        InvalidUri: wire_cst_LnUrlPayError_InvalidUri,
14799        InvoiceExpired: wire_cst_LnUrlPayError_InvoiceExpired,
14800        PaymentFailed: wire_cst_LnUrlPayError_PaymentFailed,
14801        PaymentTimeout: wire_cst_LnUrlPayError_PaymentTimeout,
14802        RouteNotFound: wire_cst_LnUrlPayError_RouteNotFound,
14803        RouteTooExpensive: wire_cst_LnUrlPayError_RouteTooExpensive,
14804        ServiceConnectivity: wire_cst_LnUrlPayError_ServiceConnectivity,
14805        nil__: (),
14806    }
14807    #[repr(C)]
14808    #[derive(Clone, Copy)]
14809    pub struct wire_cst_LnUrlPayError_Generic {
14810        err: *mut wire_cst_list_prim_u_8_strict,
14811    }
14812    #[repr(C)]
14813    #[derive(Clone, Copy)]
14814    pub struct wire_cst_LnUrlPayError_InsufficientBalance {
14815        err: *mut wire_cst_list_prim_u_8_strict,
14816    }
14817    #[repr(C)]
14818    #[derive(Clone, Copy)]
14819    pub struct wire_cst_LnUrlPayError_InvalidAmount {
14820        err: *mut wire_cst_list_prim_u_8_strict,
14821    }
14822    #[repr(C)]
14823    #[derive(Clone, Copy)]
14824    pub struct wire_cst_LnUrlPayError_InvalidInvoice {
14825        err: *mut wire_cst_list_prim_u_8_strict,
14826    }
14827    #[repr(C)]
14828    #[derive(Clone, Copy)]
14829    pub struct wire_cst_LnUrlPayError_InvalidNetwork {
14830        err: *mut wire_cst_list_prim_u_8_strict,
14831    }
14832    #[repr(C)]
14833    #[derive(Clone, Copy)]
14834    pub struct wire_cst_LnUrlPayError_InvalidUri {
14835        err: *mut wire_cst_list_prim_u_8_strict,
14836    }
14837    #[repr(C)]
14838    #[derive(Clone, Copy)]
14839    pub struct wire_cst_LnUrlPayError_InvoiceExpired {
14840        err: *mut wire_cst_list_prim_u_8_strict,
14841    }
14842    #[repr(C)]
14843    #[derive(Clone, Copy)]
14844    pub struct wire_cst_LnUrlPayError_PaymentFailed {
14845        err: *mut wire_cst_list_prim_u_8_strict,
14846    }
14847    #[repr(C)]
14848    #[derive(Clone, Copy)]
14849    pub struct wire_cst_LnUrlPayError_PaymentTimeout {
14850        err: *mut wire_cst_list_prim_u_8_strict,
14851    }
14852    #[repr(C)]
14853    #[derive(Clone, Copy)]
14854    pub struct wire_cst_LnUrlPayError_RouteNotFound {
14855        err: *mut wire_cst_list_prim_u_8_strict,
14856    }
14857    #[repr(C)]
14858    #[derive(Clone, Copy)]
14859    pub struct wire_cst_LnUrlPayError_RouteTooExpensive {
14860        err: *mut wire_cst_list_prim_u_8_strict,
14861    }
14862    #[repr(C)]
14863    #[derive(Clone, Copy)]
14864    pub struct wire_cst_LnUrlPayError_ServiceConnectivity {
14865        err: *mut wire_cst_list_prim_u_8_strict,
14866    }
14867    #[repr(C)]
14868    #[derive(Clone, Copy)]
14869    pub struct wire_cst_ln_url_pay_error_data {
14870        payment_hash: *mut wire_cst_list_prim_u_8_strict,
14871        reason: *mut wire_cst_list_prim_u_8_strict,
14872    }
14873    #[repr(C)]
14874    #[derive(Clone, Copy)]
14875    pub struct wire_cst_ln_url_pay_request {
14876        prepare_response: wire_cst_prepare_ln_url_pay_response,
14877    }
14878    #[repr(C)]
14879    #[derive(Clone, Copy)]
14880    pub struct wire_cst_ln_url_pay_request_data {
14881        callback: *mut wire_cst_list_prim_u_8_strict,
14882        min_sendable: u64,
14883        max_sendable: u64,
14884        metadata_str: *mut wire_cst_list_prim_u_8_strict,
14885        comment_allowed: u16,
14886        domain: *mut wire_cst_list_prim_u_8_strict,
14887        allows_nostr: bool,
14888        nostr_pubkey: *mut wire_cst_list_prim_u_8_strict,
14889        ln_address: *mut wire_cst_list_prim_u_8_strict,
14890    }
14891    #[repr(C)]
14892    #[derive(Clone, Copy)]
14893    pub struct wire_cst_ln_url_pay_result {
14894        tag: i32,
14895        kind: LnUrlPayResultKind,
14896    }
14897    #[repr(C)]
14898    #[derive(Clone, Copy)]
14899    pub union LnUrlPayResultKind {
14900        EndpointSuccess: wire_cst_LnUrlPayResult_EndpointSuccess,
14901        EndpointError: wire_cst_LnUrlPayResult_EndpointError,
14902        PayError: wire_cst_LnUrlPayResult_PayError,
14903        nil__: (),
14904    }
14905    #[repr(C)]
14906    #[derive(Clone, Copy)]
14907    pub struct wire_cst_LnUrlPayResult_EndpointSuccess {
14908        data: *mut wire_cst_ln_url_pay_success_data,
14909    }
14910    #[repr(C)]
14911    #[derive(Clone, Copy)]
14912    pub struct wire_cst_LnUrlPayResult_EndpointError {
14913        data: *mut wire_cst_ln_url_error_data,
14914    }
14915    #[repr(C)]
14916    #[derive(Clone, Copy)]
14917    pub struct wire_cst_LnUrlPayResult_PayError {
14918        data: *mut wire_cst_ln_url_pay_error_data,
14919    }
14920    #[repr(C)]
14921    #[derive(Clone, Copy)]
14922    pub struct wire_cst_ln_url_pay_success_data {
14923        payment: wire_cst_payment,
14924        success_action: *mut wire_cst_success_action_processed,
14925    }
14926    #[repr(C)]
14927    #[derive(Clone, Copy)]
14928    pub struct wire_cst_ln_url_withdraw_error {
14929        tag: i32,
14930        kind: LnUrlWithdrawErrorKind,
14931    }
14932    #[repr(C)]
14933    #[derive(Clone, Copy)]
14934    pub union LnUrlWithdrawErrorKind {
14935        Generic: wire_cst_LnUrlWithdrawError_Generic,
14936        InvalidAmount: wire_cst_LnUrlWithdrawError_InvalidAmount,
14937        InvalidInvoice: wire_cst_LnUrlWithdrawError_InvalidInvoice,
14938        InvalidUri: wire_cst_LnUrlWithdrawError_InvalidUri,
14939        InvoiceNoRoutingHints: wire_cst_LnUrlWithdrawError_InvoiceNoRoutingHints,
14940        ServiceConnectivity: wire_cst_LnUrlWithdrawError_ServiceConnectivity,
14941        nil__: (),
14942    }
14943    #[repr(C)]
14944    #[derive(Clone, Copy)]
14945    pub struct wire_cst_LnUrlWithdrawError_Generic {
14946        err: *mut wire_cst_list_prim_u_8_strict,
14947    }
14948    #[repr(C)]
14949    #[derive(Clone, Copy)]
14950    pub struct wire_cst_LnUrlWithdrawError_InvalidAmount {
14951        err: *mut wire_cst_list_prim_u_8_strict,
14952    }
14953    #[repr(C)]
14954    #[derive(Clone, Copy)]
14955    pub struct wire_cst_LnUrlWithdrawError_InvalidInvoice {
14956        err: *mut wire_cst_list_prim_u_8_strict,
14957    }
14958    #[repr(C)]
14959    #[derive(Clone, Copy)]
14960    pub struct wire_cst_LnUrlWithdrawError_InvalidUri {
14961        err: *mut wire_cst_list_prim_u_8_strict,
14962    }
14963    #[repr(C)]
14964    #[derive(Clone, Copy)]
14965    pub struct wire_cst_LnUrlWithdrawError_InvoiceNoRoutingHints {
14966        err: *mut wire_cst_list_prim_u_8_strict,
14967    }
14968    #[repr(C)]
14969    #[derive(Clone, Copy)]
14970    pub struct wire_cst_LnUrlWithdrawError_ServiceConnectivity {
14971        err: *mut wire_cst_list_prim_u_8_strict,
14972    }
14973    #[repr(C)]
14974    #[derive(Clone, Copy)]
14975    pub struct wire_cst_ln_url_withdraw_request {
14976        data: wire_cst_ln_url_withdraw_request_data,
14977        amount_msat: u64,
14978        description: *mut wire_cst_list_prim_u_8_strict,
14979    }
14980    #[repr(C)]
14981    #[derive(Clone, Copy)]
14982    pub struct wire_cst_ln_url_withdraw_request_data {
14983        callback: *mut wire_cst_list_prim_u_8_strict,
14984        k1: *mut wire_cst_list_prim_u_8_strict,
14985        default_description: *mut wire_cst_list_prim_u_8_strict,
14986        min_withdrawable: u64,
14987        max_withdrawable: u64,
14988    }
14989    #[repr(C)]
14990    #[derive(Clone, Copy)]
14991    pub struct wire_cst_ln_url_withdraw_result {
14992        tag: i32,
14993        kind: LnUrlWithdrawResultKind,
14994    }
14995    #[repr(C)]
14996    #[derive(Clone, Copy)]
14997    pub union LnUrlWithdrawResultKind {
14998        Ok: wire_cst_LnUrlWithdrawResult_Ok,
14999        Timeout: wire_cst_LnUrlWithdrawResult_Timeout,
15000        ErrorStatus: wire_cst_LnUrlWithdrawResult_ErrorStatus,
15001        nil__: (),
15002    }
15003    #[repr(C)]
15004    #[derive(Clone, Copy)]
15005    pub struct wire_cst_LnUrlWithdrawResult_Ok {
15006        data: *mut wire_cst_ln_url_withdraw_success_data,
15007    }
15008    #[repr(C)]
15009    #[derive(Clone, Copy)]
15010    pub struct wire_cst_LnUrlWithdrawResult_Timeout {
15011        data: *mut wire_cst_ln_url_withdraw_success_data,
15012    }
15013    #[repr(C)]
15014    #[derive(Clone, Copy)]
15015    pub struct wire_cst_LnUrlWithdrawResult_ErrorStatus {
15016        data: *mut wire_cst_ln_url_error_data,
15017    }
15018    #[repr(C)]
15019    #[derive(Clone, Copy)]
15020    pub struct wire_cst_ln_url_withdraw_success_data {
15021        invoice: wire_cst_ln_invoice,
15022    }
15023    #[repr(C)]
15024    #[derive(Clone, Copy)]
15025    pub struct wire_cst_locale_overrides {
15026        locale: *mut wire_cst_list_prim_u_8_strict,
15027        spacing: *mut u32,
15028        symbol: wire_cst_symbol,
15029    }
15030    #[repr(C)]
15031    #[derive(Clone, Copy)]
15032    pub struct wire_cst_localized_name {
15033        locale: *mut wire_cst_list_prim_u_8_strict,
15034        name: *mut wire_cst_list_prim_u_8_strict,
15035    }
15036    #[repr(C)]
15037    #[derive(Clone, Copy)]
15038    pub struct wire_cst_log_entry {
15039        line: *mut wire_cst_list_prim_u_8_strict,
15040        level: *mut wire_cst_list_prim_u_8_strict,
15041    }
15042    #[repr(C)]
15043    #[derive(Clone, Copy)]
15044    pub struct wire_cst_message_success_action_data {
15045        message: *mut wire_cst_list_prim_u_8_strict,
15046    }
15047    #[repr(C)]
15048    #[derive(Clone, Copy)]
15049    pub struct wire_cst_onchain_payment_limits_response {
15050        send: wire_cst_limits,
15051        receive: wire_cst_limits,
15052    }
15053    #[repr(C)]
15054    #[derive(Clone, Copy)]
15055    pub struct wire_cst_pay_amount {
15056        tag: i32,
15057        kind: PayAmountKind,
15058    }
15059    #[repr(C)]
15060    #[derive(Clone, Copy)]
15061    pub union PayAmountKind {
15062        Bitcoin: wire_cst_PayAmount_Bitcoin,
15063        Asset: wire_cst_PayAmount_Asset,
15064        nil__: (),
15065    }
15066    #[repr(C)]
15067    #[derive(Clone, Copy)]
15068    pub struct wire_cst_PayAmount_Bitcoin {
15069        receiver_amount_sat: u64,
15070    }
15071    #[repr(C)]
15072    #[derive(Clone, Copy)]
15073    pub struct wire_cst_PayAmount_Asset {
15074        asset_id: *mut wire_cst_list_prim_u_8_strict,
15075        receiver_amount: f64,
15076        estimate_asset_fees: *mut bool,
15077        pay_with_bitcoin: *mut bool,
15078    }
15079    #[repr(C)]
15080    #[derive(Clone, Copy)]
15081    pub struct wire_cst_pay_onchain_request {
15082        address: *mut wire_cst_list_prim_u_8_strict,
15083        prepare_response: wire_cst_prepare_pay_onchain_response,
15084    }
15085    #[repr(C)]
15086    #[derive(Clone, Copy)]
15087    pub struct wire_cst_payment {
15088        destination: *mut wire_cst_list_prim_u_8_strict,
15089        tx_id: *mut wire_cst_list_prim_u_8_strict,
15090        unblinding_data: *mut wire_cst_list_prim_u_8_strict,
15091        timestamp: u32,
15092        amount_sat: u64,
15093        fees_sat: u64,
15094        swapper_fees_sat: *mut u64,
15095        payment_type: i32,
15096        status: i32,
15097        details: wire_cst_payment_details,
15098    }
15099    #[repr(C)]
15100    #[derive(Clone, Copy)]
15101    pub struct wire_cst_payment_details {
15102        tag: i32,
15103        kind: PaymentDetailsKind,
15104    }
15105    #[repr(C)]
15106    #[derive(Clone, Copy)]
15107    pub union PaymentDetailsKind {
15108        Lightning: wire_cst_PaymentDetails_Lightning,
15109        Liquid: wire_cst_PaymentDetails_Liquid,
15110        Bitcoin: wire_cst_PaymentDetails_Bitcoin,
15111        nil__: (),
15112    }
15113    #[repr(C)]
15114    #[derive(Clone, Copy)]
15115    pub struct wire_cst_PaymentDetails_Lightning {
15116        swap_id: *mut wire_cst_list_prim_u_8_strict,
15117        description: *mut wire_cst_list_prim_u_8_strict,
15118        liquid_expiration_blockheight: u32,
15119        preimage: *mut wire_cst_list_prim_u_8_strict,
15120        invoice: *mut wire_cst_list_prim_u_8_strict,
15121        bolt12_offer: *mut wire_cst_list_prim_u_8_strict,
15122        payment_hash: *mut wire_cst_list_prim_u_8_strict,
15123        destination_pubkey: *mut wire_cst_list_prim_u_8_strict,
15124        lnurl_info: *mut wire_cst_ln_url_info,
15125        bip353_address: *mut wire_cst_list_prim_u_8_strict,
15126        payer_note: *mut wire_cst_list_prim_u_8_strict,
15127        claim_tx_id: *mut wire_cst_list_prim_u_8_strict,
15128        refund_tx_id: *mut wire_cst_list_prim_u_8_strict,
15129        refund_tx_amount_sat: *mut u64,
15130    }
15131    #[repr(C)]
15132    #[derive(Clone, Copy)]
15133    pub struct wire_cst_PaymentDetails_Liquid {
15134        destination: *mut wire_cst_list_prim_u_8_strict,
15135        description: *mut wire_cst_list_prim_u_8_strict,
15136        asset_id: *mut wire_cst_list_prim_u_8_strict,
15137        asset_info: *mut wire_cst_asset_info,
15138        lnurl_info: *mut wire_cst_ln_url_info,
15139        bip353_address: *mut wire_cst_list_prim_u_8_strict,
15140        payer_note: *mut wire_cst_list_prim_u_8_strict,
15141    }
15142    #[repr(C)]
15143    #[derive(Clone, Copy)]
15144    pub struct wire_cst_PaymentDetails_Bitcoin {
15145        swap_id: *mut wire_cst_list_prim_u_8_strict,
15146        bitcoin_address: *mut wire_cst_list_prim_u_8_strict,
15147        description: *mut wire_cst_list_prim_u_8_strict,
15148        auto_accepted_fees: bool,
15149        liquid_expiration_blockheight: *mut u32,
15150        bitcoin_expiration_blockheight: *mut u32,
15151        lockup_tx_id: *mut wire_cst_list_prim_u_8_strict,
15152        claim_tx_id: *mut wire_cst_list_prim_u_8_strict,
15153        refund_tx_id: *mut wire_cst_list_prim_u_8_strict,
15154        refund_tx_amount_sat: *mut u64,
15155    }
15156    #[repr(C)]
15157    #[derive(Clone, Copy)]
15158    pub struct wire_cst_payment_error {
15159        tag: i32,
15160        kind: PaymentErrorKind,
15161    }
15162    #[repr(C)]
15163    #[derive(Clone, Copy)]
15164    pub union PaymentErrorKind {
15165        AmountOutOfRange: wire_cst_PaymentError_AmountOutOfRange,
15166        AmountMissing: wire_cst_PaymentError_AmountMissing,
15167        AssetError: wire_cst_PaymentError_AssetError,
15168        InvalidNetwork: wire_cst_PaymentError_InvalidNetwork,
15169        Generic: wire_cst_PaymentError_Generic,
15170        InvalidDescription: wire_cst_PaymentError_InvalidDescription,
15171        InvalidInvoice: wire_cst_PaymentError_InvalidInvoice,
15172        ReceiveError: wire_cst_PaymentError_ReceiveError,
15173        Refunded: wire_cst_PaymentError_Refunded,
15174        SendError: wire_cst_PaymentError_SendError,
15175        SignerError: wire_cst_PaymentError_SignerError,
15176        nil__: (),
15177    }
15178    #[repr(C)]
15179    #[derive(Clone, Copy)]
15180    pub struct wire_cst_PaymentError_AmountOutOfRange {
15181        min: u64,
15182        max: u64,
15183    }
15184    #[repr(C)]
15185    #[derive(Clone, Copy)]
15186    pub struct wire_cst_PaymentError_AmountMissing {
15187        err: *mut wire_cst_list_prim_u_8_strict,
15188    }
15189    #[repr(C)]
15190    #[derive(Clone, Copy)]
15191    pub struct wire_cst_PaymentError_AssetError {
15192        err: *mut wire_cst_list_prim_u_8_strict,
15193    }
15194    #[repr(C)]
15195    #[derive(Clone, Copy)]
15196    pub struct wire_cst_PaymentError_InvalidNetwork {
15197        err: *mut wire_cst_list_prim_u_8_strict,
15198    }
15199    #[repr(C)]
15200    #[derive(Clone, Copy)]
15201    pub struct wire_cst_PaymentError_Generic {
15202        err: *mut wire_cst_list_prim_u_8_strict,
15203    }
15204    #[repr(C)]
15205    #[derive(Clone, Copy)]
15206    pub struct wire_cst_PaymentError_InvalidDescription {
15207        err: *mut wire_cst_list_prim_u_8_strict,
15208    }
15209    #[repr(C)]
15210    #[derive(Clone, Copy)]
15211    pub struct wire_cst_PaymentError_InvalidInvoice {
15212        err: *mut wire_cst_list_prim_u_8_strict,
15213    }
15214    #[repr(C)]
15215    #[derive(Clone, Copy)]
15216    pub struct wire_cst_PaymentError_ReceiveError {
15217        err: *mut wire_cst_list_prim_u_8_strict,
15218    }
15219    #[repr(C)]
15220    #[derive(Clone, Copy)]
15221    pub struct wire_cst_PaymentError_Refunded {
15222        err: *mut wire_cst_list_prim_u_8_strict,
15223        refund_tx_id: *mut wire_cst_list_prim_u_8_strict,
15224    }
15225    #[repr(C)]
15226    #[derive(Clone, Copy)]
15227    pub struct wire_cst_PaymentError_SendError {
15228        err: *mut wire_cst_list_prim_u_8_strict,
15229    }
15230    #[repr(C)]
15231    #[derive(Clone, Copy)]
15232    pub struct wire_cst_PaymentError_SignerError {
15233        err: *mut wire_cst_list_prim_u_8_strict,
15234    }
15235    #[repr(C)]
15236    #[derive(Clone, Copy)]
15237    pub struct wire_cst_prepare_buy_bitcoin_request {
15238        provider: i32,
15239        amount_sat: u64,
15240    }
15241    #[repr(C)]
15242    #[derive(Clone, Copy)]
15243    pub struct wire_cst_prepare_buy_bitcoin_response {
15244        provider: i32,
15245        amount_sat: u64,
15246        fees_sat: u64,
15247    }
15248    #[repr(C)]
15249    #[derive(Clone, Copy)]
15250    pub struct wire_cst_prepare_ln_url_pay_request {
15251        data: wire_cst_ln_url_pay_request_data,
15252        amount: wire_cst_pay_amount,
15253        bip353_address: *mut wire_cst_list_prim_u_8_strict,
15254        comment: *mut wire_cst_list_prim_u_8_strict,
15255        validate_success_action_url: *mut bool,
15256    }
15257    #[repr(C)]
15258    #[derive(Clone, Copy)]
15259    pub struct wire_cst_prepare_ln_url_pay_response {
15260        destination: wire_cst_send_destination,
15261        fees_sat: u64,
15262        data: wire_cst_ln_url_pay_request_data,
15263        amount: wire_cst_pay_amount,
15264        comment: *mut wire_cst_list_prim_u_8_strict,
15265        success_action: *mut wire_cst_success_action,
15266    }
15267    #[repr(C)]
15268    #[derive(Clone, Copy)]
15269    pub struct wire_cst_prepare_pay_onchain_request {
15270        amount: wire_cst_pay_amount,
15271        fee_rate_sat_per_vbyte: *mut u32,
15272    }
15273    #[repr(C)]
15274    #[derive(Clone, Copy)]
15275    pub struct wire_cst_prepare_pay_onchain_response {
15276        receiver_amount_sat: u64,
15277        claim_fees_sat: u64,
15278        total_fees_sat: u64,
15279    }
15280    #[repr(C)]
15281    #[derive(Clone, Copy)]
15282    pub struct wire_cst_prepare_receive_request {
15283        payment_method: i32,
15284        amount: *mut wire_cst_receive_amount,
15285    }
15286    #[repr(C)]
15287    #[derive(Clone, Copy)]
15288    pub struct wire_cst_prepare_receive_response {
15289        payment_method: i32,
15290        fees_sat: u64,
15291        amount: *mut wire_cst_receive_amount,
15292        min_payer_amount_sat: *mut u64,
15293        max_payer_amount_sat: *mut u64,
15294        swapper_feerate: *mut f64,
15295    }
15296    #[repr(C)]
15297    #[derive(Clone, Copy)]
15298    pub struct wire_cst_prepare_refund_request {
15299        swap_address: *mut wire_cst_list_prim_u_8_strict,
15300        refund_address: *mut wire_cst_list_prim_u_8_strict,
15301        fee_rate_sat_per_vbyte: u32,
15302    }
15303    #[repr(C)]
15304    #[derive(Clone, Copy)]
15305    pub struct wire_cst_prepare_refund_response {
15306        tx_vsize: u32,
15307        tx_fee_sat: u64,
15308        last_refund_tx_id: *mut wire_cst_list_prim_u_8_strict,
15309    }
15310    #[repr(C)]
15311    #[derive(Clone, Copy)]
15312    pub struct wire_cst_prepare_send_request {
15313        destination: *mut wire_cst_list_prim_u_8_strict,
15314        amount: *mut wire_cst_pay_amount,
15315    }
15316    #[repr(C)]
15317    #[derive(Clone, Copy)]
15318    pub struct wire_cst_prepare_send_response {
15319        destination: wire_cst_send_destination,
15320        amount: *mut wire_cst_pay_amount,
15321        fees_sat: *mut u64,
15322        estimated_asset_fees: *mut f64,
15323    }
15324    #[repr(C)]
15325    #[derive(Clone, Copy)]
15326    pub struct wire_cst_rate {
15327        coin: *mut wire_cst_list_prim_u_8_strict,
15328        value: f64,
15329    }
15330    #[repr(C)]
15331    #[derive(Clone, Copy)]
15332    pub struct wire_cst_receive_amount {
15333        tag: i32,
15334        kind: ReceiveAmountKind,
15335    }
15336    #[repr(C)]
15337    #[derive(Clone, Copy)]
15338    pub union ReceiveAmountKind {
15339        Bitcoin: wire_cst_ReceiveAmount_Bitcoin,
15340        Asset: wire_cst_ReceiveAmount_Asset,
15341        nil__: (),
15342    }
15343    #[repr(C)]
15344    #[derive(Clone, Copy)]
15345    pub struct wire_cst_ReceiveAmount_Bitcoin {
15346        payer_amount_sat: u64,
15347    }
15348    #[repr(C)]
15349    #[derive(Clone, Copy)]
15350    pub struct wire_cst_ReceiveAmount_Asset {
15351        asset_id: *mut wire_cst_list_prim_u_8_strict,
15352        payer_amount: *mut f64,
15353    }
15354    #[repr(C)]
15355    #[derive(Clone, Copy)]
15356    pub struct wire_cst_receive_payment_request {
15357        prepare_response: wire_cst_prepare_receive_response,
15358        description: *mut wire_cst_list_prim_u_8_strict,
15359        use_description_hash: *mut bool,
15360        payer_note: *mut wire_cst_list_prim_u_8_strict,
15361    }
15362    #[repr(C)]
15363    #[derive(Clone, Copy)]
15364    pub struct wire_cst_receive_payment_response {
15365        destination: *mut wire_cst_list_prim_u_8_strict,
15366    }
15367    #[repr(C)]
15368    #[derive(Clone, Copy)]
15369    pub struct wire_cst_recommended_fees {
15370        fastest_fee: u64,
15371        half_hour_fee: u64,
15372        hour_fee: u64,
15373        economy_fee: u64,
15374        minimum_fee: u64,
15375    }
15376    #[repr(C)]
15377    #[derive(Clone, Copy)]
15378    pub struct wire_cst_refund_request {
15379        swap_address: *mut wire_cst_list_prim_u_8_strict,
15380        refund_address: *mut wire_cst_list_prim_u_8_strict,
15381        fee_rate_sat_per_vbyte: u32,
15382    }
15383    #[repr(C)]
15384    #[derive(Clone, Copy)]
15385    pub struct wire_cst_refund_response {
15386        refund_tx_id: *mut wire_cst_list_prim_u_8_strict,
15387    }
15388    #[repr(C)]
15389    #[derive(Clone, Copy)]
15390    pub struct wire_cst_refundable_swap {
15391        swap_address: *mut wire_cst_list_prim_u_8_strict,
15392        timestamp: u32,
15393        amount_sat: u64,
15394        last_refund_tx_id: *mut wire_cst_list_prim_u_8_strict,
15395    }
15396    #[repr(C)]
15397    #[derive(Clone, Copy)]
15398    pub struct wire_cst_restore_request {
15399        backup_path: *mut wire_cst_list_prim_u_8_strict,
15400    }
15401    #[repr(C)]
15402    #[derive(Clone, Copy)]
15403    pub struct wire_cst_route_hint {
15404        hops: *mut wire_cst_list_route_hint_hop,
15405    }
15406    #[repr(C)]
15407    #[derive(Clone, Copy)]
15408    pub struct wire_cst_route_hint_hop {
15409        src_node_id: *mut wire_cst_list_prim_u_8_strict,
15410        short_channel_id: *mut wire_cst_list_prim_u_8_strict,
15411        fees_base_msat: u32,
15412        fees_proportional_millionths: u32,
15413        cltv_expiry_delta: u64,
15414        htlc_minimum_msat: *mut u64,
15415        htlc_maximum_msat: *mut u64,
15416    }
15417    #[repr(C)]
15418    #[derive(Clone, Copy)]
15419    pub struct wire_cst_sdk_error {
15420        tag: i32,
15421        kind: SdkErrorKind,
15422    }
15423    #[repr(C)]
15424    #[derive(Clone, Copy)]
15425    pub union SdkErrorKind {
15426        Generic: wire_cst_SdkError_Generic,
15427        ServiceConnectivity: wire_cst_SdkError_ServiceConnectivity,
15428        nil__: (),
15429    }
15430    #[repr(C)]
15431    #[derive(Clone, Copy)]
15432    pub struct wire_cst_SdkError_Generic {
15433        err: *mut wire_cst_list_prim_u_8_strict,
15434    }
15435    #[repr(C)]
15436    #[derive(Clone, Copy)]
15437    pub struct wire_cst_SdkError_ServiceConnectivity {
15438        err: *mut wire_cst_list_prim_u_8_strict,
15439    }
15440    #[repr(C)]
15441    #[derive(Clone, Copy)]
15442    pub struct wire_cst_sdk_event {
15443        tag: i32,
15444        kind: SdkEventKind,
15445    }
15446    #[repr(C)]
15447    #[derive(Clone, Copy)]
15448    pub union SdkEventKind {
15449        PaymentFailed: wire_cst_SdkEvent_PaymentFailed,
15450        PaymentPending: wire_cst_SdkEvent_PaymentPending,
15451        PaymentRefundable: wire_cst_SdkEvent_PaymentRefundable,
15452        PaymentRefunded: wire_cst_SdkEvent_PaymentRefunded,
15453        PaymentRefundPending: wire_cst_SdkEvent_PaymentRefundPending,
15454        PaymentSucceeded: wire_cst_SdkEvent_PaymentSucceeded,
15455        PaymentWaitingConfirmation: wire_cst_SdkEvent_PaymentWaitingConfirmation,
15456        PaymentWaitingFeeAcceptance: wire_cst_SdkEvent_PaymentWaitingFeeAcceptance,
15457        DataSynced: wire_cst_SdkEvent_DataSynced,
15458        nil__: (),
15459    }
15460    #[repr(C)]
15461    #[derive(Clone, Copy)]
15462    pub struct wire_cst_SdkEvent_PaymentFailed {
15463        details: *mut wire_cst_payment,
15464    }
15465    #[repr(C)]
15466    #[derive(Clone, Copy)]
15467    pub struct wire_cst_SdkEvent_PaymentPending {
15468        details: *mut wire_cst_payment,
15469    }
15470    #[repr(C)]
15471    #[derive(Clone, Copy)]
15472    pub struct wire_cst_SdkEvent_PaymentRefundable {
15473        details: *mut wire_cst_payment,
15474    }
15475    #[repr(C)]
15476    #[derive(Clone, Copy)]
15477    pub struct wire_cst_SdkEvent_PaymentRefunded {
15478        details: *mut wire_cst_payment,
15479    }
15480    #[repr(C)]
15481    #[derive(Clone, Copy)]
15482    pub struct wire_cst_SdkEvent_PaymentRefundPending {
15483        details: *mut wire_cst_payment,
15484    }
15485    #[repr(C)]
15486    #[derive(Clone, Copy)]
15487    pub struct wire_cst_SdkEvent_PaymentSucceeded {
15488        details: *mut wire_cst_payment,
15489    }
15490    #[repr(C)]
15491    #[derive(Clone, Copy)]
15492    pub struct wire_cst_SdkEvent_PaymentWaitingConfirmation {
15493        details: *mut wire_cst_payment,
15494    }
15495    #[repr(C)]
15496    #[derive(Clone, Copy)]
15497    pub struct wire_cst_SdkEvent_PaymentWaitingFeeAcceptance {
15498        details: *mut wire_cst_payment,
15499    }
15500    #[repr(C)]
15501    #[derive(Clone, Copy)]
15502    pub struct wire_cst_SdkEvent_DataSynced {
15503        did_pull_new_records: bool,
15504    }
15505    #[repr(C)]
15506    #[derive(Clone, Copy)]
15507    pub struct wire_cst_send_destination {
15508        tag: i32,
15509        kind: SendDestinationKind,
15510    }
15511    #[repr(C)]
15512    #[derive(Clone, Copy)]
15513    pub union SendDestinationKind {
15514        LiquidAddress: wire_cst_SendDestination_LiquidAddress,
15515        Bolt11: wire_cst_SendDestination_Bolt11,
15516        Bolt12: wire_cst_SendDestination_Bolt12,
15517        nil__: (),
15518    }
15519    #[repr(C)]
15520    #[derive(Clone, Copy)]
15521    pub struct wire_cst_SendDestination_LiquidAddress {
15522        address_data: *mut wire_cst_liquid_address_data,
15523        bip353_address: *mut wire_cst_list_prim_u_8_strict,
15524    }
15525    #[repr(C)]
15526    #[derive(Clone, Copy)]
15527    pub struct wire_cst_SendDestination_Bolt11 {
15528        invoice: *mut wire_cst_ln_invoice,
15529        bip353_address: *mut wire_cst_list_prim_u_8_strict,
15530    }
15531    #[repr(C)]
15532    #[derive(Clone, Copy)]
15533    pub struct wire_cst_SendDestination_Bolt12 {
15534        offer: *mut wire_cst_ln_offer,
15535        receiver_amount_sat: u64,
15536        bip353_address: *mut wire_cst_list_prim_u_8_strict,
15537    }
15538    #[repr(C)]
15539    #[derive(Clone, Copy)]
15540    pub struct wire_cst_send_payment_request {
15541        prepare_response: wire_cst_prepare_send_response,
15542        use_asset_fees: *mut bool,
15543        payer_note: *mut wire_cst_list_prim_u_8_strict,
15544    }
15545    #[repr(C)]
15546    #[derive(Clone, Copy)]
15547    pub struct wire_cst_send_payment_response {
15548        payment: wire_cst_payment,
15549    }
15550    #[repr(C)]
15551    #[derive(Clone, Copy)]
15552    pub struct wire_cst_sign_message_request {
15553        message: *mut wire_cst_list_prim_u_8_strict,
15554    }
15555    #[repr(C)]
15556    #[derive(Clone, Copy)]
15557    pub struct wire_cst_sign_message_response {
15558        signature: *mut wire_cst_list_prim_u_8_strict,
15559    }
15560    #[repr(C)]
15561    #[derive(Clone, Copy)]
15562    pub struct wire_cst_success_action {
15563        tag: i32,
15564        kind: SuccessActionKind,
15565    }
15566    #[repr(C)]
15567    #[derive(Clone, Copy)]
15568    pub union SuccessActionKind {
15569        Aes: wire_cst_SuccessAction_Aes,
15570        Message: wire_cst_SuccessAction_Message,
15571        Url: wire_cst_SuccessAction_Url,
15572        nil__: (),
15573    }
15574    #[repr(C)]
15575    #[derive(Clone, Copy)]
15576    pub struct wire_cst_SuccessAction_Aes {
15577        data: *mut wire_cst_aes_success_action_data,
15578    }
15579    #[repr(C)]
15580    #[derive(Clone, Copy)]
15581    pub struct wire_cst_SuccessAction_Message {
15582        data: *mut wire_cst_message_success_action_data,
15583    }
15584    #[repr(C)]
15585    #[derive(Clone, Copy)]
15586    pub struct wire_cst_SuccessAction_Url {
15587        data: *mut wire_cst_url_success_action_data,
15588    }
15589    #[repr(C)]
15590    #[derive(Clone, Copy)]
15591    pub struct wire_cst_success_action_processed {
15592        tag: i32,
15593        kind: SuccessActionProcessedKind,
15594    }
15595    #[repr(C)]
15596    #[derive(Clone, Copy)]
15597    pub union SuccessActionProcessedKind {
15598        Aes: wire_cst_SuccessActionProcessed_Aes,
15599        Message: wire_cst_SuccessActionProcessed_Message,
15600        Url: wire_cst_SuccessActionProcessed_Url,
15601        nil__: (),
15602    }
15603    #[repr(C)]
15604    #[derive(Clone, Copy)]
15605    pub struct wire_cst_SuccessActionProcessed_Aes {
15606        result: *mut wire_cst_aes_success_action_data_result,
15607    }
15608    #[repr(C)]
15609    #[derive(Clone, Copy)]
15610    pub struct wire_cst_SuccessActionProcessed_Message {
15611        data: *mut wire_cst_message_success_action_data,
15612    }
15613    #[repr(C)]
15614    #[derive(Clone, Copy)]
15615    pub struct wire_cst_SuccessActionProcessed_Url {
15616        data: *mut wire_cst_url_success_action_data,
15617    }
15618    #[repr(C)]
15619    #[derive(Clone, Copy)]
15620    pub struct wire_cst_symbol {
15621        grapheme: *mut wire_cst_list_prim_u_8_strict,
15622        template: *mut wire_cst_list_prim_u_8_strict,
15623        rtl: *mut bool,
15624        position: *mut u32,
15625    }
15626    #[repr(C)]
15627    #[derive(Clone, Copy)]
15628    pub struct wire_cst_url_success_action_data {
15629        description: *mut wire_cst_list_prim_u_8_strict,
15630        url: *mut wire_cst_list_prim_u_8_strict,
15631        matches_callback_domain: bool,
15632    }
15633    #[repr(C)]
15634    #[derive(Clone, Copy)]
15635    pub struct wire_cst_wallet_info {
15636        balance_sat: u64,
15637        pending_send_sat: u64,
15638        pending_receive_sat: u64,
15639        fingerprint: *mut wire_cst_list_prim_u_8_strict,
15640        pubkey: *mut wire_cst_list_prim_u_8_strict,
15641        asset_balances: *mut wire_cst_list_asset_balance,
15642    }
15643}
15644#[cfg(not(target_family = "wasm"))]
15645pub use io::*;