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                return crate::model::PayAmount::Asset {
3973                    asset_id: var_assetId,
3974                    receiver_amount: var_receiverAmount,
3975                    estimate_asset_fees: var_estimateAssetFees,
3976                };
3977            }
3978            2 => {
3979                return crate::model::PayAmount::Drain;
3980            }
3981            _ => {
3982                unimplemented!("");
3983            }
3984        }
3985    }
3986}
3987
3988impl SseDecode for crate::model::PayOnchainRequest {
3989    // Codec=Sse (Serialization based), see doc to use other codecs
3990    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3991        let mut var_address = <String>::sse_decode(deserializer);
3992        let mut var_prepareResponse =
3993            <crate::model::PreparePayOnchainResponse>::sse_decode(deserializer);
3994        return crate::model::PayOnchainRequest {
3995            address: var_address,
3996            prepare_response: var_prepareResponse,
3997        };
3998    }
3999}
4000
4001impl SseDecode for crate::model::Payment {
4002    // Codec=Sse (Serialization based), see doc to use other codecs
4003    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4004        let mut var_destination = <Option<String>>::sse_decode(deserializer);
4005        let mut var_txId = <Option<String>>::sse_decode(deserializer);
4006        let mut var_unblindingData = <Option<String>>::sse_decode(deserializer);
4007        let mut var_timestamp = <u32>::sse_decode(deserializer);
4008        let mut var_amountSat = <u64>::sse_decode(deserializer);
4009        let mut var_feesSat = <u64>::sse_decode(deserializer);
4010        let mut var_swapperFeesSat = <Option<u64>>::sse_decode(deserializer);
4011        let mut var_paymentType = <crate::model::PaymentType>::sse_decode(deserializer);
4012        let mut var_status = <crate::model::PaymentState>::sse_decode(deserializer);
4013        let mut var_details = <crate::model::PaymentDetails>::sse_decode(deserializer);
4014        return crate::model::Payment {
4015            destination: var_destination,
4016            tx_id: var_txId,
4017            unblinding_data: var_unblindingData,
4018            timestamp: var_timestamp,
4019            amount_sat: var_amountSat,
4020            fees_sat: var_feesSat,
4021            swapper_fees_sat: var_swapperFeesSat,
4022            payment_type: var_paymentType,
4023            status: var_status,
4024            details: var_details,
4025        };
4026    }
4027}
4028
4029impl SseDecode for crate::model::PaymentDetails {
4030    // Codec=Sse (Serialization based), see doc to use other codecs
4031    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4032        let mut tag_ = <i32>::sse_decode(deserializer);
4033        match tag_ {
4034            0 => {
4035                let mut var_swapId = <String>::sse_decode(deserializer);
4036                let mut var_description = <String>::sse_decode(deserializer);
4037                let mut var_liquidExpirationBlockheight = <u32>::sse_decode(deserializer);
4038                let mut var_preimage = <Option<String>>::sse_decode(deserializer);
4039                let mut var_invoice = <Option<String>>::sse_decode(deserializer);
4040                let mut var_bolt12Offer = <Option<String>>::sse_decode(deserializer);
4041                let mut var_paymentHash = <Option<String>>::sse_decode(deserializer);
4042                let mut var_destinationPubkey = <Option<String>>::sse_decode(deserializer);
4043                let mut var_lnurlInfo = <Option<crate::model::LnUrlInfo>>::sse_decode(deserializer);
4044                let mut var_bip353Address = <Option<String>>::sse_decode(deserializer);
4045                let mut var_payerNote = <Option<String>>::sse_decode(deserializer);
4046                let mut var_claimTxId = <Option<String>>::sse_decode(deserializer);
4047                let mut var_refundTxId = <Option<String>>::sse_decode(deserializer);
4048                let mut var_refundTxAmountSat = <Option<u64>>::sse_decode(deserializer);
4049                return crate::model::PaymentDetails::Lightning {
4050                    swap_id: var_swapId,
4051                    description: var_description,
4052                    liquid_expiration_blockheight: var_liquidExpirationBlockheight,
4053                    preimage: var_preimage,
4054                    invoice: var_invoice,
4055                    bolt12_offer: var_bolt12Offer,
4056                    payment_hash: var_paymentHash,
4057                    destination_pubkey: var_destinationPubkey,
4058                    lnurl_info: var_lnurlInfo,
4059                    bip353_address: var_bip353Address,
4060                    payer_note: var_payerNote,
4061                    claim_tx_id: var_claimTxId,
4062                    refund_tx_id: var_refundTxId,
4063                    refund_tx_amount_sat: var_refundTxAmountSat,
4064                };
4065            }
4066            1 => {
4067                let mut var_destination = <String>::sse_decode(deserializer);
4068                let mut var_description = <String>::sse_decode(deserializer);
4069                let mut var_assetId = <String>::sse_decode(deserializer);
4070                let mut var_assetInfo = <Option<crate::model::AssetInfo>>::sse_decode(deserializer);
4071                let mut var_lnurlInfo = <Option<crate::model::LnUrlInfo>>::sse_decode(deserializer);
4072                let mut var_bip353Address = <Option<String>>::sse_decode(deserializer);
4073                let mut var_payerNote = <Option<String>>::sse_decode(deserializer);
4074                return crate::model::PaymentDetails::Liquid {
4075                    destination: var_destination,
4076                    description: var_description,
4077                    asset_id: var_assetId,
4078                    asset_info: var_assetInfo,
4079                    lnurl_info: var_lnurlInfo,
4080                    bip353_address: var_bip353Address,
4081                    payer_note: var_payerNote,
4082                };
4083            }
4084            2 => {
4085                let mut var_swapId = <String>::sse_decode(deserializer);
4086                let mut var_bitcoinAddress = <String>::sse_decode(deserializer);
4087                let mut var_description = <String>::sse_decode(deserializer);
4088                let mut var_autoAcceptedFees = <bool>::sse_decode(deserializer);
4089                let mut var_liquidExpirationBlockheight = <Option<u32>>::sse_decode(deserializer);
4090                let mut var_bitcoinExpirationBlockheight = <Option<u32>>::sse_decode(deserializer);
4091                let mut var_lockupTxId = <Option<String>>::sse_decode(deserializer);
4092                let mut var_claimTxId = <Option<String>>::sse_decode(deserializer);
4093                let mut var_refundTxId = <Option<String>>::sse_decode(deserializer);
4094                let mut var_refundTxAmountSat = <Option<u64>>::sse_decode(deserializer);
4095                return crate::model::PaymentDetails::Bitcoin {
4096                    swap_id: var_swapId,
4097                    bitcoin_address: var_bitcoinAddress,
4098                    description: var_description,
4099                    auto_accepted_fees: var_autoAcceptedFees,
4100                    liquid_expiration_blockheight: var_liquidExpirationBlockheight,
4101                    bitcoin_expiration_blockheight: var_bitcoinExpirationBlockheight,
4102                    lockup_tx_id: var_lockupTxId,
4103                    claim_tx_id: var_claimTxId,
4104                    refund_tx_id: var_refundTxId,
4105                    refund_tx_amount_sat: var_refundTxAmountSat,
4106                };
4107            }
4108            _ => {
4109                unimplemented!("");
4110            }
4111        }
4112    }
4113}
4114
4115impl SseDecode for crate::error::PaymentError {
4116    // Codec=Sse (Serialization based), see doc to use other codecs
4117    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4118        let mut tag_ = <i32>::sse_decode(deserializer);
4119        match tag_ {
4120            0 => {
4121                return crate::error::PaymentError::AlreadyClaimed;
4122            }
4123            1 => {
4124                return crate::error::PaymentError::AlreadyPaid;
4125            }
4126            2 => {
4127                return crate::error::PaymentError::PaymentInProgress;
4128            }
4129            3 => {
4130                let mut var_min = <u64>::sse_decode(deserializer);
4131                let mut var_max = <u64>::sse_decode(deserializer);
4132                return crate::error::PaymentError::AmountOutOfRange {
4133                    min: var_min,
4134                    max: var_max,
4135                };
4136            }
4137            4 => {
4138                let mut var_err = <String>::sse_decode(deserializer);
4139                return crate::error::PaymentError::AmountMissing { err: var_err };
4140            }
4141            5 => {
4142                let mut var_err = <String>::sse_decode(deserializer);
4143                return crate::error::PaymentError::AssetError { err: var_err };
4144            }
4145            6 => {
4146                let mut var_err = <String>::sse_decode(deserializer);
4147                return crate::error::PaymentError::InvalidNetwork { err: var_err };
4148            }
4149            7 => {
4150                let mut var_err = <String>::sse_decode(deserializer);
4151                return crate::error::PaymentError::Generic { err: var_err };
4152            }
4153            8 => {
4154                return crate::error::PaymentError::InvalidOrExpiredFees;
4155            }
4156            9 => {
4157                return crate::error::PaymentError::InsufficientFunds;
4158            }
4159            10 => {
4160                let mut var_err = <String>::sse_decode(deserializer);
4161                return crate::error::PaymentError::InvalidDescription { err: var_err };
4162            }
4163            11 => {
4164                let mut var_err = <String>::sse_decode(deserializer);
4165                return crate::error::PaymentError::InvalidInvoice { err: var_err };
4166            }
4167            12 => {
4168                return crate::error::PaymentError::InvalidPreimage;
4169            }
4170            13 => {
4171                return crate::error::PaymentError::PairsNotFound;
4172            }
4173            14 => {
4174                return crate::error::PaymentError::PaymentTimeout;
4175            }
4176            15 => {
4177                return crate::error::PaymentError::PersistError;
4178            }
4179            16 => {
4180                let mut var_err = <String>::sse_decode(deserializer);
4181                return crate::error::PaymentError::ReceiveError { err: var_err };
4182            }
4183            17 => {
4184                let mut var_err = <String>::sse_decode(deserializer);
4185                let mut var_refundTxId = <String>::sse_decode(deserializer);
4186                return crate::error::PaymentError::Refunded {
4187                    err: var_err,
4188                    refund_tx_id: var_refundTxId,
4189                };
4190            }
4191            18 => {
4192                return crate::error::PaymentError::SelfTransferNotSupported;
4193            }
4194            19 => {
4195                let mut var_err = <String>::sse_decode(deserializer);
4196                return crate::error::PaymentError::SendError { err: var_err };
4197            }
4198            20 => {
4199                let mut var_err = <String>::sse_decode(deserializer);
4200                return crate::error::PaymentError::SignerError { err: var_err };
4201            }
4202            _ => {
4203                unimplemented!("");
4204            }
4205        }
4206    }
4207}
4208
4209impl SseDecode for crate::model::PaymentMethod {
4210    // Codec=Sse (Serialization based), see doc to use other codecs
4211    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4212        let mut inner = <i32>::sse_decode(deserializer);
4213        return match inner {
4214            0 => crate::model::PaymentMethod::Lightning,
4215            1 => crate::model::PaymentMethod::Bolt11Invoice,
4216            2 => crate::model::PaymentMethod::Bolt12Offer,
4217            3 => crate::model::PaymentMethod::BitcoinAddress,
4218            4 => crate::model::PaymentMethod::LiquidAddress,
4219            _ => unreachable!("Invalid variant for PaymentMethod: {}", inner),
4220        };
4221    }
4222}
4223
4224impl SseDecode for crate::model::PaymentState {
4225    // Codec=Sse (Serialization based), see doc to use other codecs
4226    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4227        let mut inner = <i32>::sse_decode(deserializer);
4228        return match inner {
4229            0 => crate::model::PaymentState::Created,
4230            1 => crate::model::PaymentState::Pending,
4231            2 => crate::model::PaymentState::Complete,
4232            3 => crate::model::PaymentState::Failed,
4233            4 => crate::model::PaymentState::TimedOut,
4234            5 => crate::model::PaymentState::Refundable,
4235            6 => crate::model::PaymentState::RefundPending,
4236            7 => crate::model::PaymentState::WaitingFeeAcceptance,
4237            _ => unreachable!("Invalid variant for PaymentState: {}", inner),
4238        };
4239    }
4240}
4241
4242impl SseDecode for crate::model::PaymentType {
4243    // Codec=Sse (Serialization based), see doc to use other codecs
4244    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4245        let mut inner = <i32>::sse_decode(deserializer);
4246        return match inner {
4247            0 => crate::model::PaymentType::Receive,
4248            1 => crate::model::PaymentType::Send,
4249            _ => unreachable!("Invalid variant for PaymentType: {}", inner),
4250        };
4251    }
4252}
4253
4254impl SseDecode for crate::model::PrepareBuyBitcoinRequest {
4255    // Codec=Sse (Serialization based), see doc to use other codecs
4256    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4257        let mut var_provider = <crate::model::BuyBitcoinProvider>::sse_decode(deserializer);
4258        let mut var_amountSat = <u64>::sse_decode(deserializer);
4259        return crate::model::PrepareBuyBitcoinRequest {
4260            provider: var_provider,
4261            amount_sat: var_amountSat,
4262        };
4263    }
4264}
4265
4266impl SseDecode for crate::model::PrepareBuyBitcoinResponse {
4267    // Codec=Sse (Serialization based), see doc to use other codecs
4268    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4269        let mut var_provider = <crate::model::BuyBitcoinProvider>::sse_decode(deserializer);
4270        let mut var_amountSat = <u64>::sse_decode(deserializer);
4271        let mut var_feesSat = <u64>::sse_decode(deserializer);
4272        return crate::model::PrepareBuyBitcoinResponse {
4273            provider: var_provider,
4274            amount_sat: var_amountSat,
4275            fees_sat: var_feesSat,
4276        };
4277    }
4278}
4279
4280impl SseDecode for crate::model::PrepareLnUrlPayRequest {
4281    // Codec=Sse (Serialization based), see doc to use other codecs
4282    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4283        let mut var_data = <crate::bindings::LnUrlPayRequestData>::sse_decode(deserializer);
4284        let mut var_amount = <crate::model::PayAmount>::sse_decode(deserializer);
4285        let mut var_bip353Address = <Option<String>>::sse_decode(deserializer);
4286        let mut var_comment = <Option<String>>::sse_decode(deserializer);
4287        let mut var_validateSuccessActionUrl = <Option<bool>>::sse_decode(deserializer);
4288        return crate::model::PrepareLnUrlPayRequest {
4289            data: var_data,
4290            amount: var_amount,
4291            bip353_address: var_bip353Address,
4292            comment: var_comment,
4293            validate_success_action_url: var_validateSuccessActionUrl,
4294        };
4295    }
4296}
4297
4298impl SseDecode for crate::model::PrepareLnUrlPayResponse {
4299    // Codec=Sse (Serialization based), see doc to use other codecs
4300    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4301        let mut var_destination = <crate::model::SendDestination>::sse_decode(deserializer);
4302        let mut var_feesSat = <u64>::sse_decode(deserializer);
4303        let mut var_data = <crate::bindings::LnUrlPayRequestData>::sse_decode(deserializer);
4304        let mut var_amount = <crate::model::PayAmount>::sse_decode(deserializer);
4305        let mut var_comment = <Option<String>>::sse_decode(deserializer);
4306        let mut var_successAction =
4307            <Option<crate::bindings::SuccessAction>>::sse_decode(deserializer);
4308        return crate::model::PrepareLnUrlPayResponse {
4309            destination: var_destination,
4310            fees_sat: var_feesSat,
4311            data: var_data,
4312            amount: var_amount,
4313            comment: var_comment,
4314            success_action: var_successAction,
4315        };
4316    }
4317}
4318
4319impl SseDecode for crate::model::PreparePayOnchainRequest {
4320    // Codec=Sse (Serialization based), see doc to use other codecs
4321    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4322        let mut var_amount = <crate::model::PayAmount>::sse_decode(deserializer);
4323        let mut var_feeRateSatPerVbyte = <Option<u32>>::sse_decode(deserializer);
4324        return crate::model::PreparePayOnchainRequest {
4325            amount: var_amount,
4326            fee_rate_sat_per_vbyte: var_feeRateSatPerVbyte,
4327        };
4328    }
4329}
4330
4331impl SseDecode for crate::model::PreparePayOnchainResponse {
4332    // Codec=Sse (Serialization based), see doc to use other codecs
4333    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4334        let mut var_receiverAmountSat = <u64>::sse_decode(deserializer);
4335        let mut var_claimFeesSat = <u64>::sse_decode(deserializer);
4336        let mut var_totalFeesSat = <u64>::sse_decode(deserializer);
4337        return crate::model::PreparePayOnchainResponse {
4338            receiver_amount_sat: var_receiverAmountSat,
4339            claim_fees_sat: var_claimFeesSat,
4340            total_fees_sat: var_totalFeesSat,
4341        };
4342    }
4343}
4344
4345impl SseDecode for crate::model::PrepareReceiveRequest {
4346    // Codec=Sse (Serialization based), see doc to use other codecs
4347    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4348        let mut var_paymentMethod = <crate::model::PaymentMethod>::sse_decode(deserializer);
4349        let mut var_amount = <Option<crate::model::ReceiveAmount>>::sse_decode(deserializer);
4350        return crate::model::PrepareReceiveRequest {
4351            payment_method: var_paymentMethod,
4352            amount: var_amount,
4353        };
4354    }
4355}
4356
4357impl SseDecode for crate::model::PrepareReceiveResponse {
4358    // Codec=Sse (Serialization based), see doc to use other codecs
4359    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4360        let mut var_paymentMethod = <crate::model::PaymentMethod>::sse_decode(deserializer);
4361        let mut var_feesSat = <u64>::sse_decode(deserializer);
4362        let mut var_amount = <Option<crate::model::ReceiveAmount>>::sse_decode(deserializer);
4363        let mut var_minPayerAmountSat = <Option<u64>>::sse_decode(deserializer);
4364        let mut var_maxPayerAmountSat = <Option<u64>>::sse_decode(deserializer);
4365        let mut var_swapperFeerate = <Option<f64>>::sse_decode(deserializer);
4366        return crate::model::PrepareReceiveResponse {
4367            payment_method: var_paymentMethod,
4368            fees_sat: var_feesSat,
4369            amount: var_amount,
4370            min_payer_amount_sat: var_minPayerAmountSat,
4371            max_payer_amount_sat: var_maxPayerAmountSat,
4372            swapper_feerate: var_swapperFeerate,
4373        };
4374    }
4375}
4376
4377impl SseDecode for crate::model::PrepareRefundRequest {
4378    // Codec=Sse (Serialization based), see doc to use other codecs
4379    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4380        let mut var_swapAddress = <String>::sse_decode(deserializer);
4381        let mut var_refundAddress = <String>::sse_decode(deserializer);
4382        let mut var_feeRateSatPerVbyte = <u32>::sse_decode(deserializer);
4383        return crate::model::PrepareRefundRequest {
4384            swap_address: var_swapAddress,
4385            refund_address: var_refundAddress,
4386            fee_rate_sat_per_vbyte: var_feeRateSatPerVbyte,
4387        };
4388    }
4389}
4390
4391impl SseDecode for crate::model::PrepareRefundResponse {
4392    // Codec=Sse (Serialization based), see doc to use other codecs
4393    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4394        let mut var_txVsize = <u32>::sse_decode(deserializer);
4395        let mut var_txFeeSat = <u64>::sse_decode(deserializer);
4396        let mut var_lastRefundTxId = <Option<String>>::sse_decode(deserializer);
4397        return crate::model::PrepareRefundResponse {
4398            tx_vsize: var_txVsize,
4399            tx_fee_sat: var_txFeeSat,
4400            last_refund_tx_id: var_lastRefundTxId,
4401        };
4402    }
4403}
4404
4405impl SseDecode for crate::model::PrepareSendRequest {
4406    // Codec=Sse (Serialization based), see doc to use other codecs
4407    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4408        let mut var_destination = <String>::sse_decode(deserializer);
4409        let mut var_amount = <Option<crate::model::PayAmount>>::sse_decode(deserializer);
4410        return crate::model::PrepareSendRequest {
4411            destination: var_destination,
4412            amount: var_amount,
4413        };
4414    }
4415}
4416
4417impl SseDecode for crate::model::PrepareSendResponse {
4418    // Codec=Sse (Serialization based), see doc to use other codecs
4419    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4420        let mut var_destination = <crate::model::SendDestination>::sse_decode(deserializer);
4421        let mut var_amount = <Option<crate::model::PayAmount>>::sse_decode(deserializer);
4422        let mut var_feesSat = <Option<u64>>::sse_decode(deserializer);
4423        let mut var_estimatedAssetFees = <Option<f64>>::sse_decode(deserializer);
4424        return crate::model::PrepareSendResponse {
4425            destination: var_destination,
4426            amount: var_amount,
4427            fees_sat: var_feesSat,
4428            estimated_asset_fees: var_estimatedAssetFees,
4429        };
4430    }
4431}
4432
4433impl SseDecode for crate::bindings::Rate {
4434    // Codec=Sse (Serialization based), see doc to use other codecs
4435    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4436        let mut var_coin = <String>::sse_decode(deserializer);
4437        let mut var_value = <f64>::sse_decode(deserializer);
4438        return crate::bindings::Rate {
4439            coin: var_coin,
4440            value: var_value,
4441        };
4442    }
4443}
4444
4445impl SseDecode for crate::model::ReceiveAmount {
4446    // Codec=Sse (Serialization based), see doc to use other codecs
4447    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4448        let mut tag_ = <i32>::sse_decode(deserializer);
4449        match tag_ {
4450            0 => {
4451                let mut var_payerAmountSat = <u64>::sse_decode(deserializer);
4452                return crate::model::ReceiveAmount::Bitcoin {
4453                    payer_amount_sat: var_payerAmountSat,
4454                };
4455            }
4456            1 => {
4457                let mut var_assetId = <String>::sse_decode(deserializer);
4458                let mut var_payerAmount = <Option<f64>>::sse_decode(deserializer);
4459                return crate::model::ReceiveAmount::Asset {
4460                    asset_id: var_assetId,
4461                    payer_amount: var_payerAmount,
4462                };
4463            }
4464            _ => {
4465                unimplemented!("");
4466            }
4467        }
4468    }
4469}
4470
4471impl SseDecode for crate::model::ReceivePaymentRequest {
4472    // Codec=Sse (Serialization based), see doc to use other codecs
4473    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4474        let mut var_prepareResponse =
4475            <crate::model::PrepareReceiveResponse>::sse_decode(deserializer);
4476        let mut var_description = <Option<String>>::sse_decode(deserializer);
4477        let mut var_useDescriptionHash = <Option<bool>>::sse_decode(deserializer);
4478        let mut var_payerNote = <Option<String>>::sse_decode(deserializer);
4479        return crate::model::ReceivePaymentRequest {
4480            prepare_response: var_prepareResponse,
4481            description: var_description,
4482            use_description_hash: var_useDescriptionHash,
4483            payer_note: var_payerNote,
4484        };
4485    }
4486}
4487
4488impl SseDecode for crate::model::ReceivePaymentResponse {
4489    // Codec=Sse (Serialization based), see doc to use other codecs
4490    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4491        let mut var_destination = <String>::sse_decode(deserializer);
4492        return crate::model::ReceivePaymentResponse {
4493            destination: var_destination,
4494        };
4495    }
4496}
4497
4498impl SseDecode for crate::model::RecommendedFees {
4499    // Codec=Sse (Serialization based), see doc to use other codecs
4500    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4501        let mut var_fastestFee = <u64>::sse_decode(deserializer);
4502        let mut var_halfHourFee = <u64>::sse_decode(deserializer);
4503        let mut var_hourFee = <u64>::sse_decode(deserializer);
4504        let mut var_economyFee = <u64>::sse_decode(deserializer);
4505        let mut var_minimumFee = <u64>::sse_decode(deserializer);
4506        return crate::model::RecommendedFees {
4507            fastest_fee: var_fastestFee,
4508            half_hour_fee: var_halfHourFee,
4509            hour_fee: var_hourFee,
4510            economy_fee: var_economyFee,
4511            minimum_fee: var_minimumFee,
4512        };
4513    }
4514}
4515
4516impl SseDecode for crate::model::RefundRequest {
4517    // Codec=Sse (Serialization based), see doc to use other codecs
4518    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4519        let mut var_swapAddress = <String>::sse_decode(deserializer);
4520        let mut var_refundAddress = <String>::sse_decode(deserializer);
4521        let mut var_feeRateSatPerVbyte = <u32>::sse_decode(deserializer);
4522        return crate::model::RefundRequest {
4523            swap_address: var_swapAddress,
4524            refund_address: var_refundAddress,
4525            fee_rate_sat_per_vbyte: var_feeRateSatPerVbyte,
4526        };
4527    }
4528}
4529
4530impl SseDecode for crate::model::RefundResponse {
4531    // Codec=Sse (Serialization based), see doc to use other codecs
4532    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4533        let mut var_refundTxId = <String>::sse_decode(deserializer);
4534        return crate::model::RefundResponse {
4535            refund_tx_id: var_refundTxId,
4536        };
4537    }
4538}
4539
4540impl SseDecode for crate::model::RefundableSwap {
4541    // Codec=Sse (Serialization based), see doc to use other codecs
4542    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4543        let mut var_swapAddress = <String>::sse_decode(deserializer);
4544        let mut var_timestamp = <u32>::sse_decode(deserializer);
4545        let mut var_amountSat = <u64>::sse_decode(deserializer);
4546        let mut var_lastRefundTxId = <Option<String>>::sse_decode(deserializer);
4547        return crate::model::RefundableSwap {
4548            swap_address: var_swapAddress,
4549            timestamp: var_timestamp,
4550            amount_sat: var_amountSat,
4551            last_refund_tx_id: var_lastRefundTxId,
4552        };
4553    }
4554}
4555
4556impl SseDecode for crate::model::RestoreRequest {
4557    // Codec=Sse (Serialization based), see doc to use other codecs
4558    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4559        let mut var_backupPath = <Option<String>>::sse_decode(deserializer);
4560        return crate::model::RestoreRequest {
4561            backup_path: var_backupPath,
4562        };
4563    }
4564}
4565
4566impl SseDecode for crate::bindings::RouteHint {
4567    // Codec=Sse (Serialization based), see doc to use other codecs
4568    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4569        let mut var_hops = <Vec<crate::bindings::RouteHintHop>>::sse_decode(deserializer);
4570        return crate::bindings::RouteHint { hops: var_hops };
4571    }
4572}
4573
4574impl SseDecode for crate::bindings::RouteHintHop {
4575    // Codec=Sse (Serialization based), see doc to use other codecs
4576    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4577        let mut var_srcNodeId = <String>::sse_decode(deserializer);
4578        let mut var_shortChannelId = <String>::sse_decode(deserializer);
4579        let mut var_feesBaseMsat = <u32>::sse_decode(deserializer);
4580        let mut var_feesProportionalMillionths = <u32>::sse_decode(deserializer);
4581        let mut var_cltvExpiryDelta = <u64>::sse_decode(deserializer);
4582        let mut var_htlcMinimumMsat = <Option<u64>>::sse_decode(deserializer);
4583        let mut var_htlcMaximumMsat = <Option<u64>>::sse_decode(deserializer);
4584        return crate::bindings::RouteHintHop {
4585            src_node_id: var_srcNodeId,
4586            short_channel_id: var_shortChannelId,
4587            fees_base_msat: var_feesBaseMsat,
4588            fees_proportional_millionths: var_feesProportionalMillionths,
4589            cltv_expiry_delta: var_cltvExpiryDelta,
4590            htlc_minimum_msat: var_htlcMinimumMsat,
4591            htlc_maximum_msat: var_htlcMaximumMsat,
4592        };
4593    }
4594}
4595
4596impl SseDecode for crate::error::SdkError {
4597    // Codec=Sse (Serialization based), see doc to use other codecs
4598    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4599        let mut tag_ = <i32>::sse_decode(deserializer);
4600        match tag_ {
4601            0 => {
4602                return crate::error::SdkError::AlreadyStarted;
4603            }
4604            1 => {
4605                let mut var_err = <String>::sse_decode(deserializer);
4606                return crate::error::SdkError::Generic { err: var_err };
4607            }
4608            2 => {
4609                return crate::error::SdkError::NotStarted;
4610            }
4611            3 => {
4612                let mut var_err = <String>::sse_decode(deserializer);
4613                return crate::error::SdkError::ServiceConnectivity { err: var_err };
4614            }
4615            _ => {
4616                unimplemented!("");
4617            }
4618        }
4619    }
4620}
4621
4622impl SseDecode for crate::model::SdkEvent {
4623    // Codec=Sse (Serialization based), see doc to use other codecs
4624    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4625        let mut tag_ = <i32>::sse_decode(deserializer);
4626        match tag_ {
4627            0 => {
4628                let mut var_details = <crate::model::Payment>::sse_decode(deserializer);
4629                return crate::model::SdkEvent::PaymentFailed {
4630                    details: var_details,
4631                };
4632            }
4633            1 => {
4634                let mut var_details = <crate::model::Payment>::sse_decode(deserializer);
4635                return crate::model::SdkEvent::PaymentPending {
4636                    details: var_details,
4637                };
4638            }
4639            2 => {
4640                let mut var_details = <crate::model::Payment>::sse_decode(deserializer);
4641                return crate::model::SdkEvent::PaymentRefundable {
4642                    details: var_details,
4643                };
4644            }
4645            3 => {
4646                let mut var_details = <crate::model::Payment>::sse_decode(deserializer);
4647                return crate::model::SdkEvent::PaymentRefunded {
4648                    details: var_details,
4649                };
4650            }
4651            4 => {
4652                let mut var_details = <crate::model::Payment>::sse_decode(deserializer);
4653                return crate::model::SdkEvent::PaymentRefundPending {
4654                    details: var_details,
4655                };
4656            }
4657            5 => {
4658                let mut var_details = <crate::model::Payment>::sse_decode(deserializer);
4659                return crate::model::SdkEvent::PaymentSucceeded {
4660                    details: var_details,
4661                };
4662            }
4663            6 => {
4664                let mut var_details = <crate::model::Payment>::sse_decode(deserializer);
4665                return crate::model::SdkEvent::PaymentWaitingConfirmation {
4666                    details: var_details,
4667                };
4668            }
4669            7 => {
4670                let mut var_details = <crate::model::Payment>::sse_decode(deserializer);
4671                return crate::model::SdkEvent::PaymentWaitingFeeAcceptance {
4672                    details: var_details,
4673                };
4674            }
4675            8 => {
4676                return crate::model::SdkEvent::Synced;
4677            }
4678            9 => {
4679                let mut var_didPullNewRecords = <bool>::sse_decode(deserializer);
4680                return crate::model::SdkEvent::DataSynced {
4681                    did_pull_new_records: var_didPullNewRecords,
4682                };
4683            }
4684            _ => {
4685                unimplemented!("");
4686            }
4687        }
4688    }
4689}
4690
4691impl SseDecode for crate::model::SendDestination {
4692    // Codec=Sse (Serialization based), see doc to use other codecs
4693    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4694        let mut tag_ = <i32>::sse_decode(deserializer);
4695        match tag_ {
4696            0 => {
4697                let mut var_addressData =
4698                    <crate::bindings::LiquidAddressData>::sse_decode(deserializer);
4699                let mut var_bip353Address = <Option<String>>::sse_decode(deserializer);
4700                return crate::model::SendDestination::LiquidAddress {
4701                    address_data: var_addressData,
4702                    bip353_address: var_bip353Address,
4703                };
4704            }
4705            1 => {
4706                let mut var_invoice = <crate::bindings::LNInvoice>::sse_decode(deserializer);
4707                let mut var_bip353Address = <Option<String>>::sse_decode(deserializer);
4708                return crate::model::SendDestination::Bolt11 {
4709                    invoice: var_invoice,
4710                    bip353_address: var_bip353Address,
4711                };
4712            }
4713            2 => {
4714                let mut var_offer = <crate::bindings::LNOffer>::sse_decode(deserializer);
4715                let mut var_receiverAmountSat = <u64>::sse_decode(deserializer);
4716                let mut var_bip353Address = <Option<String>>::sse_decode(deserializer);
4717                return crate::model::SendDestination::Bolt12 {
4718                    offer: var_offer,
4719                    receiver_amount_sat: var_receiverAmountSat,
4720                    bip353_address: var_bip353Address,
4721                };
4722            }
4723            _ => {
4724                unimplemented!("");
4725            }
4726        }
4727    }
4728}
4729
4730impl SseDecode for crate::model::SendPaymentRequest {
4731    // Codec=Sse (Serialization based), see doc to use other codecs
4732    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4733        let mut var_prepareResponse = <crate::model::PrepareSendResponse>::sse_decode(deserializer);
4734        let mut var_useAssetFees = <Option<bool>>::sse_decode(deserializer);
4735        let mut var_payerNote = <Option<String>>::sse_decode(deserializer);
4736        return crate::model::SendPaymentRequest {
4737            prepare_response: var_prepareResponse,
4738            use_asset_fees: var_useAssetFees,
4739            payer_note: var_payerNote,
4740        };
4741    }
4742}
4743
4744impl SseDecode for crate::model::SendPaymentResponse {
4745    // Codec=Sse (Serialization based), see doc to use other codecs
4746    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4747        let mut var_payment = <crate::model::Payment>::sse_decode(deserializer);
4748        return crate::model::SendPaymentResponse {
4749            payment: var_payment,
4750        };
4751    }
4752}
4753
4754impl SseDecode for crate::model::SignMessageRequest {
4755    // Codec=Sse (Serialization based), see doc to use other codecs
4756    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4757        let mut var_message = <String>::sse_decode(deserializer);
4758        return crate::model::SignMessageRequest {
4759            message: var_message,
4760        };
4761    }
4762}
4763
4764impl SseDecode for crate::model::SignMessageResponse {
4765    // Codec=Sse (Serialization based), see doc to use other codecs
4766    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4767        let mut var_signature = <String>::sse_decode(deserializer);
4768        return crate::model::SignMessageResponse {
4769            signature: var_signature,
4770        };
4771    }
4772}
4773
4774impl SseDecode for crate::bindings::SuccessAction {
4775    // Codec=Sse (Serialization based), see doc to use other codecs
4776    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4777        let mut tag_ = <i32>::sse_decode(deserializer);
4778        match tag_ {
4779            0 => {
4780                let mut var_data =
4781                    <crate::bindings::AesSuccessActionData>::sse_decode(deserializer);
4782                return crate::bindings::SuccessAction::Aes { data: var_data };
4783            }
4784            1 => {
4785                let mut var_data =
4786                    <crate::bindings::MessageSuccessActionData>::sse_decode(deserializer);
4787                return crate::bindings::SuccessAction::Message { data: var_data };
4788            }
4789            2 => {
4790                let mut var_data =
4791                    <crate::bindings::UrlSuccessActionData>::sse_decode(deserializer);
4792                return crate::bindings::SuccessAction::Url { data: var_data };
4793            }
4794            _ => {
4795                unimplemented!("");
4796            }
4797        }
4798    }
4799}
4800
4801impl SseDecode for crate::bindings::SuccessActionProcessed {
4802    // Codec=Sse (Serialization based), see doc to use other codecs
4803    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4804        let mut tag_ = <i32>::sse_decode(deserializer);
4805        match tag_ {
4806            0 => {
4807                let mut var_result =
4808                    <crate::bindings::AesSuccessActionDataResult>::sse_decode(deserializer);
4809                return crate::bindings::SuccessActionProcessed::Aes { result: var_result };
4810            }
4811            1 => {
4812                let mut var_data =
4813                    <crate::bindings::MessageSuccessActionData>::sse_decode(deserializer);
4814                return crate::bindings::SuccessActionProcessed::Message { data: var_data };
4815            }
4816            2 => {
4817                let mut var_data =
4818                    <crate::bindings::UrlSuccessActionData>::sse_decode(deserializer);
4819                return crate::bindings::SuccessActionProcessed::Url { data: var_data };
4820            }
4821            _ => {
4822                unimplemented!("");
4823            }
4824        }
4825    }
4826}
4827
4828impl SseDecode for crate::bindings::Symbol {
4829    // Codec=Sse (Serialization based), see doc to use other codecs
4830    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4831        let mut var_grapheme = <Option<String>>::sse_decode(deserializer);
4832        let mut var_template = <Option<String>>::sse_decode(deserializer);
4833        let mut var_rtl = <Option<bool>>::sse_decode(deserializer);
4834        let mut var_position = <Option<u32>>::sse_decode(deserializer);
4835        return crate::bindings::Symbol {
4836            grapheme: var_grapheme,
4837            template: var_template,
4838            rtl: var_rtl,
4839            position: var_position,
4840        };
4841    }
4842}
4843
4844impl SseDecode for u16 {
4845    // Codec=Sse (Serialization based), see doc to use other codecs
4846    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4847        deserializer.cursor.read_u16::<NativeEndian>().unwrap()
4848    }
4849}
4850
4851impl SseDecode for u32 {
4852    // Codec=Sse (Serialization based), see doc to use other codecs
4853    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4854        deserializer.cursor.read_u32::<NativeEndian>().unwrap()
4855    }
4856}
4857
4858impl SseDecode for u64 {
4859    // Codec=Sse (Serialization based), see doc to use other codecs
4860    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4861        deserializer.cursor.read_u64::<NativeEndian>().unwrap()
4862    }
4863}
4864
4865impl SseDecode for u8 {
4866    // Codec=Sse (Serialization based), see doc to use other codecs
4867    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4868        deserializer.cursor.read_u8().unwrap()
4869    }
4870}
4871
4872impl SseDecode for () {
4873    // Codec=Sse (Serialization based), see doc to use other codecs
4874    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {}
4875}
4876
4877impl SseDecode for crate::bindings::UrlSuccessActionData {
4878    // Codec=Sse (Serialization based), see doc to use other codecs
4879    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4880        let mut var_description = <String>::sse_decode(deserializer);
4881        let mut var_url = <String>::sse_decode(deserializer);
4882        let mut var_matchesCallbackDomain = <bool>::sse_decode(deserializer);
4883        return crate::bindings::UrlSuccessActionData {
4884            description: var_description,
4885            url: var_url,
4886            matches_callback_domain: var_matchesCallbackDomain,
4887        };
4888    }
4889}
4890
4891impl SseDecode for usize {
4892    // Codec=Sse (Serialization based), see doc to use other codecs
4893    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4894        deserializer.cursor.read_u64::<NativeEndian>().unwrap() as _
4895    }
4896}
4897
4898impl SseDecode for crate::model::WalletInfo {
4899    // Codec=Sse (Serialization based), see doc to use other codecs
4900    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4901        let mut var_balanceSat = <u64>::sse_decode(deserializer);
4902        let mut var_pendingSendSat = <u64>::sse_decode(deserializer);
4903        let mut var_pendingReceiveSat = <u64>::sse_decode(deserializer);
4904        let mut var_fingerprint = <String>::sse_decode(deserializer);
4905        let mut var_pubkey = <String>::sse_decode(deserializer);
4906        let mut var_assetBalances = <Vec<crate::model::AssetBalance>>::sse_decode(deserializer);
4907        return crate::model::WalletInfo {
4908            balance_sat: var_balanceSat,
4909            pending_send_sat: var_pendingSendSat,
4910            pending_receive_sat: var_pendingReceiveSat,
4911            fingerprint: var_fingerprint,
4912            pubkey: var_pubkey,
4913            asset_balances: var_assetBalances,
4914        };
4915    }
4916}
4917
4918fn pde_ffi_dispatcher_primary_impl(
4919    func_id: i32,
4920    port: flutter_rust_bridge::for_generated::MessagePort,
4921    ptr: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
4922    rust_vec_len: i32,
4923    data_len: i32,
4924) {
4925    // Codec=Pde (Serialization + dispatch), see doc to use other codecs
4926    match func_id {
4927        _ => unreachable!(),
4928    }
4929}
4930
4931fn pde_ffi_dispatcher_sync_impl(
4932    func_id: i32,
4933    ptr: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
4934    rust_vec_len: i32,
4935    data_len: i32,
4936) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
4937    // Codec=Pde (Serialization + dispatch), see doc to use other codecs
4938    match func_id {
4939        _ => unreachable!(),
4940    }
4941}
4942
4943// Section: rust2dart
4944
4945// Codec=Dco (DartCObject based), see doc to use other codecs
4946impl flutter_rust_bridge::IntoDart for FrbWrapper<BindingLiquidSdk> {
4947    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
4948        flutter_rust_bridge::for_generated::rust_auto_opaque_encode::<_, StdArc<_>>(self.0)
4949            .into_dart()
4950    }
4951}
4952impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for FrbWrapper<BindingLiquidSdk> {}
4953
4954impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<BindingLiquidSdk>> for BindingLiquidSdk {
4955    fn into_into_dart(self) -> FrbWrapper<BindingLiquidSdk> {
4956        self.into()
4957    }
4958}
4959
4960// Codec=Dco (DartCObject based), see doc to use other codecs
4961impl flutter_rust_bridge::IntoDart for crate::model::AcceptPaymentProposedFeesRequest {
4962    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
4963        [self.response.into_into_dart().into_dart()].into_dart()
4964    }
4965}
4966impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
4967    for crate::model::AcceptPaymentProposedFeesRequest
4968{
4969}
4970impl flutter_rust_bridge::IntoIntoDart<crate::model::AcceptPaymentProposedFeesRequest>
4971    for crate::model::AcceptPaymentProposedFeesRequest
4972{
4973    fn into_into_dart(self) -> crate::model::AcceptPaymentProposedFeesRequest {
4974        self
4975    }
4976}
4977// Codec=Dco (DartCObject based), see doc to use other codecs
4978impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::AesSuccessActionData> {
4979    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
4980        [
4981            self.0.description.into_into_dart().into_dart(),
4982            self.0.ciphertext.into_into_dart().into_dart(),
4983            self.0.iv.into_into_dart().into_dart(),
4984        ]
4985        .into_dart()
4986    }
4987}
4988impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
4989    for FrbWrapper<crate::bindings::AesSuccessActionData>
4990{
4991}
4992impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::AesSuccessActionData>>
4993    for crate::bindings::AesSuccessActionData
4994{
4995    fn into_into_dart(self) -> FrbWrapper<crate::bindings::AesSuccessActionData> {
4996        self.into()
4997    }
4998}
4999// Codec=Dco (DartCObject based), see doc to use other codecs
5000impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::AesSuccessActionDataDecrypted> {
5001    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5002        [
5003            self.0.description.into_into_dart().into_dart(),
5004            self.0.plaintext.into_into_dart().into_dart(),
5005        ]
5006        .into_dart()
5007    }
5008}
5009impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5010    for FrbWrapper<crate::bindings::AesSuccessActionDataDecrypted>
5011{
5012}
5013impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::AesSuccessActionDataDecrypted>>
5014    for crate::bindings::AesSuccessActionDataDecrypted
5015{
5016    fn into_into_dart(self) -> FrbWrapper<crate::bindings::AesSuccessActionDataDecrypted> {
5017        self.into()
5018    }
5019}
5020// Codec=Dco (DartCObject based), see doc to use other codecs
5021impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::AesSuccessActionDataResult> {
5022    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5023        match self.0 {
5024            crate::bindings::AesSuccessActionDataResult::Decrypted { data } => {
5025                [0.into_dart(), data.into_into_dart().into_dart()].into_dart()
5026            }
5027            crate::bindings::AesSuccessActionDataResult::ErrorStatus { reason } => {
5028                [1.into_dart(), reason.into_into_dart().into_dart()].into_dart()
5029            }
5030            _ => {
5031                unimplemented!("");
5032            }
5033        }
5034    }
5035}
5036impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5037    for FrbWrapper<crate::bindings::AesSuccessActionDataResult>
5038{
5039}
5040impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::AesSuccessActionDataResult>>
5041    for crate::bindings::AesSuccessActionDataResult
5042{
5043    fn into_into_dart(self) -> FrbWrapper<crate::bindings::AesSuccessActionDataResult> {
5044        self.into()
5045    }
5046}
5047// Codec=Dco (DartCObject based), see doc to use other codecs
5048impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::Amount> {
5049    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5050        match self.0 {
5051            crate::bindings::Amount::Bitcoin { amount_msat } => {
5052                [0.into_dart(), amount_msat.into_into_dart().into_dart()].into_dart()
5053            }
5054            crate::bindings::Amount::Currency {
5055                iso4217_code,
5056                fractional_amount,
5057            } => [
5058                1.into_dart(),
5059                iso4217_code.into_into_dart().into_dart(),
5060                fractional_amount.into_into_dart().into_dart(),
5061            ]
5062            .into_dart(),
5063            _ => {
5064                unimplemented!("");
5065            }
5066        }
5067    }
5068}
5069impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5070    for FrbWrapper<crate::bindings::Amount>
5071{
5072}
5073impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::Amount>>
5074    for crate::bindings::Amount
5075{
5076    fn into_into_dart(self) -> FrbWrapper<crate::bindings::Amount> {
5077        self.into()
5078    }
5079}
5080// Codec=Dco (DartCObject based), see doc to use other codecs
5081impl flutter_rust_bridge::IntoDart for crate::model::AssetBalance {
5082    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5083        [
5084            self.asset_id.into_into_dart().into_dart(),
5085            self.balance_sat.into_into_dart().into_dart(),
5086            self.name.into_into_dart().into_dart(),
5087            self.ticker.into_into_dart().into_dart(),
5088            self.balance.into_into_dart().into_dart(),
5089        ]
5090        .into_dart()
5091    }
5092}
5093impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::AssetBalance {}
5094impl flutter_rust_bridge::IntoIntoDart<crate::model::AssetBalance> for crate::model::AssetBalance {
5095    fn into_into_dart(self) -> crate::model::AssetBalance {
5096        self
5097    }
5098}
5099// Codec=Dco (DartCObject based), see doc to use other codecs
5100impl flutter_rust_bridge::IntoDart for crate::model::AssetInfo {
5101    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5102        [
5103            self.name.into_into_dart().into_dart(),
5104            self.ticker.into_into_dart().into_dart(),
5105            self.amount.into_into_dart().into_dart(),
5106            self.fees.into_into_dart().into_dart(),
5107        ]
5108        .into_dart()
5109    }
5110}
5111impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::AssetInfo {}
5112impl flutter_rust_bridge::IntoIntoDart<crate::model::AssetInfo> for crate::model::AssetInfo {
5113    fn into_into_dart(self) -> crate::model::AssetInfo {
5114        self
5115    }
5116}
5117// Codec=Dco (DartCObject based), see doc to use other codecs
5118impl flutter_rust_bridge::IntoDart for crate::model::AssetMetadata {
5119    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5120        [
5121            self.asset_id.into_into_dart().into_dart(),
5122            self.name.into_into_dart().into_dart(),
5123            self.ticker.into_into_dart().into_dart(),
5124            self.precision.into_into_dart().into_dart(),
5125            self.fiat_id.into_into_dart().into_dart(),
5126        ]
5127        .into_dart()
5128    }
5129}
5130impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::AssetMetadata {}
5131impl flutter_rust_bridge::IntoIntoDart<crate::model::AssetMetadata>
5132    for crate::model::AssetMetadata
5133{
5134    fn into_into_dart(self) -> crate::model::AssetMetadata {
5135        self
5136    }
5137}
5138// Codec=Dco (DartCObject based), see doc to use other codecs
5139impl flutter_rust_bridge::IntoDart for crate::model::BackupRequest {
5140    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5141        [self.backup_path.into_into_dart().into_dart()].into_dart()
5142    }
5143}
5144impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::BackupRequest {}
5145impl flutter_rust_bridge::IntoIntoDart<crate::model::BackupRequest>
5146    for crate::model::BackupRequest
5147{
5148    fn into_into_dart(self) -> crate::model::BackupRequest {
5149        self
5150    }
5151}
5152// Codec=Dco (DartCObject based), see doc to use other codecs
5153impl flutter_rust_bridge::IntoDart for crate::bindings::BindingEventListener {
5154    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5155        [self.stream.into_into_dart().into_dart()].into_dart()
5156    }
5157}
5158impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5159    for crate::bindings::BindingEventListener
5160{
5161}
5162impl flutter_rust_bridge::IntoIntoDart<crate::bindings::BindingEventListener>
5163    for crate::bindings::BindingEventListener
5164{
5165    fn into_into_dart(self) -> crate::bindings::BindingEventListener {
5166        self
5167    }
5168}
5169// Codec=Dco (DartCObject based), see doc to use other codecs
5170impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::BitcoinAddressData> {
5171    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5172        [
5173            self.0.address.into_into_dart().into_dart(),
5174            self.0.network.into_into_dart().into_dart(),
5175            self.0.amount_sat.into_into_dart().into_dart(),
5176            self.0.label.into_into_dart().into_dart(),
5177            self.0.message.into_into_dart().into_dart(),
5178        ]
5179        .into_dart()
5180    }
5181}
5182impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5183    for FrbWrapper<crate::bindings::BitcoinAddressData>
5184{
5185}
5186impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::BitcoinAddressData>>
5187    for crate::bindings::BitcoinAddressData
5188{
5189    fn into_into_dart(self) -> FrbWrapper<crate::bindings::BitcoinAddressData> {
5190        self.into()
5191    }
5192}
5193// Codec=Dco (DartCObject based), see doc to use other codecs
5194impl flutter_rust_bridge::IntoDart for crate::model::BlockchainExplorer {
5195    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5196        match self {
5197            crate::model::BlockchainExplorer::Electrum { url } => {
5198                [0.into_dart(), url.into_into_dart().into_dart()].into_dart()
5199            }
5200            crate::model::BlockchainExplorer::Esplora {
5201                url,
5202                use_waterfalls,
5203            } => [
5204                1.into_dart(),
5205                url.into_into_dart().into_dart(),
5206                use_waterfalls.into_into_dart().into_dart(),
5207            ]
5208            .into_dart(),
5209            _ => {
5210                unimplemented!("");
5211            }
5212        }
5213    }
5214}
5215impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5216    for crate::model::BlockchainExplorer
5217{
5218}
5219impl flutter_rust_bridge::IntoIntoDart<crate::model::BlockchainExplorer>
5220    for crate::model::BlockchainExplorer
5221{
5222    fn into_into_dart(self) -> crate::model::BlockchainExplorer {
5223        self
5224    }
5225}
5226// Codec=Dco (DartCObject based), see doc to use other codecs
5227impl flutter_rust_bridge::IntoDart for crate::model::BlockchainInfo {
5228    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5229        [
5230            self.liquid_tip.into_into_dart().into_dart(),
5231            self.bitcoin_tip.into_into_dart().into_dart(),
5232        ]
5233        .into_dart()
5234    }
5235}
5236impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::BlockchainInfo {}
5237impl flutter_rust_bridge::IntoIntoDart<crate::model::BlockchainInfo>
5238    for crate::model::BlockchainInfo
5239{
5240    fn into_into_dart(self) -> crate::model::BlockchainInfo {
5241        self
5242    }
5243}
5244// Codec=Dco (DartCObject based), see doc to use other codecs
5245impl flutter_rust_bridge::IntoDart for crate::model::BuyBitcoinProvider {
5246    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5247        match self {
5248            Self::Moonpay => 0.into_dart(),
5249            _ => unreachable!(),
5250        }
5251    }
5252}
5253impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5254    for crate::model::BuyBitcoinProvider
5255{
5256}
5257impl flutter_rust_bridge::IntoIntoDart<crate::model::BuyBitcoinProvider>
5258    for crate::model::BuyBitcoinProvider
5259{
5260    fn into_into_dart(self) -> crate::model::BuyBitcoinProvider {
5261        self
5262    }
5263}
5264// Codec=Dco (DartCObject based), see doc to use other codecs
5265impl flutter_rust_bridge::IntoDart for crate::model::BuyBitcoinRequest {
5266    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5267        [
5268            self.prepare_response.into_into_dart().into_dart(),
5269            self.redirect_url.into_into_dart().into_dart(),
5270        ]
5271        .into_dart()
5272    }
5273}
5274impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5275    for crate::model::BuyBitcoinRequest
5276{
5277}
5278impl flutter_rust_bridge::IntoIntoDart<crate::model::BuyBitcoinRequest>
5279    for crate::model::BuyBitcoinRequest
5280{
5281    fn into_into_dart(self) -> crate::model::BuyBitcoinRequest {
5282        self
5283    }
5284}
5285// Codec=Dco (DartCObject based), see doc to use other codecs
5286impl flutter_rust_bridge::IntoDart for crate::model::CheckMessageRequest {
5287    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5288        [
5289            self.message.into_into_dart().into_dart(),
5290            self.pubkey.into_into_dart().into_dart(),
5291            self.signature.into_into_dart().into_dart(),
5292        ]
5293        .into_dart()
5294    }
5295}
5296impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5297    for crate::model::CheckMessageRequest
5298{
5299}
5300impl flutter_rust_bridge::IntoIntoDart<crate::model::CheckMessageRequest>
5301    for crate::model::CheckMessageRequest
5302{
5303    fn into_into_dart(self) -> crate::model::CheckMessageRequest {
5304        self
5305    }
5306}
5307// Codec=Dco (DartCObject based), see doc to use other codecs
5308impl flutter_rust_bridge::IntoDart for crate::model::CheckMessageResponse {
5309    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5310        [self.is_valid.into_into_dart().into_dart()].into_dart()
5311    }
5312}
5313impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5314    for crate::model::CheckMessageResponse
5315{
5316}
5317impl flutter_rust_bridge::IntoIntoDart<crate::model::CheckMessageResponse>
5318    for crate::model::CheckMessageResponse
5319{
5320    fn into_into_dart(self) -> crate::model::CheckMessageResponse {
5321        self
5322    }
5323}
5324// Codec=Dco (DartCObject based), see doc to use other codecs
5325impl flutter_rust_bridge::IntoDart for crate::model::Config {
5326    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5327        [
5328            self.liquid_explorer.into_into_dart().into_dart(),
5329            self.bitcoin_explorer.into_into_dart().into_dart(),
5330            self.working_dir.into_into_dart().into_dart(),
5331            self.network.into_into_dart().into_dart(),
5332            self.payment_timeout_sec.into_into_dart().into_dart(),
5333            self.sync_service_url.into_into_dart().into_dart(),
5334            self.zero_conf_max_amount_sat.into_into_dart().into_dart(),
5335            self.breez_api_key.into_into_dart().into_dart(),
5336            self.external_input_parsers.into_into_dart().into_dart(),
5337            self.use_default_external_input_parsers
5338                .into_into_dart()
5339                .into_dart(),
5340            self.onchain_fee_rate_leeway_sat
5341                .into_into_dart()
5342                .into_dart(),
5343            self.asset_metadata.into_into_dart().into_dart(),
5344            self.sideswap_api_key.into_into_dart().into_dart(),
5345        ]
5346        .into_dart()
5347    }
5348}
5349impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::Config {}
5350impl flutter_rust_bridge::IntoIntoDart<crate::model::Config> for crate::model::Config {
5351    fn into_into_dart(self) -> crate::model::Config {
5352        self
5353    }
5354}
5355// Codec=Dco (DartCObject based), see doc to use other codecs
5356impl flutter_rust_bridge::IntoDart for crate::model::ConnectRequest {
5357    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5358        [
5359            self.config.into_into_dart().into_dart(),
5360            self.mnemonic.into_into_dart().into_dart(),
5361            self.passphrase.into_into_dart().into_dart(),
5362            self.seed.into_into_dart().into_dart(),
5363        ]
5364        .into_dart()
5365    }
5366}
5367impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::ConnectRequest {}
5368impl flutter_rust_bridge::IntoIntoDart<crate::model::ConnectRequest>
5369    for crate::model::ConnectRequest
5370{
5371    fn into_into_dart(self) -> crate::model::ConnectRequest {
5372        self
5373    }
5374}
5375// Codec=Dco (DartCObject based), see doc to use other codecs
5376impl flutter_rust_bridge::IntoDart for crate::model::CreateBolt12InvoiceRequest {
5377    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5378        [
5379            self.offer.into_into_dart().into_dart(),
5380            self.invoice_request.into_into_dart().into_dart(),
5381        ]
5382        .into_dart()
5383    }
5384}
5385impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5386    for crate::model::CreateBolt12InvoiceRequest
5387{
5388}
5389impl flutter_rust_bridge::IntoIntoDart<crate::model::CreateBolt12InvoiceRequest>
5390    for crate::model::CreateBolt12InvoiceRequest
5391{
5392    fn into_into_dart(self) -> crate::model::CreateBolt12InvoiceRequest {
5393        self
5394    }
5395}
5396// Codec=Dco (DartCObject based), see doc to use other codecs
5397impl flutter_rust_bridge::IntoDart for crate::model::CreateBolt12InvoiceResponse {
5398    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5399        [self.invoice.into_into_dart().into_dart()].into_dart()
5400    }
5401}
5402impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5403    for crate::model::CreateBolt12InvoiceResponse
5404{
5405}
5406impl flutter_rust_bridge::IntoIntoDart<crate::model::CreateBolt12InvoiceResponse>
5407    for crate::model::CreateBolt12InvoiceResponse
5408{
5409    fn into_into_dart(self) -> crate::model::CreateBolt12InvoiceResponse {
5410        self
5411    }
5412}
5413// Codec=Dco (DartCObject based), see doc to use other codecs
5414impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::CurrencyInfo> {
5415    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5416        [
5417            self.0.name.into_into_dart().into_dart(),
5418            self.0.fraction_size.into_into_dart().into_dart(),
5419            self.0.spacing.into_into_dart().into_dart(),
5420            self.0.symbol.into_into_dart().into_dart(),
5421            self.0.uniq_symbol.into_into_dart().into_dart(),
5422            self.0.localized_name.into_into_dart().into_dart(),
5423            self.0.locale_overrides.into_into_dart().into_dart(),
5424        ]
5425        .into_dart()
5426    }
5427}
5428impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5429    for FrbWrapper<crate::bindings::CurrencyInfo>
5430{
5431}
5432impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::CurrencyInfo>>
5433    for crate::bindings::CurrencyInfo
5434{
5435    fn into_into_dart(self) -> FrbWrapper<crate::bindings::CurrencyInfo> {
5436        self.into()
5437    }
5438}
5439// Codec=Dco (DartCObject based), see doc to use other codecs
5440impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::ExternalInputParser> {
5441    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5442        [
5443            self.0.provider_id.into_into_dart().into_dart(),
5444            self.0.input_regex.into_into_dart().into_dart(),
5445            self.0.parser_url.into_into_dart().into_dart(),
5446        ]
5447        .into_dart()
5448    }
5449}
5450impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5451    for FrbWrapper<crate::bindings::ExternalInputParser>
5452{
5453}
5454impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::ExternalInputParser>>
5455    for crate::bindings::ExternalInputParser
5456{
5457    fn into_into_dart(self) -> FrbWrapper<crate::bindings::ExternalInputParser> {
5458        self.into()
5459    }
5460}
5461// Codec=Dco (DartCObject based), see doc to use other codecs
5462impl flutter_rust_bridge::IntoDart for crate::model::FetchPaymentProposedFeesRequest {
5463    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5464        [self.swap_id.into_into_dart().into_dart()].into_dart()
5465    }
5466}
5467impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5468    for crate::model::FetchPaymentProposedFeesRequest
5469{
5470}
5471impl flutter_rust_bridge::IntoIntoDart<crate::model::FetchPaymentProposedFeesRequest>
5472    for crate::model::FetchPaymentProposedFeesRequest
5473{
5474    fn into_into_dart(self) -> crate::model::FetchPaymentProposedFeesRequest {
5475        self
5476    }
5477}
5478// Codec=Dco (DartCObject based), see doc to use other codecs
5479impl flutter_rust_bridge::IntoDart for crate::model::FetchPaymentProposedFeesResponse {
5480    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5481        [
5482            self.swap_id.into_into_dart().into_dart(),
5483            self.fees_sat.into_into_dart().into_dart(),
5484            self.payer_amount_sat.into_into_dart().into_dart(),
5485            self.receiver_amount_sat.into_into_dart().into_dart(),
5486        ]
5487        .into_dart()
5488    }
5489}
5490impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5491    for crate::model::FetchPaymentProposedFeesResponse
5492{
5493}
5494impl flutter_rust_bridge::IntoIntoDart<crate::model::FetchPaymentProposedFeesResponse>
5495    for crate::model::FetchPaymentProposedFeesResponse
5496{
5497    fn into_into_dart(self) -> crate::model::FetchPaymentProposedFeesResponse {
5498        self
5499    }
5500}
5501// Codec=Dco (DartCObject based), see doc to use other codecs
5502impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::FiatCurrency> {
5503    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5504        [
5505            self.0.id.into_into_dart().into_dart(),
5506            self.0.info.into_into_dart().into_dart(),
5507        ]
5508        .into_dart()
5509    }
5510}
5511impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5512    for FrbWrapper<crate::bindings::FiatCurrency>
5513{
5514}
5515impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::FiatCurrency>>
5516    for crate::bindings::FiatCurrency
5517{
5518    fn into_into_dart(self) -> FrbWrapper<crate::bindings::FiatCurrency> {
5519        self.into()
5520    }
5521}
5522// Codec=Dco (DartCObject based), see doc to use other codecs
5523impl flutter_rust_bridge::IntoDart for crate::model::GetInfoResponse {
5524    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5525        [
5526            self.wallet_info.into_into_dart().into_dart(),
5527            self.blockchain_info.into_into_dart().into_dart(),
5528        ]
5529        .into_dart()
5530    }
5531}
5532impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::GetInfoResponse {}
5533impl flutter_rust_bridge::IntoIntoDart<crate::model::GetInfoResponse>
5534    for crate::model::GetInfoResponse
5535{
5536    fn into_into_dart(self) -> crate::model::GetInfoResponse {
5537        self
5538    }
5539}
5540// Codec=Dco (DartCObject based), see doc to use other codecs
5541impl flutter_rust_bridge::IntoDart for crate::model::GetPaymentRequest {
5542    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5543        match self {
5544            crate::model::GetPaymentRequest::PaymentHash { payment_hash } => {
5545                [0.into_dart(), payment_hash.into_into_dart().into_dart()].into_dart()
5546            }
5547            crate::model::GetPaymentRequest::SwapId { swap_id } => {
5548                [1.into_dart(), swap_id.into_into_dart().into_dart()].into_dart()
5549            }
5550            _ => {
5551                unimplemented!("");
5552            }
5553        }
5554    }
5555}
5556impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5557    for crate::model::GetPaymentRequest
5558{
5559}
5560impl flutter_rust_bridge::IntoIntoDart<crate::model::GetPaymentRequest>
5561    for crate::model::GetPaymentRequest
5562{
5563    fn into_into_dart(self) -> crate::model::GetPaymentRequest {
5564        self
5565    }
5566}
5567// Codec=Dco (DartCObject based), see doc to use other codecs
5568impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::InputType> {
5569    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5570        match self.0 {
5571            crate::bindings::InputType::BitcoinAddress { address } => {
5572                [0.into_dart(), address.into_into_dart().into_dart()].into_dart()
5573            }
5574            crate::bindings::InputType::LiquidAddress { address } => {
5575                [1.into_dart(), address.into_into_dart().into_dart()].into_dart()
5576            }
5577            crate::bindings::InputType::Bolt11 { invoice } => {
5578                [2.into_dart(), invoice.into_into_dart().into_dart()].into_dart()
5579            }
5580            crate::bindings::InputType::Bolt12Offer {
5581                offer,
5582                bip353_address,
5583            } => [
5584                3.into_dart(),
5585                offer.into_into_dart().into_dart(),
5586                bip353_address.into_into_dart().into_dart(),
5587            ]
5588            .into_dart(),
5589            crate::bindings::InputType::NodeId { node_id } => {
5590                [4.into_dart(), node_id.into_into_dart().into_dart()].into_dart()
5591            }
5592            crate::bindings::InputType::Url { url } => {
5593                [5.into_dart(), url.into_into_dart().into_dart()].into_dart()
5594            }
5595            crate::bindings::InputType::LnUrlPay {
5596                data,
5597                bip353_address,
5598            } => [
5599                6.into_dart(),
5600                data.into_into_dart().into_dart(),
5601                bip353_address.into_into_dart().into_dart(),
5602            ]
5603            .into_dart(),
5604            crate::bindings::InputType::LnUrlWithdraw { data } => {
5605                [7.into_dart(), data.into_into_dart().into_dart()].into_dart()
5606            }
5607            crate::bindings::InputType::LnUrlAuth { data } => {
5608                [8.into_dart(), data.into_into_dart().into_dart()].into_dart()
5609            }
5610            crate::bindings::InputType::LnUrlError { data } => {
5611                [9.into_dart(), data.into_into_dart().into_dart()].into_dart()
5612            }
5613            _ => {
5614                unimplemented!("");
5615            }
5616        }
5617    }
5618}
5619impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5620    for FrbWrapper<crate::bindings::InputType>
5621{
5622}
5623impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::InputType>>
5624    for crate::bindings::InputType
5625{
5626    fn into_into_dart(self) -> FrbWrapper<crate::bindings::InputType> {
5627        self.into()
5628    }
5629}
5630// Codec=Dco (DartCObject based), see doc to use other codecs
5631impl flutter_rust_bridge::IntoDart for crate::model::LightningPaymentLimitsResponse {
5632    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5633        [
5634            self.send.into_into_dart().into_dart(),
5635            self.receive.into_into_dart().into_dart(),
5636        ]
5637        .into_dart()
5638    }
5639}
5640impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5641    for crate::model::LightningPaymentLimitsResponse
5642{
5643}
5644impl flutter_rust_bridge::IntoIntoDart<crate::model::LightningPaymentLimitsResponse>
5645    for crate::model::LightningPaymentLimitsResponse
5646{
5647    fn into_into_dart(self) -> crate::model::LightningPaymentLimitsResponse {
5648        self
5649    }
5650}
5651// Codec=Dco (DartCObject based), see doc to use other codecs
5652impl flutter_rust_bridge::IntoDart for crate::model::Limits {
5653    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5654        [
5655            self.min_sat.into_into_dart().into_dart(),
5656            self.max_sat.into_into_dart().into_dart(),
5657            self.max_zero_conf_sat.into_into_dart().into_dart(),
5658        ]
5659        .into_dart()
5660    }
5661}
5662impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::Limits {}
5663impl flutter_rust_bridge::IntoIntoDart<crate::model::Limits> for crate::model::Limits {
5664    fn into_into_dart(self) -> crate::model::Limits {
5665        self
5666    }
5667}
5668// Codec=Dco (DartCObject based), see doc to use other codecs
5669impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LiquidAddressData> {
5670    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5671        [
5672            self.0.address.into_into_dart().into_dart(),
5673            self.0.network.into_into_dart().into_dart(),
5674            self.0.asset_id.into_into_dart().into_dart(),
5675            self.0.amount.into_into_dart().into_dart(),
5676            self.0.amount_sat.into_into_dart().into_dart(),
5677            self.0.label.into_into_dart().into_dart(),
5678            self.0.message.into_into_dart().into_dart(),
5679        ]
5680        .into_dart()
5681    }
5682}
5683impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5684    for FrbWrapper<crate::bindings::LiquidAddressData>
5685{
5686}
5687impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LiquidAddressData>>
5688    for crate::bindings::LiquidAddressData
5689{
5690    fn into_into_dart(self) -> FrbWrapper<crate::bindings::LiquidAddressData> {
5691        self.into()
5692    }
5693}
5694// Codec=Dco (DartCObject based), see doc to use other codecs
5695impl flutter_rust_bridge::IntoDart for crate::model::LiquidNetwork {
5696    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5697        match self {
5698            Self::Mainnet => 0.into_dart(),
5699            Self::Testnet => 1.into_dart(),
5700            Self::Regtest => 2.into_dart(),
5701            _ => unreachable!(),
5702        }
5703    }
5704}
5705impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::LiquidNetwork {}
5706impl flutter_rust_bridge::IntoIntoDart<crate::model::LiquidNetwork>
5707    for crate::model::LiquidNetwork
5708{
5709    fn into_into_dart(self) -> crate::model::LiquidNetwork {
5710        self
5711    }
5712}
5713// Codec=Dco (DartCObject based), see doc to use other codecs
5714impl flutter_rust_bridge::IntoDart for crate::model::ListPaymentDetails {
5715    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5716        match self {
5717            crate::model::ListPaymentDetails::Liquid {
5718                asset_id,
5719                destination,
5720            } => [
5721                0.into_dart(),
5722                asset_id.into_into_dart().into_dart(),
5723                destination.into_into_dart().into_dart(),
5724            ]
5725            .into_dart(),
5726            crate::model::ListPaymentDetails::Bitcoin { address } => {
5727                [1.into_dart(), address.into_into_dart().into_dart()].into_dart()
5728            }
5729            _ => {
5730                unimplemented!("");
5731            }
5732        }
5733    }
5734}
5735impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5736    for crate::model::ListPaymentDetails
5737{
5738}
5739impl flutter_rust_bridge::IntoIntoDart<crate::model::ListPaymentDetails>
5740    for crate::model::ListPaymentDetails
5741{
5742    fn into_into_dart(self) -> crate::model::ListPaymentDetails {
5743        self
5744    }
5745}
5746// Codec=Dco (DartCObject based), see doc to use other codecs
5747impl flutter_rust_bridge::IntoDart for crate::model::ListPaymentsRequest {
5748    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5749        [
5750            self.filters.into_into_dart().into_dart(),
5751            self.states.into_into_dart().into_dart(),
5752            self.from_timestamp.into_into_dart().into_dart(),
5753            self.to_timestamp.into_into_dart().into_dart(),
5754            self.offset.into_into_dart().into_dart(),
5755            self.limit.into_into_dart().into_dart(),
5756            self.details.into_into_dart().into_dart(),
5757            self.sort_ascending.into_into_dart().into_dart(),
5758        ]
5759        .into_dart()
5760    }
5761}
5762impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5763    for crate::model::ListPaymentsRequest
5764{
5765}
5766impl flutter_rust_bridge::IntoIntoDart<crate::model::ListPaymentsRequest>
5767    for crate::model::ListPaymentsRequest
5768{
5769    fn into_into_dart(self) -> crate::model::ListPaymentsRequest {
5770        self
5771    }
5772}
5773// Codec=Dco (DartCObject based), see doc to use other codecs
5774impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LNInvoice> {
5775    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5776        [
5777            self.0.bolt11.into_into_dart().into_dart(),
5778            self.0.network.into_into_dart().into_dart(),
5779            self.0.payee_pubkey.into_into_dart().into_dart(),
5780            self.0.payment_hash.into_into_dart().into_dart(),
5781            self.0.description.into_into_dart().into_dart(),
5782            self.0.description_hash.into_into_dart().into_dart(),
5783            self.0.amount_msat.into_into_dart().into_dart(),
5784            self.0.timestamp.into_into_dart().into_dart(),
5785            self.0.expiry.into_into_dart().into_dart(),
5786            self.0.routing_hints.into_into_dart().into_dart(),
5787            self.0.payment_secret.into_into_dart().into_dart(),
5788            self.0
5789                .min_final_cltv_expiry_delta
5790                .into_into_dart()
5791                .into_dart(),
5792        ]
5793        .into_dart()
5794    }
5795}
5796impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5797    for FrbWrapper<crate::bindings::LNInvoice>
5798{
5799}
5800impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LNInvoice>>
5801    for crate::bindings::LNInvoice
5802{
5803    fn into_into_dart(self) -> FrbWrapper<crate::bindings::LNInvoice> {
5804        self.into()
5805    }
5806}
5807// Codec=Dco (DartCObject based), see doc to use other codecs
5808impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LNOffer> {
5809    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5810        [
5811            self.0.offer.into_into_dart().into_dart(),
5812            self.0.chains.into_into_dart().into_dart(),
5813            self.0.min_amount.into_into_dart().into_dart(),
5814            self.0.description.into_into_dart().into_dart(),
5815            self.0.absolute_expiry.into_into_dart().into_dart(),
5816            self.0.issuer.into_into_dart().into_dart(),
5817            self.0.signing_pubkey.into_into_dart().into_dart(),
5818            self.0.paths.into_into_dart().into_dart(),
5819        ]
5820        .into_dart()
5821    }
5822}
5823impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5824    for FrbWrapper<crate::bindings::LNOffer>
5825{
5826}
5827impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LNOffer>>
5828    for crate::bindings::LNOffer
5829{
5830    fn into_into_dart(self) -> FrbWrapper<crate::bindings::LNOffer> {
5831        self.into()
5832    }
5833}
5834// Codec=Dco (DartCObject based), see doc to use other codecs
5835impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LnOfferBlindedPath> {
5836    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5837        [self.0.blinded_hops.into_into_dart().into_dart()].into_dart()
5838    }
5839}
5840impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5841    for FrbWrapper<crate::bindings::LnOfferBlindedPath>
5842{
5843}
5844impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LnOfferBlindedPath>>
5845    for crate::bindings::LnOfferBlindedPath
5846{
5847    fn into_into_dart(self) -> FrbWrapper<crate::bindings::LnOfferBlindedPath> {
5848        self.into()
5849    }
5850}
5851// Codec=Dco (DartCObject based), see doc to use other codecs
5852impl flutter_rust_bridge::IntoDart for crate::bindings::duplicates::LnUrlAuthError {
5853    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5854        match self {
5855            crate::bindings::duplicates::LnUrlAuthError::Generic { err } => {
5856                [0.into_dart(), err.into_into_dart().into_dart()].into_dart()
5857            }
5858            crate::bindings::duplicates::LnUrlAuthError::InvalidUri { err } => {
5859                [1.into_dart(), err.into_into_dart().into_dart()].into_dart()
5860            }
5861            crate::bindings::duplicates::LnUrlAuthError::ServiceConnectivity { err } => {
5862                [2.into_dart(), err.into_into_dart().into_dart()].into_dart()
5863            }
5864            _ => {
5865                unimplemented!("");
5866            }
5867        }
5868    }
5869}
5870impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5871    for crate::bindings::duplicates::LnUrlAuthError
5872{
5873}
5874impl flutter_rust_bridge::IntoIntoDart<crate::bindings::duplicates::LnUrlAuthError>
5875    for crate::bindings::duplicates::LnUrlAuthError
5876{
5877    fn into_into_dart(self) -> crate::bindings::duplicates::LnUrlAuthError {
5878        self
5879    }
5880}
5881// Codec=Dco (DartCObject based), see doc to use other codecs
5882impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LnUrlAuthRequestData> {
5883    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5884        [
5885            self.0.k1.into_into_dart().into_dart(),
5886            self.0.action.into_into_dart().into_dart(),
5887            self.0.domain.into_into_dart().into_dart(),
5888            self.0.url.into_into_dart().into_dart(),
5889        ]
5890        .into_dart()
5891    }
5892}
5893impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5894    for FrbWrapper<crate::bindings::LnUrlAuthRequestData>
5895{
5896}
5897impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LnUrlAuthRequestData>>
5898    for crate::bindings::LnUrlAuthRequestData
5899{
5900    fn into_into_dart(self) -> FrbWrapper<crate::bindings::LnUrlAuthRequestData> {
5901        self.into()
5902    }
5903}
5904// Codec=Dco (DartCObject based), see doc to use other codecs
5905impl flutter_rust_bridge::IntoDart for crate::bindings::duplicates::LnUrlCallbackStatus {
5906    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5907        match self {
5908            crate::bindings::duplicates::LnUrlCallbackStatus::Ok => [0.into_dart()].into_dart(),
5909            crate::bindings::duplicates::LnUrlCallbackStatus::ErrorStatus { data } => {
5910                [1.into_dart(), data.into_into_dart().into_dart()].into_dart()
5911            }
5912            _ => {
5913                unimplemented!("");
5914            }
5915        }
5916    }
5917}
5918impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5919    for crate::bindings::duplicates::LnUrlCallbackStatus
5920{
5921}
5922impl flutter_rust_bridge::IntoIntoDart<crate::bindings::duplicates::LnUrlCallbackStatus>
5923    for crate::bindings::duplicates::LnUrlCallbackStatus
5924{
5925    fn into_into_dart(self) -> crate::bindings::duplicates::LnUrlCallbackStatus {
5926        self
5927    }
5928}
5929// Codec=Dco (DartCObject based), see doc to use other codecs
5930impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LnUrlErrorData> {
5931    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5932        [self.0.reason.into_into_dart().into_dart()].into_dart()
5933    }
5934}
5935impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5936    for FrbWrapper<crate::bindings::LnUrlErrorData>
5937{
5938}
5939impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LnUrlErrorData>>
5940    for crate::bindings::LnUrlErrorData
5941{
5942    fn into_into_dart(self) -> FrbWrapper<crate::bindings::LnUrlErrorData> {
5943        self.into()
5944    }
5945}
5946// Codec=Dco (DartCObject based), see doc to use other codecs
5947impl flutter_rust_bridge::IntoDart for crate::model::LnUrlInfo {
5948    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5949        [
5950            self.ln_address.into_into_dart().into_dart(),
5951            self.lnurl_pay_comment.into_into_dart().into_dart(),
5952            self.lnurl_pay_domain.into_into_dart().into_dart(),
5953            self.lnurl_pay_metadata.into_into_dart().into_dart(),
5954            self.lnurl_pay_success_action.into_into_dart().into_dart(),
5955            self.lnurl_pay_unprocessed_success_action
5956                .into_into_dart()
5957                .into_dart(),
5958            self.lnurl_withdraw_endpoint.into_into_dart().into_dart(),
5959        ]
5960        .into_dart()
5961    }
5962}
5963impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::LnUrlInfo {}
5964impl flutter_rust_bridge::IntoIntoDart<crate::model::LnUrlInfo> for crate::model::LnUrlInfo {
5965    fn into_into_dart(self) -> crate::model::LnUrlInfo {
5966        self
5967    }
5968}
5969// Codec=Dco (DartCObject based), see doc to use other codecs
5970impl flutter_rust_bridge::IntoDart for crate::bindings::duplicates::LnUrlPayError {
5971    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5972        match self {
5973            crate::bindings::duplicates::LnUrlPayError::AlreadyPaid => [0.into_dart()].into_dart(),
5974            crate::bindings::duplicates::LnUrlPayError::Generic { err } => {
5975                [1.into_dart(), err.into_into_dart().into_dart()].into_dart()
5976            }
5977            crate::bindings::duplicates::LnUrlPayError::InsufficientBalance { err } => {
5978                [2.into_dart(), err.into_into_dart().into_dart()].into_dart()
5979            }
5980            crate::bindings::duplicates::LnUrlPayError::InvalidAmount { err } => {
5981                [3.into_dart(), err.into_into_dart().into_dart()].into_dart()
5982            }
5983            crate::bindings::duplicates::LnUrlPayError::InvalidInvoice { err } => {
5984                [4.into_dart(), err.into_into_dart().into_dart()].into_dart()
5985            }
5986            crate::bindings::duplicates::LnUrlPayError::InvalidNetwork { err } => {
5987                [5.into_dart(), err.into_into_dart().into_dart()].into_dart()
5988            }
5989            crate::bindings::duplicates::LnUrlPayError::InvalidUri { err } => {
5990                [6.into_dart(), err.into_into_dart().into_dart()].into_dart()
5991            }
5992            crate::bindings::duplicates::LnUrlPayError::InvoiceExpired { err } => {
5993                [7.into_dart(), err.into_into_dart().into_dart()].into_dart()
5994            }
5995            crate::bindings::duplicates::LnUrlPayError::PaymentFailed { err } => {
5996                [8.into_dart(), err.into_into_dart().into_dart()].into_dart()
5997            }
5998            crate::bindings::duplicates::LnUrlPayError::PaymentTimeout { err } => {
5999                [9.into_dart(), err.into_into_dart().into_dart()].into_dart()
6000            }
6001            crate::bindings::duplicates::LnUrlPayError::RouteNotFound { err } => {
6002                [10.into_dart(), err.into_into_dart().into_dart()].into_dart()
6003            }
6004            crate::bindings::duplicates::LnUrlPayError::RouteTooExpensive { err } => {
6005                [11.into_dart(), err.into_into_dart().into_dart()].into_dart()
6006            }
6007            crate::bindings::duplicates::LnUrlPayError::ServiceConnectivity { err } => {
6008                [12.into_dart(), err.into_into_dart().into_dart()].into_dart()
6009            }
6010            _ => {
6011                unimplemented!("");
6012            }
6013        }
6014    }
6015}
6016impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6017    for crate::bindings::duplicates::LnUrlPayError
6018{
6019}
6020impl flutter_rust_bridge::IntoIntoDart<crate::bindings::duplicates::LnUrlPayError>
6021    for crate::bindings::duplicates::LnUrlPayError
6022{
6023    fn into_into_dart(self) -> crate::bindings::duplicates::LnUrlPayError {
6024        self
6025    }
6026}
6027// Codec=Dco (DartCObject based), see doc to use other codecs
6028impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LnUrlPayErrorData> {
6029    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6030        [
6031            self.0.payment_hash.into_into_dart().into_dart(),
6032            self.0.reason.into_into_dart().into_dart(),
6033        ]
6034        .into_dart()
6035    }
6036}
6037impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6038    for FrbWrapper<crate::bindings::LnUrlPayErrorData>
6039{
6040}
6041impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LnUrlPayErrorData>>
6042    for crate::bindings::LnUrlPayErrorData
6043{
6044    fn into_into_dart(self) -> FrbWrapper<crate::bindings::LnUrlPayErrorData> {
6045        self.into()
6046    }
6047}
6048// Codec=Dco (DartCObject based), see doc to use other codecs
6049impl flutter_rust_bridge::IntoDart for crate::model::LnUrlPayRequest {
6050    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6051        [self.prepare_response.into_into_dart().into_dart()].into_dart()
6052    }
6053}
6054impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::LnUrlPayRequest {}
6055impl flutter_rust_bridge::IntoIntoDart<crate::model::LnUrlPayRequest>
6056    for crate::model::LnUrlPayRequest
6057{
6058    fn into_into_dart(self) -> crate::model::LnUrlPayRequest {
6059        self
6060    }
6061}
6062// Codec=Dco (DartCObject based), see doc to use other codecs
6063impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LnUrlPayRequestData> {
6064    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6065        [
6066            self.0.callback.into_into_dart().into_dart(),
6067            self.0.min_sendable.into_into_dart().into_dart(),
6068            self.0.max_sendable.into_into_dart().into_dart(),
6069            self.0.metadata_str.into_into_dart().into_dart(),
6070            self.0.comment_allowed.into_into_dart().into_dart(),
6071            self.0.domain.into_into_dart().into_dart(),
6072            self.0.allows_nostr.into_into_dart().into_dart(),
6073            self.0.nostr_pubkey.into_into_dart().into_dart(),
6074            self.0.ln_address.into_into_dart().into_dart(),
6075        ]
6076        .into_dart()
6077    }
6078}
6079impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6080    for FrbWrapper<crate::bindings::LnUrlPayRequestData>
6081{
6082}
6083impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LnUrlPayRequestData>>
6084    for crate::bindings::LnUrlPayRequestData
6085{
6086    fn into_into_dart(self) -> FrbWrapper<crate::bindings::LnUrlPayRequestData> {
6087        self.into()
6088    }
6089}
6090// Codec=Dco (DartCObject based), see doc to use other codecs
6091impl flutter_rust_bridge::IntoDart for crate::model::LnUrlPayResult {
6092    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6093        match self {
6094            crate::model::LnUrlPayResult::EndpointSuccess { data } => {
6095                [0.into_dart(), data.into_into_dart().into_dart()].into_dart()
6096            }
6097            crate::model::LnUrlPayResult::EndpointError { data } => {
6098                [1.into_dart(), data.into_into_dart().into_dart()].into_dart()
6099            }
6100            crate::model::LnUrlPayResult::PayError { data } => {
6101                [2.into_dart(), data.into_into_dart().into_dart()].into_dart()
6102            }
6103            _ => {
6104                unimplemented!("");
6105            }
6106        }
6107    }
6108}
6109impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::LnUrlPayResult {}
6110impl flutter_rust_bridge::IntoIntoDart<crate::model::LnUrlPayResult>
6111    for crate::model::LnUrlPayResult
6112{
6113    fn into_into_dart(self) -> crate::model::LnUrlPayResult {
6114        self
6115    }
6116}
6117// Codec=Dco (DartCObject based), see doc to use other codecs
6118impl flutter_rust_bridge::IntoDart for crate::model::LnUrlPaySuccessData {
6119    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6120        [
6121            self.payment.into_into_dart().into_dart(),
6122            self.success_action.into_into_dart().into_dart(),
6123        ]
6124        .into_dart()
6125    }
6126}
6127impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6128    for crate::model::LnUrlPaySuccessData
6129{
6130}
6131impl flutter_rust_bridge::IntoIntoDart<crate::model::LnUrlPaySuccessData>
6132    for crate::model::LnUrlPaySuccessData
6133{
6134    fn into_into_dart(self) -> crate::model::LnUrlPaySuccessData {
6135        self
6136    }
6137}
6138// Codec=Dco (DartCObject based), see doc to use other codecs
6139impl flutter_rust_bridge::IntoDart for crate::bindings::duplicates::LnUrlWithdrawError {
6140    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6141        match self {
6142            crate::bindings::duplicates::LnUrlWithdrawError::Generic { err } => {
6143                [0.into_dart(), err.into_into_dart().into_dart()].into_dart()
6144            }
6145            crate::bindings::duplicates::LnUrlWithdrawError::InvalidAmount { err } => {
6146                [1.into_dart(), err.into_into_dart().into_dart()].into_dart()
6147            }
6148            crate::bindings::duplicates::LnUrlWithdrawError::InvalidInvoice { err } => {
6149                [2.into_dart(), err.into_into_dart().into_dart()].into_dart()
6150            }
6151            crate::bindings::duplicates::LnUrlWithdrawError::InvalidUri { err } => {
6152                [3.into_dart(), err.into_into_dart().into_dart()].into_dart()
6153            }
6154            crate::bindings::duplicates::LnUrlWithdrawError::InvoiceNoRoutingHints { err } => {
6155                [4.into_dart(), err.into_into_dart().into_dart()].into_dart()
6156            }
6157            crate::bindings::duplicates::LnUrlWithdrawError::ServiceConnectivity { err } => {
6158                [5.into_dart(), err.into_into_dart().into_dart()].into_dart()
6159            }
6160            _ => {
6161                unimplemented!("");
6162            }
6163        }
6164    }
6165}
6166impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6167    for crate::bindings::duplicates::LnUrlWithdrawError
6168{
6169}
6170impl flutter_rust_bridge::IntoIntoDart<crate::bindings::duplicates::LnUrlWithdrawError>
6171    for crate::bindings::duplicates::LnUrlWithdrawError
6172{
6173    fn into_into_dart(self) -> crate::bindings::duplicates::LnUrlWithdrawError {
6174        self
6175    }
6176}
6177// Codec=Dco (DartCObject based), see doc to use other codecs
6178impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LnUrlWithdrawRequest> {
6179    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6180        [
6181            self.0.data.into_into_dart().into_dart(),
6182            self.0.amount_msat.into_into_dart().into_dart(),
6183            self.0.description.into_into_dart().into_dart(),
6184        ]
6185        .into_dart()
6186    }
6187}
6188impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6189    for FrbWrapper<crate::bindings::LnUrlWithdrawRequest>
6190{
6191}
6192impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LnUrlWithdrawRequest>>
6193    for crate::bindings::LnUrlWithdrawRequest
6194{
6195    fn into_into_dart(self) -> FrbWrapper<crate::bindings::LnUrlWithdrawRequest> {
6196        self.into()
6197    }
6198}
6199// Codec=Dco (DartCObject based), see doc to use other codecs
6200impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LnUrlWithdrawRequestData> {
6201    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6202        [
6203            self.0.callback.into_into_dart().into_dart(),
6204            self.0.k1.into_into_dart().into_dart(),
6205            self.0.default_description.into_into_dart().into_dart(),
6206            self.0.min_withdrawable.into_into_dart().into_dart(),
6207            self.0.max_withdrawable.into_into_dart().into_dart(),
6208        ]
6209        .into_dart()
6210    }
6211}
6212impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6213    for FrbWrapper<crate::bindings::LnUrlWithdrawRequestData>
6214{
6215}
6216impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LnUrlWithdrawRequestData>>
6217    for crate::bindings::LnUrlWithdrawRequestData
6218{
6219    fn into_into_dart(self) -> FrbWrapper<crate::bindings::LnUrlWithdrawRequestData> {
6220        self.into()
6221    }
6222}
6223// Codec=Dco (DartCObject based), see doc to use other codecs
6224impl flutter_rust_bridge::IntoDart for crate::bindings::duplicates::LnUrlWithdrawResult {
6225    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6226        match self {
6227            crate::bindings::duplicates::LnUrlWithdrawResult::Ok { data } => {
6228                [0.into_dart(), data.into_into_dart().into_dart()].into_dart()
6229            }
6230            crate::bindings::duplicates::LnUrlWithdrawResult::Timeout { data } => {
6231                [1.into_dart(), data.into_into_dart().into_dart()].into_dart()
6232            }
6233            crate::bindings::duplicates::LnUrlWithdrawResult::ErrorStatus { data } => {
6234                [2.into_dart(), data.into_into_dart().into_dart()].into_dart()
6235            }
6236            _ => {
6237                unimplemented!("");
6238            }
6239        }
6240    }
6241}
6242impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6243    for crate::bindings::duplicates::LnUrlWithdrawResult
6244{
6245}
6246impl flutter_rust_bridge::IntoIntoDart<crate::bindings::duplicates::LnUrlWithdrawResult>
6247    for crate::bindings::duplicates::LnUrlWithdrawResult
6248{
6249    fn into_into_dart(self) -> crate::bindings::duplicates::LnUrlWithdrawResult {
6250        self
6251    }
6252}
6253// Codec=Dco (DartCObject based), see doc to use other codecs
6254impl flutter_rust_bridge::IntoDart for crate::bindings::duplicates::LnUrlWithdrawSuccessData {
6255    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6256        [self.invoice.into_into_dart().into_dart()].into_dart()
6257    }
6258}
6259impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6260    for crate::bindings::duplicates::LnUrlWithdrawSuccessData
6261{
6262}
6263impl flutter_rust_bridge::IntoIntoDart<crate::bindings::duplicates::LnUrlWithdrawSuccessData>
6264    for crate::bindings::duplicates::LnUrlWithdrawSuccessData
6265{
6266    fn into_into_dart(self) -> crate::bindings::duplicates::LnUrlWithdrawSuccessData {
6267        self
6268    }
6269}
6270// Codec=Dco (DartCObject based), see doc to use other codecs
6271impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LocaleOverrides> {
6272    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6273        [
6274            self.0.locale.into_into_dart().into_dart(),
6275            self.0.spacing.into_into_dart().into_dart(),
6276            self.0.symbol.into_into_dart().into_dart(),
6277        ]
6278        .into_dart()
6279    }
6280}
6281impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6282    for FrbWrapper<crate::bindings::LocaleOverrides>
6283{
6284}
6285impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LocaleOverrides>>
6286    for crate::bindings::LocaleOverrides
6287{
6288    fn into_into_dart(self) -> FrbWrapper<crate::bindings::LocaleOverrides> {
6289        self.into()
6290    }
6291}
6292// Codec=Dco (DartCObject based), see doc to use other codecs
6293impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LocalizedName> {
6294    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6295        [
6296            self.0.locale.into_into_dart().into_dart(),
6297            self.0.name.into_into_dart().into_dart(),
6298        ]
6299        .into_dart()
6300    }
6301}
6302impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6303    for FrbWrapper<crate::bindings::LocalizedName>
6304{
6305}
6306impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LocalizedName>>
6307    for crate::bindings::LocalizedName
6308{
6309    fn into_into_dart(self) -> FrbWrapper<crate::bindings::LocalizedName> {
6310        self.into()
6311    }
6312}
6313// Codec=Dco (DartCObject based), see doc to use other codecs
6314impl flutter_rust_bridge::IntoDart for crate::model::LogEntry {
6315    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6316        [
6317            self.line.into_into_dart().into_dart(),
6318            self.level.into_into_dart().into_dart(),
6319        ]
6320        .into_dart()
6321    }
6322}
6323impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::LogEntry {}
6324impl flutter_rust_bridge::IntoIntoDart<crate::model::LogEntry> for crate::model::LogEntry {
6325    fn into_into_dart(self) -> crate::model::LogEntry {
6326        self
6327    }
6328}
6329// Codec=Dco (DartCObject based), see doc to use other codecs
6330impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::MessageSuccessActionData> {
6331    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6332        [self.0.message.into_into_dart().into_dart()].into_dart()
6333    }
6334}
6335impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6336    for FrbWrapper<crate::bindings::MessageSuccessActionData>
6337{
6338}
6339impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::MessageSuccessActionData>>
6340    for crate::bindings::MessageSuccessActionData
6341{
6342    fn into_into_dart(self) -> FrbWrapper<crate::bindings::MessageSuccessActionData> {
6343        self.into()
6344    }
6345}
6346// Codec=Dco (DartCObject based), see doc to use other codecs
6347impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::Network> {
6348    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6349        match self.0 {
6350            crate::bindings::Network::Bitcoin => 0.into_dart(),
6351            crate::bindings::Network::Testnet => 1.into_dart(),
6352            crate::bindings::Network::Signet => 2.into_dart(),
6353            crate::bindings::Network::Regtest => 3.into_dart(),
6354            _ => unreachable!(),
6355        }
6356    }
6357}
6358impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6359    for FrbWrapper<crate::bindings::Network>
6360{
6361}
6362impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::Network>>
6363    for crate::bindings::Network
6364{
6365    fn into_into_dart(self) -> FrbWrapper<crate::bindings::Network> {
6366        self.into()
6367    }
6368}
6369// Codec=Dco (DartCObject based), see doc to use other codecs
6370impl flutter_rust_bridge::IntoDart for crate::model::OnchainPaymentLimitsResponse {
6371    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6372        [
6373            self.send.into_into_dart().into_dart(),
6374            self.receive.into_into_dart().into_dart(),
6375        ]
6376        .into_dart()
6377    }
6378}
6379impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6380    for crate::model::OnchainPaymentLimitsResponse
6381{
6382}
6383impl flutter_rust_bridge::IntoIntoDart<crate::model::OnchainPaymentLimitsResponse>
6384    for crate::model::OnchainPaymentLimitsResponse
6385{
6386    fn into_into_dart(self) -> crate::model::OnchainPaymentLimitsResponse {
6387        self
6388    }
6389}
6390// Codec=Dco (DartCObject based), see doc to use other codecs
6391impl flutter_rust_bridge::IntoDart for crate::model::PayAmount {
6392    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6393        match self {
6394            crate::model::PayAmount::Bitcoin {
6395                receiver_amount_sat,
6396            } => [
6397                0.into_dart(),
6398                receiver_amount_sat.into_into_dart().into_dart(),
6399            ]
6400            .into_dart(),
6401            crate::model::PayAmount::Asset {
6402                asset_id,
6403                receiver_amount,
6404                estimate_asset_fees,
6405            } => [
6406                1.into_dart(),
6407                asset_id.into_into_dart().into_dart(),
6408                receiver_amount.into_into_dart().into_dart(),
6409                estimate_asset_fees.into_into_dart().into_dart(),
6410            ]
6411            .into_dart(),
6412            crate::model::PayAmount::Drain => [2.into_dart()].into_dart(),
6413            _ => {
6414                unimplemented!("");
6415            }
6416        }
6417    }
6418}
6419impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::PayAmount {}
6420impl flutter_rust_bridge::IntoIntoDart<crate::model::PayAmount> for crate::model::PayAmount {
6421    fn into_into_dart(self) -> crate::model::PayAmount {
6422        self
6423    }
6424}
6425// Codec=Dco (DartCObject based), see doc to use other codecs
6426impl flutter_rust_bridge::IntoDart for crate::model::PayOnchainRequest {
6427    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6428        [
6429            self.address.into_into_dart().into_dart(),
6430            self.prepare_response.into_into_dart().into_dart(),
6431        ]
6432        .into_dart()
6433    }
6434}
6435impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6436    for crate::model::PayOnchainRequest
6437{
6438}
6439impl flutter_rust_bridge::IntoIntoDart<crate::model::PayOnchainRequest>
6440    for crate::model::PayOnchainRequest
6441{
6442    fn into_into_dart(self) -> crate::model::PayOnchainRequest {
6443        self
6444    }
6445}
6446// Codec=Dco (DartCObject based), see doc to use other codecs
6447impl flutter_rust_bridge::IntoDart for crate::model::Payment {
6448    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6449        [
6450            self.destination.into_into_dart().into_dart(),
6451            self.tx_id.into_into_dart().into_dart(),
6452            self.unblinding_data.into_into_dart().into_dart(),
6453            self.timestamp.into_into_dart().into_dart(),
6454            self.amount_sat.into_into_dart().into_dart(),
6455            self.fees_sat.into_into_dart().into_dart(),
6456            self.swapper_fees_sat.into_into_dart().into_dart(),
6457            self.payment_type.into_into_dart().into_dart(),
6458            self.status.into_into_dart().into_dart(),
6459            self.details.into_into_dart().into_dart(),
6460        ]
6461        .into_dart()
6462    }
6463}
6464impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::Payment {}
6465impl flutter_rust_bridge::IntoIntoDart<crate::model::Payment> for crate::model::Payment {
6466    fn into_into_dart(self) -> crate::model::Payment {
6467        self
6468    }
6469}
6470// Codec=Dco (DartCObject based), see doc to use other codecs
6471impl flutter_rust_bridge::IntoDart for crate::model::PaymentDetails {
6472    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6473        match self {
6474            crate::model::PaymentDetails::Lightning {
6475                swap_id,
6476                description,
6477                liquid_expiration_blockheight,
6478                preimage,
6479                invoice,
6480                bolt12_offer,
6481                payment_hash,
6482                destination_pubkey,
6483                lnurl_info,
6484                bip353_address,
6485                payer_note,
6486                claim_tx_id,
6487                refund_tx_id,
6488                refund_tx_amount_sat,
6489            } => [
6490                0.into_dart(),
6491                swap_id.into_into_dart().into_dart(),
6492                description.into_into_dart().into_dart(),
6493                liquid_expiration_blockheight.into_into_dart().into_dart(),
6494                preimage.into_into_dart().into_dart(),
6495                invoice.into_into_dart().into_dart(),
6496                bolt12_offer.into_into_dart().into_dart(),
6497                payment_hash.into_into_dart().into_dart(),
6498                destination_pubkey.into_into_dart().into_dart(),
6499                lnurl_info.into_into_dart().into_dart(),
6500                bip353_address.into_into_dart().into_dart(),
6501                payer_note.into_into_dart().into_dart(),
6502                claim_tx_id.into_into_dart().into_dart(),
6503                refund_tx_id.into_into_dart().into_dart(),
6504                refund_tx_amount_sat.into_into_dart().into_dart(),
6505            ]
6506            .into_dart(),
6507            crate::model::PaymentDetails::Liquid {
6508                destination,
6509                description,
6510                asset_id,
6511                asset_info,
6512                lnurl_info,
6513                bip353_address,
6514                payer_note,
6515            } => [
6516                1.into_dart(),
6517                destination.into_into_dart().into_dart(),
6518                description.into_into_dart().into_dart(),
6519                asset_id.into_into_dart().into_dart(),
6520                asset_info.into_into_dart().into_dart(),
6521                lnurl_info.into_into_dart().into_dart(),
6522                bip353_address.into_into_dart().into_dart(),
6523                payer_note.into_into_dart().into_dart(),
6524            ]
6525            .into_dart(),
6526            crate::model::PaymentDetails::Bitcoin {
6527                swap_id,
6528                bitcoin_address,
6529                description,
6530                auto_accepted_fees,
6531                liquid_expiration_blockheight,
6532                bitcoin_expiration_blockheight,
6533                lockup_tx_id,
6534                claim_tx_id,
6535                refund_tx_id,
6536                refund_tx_amount_sat,
6537            } => [
6538                2.into_dart(),
6539                swap_id.into_into_dart().into_dart(),
6540                bitcoin_address.into_into_dart().into_dart(),
6541                description.into_into_dart().into_dart(),
6542                auto_accepted_fees.into_into_dart().into_dart(),
6543                liquid_expiration_blockheight.into_into_dart().into_dart(),
6544                bitcoin_expiration_blockheight.into_into_dart().into_dart(),
6545                lockup_tx_id.into_into_dart().into_dart(),
6546                claim_tx_id.into_into_dart().into_dart(),
6547                refund_tx_id.into_into_dart().into_dart(),
6548                refund_tx_amount_sat.into_into_dart().into_dart(),
6549            ]
6550            .into_dart(),
6551            _ => {
6552                unimplemented!("");
6553            }
6554        }
6555    }
6556}
6557impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::PaymentDetails {}
6558impl flutter_rust_bridge::IntoIntoDart<crate::model::PaymentDetails>
6559    for crate::model::PaymentDetails
6560{
6561    fn into_into_dart(self) -> crate::model::PaymentDetails {
6562        self
6563    }
6564}
6565// Codec=Dco (DartCObject based), see doc to use other codecs
6566impl flutter_rust_bridge::IntoDart for crate::error::PaymentError {
6567    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6568        match self {
6569            crate::error::PaymentError::AlreadyClaimed => [0.into_dart()].into_dart(),
6570            crate::error::PaymentError::AlreadyPaid => [1.into_dart()].into_dart(),
6571            crate::error::PaymentError::PaymentInProgress => [2.into_dart()].into_dart(),
6572            crate::error::PaymentError::AmountOutOfRange { min, max } => [
6573                3.into_dart(),
6574                min.into_into_dart().into_dart(),
6575                max.into_into_dart().into_dart(),
6576            ]
6577            .into_dart(),
6578            crate::error::PaymentError::AmountMissing { err } => {
6579                [4.into_dart(), err.into_into_dart().into_dart()].into_dart()
6580            }
6581            crate::error::PaymentError::AssetError { err } => {
6582                [5.into_dart(), err.into_into_dart().into_dart()].into_dart()
6583            }
6584            crate::error::PaymentError::InvalidNetwork { err } => {
6585                [6.into_dart(), err.into_into_dart().into_dart()].into_dart()
6586            }
6587            crate::error::PaymentError::Generic { err } => {
6588                [7.into_dart(), err.into_into_dart().into_dart()].into_dart()
6589            }
6590            crate::error::PaymentError::InvalidOrExpiredFees => [8.into_dart()].into_dart(),
6591            crate::error::PaymentError::InsufficientFunds => [9.into_dart()].into_dart(),
6592            crate::error::PaymentError::InvalidDescription { err } => {
6593                [10.into_dart(), err.into_into_dart().into_dart()].into_dart()
6594            }
6595            crate::error::PaymentError::InvalidInvoice { err } => {
6596                [11.into_dart(), err.into_into_dart().into_dart()].into_dart()
6597            }
6598            crate::error::PaymentError::InvalidPreimage => [12.into_dart()].into_dart(),
6599            crate::error::PaymentError::PairsNotFound => [13.into_dart()].into_dart(),
6600            crate::error::PaymentError::PaymentTimeout => [14.into_dart()].into_dart(),
6601            crate::error::PaymentError::PersistError => [15.into_dart()].into_dart(),
6602            crate::error::PaymentError::ReceiveError { err } => {
6603                [16.into_dart(), err.into_into_dart().into_dart()].into_dart()
6604            }
6605            crate::error::PaymentError::Refunded { err, refund_tx_id } => [
6606                17.into_dart(),
6607                err.into_into_dart().into_dart(),
6608                refund_tx_id.into_into_dart().into_dart(),
6609            ]
6610            .into_dart(),
6611            crate::error::PaymentError::SelfTransferNotSupported => [18.into_dart()].into_dart(),
6612            crate::error::PaymentError::SendError { err } => {
6613                [19.into_dart(), err.into_into_dart().into_dart()].into_dart()
6614            }
6615            crate::error::PaymentError::SignerError { err } => {
6616                [20.into_dart(), err.into_into_dart().into_dart()].into_dart()
6617            }
6618            _ => {
6619                unimplemented!("");
6620            }
6621        }
6622    }
6623}
6624impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::error::PaymentError {}
6625impl flutter_rust_bridge::IntoIntoDart<crate::error::PaymentError> for crate::error::PaymentError {
6626    fn into_into_dart(self) -> crate::error::PaymentError {
6627        self
6628    }
6629}
6630// Codec=Dco (DartCObject based), see doc to use other codecs
6631impl flutter_rust_bridge::IntoDart for crate::model::PaymentMethod {
6632    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6633        match self {
6634            Self::Lightning => 0.into_dart(),
6635            Self::Bolt11Invoice => 1.into_dart(),
6636            Self::Bolt12Offer => 2.into_dart(),
6637            Self::BitcoinAddress => 3.into_dart(),
6638            Self::LiquidAddress => 4.into_dart(),
6639            _ => unreachable!(),
6640        }
6641    }
6642}
6643impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::PaymentMethod {}
6644impl flutter_rust_bridge::IntoIntoDart<crate::model::PaymentMethod>
6645    for crate::model::PaymentMethod
6646{
6647    fn into_into_dart(self) -> crate::model::PaymentMethod {
6648        self
6649    }
6650}
6651// Codec=Dco (DartCObject based), see doc to use other codecs
6652impl flutter_rust_bridge::IntoDart for crate::model::PaymentState {
6653    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6654        match self {
6655            Self::Created => 0.into_dart(),
6656            Self::Pending => 1.into_dart(),
6657            Self::Complete => 2.into_dart(),
6658            Self::Failed => 3.into_dart(),
6659            Self::TimedOut => 4.into_dart(),
6660            Self::Refundable => 5.into_dart(),
6661            Self::RefundPending => 6.into_dart(),
6662            Self::WaitingFeeAcceptance => 7.into_dart(),
6663            _ => unreachable!(),
6664        }
6665    }
6666}
6667impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::PaymentState {}
6668impl flutter_rust_bridge::IntoIntoDart<crate::model::PaymentState> for crate::model::PaymentState {
6669    fn into_into_dart(self) -> crate::model::PaymentState {
6670        self
6671    }
6672}
6673// Codec=Dco (DartCObject based), see doc to use other codecs
6674impl flutter_rust_bridge::IntoDart for crate::model::PaymentType {
6675    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6676        match self {
6677            Self::Receive => 0.into_dart(),
6678            Self::Send => 1.into_dart(),
6679            _ => unreachable!(),
6680        }
6681    }
6682}
6683impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::PaymentType {}
6684impl flutter_rust_bridge::IntoIntoDart<crate::model::PaymentType> for crate::model::PaymentType {
6685    fn into_into_dart(self) -> crate::model::PaymentType {
6686        self
6687    }
6688}
6689// Codec=Dco (DartCObject based), see doc to use other codecs
6690impl flutter_rust_bridge::IntoDart for crate::model::PrepareBuyBitcoinRequest {
6691    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6692        [
6693            self.provider.into_into_dart().into_dart(),
6694            self.amount_sat.into_into_dart().into_dart(),
6695        ]
6696        .into_dart()
6697    }
6698}
6699impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6700    for crate::model::PrepareBuyBitcoinRequest
6701{
6702}
6703impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareBuyBitcoinRequest>
6704    for crate::model::PrepareBuyBitcoinRequest
6705{
6706    fn into_into_dart(self) -> crate::model::PrepareBuyBitcoinRequest {
6707        self
6708    }
6709}
6710// Codec=Dco (DartCObject based), see doc to use other codecs
6711impl flutter_rust_bridge::IntoDart for crate::model::PrepareBuyBitcoinResponse {
6712    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6713        [
6714            self.provider.into_into_dart().into_dart(),
6715            self.amount_sat.into_into_dart().into_dart(),
6716            self.fees_sat.into_into_dart().into_dart(),
6717        ]
6718        .into_dart()
6719    }
6720}
6721impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6722    for crate::model::PrepareBuyBitcoinResponse
6723{
6724}
6725impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareBuyBitcoinResponse>
6726    for crate::model::PrepareBuyBitcoinResponse
6727{
6728    fn into_into_dart(self) -> crate::model::PrepareBuyBitcoinResponse {
6729        self
6730    }
6731}
6732// Codec=Dco (DartCObject based), see doc to use other codecs
6733impl flutter_rust_bridge::IntoDart for crate::model::PrepareLnUrlPayRequest {
6734    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6735        [
6736            self.data.into_into_dart().into_dart(),
6737            self.amount.into_into_dart().into_dart(),
6738            self.bip353_address.into_into_dart().into_dart(),
6739            self.comment.into_into_dart().into_dart(),
6740            self.validate_success_action_url
6741                .into_into_dart()
6742                .into_dart(),
6743        ]
6744        .into_dart()
6745    }
6746}
6747impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6748    for crate::model::PrepareLnUrlPayRequest
6749{
6750}
6751impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareLnUrlPayRequest>
6752    for crate::model::PrepareLnUrlPayRequest
6753{
6754    fn into_into_dart(self) -> crate::model::PrepareLnUrlPayRequest {
6755        self
6756    }
6757}
6758// Codec=Dco (DartCObject based), see doc to use other codecs
6759impl flutter_rust_bridge::IntoDart for crate::model::PrepareLnUrlPayResponse {
6760    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6761        [
6762            self.destination.into_into_dart().into_dart(),
6763            self.fees_sat.into_into_dart().into_dart(),
6764            self.data.into_into_dart().into_dart(),
6765            self.amount.into_into_dart().into_dart(),
6766            self.comment.into_into_dart().into_dart(),
6767            self.success_action.into_into_dart().into_dart(),
6768        ]
6769        .into_dart()
6770    }
6771}
6772impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6773    for crate::model::PrepareLnUrlPayResponse
6774{
6775}
6776impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareLnUrlPayResponse>
6777    for crate::model::PrepareLnUrlPayResponse
6778{
6779    fn into_into_dart(self) -> crate::model::PrepareLnUrlPayResponse {
6780        self
6781    }
6782}
6783// Codec=Dco (DartCObject based), see doc to use other codecs
6784impl flutter_rust_bridge::IntoDart for crate::model::PreparePayOnchainRequest {
6785    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6786        [
6787            self.amount.into_into_dart().into_dart(),
6788            self.fee_rate_sat_per_vbyte.into_into_dart().into_dart(),
6789        ]
6790        .into_dart()
6791    }
6792}
6793impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6794    for crate::model::PreparePayOnchainRequest
6795{
6796}
6797impl flutter_rust_bridge::IntoIntoDart<crate::model::PreparePayOnchainRequest>
6798    for crate::model::PreparePayOnchainRequest
6799{
6800    fn into_into_dart(self) -> crate::model::PreparePayOnchainRequest {
6801        self
6802    }
6803}
6804// Codec=Dco (DartCObject based), see doc to use other codecs
6805impl flutter_rust_bridge::IntoDart for crate::model::PreparePayOnchainResponse {
6806    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6807        [
6808            self.receiver_amount_sat.into_into_dart().into_dart(),
6809            self.claim_fees_sat.into_into_dart().into_dart(),
6810            self.total_fees_sat.into_into_dart().into_dart(),
6811        ]
6812        .into_dart()
6813    }
6814}
6815impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6816    for crate::model::PreparePayOnchainResponse
6817{
6818}
6819impl flutter_rust_bridge::IntoIntoDart<crate::model::PreparePayOnchainResponse>
6820    for crate::model::PreparePayOnchainResponse
6821{
6822    fn into_into_dart(self) -> crate::model::PreparePayOnchainResponse {
6823        self
6824    }
6825}
6826// Codec=Dco (DartCObject based), see doc to use other codecs
6827impl flutter_rust_bridge::IntoDart for crate::model::PrepareReceiveRequest {
6828    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6829        [
6830            self.payment_method.into_into_dart().into_dart(),
6831            self.amount.into_into_dart().into_dart(),
6832        ]
6833        .into_dart()
6834    }
6835}
6836impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6837    for crate::model::PrepareReceiveRequest
6838{
6839}
6840impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareReceiveRequest>
6841    for crate::model::PrepareReceiveRequest
6842{
6843    fn into_into_dart(self) -> crate::model::PrepareReceiveRequest {
6844        self
6845    }
6846}
6847// Codec=Dco (DartCObject based), see doc to use other codecs
6848impl flutter_rust_bridge::IntoDart for crate::model::PrepareReceiveResponse {
6849    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6850        [
6851            self.payment_method.into_into_dart().into_dart(),
6852            self.fees_sat.into_into_dart().into_dart(),
6853            self.amount.into_into_dart().into_dart(),
6854            self.min_payer_amount_sat.into_into_dart().into_dart(),
6855            self.max_payer_amount_sat.into_into_dart().into_dart(),
6856            self.swapper_feerate.into_into_dart().into_dart(),
6857        ]
6858        .into_dart()
6859    }
6860}
6861impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6862    for crate::model::PrepareReceiveResponse
6863{
6864}
6865impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareReceiveResponse>
6866    for crate::model::PrepareReceiveResponse
6867{
6868    fn into_into_dart(self) -> crate::model::PrepareReceiveResponse {
6869        self
6870    }
6871}
6872// Codec=Dco (DartCObject based), see doc to use other codecs
6873impl flutter_rust_bridge::IntoDart for crate::model::PrepareRefundRequest {
6874    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6875        [
6876            self.swap_address.into_into_dart().into_dart(),
6877            self.refund_address.into_into_dart().into_dart(),
6878            self.fee_rate_sat_per_vbyte.into_into_dart().into_dart(),
6879        ]
6880        .into_dart()
6881    }
6882}
6883impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6884    for crate::model::PrepareRefundRequest
6885{
6886}
6887impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareRefundRequest>
6888    for crate::model::PrepareRefundRequest
6889{
6890    fn into_into_dart(self) -> crate::model::PrepareRefundRequest {
6891        self
6892    }
6893}
6894// Codec=Dco (DartCObject based), see doc to use other codecs
6895impl flutter_rust_bridge::IntoDart for crate::model::PrepareRefundResponse {
6896    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6897        [
6898            self.tx_vsize.into_into_dart().into_dart(),
6899            self.tx_fee_sat.into_into_dart().into_dart(),
6900            self.last_refund_tx_id.into_into_dart().into_dart(),
6901        ]
6902        .into_dart()
6903    }
6904}
6905impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6906    for crate::model::PrepareRefundResponse
6907{
6908}
6909impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareRefundResponse>
6910    for crate::model::PrepareRefundResponse
6911{
6912    fn into_into_dart(self) -> crate::model::PrepareRefundResponse {
6913        self
6914    }
6915}
6916// Codec=Dco (DartCObject based), see doc to use other codecs
6917impl flutter_rust_bridge::IntoDart for crate::model::PrepareSendRequest {
6918    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6919        [
6920            self.destination.into_into_dart().into_dart(),
6921            self.amount.into_into_dart().into_dart(),
6922        ]
6923        .into_dart()
6924    }
6925}
6926impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6927    for crate::model::PrepareSendRequest
6928{
6929}
6930impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareSendRequest>
6931    for crate::model::PrepareSendRequest
6932{
6933    fn into_into_dart(self) -> crate::model::PrepareSendRequest {
6934        self
6935    }
6936}
6937// Codec=Dco (DartCObject based), see doc to use other codecs
6938impl flutter_rust_bridge::IntoDart for crate::model::PrepareSendResponse {
6939    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6940        [
6941            self.destination.into_into_dart().into_dart(),
6942            self.amount.into_into_dart().into_dart(),
6943            self.fees_sat.into_into_dart().into_dart(),
6944            self.estimated_asset_fees.into_into_dart().into_dart(),
6945        ]
6946        .into_dart()
6947    }
6948}
6949impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6950    for crate::model::PrepareSendResponse
6951{
6952}
6953impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareSendResponse>
6954    for crate::model::PrepareSendResponse
6955{
6956    fn into_into_dart(self) -> crate::model::PrepareSendResponse {
6957        self
6958    }
6959}
6960// Codec=Dco (DartCObject based), see doc to use other codecs
6961impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::Rate> {
6962    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6963        [
6964            self.0.coin.into_into_dart().into_dart(),
6965            self.0.value.into_into_dart().into_dart(),
6966        ]
6967        .into_dart()
6968    }
6969}
6970impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6971    for FrbWrapper<crate::bindings::Rate>
6972{
6973}
6974impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::Rate>>
6975    for crate::bindings::Rate
6976{
6977    fn into_into_dart(self) -> FrbWrapper<crate::bindings::Rate> {
6978        self.into()
6979    }
6980}
6981// Codec=Dco (DartCObject based), see doc to use other codecs
6982impl flutter_rust_bridge::IntoDart for crate::model::ReceiveAmount {
6983    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6984        match self {
6985            crate::model::ReceiveAmount::Bitcoin { payer_amount_sat } => {
6986                [0.into_dart(), payer_amount_sat.into_into_dart().into_dart()].into_dart()
6987            }
6988            crate::model::ReceiveAmount::Asset {
6989                asset_id,
6990                payer_amount,
6991            } => [
6992                1.into_dart(),
6993                asset_id.into_into_dart().into_dart(),
6994                payer_amount.into_into_dart().into_dart(),
6995            ]
6996            .into_dart(),
6997            _ => {
6998                unimplemented!("");
6999            }
7000        }
7001    }
7002}
7003impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::ReceiveAmount {}
7004impl flutter_rust_bridge::IntoIntoDart<crate::model::ReceiveAmount>
7005    for crate::model::ReceiveAmount
7006{
7007    fn into_into_dart(self) -> crate::model::ReceiveAmount {
7008        self
7009    }
7010}
7011// Codec=Dco (DartCObject based), see doc to use other codecs
7012impl flutter_rust_bridge::IntoDart for crate::model::ReceivePaymentRequest {
7013    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7014        [
7015            self.prepare_response.into_into_dart().into_dart(),
7016            self.description.into_into_dart().into_dart(),
7017            self.use_description_hash.into_into_dart().into_dart(),
7018            self.payer_note.into_into_dart().into_dart(),
7019        ]
7020        .into_dart()
7021    }
7022}
7023impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7024    for crate::model::ReceivePaymentRequest
7025{
7026}
7027impl flutter_rust_bridge::IntoIntoDart<crate::model::ReceivePaymentRequest>
7028    for crate::model::ReceivePaymentRequest
7029{
7030    fn into_into_dart(self) -> crate::model::ReceivePaymentRequest {
7031        self
7032    }
7033}
7034// Codec=Dco (DartCObject based), see doc to use other codecs
7035impl flutter_rust_bridge::IntoDart for crate::model::ReceivePaymentResponse {
7036    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7037        [self.destination.into_into_dart().into_dart()].into_dart()
7038    }
7039}
7040impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7041    for crate::model::ReceivePaymentResponse
7042{
7043}
7044impl flutter_rust_bridge::IntoIntoDart<crate::model::ReceivePaymentResponse>
7045    for crate::model::ReceivePaymentResponse
7046{
7047    fn into_into_dart(self) -> crate::model::ReceivePaymentResponse {
7048        self
7049    }
7050}
7051// Codec=Dco (DartCObject based), see doc to use other codecs
7052impl flutter_rust_bridge::IntoDart for crate::model::RecommendedFees {
7053    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7054        [
7055            self.fastest_fee.into_into_dart().into_dart(),
7056            self.half_hour_fee.into_into_dart().into_dart(),
7057            self.hour_fee.into_into_dart().into_dart(),
7058            self.economy_fee.into_into_dart().into_dart(),
7059            self.minimum_fee.into_into_dart().into_dart(),
7060        ]
7061        .into_dart()
7062    }
7063}
7064impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::RecommendedFees {}
7065impl flutter_rust_bridge::IntoIntoDart<crate::model::RecommendedFees>
7066    for crate::model::RecommendedFees
7067{
7068    fn into_into_dart(self) -> crate::model::RecommendedFees {
7069        self
7070    }
7071}
7072// Codec=Dco (DartCObject based), see doc to use other codecs
7073impl flutter_rust_bridge::IntoDart for crate::model::RefundRequest {
7074    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7075        [
7076            self.swap_address.into_into_dart().into_dart(),
7077            self.refund_address.into_into_dart().into_dart(),
7078            self.fee_rate_sat_per_vbyte.into_into_dart().into_dart(),
7079        ]
7080        .into_dart()
7081    }
7082}
7083impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::RefundRequest {}
7084impl flutter_rust_bridge::IntoIntoDart<crate::model::RefundRequest>
7085    for crate::model::RefundRequest
7086{
7087    fn into_into_dart(self) -> crate::model::RefundRequest {
7088        self
7089    }
7090}
7091// Codec=Dco (DartCObject based), see doc to use other codecs
7092impl flutter_rust_bridge::IntoDart for crate::model::RefundResponse {
7093    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7094        [self.refund_tx_id.into_into_dart().into_dart()].into_dart()
7095    }
7096}
7097impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::RefundResponse {}
7098impl flutter_rust_bridge::IntoIntoDart<crate::model::RefundResponse>
7099    for crate::model::RefundResponse
7100{
7101    fn into_into_dart(self) -> crate::model::RefundResponse {
7102        self
7103    }
7104}
7105// Codec=Dco (DartCObject based), see doc to use other codecs
7106impl flutter_rust_bridge::IntoDart for crate::model::RefundableSwap {
7107    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7108        [
7109            self.swap_address.into_into_dart().into_dart(),
7110            self.timestamp.into_into_dart().into_dart(),
7111            self.amount_sat.into_into_dart().into_dart(),
7112            self.last_refund_tx_id.into_into_dart().into_dart(),
7113        ]
7114        .into_dart()
7115    }
7116}
7117impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::RefundableSwap {}
7118impl flutter_rust_bridge::IntoIntoDart<crate::model::RefundableSwap>
7119    for crate::model::RefundableSwap
7120{
7121    fn into_into_dart(self) -> crate::model::RefundableSwap {
7122        self
7123    }
7124}
7125// Codec=Dco (DartCObject based), see doc to use other codecs
7126impl flutter_rust_bridge::IntoDart for crate::model::RestoreRequest {
7127    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7128        [self.backup_path.into_into_dart().into_dart()].into_dart()
7129    }
7130}
7131impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::RestoreRequest {}
7132impl flutter_rust_bridge::IntoIntoDart<crate::model::RestoreRequest>
7133    for crate::model::RestoreRequest
7134{
7135    fn into_into_dart(self) -> crate::model::RestoreRequest {
7136        self
7137    }
7138}
7139// Codec=Dco (DartCObject based), see doc to use other codecs
7140impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::RouteHint> {
7141    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7142        [self.0.hops.into_into_dart().into_dart()].into_dart()
7143    }
7144}
7145impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7146    for FrbWrapper<crate::bindings::RouteHint>
7147{
7148}
7149impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::RouteHint>>
7150    for crate::bindings::RouteHint
7151{
7152    fn into_into_dart(self) -> FrbWrapper<crate::bindings::RouteHint> {
7153        self.into()
7154    }
7155}
7156// Codec=Dco (DartCObject based), see doc to use other codecs
7157impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::RouteHintHop> {
7158    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7159        [
7160            self.0.src_node_id.into_into_dart().into_dart(),
7161            self.0.short_channel_id.into_into_dart().into_dart(),
7162            self.0.fees_base_msat.into_into_dart().into_dart(),
7163            self.0
7164                .fees_proportional_millionths
7165                .into_into_dart()
7166                .into_dart(),
7167            self.0.cltv_expiry_delta.into_into_dart().into_dart(),
7168            self.0.htlc_minimum_msat.into_into_dart().into_dart(),
7169            self.0.htlc_maximum_msat.into_into_dart().into_dart(),
7170        ]
7171        .into_dart()
7172    }
7173}
7174impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7175    for FrbWrapper<crate::bindings::RouteHintHop>
7176{
7177}
7178impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::RouteHintHop>>
7179    for crate::bindings::RouteHintHop
7180{
7181    fn into_into_dart(self) -> FrbWrapper<crate::bindings::RouteHintHop> {
7182        self.into()
7183    }
7184}
7185// Codec=Dco (DartCObject based), see doc to use other codecs
7186impl flutter_rust_bridge::IntoDart for crate::error::SdkError {
7187    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7188        match self {
7189            crate::error::SdkError::AlreadyStarted => [0.into_dart()].into_dart(),
7190            crate::error::SdkError::Generic { err } => {
7191                [1.into_dart(), err.into_into_dart().into_dart()].into_dart()
7192            }
7193            crate::error::SdkError::NotStarted => [2.into_dart()].into_dart(),
7194            crate::error::SdkError::ServiceConnectivity { err } => {
7195                [3.into_dart(), err.into_into_dart().into_dart()].into_dart()
7196            }
7197            _ => {
7198                unimplemented!("");
7199            }
7200        }
7201    }
7202}
7203impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::error::SdkError {}
7204impl flutter_rust_bridge::IntoIntoDart<crate::error::SdkError> for crate::error::SdkError {
7205    fn into_into_dart(self) -> crate::error::SdkError {
7206        self
7207    }
7208}
7209// Codec=Dco (DartCObject based), see doc to use other codecs
7210impl flutter_rust_bridge::IntoDart for crate::model::SdkEvent {
7211    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7212        match self {
7213            crate::model::SdkEvent::PaymentFailed { details } => {
7214                [0.into_dart(), details.into_into_dart().into_dart()].into_dart()
7215            }
7216            crate::model::SdkEvent::PaymentPending { details } => {
7217                [1.into_dart(), details.into_into_dart().into_dart()].into_dart()
7218            }
7219            crate::model::SdkEvent::PaymentRefundable { details } => {
7220                [2.into_dart(), details.into_into_dart().into_dart()].into_dart()
7221            }
7222            crate::model::SdkEvent::PaymentRefunded { details } => {
7223                [3.into_dart(), details.into_into_dart().into_dart()].into_dart()
7224            }
7225            crate::model::SdkEvent::PaymentRefundPending { details } => {
7226                [4.into_dart(), details.into_into_dart().into_dart()].into_dart()
7227            }
7228            crate::model::SdkEvent::PaymentSucceeded { details } => {
7229                [5.into_dart(), details.into_into_dart().into_dart()].into_dart()
7230            }
7231            crate::model::SdkEvent::PaymentWaitingConfirmation { details } => {
7232                [6.into_dart(), details.into_into_dart().into_dart()].into_dart()
7233            }
7234            crate::model::SdkEvent::PaymentWaitingFeeAcceptance { details } => {
7235                [7.into_dart(), details.into_into_dart().into_dart()].into_dart()
7236            }
7237            crate::model::SdkEvent::Synced => [8.into_dart()].into_dart(),
7238            crate::model::SdkEvent::DataSynced {
7239                did_pull_new_records,
7240            } => [
7241                9.into_dart(),
7242                did_pull_new_records.into_into_dart().into_dart(),
7243            ]
7244            .into_dart(),
7245            _ => {
7246                unimplemented!("");
7247            }
7248        }
7249    }
7250}
7251impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::SdkEvent {}
7252impl flutter_rust_bridge::IntoIntoDart<crate::model::SdkEvent> for crate::model::SdkEvent {
7253    fn into_into_dart(self) -> crate::model::SdkEvent {
7254        self
7255    }
7256}
7257// Codec=Dco (DartCObject based), see doc to use other codecs
7258impl flutter_rust_bridge::IntoDart for crate::model::SendDestination {
7259    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7260        match self {
7261            crate::model::SendDestination::LiquidAddress {
7262                address_data,
7263                bip353_address,
7264            } => [
7265                0.into_dart(),
7266                address_data.into_into_dart().into_dart(),
7267                bip353_address.into_into_dart().into_dart(),
7268            ]
7269            .into_dart(),
7270            crate::model::SendDestination::Bolt11 {
7271                invoice,
7272                bip353_address,
7273            } => [
7274                1.into_dart(),
7275                invoice.into_into_dart().into_dart(),
7276                bip353_address.into_into_dart().into_dart(),
7277            ]
7278            .into_dart(),
7279            crate::model::SendDestination::Bolt12 {
7280                offer,
7281                receiver_amount_sat,
7282                bip353_address,
7283            } => [
7284                2.into_dart(),
7285                offer.into_into_dart().into_dart(),
7286                receiver_amount_sat.into_into_dart().into_dart(),
7287                bip353_address.into_into_dart().into_dart(),
7288            ]
7289            .into_dart(),
7290            _ => {
7291                unimplemented!("");
7292            }
7293        }
7294    }
7295}
7296impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::SendDestination {}
7297impl flutter_rust_bridge::IntoIntoDart<crate::model::SendDestination>
7298    for crate::model::SendDestination
7299{
7300    fn into_into_dart(self) -> crate::model::SendDestination {
7301        self
7302    }
7303}
7304// Codec=Dco (DartCObject based), see doc to use other codecs
7305impl flutter_rust_bridge::IntoDart for crate::model::SendPaymentRequest {
7306    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7307        [
7308            self.prepare_response.into_into_dart().into_dart(),
7309            self.use_asset_fees.into_into_dart().into_dart(),
7310            self.payer_note.into_into_dart().into_dart(),
7311        ]
7312        .into_dart()
7313    }
7314}
7315impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7316    for crate::model::SendPaymentRequest
7317{
7318}
7319impl flutter_rust_bridge::IntoIntoDart<crate::model::SendPaymentRequest>
7320    for crate::model::SendPaymentRequest
7321{
7322    fn into_into_dart(self) -> crate::model::SendPaymentRequest {
7323        self
7324    }
7325}
7326// Codec=Dco (DartCObject based), see doc to use other codecs
7327impl flutter_rust_bridge::IntoDart for crate::model::SendPaymentResponse {
7328    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7329        [self.payment.into_into_dart().into_dart()].into_dart()
7330    }
7331}
7332impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7333    for crate::model::SendPaymentResponse
7334{
7335}
7336impl flutter_rust_bridge::IntoIntoDart<crate::model::SendPaymentResponse>
7337    for crate::model::SendPaymentResponse
7338{
7339    fn into_into_dart(self) -> crate::model::SendPaymentResponse {
7340        self
7341    }
7342}
7343// Codec=Dco (DartCObject based), see doc to use other codecs
7344impl flutter_rust_bridge::IntoDart for crate::model::SignMessageRequest {
7345    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7346        [self.message.into_into_dart().into_dart()].into_dart()
7347    }
7348}
7349impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7350    for crate::model::SignMessageRequest
7351{
7352}
7353impl flutter_rust_bridge::IntoIntoDart<crate::model::SignMessageRequest>
7354    for crate::model::SignMessageRequest
7355{
7356    fn into_into_dart(self) -> crate::model::SignMessageRequest {
7357        self
7358    }
7359}
7360// Codec=Dco (DartCObject based), see doc to use other codecs
7361impl flutter_rust_bridge::IntoDart for crate::model::SignMessageResponse {
7362    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7363        [self.signature.into_into_dart().into_dart()].into_dart()
7364    }
7365}
7366impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7367    for crate::model::SignMessageResponse
7368{
7369}
7370impl flutter_rust_bridge::IntoIntoDart<crate::model::SignMessageResponse>
7371    for crate::model::SignMessageResponse
7372{
7373    fn into_into_dart(self) -> crate::model::SignMessageResponse {
7374        self
7375    }
7376}
7377// Codec=Dco (DartCObject based), see doc to use other codecs
7378impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::SuccessAction> {
7379    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7380        match self.0 {
7381            crate::bindings::SuccessAction::Aes { data } => {
7382                [0.into_dart(), data.into_into_dart().into_dart()].into_dart()
7383            }
7384            crate::bindings::SuccessAction::Message { data } => {
7385                [1.into_dart(), data.into_into_dart().into_dart()].into_dart()
7386            }
7387            crate::bindings::SuccessAction::Url { data } => {
7388                [2.into_dart(), data.into_into_dart().into_dart()].into_dart()
7389            }
7390            _ => {
7391                unimplemented!("");
7392            }
7393        }
7394    }
7395}
7396impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7397    for FrbWrapper<crate::bindings::SuccessAction>
7398{
7399}
7400impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::SuccessAction>>
7401    for crate::bindings::SuccessAction
7402{
7403    fn into_into_dart(self) -> FrbWrapper<crate::bindings::SuccessAction> {
7404        self.into()
7405    }
7406}
7407// Codec=Dco (DartCObject based), see doc to use other codecs
7408impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::SuccessActionProcessed> {
7409    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7410        match self.0 {
7411            crate::bindings::SuccessActionProcessed::Aes { result } => {
7412                [0.into_dart(), result.into_into_dart().into_dart()].into_dart()
7413            }
7414            crate::bindings::SuccessActionProcessed::Message { data } => {
7415                [1.into_dart(), data.into_into_dart().into_dart()].into_dart()
7416            }
7417            crate::bindings::SuccessActionProcessed::Url { data } => {
7418                [2.into_dart(), data.into_into_dart().into_dart()].into_dart()
7419            }
7420            _ => {
7421                unimplemented!("");
7422            }
7423        }
7424    }
7425}
7426impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7427    for FrbWrapper<crate::bindings::SuccessActionProcessed>
7428{
7429}
7430impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::SuccessActionProcessed>>
7431    for crate::bindings::SuccessActionProcessed
7432{
7433    fn into_into_dart(self) -> FrbWrapper<crate::bindings::SuccessActionProcessed> {
7434        self.into()
7435    }
7436}
7437// Codec=Dco (DartCObject based), see doc to use other codecs
7438impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::Symbol> {
7439    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7440        [
7441            self.0.grapheme.into_into_dart().into_dart(),
7442            self.0.template.into_into_dart().into_dart(),
7443            self.0.rtl.into_into_dart().into_dart(),
7444            self.0.position.into_into_dart().into_dart(),
7445        ]
7446        .into_dart()
7447    }
7448}
7449impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7450    for FrbWrapper<crate::bindings::Symbol>
7451{
7452}
7453impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::Symbol>>
7454    for crate::bindings::Symbol
7455{
7456    fn into_into_dart(self) -> FrbWrapper<crate::bindings::Symbol> {
7457        self.into()
7458    }
7459}
7460// Codec=Dco (DartCObject based), see doc to use other codecs
7461impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::UrlSuccessActionData> {
7462    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7463        [
7464            self.0.description.into_into_dart().into_dart(),
7465            self.0.url.into_into_dart().into_dart(),
7466            self.0.matches_callback_domain.into_into_dart().into_dart(),
7467        ]
7468        .into_dart()
7469    }
7470}
7471impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7472    for FrbWrapper<crate::bindings::UrlSuccessActionData>
7473{
7474}
7475impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::UrlSuccessActionData>>
7476    for crate::bindings::UrlSuccessActionData
7477{
7478    fn into_into_dart(self) -> FrbWrapper<crate::bindings::UrlSuccessActionData> {
7479        self.into()
7480    }
7481}
7482// Codec=Dco (DartCObject based), see doc to use other codecs
7483impl flutter_rust_bridge::IntoDart for crate::model::WalletInfo {
7484    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7485        [
7486            self.balance_sat.into_into_dart().into_dart(),
7487            self.pending_send_sat.into_into_dart().into_dart(),
7488            self.pending_receive_sat.into_into_dart().into_dart(),
7489            self.fingerprint.into_into_dart().into_dart(),
7490            self.pubkey.into_into_dart().into_dart(),
7491            self.asset_balances.into_into_dart().into_dart(),
7492        ]
7493        .into_dart()
7494    }
7495}
7496impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::WalletInfo {}
7497impl flutter_rust_bridge::IntoIntoDart<crate::model::WalletInfo> for crate::model::WalletInfo {
7498    fn into_into_dart(self) -> crate::model::WalletInfo {
7499        self
7500    }
7501}
7502
7503impl SseEncode for flutter_rust_bridge::for_generated::anyhow::Error {
7504    // Codec=Sse (Serialization based), see doc to use other codecs
7505    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7506        <String>::sse_encode(format!("{:?}", self), serializer);
7507    }
7508}
7509
7510impl SseEncode for BindingLiquidSdk {
7511    // Codec=Sse (Serialization based), see doc to use other codecs
7512    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7513        <RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>>::sse_encode(flutter_rust_bridge::for_generated::rust_auto_opaque_encode::<_, StdArc<_>>(self), serializer);
7514    }
7515}
7516
7517impl SseEncode
7518    for RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>
7519{
7520    // Codec=Sse (Serialization based), see doc to use other codecs
7521    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7522        let (ptr, size) = self.sse_encode_raw();
7523        <usize>::sse_encode(ptr, serializer);
7524        <i32>::sse_encode(size, serializer);
7525    }
7526}
7527
7528impl SseEncode
7529    for StreamSink<crate::model::LogEntry, flutter_rust_bridge::for_generated::DcoCodec>
7530{
7531    // Codec=Sse (Serialization based), see doc to use other codecs
7532    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7533        unimplemented!("")
7534    }
7535}
7536
7537impl SseEncode
7538    for StreamSink<crate::model::SdkEvent, flutter_rust_bridge::for_generated::DcoCodec>
7539{
7540    // Codec=Sse (Serialization based), see doc to use other codecs
7541    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7542        unimplemented!("")
7543    }
7544}
7545
7546impl SseEncode for String {
7547    // Codec=Sse (Serialization based), see doc to use other codecs
7548    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7549        <Vec<u8>>::sse_encode(self.into_bytes(), serializer);
7550    }
7551}
7552
7553impl SseEncode for crate::model::AcceptPaymentProposedFeesRequest {
7554    // Codec=Sse (Serialization based), see doc to use other codecs
7555    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7556        <crate::model::FetchPaymentProposedFeesResponse>::sse_encode(self.response, serializer);
7557    }
7558}
7559
7560impl SseEncode for crate::bindings::AesSuccessActionData {
7561    // Codec=Sse (Serialization based), see doc to use other codecs
7562    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7563        <String>::sse_encode(self.description, serializer);
7564        <String>::sse_encode(self.ciphertext, serializer);
7565        <String>::sse_encode(self.iv, serializer);
7566    }
7567}
7568
7569impl SseEncode for crate::bindings::AesSuccessActionDataDecrypted {
7570    // Codec=Sse (Serialization based), see doc to use other codecs
7571    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7572        <String>::sse_encode(self.description, serializer);
7573        <String>::sse_encode(self.plaintext, serializer);
7574    }
7575}
7576
7577impl SseEncode for crate::bindings::AesSuccessActionDataResult {
7578    // Codec=Sse (Serialization based), see doc to use other codecs
7579    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7580        match self {
7581            crate::bindings::AesSuccessActionDataResult::Decrypted { data } => {
7582                <i32>::sse_encode(0, serializer);
7583                <crate::bindings::AesSuccessActionDataDecrypted>::sse_encode(data, serializer);
7584            }
7585            crate::bindings::AesSuccessActionDataResult::ErrorStatus { reason } => {
7586                <i32>::sse_encode(1, serializer);
7587                <String>::sse_encode(reason, serializer);
7588            }
7589            _ => {
7590                unimplemented!("");
7591            }
7592        }
7593    }
7594}
7595
7596impl SseEncode for crate::bindings::Amount {
7597    // Codec=Sse (Serialization based), see doc to use other codecs
7598    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7599        match self {
7600            crate::bindings::Amount::Bitcoin { amount_msat } => {
7601                <i32>::sse_encode(0, serializer);
7602                <u64>::sse_encode(amount_msat, serializer);
7603            }
7604            crate::bindings::Amount::Currency {
7605                iso4217_code,
7606                fractional_amount,
7607            } => {
7608                <i32>::sse_encode(1, serializer);
7609                <String>::sse_encode(iso4217_code, serializer);
7610                <u64>::sse_encode(fractional_amount, serializer);
7611            }
7612            _ => {
7613                unimplemented!("");
7614            }
7615        }
7616    }
7617}
7618
7619impl SseEncode for crate::model::AssetBalance {
7620    // Codec=Sse (Serialization based), see doc to use other codecs
7621    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7622        <String>::sse_encode(self.asset_id, serializer);
7623        <u64>::sse_encode(self.balance_sat, serializer);
7624        <Option<String>>::sse_encode(self.name, serializer);
7625        <Option<String>>::sse_encode(self.ticker, serializer);
7626        <Option<f64>>::sse_encode(self.balance, serializer);
7627    }
7628}
7629
7630impl SseEncode for crate::model::AssetInfo {
7631    // Codec=Sse (Serialization based), see doc to use other codecs
7632    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7633        <String>::sse_encode(self.name, serializer);
7634        <String>::sse_encode(self.ticker, serializer);
7635        <f64>::sse_encode(self.amount, serializer);
7636        <Option<f64>>::sse_encode(self.fees, serializer);
7637    }
7638}
7639
7640impl SseEncode for crate::model::AssetMetadata {
7641    // Codec=Sse (Serialization based), see doc to use other codecs
7642    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7643        <String>::sse_encode(self.asset_id, serializer);
7644        <String>::sse_encode(self.name, serializer);
7645        <String>::sse_encode(self.ticker, serializer);
7646        <u8>::sse_encode(self.precision, serializer);
7647        <Option<String>>::sse_encode(self.fiat_id, serializer);
7648    }
7649}
7650
7651impl SseEncode for crate::model::BackupRequest {
7652    // Codec=Sse (Serialization based), see doc to use other codecs
7653    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7654        <Option<String>>::sse_encode(self.backup_path, serializer);
7655    }
7656}
7657
7658impl SseEncode for crate::bindings::BindingEventListener {
7659    // Codec=Sse (Serialization based), see doc to use other codecs
7660    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7661        <StreamSink<crate::model::SdkEvent,flutter_rust_bridge::for_generated::DcoCodec>>::sse_encode(self.stream, serializer);
7662    }
7663}
7664
7665impl SseEncode for crate::bindings::BitcoinAddressData {
7666    // Codec=Sse (Serialization based), see doc to use other codecs
7667    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7668        <String>::sse_encode(self.address, serializer);
7669        <crate::bindings::Network>::sse_encode(self.network, serializer);
7670        <Option<u64>>::sse_encode(self.amount_sat, serializer);
7671        <Option<String>>::sse_encode(self.label, serializer);
7672        <Option<String>>::sse_encode(self.message, serializer);
7673    }
7674}
7675
7676impl SseEncode for crate::model::BlockchainExplorer {
7677    // Codec=Sse (Serialization based), see doc to use other codecs
7678    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7679        match self {
7680            crate::model::BlockchainExplorer::Electrum { url } => {
7681                <i32>::sse_encode(0, serializer);
7682                <String>::sse_encode(url, serializer);
7683            }
7684            crate::model::BlockchainExplorer::Esplora {
7685                url,
7686                use_waterfalls,
7687            } => {
7688                <i32>::sse_encode(1, serializer);
7689                <String>::sse_encode(url, serializer);
7690                <bool>::sse_encode(use_waterfalls, serializer);
7691            }
7692            _ => {
7693                unimplemented!("");
7694            }
7695        }
7696    }
7697}
7698
7699impl SseEncode for crate::model::BlockchainInfo {
7700    // Codec=Sse (Serialization based), see doc to use other codecs
7701    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7702        <u32>::sse_encode(self.liquid_tip, serializer);
7703        <u32>::sse_encode(self.bitcoin_tip, serializer);
7704    }
7705}
7706
7707impl SseEncode for bool {
7708    // Codec=Sse (Serialization based), see doc to use other codecs
7709    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7710        serializer.cursor.write_u8(self as _).unwrap();
7711    }
7712}
7713
7714impl SseEncode for crate::model::BuyBitcoinProvider {
7715    // Codec=Sse (Serialization based), see doc to use other codecs
7716    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7717        <i32>::sse_encode(
7718            match self {
7719                crate::model::BuyBitcoinProvider::Moonpay => 0,
7720                _ => {
7721                    unimplemented!("");
7722                }
7723            },
7724            serializer,
7725        );
7726    }
7727}
7728
7729impl SseEncode for crate::model::BuyBitcoinRequest {
7730    // Codec=Sse (Serialization based), see doc to use other codecs
7731    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7732        <crate::model::PrepareBuyBitcoinResponse>::sse_encode(self.prepare_response, serializer);
7733        <Option<String>>::sse_encode(self.redirect_url, serializer);
7734    }
7735}
7736
7737impl SseEncode for crate::model::CheckMessageRequest {
7738    // Codec=Sse (Serialization based), see doc to use other codecs
7739    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7740        <String>::sse_encode(self.message, serializer);
7741        <String>::sse_encode(self.pubkey, serializer);
7742        <String>::sse_encode(self.signature, serializer);
7743    }
7744}
7745
7746impl SseEncode for crate::model::CheckMessageResponse {
7747    // Codec=Sse (Serialization based), see doc to use other codecs
7748    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7749        <bool>::sse_encode(self.is_valid, serializer);
7750    }
7751}
7752
7753impl SseEncode for crate::model::Config {
7754    // Codec=Sse (Serialization based), see doc to use other codecs
7755    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7756        <crate::model::BlockchainExplorer>::sse_encode(self.liquid_explorer, serializer);
7757        <crate::model::BlockchainExplorer>::sse_encode(self.bitcoin_explorer, serializer);
7758        <String>::sse_encode(self.working_dir, serializer);
7759        <crate::model::LiquidNetwork>::sse_encode(self.network, serializer);
7760        <u64>::sse_encode(self.payment_timeout_sec, serializer);
7761        <Option<String>>::sse_encode(self.sync_service_url, serializer);
7762        <Option<u64>>::sse_encode(self.zero_conf_max_amount_sat, serializer);
7763        <Option<String>>::sse_encode(self.breez_api_key, serializer);
7764        <Option<Vec<crate::bindings::ExternalInputParser>>>::sse_encode(
7765            self.external_input_parsers,
7766            serializer,
7767        );
7768        <bool>::sse_encode(self.use_default_external_input_parsers, serializer);
7769        <Option<u64>>::sse_encode(self.onchain_fee_rate_leeway_sat, serializer);
7770        <Option<Vec<crate::model::AssetMetadata>>>::sse_encode(self.asset_metadata, serializer);
7771        <Option<String>>::sse_encode(self.sideswap_api_key, serializer);
7772    }
7773}
7774
7775impl SseEncode for crate::model::ConnectRequest {
7776    // Codec=Sse (Serialization based), see doc to use other codecs
7777    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7778        <crate::model::Config>::sse_encode(self.config, serializer);
7779        <Option<String>>::sse_encode(self.mnemonic, serializer);
7780        <Option<String>>::sse_encode(self.passphrase, serializer);
7781        <Option<Vec<u8>>>::sse_encode(self.seed, serializer);
7782    }
7783}
7784
7785impl SseEncode for crate::model::CreateBolt12InvoiceRequest {
7786    // Codec=Sse (Serialization based), see doc to use other codecs
7787    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7788        <String>::sse_encode(self.offer, serializer);
7789        <String>::sse_encode(self.invoice_request, serializer);
7790    }
7791}
7792
7793impl SseEncode for crate::model::CreateBolt12InvoiceResponse {
7794    // Codec=Sse (Serialization based), see doc to use other codecs
7795    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7796        <String>::sse_encode(self.invoice, serializer);
7797    }
7798}
7799
7800impl SseEncode for crate::bindings::CurrencyInfo {
7801    // Codec=Sse (Serialization based), see doc to use other codecs
7802    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7803        <String>::sse_encode(self.name, serializer);
7804        <u32>::sse_encode(self.fraction_size, serializer);
7805        <Option<u32>>::sse_encode(self.spacing, serializer);
7806        <Option<crate::bindings::Symbol>>::sse_encode(self.symbol, serializer);
7807        <Option<crate::bindings::Symbol>>::sse_encode(self.uniq_symbol, serializer);
7808        <Vec<crate::bindings::LocalizedName>>::sse_encode(self.localized_name, serializer);
7809        <Vec<crate::bindings::LocaleOverrides>>::sse_encode(self.locale_overrides, serializer);
7810    }
7811}
7812
7813impl SseEncode for crate::bindings::ExternalInputParser {
7814    // Codec=Sse (Serialization based), see doc to use other codecs
7815    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7816        <String>::sse_encode(self.provider_id, serializer);
7817        <String>::sse_encode(self.input_regex, serializer);
7818        <String>::sse_encode(self.parser_url, serializer);
7819    }
7820}
7821
7822impl SseEncode for f64 {
7823    // Codec=Sse (Serialization based), see doc to use other codecs
7824    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7825        serializer.cursor.write_f64::<NativeEndian>(self).unwrap();
7826    }
7827}
7828
7829impl SseEncode for crate::model::FetchPaymentProposedFeesRequest {
7830    // Codec=Sse (Serialization based), see doc to use other codecs
7831    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7832        <String>::sse_encode(self.swap_id, serializer);
7833    }
7834}
7835
7836impl SseEncode for crate::model::FetchPaymentProposedFeesResponse {
7837    // Codec=Sse (Serialization based), see doc to use other codecs
7838    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7839        <String>::sse_encode(self.swap_id, serializer);
7840        <u64>::sse_encode(self.fees_sat, serializer);
7841        <u64>::sse_encode(self.payer_amount_sat, serializer);
7842        <u64>::sse_encode(self.receiver_amount_sat, serializer);
7843    }
7844}
7845
7846impl SseEncode for crate::bindings::FiatCurrency {
7847    // Codec=Sse (Serialization based), see doc to use other codecs
7848    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7849        <String>::sse_encode(self.id, serializer);
7850        <crate::bindings::CurrencyInfo>::sse_encode(self.info, serializer);
7851    }
7852}
7853
7854impl SseEncode for crate::model::GetInfoResponse {
7855    // Codec=Sse (Serialization based), see doc to use other codecs
7856    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7857        <crate::model::WalletInfo>::sse_encode(self.wallet_info, serializer);
7858        <crate::model::BlockchainInfo>::sse_encode(self.blockchain_info, serializer);
7859    }
7860}
7861
7862impl SseEncode for crate::model::GetPaymentRequest {
7863    // Codec=Sse (Serialization based), see doc to use other codecs
7864    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7865        match self {
7866            crate::model::GetPaymentRequest::PaymentHash { payment_hash } => {
7867                <i32>::sse_encode(0, serializer);
7868                <String>::sse_encode(payment_hash, serializer);
7869            }
7870            crate::model::GetPaymentRequest::SwapId { swap_id } => {
7871                <i32>::sse_encode(1, serializer);
7872                <String>::sse_encode(swap_id, serializer);
7873            }
7874            _ => {
7875                unimplemented!("");
7876            }
7877        }
7878    }
7879}
7880
7881impl SseEncode for i32 {
7882    // Codec=Sse (Serialization based), see doc to use other codecs
7883    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7884        serializer.cursor.write_i32::<NativeEndian>(self).unwrap();
7885    }
7886}
7887
7888impl SseEncode for i64 {
7889    // Codec=Sse (Serialization based), see doc to use other codecs
7890    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7891        serializer.cursor.write_i64::<NativeEndian>(self).unwrap();
7892    }
7893}
7894
7895impl SseEncode for crate::bindings::InputType {
7896    // Codec=Sse (Serialization based), see doc to use other codecs
7897    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7898        match self {
7899            crate::bindings::InputType::BitcoinAddress { address } => {
7900                <i32>::sse_encode(0, serializer);
7901                <crate::bindings::BitcoinAddressData>::sse_encode(address, serializer);
7902            }
7903            crate::bindings::InputType::LiquidAddress { address } => {
7904                <i32>::sse_encode(1, serializer);
7905                <crate::bindings::LiquidAddressData>::sse_encode(address, serializer);
7906            }
7907            crate::bindings::InputType::Bolt11 { invoice } => {
7908                <i32>::sse_encode(2, serializer);
7909                <crate::bindings::LNInvoice>::sse_encode(invoice, serializer);
7910            }
7911            crate::bindings::InputType::Bolt12Offer {
7912                offer,
7913                bip353_address,
7914            } => {
7915                <i32>::sse_encode(3, serializer);
7916                <crate::bindings::LNOffer>::sse_encode(offer, serializer);
7917                <Option<String>>::sse_encode(bip353_address, serializer);
7918            }
7919            crate::bindings::InputType::NodeId { node_id } => {
7920                <i32>::sse_encode(4, serializer);
7921                <String>::sse_encode(node_id, serializer);
7922            }
7923            crate::bindings::InputType::Url { url } => {
7924                <i32>::sse_encode(5, serializer);
7925                <String>::sse_encode(url, serializer);
7926            }
7927            crate::bindings::InputType::LnUrlPay {
7928                data,
7929                bip353_address,
7930            } => {
7931                <i32>::sse_encode(6, serializer);
7932                <crate::bindings::LnUrlPayRequestData>::sse_encode(data, serializer);
7933                <Option<String>>::sse_encode(bip353_address, serializer);
7934            }
7935            crate::bindings::InputType::LnUrlWithdraw { data } => {
7936                <i32>::sse_encode(7, serializer);
7937                <crate::bindings::LnUrlWithdrawRequestData>::sse_encode(data, serializer);
7938            }
7939            crate::bindings::InputType::LnUrlAuth { data } => {
7940                <i32>::sse_encode(8, serializer);
7941                <crate::bindings::LnUrlAuthRequestData>::sse_encode(data, serializer);
7942            }
7943            crate::bindings::InputType::LnUrlError { data } => {
7944                <i32>::sse_encode(9, serializer);
7945                <crate::bindings::LnUrlErrorData>::sse_encode(data, serializer);
7946            }
7947            _ => {
7948                unimplemented!("");
7949            }
7950        }
7951    }
7952}
7953
7954impl SseEncode for crate::model::LightningPaymentLimitsResponse {
7955    // Codec=Sse (Serialization based), see doc to use other codecs
7956    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7957        <crate::model::Limits>::sse_encode(self.send, serializer);
7958        <crate::model::Limits>::sse_encode(self.receive, serializer);
7959    }
7960}
7961
7962impl SseEncode for crate::model::Limits {
7963    // Codec=Sse (Serialization based), see doc to use other codecs
7964    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7965        <u64>::sse_encode(self.min_sat, serializer);
7966        <u64>::sse_encode(self.max_sat, serializer);
7967        <u64>::sse_encode(self.max_zero_conf_sat, serializer);
7968    }
7969}
7970
7971impl SseEncode for crate::bindings::LiquidAddressData {
7972    // Codec=Sse (Serialization based), see doc to use other codecs
7973    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7974        <String>::sse_encode(self.address, serializer);
7975        <crate::bindings::Network>::sse_encode(self.network, serializer);
7976        <Option<String>>::sse_encode(self.asset_id, serializer);
7977        <Option<f64>>::sse_encode(self.amount, serializer);
7978        <Option<u64>>::sse_encode(self.amount_sat, serializer);
7979        <Option<String>>::sse_encode(self.label, serializer);
7980        <Option<String>>::sse_encode(self.message, serializer);
7981    }
7982}
7983
7984impl SseEncode for crate::model::LiquidNetwork {
7985    // Codec=Sse (Serialization based), see doc to use other codecs
7986    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7987        <i32>::sse_encode(
7988            match self {
7989                crate::model::LiquidNetwork::Mainnet => 0,
7990                crate::model::LiquidNetwork::Testnet => 1,
7991                crate::model::LiquidNetwork::Regtest => 2,
7992                _ => {
7993                    unimplemented!("");
7994                }
7995            },
7996            serializer,
7997        );
7998    }
7999}
8000
8001impl SseEncode for Vec<String> {
8002    // Codec=Sse (Serialization based), see doc to use other codecs
8003    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8004        <i32>::sse_encode(self.len() as _, serializer);
8005        for item in self {
8006            <String>::sse_encode(item, serializer);
8007        }
8008    }
8009}
8010
8011impl SseEncode for Vec<crate::model::AssetBalance> {
8012    // Codec=Sse (Serialization based), see doc to use other codecs
8013    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8014        <i32>::sse_encode(self.len() as _, serializer);
8015        for item in self {
8016            <crate::model::AssetBalance>::sse_encode(item, serializer);
8017        }
8018    }
8019}
8020
8021impl SseEncode for Vec<crate::model::AssetMetadata> {
8022    // Codec=Sse (Serialization based), see doc to use other codecs
8023    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8024        <i32>::sse_encode(self.len() as _, serializer);
8025        for item in self {
8026            <crate::model::AssetMetadata>::sse_encode(item, serializer);
8027        }
8028    }
8029}
8030
8031impl SseEncode for Vec<crate::bindings::ExternalInputParser> {
8032    // Codec=Sse (Serialization based), see doc to use other codecs
8033    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8034        <i32>::sse_encode(self.len() as _, serializer);
8035        for item in self {
8036            <crate::bindings::ExternalInputParser>::sse_encode(item, serializer);
8037        }
8038    }
8039}
8040
8041impl SseEncode for Vec<crate::bindings::FiatCurrency> {
8042    // Codec=Sse (Serialization based), see doc to use other codecs
8043    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8044        <i32>::sse_encode(self.len() as _, serializer);
8045        for item in self {
8046            <crate::bindings::FiatCurrency>::sse_encode(item, serializer);
8047        }
8048    }
8049}
8050
8051impl SseEncode for Vec<crate::bindings::LnOfferBlindedPath> {
8052    // Codec=Sse (Serialization based), see doc to use other codecs
8053    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8054        <i32>::sse_encode(self.len() as _, serializer);
8055        for item in self {
8056            <crate::bindings::LnOfferBlindedPath>::sse_encode(item, serializer);
8057        }
8058    }
8059}
8060
8061impl SseEncode for Vec<crate::bindings::LocaleOverrides> {
8062    // Codec=Sse (Serialization based), see doc to use other codecs
8063    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8064        <i32>::sse_encode(self.len() as _, serializer);
8065        for item in self {
8066            <crate::bindings::LocaleOverrides>::sse_encode(item, serializer);
8067        }
8068    }
8069}
8070
8071impl SseEncode for Vec<crate::bindings::LocalizedName> {
8072    // Codec=Sse (Serialization based), see doc to use other codecs
8073    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8074        <i32>::sse_encode(self.len() as _, serializer);
8075        for item in self {
8076            <crate::bindings::LocalizedName>::sse_encode(item, serializer);
8077        }
8078    }
8079}
8080
8081impl SseEncode for Vec<crate::model::Payment> {
8082    // Codec=Sse (Serialization based), see doc to use other codecs
8083    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8084        <i32>::sse_encode(self.len() as _, serializer);
8085        for item in self {
8086            <crate::model::Payment>::sse_encode(item, serializer);
8087        }
8088    }
8089}
8090
8091impl SseEncode for crate::model::ListPaymentDetails {
8092    // Codec=Sse (Serialization based), see doc to use other codecs
8093    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8094        match self {
8095            crate::model::ListPaymentDetails::Liquid {
8096                asset_id,
8097                destination,
8098            } => {
8099                <i32>::sse_encode(0, serializer);
8100                <Option<String>>::sse_encode(asset_id, serializer);
8101                <Option<String>>::sse_encode(destination, serializer);
8102            }
8103            crate::model::ListPaymentDetails::Bitcoin { address } => {
8104                <i32>::sse_encode(1, serializer);
8105                <Option<String>>::sse_encode(address, serializer);
8106            }
8107            _ => {
8108                unimplemented!("");
8109            }
8110        }
8111    }
8112}
8113
8114impl SseEncode for Vec<crate::model::PaymentState> {
8115    // Codec=Sse (Serialization based), see doc to use other codecs
8116    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8117        <i32>::sse_encode(self.len() as _, serializer);
8118        for item in self {
8119            <crate::model::PaymentState>::sse_encode(item, serializer);
8120        }
8121    }
8122}
8123
8124impl SseEncode for Vec<crate::model::PaymentType> {
8125    // Codec=Sse (Serialization based), see doc to use other codecs
8126    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8127        <i32>::sse_encode(self.len() as _, serializer);
8128        for item in self {
8129            <crate::model::PaymentType>::sse_encode(item, serializer);
8130        }
8131    }
8132}
8133
8134impl SseEncode for crate::model::ListPaymentsRequest {
8135    // Codec=Sse (Serialization based), see doc to use other codecs
8136    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8137        <Option<Vec<crate::model::PaymentType>>>::sse_encode(self.filters, serializer);
8138        <Option<Vec<crate::model::PaymentState>>>::sse_encode(self.states, serializer);
8139        <Option<i64>>::sse_encode(self.from_timestamp, serializer);
8140        <Option<i64>>::sse_encode(self.to_timestamp, serializer);
8141        <Option<u32>>::sse_encode(self.offset, serializer);
8142        <Option<u32>>::sse_encode(self.limit, serializer);
8143        <Option<crate::model::ListPaymentDetails>>::sse_encode(self.details, serializer);
8144        <Option<bool>>::sse_encode(self.sort_ascending, serializer);
8145    }
8146}
8147
8148impl SseEncode for Vec<u8> {
8149    // Codec=Sse (Serialization based), see doc to use other codecs
8150    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8151        <i32>::sse_encode(self.len() as _, serializer);
8152        for item in self {
8153            <u8>::sse_encode(item, serializer);
8154        }
8155    }
8156}
8157
8158impl SseEncode for Vec<crate::bindings::Rate> {
8159    // Codec=Sse (Serialization based), see doc to use other codecs
8160    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8161        <i32>::sse_encode(self.len() as _, serializer);
8162        for item in self {
8163            <crate::bindings::Rate>::sse_encode(item, serializer);
8164        }
8165    }
8166}
8167
8168impl SseEncode for Vec<crate::model::RefundableSwap> {
8169    // Codec=Sse (Serialization based), see doc to use other codecs
8170    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8171        <i32>::sse_encode(self.len() as _, serializer);
8172        for item in self {
8173            <crate::model::RefundableSwap>::sse_encode(item, serializer);
8174        }
8175    }
8176}
8177
8178impl SseEncode for Vec<crate::bindings::RouteHint> {
8179    // Codec=Sse (Serialization based), see doc to use other codecs
8180    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8181        <i32>::sse_encode(self.len() as _, serializer);
8182        for item in self {
8183            <crate::bindings::RouteHint>::sse_encode(item, serializer);
8184        }
8185    }
8186}
8187
8188impl SseEncode for Vec<crate::bindings::RouteHintHop> {
8189    // Codec=Sse (Serialization based), see doc to use other codecs
8190    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8191        <i32>::sse_encode(self.len() as _, serializer);
8192        for item in self {
8193            <crate::bindings::RouteHintHop>::sse_encode(item, serializer);
8194        }
8195    }
8196}
8197
8198impl SseEncode for crate::bindings::LNInvoice {
8199    // Codec=Sse (Serialization based), see doc to use other codecs
8200    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8201        <String>::sse_encode(self.bolt11, serializer);
8202        <crate::bindings::Network>::sse_encode(self.network, serializer);
8203        <String>::sse_encode(self.payee_pubkey, serializer);
8204        <String>::sse_encode(self.payment_hash, serializer);
8205        <Option<String>>::sse_encode(self.description, serializer);
8206        <Option<String>>::sse_encode(self.description_hash, serializer);
8207        <Option<u64>>::sse_encode(self.amount_msat, serializer);
8208        <u64>::sse_encode(self.timestamp, serializer);
8209        <u64>::sse_encode(self.expiry, serializer);
8210        <Vec<crate::bindings::RouteHint>>::sse_encode(self.routing_hints, serializer);
8211        <Vec<u8>>::sse_encode(self.payment_secret, serializer);
8212        <u64>::sse_encode(self.min_final_cltv_expiry_delta, serializer);
8213    }
8214}
8215
8216impl SseEncode for crate::bindings::LNOffer {
8217    // Codec=Sse (Serialization based), see doc to use other codecs
8218    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8219        <String>::sse_encode(self.offer, serializer);
8220        <Vec<String>>::sse_encode(self.chains, serializer);
8221        <Option<crate::bindings::Amount>>::sse_encode(self.min_amount, serializer);
8222        <Option<String>>::sse_encode(self.description, serializer);
8223        <Option<u64>>::sse_encode(self.absolute_expiry, serializer);
8224        <Option<String>>::sse_encode(self.issuer, serializer);
8225        <Option<String>>::sse_encode(self.signing_pubkey, serializer);
8226        <Vec<crate::bindings::LnOfferBlindedPath>>::sse_encode(self.paths, serializer);
8227    }
8228}
8229
8230impl SseEncode for crate::bindings::LnOfferBlindedPath {
8231    // Codec=Sse (Serialization based), see doc to use other codecs
8232    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8233        <Vec<String>>::sse_encode(self.blinded_hops, serializer);
8234    }
8235}
8236
8237impl SseEncode for crate::bindings::duplicates::LnUrlAuthError {
8238    // Codec=Sse (Serialization based), see doc to use other codecs
8239    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8240        match self {
8241            crate::bindings::duplicates::LnUrlAuthError::Generic { err } => {
8242                <i32>::sse_encode(0, serializer);
8243                <String>::sse_encode(err, serializer);
8244            }
8245            crate::bindings::duplicates::LnUrlAuthError::InvalidUri { err } => {
8246                <i32>::sse_encode(1, serializer);
8247                <String>::sse_encode(err, serializer);
8248            }
8249            crate::bindings::duplicates::LnUrlAuthError::ServiceConnectivity { err } => {
8250                <i32>::sse_encode(2, serializer);
8251                <String>::sse_encode(err, serializer);
8252            }
8253            _ => {
8254                unimplemented!("");
8255            }
8256        }
8257    }
8258}
8259
8260impl SseEncode for crate::bindings::LnUrlAuthRequestData {
8261    // Codec=Sse (Serialization based), see doc to use other codecs
8262    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8263        <String>::sse_encode(self.k1, serializer);
8264        <Option<String>>::sse_encode(self.action, serializer);
8265        <String>::sse_encode(self.domain, serializer);
8266        <String>::sse_encode(self.url, serializer);
8267    }
8268}
8269
8270impl SseEncode for crate::bindings::duplicates::LnUrlCallbackStatus {
8271    // Codec=Sse (Serialization based), see doc to use other codecs
8272    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8273        match self {
8274            crate::bindings::duplicates::LnUrlCallbackStatus::Ok => {
8275                <i32>::sse_encode(0, serializer);
8276            }
8277            crate::bindings::duplicates::LnUrlCallbackStatus::ErrorStatus { data } => {
8278                <i32>::sse_encode(1, serializer);
8279                <crate::bindings::LnUrlErrorData>::sse_encode(data, serializer);
8280            }
8281            _ => {
8282                unimplemented!("");
8283            }
8284        }
8285    }
8286}
8287
8288impl SseEncode for crate::bindings::LnUrlErrorData {
8289    // Codec=Sse (Serialization based), see doc to use other codecs
8290    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8291        <String>::sse_encode(self.reason, serializer);
8292    }
8293}
8294
8295impl SseEncode for crate::model::LnUrlInfo {
8296    // Codec=Sse (Serialization based), see doc to use other codecs
8297    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8298        <Option<String>>::sse_encode(self.ln_address, serializer);
8299        <Option<String>>::sse_encode(self.lnurl_pay_comment, serializer);
8300        <Option<String>>::sse_encode(self.lnurl_pay_domain, serializer);
8301        <Option<String>>::sse_encode(self.lnurl_pay_metadata, serializer);
8302        <Option<crate::bindings::SuccessActionProcessed>>::sse_encode(
8303            self.lnurl_pay_success_action,
8304            serializer,
8305        );
8306        <Option<crate::bindings::SuccessAction>>::sse_encode(
8307            self.lnurl_pay_unprocessed_success_action,
8308            serializer,
8309        );
8310        <Option<String>>::sse_encode(self.lnurl_withdraw_endpoint, serializer);
8311    }
8312}
8313
8314impl SseEncode for crate::bindings::duplicates::LnUrlPayError {
8315    // Codec=Sse (Serialization based), see doc to use other codecs
8316    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8317        match self {
8318            crate::bindings::duplicates::LnUrlPayError::AlreadyPaid => {
8319                <i32>::sse_encode(0, serializer);
8320            }
8321            crate::bindings::duplicates::LnUrlPayError::Generic { err } => {
8322                <i32>::sse_encode(1, serializer);
8323                <String>::sse_encode(err, serializer);
8324            }
8325            crate::bindings::duplicates::LnUrlPayError::InsufficientBalance { err } => {
8326                <i32>::sse_encode(2, serializer);
8327                <String>::sse_encode(err, serializer);
8328            }
8329            crate::bindings::duplicates::LnUrlPayError::InvalidAmount { err } => {
8330                <i32>::sse_encode(3, serializer);
8331                <String>::sse_encode(err, serializer);
8332            }
8333            crate::bindings::duplicates::LnUrlPayError::InvalidInvoice { err } => {
8334                <i32>::sse_encode(4, serializer);
8335                <String>::sse_encode(err, serializer);
8336            }
8337            crate::bindings::duplicates::LnUrlPayError::InvalidNetwork { err } => {
8338                <i32>::sse_encode(5, serializer);
8339                <String>::sse_encode(err, serializer);
8340            }
8341            crate::bindings::duplicates::LnUrlPayError::InvalidUri { err } => {
8342                <i32>::sse_encode(6, serializer);
8343                <String>::sse_encode(err, serializer);
8344            }
8345            crate::bindings::duplicates::LnUrlPayError::InvoiceExpired { err } => {
8346                <i32>::sse_encode(7, serializer);
8347                <String>::sse_encode(err, serializer);
8348            }
8349            crate::bindings::duplicates::LnUrlPayError::PaymentFailed { err } => {
8350                <i32>::sse_encode(8, serializer);
8351                <String>::sse_encode(err, serializer);
8352            }
8353            crate::bindings::duplicates::LnUrlPayError::PaymentTimeout { err } => {
8354                <i32>::sse_encode(9, serializer);
8355                <String>::sse_encode(err, serializer);
8356            }
8357            crate::bindings::duplicates::LnUrlPayError::RouteNotFound { err } => {
8358                <i32>::sse_encode(10, serializer);
8359                <String>::sse_encode(err, serializer);
8360            }
8361            crate::bindings::duplicates::LnUrlPayError::RouteTooExpensive { err } => {
8362                <i32>::sse_encode(11, serializer);
8363                <String>::sse_encode(err, serializer);
8364            }
8365            crate::bindings::duplicates::LnUrlPayError::ServiceConnectivity { err } => {
8366                <i32>::sse_encode(12, serializer);
8367                <String>::sse_encode(err, serializer);
8368            }
8369            _ => {
8370                unimplemented!("");
8371            }
8372        }
8373    }
8374}
8375
8376impl SseEncode for crate::bindings::LnUrlPayErrorData {
8377    // Codec=Sse (Serialization based), see doc to use other codecs
8378    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8379        <String>::sse_encode(self.payment_hash, serializer);
8380        <String>::sse_encode(self.reason, serializer);
8381    }
8382}
8383
8384impl SseEncode for crate::model::LnUrlPayRequest {
8385    // Codec=Sse (Serialization based), see doc to use other codecs
8386    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8387        <crate::model::PrepareLnUrlPayResponse>::sse_encode(self.prepare_response, serializer);
8388    }
8389}
8390
8391impl SseEncode for crate::bindings::LnUrlPayRequestData {
8392    // Codec=Sse (Serialization based), see doc to use other codecs
8393    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8394        <String>::sse_encode(self.callback, serializer);
8395        <u64>::sse_encode(self.min_sendable, serializer);
8396        <u64>::sse_encode(self.max_sendable, serializer);
8397        <String>::sse_encode(self.metadata_str, serializer);
8398        <u16>::sse_encode(self.comment_allowed, serializer);
8399        <String>::sse_encode(self.domain, serializer);
8400        <bool>::sse_encode(self.allows_nostr, serializer);
8401        <Option<String>>::sse_encode(self.nostr_pubkey, serializer);
8402        <Option<String>>::sse_encode(self.ln_address, serializer);
8403    }
8404}
8405
8406impl SseEncode for crate::model::LnUrlPayResult {
8407    // Codec=Sse (Serialization based), see doc to use other codecs
8408    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8409        match self {
8410            crate::model::LnUrlPayResult::EndpointSuccess { data } => {
8411                <i32>::sse_encode(0, serializer);
8412                <crate::model::LnUrlPaySuccessData>::sse_encode(data, serializer);
8413            }
8414            crate::model::LnUrlPayResult::EndpointError { data } => {
8415                <i32>::sse_encode(1, serializer);
8416                <crate::bindings::LnUrlErrorData>::sse_encode(data, serializer);
8417            }
8418            crate::model::LnUrlPayResult::PayError { data } => {
8419                <i32>::sse_encode(2, serializer);
8420                <crate::bindings::LnUrlPayErrorData>::sse_encode(data, serializer);
8421            }
8422            _ => {
8423                unimplemented!("");
8424            }
8425        }
8426    }
8427}
8428
8429impl SseEncode for crate::model::LnUrlPaySuccessData {
8430    // Codec=Sse (Serialization based), see doc to use other codecs
8431    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8432        <crate::model::Payment>::sse_encode(self.payment, serializer);
8433        <Option<crate::bindings::SuccessActionProcessed>>::sse_encode(
8434            self.success_action,
8435            serializer,
8436        );
8437    }
8438}
8439
8440impl SseEncode for crate::bindings::duplicates::LnUrlWithdrawError {
8441    // Codec=Sse (Serialization based), see doc to use other codecs
8442    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8443        match self {
8444            crate::bindings::duplicates::LnUrlWithdrawError::Generic { err } => {
8445                <i32>::sse_encode(0, serializer);
8446                <String>::sse_encode(err, serializer);
8447            }
8448            crate::bindings::duplicates::LnUrlWithdrawError::InvalidAmount { err } => {
8449                <i32>::sse_encode(1, serializer);
8450                <String>::sse_encode(err, serializer);
8451            }
8452            crate::bindings::duplicates::LnUrlWithdrawError::InvalidInvoice { err } => {
8453                <i32>::sse_encode(2, serializer);
8454                <String>::sse_encode(err, serializer);
8455            }
8456            crate::bindings::duplicates::LnUrlWithdrawError::InvalidUri { err } => {
8457                <i32>::sse_encode(3, serializer);
8458                <String>::sse_encode(err, serializer);
8459            }
8460            crate::bindings::duplicates::LnUrlWithdrawError::InvoiceNoRoutingHints { err } => {
8461                <i32>::sse_encode(4, serializer);
8462                <String>::sse_encode(err, serializer);
8463            }
8464            crate::bindings::duplicates::LnUrlWithdrawError::ServiceConnectivity { err } => {
8465                <i32>::sse_encode(5, serializer);
8466                <String>::sse_encode(err, serializer);
8467            }
8468            _ => {
8469                unimplemented!("");
8470            }
8471        }
8472    }
8473}
8474
8475impl SseEncode for crate::bindings::LnUrlWithdrawRequest {
8476    // Codec=Sse (Serialization based), see doc to use other codecs
8477    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8478        <crate::bindings::LnUrlWithdrawRequestData>::sse_encode(self.data, serializer);
8479        <u64>::sse_encode(self.amount_msat, serializer);
8480        <Option<String>>::sse_encode(self.description, serializer);
8481    }
8482}
8483
8484impl SseEncode for crate::bindings::LnUrlWithdrawRequestData {
8485    // Codec=Sse (Serialization based), see doc to use other codecs
8486    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8487        <String>::sse_encode(self.callback, serializer);
8488        <String>::sse_encode(self.k1, serializer);
8489        <String>::sse_encode(self.default_description, serializer);
8490        <u64>::sse_encode(self.min_withdrawable, serializer);
8491        <u64>::sse_encode(self.max_withdrawable, serializer);
8492    }
8493}
8494
8495impl SseEncode for crate::bindings::duplicates::LnUrlWithdrawResult {
8496    // Codec=Sse (Serialization based), see doc to use other codecs
8497    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8498        match self {
8499            crate::bindings::duplicates::LnUrlWithdrawResult::Ok { data } => {
8500                <i32>::sse_encode(0, serializer);
8501                <crate::bindings::duplicates::LnUrlWithdrawSuccessData>::sse_encode(
8502                    data, serializer,
8503                );
8504            }
8505            crate::bindings::duplicates::LnUrlWithdrawResult::Timeout { data } => {
8506                <i32>::sse_encode(1, serializer);
8507                <crate::bindings::duplicates::LnUrlWithdrawSuccessData>::sse_encode(
8508                    data, serializer,
8509                );
8510            }
8511            crate::bindings::duplicates::LnUrlWithdrawResult::ErrorStatus { data } => {
8512                <i32>::sse_encode(2, serializer);
8513                <crate::bindings::LnUrlErrorData>::sse_encode(data, serializer);
8514            }
8515            _ => {
8516                unimplemented!("");
8517            }
8518        }
8519    }
8520}
8521
8522impl SseEncode for crate::bindings::duplicates::LnUrlWithdrawSuccessData {
8523    // Codec=Sse (Serialization based), see doc to use other codecs
8524    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8525        <crate::bindings::LNInvoice>::sse_encode(self.invoice, serializer);
8526    }
8527}
8528
8529impl SseEncode for crate::bindings::LocaleOverrides {
8530    // Codec=Sse (Serialization based), see doc to use other codecs
8531    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8532        <String>::sse_encode(self.locale, serializer);
8533        <Option<u32>>::sse_encode(self.spacing, serializer);
8534        <crate::bindings::Symbol>::sse_encode(self.symbol, serializer);
8535    }
8536}
8537
8538impl SseEncode for crate::bindings::LocalizedName {
8539    // Codec=Sse (Serialization based), see doc to use other codecs
8540    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8541        <String>::sse_encode(self.locale, serializer);
8542        <String>::sse_encode(self.name, serializer);
8543    }
8544}
8545
8546impl SseEncode for crate::model::LogEntry {
8547    // Codec=Sse (Serialization based), see doc to use other codecs
8548    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8549        <String>::sse_encode(self.line, serializer);
8550        <String>::sse_encode(self.level, serializer);
8551    }
8552}
8553
8554impl SseEncode for crate::bindings::MessageSuccessActionData {
8555    // Codec=Sse (Serialization based), see doc to use other codecs
8556    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8557        <String>::sse_encode(self.message, serializer);
8558    }
8559}
8560
8561impl SseEncode for crate::bindings::Network {
8562    // Codec=Sse (Serialization based), see doc to use other codecs
8563    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8564        <i32>::sse_encode(
8565            match self {
8566                crate::bindings::Network::Bitcoin => 0,
8567                crate::bindings::Network::Testnet => 1,
8568                crate::bindings::Network::Signet => 2,
8569                crate::bindings::Network::Regtest => 3,
8570                _ => {
8571                    unimplemented!("");
8572                }
8573            },
8574            serializer,
8575        );
8576    }
8577}
8578
8579impl SseEncode for crate::model::OnchainPaymentLimitsResponse {
8580    // Codec=Sse (Serialization based), see doc to use other codecs
8581    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8582        <crate::model::Limits>::sse_encode(self.send, serializer);
8583        <crate::model::Limits>::sse_encode(self.receive, serializer);
8584    }
8585}
8586
8587impl SseEncode for Option<String> {
8588    // Codec=Sse (Serialization based), see doc to use other codecs
8589    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8590        <bool>::sse_encode(self.is_some(), serializer);
8591        if let Some(value) = self {
8592            <String>::sse_encode(value, serializer);
8593        }
8594    }
8595}
8596
8597impl SseEncode for Option<crate::bindings::Amount> {
8598    // Codec=Sse (Serialization based), see doc to use other codecs
8599    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8600        <bool>::sse_encode(self.is_some(), serializer);
8601        if let Some(value) = self {
8602            <crate::bindings::Amount>::sse_encode(value, serializer);
8603        }
8604    }
8605}
8606
8607impl SseEncode for Option<crate::model::AssetInfo> {
8608    // Codec=Sse (Serialization based), see doc to use other codecs
8609    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8610        <bool>::sse_encode(self.is_some(), serializer);
8611        if let Some(value) = self {
8612            <crate::model::AssetInfo>::sse_encode(value, serializer);
8613        }
8614    }
8615}
8616
8617impl SseEncode for Option<bool> {
8618    // Codec=Sse (Serialization based), see doc to use other codecs
8619    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8620        <bool>::sse_encode(self.is_some(), serializer);
8621        if let Some(value) = self {
8622            <bool>::sse_encode(value, serializer);
8623        }
8624    }
8625}
8626
8627impl SseEncode for Option<f64> {
8628    // Codec=Sse (Serialization based), see doc to use other codecs
8629    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8630        <bool>::sse_encode(self.is_some(), serializer);
8631        if let Some(value) = self {
8632            <f64>::sse_encode(value, serializer);
8633        }
8634    }
8635}
8636
8637impl SseEncode for Option<i64> {
8638    // Codec=Sse (Serialization based), see doc to use other codecs
8639    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8640        <bool>::sse_encode(self.is_some(), serializer);
8641        if let Some(value) = self {
8642            <i64>::sse_encode(value, serializer);
8643        }
8644    }
8645}
8646
8647impl SseEncode for Option<crate::model::ListPaymentDetails> {
8648    // Codec=Sse (Serialization based), see doc to use other codecs
8649    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8650        <bool>::sse_encode(self.is_some(), serializer);
8651        if let Some(value) = self {
8652            <crate::model::ListPaymentDetails>::sse_encode(value, serializer);
8653        }
8654    }
8655}
8656
8657impl SseEncode for Option<crate::model::LnUrlInfo> {
8658    // Codec=Sse (Serialization based), see doc to use other codecs
8659    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8660        <bool>::sse_encode(self.is_some(), serializer);
8661        if let Some(value) = self {
8662            <crate::model::LnUrlInfo>::sse_encode(value, serializer);
8663        }
8664    }
8665}
8666
8667impl SseEncode for Option<crate::model::PayAmount> {
8668    // Codec=Sse (Serialization based), see doc to use other codecs
8669    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8670        <bool>::sse_encode(self.is_some(), serializer);
8671        if let Some(value) = self {
8672            <crate::model::PayAmount>::sse_encode(value, serializer);
8673        }
8674    }
8675}
8676
8677impl SseEncode for Option<crate::model::Payment> {
8678    // Codec=Sse (Serialization based), see doc to use other codecs
8679    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8680        <bool>::sse_encode(self.is_some(), serializer);
8681        if let Some(value) = self {
8682            <crate::model::Payment>::sse_encode(value, serializer);
8683        }
8684    }
8685}
8686
8687impl SseEncode for Option<crate::model::ReceiveAmount> {
8688    // Codec=Sse (Serialization based), see doc to use other codecs
8689    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8690        <bool>::sse_encode(self.is_some(), serializer);
8691        if let Some(value) = self {
8692            <crate::model::ReceiveAmount>::sse_encode(value, serializer);
8693        }
8694    }
8695}
8696
8697impl SseEncode for Option<crate::bindings::SuccessAction> {
8698    // Codec=Sse (Serialization based), see doc to use other codecs
8699    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8700        <bool>::sse_encode(self.is_some(), serializer);
8701        if let Some(value) = self {
8702            <crate::bindings::SuccessAction>::sse_encode(value, serializer);
8703        }
8704    }
8705}
8706
8707impl SseEncode for Option<crate::bindings::SuccessActionProcessed> {
8708    // Codec=Sse (Serialization based), see doc to use other codecs
8709    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8710        <bool>::sse_encode(self.is_some(), serializer);
8711        if let Some(value) = self {
8712            <crate::bindings::SuccessActionProcessed>::sse_encode(value, serializer);
8713        }
8714    }
8715}
8716
8717impl SseEncode for Option<crate::bindings::Symbol> {
8718    // Codec=Sse (Serialization based), see doc to use other codecs
8719    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8720        <bool>::sse_encode(self.is_some(), serializer);
8721        if let Some(value) = self {
8722            <crate::bindings::Symbol>::sse_encode(value, serializer);
8723        }
8724    }
8725}
8726
8727impl SseEncode for Option<u32> {
8728    // Codec=Sse (Serialization based), see doc to use other codecs
8729    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8730        <bool>::sse_encode(self.is_some(), serializer);
8731        if let Some(value) = self {
8732            <u32>::sse_encode(value, serializer);
8733        }
8734    }
8735}
8736
8737impl SseEncode for Option<u64> {
8738    // Codec=Sse (Serialization based), see doc to use other codecs
8739    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8740        <bool>::sse_encode(self.is_some(), serializer);
8741        if let Some(value) = self {
8742            <u64>::sse_encode(value, serializer);
8743        }
8744    }
8745}
8746
8747impl SseEncode for Option<Vec<crate::model::AssetMetadata>> {
8748    // Codec=Sse (Serialization based), see doc to use other codecs
8749    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8750        <bool>::sse_encode(self.is_some(), serializer);
8751        if let Some(value) = self {
8752            <Vec<crate::model::AssetMetadata>>::sse_encode(value, serializer);
8753        }
8754    }
8755}
8756
8757impl SseEncode for Option<Vec<crate::bindings::ExternalInputParser>> {
8758    // Codec=Sse (Serialization based), see doc to use other codecs
8759    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8760        <bool>::sse_encode(self.is_some(), serializer);
8761        if let Some(value) = self {
8762            <Vec<crate::bindings::ExternalInputParser>>::sse_encode(value, serializer);
8763        }
8764    }
8765}
8766
8767impl SseEncode for Option<Vec<crate::model::PaymentState>> {
8768    // Codec=Sse (Serialization based), see doc to use other codecs
8769    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8770        <bool>::sse_encode(self.is_some(), serializer);
8771        if let Some(value) = self {
8772            <Vec<crate::model::PaymentState>>::sse_encode(value, serializer);
8773        }
8774    }
8775}
8776
8777impl SseEncode for Option<Vec<crate::model::PaymentType>> {
8778    // Codec=Sse (Serialization based), see doc to use other codecs
8779    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8780        <bool>::sse_encode(self.is_some(), serializer);
8781        if let Some(value) = self {
8782            <Vec<crate::model::PaymentType>>::sse_encode(value, serializer);
8783        }
8784    }
8785}
8786
8787impl SseEncode for Option<Vec<u8>> {
8788    // Codec=Sse (Serialization based), see doc to use other codecs
8789    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8790        <bool>::sse_encode(self.is_some(), serializer);
8791        if let Some(value) = self {
8792            <Vec<u8>>::sse_encode(value, serializer);
8793        }
8794    }
8795}
8796
8797impl SseEncode for crate::model::PayAmount {
8798    // Codec=Sse (Serialization based), see doc to use other codecs
8799    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8800        match self {
8801            crate::model::PayAmount::Bitcoin {
8802                receiver_amount_sat,
8803            } => {
8804                <i32>::sse_encode(0, serializer);
8805                <u64>::sse_encode(receiver_amount_sat, serializer);
8806            }
8807            crate::model::PayAmount::Asset {
8808                asset_id,
8809                receiver_amount,
8810                estimate_asset_fees,
8811            } => {
8812                <i32>::sse_encode(1, serializer);
8813                <String>::sse_encode(asset_id, serializer);
8814                <f64>::sse_encode(receiver_amount, serializer);
8815                <Option<bool>>::sse_encode(estimate_asset_fees, serializer);
8816            }
8817            crate::model::PayAmount::Drain => {
8818                <i32>::sse_encode(2, serializer);
8819            }
8820            _ => {
8821                unimplemented!("");
8822            }
8823        }
8824    }
8825}
8826
8827impl SseEncode for crate::model::PayOnchainRequest {
8828    // Codec=Sse (Serialization based), see doc to use other codecs
8829    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8830        <String>::sse_encode(self.address, serializer);
8831        <crate::model::PreparePayOnchainResponse>::sse_encode(self.prepare_response, serializer);
8832    }
8833}
8834
8835impl SseEncode for crate::model::Payment {
8836    // Codec=Sse (Serialization based), see doc to use other codecs
8837    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8838        <Option<String>>::sse_encode(self.destination, serializer);
8839        <Option<String>>::sse_encode(self.tx_id, serializer);
8840        <Option<String>>::sse_encode(self.unblinding_data, serializer);
8841        <u32>::sse_encode(self.timestamp, serializer);
8842        <u64>::sse_encode(self.amount_sat, serializer);
8843        <u64>::sse_encode(self.fees_sat, serializer);
8844        <Option<u64>>::sse_encode(self.swapper_fees_sat, serializer);
8845        <crate::model::PaymentType>::sse_encode(self.payment_type, serializer);
8846        <crate::model::PaymentState>::sse_encode(self.status, serializer);
8847        <crate::model::PaymentDetails>::sse_encode(self.details, serializer);
8848    }
8849}
8850
8851impl SseEncode for crate::model::PaymentDetails {
8852    // Codec=Sse (Serialization based), see doc to use other codecs
8853    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8854        match self {
8855            crate::model::PaymentDetails::Lightning {
8856                swap_id,
8857                description,
8858                liquid_expiration_blockheight,
8859                preimage,
8860                invoice,
8861                bolt12_offer,
8862                payment_hash,
8863                destination_pubkey,
8864                lnurl_info,
8865                bip353_address,
8866                payer_note,
8867                claim_tx_id,
8868                refund_tx_id,
8869                refund_tx_amount_sat,
8870            } => {
8871                <i32>::sse_encode(0, serializer);
8872                <String>::sse_encode(swap_id, serializer);
8873                <String>::sse_encode(description, serializer);
8874                <u32>::sse_encode(liquid_expiration_blockheight, serializer);
8875                <Option<String>>::sse_encode(preimage, serializer);
8876                <Option<String>>::sse_encode(invoice, serializer);
8877                <Option<String>>::sse_encode(bolt12_offer, serializer);
8878                <Option<String>>::sse_encode(payment_hash, serializer);
8879                <Option<String>>::sse_encode(destination_pubkey, serializer);
8880                <Option<crate::model::LnUrlInfo>>::sse_encode(lnurl_info, serializer);
8881                <Option<String>>::sse_encode(bip353_address, serializer);
8882                <Option<String>>::sse_encode(payer_note, serializer);
8883                <Option<String>>::sse_encode(claim_tx_id, serializer);
8884                <Option<String>>::sse_encode(refund_tx_id, serializer);
8885                <Option<u64>>::sse_encode(refund_tx_amount_sat, serializer);
8886            }
8887            crate::model::PaymentDetails::Liquid {
8888                destination,
8889                description,
8890                asset_id,
8891                asset_info,
8892                lnurl_info,
8893                bip353_address,
8894                payer_note,
8895            } => {
8896                <i32>::sse_encode(1, serializer);
8897                <String>::sse_encode(destination, serializer);
8898                <String>::sse_encode(description, serializer);
8899                <String>::sse_encode(asset_id, serializer);
8900                <Option<crate::model::AssetInfo>>::sse_encode(asset_info, serializer);
8901                <Option<crate::model::LnUrlInfo>>::sse_encode(lnurl_info, serializer);
8902                <Option<String>>::sse_encode(bip353_address, serializer);
8903                <Option<String>>::sse_encode(payer_note, serializer);
8904            }
8905            crate::model::PaymentDetails::Bitcoin {
8906                swap_id,
8907                bitcoin_address,
8908                description,
8909                auto_accepted_fees,
8910                liquid_expiration_blockheight,
8911                bitcoin_expiration_blockheight,
8912                lockup_tx_id,
8913                claim_tx_id,
8914                refund_tx_id,
8915                refund_tx_amount_sat,
8916            } => {
8917                <i32>::sse_encode(2, serializer);
8918                <String>::sse_encode(swap_id, serializer);
8919                <String>::sse_encode(bitcoin_address, serializer);
8920                <String>::sse_encode(description, serializer);
8921                <bool>::sse_encode(auto_accepted_fees, serializer);
8922                <Option<u32>>::sse_encode(liquid_expiration_blockheight, serializer);
8923                <Option<u32>>::sse_encode(bitcoin_expiration_blockheight, serializer);
8924                <Option<String>>::sse_encode(lockup_tx_id, serializer);
8925                <Option<String>>::sse_encode(claim_tx_id, serializer);
8926                <Option<String>>::sse_encode(refund_tx_id, serializer);
8927                <Option<u64>>::sse_encode(refund_tx_amount_sat, serializer);
8928            }
8929            _ => {
8930                unimplemented!("");
8931            }
8932        }
8933    }
8934}
8935
8936impl SseEncode for crate::error::PaymentError {
8937    // Codec=Sse (Serialization based), see doc to use other codecs
8938    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8939        match self {
8940            crate::error::PaymentError::AlreadyClaimed => {
8941                <i32>::sse_encode(0, serializer);
8942            }
8943            crate::error::PaymentError::AlreadyPaid => {
8944                <i32>::sse_encode(1, serializer);
8945            }
8946            crate::error::PaymentError::PaymentInProgress => {
8947                <i32>::sse_encode(2, serializer);
8948            }
8949            crate::error::PaymentError::AmountOutOfRange { min, max } => {
8950                <i32>::sse_encode(3, serializer);
8951                <u64>::sse_encode(min, serializer);
8952                <u64>::sse_encode(max, serializer);
8953            }
8954            crate::error::PaymentError::AmountMissing { err } => {
8955                <i32>::sse_encode(4, serializer);
8956                <String>::sse_encode(err, serializer);
8957            }
8958            crate::error::PaymentError::AssetError { err } => {
8959                <i32>::sse_encode(5, serializer);
8960                <String>::sse_encode(err, serializer);
8961            }
8962            crate::error::PaymentError::InvalidNetwork { err } => {
8963                <i32>::sse_encode(6, serializer);
8964                <String>::sse_encode(err, serializer);
8965            }
8966            crate::error::PaymentError::Generic { err } => {
8967                <i32>::sse_encode(7, serializer);
8968                <String>::sse_encode(err, serializer);
8969            }
8970            crate::error::PaymentError::InvalidOrExpiredFees => {
8971                <i32>::sse_encode(8, serializer);
8972            }
8973            crate::error::PaymentError::InsufficientFunds => {
8974                <i32>::sse_encode(9, serializer);
8975            }
8976            crate::error::PaymentError::InvalidDescription { err } => {
8977                <i32>::sse_encode(10, serializer);
8978                <String>::sse_encode(err, serializer);
8979            }
8980            crate::error::PaymentError::InvalidInvoice { err } => {
8981                <i32>::sse_encode(11, serializer);
8982                <String>::sse_encode(err, serializer);
8983            }
8984            crate::error::PaymentError::InvalidPreimage => {
8985                <i32>::sse_encode(12, serializer);
8986            }
8987            crate::error::PaymentError::PairsNotFound => {
8988                <i32>::sse_encode(13, serializer);
8989            }
8990            crate::error::PaymentError::PaymentTimeout => {
8991                <i32>::sse_encode(14, serializer);
8992            }
8993            crate::error::PaymentError::PersistError => {
8994                <i32>::sse_encode(15, serializer);
8995            }
8996            crate::error::PaymentError::ReceiveError { err } => {
8997                <i32>::sse_encode(16, serializer);
8998                <String>::sse_encode(err, serializer);
8999            }
9000            crate::error::PaymentError::Refunded { err, refund_tx_id } => {
9001                <i32>::sse_encode(17, serializer);
9002                <String>::sse_encode(err, serializer);
9003                <String>::sse_encode(refund_tx_id, serializer);
9004            }
9005            crate::error::PaymentError::SelfTransferNotSupported => {
9006                <i32>::sse_encode(18, serializer);
9007            }
9008            crate::error::PaymentError::SendError { err } => {
9009                <i32>::sse_encode(19, serializer);
9010                <String>::sse_encode(err, serializer);
9011            }
9012            crate::error::PaymentError::SignerError { err } => {
9013                <i32>::sse_encode(20, serializer);
9014                <String>::sse_encode(err, serializer);
9015            }
9016            _ => {
9017                unimplemented!("");
9018            }
9019        }
9020    }
9021}
9022
9023impl SseEncode for crate::model::PaymentMethod {
9024    // Codec=Sse (Serialization based), see doc to use other codecs
9025    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9026        <i32>::sse_encode(
9027            match self {
9028                crate::model::PaymentMethod::Lightning => 0,
9029                crate::model::PaymentMethod::Bolt11Invoice => 1,
9030                crate::model::PaymentMethod::Bolt12Offer => 2,
9031                crate::model::PaymentMethod::BitcoinAddress => 3,
9032                crate::model::PaymentMethod::LiquidAddress => 4,
9033                _ => {
9034                    unimplemented!("");
9035                }
9036            },
9037            serializer,
9038        );
9039    }
9040}
9041
9042impl SseEncode for crate::model::PaymentState {
9043    // Codec=Sse (Serialization based), see doc to use other codecs
9044    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9045        <i32>::sse_encode(
9046            match self {
9047                crate::model::PaymentState::Created => 0,
9048                crate::model::PaymentState::Pending => 1,
9049                crate::model::PaymentState::Complete => 2,
9050                crate::model::PaymentState::Failed => 3,
9051                crate::model::PaymentState::TimedOut => 4,
9052                crate::model::PaymentState::Refundable => 5,
9053                crate::model::PaymentState::RefundPending => 6,
9054                crate::model::PaymentState::WaitingFeeAcceptance => 7,
9055                _ => {
9056                    unimplemented!("");
9057                }
9058            },
9059            serializer,
9060        );
9061    }
9062}
9063
9064impl SseEncode for crate::model::PaymentType {
9065    // Codec=Sse (Serialization based), see doc to use other codecs
9066    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9067        <i32>::sse_encode(
9068            match self {
9069                crate::model::PaymentType::Receive => 0,
9070                crate::model::PaymentType::Send => 1,
9071                _ => {
9072                    unimplemented!("");
9073                }
9074            },
9075            serializer,
9076        );
9077    }
9078}
9079
9080impl SseEncode for crate::model::PrepareBuyBitcoinRequest {
9081    // Codec=Sse (Serialization based), see doc to use other codecs
9082    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9083        <crate::model::BuyBitcoinProvider>::sse_encode(self.provider, serializer);
9084        <u64>::sse_encode(self.amount_sat, serializer);
9085    }
9086}
9087
9088impl SseEncode for crate::model::PrepareBuyBitcoinResponse {
9089    // Codec=Sse (Serialization based), see doc to use other codecs
9090    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9091        <crate::model::BuyBitcoinProvider>::sse_encode(self.provider, serializer);
9092        <u64>::sse_encode(self.amount_sat, serializer);
9093        <u64>::sse_encode(self.fees_sat, serializer);
9094    }
9095}
9096
9097impl SseEncode for crate::model::PrepareLnUrlPayRequest {
9098    // Codec=Sse (Serialization based), see doc to use other codecs
9099    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9100        <crate::bindings::LnUrlPayRequestData>::sse_encode(self.data, serializer);
9101        <crate::model::PayAmount>::sse_encode(self.amount, serializer);
9102        <Option<String>>::sse_encode(self.bip353_address, serializer);
9103        <Option<String>>::sse_encode(self.comment, serializer);
9104        <Option<bool>>::sse_encode(self.validate_success_action_url, serializer);
9105    }
9106}
9107
9108impl SseEncode for crate::model::PrepareLnUrlPayResponse {
9109    // Codec=Sse (Serialization based), see doc to use other codecs
9110    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9111        <crate::model::SendDestination>::sse_encode(self.destination, serializer);
9112        <u64>::sse_encode(self.fees_sat, serializer);
9113        <crate::bindings::LnUrlPayRequestData>::sse_encode(self.data, serializer);
9114        <crate::model::PayAmount>::sse_encode(self.amount, serializer);
9115        <Option<String>>::sse_encode(self.comment, serializer);
9116        <Option<crate::bindings::SuccessAction>>::sse_encode(self.success_action, serializer);
9117    }
9118}
9119
9120impl SseEncode for crate::model::PreparePayOnchainRequest {
9121    // Codec=Sse (Serialization based), see doc to use other codecs
9122    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9123        <crate::model::PayAmount>::sse_encode(self.amount, serializer);
9124        <Option<u32>>::sse_encode(self.fee_rate_sat_per_vbyte, serializer);
9125    }
9126}
9127
9128impl SseEncode for crate::model::PreparePayOnchainResponse {
9129    // Codec=Sse (Serialization based), see doc to use other codecs
9130    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9131        <u64>::sse_encode(self.receiver_amount_sat, serializer);
9132        <u64>::sse_encode(self.claim_fees_sat, serializer);
9133        <u64>::sse_encode(self.total_fees_sat, serializer);
9134    }
9135}
9136
9137impl SseEncode for crate::model::PrepareReceiveRequest {
9138    // Codec=Sse (Serialization based), see doc to use other codecs
9139    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9140        <crate::model::PaymentMethod>::sse_encode(self.payment_method, serializer);
9141        <Option<crate::model::ReceiveAmount>>::sse_encode(self.amount, serializer);
9142    }
9143}
9144
9145impl SseEncode for crate::model::PrepareReceiveResponse {
9146    // Codec=Sse (Serialization based), see doc to use other codecs
9147    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9148        <crate::model::PaymentMethod>::sse_encode(self.payment_method, serializer);
9149        <u64>::sse_encode(self.fees_sat, serializer);
9150        <Option<crate::model::ReceiveAmount>>::sse_encode(self.amount, serializer);
9151        <Option<u64>>::sse_encode(self.min_payer_amount_sat, serializer);
9152        <Option<u64>>::sse_encode(self.max_payer_amount_sat, serializer);
9153        <Option<f64>>::sse_encode(self.swapper_feerate, serializer);
9154    }
9155}
9156
9157impl SseEncode for crate::model::PrepareRefundRequest {
9158    // Codec=Sse (Serialization based), see doc to use other codecs
9159    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9160        <String>::sse_encode(self.swap_address, serializer);
9161        <String>::sse_encode(self.refund_address, serializer);
9162        <u32>::sse_encode(self.fee_rate_sat_per_vbyte, serializer);
9163    }
9164}
9165
9166impl SseEncode for crate::model::PrepareRefundResponse {
9167    // Codec=Sse (Serialization based), see doc to use other codecs
9168    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9169        <u32>::sse_encode(self.tx_vsize, serializer);
9170        <u64>::sse_encode(self.tx_fee_sat, serializer);
9171        <Option<String>>::sse_encode(self.last_refund_tx_id, serializer);
9172    }
9173}
9174
9175impl SseEncode for crate::model::PrepareSendRequest {
9176    // Codec=Sse (Serialization based), see doc to use other codecs
9177    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9178        <String>::sse_encode(self.destination, serializer);
9179        <Option<crate::model::PayAmount>>::sse_encode(self.amount, serializer);
9180    }
9181}
9182
9183impl SseEncode for crate::model::PrepareSendResponse {
9184    // Codec=Sse (Serialization based), see doc to use other codecs
9185    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9186        <crate::model::SendDestination>::sse_encode(self.destination, serializer);
9187        <Option<crate::model::PayAmount>>::sse_encode(self.amount, serializer);
9188        <Option<u64>>::sse_encode(self.fees_sat, serializer);
9189        <Option<f64>>::sse_encode(self.estimated_asset_fees, serializer);
9190    }
9191}
9192
9193impl SseEncode for crate::bindings::Rate {
9194    // Codec=Sse (Serialization based), see doc to use other codecs
9195    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9196        <String>::sse_encode(self.coin, serializer);
9197        <f64>::sse_encode(self.value, serializer);
9198    }
9199}
9200
9201impl SseEncode for crate::model::ReceiveAmount {
9202    // Codec=Sse (Serialization based), see doc to use other codecs
9203    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9204        match self {
9205            crate::model::ReceiveAmount::Bitcoin { payer_amount_sat } => {
9206                <i32>::sse_encode(0, serializer);
9207                <u64>::sse_encode(payer_amount_sat, serializer);
9208            }
9209            crate::model::ReceiveAmount::Asset {
9210                asset_id,
9211                payer_amount,
9212            } => {
9213                <i32>::sse_encode(1, serializer);
9214                <String>::sse_encode(asset_id, serializer);
9215                <Option<f64>>::sse_encode(payer_amount, serializer);
9216            }
9217            _ => {
9218                unimplemented!("");
9219            }
9220        }
9221    }
9222}
9223
9224impl SseEncode for crate::model::ReceivePaymentRequest {
9225    // Codec=Sse (Serialization based), see doc to use other codecs
9226    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9227        <crate::model::PrepareReceiveResponse>::sse_encode(self.prepare_response, serializer);
9228        <Option<String>>::sse_encode(self.description, serializer);
9229        <Option<bool>>::sse_encode(self.use_description_hash, serializer);
9230        <Option<String>>::sse_encode(self.payer_note, serializer);
9231    }
9232}
9233
9234impl SseEncode for crate::model::ReceivePaymentResponse {
9235    // Codec=Sse (Serialization based), see doc to use other codecs
9236    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9237        <String>::sse_encode(self.destination, serializer);
9238    }
9239}
9240
9241impl SseEncode for crate::model::RecommendedFees {
9242    // Codec=Sse (Serialization based), see doc to use other codecs
9243    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9244        <u64>::sse_encode(self.fastest_fee, serializer);
9245        <u64>::sse_encode(self.half_hour_fee, serializer);
9246        <u64>::sse_encode(self.hour_fee, serializer);
9247        <u64>::sse_encode(self.economy_fee, serializer);
9248        <u64>::sse_encode(self.minimum_fee, serializer);
9249    }
9250}
9251
9252impl SseEncode for crate::model::RefundRequest {
9253    // Codec=Sse (Serialization based), see doc to use other codecs
9254    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9255        <String>::sse_encode(self.swap_address, serializer);
9256        <String>::sse_encode(self.refund_address, serializer);
9257        <u32>::sse_encode(self.fee_rate_sat_per_vbyte, serializer);
9258    }
9259}
9260
9261impl SseEncode for crate::model::RefundResponse {
9262    // Codec=Sse (Serialization based), see doc to use other codecs
9263    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9264        <String>::sse_encode(self.refund_tx_id, serializer);
9265    }
9266}
9267
9268impl SseEncode for crate::model::RefundableSwap {
9269    // Codec=Sse (Serialization based), see doc to use other codecs
9270    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9271        <String>::sse_encode(self.swap_address, serializer);
9272        <u32>::sse_encode(self.timestamp, serializer);
9273        <u64>::sse_encode(self.amount_sat, serializer);
9274        <Option<String>>::sse_encode(self.last_refund_tx_id, serializer);
9275    }
9276}
9277
9278impl SseEncode for crate::model::RestoreRequest {
9279    // Codec=Sse (Serialization based), see doc to use other codecs
9280    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9281        <Option<String>>::sse_encode(self.backup_path, serializer);
9282    }
9283}
9284
9285impl SseEncode for crate::bindings::RouteHint {
9286    // Codec=Sse (Serialization based), see doc to use other codecs
9287    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9288        <Vec<crate::bindings::RouteHintHop>>::sse_encode(self.hops, serializer);
9289    }
9290}
9291
9292impl SseEncode for crate::bindings::RouteHintHop {
9293    // Codec=Sse (Serialization based), see doc to use other codecs
9294    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9295        <String>::sse_encode(self.src_node_id, serializer);
9296        <String>::sse_encode(self.short_channel_id, serializer);
9297        <u32>::sse_encode(self.fees_base_msat, serializer);
9298        <u32>::sse_encode(self.fees_proportional_millionths, serializer);
9299        <u64>::sse_encode(self.cltv_expiry_delta, serializer);
9300        <Option<u64>>::sse_encode(self.htlc_minimum_msat, serializer);
9301        <Option<u64>>::sse_encode(self.htlc_maximum_msat, serializer);
9302    }
9303}
9304
9305impl SseEncode for crate::error::SdkError {
9306    // Codec=Sse (Serialization based), see doc to use other codecs
9307    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9308        match self {
9309            crate::error::SdkError::AlreadyStarted => {
9310                <i32>::sse_encode(0, serializer);
9311            }
9312            crate::error::SdkError::Generic { err } => {
9313                <i32>::sse_encode(1, serializer);
9314                <String>::sse_encode(err, serializer);
9315            }
9316            crate::error::SdkError::NotStarted => {
9317                <i32>::sse_encode(2, serializer);
9318            }
9319            crate::error::SdkError::ServiceConnectivity { err } => {
9320                <i32>::sse_encode(3, serializer);
9321                <String>::sse_encode(err, serializer);
9322            }
9323            _ => {
9324                unimplemented!("");
9325            }
9326        }
9327    }
9328}
9329
9330impl SseEncode for crate::model::SdkEvent {
9331    // Codec=Sse (Serialization based), see doc to use other codecs
9332    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9333        match self {
9334            crate::model::SdkEvent::PaymentFailed { details } => {
9335                <i32>::sse_encode(0, serializer);
9336                <crate::model::Payment>::sse_encode(details, serializer);
9337            }
9338            crate::model::SdkEvent::PaymentPending { details } => {
9339                <i32>::sse_encode(1, serializer);
9340                <crate::model::Payment>::sse_encode(details, serializer);
9341            }
9342            crate::model::SdkEvent::PaymentRefundable { details } => {
9343                <i32>::sse_encode(2, serializer);
9344                <crate::model::Payment>::sse_encode(details, serializer);
9345            }
9346            crate::model::SdkEvent::PaymentRefunded { details } => {
9347                <i32>::sse_encode(3, serializer);
9348                <crate::model::Payment>::sse_encode(details, serializer);
9349            }
9350            crate::model::SdkEvent::PaymentRefundPending { details } => {
9351                <i32>::sse_encode(4, serializer);
9352                <crate::model::Payment>::sse_encode(details, serializer);
9353            }
9354            crate::model::SdkEvent::PaymentSucceeded { details } => {
9355                <i32>::sse_encode(5, serializer);
9356                <crate::model::Payment>::sse_encode(details, serializer);
9357            }
9358            crate::model::SdkEvent::PaymentWaitingConfirmation { details } => {
9359                <i32>::sse_encode(6, serializer);
9360                <crate::model::Payment>::sse_encode(details, serializer);
9361            }
9362            crate::model::SdkEvent::PaymentWaitingFeeAcceptance { details } => {
9363                <i32>::sse_encode(7, serializer);
9364                <crate::model::Payment>::sse_encode(details, serializer);
9365            }
9366            crate::model::SdkEvent::Synced => {
9367                <i32>::sse_encode(8, serializer);
9368            }
9369            crate::model::SdkEvent::DataSynced {
9370                did_pull_new_records,
9371            } => {
9372                <i32>::sse_encode(9, serializer);
9373                <bool>::sse_encode(did_pull_new_records, serializer);
9374            }
9375            _ => {
9376                unimplemented!("");
9377            }
9378        }
9379    }
9380}
9381
9382impl SseEncode for crate::model::SendDestination {
9383    // Codec=Sse (Serialization based), see doc to use other codecs
9384    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9385        match self {
9386            crate::model::SendDestination::LiquidAddress {
9387                address_data,
9388                bip353_address,
9389            } => {
9390                <i32>::sse_encode(0, serializer);
9391                <crate::bindings::LiquidAddressData>::sse_encode(address_data, serializer);
9392                <Option<String>>::sse_encode(bip353_address, serializer);
9393            }
9394            crate::model::SendDestination::Bolt11 {
9395                invoice,
9396                bip353_address,
9397            } => {
9398                <i32>::sse_encode(1, serializer);
9399                <crate::bindings::LNInvoice>::sse_encode(invoice, serializer);
9400                <Option<String>>::sse_encode(bip353_address, serializer);
9401            }
9402            crate::model::SendDestination::Bolt12 {
9403                offer,
9404                receiver_amount_sat,
9405                bip353_address,
9406            } => {
9407                <i32>::sse_encode(2, serializer);
9408                <crate::bindings::LNOffer>::sse_encode(offer, serializer);
9409                <u64>::sse_encode(receiver_amount_sat, serializer);
9410                <Option<String>>::sse_encode(bip353_address, serializer);
9411            }
9412            _ => {
9413                unimplemented!("");
9414            }
9415        }
9416    }
9417}
9418
9419impl SseEncode for crate::model::SendPaymentRequest {
9420    // Codec=Sse (Serialization based), see doc to use other codecs
9421    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9422        <crate::model::PrepareSendResponse>::sse_encode(self.prepare_response, serializer);
9423        <Option<bool>>::sse_encode(self.use_asset_fees, serializer);
9424        <Option<String>>::sse_encode(self.payer_note, serializer);
9425    }
9426}
9427
9428impl SseEncode for crate::model::SendPaymentResponse {
9429    // Codec=Sse (Serialization based), see doc to use other codecs
9430    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9431        <crate::model::Payment>::sse_encode(self.payment, serializer);
9432    }
9433}
9434
9435impl SseEncode for crate::model::SignMessageRequest {
9436    // Codec=Sse (Serialization based), see doc to use other codecs
9437    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9438        <String>::sse_encode(self.message, serializer);
9439    }
9440}
9441
9442impl SseEncode for crate::model::SignMessageResponse {
9443    // Codec=Sse (Serialization based), see doc to use other codecs
9444    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9445        <String>::sse_encode(self.signature, serializer);
9446    }
9447}
9448
9449impl SseEncode for crate::bindings::SuccessAction {
9450    // Codec=Sse (Serialization based), see doc to use other codecs
9451    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9452        match self {
9453            crate::bindings::SuccessAction::Aes { data } => {
9454                <i32>::sse_encode(0, serializer);
9455                <crate::bindings::AesSuccessActionData>::sse_encode(data, serializer);
9456            }
9457            crate::bindings::SuccessAction::Message { data } => {
9458                <i32>::sse_encode(1, serializer);
9459                <crate::bindings::MessageSuccessActionData>::sse_encode(data, serializer);
9460            }
9461            crate::bindings::SuccessAction::Url { data } => {
9462                <i32>::sse_encode(2, serializer);
9463                <crate::bindings::UrlSuccessActionData>::sse_encode(data, serializer);
9464            }
9465            _ => {
9466                unimplemented!("");
9467            }
9468        }
9469    }
9470}
9471
9472impl SseEncode for crate::bindings::SuccessActionProcessed {
9473    // Codec=Sse (Serialization based), see doc to use other codecs
9474    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9475        match self {
9476            crate::bindings::SuccessActionProcessed::Aes { result } => {
9477                <i32>::sse_encode(0, serializer);
9478                <crate::bindings::AesSuccessActionDataResult>::sse_encode(result, serializer);
9479            }
9480            crate::bindings::SuccessActionProcessed::Message { data } => {
9481                <i32>::sse_encode(1, serializer);
9482                <crate::bindings::MessageSuccessActionData>::sse_encode(data, serializer);
9483            }
9484            crate::bindings::SuccessActionProcessed::Url { data } => {
9485                <i32>::sse_encode(2, serializer);
9486                <crate::bindings::UrlSuccessActionData>::sse_encode(data, serializer);
9487            }
9488            _ => {
9489                unimplemented!("");
9490            }
9491        }
9492    }
9493}
9494
9495impl SseEncode for crate::bindings::Symbol {
9496    // Codec=Sse (Serialization based), see doc to use other codecs
9497    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9498        <Option<String>>::sse_encode(self.grapheme, serializer);
9499        <Option<String>>::sse_encode(self.template, serializer);
9500        <Option<bool>>::sse_encode(self.rtl, serializer);
9501        <Option<u32>>::sse_encode(self.position, serializer);
9502    }
9503}
9504
9505impl SseEncode for u16 {
9506    // Codec=Sse (Serialization based), see doc to use other codecs
9507    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9508        serializer.cursor.write_u16::<NativeEndian>(self).unwrap();
9509    }
9510}
9511
9512impl SseEncode for u32 {
9513    // Codec=Sse (Serialization based), see doc to use other codecs
9514    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9515        serializer.cursor.write_u32::<NativeEndian>(self).unwrap();
9516    }
9517}
9518
9519impl SseEncode for u64 {
9520    // Codec=Sse (Serialization based), see doc to use other codecs
9521    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9522        serializer.cursor.write_u64::<NativeEndian>(self).unwrap();
9523    }
9524}
9525
9526impl SseEncode for u8 {
9527    // Codec=Sse (Serialization based), see doc to use other codecs
9528    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9529        serializer.cursor.write_u8(self).unwrap();
9530    }
9531}
9532
9533impl SseEncode for () {
9534    // Codec=Sse (Serialization based), see doc to use other codecs
9535    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {}
9536}
9537
9538impl SseEncode for crate::bindings::UrlSuccessActionData {
9539    // Codec=Sse (Serialization based), see doc to use other codecs
9540    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9541        <String>::sse_encode(self.description, serializer);
9542        <String>::sse_encode(self.url, serializer);
9543        <bool>::sse_encode(self.matches_callback_domain, serializer);
9544    }
9545}
9546
9547impl SseEncode for usize {
9548    // Codec=Sse (Serialization based), see doc to use other codecs
9549    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9550        serializer
9551            .cursor
9552            .write_u64::<NativeEndian>(self as _)
9553            .unwrap();
9554    }
9555}
9556
9557impl SseEncode for crate::model::WalletInfo {
9558    // Codec=Sse (Serialization based), see doc to use other codecs
9559    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9560        <u64>::sse_encode(self.balance_sat, serializer);
9561        <u64>::sse_encode(self.pending_send_sat, serializer);
9562        <u64>::sse_encode(self.pending_receive_sat, serializer);
9563        <String>::sse_encode(self.fingerprint, serializer);
9564        <String>::sse_encode(self.pubkey, serializer);
9565        <Vec<crate::model::AssetBalance>>::sse_encode(self.asset_balances, serializer);
9566    }
9567}
9568
9569#[cfg(not(target_family = "wasm"))]
9570mod io {
9571    // This file is automatically generated, so please do not edit it.
9572    // @generated by `flutter_rust_bridge`@ 2.9.0.
9573
9574    // Section: imports
9575
9576    use super::*;
9577    use crate::bindings::*;
9578    use crate::model::EventListener;
9579    use flutter_rust_bridge::for_generated::byteorder::{
9580        NativeEndian, ReadBytesExt, WriteBytesExt,
9581    };
9582    use flutter_rust_bridge::for_generated::{transform_result_dco, Lifetimeable, Lockable};
9583    use flutter_rust_bridge::{Handler, IntoIntoDart};
9584
9585    // Section: boilerplate
9586
9587    flutter_rust_bridge::frb_generated_boilerplate_io!();
9588
9589    // Section: dart2rust
9590
9591    impl CstDecode<flutter_rust_bridge::for_generated::anyhow::Error>
9592        for *mut wire_cst_list_prim_u_8_strict
9593    {
9594        // Codec=Cst (C-struct based), see doc to use other codecs
9595        fn cst_decode(self) -> flutter_rust_bridge::for_generated::anyhow::Error {
9596            unimplemented!()
9597        }
9598    }
9599    impl CstDecode<BindingLiquidSdk> for usize {
9600        // Codec=Cst (C-struct based), see doc to use other codecs
9601        fn cst_decode(self) -> BindingLiquidSdk {
9602            flutter_rust_bridge::for_generated::rust_auto_opaque_decode_owned(CstDecode::<
9603                RustOpaqueNom<
9604                    flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>,
9605                >,
9606            >::cst_decode(
9607                self
9608            ))
9609        }
9610    }
9611    impl
9612        CstDecode<
9613            RustOpaqueNom<
9614                flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>,
9615            >,
9616        > for usize
9617    {
9618        // Codec=Cst (C-struct based), see doc to use other codecs
9619        fn cst_decode(
9620            self,
9621        ) -> RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>
9622        {
9623            unsafe { decode_rust_opaque_nom(self as _) }
9624        }
9625    }
9626    impl CstDecode<StreamSink<crate::model::LogEntry, flutter_rust_bridge::for_generated::DcoCodec>>
9627        for *mut wire_cst_list_prim_u_8_strict
9628    {
9629        // Codec=Cst (C-struct based), see doc to use other codecs
9630        fn cst_decode(
9631            self,
9632        ) -> StreamSink<crate::model::LogEntry, flutter_rust_bridge::for_generated::DcoCodec>
9633        {
9634            let raw: String = self.cst_decode();
9635            StreamSink::deserialize(raw)
9636        }
9637    }
9638    impl CstDecode<StreamSink<crate::model::SdkEvent, flutter_rust_bridge::for_generated::DcoCodec>>
9639        for *mut wire_cst_list_prim_u_8_strict
9640    {
9641        // Codec=Cst (C-struct based), see doc to use other codecs
9642        fn cst_decode(
9643            self,
9644        ) -> StreamSink<crate::model::SdkEvent, flutter_rust_bridge::for_generated::DcoCodec>
9645        {
9646            let raw: String = self.cst_decode();
9647            StreamSink::deserialize(raw)
9648        }
9649    }
9650    impl CstDecode<String> for *mut wire_cst_list_prim_u_8_strict {
9651        // Codec=Cst (C-struct based), see doc to use other codecs
9652        fn cst_decode(self) -> String {
9653            let vec: Vec<u8> = self.cst_decode();
9654            String::from_utf8(vec).unwrap()
9655        }
9656    }
9657    impl CstDecode<crate::model::AcceptPaymentProposedFeesRequest>
9658        for wire_cst_accept_payment_proposed_fees_request
9659    {
9660        // Codec=Cst (C-struct based), see doc to use other codecs
9661        fn cst_decode(self) -> crate::model::AcceptPaymentProposedFeesRequest {
9662            crate::model::AcceptPaymentProposedFeesRequest {
9663                response: self.response.cst_decode(),
9664            }
9665        }
9666    }
9667    impl CstDecode<crate::bindings::AesSuccessActionData> for wire_cst_aes_success_action_data {
9668        // Codec=Cst (C-struct based), see doc to use other codecs
9669        fn cst_decode(self) -> crate::bindings::AesSuccessActionData {
9670            crate::bindings::AesSuccessActionData {
9671                description: self.description.cst_decode(),
9672                ciphertext: self.ciphertext.cst_decode(),
9673                iv: self.iv.cst_decode(),
9674            }
9675        }
9676    }
9677    impl CstDecode<crate::bindings::AesSuccessActionDataDecrypted>
9678        for wire_cst_aes_success_action_data_decrypted
9679    {
9680        // Codec=Cst (C-struct based), see doc to use other codecs
9681        fn cst_decode(self) -> crate::bindings::AesSuccessActionDataDecrypted {
9682            crate::bindings::AesSuccessActionDataDecrypted {
9683                description: self.description.cst_decode(),
9684                plaintext: self.plaintext.cst_decode(),
9685            }
9686        }
9687    }
9688    impl CstDecode<crate::bindings::AesSuccessActionDataResult>
9689        for wire_cst_aes_success_action_data_result
9690    {
9691        // Codec=Cst (C-struct based), see doc to use other codecs
9692        fn cst_decode(self) -> crate::bindings::AesSuccessActionDataResult {
9693            match self.tag {
9694                0 => {
9695                    let ans = unsafe { self.kind.Decrypted };
9696                    crate::bindings::AesSuccessActionDataResult::Decrypted {
9697                        data: ans.data.cst_decode(),
9698                    }
9699                }
9700                1 => {
9701                    let ans = unsafe { self.kind.ErrorStatus };
9702                    crate::bindings::AesSuccessActionDataResult::ErrorStatus {
9703                        reason: ans.reason.cst_decode(),
9704                    }
9705                }
9706                _ => unreachable!(),
9707            }
9708        }
9709    }
9710    impl CstDecode<crate::bindings::Amount> for wire_cst_amount {
9711        // Codec=Cst (C-struct based), see doc to use other codecs
9712        fn cst_decode(self) -> crate::bindings::Amount {
9713            match self.tag {
9714                0 => {
9715                    let ans = unsafe { self.kind.Bitcoin };
9716                    crate::bindings::Amount::Bitcoin {
9717                        amount_msat: ans.amount_msat.cst_decode(),
9718                    }
9719                }
9720                1 => {
9721                    let ans = unsafe { self.kind.Currency };
9722                    crate::bindings::Amount::Currency {
9723                        iso4217_code: ans.iso4217_code.cst_decode(),
9724                        fractional_amount: ans.fractional_amount.cst_decode(),
9725                    }
9726                }
9727                _ => unreachable!(),
9728            }
9729        }
9730    }
9731    impl CstDecode<crate::model::AssetBalance> for wire_cst_asset_balance {
9732        // Codec=Cst (C-struct based), see doc to use other codecs
9733        fn cst_decode(self) -> crate::model::AssetBalance {
9734            crate::model::AssetBalance {
9735                asset_id: self.asset_id.cst_decode(),
9736                balance_sat: self.balance_sat.cst_decode(),
9737                name: self.name.cst_decode(),
9738                ticker: self.ticker.cst_decode(),
9739                balance: self.balance.cst_decode(),
9740            }
9741        }
9742    }
9743    impl CstDecode<crate::model::AssetInfo> for wire_cst_asset_info {
9744        // Codec=Cst (C-struct based), see doc to use other codecs
9745        fn cst_decode(self) -> crate::model::AssetInfo {
9746            crate::model::AssetInfo {
9747                name: self.name.cst_decode(),
9748                ticker: self.ticker.cst_decode(),
9749                amount: self.amount.cst_decode(),
9750                fees: self.fees.cst_decode(),
9751            }
9752        }
9753    }
9754    impl CstDecode<crate::model::AssetMetadata> for wire_cst_asset_metadata {
9755        // Codec=Cst (C-struct based), see doc to use other codecs
9756        fn cst_decode(self) -> crate::model::AssetMetadata {
9757            crate::model::AssetMetadata {
9758                asset_id: self.asset_id.cst_decode(),
9759                name: self.name.cst_decode(),
9760                ticker: self.ticker.cst_decode(),
9761                precision: self.precision.cst_decode(),
9762                fiat_id: self.fiat_id.cst_decode(),
9763            }
9764        }
9765    }
9766    impl CstDecode<crate::model::BackupRequest> for wire_cst_backup_request {
9767        // Codec=Cst (C-struct based), see doc to use other codecs
9768        fn cst_decode(self) -> crate::model::BackupRequest {
9769            crate::model::BackupRequest {
9770                backup_path: self.backup_path.cst_decode(),
9771            }
9772        }
9773    }
9774    impl CstDecode<crate::bindings::BindingEventListener> for wire_cst_binding_event_listener {
9775        // Codec=Cst (C-struct based), see doc to use other codecs
9776        fn cst_decode(self) -> crate::bindings::BindingEventListener {
9777            crate::bindings::BindingEventListener {
9778                stream: self.stream.cst_decode(),
9779            }
9780        }
9781    }
9782    impl CstDecode<crate::bindings::BitcoinAddressData> for wire_cst_bitcoin_address_data {
9783        // Codec=Cst (C-struct based), see doc to use other codecs
9784        fn cst_decode(self) -> crate::bindings::BitcoinAddressData {
9785            crate::bindings::BitcoinAddressData {
9786                address: self.address.cst_decode(),
9787                network: self.network.cst_decode(),
9788                amount_sat: self.amount_sat.cst_decode(),
9789                label: self.label.cst_decode(),
9790                message: self.message.cst_decode(),
9791            }
9792        }
9793    }
9794    impl CstDecode<crate::model::BlockchainExplorer> for wire_cst_blockchain_explorer {
9795        // Codec=Cst (C-struct based), see doc to use other codecs
9796        fn cst_decode(self) -> crate::model::BlockchainExplorer {
9797            match self.tag {
9798                0 => {
9799                    let ans = unsafe { self.kind.Electrum };
9800                    crate::model::BlockchainExplorer::Electrum {
9801                        url: ans.url.cst_decode(),
9802                    }
9803                }
9804                1 => {
9805                    let ans = unsafe { self.kind.Esplora };
9806                    crate::model::BlockchainExplorer::Esplora {
9807                        url: ans.url.cst_decode(),
9808                        use_waterfalls: ans.use_waterfalls.cst_decode(),
9809                    }
9810                }
9811                _ => unreachable!(),
9812            }
9813        }
9814    }
9815    impl CstDecode<crate::model::BlockchainInfo> for wire_cst_blockchain_info {
9816        // Codec=Cst (C-struct based), see doc to use other codecs
9817        fn cst_decode(self) -> crate::model::BlockchainInfo {
9818            crate::model::BlockchainInfo {
9819                liquid_tip: self.liquid_tip.cst_decode(),
9820                bitcoin_tip: self.bitcoin_tip.cst_decode(),
9821            }
9822        }
9823    }
9824    impl CstDecode<crate::model::AcceptPaymentProposedFeesRequest>
9825        for *mut wire_cst_accept_payment_proposed_fees_request
9826    {
9827        // Codec=Cst (C-struct based), see doc to use other codecs
9828        fn cst_decode(self) -> crate::model::AcceptPaymentProposedFeesRequest {
9829            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9830            CstDecode::<crate::model::AcceptPaymentProposedFeesRequest>::cst_decode(*wrap).into()
9831        }
9832    }
9833    impl CstDecode<crate::bindings::AesSuccessActionData> for *mut wire_cst_aes_success_action_data {
9834        // Codec=Cst (C-struct based), see doc to use other codecs
9835        fn cst_decode(self) -> crate::bindings::AesSuccessActionData {
9836            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9837            CstDecode::<crate::bindings::AesSuccessActionData>::cst_decode(*wrap).into()
9838        }
9839    }
9840    impl CstDecode<crate::bindings::AesSuccessActionDataDecrypted>
9841        for *mut wire_cst_aes_success_action_data_decrypted
9842    {
9843        // Codec=Cst (C-struct based), see doc to use other codecs
9844        fn cst_decode(self) -> crate::bindings::AesSuccessActionDataDecrypted {
9845            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9846            CstDecode::<crate::bindings::AesSuccessActionDataDecrypted>::cst_decode(*wrap).into()
9847        }
9848    }
9849    impl CstDecode<crate::bindings::AesSuccessActionDataResult>
9850        for *mut wire_cst_aes_success_action_data_result
9851    {
9852        // Codec=Cst (C-struct based), see doc to use other codecs
9853        fn cst_decode(self) -> crate::bindings::AesSuccessActionDataResult {
9854            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9855            CstDecode::<crate::bindings::AesSuccessActionDataResult>::cst_decode(*wrap).into()
9856        }
9857    }
9858    impl CstDecode<crate::bindings::Amount> for *mut wire_cst_amount {
9859        // Codec=Cst (C-struct based), see doc to use other codecs
9860        fn cst_decode(self) -> crate::bindings::Amount {
9861            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9862            CstDecode::<crate::bindings::Amount>::cst_decode(*wrap).into()
9863        }
9864    }
9865    impl CstDecode<crate::model::AssetInfo> for *mut wire_cst_asset_info {
9866        // Codec=Cst (C-struct based), see doc to use other codecs
9867        fn cst_decode(self) -> crate::model::AssetInfo {
9868            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9869            CstDecode::<crate::model::AssetInfo>::cst_decode(*wrap).into()
9870        }
9871    }
9872    impl CstDecode<crate::model::BackupRequest> for *mut wire_cst_backup_request {
9873        // Codec=Cst (C-struct based), see doc to use other codecs
9874        fn cst_decode(self) -> crate::model::BackupRequest {
9875            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9876            CstDecode::<crate::model::BackupRequest>::cst_decode(*wrap).into()
9877        }
9878    }
9879    impl CstDecode<crate::bindings::BindingEventListener> for *mut wire_cst_binding_event_listener {
9880        // Codec=Cst (C-struct based), see doc to use other codecs
9881        fn cst_decode(self) -> crate::bindings::BindingEventListener {
9882            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9883            CstDecode::<crate::bindings::BindingEventListener>::cst_decode(*wrap).into()
9884        }
9885    }
9886    impl CstDecode<crate::bindings::BitcoinAddressData> for *mut wire_cst_bitcoin_address_data {
9887        // Codec=Cst (C-struct based), see doc to use other codecs
9888        fn cst_decode(self) -> crate::bindings::BitcoinAddressData {
9889            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9890            CstDecode::<crate::bindings::BitcoinAddressData>::cst_decode(*wrap).into()
9891        }
9892    }
9893    impl CstDecode<bool> for *mut bool {
9894        // Codec=Cst (C-struct based), see doc to use other codecs
9895        fn cst_decode(self) -> bool {
9896            unsafe { *flutter_rust_bridge::for_generated::box_from_leak_ptr(self) }
9897        }
9898    }
9899    impl CstDecode<crate::model::BuyBitcoinRequest> for *mut wire_cst_buy_bitcoin_request {
9900        // Codec=Cst (C-struct based), see doc to use other codecs
9901        fn cst_decode(self) -> crate::model::BuyBitcoinRequest {
9902            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9903            CstDecode::<crate::model::BuyBitcoinRequest>::cst_decode(*wrap).into()
9904        }
9905    }
9906    impl CstDecode<crate::model::CheckMessageRequest> for *mut wire_cst_check_message_request {
9907        // Codec=Cst (C-struct based), see doc to use other codecs
9908        fn cst_decode(self) -> crate::model::CheckMessageRequest {
9909            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9910            CstDecode::<crate::model::CheckMessageRequest>::cst_decode(*wrap).into()
9911        }
9912    }
9913    impl CstDecode<crate::model::ConnectRequest> for *mut wire_cst_connect_request {
9914        // Codec=Cst (C-struct based), see doc to use other codecs
9915        fn cst_decode(self) -> crate::model::ConnectRequest {
9916            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9917            CstDecode::<crate::model::ConnectRequest>::cst_decode(*wrap).into()
9918        }
9919    }
9920    impl CstDecode<crate::model::CreateBolt12InvoiceRequest>
9921        for *mut wire_cst_create_bolt_12_invoice_request
9922    {
9923        // Codec=Cst (C-struct based), see doc to use other codecs
9924        fn cst_decode(self) -> crate::model::CreateBolt12InvoiceRequest {
9925            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9926            CstDecode::<crate::model::CreateBolt12InvoiceRequest>::cst_decode(*wrap).into()
9927        }
9928    }
9929    impl CstDecode<f64> for *mut f64 {
9930        // Codec=Cst (C-struct based), see doc to use other codecs
9931        fn cst_decode(self) -> f64 {
9932            unsafe { *flutter_rust_bridge::for_generated::box_from_leak_ptr(self) }
9933        }
9934    }
9935    impl CstDecode<crate::model::FetchPaymentProposedFeesRequest>
9936        for *mut wire_cst_fetch_payment_proposed_fees_request
9937    {
9938        // Codec=Cst (C-struct based), see doc to use other codecs
9939        fn cst_decode(self) -> crate::model::FetchPaymentProposedFeesRequest {
9940            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9941            CstDecode::<crate::model::FetchPaymentProposedFeesRequest>::cst_decode(*wrap).into()
9942        }
9943    }
9944    impl CstDecode<crate::model::GetPaymentRequest> for *mut wire_cst_get_payment_request {
9945        // Codec=Cst (C-struct based), see doc to use other codecs
9946        fn cst_decode(self) -> crate::model::GetPaymentRequest {
9947            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9948            CstDecode::<crate::model::GetPaymentRequest>::cst_decode(*wrap).into()
9949        }
9950    }
9951    impl CstDecode<i64> for *mut i64 {
9952        // Codec=Cst (C-struct based), see doc to use other codecs
9953        fn cst_decode(self) -> i64 {
9954            unsafe { *flutter_rust_bridge::for_generated::box_from_leak_ptr(self) }
9955        }
9956    }
9957    impl CstDecode<crate::bindings::LiquidAddressData> for *mut wire_cst_liquid_address_data {
9958        // Codec=Cst (C-struct based), see doc to use other codecs
9959        fn cst_decode(self) -> crate::bindings::LiquidAddressData {
9960            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9961            CstDecode::<crate::bindings::LiquidAddressData>::cst_decode(*wrap).into()
9962        }
9963    }
9964    impl CstDecode<crate::model::ListPaymentDetails> for *mut wire_cst_list_payment_details {
9965        // Codec=Cst (C-struct based), see doc to use other codecs
9966        fn cst_decode(self) -> crate::model::ListPaymentDetails {
9967            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9968            CstDecode::<crate::model::ListPaymentDetails>::cst_decode(*wrap).into()
9969        }
9970    }
9971    impl CstDecode<crate::model::ListPaymentsRequest> for *mut wire_cst_list_payments_request {
9972        // Codec=Cst (C-struct based), see doc to use other codecs
9973        fn cst_decode(self) -> crate::model::ListPaymentsRequest {
9974            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9975            CstDecode::<crate::model::ListPaymentsRequest>::cst_decode(*wrap).into()
9976        }
9977    }
9978    impl CstDecode<crate::bindings::LNInvoice> for *mut wire_cst_ln_invoice {
9979        // Codec=Cst (C-struct based), see doc to use other codecs
9980        fn cst_decode(self) -> crate::bindings::LNInvoice {
9981            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9982            CstDecode::<crate::bindings::LNInvoice>::cst_decode(*wrap).into()
9983        }
9984    }
9985    impl CstDecode<crate::bindings::LNOffer> for *mut wire_cst_ln_offer {
9986        // Codec=Cst (C-struct based), see doc to use other codecs
9987        fn cst_decode(self) -> crate::bindings::LNOffer {
9988            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9989            CstDecode::<crate::bindings::LNOffer>::cst_decode(*wrap).into()
9990        }
9991    }
9992    impl CstDecode<crate::bindings::LnUrlAuthRequestData> for *mut wire_cst_ln_url_auth_request_data {
9993        // Codec=Cst (C-struct based), see doc to use other codecs
9994        fn cst_decode(self) -> crate::bindings::LnUrlAuthRequestData {
9995            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9996            CstDecode::<crate::bindings::LnUrlAuthRequestData>::cst_decode(*wrap).into()
9997        }
9998    }
9999    impl CstDecode<crate::bindings::LnUrlErrorData> for *mut wire_cst_ln_url_error_data {
10000        // Codec=Cst (C-struct based), see doc to use other codecs
10001        fn cst_decode(self) -> crate::bindings::LnUrlErrorData {
10002            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10003            CstDecode::<crate::bindings::LnUrlErrorData>::cst_decode(*wrap).into()
10004        }
10005    }
10006    impl CstDecode<crate::model::LnUrlInfo> for *mut wire_cst_ln_url_info {
10007        // Codec=Cst (C-struct based), see doc to use other codecs
10008        fn cst_decode(self) -> crate::model::LnUrlInfo {
10009            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10010            CstDecode::<crate::model::LnUrlInfo>::cst_decode(*wrap).into()
10011        }
10012    }
10013    impl CstDecode<crate::bindings::LnUrlPayErrorData> for *mut wire_cst_ln_url_pay_error_data {
10014        // Codec=Cst (C-struct based), see doc to use other codecs
10015        fn cst_decode(self) -> crate::bindings::LnUrlPayErrorData {
10016            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10017            CstDecode::<crate::bindings::LnUrlPayErrorData>::cst_decode(*wrap).into()
10018        }
10019    }
10020    impl CstDecode<crate::model::LnUrlPayRequest> for *mut wire_cst_ln_url_pay_request {
10021        // Codec=Cst (C-struct based), see doc to use other codecs
10022        fn cst_decode(self) -> crate::model::LnUrlPayRequest {
10023            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10024            CstDecode::<crate::model::LnUrlPayRequest>::cst_decode(*wrap).into()
10025        }
10026    }
10027    impl CstDecode<crate::bindings::LnUrlPayRequestData> for *mut wire_cst_ln_url_pay_request_data {
10028        // Codec=Cst (C-struct based), see doc to use other codecs
10029        fn cst_decode(self) -> crate::bindings::LnUrlPayRequestData {
10030            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10031            CstDecode::<crate::bindings::LnUrlPayRequestData>::cst_decode(*wrap).into()
10032        }
10033    }
10034    impl CstDecode<crate::model::LnUrlPaySuccessData> for *mut wire_cst_ln_url_pay_success_data {
10035        // Codec=Cst (C-struct based), see doc to use other codecs
10036        fn cst_decode(self) -> crate::model::LnUrlPaySuccessData {
10037            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10038            CstDecode::<crate::model::LnUrlPaySuccessData>::cst_decode(*wrap).into()
10039        }
10040    }
10041    impl CstDecode<crate::bindings::LnUrlWithdrawRequest> for *mut wire_cst_ln_url_withdraw_request {
10042        // Codec=Cst (C-struct based), see doc to use other codecs
10043        fn cst_decode(self) -> crate::bindings::LnUrlWithdrawRequest {
10044            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10045            CstDecode::<crate::bindings::LnUrlWithdrawRequest>::cst_decode(*wrap).into()
10046        }
10047    }
10048    impl CstDecode<crate::bindings::LnUrlWithdrawRequestData>
10049        for *mut wire_cst_ln_url_withdraw_request_data
10050    {
10051        // Codec=Cst (C-struct based), see doc to use other codecs
10052        fn cst_decode(self) -> crate::bindings::LnUrlWithdrawRequestData {
10053            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10054            CstDecode::<crate::bindings::LnUrlWithdrawRequestData>::cst_decode(*wrap).into()
10055        }
10056    }
10057    impl CstDecode<crate::bindings::duplicates::LnUrlWithdrawSuccessData>
10058        for *mut wire_cst_ln_url_withdraw_success_data
10059    {
10060        // Codec=Cst (C-struct based), see doc to use other codecs
10061        fn cst_decode(self) -> crate::bindings::duplicates::LnUrlWithdrawSuccessData {
10062            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10063            CstDecode::<crate::bindings::duplicates::LnUrlWithdrawSuccessData>::cst_decode(*wrap)
10064                .into()
10065        }
10066    }
10067    impl CstDecode<crate::bindings::MessageSuccessActionData>
10068        for *mut wire_cst_message_success_action_data
10069    {
10070        // Codec=Cst (C-struct based), see doc to use other codecs
10071        fn cst_decode(self) -> crate::bindings::MessageSuccessActionData {
10072            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10073            CstDecode::<crate::bindings::MessageSuccessActionData>::cst_decode(*wrap).into()
10074        }
10075    }
10076    impl CstDecode<crate::model::PayAmount> for *mut wire_cst_pay_amount {
10077        // Codec=Cst (C-struct based), see doc to use other codecs
10078        fn cst_decode(self) -> crate::model::PayAmount {
10079            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10080            CstDecode::<crate::model::PayAmount>::cst_decode(*wrap).into()
10081        }
10082    }
10083    impl CstDecode<crate::model::PayOnchainRequest> for *mut wire_cst_pay_onchain_request {
10084        // Codec=Cst (C-struct based), see doc to use other codecs
10085        fn cst_decode(self) -> crate::model::PayOnchainRequest {
10086            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10087            CstDecode::<crate::model::PayOnchainRequest>::cst_decode(*wrap).into()
10088        }
10089    }
10090    impl CstDecode<crate::model::Payment> for *mut wire_cst_payment {
10091        // Codec=Cst (C-struct based), see doc to use other codecs
10092        fn cst_decode(self) -> crate::model::Payment {
10093            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10094            CstDecode::<crate::model::Payment>::cst_decode(*wrap).into()
10095        }
10096    }
10097    impl CstDecode<crate::model::PrepareBuyBitcoinRequest>
10098        for *mut wire_cst_prepare_buy_bitcoin_request
10099    {
10100        // Codec=Cst (C-struct based), see doc to use other codecs
10101        fn cst_decode(self) -> crate::model::PrepareBuyBitcoinRequest {
10102            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10103            CstDecode::<crate::model::PrepareBuyBitcoinRequest>::cst_decode(*wrap).into()
10104        }
10105    }
10106    impl CstDecode<crate::model::PrepareLnUrlPayRequest> for *mut wire_cst_prepare_ln_url_pay_request {
10107        // Codec=Cst (C-struct based), see doc to use other codecs
10108        fn cst_decode(self) -> crate::model::PrepareLnUrlPayRequest {
10109            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10110            CstDecode::<crate::model::PrepareLnUrlPayRequest>::cst_decode(*wrap).into()
10111        }
10112    }
10113    impl CstDecode<crate::model::PreparePayOnchainRequest>
10114        for *mut wire_cst_prepare_pay_onchain_request
10115    {
10116        // Codec=Cst (C-struct based), see doc to use other codecs
10117        fn cst_decode(self) -> crate::model::PreparePayOnchainRequest {
10118            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10119            CstDecode::<crate::model::PreparePayOnchainRequest>::cst_decode(*wrap).into()
10120        }
10121    }
10122    impl CstDecode<crate::model::PrepareReceiveRequest> for *mut wire_cst_prepare_receive_request {
10123        // Codec=Cst (C-struct based), see doc to use other codecs
10124        fn cst_decode(self) -> crate::model::PrepareReceiveRequest {
10125            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10126            CstDecode::<crate::model::PrepareReceiveRequest>::cst_decode(*wrap).into()
10127        }
10128    }
10129    impl CstDecode<crate::model::PrepareRefundRequest> for *mut wire_cst_prepare_refund_request {
10130        // Codec=Cst (C-struct based), see doc to use other codecs
10131        fn cst_decode(self) -> crate::model::PrepareRefundRequest {
10132            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10133            CstDecode::<crate::model::PrepareRefundRequest>::cst_decode(*wrap).into()
10134        }
10135    }
10136    impl CstDecode<crate::model::PrepareSendRequest> for *mut wire_cst_prepare_send_request {
10137        // Codec=Cst (C-struct based), see doc to use other codecs
10138        fn cst_decode(self) -> crate::model::PrepareSendRequest {
10139            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10140            CstDecode::<crate::model::PrepareSendRequest>::cst_decode(*wrap).into()
10141        }
10142    }
10143    impl CstDecode<crate::model::ReceiveAmount> for *mut wire_cst_receive_amount {
10144        // Codec=Cst (C-struct based), see doc to use other codecs
10145        fn cst_decode(self) -> crate::model::ReceiveAmount {
10146            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10147            CstDecode::<crate::model::ReceiveAmount>::cst_decode(*wrap).into()
10148        }
10149    }
10150    impl CstDecode<crate::model::ReceivePaymentRequest> for *mut wire_cst_receive_payment_request {
10151        // Codec=Cst (C-struct based), see doc to use other codecs
10152        fn cst_decode(self) -> crate::model::ReceivePaymentRequest {
10153            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10154            CstDecode::<crate::model::ReceivePaymentRequest>::cst_decode(*wrap).into()
10155        }
10156    }
10157    impl CstDecode<crate::model::RefundRequest> for *mut wire_cst_refund_request {
10158        // Codec=Cst (C-struct based), see doc to use other codecs
10159        fn cst_decode(self) -> crate::model::RefundRequest {
10160            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10161            CstDecode::<crate::model::RefundRequest>::cst_decode(*wrap).into()
10162        }
10163    }
10164    impl CstDecode<crate::model::RestoreRequest> for *mut wire_cst_restore_request {
10165        // Codec=Cst (C-struct based), see doc to use other codecs
10166        fn cst_decode(self) -> crate::model::RestoreRequest {
10167            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10168            CstDecode::<crate::model::RestoreRequest>::cst_decode(*wrap).into()
10169        }
10170    }
10171    impl CstDecode<crate::model::SdkEvent> for *mut wire_cst_sdk_event {
10172        // Codec=Cst (C-struct based), see doc to use other codecs
10173        fn cst_decode(self) -> crate::model::SdkEvent {
10174            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10175            CstDecode::<crate::model::SdkEvent>::cst_decode(*wrap).into()
10176        }
10177    }
10178    impl CstDecode<crate::model::SendPaymentRequest> for *mut wire_cst_send_payment_request {
10179        // Codec=Cst (C-struct based), see doc to use other codecs
10180        fn cst_decode(self) -> crate::model::SendPaymentRequest {
10181            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10182            CstDecode::<crate::model::SendPaymentRequest>::cst_decode(*wrap).into()
10183        }
10184    }
10185    impl CstDecode<crate::model::SignMessageRequest> for *mut wire_cst_sign_message_request {
10186        // Codec=Cst (C-struct based), see doc to use other codecs
10187        fn cst_decode(self) -> crate::model::SignMessageRequest {
10188            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10189            CstDecode::<crate::model::SignMessageRequest>::cst_decode(*wrap).into()
10190        }
10191    }
10192    impl CstDecode<crate::bindings::SuccessAction> for *mut wire_cst_success_action {
10193        // Codec=Cst (C-struct based), see doc to use other codecs
10194        fn cst_decode(self) -> crate::bindings::SuccessAction {
10195            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10196            CstDecode::<crate::bindings::SuccessAction>::cst_decode(*wrap).into()
10197        }
10198    }
10199    impl CstDecode<crate::bindings::SuccessActionProcessed> for *mut wire_cst_success_action_processed {
10200        // Codec=Cst (C-struct based), see doc to use other codecs
10201        fn cst_decode(self) -> crate::bindings::SuccessActionProcessed {
10202            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10203            CstDecode::<crate::bindings::SuccessActionProcessed>::cst_decode(*wrap).into()
10204        }
10205    }
10206    impl CstDecode<crate::bindings::Symbol> for *mut wire_cst_symbol {
10207        // Codec=Cst (C-struct based), see doc to use other codecs
10208        fn cst_decode(self) -> crate::bindings::Symbol {
10209            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10210            CstDecode::<crate::bindings::Symbol>::cst_decode(*wrap).into()
10211        }
10212    }
10213    impl CstDecode<u32> for *mut u32 {
10214        // Codec=Cst (C-struct based), see doc to use other codecs
10215        fn cst_decode(self) -> u32 {
10216            unsafe { *flutter_rust_bridge::for_generated::box_from_leak_ptr(self) }
10217        }
10218    }
10219    impl CstDecode<u64> for *mut u64 {
10220        // Codec=Cst (C-struct based), see doc to use other codecs
10221        fn cst_decode(self) -> u64 {
10222            unsafe { *flutter_rust_bridge::for_generated::box_from_leak_ptr(self) }
10223        }
10224    }
10225    impl CstDecode<crate::bindings::UrlSuccessActionData> for *mut wire_cst_url_success_action_data {
10226        // Codec=Cst (C-struct based), see doc to use other codecs
10227        fn cst_decode(self) -> crate::bindings::UrlSuccessActionData {
10228            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10229            CstDecode::<crate::bindings::UrlSuccessActionData>::cst_decode(*wrap).into()
10230        }
10231    }
10232    impl CstDecode<crate::model::BuyBitcoinRequest> for wire_cst_buy_bitcoin_request {
10233        // Codec=Cst (C-struct based), see doc to use other codecs
10234        fn cst_decode(self) -> crate::model::BuyBitcoinRequest {
10235            crate::model::BuyBitcoinRequest {
10236                prepare_response: self.prepare_response.cst_decode(),
10237                redirect_url: self.redirect_url.cst_decode(),
10238            }
10239        }
10240    }
10241    impl CstDecode<crate::model::CheckMessageRequest> for wire_cst_check_message_request {
10242        // Codec=Cst (C-struct based), see doc to use other codecs
10243        fn cst_decode(self) -> crate::model::CheckMessageRequest {
10244            crate::model::CheckMessageRequest {
10245                message: self.message.cst_decode(),
10246                pubkey: self.pubkey.cst_decode(),
10247                signature: self.signature.cst_decode(),
10248            }
10249        }
10250    }
10251    impl CstDecode<crate::model::CheckMessageResponse> for wire_cst_check_message_response {
10252        // Codec=Cst (C-struct based), see doc to use other codecs
10253        fn cst_decode(self) -> crate::model::CheckMessageResponse {
10254            crate::model::CheckMessageResponse {
10255                is_valid: self.is_valid.cst_decode(),
10256            }
10257        }
10258    }
10259    impl CstDecode<crate::model::Config> for wire_cst_config {
10260        // Codec=Cst (C-struct based), see doc to use other codecs
10261        fn cst_decode(self) -> crate::model::Config {
10262            crate::model::Config {
10263                liquid_explorer: self.liquid_explorer.cst_decode(),
10264                bitcoin_explorer: self.bitcoin_explorer.cst_decode(),
10265                working_dir: self.working_dir.cst_decode(),
10266                network: self.network.cst_decode(),
10267                payment_timeout_sec: self.payment_timeout_sec.cst_decode(),
10268                sync_service_url: self.sync_service_url.cst_decode(),
10269                zero_conf_max_amount_sat: self.zero_conf_max_amount_sat.cst_decode(),
10270                breez_api_key: self.breez_api_key.cst_decode(),
10271                external_input_parsers: self.external_input_parsers.cst_decode(),
10272                use_default_external_input_parsers: self
10273                    .use_default_external_input_parsers
10274                    .cst_decode(),
10275                onchain_fee_rate_leeway_sat: self.onchain_fee_rate_leeway_sat.cst_decode(),
10276                asset_metadata: self.asset_metadata.cst_decode(),
10277                sideswap_api_key: self.sideswap_api_key.cst_decode(),
10278            }
10279        }
10280    }
10281    impl CstDecode<crate::model::ConnectRequest> for wire_cst_connect_request {
10282        // Codec=Cst (C-struct based), see doc to use other codecs
10283        fn cst_decode(self) -> crate::model::ConnectRequest {
10284            crate::model::ConnectRequest {
10285                config: self.config.cst_decode(),
10286                mnemonic: self.mnemonic.cst_decode(),
10287                passphrase: self.passphrase.cst_decode(),
10288                seed: self.seed.cst_decode(),
10289            }
10290        }
10291    }
10292    impl CstDecode<crate::model::CreateBolt12InvoiceRequest>
10293        for wire_cst_create_bolt_12_invoice_request
10294    {
10295        // Codec=Cst (C-struct based), see doc to use other codecs
10296        fn cst_decode(self) -> crate::model::CreateBolt12InvoiceRequest {
10297            crate::model::CreateBolt12InvoiceRequest {
10298                offer: self.offer.cst_decode(),
10299                invoice_request: self.invoice_request.cst_decode(),
10300            }
10301        }
10302    }
10303    impl CstDecode<crate::model::CreateBolt12InvoiceResponse>
10304        for wire_cst_create_bolt_12_invoice_response
10305    {
10306        // Codec=Cst (C-struct based), see doc to use other codecs
10307        fn cst_decode(self) -> crate::model::CreateBolt12InvoiceResponse {
10308            crate::model::CreateBolt12InvoiceResponse {
10309                invoice: self.invoice.cst_decode(),
10310            }
10311        }
10312    }
10313    impl CstDecode<crate::bindings::CurrencyInfo> for wire_cst_currency_info {
10314        // Codec=Cst (C-struct based), see doc to use other codecs
10315        fn cst_decode(self) -> crate::bindings::CurrencyInfo {
10316            crate::bindings::CurrencyInfo {
10317                name: self.name.cst_decode(),
10318                fraction_size: self.fraction_size.cst_decode(),
10319                spacing: self.spacing.cst_decode(),
10320                symbol: self.symbol.cst_decode(),
10321                uniq_symbol: self.uniq_symbol.cst_decode(),
10322                localized_name: self.localized_name.cst_decode(),
10323                locale_overrides: self.locale_overrides.cst_decode(),
10324            }
10325        }
10326    }
10327    impl CstDecode<crate::bindings::ExternalInputParser> for wire_cst_external_input_parser {
10328        // Codec=Cst (C-struct based), see doc to use other codecs
10329        fn cst_decode(self) -> crate::bindings::ExternalInputParser {
10330            crate::bindings::ExternalInputParser {
10331                provider_id: self.provider_id.cst_decode(),
10332                input_regex: self.input_regex.cst_decode(),
10333                parser_url: self.parser_url.cst_decode(),
10334            }
10335        }
10336    }
10337    impl CstDecode<crate::model::FetchPaymentProposedFeesRequest>
10338        for wire_cst_fetch_payment_proposed_fees_request
10339    {
10340        // Codec=Cst (C-struct based), see doc to use other codecs
10341        fn cst_decode(self) -> crate::model::FetchPaymentProposedFeesRequest {
10342            crate::model::FetchPaymentProposedFeesRequest {
10343                swap_id: self.swap_id.cst_decode(),
10344            }
10345        }
10346    }
10347    impl CstDecode<crate::model::FetchPaymentProposedFeesResponse>
10348        for wire_cst_fetch_payment_proposed_fees_response
10349    {
10350        // Codec=Cst (C-struct based), see doc to use other codecs
10351        fn cst_decode(self) -> crate::model::FetchPaymentProposedFeesResponse {
10352            crate::model::FetchPaymentProposedFeesResponse {
10353                swap_id: self.swap_id.cst_decode(),
10354                fees_sat: self.fees_sat.cst_decode(),
10355                payer_amount_sat: self.payer_amount_sat.cst_decode(),
10356                receiver_amount_sat: self.receiver_amount_sat.cst_decode(),
10357            }
10358        }
10359    }
10360    impl CstDecode<crate::bindings::FiatCurrency> for wire_cst_fiat_currency {
10361        // Codec=Cst (C-struct based), see doc to use other codecs
10362        fn cst_decode(self) -> crate::bindings::FiatCurrency {
10363            crate::bindings::FiatCurrency {
10364                id: self.id.cst_decode(),
10365                info: self.info.cst_decode(),
10366            }
10367        }
10368    }
10369    impl CstDecode<crate::model::GetInfoResponse> for wire_cst_get_info_response {
10370        // Codec=Cst (C-struct based), see doc to use other codecs
10371        fn cst_decode(self) -> crate::model::GetInfoResponse {
10372            crate::model::GetInfoResponse {
10373                wallet_info: self.wallet_info.cst_decode(),
10374                blockchain_info: self.blockchain_info.cst_decode(),
10375            }
10376        }
10377    }
10378    impl CstDecode<crate::model::GetPaymentRequest> for wire_cst_get_payment_request {
10379        // Codec=Cst (C-struct based), see doc to use other codecs
10380        fn cst_decode(self) -> crate::model::GetPaymentRequest {
10381            match self.tag {
10382                0 => {
10383                    let ans = unsafe { self.kind.PaymentHash };
10384                    crate::model::GetPaymentRequest::PaymentHash {
10385                        payment_hash: ans.payment_hash.cst_decode(),
10386                    }
10387                }
10388                1 => {
10389                    let ans = unsafe { self.kind.SwapId };
10390                    crate::model::GetPaymentRequest::SwapId {
10391                        swap_id: ans.swap_id.cst_decode(),
10392                    }
10393                }
10394                _ => unreachable!(),
10395            }
10396        }
10397    }
10398    impl CstDecode<crate::bindings::InputType> for wire_cst_input_type {
10399        // Codec=Cst (C-struct based), see doc to use other codecs
10400        fn cst_decode(self) -> crate::bindings::InputType {
10401            match self.tag {
10402                0 => {
10403                    let ans = unsafe { self.kind.BitcoinAddress };
10404                    crate::bindings::InputType::BitcoinAddress {
10405                        address: ans.address.cst_decode(),
10406                    }
10407                }
10408                1 => {
10409                    let ans = unsafe { self.kind.LiquidAddress };
10410                    crate::bindings::InputType::LiquidAddress {
10411                        address: ans.address.cst_decode(),
10412                    }
10413                }
10414                2 => {
10415                    let ans = unsafe { self.kind.Bolt11 };
10416                    crate::bindings::InputType::Bolt11 {
10417                        invoice: ans.invoice.cst_decode(),
10418                    }
10419                }
10420                3 => {
10421                    let ans = unsafe { self.kind.Bolt12Offer };
10422                    crate::bindings::InputType::Bolt12Offer {
10423                        offer: ans.offer.cst_decode(),
10424                        bip353_address: ans.bip353_address.cst_decode(),
10425                    }
10426                }
10427                4 => {
10428                    let ans = unsafe { self.kind.NodeId };
10429                    crate::bindings::InputType::NodeId {
10430                        node_id: ans.node_id.cst_decode(),
10431                    }
10432                }
10433                5 => {
10434                    let ans = unsafe { self.kind.Url };
10435                    crate::bindings::InputType::Url {
10436                        url: ans.url.cst_decode(),
10437                    }
10438                }
10439                6 => {
10440                    let ans = unsafe { self.kind.LnUrlPay };
10441                    crate::bindings::InputType::LnUrlPay {
10442                        data: ans.data.cst_decode(),
10443                        bip353_address: ans.bip353_address.cst_decode(),
10444                    }
10445                }
10446                7 => {
10447                    let ans = unsafe { self.kind.LnUrlWithdraw };
10448                    crate::bindings::InputType::LnUrlWithdraw {
10449                        data: ans.data.cst_decode(),
10450                    }
10451                }
10452                8 => {
10453                    let ans = unsafe { self.kind.LnUrlAuth };
10454                    crate::bindings::InputType::LnUrlAuth {
10455                        data: ans.data.cst_decode(),
10456                    }
10457                }
10458                9 => {
10459                    let ans = unsafe { self.kind.LnUrlError };
10460                    crate::bindings::InputType::LnUrlError {
10461                        data: ans.data.cst_decode(),
10462                    }
10463                }
10464                _ => unreachable!(),
10465            }
10466        }
10467    }
10468    impl CstDecode<crate::model::LightningPaymentLimitsResponse>
10469        for wire_cst_lightning_payment_limits_response
10470    {
10471        // Codec=Cst (C-struct based), see doc to use other codecs
10472        fn cst_decode(self) -> crate::model::LightningPaymentLimitsResponse {
10473            crate::model::LightningPaymentLimitsResponse {
10474                send: self.send.cst_decode(),
10475                receive: self.receive.cst_decode(),
10476            }
10477        }
10478    }
10479    impl CstDecode<crate::model::Limits> for wire_cst_limits {
10480        // Codec=Cst (C-struct based), see doc to use other codecs
10481        fn cst_decode(self) -> crate::model::Limits {
10482            crate::model::Limits {
10483                min_sat: self.min_sat.cst_decode(),
10484                max_sat: self.max_sat.cst_decode(),
10485                max_zero_conf_sat: self.max_zero_conf_sat.cst_decode(),
10486            }
10487        }
10488    }
10489    impl CstDecode<crate::bindings::LiquidAddressData> for wire_cst_liquid_address_data {
10490        // Codec=Cst (C-struct based), see doc to use other codecs
10491        fn cst_decode(self) -> crate::bindings::LiquidAddressData {
10492            crate::bindings::LiquidAddressData {
10493                address: self.address.cst_decode(),
10494                network: self.network.cst_decode(),
10495                asset_id: self.asset_id.cst_decode(),
10496                amount: self.amount.cst_decode(),
10497                amount_sat: self.amount_sat.cst_decode(),
10498                label: self.label.cst_decode(),
10499                message: self.message.cst_decode(),
10500            }
10501        }
10502    }
10503    impl CstDecode<Vec<String>> for *mut wire_cst_list_String {
10504        // Codec=Cst (C-struct based), see doc to use other codecs
10505        fn cst_decode(self) -> Vec<String> {
10506            let vec = unsafe {
10507                let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10508                flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10509            };
10510            vec.into_iter().map(CstDecode::cst_decode).collect()
10511        }
10512    }
10513    impl CstDecode<Vec<crate::model::AssetBalance>> for *mut wire_cst_list_asset_balance {
10514        // Codec=Cst (C-struct based), see doc to use other codecs
10515        fn cst_decode(self) -> Vec<crate::model::AssetBalance> {
10516            let vec = unsafe {
10517                let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10518                flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10519            };
10520            vec.into_iter().map(CstDecode::cst_decode).collect()
10521        }
10522    }
10523    impl CstDecode<Vec<crate::model::AssetMetadata>> for *mut wire_cst_list_asset_metadata {
10524        // Codec=Cst (C-struct based), see doc to use other codecs
10525        fn cst_decode(self) -> Vec<crate::model::AssetMetadata> {
10526            let vec = unsafe {
10527                let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10528                flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10529            };
10530            vec.into_iter().map(CstDecode::cst_decode).collect()
10531        }
10532    }
10533    impl CstDecode<Vec<crate::bindings::ExternalInputParser>>
10534        for *mut wire_cst_list_external_input_parser
10535    {
10536        // Codec=Cst (C-struct based), see doc to use other codecs
10537        fn cst_decode(self) -> Vec<crate::bindings::ExternalInputParser> {
10538            let vec = unsafe {
10539                let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10540                flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10541            };
10542            vec.into_iter().map(CstDecode::cst_decode).collect()
10543        }
10544    }
10545    impl CstDecode<Vec<crate::bindings::FiatCurrency>> for *mut wire_cst_list_fiat_currency {
10546        // Codec=Cst (C-struct based), see doc to use other codecs
10547        fn cst_decode(self) -> Vec<crate::bindings::FiatCurrency> {
10548            let vec = unsafe {
10549                let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10550                flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10551            };
10552            vec.into_iter().map(CstDecode::cst_decode).collect()
10553        }
10554    }
10555    impl CstDecode<Vec<crate::bindings::LnOfferBlindedPath>>
10556        for *mut wire_cst_list_ln_offer_blinded_path
10557    {
10558        // Codec=Cst (C-struct based), see doc to use other codecs
10559        fn cst_decode(self) -> Vec<crate::bindings::LnOfferBlindedPath> {
10560            let vec = unsafe {
10561                let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10562                flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10563            };
10564            vec.into_iter().map(CstDecode::cst_decode).collect()
10565        }
10566    }
10567    impl CstDecode<Vec<crate::bindings::LocaleOverrides>> for *mut wire_cst_list_locale_overrides {
10568        // Codec=Cst (C-struct based), see doc to use other codecs
10569        fn cst_decode(self) -> Vec<crate::bindings::LocaleOverrides> {
10570            let vec = unsafe {
10571                let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10572                flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10573            };
10574            vec.into_iter().map(CstDecode::cst_decode).collect()
10575        }
10576    }
10577    impl CstDecode<Vec<crate::bindings::LocalizedName>> for *mut wire_cst_list_localized_name {
10578        // Codec=Cst (C-struct based), see doc to use other codecs
10579        fn cst_decode(self) -> Vec<crate::bindings::LocalizedName> {
10580            let vec = unsafe {
10581                let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10582                flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10583            };
10584            vec.into_iter().map(CstDecode::cst_decode).collect()
10585        }
10586    }
10587    impl CstDecode<Vec<crate::model::Payment>> for *mut wire_cst_list_payment {
10588        // Codec=Cst (C-struct based), see doc to use other codecs
10589        fn cst_decode(self) -> Vec<crate::model::Payment> {
10590            let vec = unsafe {
10591                let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10592                flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10593            };
10594            vec.into_iter().map(CstDecode::cst_decode).collect()
10595        }
10596    }
10597    impl CstDecode<crate::model::ListPaymentDetails> for wire_cst_list_payment_details {
10598        // Codec=Cst (C-struct based), see doc to use other codecs
10599        fn cst_decode(self) -> crate::model::ListPaymentDetails {
10600            match self.tag {
10601                0 => {
10602                    let ans = unsafe { self.kind.Liquid };
10603                    crate::model::ListPaymentDetails::Liquid {
10604                        asset_id: ans.asset_id.cst_decode(),
10605                        destination: ans.destination.cst_decode(),
10606                    }
10607                }
10608                1 => {
10609                    let ans = unsafe { self.kind.Bitcoin };
10610                    crate::model::ListPaymentDetails::Bitcoin {
10611                        address: ans.address.cst_decode(),
10612                    }
10613                }
10614                _ => unreachable!(),
10615            }
10616        }
10617    }
10618    impl CstDecode<Vec<crate::model::PaymentState>> for *mut wire_cst_list_payment_state {
10619        // Codec=Cst (C-struct based), see doc to use other codecs
10620        fn cst_decode(self) -> Vec<crate::model::PaymentState> {
10621            let vec = unsafe {
10622                let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10623                flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10624            };
10625            vec.into_iter().map(CstDecode::cst_decode).collect()
10626        }
10627    }
10628    impl CstDecode<Vec<crate::model::PaymentType>> for *mut wire_cst_list_payment_type {
10629        // Codec=Cst (C-struct based), see doc to use other codecs
10630        fn cst_decode(self) -> Vec<crate::model::PaymentType> {
10631            let vec = unsafe {
10632                let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10633                flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10634            };
10635            vec.into_iter().map(CstDecode::cst_decode).collect()
10636        }
10637    }
10638    impl CstDecode<crate::model::ListPaymentsRequest> for wire_cst_list_payments_request {
10639        // Codec=Cst (C-struct based), see doc to use other codecs
10640        fn cst_decode(self) -> crate::model::ListPaymentsRequest {
10641            crate::model::ListPaymentsRequest {
10642                filters: self.filters.cst_decode(),
10643                states: self.states.cst_decode(),
10644                from_timestamp: self.from_timestamp.cst_decode(),
10645                to_timestamp: self.to_timestamp.cst_decode(),
10646                offset: self.offset.cst_decode(),
10647                limit: self.limit.cst_decode(),
10648                details: self.details.cst_decode(),
10649                sort_ascending: self.sort_ascending.cst_decode(),
10650            }
10651        }
10652    }
10653    impl CstDecode<Vec<u8>> for *mut wire_cst_list_prim_u_8_strict {
10654        // Codec=Cst (C-struct based), see doc to use other codecs
10655        fn cst_decode(self) -> Vec<u8> {
10656            unsafe {
10657                let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10658                flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10659            }
10660        }
10661    }
10662    impl CstDecode<Vec<crate::bindings::Rate>> for *mut wire_cst_list_rate {
10663        // Codec=Cst (C-struct based), see doc to use other codecs
10664        fn cst_decode(self) -> Vec<crate::bindings::Rate> {
10665            let vec = unsafe {
10666                let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10667                flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10668            };
10669            vec.into_iter().map(CstDecode::cst_decode).collect()
10670        }
10671    }
10672    impl CstDecode<Vec<crate::model::RefundableSwap>> for *mut wire_cst_list_refundable_swap {
10673        // Codec=Cst (C-struct based), see doc to use other codecs
10674        fn cst_decode(self) -> Vec<crate::model::RefundableSwap> {
10675            let vec = unsafe {
10676                let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10677                flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10678            };
10679            vec.into_iter().map(CstDecode::cst_decode).collect()
10680        }
10681    }
10682    impl CstDecode<Vec<crate::bindings::RouteHint>> for *mut wire_cst_list_route_hint {
10683        // Codec=Cst (C-struct based), see doc to use other codecs
10684        fn cst_decode(self) -> Vec<crate::bindings::RouteHint> {
10685            let vec = unsafe {
10686                let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10687                flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10688            };
10689            vec.into_iter().map(CstDecode::cst_decode).collect()
10690        }
10691    }
10692    impl CstDecode<Vec<crate::bindings::RouteHintHop>> for *mut wire_cst_list_route_hint_hop {
10693        // Codec=Cst (C-struct based), see doc to use other codecs
10694        fn cst_decode(self) -> Vec<crate::bindings::RouteHintHop> {
10695            let vec = unsafe {
10696                let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10697                flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10698            };
10699            vec.into_iter().map(CstDecode::cst_decode).collect()
10700        }
10701    }
10702    impl CstDecode<crate::bindings::LNInvoice> for wire_cst_ln_invoice {
10703        // Codec=Cst (C-struct based), see doc to use other codecs
10704        fn cst_decode(self) -> crate::bindings::LNInvoice {
10705            crate::bindings::LNInvoice {
10706                bolt11: self.bolt11.cst_decode(),
10707                network: self.network.cst_decode(),
10708                payee_pubkey: self.payee_pubkey.cst_decode(),
10709                payment_hash: self.payment_hash.cst_decode(),
10710                description: self.description.cst_decode(),
10711                description_hash: self.description_hash.cst_decode(),
10712                amount_msat: self.amount_msat.cst_decode(),
10713                timestamp: self.timestamp.cst_decode(),
10714                expiry: self.expiry.cst_decode(),
10715                routing_hints: self.routing_hints.cst_decode(),
10716                payment_secret: self.payment_secret.cst_decode(),
10717                min_final_cltv_expiry_delta: self.min_final_cltv_expiry_delta.cst_decode(),
10718            }
10719        }
10720    }
10721    impl CstDecode<crate::bindings::LNOffer> for wire_cst_ln_offer {
10722        // Codec=Cst (C-struct based), see doc to use other codecs
10723        fn cst_decode(self) -> crate::bindings::LNOffer {
10724            crate::bindings::LNOffer {
10725                offer: self.offer.cst_decode(),
10726                chains: self.chains.cst_decode(),
10727                min_amount: self.min_amount.cst_decode(),
10728                description: self.description.cst_decode(),
10729                absolute_expiry: self.absolute_expiry.cst_decode(),
10730                issuer: self.issuer.cst_decode(),
10731                signing_pubkey: self.signing_pubkey.cst_decode(),
10732                paths: self.paths.cst_decode(),
10733            }
10734        }
10735    }
10736    impl CstDecode<crate::bindings::LnOfferBlindedPath> for wire_cst_ln_offer_blinded_path {
10737        // Codec=Cst (C-struct based), see doc to use other codecs
10738        fn cst_decode(self) -> crate::bindings::LnOfferBlindedPath {
10739            crate::bindings::LnOfferBlindedPath {
10740                blinded_hops: self.blinded_hops.cst_decode(),
10741            }
10742        }
10743    }
10744    impl CstDecode<crate::bindings::duplicates::LnUrlAuthError> for wire_cst_ln_url_auth_error {
10745        // Codec=Cst (C-struct based), see doc to use other codecs
10746        fn cst_decode(self) -> crate::bindings::duplicates::LnUrlAuthError {
10747            match self.tag {
10748                0 => {
10749                    let ans = unsafe { self.kind.Generic };
10750                    crate::bindings::duplicates::LnUrlAuthError::Generic {
10751                        err: ans.err.cst_decode(),
10752                    }
10753                }
10754                1 => {
10755                    let ans = unsafe { self.kind.InvalidUri };
10756                    crate::bindings::duplicates::LnUrlAuthError::InvalidUri {
10757                        err: ans.err.cst_decode(),
10758                    }
10759                }
10760                2 => {
10761                    let ans = unsafe { self.kind.ServiceConnectivity };
10762                    crate::bindings::duplicates::LnUrlAuthError::ServiceConnectivity {
10763                        err: ans.err.cst_decode(),
10764                    }
10765                }
10766                _ => unreachable!(),
10767            }
10768        }
10769    }
10770    impl CstDecode<crate::bindings::LnUrlAuthRequestData> for wire_cst_ln_url_auth_request_data {
10771        // Codec=Cst (C-struct based), see doc to use other codecs
10772        fn cst_decode(self) -> crate::bindings::LnUrlAuthRequestData {
10773            crate::bindings::LnUrlAuthRequestData {
10774                k1: self.k1.cst_decode(),
10775                action: self.action.cst_decode(),
10776                domain: self.domain.cst_decode(),
10777                url: self.url.cst_decode(),
10778            }
10779        }
10780    }
10781    impl CstDecode<crate::bindings::duplicates::LnUrlCallbackStatus>
10782        for wire_cst_ln_url_callback_status
10783    {
10784        // Codec=Cst (C-struct based), see doc to use other codecs
10785        fn cst_decode(self) -> crate::bindings::duplicates::LnUrlCallbackStatus {
10786            match self.tag {
10787                0 => crate::bindings::duplicates::LnUrlCallbackStatus::Ok,
10788                1 => {
10789                    let ans = unsafe { self.kind.ErrorStatus };
10790                    crate::bindings::duplicates::LnUrlCallbackStatus::ErrorStatus {
10791                        data: ans.data.cst_decode(),
10792                    }
10793                }
10794                _ => unreachable!(),
10795            }
10796        }
10797    }
10798    impl CstDecode<crate::bindings::LnUrlErrorData> for wire_cst_ln_url_error_data {
10799        // Codec=Cst (C-struct based), see doc to use other codecs
10800        fn cst_decode(self) -> crate::bindings::LnUrlErrorData {
10801            crate::bindings::LnUrlErrorData {
10802                reason: self.reason.cst_decode(),
10803            }
10804        }
10805    }
10806    impl CstDecode<crate::model::LnUrlInfo> for wire_cst_ln_url_info {
10807        // Codec=Cst (C-struct based), see doc to use other codecs
10808        fn cst_decode(self) -> crate::model::LnUrlInfo {
10809            crate::model::LnUrlInfo {
10810                ln_address: self.ln_address.cst_decode(),
10811                lnurl_pay_comment: self.lnurl_pay_comment.cst_decode(),
10812                lnurl_pay_domain: self.lnurl_pay_domain.cst_decode(),
10813                lnurl_pay_metadata: self.lnurl_pay_metadata.cst_decode(),
10814                lnurl_pay_success_action: self.lnurl_pay_success_action.cst_decode(),
10815                lnurl_pay_unprocessed_success_action: self
10816                    .lnurl_pay_unprocessed_success_action
10817                    .cst_decode(),
10818                lnurl_withdraw_endpoint: self.lnurl_withdraw_endpoint.cst_decode(),
10819            }
10820        }
10821    }
10822    impl CstDecode<crate::bindings::duplicates::LnUrlPayError> for wire_cst_ln_url_pay_error {
10823        // Codec=Cst (C-struct based), see doc to use other codecs
10824        fn cst_decode(self) -> crate::bindings::duplicates::LnUrlPayError {
10825            match self.tag {
10826                0 => crate::bindings::duplicates::LnUrlPayError::AlreadyPaid,
10827                1 => {
10828                    let ans = unsafe { self.kind.Generic };
10829                    crate::bindings::duplicates::LnUrlPayError::Generic {
10830                        err: ans.err.cst_decode(),
10831                    }
10832                }
10833                2 => {
10834                    let ans = unsafe { self.kind.InsufficientBalance };
10835                    crate::bindings::duplicates::LnUrlPayError::InsufficientBalance {
10836                        err: ans.err.cst_decode(),
10837                    }
10838                }
10839                3 => {
10840                    let ans = unsafe { self.kind.InvalidAmount };
10841                    crate::bindings::duplicates::LnUrlPayError::InvalidAmount {
10842                        err: ans.err.cst_decode(),
10843                    }
10844                }
10845                4 => {
10846                    let ans = unsafe { self.kind.InvalidInvoice };
10847                    crate::bindings::duplicates::LnUrlPayError::InvalidInvoice {
10848                        err: ans.err.cst_decode(),
10849                    }
10850                }
10851                5 => {
10852                    let ans = unsafe { self.kind.InvalidNetwork };
10853                    crate::bindings::duplicates::LnUrlPayError::InvalidNetwork {
10854                        err: ans.err.cst_decode(),
10855                    }
10856                }
10857                6 => {
10858                    let ans = unsafe { self.kind.InvalidUri };
10859                    crate::bindings::duplicates::LnUrlPayError::InvalidUri {
10860                        err: ans.err.cst_decode(),
10861                    }
10862                }
10863                7 => {
10864                    let ans = unsafe { self.kind.InvoiceExpired };
10865                    crate::bindings::duplicates::LnUrlPayError::InvoiceExpired {
10866                        err: ans.err.cst_decode(),
10867                    }
10868                }
10869                8 => {
10870                    let ans = unsafe { self.kind.PaymentFailed };
10871                    crate::bindings::duplicates::LnUrlPayError::PaymentFailed {
10872                        err: ans.err.cst_decode(),
10873                    }
10874                }
10875                9 => {
10876                    let ans = unsafe { self.kind.PaymentTimeout };
10877                    crate::bindings::duplicates::LnUrlPayError::PaymentTimeout {
10878                        err: ans.err.cst_decode(),
10879                    }
10880                }
10881                10 => {
10882                    let ans = unsafe { self.kind.RouteNotFound };
10883                    crate::bindings::duplicates::LnUrlPayError::RouteNotFound {
10884                        err: ans.err.cst_decode(),
10885                    }
10886                }
10887                11 => {
10888                    let ans = unsafe { self.kind.RouteTooExpensive };
10889                    crate::bindings::duplicates::LnUrlPayError::RouteTooExpensive {
10890                        err: ans.err.cst_decode(),
10891                    }
10892                }
10893                12 => {
10894                    let ans = unsafe { self.kind.ServiceConnectivity };
10895                    crate::bindings::duplicates::LnUrlPayError::ServiceConnectivity {
10896                        err: ans.err.cst_decode(),
10897                    }
10898                }
10899                _ => unreachable!(),
10900            }
10901        }
10902    }
10903    impl CstDecode<crate::bindings::LnUrlPayErrorData> for wire_cst_ln_url_pay_error_data {
10904        // Codec=Cst (C-struct based), see doc to use other codecs
10905        fn cst_decode(self) -> crate::bindings::LnUrlPayErrorData {
10906            crate::bindings::LnUrlPayErrorData {
10907                payment_hash: self.payment_hash.cst_decode(),
10908                reason: self.reason.cst_decode(),
10909            }
10910        }
10911    }
10912    impl CstDecode<crate::model::LnUrlPayRequest> for wire_cst_ln_url_pay_request {
10913        // Codec=Cst (C-struct based), see doc to use other codecs
10914        fn cst_decode(self) -> crate::model::LnUrlPayRequest {
10915            crate::model::LnUrlPayRequest {
10916                prepare_response: self.prepare_response.cst_decode(),
10917            }
10918        }
10919    }
10920    impl CstDecode<crate::bindings::LnUrlPayRequestData> for wire_cst_ln_url_pay_request_data {
10921        // Codec=Cst (C-struct based), see doc to use other codecs
10922        fn cst_decode(self) -> crate::bindings::LnUrlPayRequestData {
10923            crate::bindings::LnUrlPayRequestData {
10924                callback: self.callback.cst_decode(),
10925                min_sendable: self.min_sendable.cst_decode(),
10926                max_sendable: self.max_sendable.cst_decode(),
10927                metadata_str: self.metadata_str.cst_decode(),
10928                comment_allowed: self.comment_allowed.cst_decode(),
10929                domain: self.domain.cst_decode(),
10930                allows_nostr: self.allows_nostr.cst_decode(),
10931                nostr_pubkey: self.nostr_pubkey.cst_decode(),
10932                ln_address: self.ln_address.cst_decode(),
10933            }
10934        }
10935    }
10936    impl CstDecode<crate::model::LnUrlPayResult> for wire_cst_ln_url_pay_result {
10937        // Codec=Cst (C-struct based), see doc to use other codecs
10938        fn cst_decode(self) -> crate::model::LnUrlPayResult {
10939            match self.tag {
10940                0 => {
10941                    let ans = unsafe { self.kind.EndpointSuccess };
10942                    crate::model::LnUrlPayResult::EndpointSuccess {
10943                        data: ans.data.cst_decode(),
10944                    }
10945                }
10946                1 => {
10947                    let ans = unsafe { self.kind.EndpointError };
10948                    crate::model::LnUrlPayResult::EndpointError {
10949                        data: ans.data.cst_decode(),
10950                    }
10951                }
10952                2 => {
10953                    let ans = unsafe { self.kind.PayError };
10954                    crate::model::LnUrlPayResult::PayError {
10955                        data: ans.data.cst_decode(),
10956                    }
10957                }
10958                _ => unreachable!(),
10959            }
10960        }
10961    }
10962    impl CstDecode<crate::model::LnUrlPaySuccessData> for wire_cst_ln_url_pay_success_data {
10963        // Codec=Cst (C-struct based), see doc to use other codecs
10964        fn cst_decode(self) -> crate::model::LnUrlPaySuccessData {
10965            crate::model::LnUrlPaySuccessData {
10966                payment: self.payment.cst_decode(),
10967                success_action: self.success_action.cst_decode(),
10968            }
10969        }
10970    }
10971    impl CstDecode<crate::bindings::duplicates::LnUrlWithdrawError> for wire_cst_ln_url_withdraw_error {
10972        // Codec=Cst (C-struct based), see doc to use other codecs
10973        fn cst_decode(self) -> crate::bindings::duplicates::LnUrlWithdrawError {
10974            match self.tag {
10975                0 => {
10976                    let ans = unsafe { self.kind.Generic };
10977                    crate::bindings::duplicates::LnUrlWithdrawError::Generic {
10978                        err: ans.err.cst_decode(),
10979                    }
10980                }
10981                1 => {
10982                    let ans = unsafe { self.kind.InvalidAmount };
10983                    crate::bindings::duplicates::LnUrlWithdrawError::InvalidAmount {
10984                        err: ans.err.cst_decode(),
10985                    }
10986                }
10987                2 => {
10988                    let ans = unsafe { self.kind.InvalidInvoice };
10989                    crate::bindings::duplicates::LnUrlWithdrawError::InvalidInvoice {
10990                        err: ans.err.cst_decode(),
10991                    }
10992                }
10993                3 => {
10994                    let ans = unsafe { self.kind.InvalidUri };
10995                    crate::bindings::duplicates::LnUrlWithdrawError::InvalidUri {
10996                        err: ans.err.cst_decode(),
10997                    }
10998                }
10999                4 => {
11000                    let ans = unsafe { self.kind.InvoiceNoRoutingHints };
11001                    crate::bindings::duplicates::LnUrlWithdrawError::InvoiceNoRoutingHints {
11002                        err: ans.err.cst_decode(),
11003                    }
11004                }
11005                5 => {
11006                    let ans = unsafe { self.kind.ServiceConnectivity };
11007                    crate::bindings::duplicates::LnUrlWithdrawError::ServiceConnectivity {
11008                        err: ans.err.cst_decode(),
11009                    }
11010                }
11011                _ => unreachable!(),
11012            }
11013        }
11014    }
11015    impl CstDecode<crate::bindings::LnUrlWithdrawRequest> for wire_cst_ln_url_withdraw_request {
11016        // Codec=Cst (C-struct based), see doc to use other codecs
11017        fn cst_decode(self) -> crate::bindings::LnUrlWithdrawRequest {
11018            crate::bindings::LnUrlWithdrawRequest {
11019                data: self.data.cst_decode(),
11020                amount_msat: self.amount_msat.cst_decode(),
11021                description: self.description.cst_decode(),
11022            }
11023        }
11024    }
11025    impl CstDecode<crate::bindings::LnUrlWithdrawRequestData>
11026        for wire_cst_ln_url_withdraw_request_data
11027    {
11028        // Codec=Cst (C-struct based), see doc to use other codecs
11029        fn cst_decode(self) -> crate::bindings::LnUrlWithdrawRequestData {
11030            crate::bindings::LnUrlWithdrawRequestData {
11031                callback: self.callback.cst_decode(),
11032                k1: self.k1.cst_decode(),
11033                default_description: self.default_description.cst_decode(),
11034                min_withdrawable: self.min_withdrawable.cst_decode(),
11035                max_withdrawable: self.max_withdrawable.cst_decode(),
11036            }
11037        }
11038    }
11039    impl CstDecode<crate::bindings::duplicates::LnUrlWithdrawResult>
11040        for wire_cst_ln_url_withdraw_result
11041    {
11042        // Codec=Cst (C-struct based), see doc to use other codecs
11043        fn cst_decode(self) -> crate::bindings::duplicates::LnUrlWithdrawResult {
11044            match self.tag {
11045                0 => {
11046                    let ans = unsafe { self.kind.Ok };
11047                    crate::bindings::duplicates::LnUrlWithdrawResult::Ok {
11048                        data: ans.data.cst_decode(),
11049                    }
11050                }
11051                1 => {
11052                    let ans = unsafe { self.kind.Timeout };
11053                    crate::bindings::duplicates::LnUrlWithdrawResult::Timeout {
11054                        data: ans.data.cst_decode(),
11055                    }
11056                }
11057                2 => {
11058                    let ans = unsafe { self.kind.ErrorStatus };
11059                    crate::bindings::duplicates::LnUrlWithdrawResult::ErrorStatus {
11060                        data: ans.data.cst_decode(),
11061                    }
11062                }
11063                _ => unreachable!(),
11064            }
11065        }
11066    }
11067    impl CstDecode<crate::bindings::duplicates::LnUrlWithdrawSuccessData>
11068        for wire_cst_ln_url_withdraw_success_data
11069    {
11070        // Codec=Cst (C-struct based), see doc to use other codecs
11071        fn cst_decode(self) -> crate::bindings::duplicates::LnUrlWithdrawSuccessData {
11072            crate::bindings::duplicates::LnUrlWithdrawSuccessData {
11073                invoice: self.invoice.cst_decode(),
11074            }
11075        }
11076    }
11077    impl CstDecode<crate::bindings::LocaleOverrides> for wire_cst_locale_overrides {
11078        // Codec=Cst (C-struct based), see doc to use other codecs
11079        fn cst_decode(self) -> crate::bindings::LocaleOverrides {
11080            crate::bindings::LocaleOverrides {
11081                locale: self.locale.cst_decode(),
11082                spacing: self.spacing.cst_decode(),
11083                symbol: self.symbol.cst_decode(),
11084            }
11085        }
11086    }
11087    impl CstDecode<crate::bindings::LocalizedName> for wire_cst_localized_name {
11088        // Codec=Cst (C-struct based), see doc to use other codecs
11089        fn cst_decode(self) -> crate::bindings::LocalizedName {
11090            crate::bindings::LocalizedName {
11091                locale: self.locale.cst_decode(),
11092                name: self.name.cst_decode(),
11093            }
11094        }
11095    }
11096    impl CstDecode<crate::model::LogEntry> for wire_cst_log_entry {
11097        // Codec=Cst (C-struct based), see doc to use other codecs
11098        fn cst_decode(self) -> crate::model::LogEntry {
11099            crate::model::LogEntry {
11100                line: self.line.cst_decode(),
11101                level: self.level.cst_decode(),
11102            }
11103        }
11104    }
11105    impl CstDecode<crate::bindings::MessageSuccessActionData> for wire_cst_message_success_action_data {
11106        // Codec=Cst (C-struct based), see doc to use other codecs
11107        fn cst_decode(self) -> crate::bindings::MessageSuccessActionData {
11108            crate::bindings::MessageSuccessActionData {
11109                message: self.message.cst_decode(),
11110            }
11111        }
11112    }
11113    impl CstDecode<crate::model::OnchainPaymentLimitsResponse>
11114        for wire_cst_onchain_payment_limits_response
11115    {
11116        // Codec=Cst (C-struct based), see doc to use other codecs
11117        fn cst_decode(self) -> crate::model::OnchainPaymentLimitsResponse {
11118            crate::model::OnchainPaymentLimitsResponse {
11119                send: self.send.cst_decode(),
11120                receive: self.receive.cst_decode(),
11121            }
11122        }
11123    }
11124    impl CstDecode<crate::model::PayAmount> for wire_cst_pay_amount {
11125        // Codec=Cst (C-struct based), see doc to use other codecs
11126        fn cst_decode(self) -> crate::model::PayAmount {
11127            match self.tag {
11128                0 => {
11129                    let ans = unsafe { self.kind.Bitcoin };
11130                    crate::model::PayAmount::Bitcoin {
11131                        receiver_amount_sat: ans.receiver_amount_sat.cst_decode(),
11132                    }
11133                }
11134                1 => {
11135                    let ans = unsafe { self.kind.Asset };
11136                    crate::model::PayAmount::Asset {
11137                        asset_id: ans.asset_id.cst_decode(),
11138                        receiver_amount: ans.receiver_amount.cst_decode(),
11139                        estimate_asset_fees: ans.estimate_asset_fees.cst_decode(),
11140                    }
11141                }
11142                2 => crate::model::PayAmount::Drain,
11143                _ => unreachable!(),
11144            }
11145        }
11146    }
11147    impl CstDecode<crate::model::PayOnchainRequest> for wire_cst_pay_onchain_request {
11148        // Codec=Cst (C-struct based), see doc to use other codecs
11149        fn cst_decode(self) -> crate::model::PayOnchainRequest {
11150            crate::model::PayOnchainRequest {
11151                address: self.address.cst_decode(),
11152                prepare_response: self.prepare_response.cst_decode(),
11153            }
11154        }
11155    }
11156    impl CstDecode<crate::model::Payment> for wire_cst_payment {
11157        // Codec=Cst (C-struct based), see doc to use other codecs
11158        fn cst_decode(self) -> crate::model::Payment {
11159            crate::model::Payment {
11160                destination: self.destination.cst_decode(),
11161                tx_id: self.tx_id.cst_decode(),
11162                unblinding_data: self.unblinding_data.cst_decode(),
11163                timestamp: self.timestamp.cst_decode(),
11164                amount_sat: self.amount_sat.cst_decode(),
11165                fees_sat: self.fees_sat.cst_decode(),
11166                swapper_fees_sat: self.swapper_fees_sat.cst_decode(),
11167                payment_type: self.payment_type.cst_decode(),
11168                status: self.status.cst_decode(),
11169                details: self.details.cst_decode(),
11170            }
11171        }
11172    }
11173    impl CstDecode<crate::model::PaymentDetails> for wire_cst_payment_details {
11174        // Codec=Cst (C-struct based), see doc to use other codecs
11175        fn cst_decode(self) -> crate::model::PaymentDetails {
11176            match self.tag {
11177                0 => {
11178                    let ans = unsafe { self.kind.Lightning };
11179                    crate::model::PaymentDetails::Lightning {
11180                        swap_id: ans.swap_id.cst_decode(),
11181                        description: ans.description.cst_decode(),
11182                        liquid_expiration_blockheight: ans
11183                            .liquid_expiration_blockheight
11184                            .cst_decode(),
11185                        preimage: ans.preimage.cst_decode(),
11186                        invoice: ans.invoice.cst_decode(),
11187                        bolt12_offer: ans.bolt12_offer.cst_decode(),
11188                        payment_hash: ans.payment_hash.cst_decode(),
11189                        destination_pubkey: ans.destination_pubkey.cst_decode(),
11190                        lnurl_info: ans.lnurl_info.cst_decode(),
11191                        bip353_address: ans.bip353_address.cst_decode(),
11192                        payer_note: ans.payer_note.cst_decode(),
11193                        claim_tx_id: ans.claim_tx_id.cst_decode(),
11194                        refund_tx_id: ans.refund_tx_id.cst_decode(),
11195                        refund_tx_amount_sat: ans.refund_tx_amount_sat.cst_decode(),
11196                    }
11197                }
11198                1 => {
11199                    let ans = unsafe { self.kind.Liquid };
11200                    crate::model::PaymentDetails::Liquid {
11201                        destination: ans.destination.cst_decode(),
11202                        description: ans.description.cst_decode(),
11203                        asset_id: ans.asset_id.cst_decode(),
11204                        asset_info: ans.asset_info.cst_decode(),
11205                        lnurl_info: ans.lnurl_info.cst_decode(),
11206                        bip353_address: ans.bip353_address.cst_decode(),
11207                        payer_note: ans.payer_note.cst_decode(),
11208                    }
11209                }
11210                2 => {
11211                    let ans = unsafe { self.kind.Bitcoin };
11212                    crate::model::PaymentDetails::Bitcoin {
11213                        swap_id: ans.swap_id.cst_decode(),
11214                        bitcoin_address: ans.bitcoin_address.cst_decode(),
11215                        description: ans.description.cst_decode(),
11216                        auto_accepted_fees: ans.auto_accepted_fees.cst_decode(),
11217                        liquid_expiration_blockheight: ans
11218                            .liquid_expiration_blockheight
11219                            .cst_decode(),
11220                        bitcoin_expiration_blockheight: ans
11221                            .bitcoin_expiration_blockheight
11222                            .cst_decode(),
11223                        lockup_tx_id: ans.lockup_tx_id.cst_decode(),
11224                        claim_tx_id: ans.claim_tx_id.cst_decode(),
11225                        refund_tx_id: ans.refund_tx_id.cst_decode(),
11226                        refund_tx_amount_sat: ans.refund_tx_amount_sat.cst_decode(),
11227                    }
11228                }
11229                _ => unreachable!(),
11230            }
11231        }
11232    }
11233    impl CstDecode<crate::error::PaymentError> for wire_cst_payment_error {
11234        // Codec=Cst (C-struct based), see doc to use other codecs
11235        fn cst_decode(self) -> crate::error::PaymentError {
11236            match self.tag {
11237                0 => crate::error::PaymentError::AlreadyClaimed,
11238                1 => crate::error::PaymentError::AlreadyPaid,
11239                2 => crate::error::PaymentError::PaymentInProgress,
11240                3 => {
11241                    let ans = unsafe { self.kind.AmountOutOfRange };
11242                    crate::error::PaymentError::AmountOutOfRange {
11243                        min: ans.min.cst_decode(),
11244                        max: ans.max.cst_decode(),
11245                    }
11246                }
11247                4 => {
11248                    let ans = unsafe { self.kind.AmountMissing };
11249                    crate::error::PaymentError::AmountMissing {
11250                        err: ans.err.cst_decode(),
11251                    }
11252                }
11253                5 => {
11254                    let ans = unsafe { self.kind.AssetError };
11255                    crate::error::PaymentError::AssetError {
11256                        err: ans.err.cst_decode(),
11257                    }
11258                }
11259                6 => {
11260                    let ans = unsafe { self.kind.InvalidNetwork };
11261                    crate::error::PaymentError::InvalidNetwork {
11262                        err: ans.err.cst_decode(),
11263                    }
11264                }
11265                7 => {
11266                    let ans = unsafe { self.kind.Generic };
11267                    crate::error::PaymentError::Generic {
11268                        err: ans.err.cst_decode(),
11269                    }
11270                }
11271                8 => crate::error::PaymentError::InvalidOrExpiredFees,
11272                9 => crate::error::PaymentError::InsufficientFunds,
11273                10 => {
11274                    let ans = unsafe { self.kind.InvalidDescription };
11275                    crate::error::PaymentError::InvalidDescription {
11276                        err: ans.err.cst_decode(),
11277                    }
11278                }
11279                11 => {
11280                    let ans = unsafe { self.kind.InvalidInvoice };
11281                    crate::error::PaymentError::InvalidInvoice {
11282                        err: ans.err.cst_decode(),
11283                    }
11284                }
11285                12 => crate::error::PaymentError::InvalidPreimage,
11286                13 => crate::error::PaymentError::PairsNotFound,
11287                14 => crate::error::PaymentError::PaymentTimeout,
11288                15 => crate::error::PaymentError::PersistError,
11289                16 => {
11290                    let ans = unsafe { self.kind.ReceiveError };
11291                    crate::error::PaymentError::ReceiveError {
11292                        err: ans.err.cst_decode(),
11293                    }
11294                }
11295                17 => {
11296                    let ans = unsafe { self.kind.Refunded };
11297                    crate::error::PaymentError::Refunded {
11298                        err: ans.err.cst_decode(),
11299                        refund_tx_id: ans.refund_tx_id.cst_decode(),
11300                    }
11301                }
11302                18 => crate::error::PaymentError::SelfTransferNotSupported,
11303                19 => {
11304                    let ans = unsafe { self.kind.SendError };
11305                    crate::error::PaymentError::SendError {
11306                        err: ans.err.cst_decode(),
11307                    }
11308                }
11309                20 => {
11310                    let ans = unsafe { self.kind.SignerError };
11311                    crate::error::PaymentError::SignerError {
11312                        err: ans.err.cst_decode(),
11313                    }
11314                }
11315                _ => unreachable!(),
11316            }
11317        }
11318    }
11319    impl CstDecode<crate::model::PrepareBuyBitcoinRequest> for wire_cst_prepare_buy_bitcoin_request {
11320        // Codec=Cst (C-struct based), see doc to use other codecs
11321        fn cst_decode(self) -> crate::model::PrepareBuyBitcoinRequest {
11322            crate::model::PrepareBuyBitcoinRequest {
11323                provider: self.provider.cst_decode(),
11324                amount_sat: self.amount_sat.cst_decode(),
11325            }
11326        }
11327    }
11328    impl CstDecode<crate::model::PrepareBuyBitcoinResponse> for wire_cst_prepare_buy_bitcoin_response {
11329        // Codec=Cst (C-struct based), see doc to use other codecs
11330        fn cst_decode(self) -> crate::model::PrepareBuyBitcoinResponse {
11331            crate::model::PrepareBuyBitcoinResponse {
11332                provider: self.provider.cst_decode(),
11333                amount_sat: self.amount_sat.cst_decode(),
11334                fees_sat: self.fees_sat.cst_decode(),
11335            }
11336        }
11337    }
11338    impl CstDecode<crate::model::PrepareLnUrlPayRequest> for wire_cst_prepare_ln_url_pay_request {
11339        // Codec=Cst (C-struct based), see doc to use other codecs
11340        fn cst_decode(self) -> crate::model::PrepareLnUrlPayRequest {
11341            crate::model::PrepareLnUrlPayRequest {
11342                data: self.data.cst_decode(),
11343                amount: self.amount.cst_decode(),
11344                bip353_address: self.bip353_address.cst_decode(),
11345                comment: self.comment.cst_decode(),
11346                validate_success_action_url: self.validate_success_action_url.cst_decode(),
11347            }
11348        }
11349    }
11350    impl CstDecode<crate::model::PrepareLnUrlPayResponse> for wire_cst_prepare_ln_url_pay_response {
11351        // Codec=Cst (C-struct based), see doc to use other codecs
11352        fn cst_decode(self) -> crate::model::PrepareLnUrlPayResponse {
11353            crate::model::PrepareLnUrlPayResponse {
11354                destination: self.destination.cst_decode(),
11355                fees_sat: self.fees_sat.cst_decode(),
11356                data: self.data.cst_decode(),
11357                amount: self.amount.cst_decode(),
11358                comment: self.comment.cst_decode(),
11359                success_action: self.success_action.cst_decode(),
11360            }
11361        }
11362    }
11363    impl CstDecode<crate::model::PreparePayOnchainRequest> for wire_cst_prepare_pay_onchain_request {
11364        // Codec=Cst (C-struct based), see doc to use other codecs
11365        fn cst_decode(self) -> crate::model::PreparePayOnchainRequest {
11366            crate::model::PreparePayOnchainRequest {
11367                amount: self.amount.cst_decode(),
11368                fee_rate_sat_per_vbyte: self.fee_rate_sat_per_vbyte.cst_decode(),
11369            }
11370        }
11371    }
11372    impl CstDecode<crate::model::PreparePayOnchainResponse> for wire_cst_prepare_pay_onchain_response {
11373        // Codec=Cst (C-struct based), see doc to use other codecs
11374        fn cst_decode(self) -> crate::model::PreparePayOnchainResponse {
11375            crate::model::PreparePayOnchainResponse {
11376                receiver_amount_sat: self.receiver_amount_sat.cst_decode(),
11377                claim_fees_sat: self.claim_fees_sat.cst_decode(),
11378                total_fees_sat: self.total_fees_sat.cst_decode(),
11379            }
11380        }
11381    }
11382    impl CstDecode<crate::model::PrepareReceiveRequest> for wire_cst_prepare_receive_request {
11383        // Codec=Cst (C-struct based), see doc to use other codecs
11384        fn cst_decode(self) -> crate::model::PrepareReceiveRequest {
11385            crate::model::PrepareReceiveRequest {
11386                payment_method: self.payment_method.cst_decode(),
11387                amount: self.amount.cst_decode(),
11388            }
11389        }
11390    }
11391    impl CstDecode<crate::model::PrepareReceiveResponse> for wire_cst_prepare_receive_response {
11392        // Codec=Cst (C-struct based), see doc to use other codecs
11393        fn cst_decode(self) -> crate::model::PrepareReceiveResponse {
11394            crate::model::PrepareReceiveResponse {
11395                payment_method: self.payment_method.cst_decode(),
11396                fees_sat: self.fees_sat.cst_decode(),
11397                amount: self.amount.cst_decode(),
11398                min_payer_amount_sat: self.min_payer_amount_sat.cst_decode(),
11399                max_payer_amount_sat: self.max_payer_amount_sat.cst_decode(),
11400                swapper_feerate: self.swapper_feerate.cst_decode(),
11401            }
11402        }
11403    }
11404    impl CstDecode<crate::model::PrepareRefundRequest> for wire_cst_prepare_refund_request {
11405        // Codec=Cst (C-struct based), see doc to use other codecs
11406        fn cst_decode(self) -> crate::model::PrepareRefundRequest {
11407            crate::model::PrepareRefundRequest {
11408                swap_address: self.swap_address.cst_decode(),
11409                refund_address: self.refund_address.cst_decode(),
11410                fee_rate_sat_per_vbyte: self.fee_rate_sat_per_vbyte.cst_decode(),
11411            }
11412        }
11413    }
11414    impl CstDecode<crate::model::PrepareRefundResponse> for wire_cst_prepare_refund_response {
11415        // Codec=Cst (C-struct based), see doc to use other codecs
11416        fn cst_decode(self) -> crate::model::PrepareRefundResponse {
11417            crate::model::PrepareRefundResponse {
11418                tx_vsize: self.tx_vsize.cst_decode(),
11419                tx_fee_sat: self.tx_fee_sat.cst_decode(),
11420                last_refund_tx_id: self.last_refund_tx_id.cst_decode(),
11421            }
11422        }
11423    }
11424    impl CstDecode<crate::model::PrepareSendRequest> for wire_cst_prepare_send_request {
11425        // Codec=Cst (C-struct based), see doc to use other codecs
11426        fn cst_decode(self) -> crate::model::PrepareSendRequest {
11427            crate::model::PrepareSendRequest {
11428                destination: self.destination.cst_decode(),
11429                amount: self.amount.cst_decode(),
11430            }
11431        }
11432    }
11433    impl CstDecode<crate::model::PrepareSendResponse> for wire_cst_prepare_send_response {
11434        // Codec=Cst (C-struct based), see doc to use other codecs
11435        fn cst_decode(self) -> crate::model::PrepareSendResponse {
11436            crate::model::PrepareSendResponse {
11437                destination: self.destination.cst_decode(),
11438                amount: self.amount.cst_decode(),
11439                fees_sat: self.fees_sat.cst_decode(),
11440                estimated_asset_fees: self.estimated_asset_fees.cst_decode(),
11441            }
11442        }
11443    }
11444    impl CstDecode<crate::bindings::Rate> for wire_cst_rate {
11445        // Codec=Cst (C-struct based), see doc to use other codecs
11446        fn cst_decode(self) -> crate::bindings::Rate {
11447            crate::bindings::Rate {
11448                coin: self.coin.cst_decode(),
11449                value: self.value.cst_decode(),
11450            }
11451        }
11452    }
11453    impl CstDecode<crate::model::ReceiveAmount> for wire_cst_receive_amount {
11454        // Codec=Cst (C-struct based), see doc to use other codecs
11455        fn cst_decode(self) -> crate::model::ReceiveAmount {
11456            match self.tag {
11457                0 => {
11458                    let ans = unsafe { self.kind.Bitcoin };
11459                    crate::model::ReceiveAmount::Bitcoin {
11460                        payer_amount_sat: ans.payer_amount_sat.cst_decode(),
11461                    }
11462                }
11463                1 => {
11464                    let ans = unsafe { self.kind.Asset };
11465                    crate::model::ReceiveAmount::Asset {
11466                        asset_id: ans.asset_id.cst_decode(),
11467                        payer_amount: ans.payer_amount.cst_decode(),
11468                    }
11469                }
11470                _ => unreachable!(),
11471            }
11472        }
11473    }
11474    impl CstDecode<crate::model::ReceivePaymentRequest> for wire_cst_receive_payment_request {
11475        // Codec=Cst (C-struct based), see doc to use other codecs
11476        fn cst_decode(self) -> crate::model::ReceivePaymentRequest {
11477            crate::model::ReceivePaymentRequest {
11478                prepare_response: self.prepare_response.cst_decode(),
11479                description: self.description.cst_decode(),
11480                use_description_hash: self.use_description_hash.cst_decode(),
11481                payer_note: self.payer_note.cst_decode(),
11482            }
11483        }
11484    }
11485    impl CstDecode<crate::model::ReceivePaymentResponse> for wire_cst_receive_payment_response {
11486        // Codec=Cst (C-struct based), see doc to use other codecs
11487        fn cst_decode(self) -> crate::model::ReceivePaymentResponse {
11488            crate::model::ReceivePaymentResponse {
11489                destination: self.destination.cst_decode(),
11490            }
11491        }
11492    }
11493    impl CstDecode<crate::model::RecommendedFees> for wire_cst_recommended_fees {
11494        // Codec=Cst (C-struct based), see doc to use other codecs
11495        fn cst_decode(self) -> crate::model::RecommendedFees {
11496            crate::model::RecommendedFees {
11497                fastest_fee: self.fastest_fee.cst_decode(),
11498                half_hour_fee: self.half_hour_fee.cst_decode(),
11499                hour_fee: self.hour_fee.cst_decode(),
11500                economy_fee: self.economy_fee.cst_decode(),
11501                minimum_fee: self.minimum_fee.cst_decode(),
11502            }
11503        }
11504    }
11505    impl CstDecode<crate::model::RefundRequest> for wire_cst_refund_request {
11506        // Codec=Cst (C-struct based), see doc to use other codecs
11507        fn cst_decode(self) -> crate::model::RefundRequest {
11508            crate::model::RefundRequest {
11509                swap_address: self.swap_address.cst_decode(),
11510                refund_address: self.refund_address.cst_decode(),
11511                fee_rate_sat_per_vbyte: self.fee_rate_sat_per_vbyte.cst_decode(),
11512            }
11513        }
11514    }
11515    impl CstDecode<crate::model::RefundResponse> for wire_cst_refund_response {
11516        // Codec=Cst (C-struct based), see doc to use other codecs
11517        fn cst_decode(self) -> crate::model::RefundResponse {
11518            crate::model::RefundResponse {
11519                refund_tx_id: self.refund_tx_id.cst_decode(),
11520            }
11521        }
11522    }
11523    impl CstDecode<crate::model::RefundableSwap> for wire_cst_refundable_swap {
11524        // Codec=Cst (C-struct based), see doc to use other codecs
11525        fn cst_decode(self) -> crate::model::RefundableSwap {
11526            crate::model::RefundableSwap {
11527                swap_address: self.swap_address.cst_decode(),
11528                timestamp: self.timestamp.cst_decode(),
11529                amount_sat: self.amount_sat.cst_decode(),
11530                last_refund_tx_id: self.last_refund_tx_id.cst_decode(),
11531            }
11532        }
11533    }
11534    impl CstDecode<crate::model::RestoreRequest> for wire_cst_restore_request {
11535        // Codec=Cst (C-struct based), see doc to use other codecs
11536        fn cst_decode(self) -> crate::model::RestoreRequest {
11537            crate::model::RestoreRequest {
11538                backup_path: self.backup_path.cst_decode(),
11539            }
11540        }
11541    }
11542    impl CstDecode<crate::bindings::RouteHint> for wire_cst_route_hint {
11543        // Codec=Cst (C-struct based), see doc to use other codecs
11544        fn cst_decode(self) -> crate::bindings::RouteHint {
11545            crate::bindings::RouteHint {
11546                hops: self.hops.cst_decode(),
11547            }
11548        }
11549    }
11550    impl CstDecode<crate::bindings::RouteHintHop> for wire_cst_route_hint_hop {
11551        // Codec=Cst (C-struct based), see doc to use other codecs
11552        fn cst_decode(self) -> crate::bindings::RouteHintHop {
11553            crate::bindings::RouteHintHop {
11554                src_node_id: self.src_node_id.cst_decode(),
11555                short_channel_id: self.short_channel_id.cst_decode(),
11556                fees_base_msat: self.fees_base_msat.cst_decode(),
11557                fees_proportional_millionths: self.fees_proportional_millionths.cst_decode(),
11558                cltv_expiry_delta: self.cltv_expiry_delta.cst_decode(),
11559                htlc_minimum_msat: self.htlc_minimum_msat.cst_decode(),
11560                htlc_maximum_msat: self.htlc_maximum_msat.cst_decode(),
11561            }
11562        }
11563    }
11564    impl CstDecode<crate::error::SdkError> for wire_cst_sdk_error {
11565        // Codec=Cst (C-struct based), see doc to use other codecs
11566        fn cst_decode(self) -> crate::error::SdkError {
11567            match self.tag {
11568                0 => crate::error::SdkError::AlreadyStarted,
11569                1 => {
11570                    let ans = unsafe { self.kind.Generic };
11571                    crate::error::SdkError::Generic {
11572                        err: ans.err.cst_decode(),
11573                    }
11574                }
11575                2 => crate::error::SdkError::NotStarted,
11576                3 => {
11577                    let ans = unsafe { self.kind.ServiceConnectivity };
11578                    crate::error::SdkError::ServiceConnectivity {
11579                        err: ans.err.cst_decode(),
11580                    }
11581                }
11582                _ => unreachable!(),
11583            }
11584        }
11585    }
11586    impl CstDecode<crate::model::SdkEvent> for wire_cst_sdk_event {
11587        // Codec=Cst (C-struct based), see doc to use other codecs
11588        fn cst_decode(self) -> crate::model::SdkEvent {
11589            match self.tag {
11590                0 => {
11591                    let ans = unsafe { self.kind.PaymentFailed };
11592                    crate::model::SdkEvent::PaymentFailed {
11593                        details: ans.details.cst_decode(),
11594                    }
11595                }
11596                1 => {
11597                    let ans = unsafe { self.kind.PaymentPending };
11598                    crate::model::SdkEvent::PaymentPending {
11599                        details: ans.details.cst_decode(),
11600                    }
11601                }
11602                2 => {
11603                    let ans = unsafe { self.kind.PaymentRefundable };
11604                    crate::model::SdkEvent::PaymentRefundable {
11605                        details: ans.details.cst_decode(),
11606                    }
11607                }
11608                3 => {
11609                    let ans = unsafe { self.kind.PaymentRefunded };
11610                    crate::model::SdkEvent::PaymentRefunded {
11611                        details: ans.details.cst_decode(),
11612                    }
11613                }
11614                4 => {
11615                    let ans = unsafe { self.kind.PaymentRefundPending };
11616                    crate::model::SdkEvent::PaymentRefundPending {
11617                        details: ans.details.cst_decode(),
11618                    }
11619                }
11620                5 => {
11621                    let ans = unsafe { self.kind.PaymentSucceeded };
11622                    crate::model::SdkEvent::PaymentSucceeded {
11623                        details: ans.details.cst_decode(),
11624                    }
11625                }
11626                6 => {
11627                    let ans = unsafe { self.kind.PaymentWaitingConfirmation };
11628                    crate::model::SdkEvent::PaymentWaitingConfirmation {
11629                        details: ans.details.cst_decode(),
11630                    }
11631                }
11632                7 => {
11633                    let ans = unsafe { self.kind.PaymentWaitingFeeAcceptance };
11634                    crate::model::SdkEvent::PaymentWaitingFeeAcceptance {
11635                        details: ans.details.cst_decode(),
11636                    }
11637                }
11638                8 => crate::model::SdkEvent::Synced,
11639                9 => {
11640                    let ans = unsafe { self.kind.DataSynced };
11641                    crate::model::SdkEvent::DataSynced {
11642                        did_pull_new_records: ans.did_pull_new_records.cst_decode(),
11643                    }
11644                }
11645                _ => unreachable!(),
11646            }
11647        }
11648    }
11649    impl CstDecode<crate::model::SendDestination> for wire_cst_send_destination {
11650        // Codec=Cst (C-struct based), see doc to use other codecs
11651        fn cst_decode(self) -> crate::model::SendDestination {
11652            match self.tag {
11653                0 => {
11654                    let ans = unsafe { self.kind.LiquidAddress };
11655                    crate::model::SendDestination::LiquidAddress {
11656                        address_data: ans.address_data.cst_decode(),
11657                        bip353_address: ans.bip353_address.cst_decode(),
11658                    }
11659                }
11660                1 => {
11661                    let ans = unsafe { self.kind.Bolt11 };
11662                    crate::model::SendDestination::Bolt11 {
11663                        invoice: ans.invoice.cst_decode(),
11664                        bip353_address: ans.bip353_address.cst_decode(),
11665                    }
11666                }
11667                2 => {
11668                    let ans = unsafe { self.kind.Bolt12 };
11669                    crate::model::SendDestination::Bolt12 {
11670                        offer: ans.offer.cst_decode(),
11671                        receiver_amount_sat: ans.receiver_amount_sat.cst_decode(),
11672                        bip353_address: ans.bip353_address.cst_decode(),
11673                    }
11674                }
11675                _ => unreachable!(),
11676            }
11677        }
11678    }
11679    impl CstDecode<crate::model::SendPaymentRequest> for wire_cst_send_payment_request {
11680        // Codec=Cst (C-struct based), see doc to use other codecs
11681        fn cst_decode(self) -> crate::model::SendPaymentRequest {
11682            crate::model::SendPaymentRequest {
11683                prepare_response: self.prepare_response.cst_decode(),
11684                use_asset_fees: self.use_asset_fees.cst_decode(),
11685                payer_note: self.payer_note.cst_decode(),
11686            }
11687        }
11688    }
11689    impl CstDecode<crate::model::SendPaymentResponse> for wire_cst_send_payment_response {
11690        // Codec=Cst (C-struct based), see doc to use other codecs
11691        fn cst_decode(self) -> crate::model::SendPaymentResponse {
11692            crate::model::SendPaymentResponse {
11693                payment: self.payment.cst_decode(),
11694            }
11695        }
11696    }
11697    impl CstDecode<crate::model::SignMessageRequest> for wire_cst_sign_message_request {
11698        // Codec=Cst (C-struct based), see doc to use other codecs
11699        fn cst_decode(self) -> crate::model::SignMessageRequest {
11700            crate::model::SignMessageRequest {
11701                message: self.message.cst_decode(),
11702            }
11703        }
11704    }
11705    impl CstDecode<crate::model::SignMessageResponse> for wire_cst_sign_message_response {
11706        // Codec=Cst (C-struct based), see doc to use other codecs
11707        fn cst_decode(self) -> crate::model::SignMessageResponse {
11708            crate::model::SignMessageResponse {
11709                signature: self.signature.cst_decode(),
11710            }
11711        }
11712    }
11713    impl CstDecode<crate::bindings::SuccessAction> for wire_cst_success_action {
11714        // Codec=Cst (C-struct based), see doc to use other codecs
11715        fn cst_decode(self) -> crate::bindings::SuccessAction {
11716            match self.tag {
11717                0 => {
11718                    let ans = unsafe { self.kind.Aes };
11719                    crate::bindings::SuccessAction::Aes {
11720                        data: ans.data.cst_decode(),
11721                    }
11722                }
11723                1 => {
11724                    let ans = unsafe { self.kind.Message };
11725                    crate::bindings::SuccessAction::Message {
11726                        data: ans.data.cst_decode(),
11727                    }
11728                }
11729                2 => {
11730                    let ans = unsafe { self.kind.Url };
11731                    crate::bindings::SuccessAction::Url {
11732                        data: ans.data.cst_decode(),
11733                    }
11734                }
11735                _ => unreachable!(),
11736            }
11737        }
11738    }
11739    impl CstDecode<crate::bindings::SuccessActionProcessed> for wire_cst_success_action_processed {
11740        // Codec=Cst (C-struct based), see doc to use other codecs
11741        fn cst_decode(self) -> crate::bindings::SuccessActionProcessed {
11742            match self.tag {
11743                0 => {
11744                    let ans = unsafe { self.kind.Aes };
11745                    crate::bindings::SuccessActionProcessed::Aes {
11746                        result: ans.result.cst_decode(),
11747                    }
11748                }
11749                1 => {
11750                    let ans = unsafe { self.kind.Message };
11751                    crate::bindings::SuccessActionProcessed::Message {
11752                        data: ans.data.cst_decode(),
11753                    }
11754                }
11755                2 => {
11756                    let ans = unsafe { self.kind.Url };
11757                    crate::bindings::SuccessActionProcessed::Url {
11758                        data: ans.data.cst_decode(),
11759                    }
11760                }
11761                _ => unreachable!(),
11762            }
11763        }
11764    }
11765    impl CstDecode<crate::bindings::Symbol> for wire_cst_symbol {
11766        // Codec=Cst (C-struct based), see doc to use other codecs
11767        fn cst_decode(self) -> crate::bindings::Symbol {
11768            crate::bindings::Symbol {
11769                grapheme: self.grapheme.cst_decode(),
11770                template: self.template.cst_decode(),
11771                rtl: self.rtl.cst_decode(),
11772                position: self.position.cst_decode(),
11773            }
11774        }
11775    }
11776    impl CstDecode<crate::bindings::UrlSuccessActionData> for wire_cst_url_success_action_data {
11777        // Codec=Cst (C-struct based), see doc to use other codecs
11778        fn cst_decode(self) -> crate::bindings::UrlSuccessActionData {
11779            crate::bindings::UrlSuccessActionData {
11780                description: self.description.cst_decode(),
11781                url: self.url.cst_decode(),
11782                matches_callback_domain: self.matches_callback_domain.cst_decode(),
11783            }
11784        }
11785    }
11786    impl CstDecode<crate::model::WalletInfo> for wire_cst_wallet_info {
11787        // Codec=Cst (C-struct based), see doc to use other codecs
11788        fn cst_decode(self) -> crate::model::WalletInfo {
11789            crate::model::WalletInfo {
11790                balance_sat: self.balance_sat.cst_decode(),
11791                pending_send_sat: self.pending_send_sat.cst_decode(),
11792                pending_receive_sat: self.pending_receive_sat.cst_decode(),
11793                fingerprint: self.fingerprint.cst_decode(),
11794                pubkey: self.pubkey.cst_decode(),
11795                asset_balances: self.asset_balances.cst_decode(),
11796            }
11797        }
11798    }
11799    impl NewWithNullPtr for wire_cst_accept_payment_proposed_fees_request {
11800        fn new_with_null_ptr() -> Self {
11801            Self {
11802                response: Default::default(),
11803            }
11804        }
11805    }
11806    impl Default for wire_cst_accept_payment_proposed_fees_request {
11807        fn default() -> Self {
11808            Self::new_with_null_ptr()
11809        }
11810    }
11811    impl NewWithNullPtr for wire_cst_aes_success_action_data {
11812        fn new_with_null_ptr() -> Self {
11813            Self {
11814                description: core::ptr::null_mut(),
11815                ciphertext: core::ptr::null_mut(),
11816                iv: core::ptr::null_mut(),
11817            }
11818        }
11819    }
11820    impl Default for wire_cst_aes_success_action_data {
11821        fn default() -> Self {
11822            Self::new_with_null_ptr()
11823        }
11824    }
11825    impl NewWithNullPtr for wire_cst_aes_success_action_data_decrypted {
11826        fn new_with_null_ptr() -> Self {
11827            Self {
11828                description: core::ptr::null_mut(),
11829                plaintext: core::ptr::null_mut(),
11830            }
11831        }
11832    }
11833    impl Default for wire_cst_aes_success_action_data_decrypted {
11834        fn default() -> Self {
11835            Self::new_with_null_ptr()
11836        }
11837    }
11838    impl NewWithNullPtr for wire_cst_aes_success_action_data_result {
11839        fn new_with_null_ptr() -> Self {
11840            Self {
11841                tag: -1,
11842                kind: AesSuccessActionDataResultKind { nil__: () },
11843            }
11844        }
11845    }
11846    impl Default for wire_cst_aes_success_action_data_result {
11847        fn default() -> Self {
11848            Self::new_with_null_ptr()
11849        }
11850    }
11851    impl NewWithNullPtr for wire_cst_amount {
11852        fn new_with_null_ptr() -> Self {
11853            Self {
11854                tag: -1,
11855                kind: AmountKind { nil__: () },
11856            }
11857        }
11858    }
11859    impl Default for wire_cst_amount {
11860        fn default() -> Self {
11861            Self::new_with_null_ptr()
11862        }
11863    }
11864    impl NewWithNullPtr for wire_cst_asset_balance {
11865        fn new_with_null_ptr() -> Self {
11866            Self {
11867                asset_id: core::ptr::null_mut(),
11868                balance_sat: Default::default(),
11869                name: core::ptr::null_mut(),
11870                ticker: core::ptr::null_mut(),
11871                balance: core::ptr::null_mut(),
11872            }
11873        }
11874    }
11875    impl Default for wire_cst_asset_balance {
11876        fn default() -> Self {
11877            Self::new_with_null_ptr()
11878        }
11879    }
11880    impl NewWithNullPtr for wire_cst_asset_info {
11881        fn new_with_null_ptr() -> Self {
11882            Self {
11883                name: core::ptr::null_mut(),
11884                ticker: core::ptr::null_mut(),
11885                amount: Default::default(),
11886                fees: core::ptr::null_mut(),
11887            }
11888        }
11889    }
11890    impl Default for wire_cst_asset_info {
11891        fn default() -> Self {
11892            Self::new_with_null_ptr()
11893        }
11894    }
11895    impl NewWithNullPtr for wire_cst_asset_metadata {
11896        fn new_with_null_ptr() -> Self {
11897            Self {
11898                asset_id: core::ptr::null_mut(),
11899                name: core::ptr::null_mut(),
11900                ticker: core::ptr::null_mut(),
11901                precision: Default::default(),
11902                fiat_id: core::ptr::null_mut(),
11903            }
11904        }
11905    }
11906    impl Default for wire_cst_asset_metadata {
11907        fn default() -> Self {
11908            Self::new_with_null_ptr()
11909        }
11910    }
11911    impl NewWithNullPtr for wire_cst_backup_request {
11912        fn new_with_null_ptr() -> Self {
11913            Self {
11914                backup_path: core::ptr::null_mut(),
11915            }
11916        }
11917    }
11918    impl Default for wire_cst_backup_request {
11919        fn default() -> Self {
11920            Self::new_with_null_ptr()
11921        }
11922    }
11923    impl NewWithNullPtr for wire_cst_binding_event_listener {
11924        fn new_with_null_ptr() -> Self {
11925            Self {
11926                stream: core::ptr::null_mut(),
11927            }
11928        }
11929    }
11930    impl Default for wire_cst_binding_event_listener {
11931        fn default() -> Self {
11932            Self::new_with_null_ptr()
11933        }
11934    }
11935    impl NewWithNullPtr for wire_cst_bitcoin_address_data {
11936        fn new_with_null_ptr() -> Self {
11937            Self {
11938                address: core::ptr::null_mut(),
11939                network: Default::default(),
11940                amount_sat: core::ptr::null_mut(),
11941                label: core::ptr::null_mut(),
11942                message: core::ptr::null_mut(),
11943            }
11944        }
11945    }
11946    impl Default for wire_cst_bitcoin_address_data {
11947        fn default() -> Self {
11948            Self::new_with_null_ptr()
11949        }
11950    }
11951    impl NewWithNullPtr for wire_cst_blockchain_explorer {
11952        fn new_with_null_ptr() -> Self {
11953            Self {
11954                tag: -1,
11955                kind: BlockchainExplorerKind { nil__: () },
11956            }
11957        }
11958    }
11959    impl Default for wire_cst_blockchain_explorer {
11960        fn default() -> Self {
11961            Self::new_with_null_ptr()
11962        }
11963    }
11964    impl NewWithNullPtr for wire_cst_blockchain_info {
11965        fn new_with_null_ptr() -> Self {
11966            Self {
11967                liquid_tip: Default::default(),
11968                bitcoin_tip: Default::default(),
11969            }
11970        }
11971    }
11972    impl Default for wire_cst_blockchain_info {
11973        fn default() -> Self {
11974            Self::new_with_null_ptr()
11975        }
11976    }
11977    impl NewWithNullPtr for wire_cst_buy_bitcoin_request {
11978        fn new_with_null_ptr() -> Self {
11979            Self {
11980                prepare_response: Default::default(),
11981                redirect_url: core::ptr::null_mut(),
11982            }
11983        }
11984    }
11985    impl Default for wire_cst_buy_bitcoin_request {
11986        fn default() -> Self {
11987            Self::new_with_null_ptr()
11988        }
11989    }
11990    impl NewWithNullPtr for wire_cst_check_message_request {
11991        fn new_with_null_ptr() -> Self {
11992            Self {
11993                message: core::ptr::null_mut(),
11994                pubkey: core::ptr::null_mut(),
11995                signature: core::ptr::null_mut(),
11996            }
11997        }
11998    }
11999    impl Default for wire_cst_check_message_request {
12000        fn default() -> Self {
12001            Self::new_with_null_ptr()
12002        }
12003    }
12004    impl NewWithNullPtr for wire_cst_check_message_response {
12005        fn new_with_null_ptr() -> Self {
12006            Self {
12007                is_valid: Default::default(),
12008            }
12009        }
12010    }
12011    impl Default for wire_cst_check_message_response {
12012        fn default() -> Self {
12013            Self::new_with_null_ptr()
12014        }
12015    }
12016    impl NewWithNullPtr for wire_cst_config {
12017        fn new_with_null_ptr() -> Self {
12018            Self {
12019                liquid_explorer: Default::default(),
12020                bitcoin_explorer: Default::default(),
12021                working_dir: core::ptr::null_mut(),
12022                network: Default::default(),
12023                payment_timeout_sec: Default::default(),
12024                sync_service_url: core::ptr::null_mut(),
12025                zero_conf_max_amount_sat: core::ptr::null_mut(),
12026                breez_api_key: core::ptr::null_mut(),
12027                external_input_parsers: core::ptr::null_mut(),
12028                use_default_external_input_parsers: Default::default(),
12029                onchain_fee_rate_leeway_sat: core::ptr::null_mut(),
12030                asset_metadata: core::ptr::null_mut(),
12031                sideswap_api_key: core::ptr::null_mut(),
12032            }
12033        }
12034    }
12035    impl Default for wire_cst_config {
12036        fn default() -> Self {
12037            Self::new_with_null_ptr()
12038        }
12039    }
12040    impl NewWithNullPtr for wire_cst_connect_request {
12041        fn new_with_null_ptr() -> Self {
12042            Self {
12043                config: Default::default(),
12044                mnemonic: core::ptr::null_mut(),
12045                passphrase: core::ptr::null_mut(),
12046                seed: core::ptr::null_mut(),
12047            }
12048        }
12049    }
12050    impl Default for wire_cst_connect_request {
12051        fn default() -> Self {
12052            Self::new_with_null_ptr()
12053        }
12054    }
12055    impl NewWithNullPtr for wire_cst_create_bolt_12_invoice_request {
12056        fn new_with_null_ptr() -> Self {
12057            Self {
12058                offer: core::ptr::null_mut(),
12059                invoice_request: core::ptr::null_mut(),
12060            }
12061        }
12062    }
12063    impl Default for wire_cst_create_bolt_12_invoice_request {
12064        fn default() -> Self {
12065            Self::new_with_null_ptr()
12066        }
12067    }
12068    impl NewWithNullPtr for wire_cst_create_bolt_12_invoice_response {
12069        fn new_with_null_ptr() -> Self {
12070            Self {
12071                invoice: core::ptr::null_mut(),
12072            }
12073        }
12074    }
12075    impl Default for wire_cst_create_bolt_12_invoice_response {
12076        fn default() -> Self {
12077            Self::new_with_null_ptr()
12078        }
12079    }
12080    impl NewWithNullPtr for wire_cst_currency_info {
12081        fn new_with_null_ptr() -> Self {
12082            Self {
12083                name: core::ptr::null_mut(),
12084                fraction_size: Default::default(),
12085                spacing: core::ptr::null_mut(),
12086                symbol: core::ptr::null_mut(),
12087                uniq_symbol: core::ptr::null_mut(),
12088                localized_name: core::ptr::null_mut(),
12089                locale_overrides: core::ptr::null_mut(),
12090            }
12091        }
12092    }
12093    impl Default for wire_cst_currency_info {
12094        fn default() -> Self {
12095            Self::new_with_null_ptr()
12096        }
12097    }
12098    impl NewWithNullPtr for wire_cst_external_input_parser {
12099        fn new_with_null_ptr() -> Self {
12100            Self {
12101                provider_id: core::ptr::null_mut(),
12102                input_regex: core::ptr::null_mut(),
12103                parser_url: core::ptr::null_mut(),
12104            }
12105        }
12106    }
12107    impl Default for wire_cst_external_input_parser {
12108        fn default() -> Self {
12109            Self::new_with_null_ptr()
12110        }
12111    }
12112    impl NewWithNullPtr for wire_cst_fetch_payment_proposed_fees_request {
12113        fn new_with_null_ptr() -> Self {
12114            Self {
12115                swap_id: core::ptr::null_mut(),
12116            }
12117        }
12118    }
12119    impl Default for wire_cst_fetch_payment_proposed_fees_request {
12120        fn default() -> Self {
12121            Self::new_with_null_ptr()
12122        }
12123    }
12124    impl NewWithNullPtr for wire_cst_fetch_payment_proposed_fees_response {
12125        fn new_with_null_ptr() -> Self {
12126            Self {
12127                swap_id: core::ptr::null_mut(),
12128                fees_sat: Default::default(),
12129                payer_amount_sat: Default::default(),
12130                receiver_amount_sat: Default::default(),
12131            }
12132        }
12133    }
12134    impl Default for wire_cst_fetch_payment_proposed_fees_response {
12135        fn default() -> Self {
12136            Self::new_with_null_ptr()
12137        }
12138    }
12139    impl NewWithNullPtr for wire_cst_fiat_currency {
12140        fn new_with_null_ptr() -> Self {
12141            Self {
12142                id: core::ptr::null_mut(),
12143                info: Default::default(),
12144            }
12145        }
12146    }
12147    impl Default for wire_cst_fiat_currency {
12148        fn default() -> Self {
12149            Self::new_with_null_ptr()
12150        }
12151    }
12152    impl NewWithNullPtr for wire_cst_get_info_response {
12153        fn new_with_null_ptr() -> Self {
12154            Self {
12155                wallet_info: Default::default(),
12156                blockchain_info: Default::default(),
12157            }
12158        }
12159    }
12160    impl Default for wire_cst_get_info_response {
12161        fn default() -> Self {
12162            Self::new_with_null_ptr()
12163        }
12164    }
12165    impl NewWithNullPtr for wire_cst_get_payment_request {
12166        fn new_with_null_ptr() -> Self {
12167            Self {
12168                tag: -1,
12169                kind: GetPaymentRequestKind { nil__: () },
12170            }
12171        }
12172    }
12173    impl Default for wire_cst_get_payment_request {
12174        fn default() -> Self {
12175            Self::new_with_null_ptr()
12176        }
12177    }
12178    impl NewWithNullPtr for wire_cst_input_type {
12179        fn new_with_null_ptr() -> Self {
12180            Self {
12181                tag: -1,
12182                kind: InputTypeKind { nil__: () },
12183            }
12184        }
12185    }
12186    impl Default for wire_cst_input_type {
12187        fn default() -> Self {
12188            Self::new_with_null_ptr()
12189        }
12190    }
12191    impl NewWithNullPtr for wire_cst_lightning_payment_limits_response {
12192        fn new_with_null_ptr() -> Self {
12193            Self {
12194                send: Default::default(),
12195                receive: Default::default(),
12196            }
12197        }
12198    }
12199    impl Default for wire_cst_lightning_payment_limits_response {
12200        fn default() -> Self {
12201            Self::new_with_null_ptr()
12202        }
12203    }
12204    impl NewWithNullPtr for wire_cst_limits {
12205        fn new_with_null_ptr() -> Self {
12206            Self {
12207                min_sat: Default::default(),
12208                max_sat: Default::default(),
12209                max_zero_conf_sat: Default::default(),
12210            }
12211        }
12212    }
12213    impl Default for wire_cst_limits {
12214        fn default() -> Self {
12215            Self::new_with_null_ptr()
12216        }
12217    }
12218    impl NewWithNullPtr for wire_cst_liquid_address_data {
12219        fn new_with_null_ptr() -> Self {
12220            Self {
12221                address: core::ptr::null_mut(),
12222                network: Default::default(),
12223                asset_id: core::ptr::null_mut(),
12224                amount: core::ptr::null_mut(),
12225                amount_sat: core::ptr::null_mut(),
12226                label: core::ptr::null_mut(),
12227                message: core::ptr::null_mut(),
12228            }
12229        }
12230    }
12231    impl Default for wire_cst_liquid_address_data {
12232        fn default() -> Self {
12233            Self::new_with_null_ptr()
12234        }
12235    }
12236    impl NewWithNullPtr for wire_cst_list_payment_details {
12237        fn new_with_null_ptr() -> Self {
12238            Self {
12239                tag: -1,
12240                kind: ListPaymentDetailsKind { nil__: () },
12241            }
12242        }
12243    }
12244    impl Default for wire_cst_list_payment_details {
12245        fn default() -> Self {
12246            Self::new_with_null_ptr()
12247        }
12248    }
12249    impl NewWithNullPtr for wire_cst_list_payments_request {
12250        fn new_with_null_ptr() -> Self {
12251            Self {
12252                filters: core::ptr::null_mut(),
12253                states: core::ptr::null_mut(),
12254                from_timestamp: core::ptr::null_mut(),
12255                to_timestamp: core::ptr::null_mut(),
12256                offset: core::ptr::null_mut(),
12257                limit: core::ptr::null_mut(),
12258                details: core::ptr::null_mut(),
12259                sort_ascending: core::ptr::null_mut(),
12260            }
12261        }
12262    }
12263    impl Default for wire_cst_list_payments_request {
12264        fn default() -> Self {
12265            Self::new_with_null_ptr()
12266        }
12267    }
12268    impl NewWithNullPtr for wire_cst_ln_invoice {
12269        fn new_with_null_ptr() -> Self {
12270            Self {
12271                bolt11: core::ptr::null_mut(),
12272                network: Default::default(),
12273                payee_pubkey: core::ptr::null_mut(),
12274                payment_hash: core::ptr::null_mut(),
12275                description: core::ptr::null_mut(),
12276                description_hash: core::ptr::null_mut(),
12277                amount_msat: core::ptr::null_mut(),
12278                timestamp: Default::default(),
12279                expiry: Default::default(),
12280                routing_hints: core::ptr::null_mut(),
12281                payment_secret: core::ptr::null_mut(),
12282                min_final_cltv_expiry_delta: Default::default(),
12283            }
12284        }
12285    }
12286    impl Default for wire_cst_ln_invoice {
12287        fn default() -> Self {
12288            Self::new_with_null_ptr()
12289        }
12290    }
12291    impl NewWithNullPtr for wire_cst_ln_offer {
12292        fn new_with_null_ptr() -> Self {
12293            Self {
12294                offer: core::ptr::null_mut(),
12295                chains: core::ptr::null_mut(),
12296                min_amount: core::ptr::null_mut(),
12297                description: core::ptr::null_mut(),
12298                absolute_expiry: core::ptr::null_mut(),
12299                issuer: core::ptr::null_mut(),
12300                signing_pubkey: core::ptr::null_mut(),
12301                paths: core::ptr::null_mut(),
12302            }
12303        }
12304    }
12305    impl Default for wire_cst_ln_offer {
12306        fn default() -> Self {
12307            Self::new_with_null_ptr()
12308        }
12309    }
12310    impl NewWithNullPtr for wire_cst_ln_offer_blinded_path {
12311        fn new_with_null_ptr() -> Self {
12312            Self {
12313                blinded_hops: core::ptr::null_mut(),
12314            }
12315        }
12316    }
12317    impl Default for wire_cst_ln_offer_blinded_path {
12318        fn default() -> Self {
12319            Self::new_with_null_ptr()
12320        }
12321    }
12322    impl NewWithNullPtr for wire_cst_ln_url_auth_error {
12323        fn new_with_null_ptr() -> Self {
12324            Self {
12325                tag: -1,
12326                kind: LnUrlAuthErrorKind { nil__: () },
12327            }
12328        }
12329    }
12330    impl Default for wire_cst_ln_url_auth_error {
12331        fn default() -> Self {
12332            Self::new_with_null_ptr()
12333        }
12334    }
12335    impl NewWithNullPtr for wire_cst_ln_url_auth_request_data {
12336        fn new_with_null_ptr() -> Self {
12337            Self {
12338                k1: core::ptr::null_mut(),
12339                action: core::ptr::null_mut(),
12340                domain: core::ptr::null_mut(),
12341                url: core::ptr::null_mut(),
12342            }
12343        }
12344    }
12345    impl Default for wire_cst_ln_url_auth_request_data {
12346        fn default() -> Self {
12347            Self::new_with_null_ptr()
12348        }
12349    }
12350    impl NewWithNullPtr for wire_cst_ln_url_callback_status {
12351        fn new_with_null_ptr() -> Self {
12352            Self {
12353                tag: -1,
12354                kind: LnUrlCallbackStatusKind { nil__: () },
12355            }
12356        }
12357    }
12358    impl Default for wire_cst_ln_url_callback_status {
12359        fn default() -> Self {
12360            Self::new_with_null_ptr()
12361        }
12362    }
12363    impl NewWithNullPtr for wire_cst_ln_url_error_data {
12364        fn new_with_null_ptr() -> Self {
12365            Self {
12366                reason: core::ptr::null_mut(),
12367            }
12368        }
12369    }
12370    impl Default for wire_cst_ln_url_error_data {
12371        fn default() -> Self {
12372            Self::new_with_null_ptr()
12373        }
12374    }
12375    impl NewWithNullPtr for wire_cst_ln_url_info {
12376        fn new_with_null_ptr() -> Self {
12377            Self {
12378                ln_address: core::ptr::null_mut(),
12379                lnurl_pay_comment: core::ptr::null_mut(),
12380                lnurl_pay_domain: core::ptr::null_mut(),
12381                lnurl_pay_metadata: core::ptr::null_mut(),
12382                lnurl_pay_success_action: core::ptr::null_mut(),
12383                lnurl_pay_unprocessed_success_action: core::ptr::null_mut(),
12384                lnurl_withdraw_endpoint: core::ptr::null_mut(),
12385            }
12386        }
12387    }
12388    impl Default for wire_cst_ln_url_info {
12389        fn default() -> Self {
12390            Self::new_with_null_ptr()
12391        }
12392    }
12393    impl NewWithNullPtr for wire_cst_ln_url_pay_error {
12394        fn new_with_null_ptr() -> Self {
12395            Self {
12396                tag: -1,
12397                kind: LnUrlPayErrorKind { nil__: () },
12398            }
12399        }
12400    }
12401    impl Default for wire_cst_ln_url_pay_error {
12402        fn default() -> Self {
12403            Self::new_with_null_ptr()
12404        }
12405    }
12406    impl NewWithNullPtr for wire_cst_ln_url_pay_error_data {
12407        fn new_with_null_ptr() -> Self {
12408            Self {
12409                payment_hash: core::ptr::null_mut(),
12410                reason: core::ptr::null_mut(),
12411            }
12412        }
12413    }
12414    impl Default for wire_cst_ln_url_pay_error_data {
12415        fn default() -> Self {
12416            Self::new_with_null_ptr()
12417        }
12418    }
12419    impl NewWithNullPtr for wire_cst_ln_url_pay_request {
12420        fn new_with_null_ptr() -> Self {
12421            Self {
12422                prepare_response: Default::default(),
12423            }
12424        }
12425    }
12426    impl Default for wire_cst_ln_url_pay_request {
12427        fn default() -> Self {
12428            Self::new_with_null_ptr()
12429        }
12430    }
12431    impl NewWithNullPtr for wire_cst_ln_url_pay_request_data {
12432        fn new_with_null_ptr() -> Self {
12433            Self {
12434                callback: core::ptr::null_mut(),
12435                min_sendable: Default::default(),
12436                max_sendable: Default::default(),
12437                metadata_str: core::ptr::null_mut(),
12438                comment_allowed: Default::default(),
12439                domain: core::ptr::null_mut(),
12440                allows_nostr: Default::default(),
12441                nostr_pubkey: core::ptr::null_mut(),
12442                ln_address: core::ptr::null_mut(),
12443            }
12444        }
12445    }
12446    impl Default for wire_cst_ln_url_pay_request_data {
12447        fn default() -> Self {
12448            Self::new_with_null_ptr()
12449        }
12450    }
12451    impl NewWithNullPtr for wire_cst_ln_url_pay_result {
12452        fn new_with_null_ptr() -> Self {
12453            Self {
12454                tag: -1,
12455                kind: LnUrlPayResultKind { nil__: () },
12456            }
12457        }
12458    }
12459    impl Default for wire_cst_ln_url_pay_result {
12460        fn default() -> Self {
12461            Self::new_with_null_ptr()
12462        }
12463    }
12464    impl NewWithNullPtr for wire_cst_ln_url_pay_success_data {
12465        fn new_with_null_ptr() -> Self {
12466            Self {
12467                payment: Default::default(),
12468                success_action: core::ptr::null_mut(),
12469            }
12470        }
12471    }
12472    impl Default for wire_cst_ln_url_pay_success_data {
12473        fn default() -> Self {
12474            Self::new_with_null_ptr()
12475        }
12476    }
12477    impl NewWithNullPtr for wire_cst_ln_url_withdraw_error {
12478        fn new_with_null_ptr() -> Self {
12479            Self {
12480                tag: -1,
12481                kind: LnUrlWithdrawErrorKind { nil__: () },
12482            }
12483        }
12484    }
12485    impl Default for wire_cst_ln_url_withdraw_error {
12486        fn default() -> Self {
12487            Self::new_with_null_ptr()
12488        }
12489    }
12490    impl NewWithNullPtr for wire_cst_ln_url_withdraw_request {
12491        fn new_with_null_ptr() -> Self {
12492            Self {
12493                data: Default::default(),
12494                amount_msat: Default::default(),
12495                description: core::ptr::null_mut(),
12496            }
12497        }
12498    }
12499    impl Default for wire_cst_ln_url_withdraw_request {
12500        fn default() -> Self {
12501            Self::new_with_null_ptr()
12502        }
12503    }
12504    impl NewWithNullPtr for wire_cst_ln_url_withdraw_request_data {
12505        fn new_with_null_ptr() -> Self {
12506            Self {
12507                callback: core::ptr::null_mut(),
12508                k1: core::ptr::null_mut(),
12509                default_description: core::ptr::null_mut(),
12510                min_withdrawable: Default::default(),
12511                max_withdrawable: Default::default(),
12512            }
12513        }
12514    }
12515    impl Default for wire_cst_ln_url_withdraw_request_data {
12516        fn default() -> Self {
12517            Self::new_with_null_ptr()
12518        }
12519    }
12520    impl NewWithNullPtr for wire_cst_ln_url_withdraw_result {
12521        fn new_with_null_ptr() -> Self {
12522            Self {
12523                tag: -1,
12524                kind: LnUrlWithdrawResultKind { nil__: () },
12525            }
12526        }
12527    }
12528    impl Default for wire_cst_ln_url_withdraw_result {
12529        fn default() -> Self {
12530            Self::new_with_null_ptr()
12531        }
12532    }
12533    impl NewWithNullPtr for wire_cst_ln_url_withdraw_success_data {
12534        fn new_with_null_ptr() -> Self {
12535            Self {
12536                invoice: Default::default(),
12537            }
12538        }
12539    }
12540    impl Default for wire_cst_ln_url_withdraw_success_data {
12541        fn default() -> Self {
12542            Self::new_with_null_ptr()
12543        }
12544    }
12545    impl NewWithNullPtr for wire_cst_locale_overrides {
12546        fn new_with_null_ptr() -> Self {
12547            Self {
12548                locale: core::ptr::null_mut(),
12549                spacing: core::ptr::null_mut(),
12550                symbol: Default::default(),
12551            }
12552        }
12553    }
12554    impl Default for wire_cst_locale_overrides {
12555        fn default() -> Self {
12556            Self::new_with_null_ptr()
12557        }
12558    }
12559    impl NewWithNullPtr for wire_cst_localized_name {
12560        fn new_with_null_ptr() -> Self {
12561            Self {
12562                locale: core::ptr::null_mut(),
12563                name: core::ptr::null_mut(),
12564            }
12565        }
12566    }
12567    impl Default for wire_cst_localized_name {
12568        fn default() -> Self {
12569            Self::new_with_null_ptr()
12570        }
12571    }
12572    impl NewWithNullPtr for wire_cst_log_entry {
12573        fn new_with_null_ptr() -> Self {
12574            Self {
12575                line: core::ptr::null_mut(),
12576                level: core::ptr::null_mut(),
12577            }
12578        }
12579    }
12580    impl Default for wire_cst_log_entry {
12581        fn default() -> Self {
12582            Self::new_with_null_ptr()
12583        }
12584    }
12585    impl NewWithNullPtr for wire_cst_message_success_action_data {
12586        fn new_with_null_ptr() -> Self {
12587            Self {
12588                message: core::ptr::null_mut(),
12589            }
12590        }
12591    }
12592    impl Default for wire_cst_message_success_action_data {
12593        fn default() -> Self {
12594            Self::new_with_null_ptr()
12595        }
12596    }
12597    impl NewWithNullPtr for wire_cst_onchain_payment_limits_response {
12598        fn new_with_null_ptr() -> Self {
12599            Self {
12600                send: Default::default(),
12601                receive: Default::default(),
12602            }
12603        }
12604    }
12605    impl Default for wire_cst_onchain_payment_limits_response {
12606        fn default() -> Self {
12607            Self::new_with_null_ptr()
12608        }
12609    }
12610    impl NewWithNullPtr for wire_cst_pay_amount {
12611        fn new_with_null_ptr() -> Self {
12612            Self {
12613                tag: -1,
12614                kind: PayAmountKind { nil__: () },
12615            }
12616        }
12617    }
12618    impl Default for wire_cst_pay_amount {
12619        fn default() -> Self {
12620            Self::new_with_null_ptr()
12621        }
12622    }
12623    impl NewWithNullPtr for wire_cst_pay_onchain_request {
12624        fn new_with_null_ptr() -> Self {
12625            Self {
12626                address: core::ptr::null_mut(),
12627                prepare_response: Default::default(),
12628            }
12629        }
12630    }
12631    impl Default for wire_cst_pay_onchain_request {
12632        fn default() -> Self {
12633            Self::new_with_null_ptr()
12634        }
12635    }
12636    impl NewWithNullPtr for wire_cst_payment {
12637        fn new_with_null_ptr() -> Self {
12638            Self {
12639                destination: core::ptr::null_mut(),
12640                tx_id: core::ptr::null_mut(),
12641                unblinding_data: core::ptr::null_mut(),
12642                timestamp: Default::default(),
12643                amount_sat: Default::default(),
12644                fees_sat: Default::default(),
12645                swapper_fees_sat: core::ptr::null_mut(),
12646                payment_type: Default::default(),
12647                status: Default::default(),
12648                details: Default::default(),
12649            }
12650        }
12651    }
12652    impl Default for wire_cst_payment {
12653        fn default() -> Self {
12654            Self::new_with_null_ptr()
12655        }
12656    }
12657    impl NewWithNullPtr for wire_cst_payment_details {
12658        fn new_with_null_ptr() -> Self {
12659            Self {
12660                tag: -1,
12661                kind: PaymentDetailsKind { nil__: () },
12662            }
12663        }
12664    }
12665    impl Default for wire_cst_payment_details {
12666        fn default() -> Self {
12667            Self::new_with_null_ptr()
12668        }
12669    }
12670    impl NewWithNullPtr for wire_cst_payment_error {
12671        fn new_with_null_ptr() -> Self {
12672            Self {
12673                tag: -1,
12674                kind: PaymentErrorKind { nil__: () },
12675            }
12676        }
12677    }
12678    impl Default for wire_cst_payment_error {
12679        fn default() -> Self {
12680            Self::new_with_null_ptr()
12681        }
12682    }
12683    impl NewWithNullPtr for wire_cst_prepare_buy_bitcoin_request {
12684        fn new_with_null_ptr() -> Self {
12685            Self {
12686                provider: Default::default(),
12687                amount_sat: Default::default(),
12688            }
12689        }
12690    }
12691    impl Default for wire_cst_prepare_buy_bitcoin_request {
12692        fn default() -> Self {
12693            Self::new_with_null_ptr()
12694        }
12695    }
12696    impl NewWithNullPtr for wire_cst_prepare_buy_bitcoin_response {
12697        fn new_with_null_ptr() -> Self {
12698            Self {
12699                provider: Default::default(),
12700                amount_sat: Default::default(),
12701                fees_sat: Default::default(),
12702            }
12703        }
12704    }
12705    impl Default for wire_cst_prepare_buy_bitcoin_response {
12706        fn default() -> Self {
12707            Self::new_with_null_ptr()
12708        }
12709    }
12710    impl NewWithNullPtr for wire_cst_prepare_ln_url_pay_request {
12711        fn new_with_null_ptr() -> Self {
12712            Self {
12713                data: Default::default(),
12714                amount: Default::default(),
12715                bip353_address: core::ptr::null_mut(),
12716                comment: core::ptr::null_mut(),
12717                validate_success_action_url: core::ptr::null_mut(),
12718            }
12719        }
12720    }
12721    impl Default for wire_cst_prepare_ln_url_pay_request {
12722        fn default() -> Self {
12723            Self::new_with_null_ptr()
12724        }
12725    }
12726    impl NewWithNullPtr for wire_cst_prepare_ln_url_pay_response {
12727        fn new_with_null_ptr() -> Self {
12728            Self {
12729                destination: Default::default(),
12730                fees_sat: Default::default(),
12731                data: Default::default(),
12732                amount: Default::default(),
12733                comment: core::ptr::null_mut(),
12734                success_action: core::ptr::null_mut(),
12735            }
12736        }
12737    }
12738    impl Default for wire_cst_prepare_ln_url_pay_response {
12739        fn default() -> Self {
12740            Self::new_with_null_ptr()
12741        }
12742    }
12743    impl NewWithNullPtr for wire_cst_prepare_pay_onchain_request {
12744        fn new_with_null_ptr() -> Self {
12745            Self {
12746                amount: Default::default(),
12747                fee_rate_sat_per_vbyte: core::ptr::null_mut(),
12748            }
12749        }
12750    }
12751    impl Default for wire_cst_prepare_pay_onchain_request {
12752        fn default() -> Self {
12753            Self::new_with_null_ptr()
12754        }
12755    }
12756    impl NewWithNullPtr for wire_cst_prepare_pay_onchain_response {
12757        fn new_with_null_ptr() -> Self {
12758            Self {
12759                receiver_amount_sat: Default::default(),
12760                claim_fees_sat: Default::default(),
12761                total_fees_sat: Default::default(),
12762            }
12763        }
12764    }
12765    impl Default for wire_cst_prepare_pay_onchain_response {
12766        fn default() -> Self {
12767            Self::new_with_null_ptr()
12768        }
12769    }
12770    impl NewWithNullPtr for wire_cst_prepare_receive_request {
12771        fn new_with_null_ptr() -> Self {
12772            Self {
12773                payment_method: Default::default(),
12774                amount: core::ptr::null_mut(),
12775            }
12776        }
12777    }
12778    impl Default for wire_cst_prepare_receive_request {
12779        fn default() -> Self {
12780            Self::new_with_null_ptr()
12781        }
12782    }
12783    impl NewWithNullPtr for wire_cst_prepare_receive_response {
12784        fn new_with_null_ptr() -> Self {
12785            Self {
12786                payment_method: Default::default(),
12787                fees_sat: Default::default(),
12788                amount: core::ptr::null_mut(),
12789                min_payer_amount_sat: core::ptr::null_mut(),
12790                max_payer_amount_sat: core::ptr::null_mut(),
12791                swapper_feerate: core::ptr::null_mut(),
12792            }
12793        }
12794    }
12795    impl Default for wire_cst_prepare_receive_response {
12796        fn default() -> Self {
12797            Self::new_with_null_ptr()
12798        }
12799    }
12800    impl NewWithNullPtr for wire_cst_prepare_refund_request {
12801        fn new_with_null_ptr() -> Self {
12802            Self {
12803                swap_address: core::ptr::null_mut(),
12804                refund_address: core::ptr::null_mut(),
12805                fee_rate_sat_per_vbyte: Default::default(),
12806            }
12807        }
12808    }
12809    impl Default for wire_cst_prepare_refund_request {
12810        fn default() -> Self {
12811            Self::new_with_null_ptr()
12812        }
12813    }
12814    impl NewWithNullPtr for wire_cst_prepare_refund_response {
12815        fn new_with_null_ptr() -> Self {
12816            Self {
12817                tx_vsize: Default::default(),
12818                tx_fee_sat: Default::default(),
12819                last_refund_tx_id: core::ptr::null_mut(),
12820            }
12821        }
12822    }
12823    impl Default for wire_cst_prepare_refund_response {
12824        fn default() -> Self {
12825            Self::new_with_null_ptr()
12826        }
12827    }
12828    impl NewWithNullPtr for wire_cst_prepare_send_request {
12829        fn new_with_null_ptr() -> Self {
12830            Self {
12831                destination: core::ptr::null_mut(),
12832                amount: core::ptr::null_mut(),
12833            }
12834        }
12835    }
12836    impl Default for wire_cst_prepare_send_request {
12837        fn default() -> Self {
12838            Self::new_with_null_ptr()
12839        }
12840    }
12841    impl NewWithNullPtr for wire_cst_prepare_send_response {
12842        fn new_with_null_ptr() -> Self {
12843            Self {
12844                destination: Default::default(),
12845                amount: core::ptr::null_mut(),
12846                fees_sat: core::ptr::null_mut(),
12847                estimated_asset_fees: core::ptr::null_mut(),
12848            }
12849        }
12850    }
12851    impl Default for wire_cst_prepare_send_response {
12852        fn default() -> Self {
12853            Self::new_with_null_ptr()
12854        }
12855    }
12856    impl NewWithNullPtr for wire_cst_rate {
12857        fn new_with_null_ptr() -> Self {
12858            Self {
12859                coin: core::ptr::null_mut(),
12860                value: Default::default(),
12861            }
12862        }
12863    }
12864    impl Default for wire_cst_rate {
12865        fn default() -> Self {
12866            Self::new_with_null_ptr()
12867        }
12868    }
12869    impl NewWithNullPtr for wire_cst_receive_amount {
12870        fn new_with_null_ptr() -> Self {
12871            Self {
12872                tag: -1,
12873                kind: ReceiveAmountKind { nil__: () },
12874            }
12875        }
12876    }
12877    impl Default for wire_cst_receive_amount {
12878        fn default() -> Self {
12879            Self::new_with_null_ptr()
12880        }
12881    }
12882    impl NewWithNullPtr for wire_cst_receive_payment_request {
12883        fn new_with_null_ptr() -> Self {
12884            Self {
12885                prepare_response: Default::default(),
12886                description: core::ptr::null_mut(),
12887                use_description_hash: core::ptr::null_mut(),
12888                payer_note: core::ptr::null_mut(),
12889            }
12890        }
12891    }
12892    impl Default for wire_cst_receive_payment_request {
12893        fn default() -> Self {
12894            Self::new_with_null_ptr()
12895        }
12896    }
12897    impl NewWithNullPtr for wire_cst_receive_payment_response {
12898        fn new_with_null_ptr() -> Self {
12899            Self {
12900                destination: core::ptr::null_mut(),
12901            }
12902        }
12903    }
12904    impl Default for wire_cst_receive_payment_response {
12905        fn default() -> Self {
12906            Self::new_with_null_ptr()
12907        }
12908    }
12909    impl NewWithNullPtr for wire_cst_recommended_fees {
12910        fn new_with_null_ptr() -> Self {
12911            Self {
12912                fastest_fee: Default::default(),
12913                half_hour_fee: Default::default(),
12914                hour_fee: Default::default(),
12915                economy_fee: Default::default(),
12916                minimum_fee: Default::default(),
12917            }
12918        }
12919    }
12920    impl Default for wire_cst_recommended_fees {
12921        fn default() -> Self {
12922            Self::new_with_null_ptr()
12923        }
12924    }
12925    impl NewWithNullPtr for wire_cst_refund_request {
12926        fn new_with_null_ptr() -> Self {
12927            Self {
12928                swap_address: core::ptr::null_mut(),
12929                refund_address: core::ptr::null_mut(),
12930                fee_rate_sat_per_vbyte: Default::default(),
12931            }
12932        }
12933    }
12934    impl Default for wire_cst_refund_request {
12935        fn default() -> Self {
12936            Self::new_with_null_ptr()
12937        }
12938    }
12939    impl NewWithNullPtr for wire_cst_refund_response {
12940        fn new_with_null_ptr() -> Self {
12941            Self {
12942                refund_tx_id: core::ptr::null_mut(),
12943            }
12944        }
12945    }
12946    impl Default for wire_cst_refund_response {
12947        fn default() -> Self {
12948            Self::new_with_null_ptr()
12949        }
12950    }
12951    impl NewWithNullPtr for wire_cst_refundable_swap {
12952        fn new_with_null_ptr() -> Self {
12953            Self {
12954                swap_address: core::ptr::null_mut(),
12955                timestamp: Default::default(),
12956                amount_sat: Default::default(),
12957                last_refund_tx_id: core::ptr::null_mut(),
12958            }
12959        }
12960    }
12961    impl Default for wire_cst_refundable_swap {
12962        fn default() -> Self {
12963            Self::new_with_null_ptr()
12964        }
12965    }
12966    impl NewWithNullPtr for wire_cst_restore_request {
12967        fn new_with_null_ptr() -> Self {
12968            Self {
12969                backup_path: core::ptr::null_mut(),
12970            }
12971        }
12972    }
12973    impl Default for wire_cst_restore_request {
12974        fn default() -> Self {
12975            Self::new_with_null_ptr()
12976        }
12977    }
12978    impl NewWithNullPtr for wire_cst_route_hint {
12979        fn new_with_null_ptr() -> Self {
12980            Self {
12981                hops: core::ptr::null_mut(),
12982            }
12983        }
12984    }
12985    impl Default for wire_cst_route_hint {
12986        fn default() -> Self {
12987            Self::new_with_null_ptr()
12988        }
12989    }
12990    impl NewWithNullPtr for wire_cst_route_hint_hop {
12991        fn new_with_null_ptr() -> Self {
12992            Self {
12993                src_node_id: core::ptr::null_mut(),
12994                short_channel_id: core::ptr::null_mut(),
12995                fees_base_msat: Default::default(),
12996                fees_proportional_millionths: Default::default(),
12997                cltv_expiry_delta: Default::default(),
12998                htlc_minimum_msat: core::ptr::null_mut(),
12999                htlc_maximum_msat: core::ptr::null_mut(),
13000            }
13001        }
13002    }
13003    impl Default for wire_cst_route_hint_hop {
13004        fn default() -> Self {
13005            Self::new_with_null_ptr()
13006        }
13007    }
13008    impl NewWithNullPtr for wire_cst_sdk_error {
13009        fn new_with_null_ptr() -> Self {
13010            Self {
13011                tag: -1,
13012                kind: SdkErrorKind { nil__: () },
13013            }
13014        }
13015    }
13016    impl Default for wire_cst_sdk_error {
13017        fn default() -> Self {
13018            Self::new_with_null_ptr()
13019        }
13020    }
13021    impl NewWithNullPtr for wire_cst_sdk_event {
13022        fn new_with_null_ptr() -> Self {
13023            Self {
13024                tag: -1,
13025                kind: SdkEventKind { nil__: () },
13026            }
13027        }
13028    }
13029    impl Default for wire_cst_sdk_event {
13030        fn default() -> Self {
13031            Self::new_with_null_ptr()
13032        }
13033    }
13034    impl NewWithNullPtr for wire_cst_send_destination {
13035        fn new_with_null_ptr() -> Self {
13036            Self {
13037                tag: -1,
13038                kind: SendDestinationKind { nil__: () },
13039            }
13040        }
13041    }
13042    impl Default for wire_cst_send_destination {
13043        fn default() -> Self {
13044            Self::new_with_null_ptr()
13045        }
13046    }
13047    impl NewWithNullPtr for wire_cst_send_payment_request {
13048        fn new_with_null_ptr() -> Self {
13049            Self {
13050                prepare_response: Default::default(),
13051                use_asset_fees: core::ptr::null_mut(),
13052                payer_note: core::ptr::null_mut(),
13053            }
13054        }
13055    }
13056    impl Default for wire_cst_send_payment_request {
13057        fn default() -> Self {
13058            Self::new_with_null_ptr()
13059        }
13060    }
13061    impl NewWithNullPtr for wire_cst_send_payment_response {
13062        fn new_with_null_ptr() -> Self {
13063            Self {
13064                payment: Default::default(),
13065            }
13066        }
13067    }
13068    impl Default for wire_cst_send_payment_response {
13069        fn default() -> Self {
13070            Self::new_with_null_ptr()
13071        }
13072    }
13073    impl NewWithNullPtr for wire_cst_sign_message_request {
13074        fn new_with_null_ptr() -> Self {
13075            Self {
13076                message: core::ptr::null_mut(),
13077            }
13078        }
13079    }
13080    impl Default for wire_cst_sign_message_request {
13081        fn default() -> Self {
13082            Self::new_with_null_ptr()
13083        }
13084    }
13085    impl NewWithNullPtr for wire_cst_sign_message_response {
13086        fn new_with_null_ptr() -> Self {
13087            Self {
13088                signature: core::ptr::null_mut(),
13089            }
13090        }
13091    }
13092    impl Default for wire_cst_sign_message_response {
13093        fn default() -> Self {
13094            Self::new_with_null_ptr()
13095        }
13096    }
13097    impl NewWithNullPtr for wire_cst_success_action {
13098        fn new_with_null_ptr() -> Self {
13099            Self {
13100                tag: -1,
13101                kind: SuccessActionKind { nil__: () },
13102            }
13103        }
13104    }
13105    impl Default for wire_cst_success_action {
13106        fn default() -> Self {
13107            Self::new_with_null_ptr()
13108        }
13109    }
13110    impl NewWithNullPtr for wire_cst_success_action_processed {
13111        fn new_with_null_ptr() -> Self {
13112            Self {
13113                tag: -1,
13114                kind: SuccessActionProcessedKind { nil__: () },
13115            }
13116        }
13117    }
13118    impl Default for wire_cst_success_action_processed {
13119        fn default() -> Self {
13120            Self::new_with_null_ptr()
13121        }
13122    }
13123    impl NewWithNullPtr for wire_cst_symbol {
13124        fn new_with_null_ptr() -> Self {
13125            Self {
13126                grapheme: core::ptr::null_mut(),
13127                template: core::ptr::null_mut(),
13128                rtl: core::ptr::null_mut(),
13129                position: core::ptr::null_mut(),
13130            }
13131        }
13132    }
13133    impl Default for wire_cst_symbol {
13134        fn default() -> Self {
13135            Self::new_with_null_ptr()
13136        }
13137    }
13138    impl NewWithNullPtr for wire_cst_url_success_action_data {
13139        fn new_with_null_ptr() -> Self {
13140            Self {
13141                description: core::ptr::null_mut(),
13142                url: core::ptr::null_mut(),
13143                matches_callback_domain: Default::default(),
13144            }
13145        }
13146    }
13147    impl Default for wire_cst_url_success_action_data {
13148        fn default() -> Self {
13149            Self::new_with_null_ptr()
13150        }
13151    }
13152    impl NewWithNullPtr for wire_cst_wallet_info {
13153        fn new_with_null_ptr() -> Self {
13154            Self {
13155                balance_sat: Default::default(),
13156                pending_send_sat: Default::default(),
13157                pending_receive_sat: Default::default(),
13158                fingerprint: core::ptr::null_mut(),
13159                pubkey: core::ptr::null_mut(),
13160                asset_balances: core::ptr::null_mut(),
13161            }
13162        }
13163    }
13164    impl Default for wire_cst_wallet_info {
13165        fn default() -> Self {
13166            Self::new_with_null_ptr()
13167        }
13168    }
13169
13170    #[unsafe(no_mangle)]
13171    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_accept_payment_proposed_fees(
13172        port_: i64,
13173        that: usize,
13174        req: *mut wire_cst_accept_payment_proposed_fees_request,
13175    ) {
13176        wire__crate__bindings__BindingLiquidSdk_accept_payment_proposed_fees_impl(port_, that, req)
13177    }
13178
13179    #[unsafe(no_mangle)]
13180    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_add_event_listener(
13181        port_: i64,
13182        that: usize,
13183        listener: *mut wire_cst_list_prim_u_8_strict,
13184    ) {
13185        wire__crate__bindings__BindingLiquidSdk_add_event_listener_impl(port_, that, listener)
13186    }
13187
13188    #[unsafe(no_mangle)]
13189    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_backup(
13190        that: usize,
13191        req: *mut wire_cst_backup_request,
13192    ) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
13193        wire__crate__bindings__BindingLiquidSdk_backup_impl(that, req)
13194    }
13195
13196    #[unsafe(no_mangle)]
13197    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_buy_bitcoin(
13198        port_: i64,
13199        that: usize,
13200        req: *mut wire_cst_buy_bitcoin_request,
13201    ) {
13202        wire__crate__bindings__BindingLiquidSdk_buy_bitcoin_impl(port_, that, req)
13203    }
13204
13205    #[unsafe(no_mangle)]
13206    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_check_message(
13207        that: usize,
13208        req: *mut wire_cst_check_message_request,
13209    ) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
13210        wire__crate__bindings__BindingLiquidSdk_check_message_impl(that, req)
13211    }
13212
13213    #[unsafe(no_mangle)]
13214    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_create_bolt12_invoice(
13215        port_: i64,
13216        that: usize,
13217        req: *mut wire_cst_create_bolt_12_invoice_request,
13218    ) {
13219        wire__crate__bindings__BindingLiquidSdk_create_bolt12_invoice_impl(port_, that, req)
13220    }
13221
13222    #[unsafe(no_mangle)]
13223    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_disconnect(
13224        port_: i64,
13225        that: usize,
13226    ) {
13227        wire__crate__bindings__BindingLiquidSdk_disconnect_impl(port_, that)
13228    }
13229
13230    #[unsafe(no_mangle)]
13231    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_empty_wallet_cache(
13232        that: usize,
13233    ) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
13234        wire__crate__bindings__BindingLiquidSdk_empty_wallet_cache_impl(that)
13235    }
13236
13237    #[unsafe(no_mangle)]
13238    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_fetch_fiat_rates(
13239        port_: i64,
13240        that: usize,
13241    ) {
13242        wire__crate__bindings__BindingLiquidSdk_fetch_fiat_rates_impl(port_, that)
13243    }
13244
13245    #[unsafe(no_mangle)]
13246    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_fetch_lightning_limits(
13247        port_: i64,
13248        that: usize,
13249    ) {
13250        wire__crate__bindings__BindingLiquidSdk_fetch_lightning_limits_impl(port_, that)
13251    }
13252
13253    #[unsafe(no_mangle)]
13254    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_fetch_onchain_limits(
13255        port_: i64,
13256        that: usize,
13257    ) {
13258        wire__crate__bindings__BindingLiquidSdk_fetch_onchain_limits_impl(port_, that)
13259    }
13260
13261    #[unsafe(no_mangle)]
13262    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_fetch_payment_proposed_fees(
13263        port_: i64,
13264        that: usize,
13265        req: *mut wire_cst_fetch_payment_proposed_fees_request,
13266    ) {
13267        wire__crate__bindings__BindingLiquidSdk_fetch_payment_proposed_fees_impl(port_, that, req)
13268    }
13269
13270    #[unsafe(no_mangle)]
13271    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_get_info(
13272        port_: i64,
13273        that: usize,
13274    ) {
13275        wire__crate__bindings__BindingLiquidSdk_get_info_impl(port_, that)
13276    }
13277
13278    #[unsafe(no_mangle)]
13279    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_get_payment(
13280        port_: i64,
13281        that: usize,
13282        req: *mut wire_cst_get_payment_request,
13283    ) {
13284        wire__crate__bindings__BindingLiquidSdk_get_payment_impl(port_, that, req)
13285    }
13286
13287    #[unsafe(no_mangle)]
13288    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_list_fiat_currencies(
13289        port_: i64,
13290        that: usize,
13291    ) {
13292        wire__crate__bindings__BindingLiquidSdk_list_fiat_currencies_impl(port_, that)
13293    }
13294
13295    #[unsafe(no_mangle)]
13296    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_list_payments(
13297        port_: i64,
13298        that: usize,
13299        req: *mut wire_cst_list_payments_request,
13300    ) {
13301        wire__crate__bindings__BindingLiquidSdk_list_payments_impl(port_, that, req)
13302    }
13303
13304    #[unsafe(no_mangle)]
13305    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_list_refundables(
13306        port_: i64,
13307        that: usize,
13308    ) {
13309        wire__crate__bindings__BindingLiquidSdk_list_refundables_impl(port_, that)
13310    }
13311
13312    #[unsafe(no_mangle)]
13313    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_lnurl_auth(
13314        port_: i64,
13315        that: usize,
13316        req_data: *mut wire_cst_ln_url_auth_request_data,
13317    ) {
13318        wire__crate__bindings__BindingLiquidSdk_lnurl_auth_impl(port_, that, req_data)
13319    }
13320
13321    #[unsafe(no_mangle)]
13322    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_lnurl_pay(
13323        port_: i64,
13324        that: usize,
13325        req: *mut wire_cst_ln_url_pay_request,
13326    ) {
13327        wire__crate__bindings__BindingLiquidSdk_lnurl_pay_impl(port_, that, req)
13328    }
13329
13330    #[unsafe(no_mangle)]
13331    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_lnurl_withdraw(
13332        port_: i64,
13333        that: usize,
13334        req: *mut wire_cst_ln_url_withdraw_request,
13335    ) {
13336        wire__crate__bindings__BindingLiquidSdk_lnurl_withdraw_impl(port_, that, req)
13337    }
13338
13339    #[unsafe(no_mangle)]
13340    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_parse(
13341        port_: i64,
13342        that: usize,
13343        input: *mut wire_cst_list_prim_u_8_strict,
13344    ) {
13345        wire__crate__bindings__BindingLiquidSdk_parse_impl(port_, that, input)
13346    }
13347
13348    #[unsafe(no_mangle)]
13349    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_pay_onchain(
13350        port_: i64,
13351        that: usize,
13352        req: *mut wire_cst_pay_onchain_request,
13353    ) {
13354        wire__crate__bindings__BindingLiquidSdk_pay_onchain_impl(port_, that, req)
13355    }
13356
13357    #[unsafe(no_mangle)]
13358    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_prepare_buy_bitcoin(
13359        port_: i64,
13360        that: usize,
13361        req: *mut wire_cst_prepare_buy_bitcoin_request,
13362    ) {
13363        wire__crate__bindings__BindingLiquidSdk_prepare_buy_bitcoin_impl(port_, that, req)
13364    }
13365
13366    #[unsafe(no_mangle)]
13367    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_prepare_lnurl_pay(
13368        port_: i64,
13369        that: usize,
13370        req: *mut wire_cst_prepare_ln_url_pay_request,
13371    ) {
13372        wire__crate__bindings__BindingLiquidSdk_prepare_lnurl_pay_impl(port_, that, req)
13373    }
13374
13375    #[unsafe(no_mangle)]
13376    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_prepare_pay_onchain(
13377        port_: i64,
13378        that: usize,
13379        req: *mut wire_cst_prepare_pay_onchain_request,
13380    ) {
13381        wire__crate__bindings__BindingLiquidSdk_prepare_pay_onchain_impl(port_, that, req)
13382    }
13383
13384    #[unsafe(no_mangle)]
13385    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_prepare_receive_payment(
13386        port_: i64,
13387        that: usize,
13388        req: *mut wire_cst_prepare_receive_request,
13389    ) {
13390        wire__crate__bindings__BindingLiquidSdk_prepare_receive_payment_impl(port_, that, req)
13391    }
13392
13393    #[unsafe(no_mangle)]
13394    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_prepare_refund(
13395        port_: i64,
13396        that: usize,
13397        req: *mut wire_cst_prepare_refund_request,
13398    ) {
13399        wire__crate__bindings__BindingLiquidSdk_prepare_refund_impl(port_, that, req)
13400    }
13401
13402    #[unsafe(no_mangle)]
13403    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_prepare_send_payment(
13404        port_: i64,
13405        that: usize,
13406        req: *mut wire_cst_prepare_send_request,
13407    ) {
13408        wire__crate__bindings__BindingLiquidSdk_prepare_send_payment_impl(port_, that, req)
13409    }
13410
13411    #[unsafe(no_mangle)]
13412    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_receive_payment(
13413        port_: i64,
13414        that: usize,
13415        req: *mut wire_cst_receive_payment_request,
13416    ) {
13417        wire__crate__bindings__BindingLiquidSdk_receive_payment_impl(port_, that, req)
13418    }
13419
13420    #[unsafe(no_mangle)]
13421    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_recommended_fees(
13422        port_: i64,
13423        that: usize,
13424    ) {
13425        wire__crate__bindings__BindingLiquidSdk_recommended_fees_impl(port_, that)
13426    }
13427
13428    #[unsafe(no_mangle)]
13429    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_refund(
13430        port_: i64,
13431        that: usize,
13432        req: *mut wire_cst_refund_request,
13433    ) {
13434        wire__crate__bindings__BindingLiquidSdk_refund_impl(port_, that, req)
13435    }
13436
13437    #[unsafe(no_mangle)]
13438    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_register_webhook(
13439        port_: i64,
13440        that: usize,
13441        webhook_url: *mut wire_cst_list_prim_u_8_strict,
13442    ) {
13443        wire__crate__bindings__BindingLiquidSdk_register_webhook_impl(port_, that, webhook_url)
13444    }
13445
13446    #[unsafe(no_mangle)]
13447    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_rescan_onchain_swaps(
13448        port_: i64,
13449        that: usize,
13450    ) {
13451        wire__crate__bindings__BindingLiquidSdk_rescan_onchain_swaps_impl(port_, that)
13452    }
13453
13454    #[unsafe(no_mangle)]
13455    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_restore(
13456        that: usize,
13457        req: *mut wire_cst_restore_request,
13458    ) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
13459        wire__crate__bindings__BindingLiquidSdk_restore_impl(that, req)
13460    }
13461
13462    #[unsafe(no_mangle)]
13463    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_send_payment(
13464        port_: i64,
13465        that: usize,
13466        req: *mut wire_cst_send_payment_request,
13467    ) {
13468        wire__crate__bindings__BindingLiquidSdk_send_payment_impl(port_, that, req)
13469    }
13470
13471    #[unsafe(no_mangle)]
13472    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_sign_message(
13473        that: usize,
13474        req: *mut wire_cst_sign_message_request,
13475    ) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
13476        wire__crate__bindings__BindingLiquidSdk_sign_message_impl(that, req)
13477    }
13478
13479    #[unsafe(no_mangle)]
13480    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_sync(
13481        port_: i64,
13482        that: usize,
13483    ) {
13484        wire__crate__bindings__BindingLiquidSdk_sync_impl(port_, that)
13485    }
13486
13487    #[unsafe(no_mangle)]
13488    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_unregister_webhook(
13489        port_: i64,
13490        that: usize,
13491    ) {
13492        wire__crate__bindings__BindingLiquidSdk_unregister_webhook_impl(port_, that)
13493    }
13494
13495    #[unsafe(no_mangle)]
13496    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__binding_event_listener_on_event(
13497        port_: i64,
13498        that: *mut wire_cst_binding_event_listener,
13499        e: *mut wire_cst_sdk_event,
13500    ) {
13501        wire__crate__bindings__binding_event_listener_on_event_impl(port_, that, e)
13502    }
13503
13504    #[unsafe(no_mangle)]
13505    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__breez_log_stream(
13506        port_: i64,
13507        s: *mut wire_cst_list_prim_u_8_strict,
13508    ) {
13509        wire__crate__bindings__breez_log_stream_impl(port_, s)
13510    }
13511
13512    #[unsafe(no_mangle)]
13513    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__connect(
13514        port_: i64,
13515        req: *mut wire_cst_connect_request,
13516    ) {
13517        wire__crate__bindings__connect_impl(port_, req)
13518    }
13519
13520    #[unsafe(no_mangle)]
13521    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__default_config(
13522        network: i32,
13523        breez_api_key: *mut wire_cst_list_prim_u_8_strict,
13524    ) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
13525        wire__crate__bindings__default_config_impl(network, breez_api_key)
13526    }
13527
13528    #[unsafe(no_mangle)]
13529    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__parse_invoice(
13530        input: *mut wire_cst_list_prim_u_8_strict,
13531    ) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
13532        wire__crate__bindings__parse_invoice_impl(input)
13533    }
13534
13535    #[unsafe(no_mangle)]
13536    pub extern "C" fn frbgen_breez_liquid_rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerBindingLiquidSdk(
13537        ptr: *const std::ffi::c_void,
13538    ) {
13539        unsafe {
13540            StdArc::<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>::increment_strong_count(ptr as _);
13541        }
13542    }
13543
13544    #[unsafe(no_mangle)]
13545    pub extern "C" fn frbgen_breez_liquid_rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerBindingLiquidSdk(
13546        ptr: *const std::ffi::c_void,
13547    ) {
13548        unsafe {
13549            StdArc::<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>::decrement_strong_count(ptr as _);
13550        }
13551    }
13552
13553    #[unsafe(no_mangle)]
13554    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_accept_payment_proposed_fees_request(
13555    ) -> *mut wire_cst_accept_payment_proposed_fees_request {
13556        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13557            wire_cst_accept_payment_proposed_fees_request::new_with_null_ptr(),
13558        )
13559    }
13560
13561    #[unsafe(no_mangle)]
13562    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_aes_success_action_data(
13563    ) -> *mut wire_cst_aes_success_action_data {
13564        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13565            wire_cst_aes_success_action_data::new_with_null_ptr(),
13566        )
13567    }
13568
13569    #[unsafe(no_mangle)]
13570    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_aes_success_action_data_decrypted(
13571    ) -> *mut wire_cst_aes_success_action_data_decrypted {
13572        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13573            wire_cst_aes_success_action_data_decrypted::new_with_null_ptr(),
13574        )
13575    }
13576
13577    #[unsafe(no_mangle)]
13578    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_aes_success_action_data_result(
13579    ) -> *mut wire_cst_aes_success_action_data_result {
13580        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13581            wire_cst_aes_success_action_data_result::new_with_null_ptr(),
13582        )
13583    }
13584
13585    #[unsafe(no_mangle)]
13586    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_amount() -> *mut wire_cst_amount {
13587        flutter_rust_bridge::for_generated::new_leak_box_ptr(wire_cst_amount::new_with_null_ptr())
13588    }
13589
13590    #[unsafe(no_mangle)]
13591    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_asset_info(
13592    ) -> *mut wire_cst_asset_info {
13593        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13594            wire_cst_asset_info::new_with_null_ptr(),
13595        )
13596    }
13597
13598    #[unsafe(no_mangle)]
13599    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_backup_request(
13600    ) -> *mut wire_cst_backup_request {
13601        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13602            wire_cst_backup_request::new_with_null_ptr(),
13603        )
13604    }
13605
13606    #[unsafe(no_mangle)]
13607    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_binding_event_listener(
13608    ) -> *mut wire_cst_binding_event_listener {
13609        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13610            wire_cst_binding_event_listener::new_with_null_ptr(),
13611        )
13612    }
13613
13614    #[unsafe(no_mangle)]
13615    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_bitcoin_address_data(
13616    ) -> *mut wire_cst_bitcoin_address_data {
13617        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13618            wire_cst_bitcoin_address_data::new_with_null_ptr(),
13619        )
13620    }
13621
13622    #[unsafe(no_mangle)]
13623    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_bool(value: bool) -> *mut bool {
13624        flutter_rust_bridge::for_generated::new_leak_box_ptr(value)
13625    }
13626
13627    #[unsafe(no_mangle)]
13628    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_buy_bitcoin_request(
13629    ) -> *mut wire_cst_buy_bitcoin_request {
13630        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13631            wire_cst_buy_bitcoin_request::new_with_null_ptr(),
13632        )
13633    }
13634
13635    #[unsafe(no_mangle)]
13636    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_check_message_request(
13637    ) -> *mut wire_cst_check_message_request {
13638        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13639            wire_cst_check_message_request::new_with_null_ptr(),
13640        )
13641    }
13642
13643    #[unsafe(no_mangle)]
13644    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_connect_request(
13645    ) -> *mut wire_cst_connect_request {
13646        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13647            wire_cst_connect_request::new_with_null_ptr(),
13648        )
13649    }
13650
13651    #[unsafe(no_mangle)]
13652    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_create_bolt_12_invoice_request(
13653    ) -> *mut wire_cst_create_bolt_12_invoice_request {
13654        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13655            wire_cst_create_bolt_12_invoice_request::new_with_null_ptr(),
13656        )
13657    }
13658
13659    #[unsafe(no_mangle)]
13660    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_f_64(value: f64) -> *mut f64 {
13661        flutter_rust_bridge::for_generated::new_leak_box_ptr(value)
13662    }
13663
13664    #[unsafe(no_mangle)]
13665    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_fetch_payment_proposed_fees_request(
13666    ) -> *mut wire_cst_fetch_payment_proposed_fees_request {
13667        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13668            wire_cst_fetch_payment_proposed_fees_request::new_with_null_ptr(),
13669        )
13670    }
13671
13672    #[unsafe(no_mangle)]
13673    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_get_payment_request(
13674    ) -> *mut wire_cst_get_payment_request {
13675        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13676            wire_cst_get_payment_request::new_with_null_ptr(),
13677        )
13678    }
13679
13680    #[unsafe(no_mangle)]
13681    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_i_64(value: i64) -> *mut i64 {
13682        flutter_rust_bridge::for_generated::new_leak_box_ptr(value)
13683    }
13684
13685    #[unsafe(no_mangle)]
13686    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_liquid_address_data(
13687    ) -> *mut wire_cst_liquid_address_data {
13688        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13689            wire_cst_liquid_address_data::new_with_null_ptr(),
13690        )
13691    }
13692
13693    #[unsafe(no_mangle)]
13694    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_list_payment_details(
13695    ) -> *mut wire_cst_list_payment_details {
13696        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13697            wire_cst_list_payment_details::new_with_null_ptr(),
13698        )
13699    }
13700
13701    #[unsafe(no_mangle)]
13702    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_list_payments_request(
13703    ) -> *mut wire_cst_list_payments_request {
13704        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13705            wire_cst_list_payments_request::new_with_null_ptr(),
13706        )
13707    }
13708
13709    #[unsafe(no_mangle)]
13710    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_invoice(
13711    ) -> *mut wire_cst_ln_invoice {
13712        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13713            wire_cst_ln_invoice::new_with_null_ptr(),
13714        )
13715    }
13716
13717    #[unsafe(no_mangle)]
13718    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_offer() -> *mut wire_cst_ln_offer {
13719        flutter_rust_bridge::for_generated::new_leak_box_ptr(wire_cst_ln_offer::new_with_null_ptr())
13720    }
13721
13722    #[unsafe(no_mangle)]
13723    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_url_auth_request_data(
13724    ) -> *mut wire_cst_ln_url_auth_request_data {
13725        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13726            wire_cst_ln_url_auth_request_data::new_with_null_ptr(),
13727        )
13728    }
13729
13730    #[unsafe(no_mangle)]
13731    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_url_error_data(
13732    ) -> *mut wire_cst_ln_url_error_data {
13733        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13734            wire_cst_ln_url_error_data::new_with_null_ptr(),
13735        )
13736    }
13737
13738    #[unsafe(no_mangle)]
13739    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_url_info(
13740    ) -> *mut wire_cst_ln_url_info {
13741        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13742            wire_cst_ln_url_info::new_with_null_ptr(),
13743        )
13744    }
13745
13746    #[unsafe(no_mangle)]
13747    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_url_pay_error_data(
13748    ) -> *mut wire_cst_ln_url_pay_error_data {
13749        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13750            wire_cst_ln_url_pay_error_data::new_with_null_ptr(),
13751        )
13752    }
13753
13754    #[unsafe(no_mangle)]
13755    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_url_pay_request(
13756    ) -> *mut wire_cst_ln_url_pay_request {
13757        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13758            wire_cst_ln_url_pay_request::new_with_null_ptr(),
13759        )
13760    }
13761
13762    #[unsafe(no_mangle)]
13763    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_url_pay_request_data(
13764    ) -> *mut wire_cst_ln_url_pay_request_data {
13765        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13766            wire_cst_ln_url_pay_request_data::new_with_null_ptr(),
13767        )
13768    }
13769
13770    #[unsafe(no_mangle)]
13771    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_url_pay_success_data(
13772    ) -> *mut wire_cst_ln_url_pay_success_data {
13773        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13774            wire_cst_ln_url_pay_success_data::new_with_null_ptr(),
13775        )
13776    }
13777
13778    #[unsafe(no_mangle)]
13779    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_url_withdraw_request(
13780    ) -> *mut wire_cst_ln_url_withdraw_request {
13781        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13782            wire_cst_ln_url_withdraw_request::new_with_null_ptr(),
13783        )
13784    }
13785
13786    #[unsafe(no_mangle)]
13787    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_url_withdraw_request_data(
13788    ) -> *mut wire_cst_ln_url_withdraw_request_data {
13789        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13790            wire_cst_ln_url_withdraw_request_data::new_with_null_ptr(),
13791        )
13792    }
13793
13794    #[unsafe(no_mangle)]
13795    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_url_withdraw_success_data(
13796    ) -> *mut wire_cst_ln_url_withdraw_success_data {
13797        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13798            wire_cst_ln_url_withdraw_success_data::new_with_null_ptr(),
13799        )
13800    }
13801
13802    #[unsafe(no_mangle)]
13803    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_message_success_action_data(
13804    ) -> *mut wire_cst_message_success_action_data {
13805        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13806            wire_cst_message_success_action_data::new_with_null_ptr(),
13807        )
13808    }
13809
13810    #[unsafe(no_mangle)]
13811    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_pay_amount(
13812    ) -> *mut wire_cst_pay_amount {
13813        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13814            wire_cst_pay_amount::new_with_null_ptr(),
13815        )
13816    }
13817
13818    #[unsafe(no_mangle)]
13819    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_pay_onchain_request(
13820    ) -> *mut wire_cst_pay_onchain_request {
13821        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13822            wire_cst_pay_onchain_request::new_with_null_ptr(),
13823        )
13824    }
13825
13826    #[unsafe(no_mangle)]
13827    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_payment() -> *mut wire_cst_payment {
13828        flutter_rust_bridge::for_generated::new_leak_box_ptr(wire_cst_payment::new_with_null_ptr())
13829    }
13830
13831    #[unsafe(no_mangle)]
13832    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_prepare_buy_bitcoin_request(
13833    ) -> *mut wire_cst_prepare_buy_bitcoin_request {
13834        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13835            wire_cst_prepare_buy_bitcoin_request::new_with_null_ptr(),
13836        )
13837    }
13838
13839    #[unsafe(no_mangle)]
13840    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_prepare_ln_url_pay_request(
13841    ) -> *mut wire_cst_prepare_ln_url_pay_request {
13842        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13843            wire_cst_prepare_ln_url_pay_request::new_with_null_ptr(),
13844        )
13845    }
13846
13847    #[unsafe(no_mangle)]
13848    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_prepare_pay_onchain_request(
13849    ) -> *mut wire_cst_prepare_pay_onchain_request {
13850        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13851            wire_cst_prepare_pay_onchain_request::new_with_null_ptr(),
13852        )
13853    }
13854
13855    #[unsafe(no_mangle)]
13856    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_prepare_receive_request(
13857    ) -> *mut wire_cst_prepare_receive_request {
13858        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13859            wire_cst_prepare_receive_request::new_with_null_ptr(),
13860        )
13861    }
13862
13863    #[unsafe(no_mangle)]
13864    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_prepare_refund_request(
13865    ) -> *mut wire_cst_prepare_refund_request {
13866        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13867            wire_cst_prepare_refund_request::new_with_null_ptr(),
13868        )
13869    }
13870
13871    #[unsafe(no_mangle)]
13872    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_prepare_send_request(
13873    ) -> *mut wire_cst_prepare_send_request {
13874        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13875            wire_cst_prepare_send_request::new_with_null_ptr(),
13876        )
13877    }
13878
13879    #[unsafe(no_mangle)]
13880    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_receive_amount(
13881    ) -> *mut wire_cst_receive_amount {
13882        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13883            wire_cst_receive_amount::new_with_null_ptr(),
13884        )
13885    }
13886
13887    #[unsafe(no_mangle)]
13888    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_receive_payment_request(
13889    ) -> *mut wire_cst_receive_payment_request {
13890        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13891            wire_cst_receive_payment_request::new_with_null_ptr(),
13892        )
13893    }
13894
13895    #[unsafe(no_mangle)]
13896    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_refund_request(
13897    ) -> *mut wire_cst_refund_request {
13898        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13899            wire_cst_refund_request::new_with_null_ptr(),
13900        )
13901    }
13902
13903    #[unsafe(no_mangle)]
13904    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_restore_request(
13905    ) -> *mut wire_cst_restore_request {
13906        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13907            wire_cst_restore_request::new_with_null_ptr(),
13908        )
13909    }
13910
13911    #[unsafe(no_mangle)]
13912    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_sdk_event() -> *mut wire_cst_sdk_event
13913    {
13914        flutter_rust_bridge::for_generated::new_leak_box_ptr(wire_cst_sdk_event::new_with_null_ptr())
13915    }
13916
13917    #[unsafe(no_mangle)]
13918    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_send_payment_request(
13919    ) -> *mut wire_cst_send_payment_request {
13920        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13921            wire_cst_send_payment_request::new_with_null_ptr(),
13922        )
13923    }
13924
13925    #[unsafe(no_mangle)]
13926    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_sign_message_request(
13927    ) -> *mut wire_cst_sign_message_request {
13928        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13929            wire_cst_sign_message_request::new_with_null_ptr(),
13930        )
13931    }
13932
13933    #[unsafe(no_mangle)]
13934    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_success_action(
13935    ) -> *mut wire_cst_success_action {
13936        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13937            wire_cst_success_action::new_with_null_ptr(),
13938        )
13939    }
13940
13941    #[unsafe(no_mangle)]
13942    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_success_action_processed(
13943    ) -> *mut wire_cst_success_action_processed {
13944        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13945            wire_cst_success_action_processed::new_with_null_ptr(),
13946        )
13947    }
13948
13949    #[unsafe(no_mangle)]
13950    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_symbol() -> *mut wire_cst_symbol {
13951        flutter_rust_bridge::for_generated::new_leak_box_ptr(wire_cst_symbol::new_with_null_ptr())
13952    }
13953
13954    #[unsafe(no_mangle)]
13955    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_u_32(value: u32) -> *mut u32 {
13956        flutter_rust_bridge::for_generated::new_leak_box_ptr(value)
13957    }
13958
13959    #[unsafe(no_mangle)]
13960    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_u_64(value: u64) -> *mut u64 {
13961        flutter_rust_bridge::for_generated::new_leak_box_ptr(value)
13962    }
13963
13964    #[unsafe(no_mangle)]
13965    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_url_success_action_data(
13966    ) -> *mut wire_cst_url_success_action_data {
13967        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13968            wire_cst_url_success_action_data::new_with_null_ptr(),
13969        )
13970    }
13971
13972    #[unsafe(no_mangle)]
13973    pub extern "C" fn frbgen_breez_liquid_cst_new_list_String(
13974        len: i32,
13975    ) -> *mut wire_cst_list_String {
13976        let wrap = wire_cst_list_String {
13977            ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
13978                <*mut wire_cst_list_prim_u_8_strict>::new_with_null_ptr(),
13979                len,
13980            ),
13981            len,
13982        };
13983        flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
13984    }
13985
13986    #[unsafe(no_mangle)]
13987    pub extern "C" fn frbgen_breez_liquid_cst_new_list_asset_balance(
13988        len: i32,
13989    ) -> *mut wire_cst_list_asset_balance {
13990        let wrap = wire_cst_list_asset_balance {
13991            ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
13992                <wire_cst_asset_balance>::new_with_null_ptr(),
13993                len,
13994            ),
13995            len,
13996        };
13997        flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
13998    }
13999
14000    #[unsafe(no_mangle)]
14001    pub extern "C" fn frbgen_breez_liquid_cst_new_list_asset_metadata(
14002        len: i32,
14003    ) -> *mut wire_cst_list_asset_metadata {
14004        let wrap = wire_cst_list_asset_metadata {
14005            ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
14006                <wire_cst_asset_metadata>::new_with_null_ptr(),
14007                len,
14008            ),
14009            len,
14010        };
14011        flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14012    }
14013
14014    #[unsafe(no_mangle)]
14015    pub extern "C" fn frbgen_breez_liquid_cst_new_list_external_input_parser(
14016        len: i32,
14017    ) -> *mut wire_cst_list_external_input_parser {
14018        let wrap = wire_cst_list_external_input_parser {
14019            ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
14020                <wire_cst_external_input_parser>::new_with_null_ptr(),
14021                len,
14022            ),
14023            len,
14024        };
14025        flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14026    }
14027
14028    #[unsafe(no_mangle)]
14029    pub extern "C" fn frbgen_breez_liquid_cst_new_list_fiat_currency(
14030        len: i32,
14031    ) -> *mut wire_cst_list_fiat_currency {
14032        let wrap = wire_cst_list_fiat_currency {
14033            ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
14034                <wire_cst_fiat_currency>::new_with_null_ptr(),
14035                len,
14036            ),
14037            len,
14038        };
14039        flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14040    }
14041
14042    #[unsafe(no_mangle)]
14043    pub extern "C" fn frbgen_breez_liquid_cst_new_list_ln_offer_blinded_path(
14044        len: i32,
14045    ) -> *mut wire_cst_list_ln_offer_blinded_path {
14046        let wrap = wire_cst_list_ln_offer_blinded_path {
14047            ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
14048                <wire_cst_ln_offer_blinded_path>::new_with_null_ptr(),
14049                len,
14050            ),
14051            len,
14052        };
14053        flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14054    }
14055
14056    #[unsafe(no_mangle)]
14057    pub extern "C" fn frbgen_breez_liquid_cst_new_list_locale_overrides(
14058        len: i32,
14059    ) -> *mut wire_cst_list_locale_overrides {
14060        let wrap = wire_cst_list_locale_overrides {
14061            ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
14062                <wire_cst_locale_overrides>::new_with_null_ptr(),
14063                len,
14064            ),
14065            len,
14066        };
14067        flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14068    }
14069
14070    #[unsafe(no_mangle)]
14071    pub extern "C" fn frbgen_breez_liquid_cst_new_list_localized_name(
14072        len: i32,
14073    ) -> *mut wire_cst_list_localized_name {
14074        let wrap = wire_cst_list_localized_name {
14075            ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
14076                <wire_cst_localized_name>::new_with_null_ptr(),
14077                len,
14078            ),
14079            len,
14080        };
14081        flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14082    }
14083
14084    #[unsafe(no_mangle)]
14085    pub extern "C" fn frbgen_breez_liquid_cst_new_list_payment(
14086        len: i32,
14087    ) -> *mut wire_cst_list_payment {
14088        let wrap = wire_cst_list_payment {
14089            ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
14090                <wire_cst_payment>::new_with_null_ptr(),
14091                len,
14092            ),
14093            len,
14094        };
14095        flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14096    }
14097
14098    #[unsafe(no_mangle)]
14099    pub extern "C" fn frbgen_breez_liquid_cst_new_list_payment_state(
14100        len: i32,
14101    ) -> *mut wire_cst_list_payment_state {
14102        let wrap = wire_cst_list_payment_state {
14103            ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(Default::default(), len),
14104            len,
14105        };
14106        flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14107    }
14108
14109    #[unsafe(no_mangle)]
14110    pub extern "C" fn frbgen_breez_liquid_cst_new_list_payment_type(
14111        len: i32,
14112    ) -> *mut wire_cst_list_payment_type {
14113        let wrap = wire_cst_list_payment_type {
14114            ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(Default::default(), len),
14115            len,
14116        };
14117        flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14118    }
14119
14120    #[unsafe(no_mangle)]
14121    pub extern "C" fn frbgen_breez_liquid_cst_new_list_prim_u_8_strict(
14122        len: i32,
14123    ) -> *mut wire_cst_list_prim_u_8_strict {
14124        let ans = wire_cst_list_prim_u_8_strict {
14125            ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(Default::default(), len),
14126            len,
14127        };
14128        flutter_rust_bridge::for_generated::new_leak_box_ptr(ans)
14129    }
14130
14131    #[unsafe(no_mangle)]
14132    pub extern "C" fn frbgen_breez_liquid_cst_new_list_rate(len: i32) -> *mut wire_cst_list_rate {
14133        let wrap = wire_cst_list_rate {
14134            ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
14135                <wire_cst_rate>::new_with_null_ptr(),
14136                len,
14137            ),
14138            len,
14139        };
14140        flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14141    }
14142
14143    #[unsafe(no_mangle)]
14144    pub extern "C" fn frbgen_breez_liquid_cst_new_list_refundable_swap(
14145        len: i32,
14146    ) -> *mut wire_cst_list_refundable_swap {
14147        let wrap = wire_cst_list_refundable_swap {
14148            ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
14149                <wire_cst_refundable_swap>::new_with_null_ptr(),
14150                len,
14151            ),
14152            len,
14153        };
14154        flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14155    }
14156
14157    #[unsafe(no_mangle)]
14158    pub extern "C" fn frbgen_breez_liquid_cst_new_list_route_hint(
14159        len: i32,
14160    ) -> *mut wire_cst_list_route_hint {
14161        let wrap = wire_cst_list_route_hint {
14162            ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
14163                <wire_cst_route_hint>::new_with_null_ptr(),
14164                len,
14165            ),
14166            len,
14167        };
14168        flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14169    }
14170
14171    #[unsafe(no_mangle)]
14172    pub extern "C" fn frbgen_breez_liquid_cst_new_list_route_hint_hop(
14173        len: i32,
14174    ) -> *mut wire_cst_list_route_hint_hop {
14175        let wrap = wire_cst_list_route_hint_hop {
14176            ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
14177                <wire_cst_route_hint_hop>::new_with_null_ptr(),
14178                len,
14179            ),
14180            len,
14181        };
14182        flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14183    }
14184
14185    #[repr(C)]
14186    #[derive(Clone, Copy)]
14187    pub struct wire_cst_accept_payment_proposed_fees_request {
14188        response: wire_cst_fetch_payment_proposed_fees_response,
14189    }
14190    #[repr(C)]
14191    #[derive(Clone, Copy)]
14192    pub struct wire_cst_aes_success_action_data {
14193        description: *mut wire_cst_list_prim_u_8_strict,
14194        ciphertext: *mut wire_cst_list_prim_u_8_strict,
14195        iv: *mut wire_cst_list_prim_u_8_strict,
14196    }
14197    #[repr(C)]
14198    #[derive(Clone, Copy)]
14199    pub struct wire_cst_aes_success_action_data_decrypted {
14200        description: *mut wire_cst_list_prim_u_8_strict,
14201        plaintext: *mut wire_cst_list_prim_u_8_strict,
14202    }
14203    #[repr(C)]
14204    #[derive(Clone, Copy)]
14205    pub struct wire_cst_aes_success_action_data_result {
14206        tag: i32,
14207        kind: AesSuccessActionDataResultKind,
14208    }
14209    #[repr(C)]
14210    #[derive(Clone, Copy)]
14211    pub union AesSuccessActionDataResultKind {
14212        Decrypted: wire_cst_AesSuccessActionDataResult_Decrypted,
14213        ErrorStatus: wire_cst_AesSuccessActionDataResult_ErrorStatus,
14214        nil__: (),
14215    }
14216    #[repr(C)]
14217    #[derive(Clone, Copy)]
14218    pub struct wire_cst_AesSuccessActionDataResult_Decrypted {
14219        data: *mut wire_cst_aes_success_action_data_decrypted,
14220    }
14221    #[repr(C)]
14222    #[derive(Clone, Copy)]
14223    pub struct wire_cst_AesSuccessActionDataResult_ErrorStatus {
14224        reason: *mut wire_cst_list_prim_u_8_strict,
14225    }
14226    #[repr(C)]
14227    #[derive(Clone, Copy)]
14228    pub struct wire_cst_amount {
14229        tag: i32,
14230        kind: AmountKind,
14231    }
14232    #[repr(C)]
14233    #[derive(Clone, Copy)]
14234    pub union AmountKind {
14235        Bitcoin: wire_cst_Amount_Bitcoin,
14236        Currency: wire_cst_Amount_Currency,
14237        nil__: (),
14238    }
14239    #[repr(C)]
14240    #[derive(Clone, Copy)]
14241    pub struct wire_cst_Amount_Bitcoin {
14242        amount_msat: u64,
14243    }
14244    #[repr(C)]
14245    #[derive(Clone, Copy)]
14246    pub struct wire_cst_Amount_Currency {
14247        iso4217_code: *mut wire_cst_list_prim_u_8_strict,
14248        fractional_amount: u64,
14249    }
14250    #[repr(C)]
14251    #[derive(Clone, Copy)]
14252    pub struct wire_cst_asset_balance {
14253        asset_id: *mut wire_cst_list_prim_u_8_strict,
14254        balance_sat: u64,
14255        name: *mut wire_cst_list_prim_u_8_strict,
14256        ticker: *mut wire_cst_list_prim_u_8_strict,
14257        balance: *mut f64,
14258    }
14259    #[repr(C)]
14260    #[derive(Clone, Copy)]
14261    pub struct wire_cst_asset_info {
14262        name: *mut wire_cst_list_prim_u_8_strict,
14263        ticker: *mut wire_cst_list_prim_u_8_strict,
14264        amount: f64,
14265        fees: *mut f64,
14266    }
14267    #[repr(C)]
14268    #[derive(Clone, Copy)]
14269    pub struct wire_cst_asset_metadata {
14270        asset_id: *mut wire_cst_list_prim_u_8_strict,
14271        name: *mut wire_cst_list_prim_u_8_strict,
14272        ticker: *mut wire_cst_list_prim_u_8_strict,
14273        precision: u8,
14274        fiat_id: *mut wire_cst_list_prim_u_8_strict,
14275    }
14276    #[repr(C)]
14277    #[derive(Clone, Copy)]
14278    pub struct wire_cst_backup_request {
14279        backup_path: *mut wire_cst_list_prim_u_8_strict,
14280    }
14281    #[repr(C)]
14282    #[derive(Clone, Copy)]
14283    pub struct wire_cst_binding_event_listener {
14284        stream: *mut wire_cst_list_prim_u_8_strict,
14285    }
14286    #[repr(C)]
14287    #[derive(Clone, Copy)]
14288    pub struct wire_cst_bitcoin_address_data {
14289        address: *mut wire_cst_list_prim_u_8_strict,
14290        network: i32,
14291        amount_sat: *mut u64,
14292        label: *mut wire_cst_list_prim_u_8_strict,
14293        message: *mut wire_cst_list_prim_u_8_strict,
14294    }
14295    #[repr(C)]
14296    #[derive(Clone, Copy)]
14297    pub struct wire_cst_blockchain_explorer {
14298        tag: i32,
14299        kind: BlockchainExplorerKind,
14300    }
14301    #[repr(C)]
14302    #[derive(Clone, Copy)]
14303    pub union BlockchainExplorerKind {
14304        Electrum: wire_cst_BlockchainExplorer_Electrum,
14305        Esplora: wire_cst_BlockchainExplorer_Esplora,
14306        nil__: (),
14307    }
14308    #[repr(C)]
14309    #[derive(Clone, Copy)]
14310    pub struct wire_cst_BlockchainExplorer_Electrum {
14311        url: *mut wire_cst_list_prim_u_8_strict,
14312    }
14313    #[repr(C)]
14314    #[derive(Clone, Copy)]
14315    pub struct wire_cst_BlockchainExplorer_Esplora {
14316        url: *mut wire_cst_list_prim_u_8_strict,
14317        use_waterfalls: bool,
14318    }
14319    #[repr(C)]
14320    #[derive(Clone, Copy)]
14321    pub struct wire_cst_blockchain_info {
14322        liquid_tip: u32,
14323        bitcoin_tip: u32,
14324    }
14325    #[repr(C)]
14326    #[derive(Clone, Copy)]
14327    pub struct wire_cst_buy_bitcoin_request {
14328        prepare_response: wire_cst_prepare_buy_bitcoin_response,
14329        redirect_url: *mut wire_cst_list_prim_u_8_strict,
14330    }
14331    #[repr(C)]
14332    #[derive(Clone, Copy)]
14333    pub struct wire_cst_check_message_request {
14334        message: *mut wire_cst_list_prim_u_8_strict,
14335        pubkey: *mut wire_cst_list_prim_u_8_strict,
14336        signature: *mut wire_cst_list_prim_u_8_strict,
14337    }
14338    #[repr(C)]
14339    #[derive(Clone, Copy)]
14340    pub struct wire_cst_check_message_response {
14341        is_valid: bool,
14342    }
14343    #[repr(C)]
14344    #[derive(Clone, Copy)]
14345    pub struct wire_cst_config {
14346        liquid_explorer: wire_cst_blockchain_explorer,
14347        bitcoin_explorer: wire_cst_blockchain_explorer,
14348        working_dir: *mut wire_cst_list_prim_u_8_strict,
14349        network: i32,
14350        payment_timeout_sec: u64,
14351        sync_service_url: *mut wire_cst_list_prim_u_8_strict,
14352        zero_conf_max_amount_sat: *mut u64,
14353        breez_api_key: *mut wire_cst_list_prim_u_8_strict,
14354        external_input_parsers: *mut wire_cst_list_external_input_parser,
14355        use_default_external_input_parsers: bool,
14356        onchain_fee_rate_leeway_sat: *mut u64,
14357        asset_metadata: *mut wire_cst_list_asset_metadata,
14358        sideswap_api_key: *mut wire_cst_list_prim_u_8_strict,
14359    }
14360    #[repr(C)]
14361    #[derive(Clone, Copy)]
14362    pub struct wire_cst_connect_request {
14363        config: wire_cst_config,
14364        mnemonic: *mut wire_cst_list_prim_u_8_strict,
14365        passphrase: *mut wire_cst_list_prim_u_8_strict,
14366        seed: *mut wire_cst_list_prim_u_8_strict,
14367    }
14368    #[repr(C)]
14369    #[derive(Clone, Copy)]
14370    pub struct wire_cst_create_bolt_12_invoice_request {
14371        offer: *mut wire_cst_list_prim_u_8_strict,
14372        invoice_request: *mut wire_cst_list_prim_u_8_strict,
14373    }
14374    #[repr(C)]
14375    #[derive(Clone, Copy)]
14376    pub struct wire_cst_create_bolt_12_invoice_response {
14377        invoice: *mut wire_cst_list_prim_u_8_strict,
14378    }
14379    #[repr(C)]
14380    #[derive(Clone, Copy)]
14381    pub struct wire_cst_currency_info {
14382        name: *mut wire_cst_list_prim_u_8_strict,
14383        fraction_size: u32,
14384        spacing: *mut u32,
14385        symbol: *mut wire_cst_symbol,
14386        uniq_symbol: *mut wire_cst_symbol,
14387        localized_name: *mut wire_cst_list_localized_name,
14388        locale_overrides: *mut wire_cst_list_locale_overrides,
14389    }
14390    #[repr(C)]
14391    #[derive(Clone, Copy)]
14392    pub struct wire_cst_external_input_parser {
14393        provider_id: *mut wire_cst_list_prim_u_8_strict,
14394        input_regex: *mut wire_cst_list_prim_u_8_strict,
14395        parser_url: *mut wire_cst_list_prim_u_8_strict,
14396    }
14397    #[repr(C)]
14398    #[derive(Clone, Copy)]
14399    pub struct wire_cst_fetch_payment_proposed_fees_request {
14400        swap_id: *mut wire_cst_list_prim_u_8_strict,
14401    }
14402    #[repr(C)]
14403    #[derive(Clone, Copy)]
14404    pub struct wire_cst_fetch_payment_proposed_fees_response {
14405        swap_id: *mut wire_cst_list_prim_u_8_strict,
14406        fees_sat: u64,
14407        payer_amount_sat: u64,
14408        receiver_amount_sat: u64,
14409    }
14410    #[repr(C)]
14411    #[derive(Clone, Copy)]
14412    pub struct wire_cst_fiat_currency {
14413        id: *mut wire_cst_list_prim_u_8_strict,
14414        info: wire_cst_currency_info,
14415    }
14416    #[repr(C)]
14417    #[derive(Clone, Copy)]
14418    pub struct wire_cst_get_info_response {
14419        wallet_info: wire_cst_wallet_info,
14420        blockchain_info: wire_cst_blockchain_info,
14421    }
14422    #[repr(C)]
14423    #[derive(Clone, Copy)]
14424    pub struct wire_cst_get_payment_request {
14425        tag: i32,
14426        kind: GetPaymentRequestKind,
14427    }
14428    #[repr(C)]
14429    #[derive(Clone, Copy)]
14430    pub union GetPaymentRequestKind {
14431        PaymentHash: wire_cst_GetPaymentRequest_PaymentHash,
14432        SwapId: wire_cst_GetPaymentRequest_SwapId,
14433        nil__: (),
14434    }
14435    #[repr(C)]
14436    #[derive(Clone, Copy)]
14437    pub struct wire_cst_GetPaymentRequest_PaymentHash {
14438        payment_hash: *mut wire_cst_list_prim_u_8_strict,
14439    }
14440    #[repr(C)]
14441    #[derive(Clone, Copy)]
14442    pub struct wire_cst_GetPaymentRequest_SwapId {
14443        swap_id: *mut wire_cst_list_prim_u_8_strict,
14444    }
14445    #[repr(C)]
14446    #[derive(Clone, Copy)]
14447    pub struct wire_cst_input_type {
14448        tag: i32,
14449        kind: InputTypeKind,
14450    }
14451    #[repr(C)]
14452    #[derive(Clone, Copy)]
14453    pub union InputTypeKind {
14454        BitcoinAddress: wire_cst_InputType_BitcoinAddress,
14455        LiquidAddress: wire_cst_InputType_LiquidAddress,
14456        Bolt11: wire_cst_InputType_Bolt11,
14457        Bolt12Offer: wire_cst_InputType_Bolt12Offer,
14458        NodeId: wire_cst_InputType_NodeId,
14459        Url: wire_cst_InputType_Url,
14460        LnUrlPay: wire_cst_InputType_LnUrlPay,
14461        LnUrlWithdraw: wire_cst_InputType_LnUrlWithdraw,
14462        LnUrlAuth: wire_cst_InputType_LnUrlAuth,
14463        LnUrlError: wire_cst_InputType_LnUrlError,
14464        nil__: (),
14465    }
14466    #[repr(C)]
14467    #[derive(Clone, Copy)]
14468    pub struct wire_cst_InputType_BitcoinAddress {
14469        address: *mut wire_cst_bitcoin_address_data,
14470    }
14471    #[repr(C)]
14472    #[derive(Clone, Copy)]
14473    pub struct wire_cst_InputType_LiquidAddress {
14474        address: *mut wire_cst_liquid_address_data,
14475    }
14476    #[repr(C)]
14477    #[derive(Clone, Copy)]
14478    pub struct wire_cst_InputType_Bolt11 {
14479        invoice: *mut wire_cst_ln_invoice,
14480    }
14481    #[repr(C)]
14482    #[derive(Clone, Copy)]
14483    pub struct wire_cst_InputType_Bolt12Offer {
14484        offer: *mut wire_cst_ln_offer,
14485        bip353_address: *mut wire_cst_list_prim_u_8_strict,
14486    }
14487    #[repr(C)]
14488    #[derive(Clone, Copy)]
14489    pub struct wire_cst_InputType_NodeId {
14490        node_id: *mut wire_cst_list_prim_u_8_strict,
14491    }
14492    #[repr(C)]
14493    #[derive(Clone, Copy)]
14494    pub struct wire_cst_InputType_Url {
14495        url: *mut wire_cst_list_prim_u_8_strict,
14496    }
14497    #[repr(C)]
14498    #[derive(Clone, Copy)]
14499    pub struct wire_cst_InputType_LnUrlPay {
14500        data: *mut wire_cst_ln_url_pay_request_data,
14501        bip353_address: *mut wire_cst_list_prim_u_8_strict,
14502    }
14503    #[repr(C)]
14504    #[derive(Clone, Copy)]
14505    pub struct wire_cst_InputType_LnUrlWithdraw {
14506        data: *mut wire_cst_ln_url_withdraw_request_data,
14507    }
14508    #[repr(C)]
14509    #[derive(Clone, Copy)]
14510    pub struct wire_cst_InputType_LnUrlAuth {
14511        data: *mut wire_cst_ln_url_auth_request_data,
14512    }
14513    #[repr(C)]
14514    #[derive(Clone, Copy)]
14515    pub struct wire_cst_InputType_LnUrlError {
14516        data: *mut wire_cst_ln_url_error_data,
14517    }
14518    #[repr(C)]
14519    #[derive(Clone, Copy)]
14520    pub struct wire_cst_lightning_payment_limits_response {
14521        send: wire_cst_limits,
14522        receive: wire_cst_limits,
14523    }
14524    #[repr(C)]
14525    #[derive(Clone, Copy)]
14526    pub struct wire_cst_limits {
14527        min_sat: u64,
14528        max_sat: u64,
14529        max_zero_conf_sat: u64,
14530    }
14531    #[repr(C)]
14532    #[derive(Clone, Copy)]
14533    pub struct wire_cst_liquid_address_data {
14534        address: *mut wire_cst_list_prim_u_8_strict,
14535        network: i32,
14536        asset_id: *mut wire_cst_list_prim_u_8_strict,
14537        amount: *mut f64,
14538        amount_sat: *mut u64,
14539        label: *mut wire_cst_list_prim_u_8_strict,
14540        message: *mut wire_cst_list_prim_u_8_strict,
14541    }
14542    #[repr(C)]
14543    #[derive(Clone, Copy)]
14544    pub struct wire_cst_list_String {
14545        ptr: *mut *mut wire_cst_list_prim_u_8_strict,
14546        len: i32,
14547    }
14548    #[repr(C)]
14549    #[derive(Clone, Copy)]
14550    pub struct wire_cst_list_asset_balance {
14551        ptr: *mut wire_cst_asset_balance,
14552        len: i32,
14553    }
14554    #[repr(C)]
14555    #[derive(Clone, Copy)]
14556    pub struct wire_cst_list_asset_metadata {
14557        ptr: *mut wire_cst_asset_metadata,
14558        len: i32,
14559    }
14560    #[repr(C)]
14561    #[derive(Clone, Copy)]
14562    pub struct wire_cst_list_external_input_parser {
14563        ptr: *mut wire_cst_external_input_parser,
14564        len: i32,
14565    }
14566    #[repr(C)]
14567    #[derive(Clone, Copy)]
14568    pub struct wire_cst_list_fiat_currency {
14569        ptr: *mut wire_cst_fiat_currency,
14570        len: i32,
14571    }
14572    #[repr(C)]
14573    #[derive(Clone, Copy)]
14574    pub struct wire_cst_list_ln_offer_blinded_path {
14575        ptr: *mut wire_cst_ln_offer_blinded_path,
14576        len: i32,
14577    }
14578    #[repr(C)]
14579    #[derive(Clone, Copy)]
14580    pub struct wire_cst_list_locale_overrides {
14581        ptr: *mut wire_cst_locale_overrides,
14582        len: i32,
14583    }
14584    #[repr(C)]
14585    #[derive(Clone, Copy)]
14586    pub struct wire_cst_list_localized_name {
14587        ptr: *mut wire_cst_localized_name,
14588        len: i32,
14589    }
14590    #[repr(C)]
14591    #[derive(Clone, Copy)]
14592    pub struct wire_cst_list_payment {
14593        ptr: *mut wire_cst_payment,
14594        len: i32,
14595    }
14596    #[repr(C)]
14597    #[derive(Clone, Copy)]
14598    pub struct wire_cst_list_payment_details {
14599        tag: i32,
14600        kind: ListPaymentDetailsKind,
14601    }
14602    #[repr(C)]
14603    #[derive(Clone, Copy)]
14604    pub union ListPaymentDetailsKind {
14605        Liquid: wire_cst_ListPaymentDetails_Liquid,
14606        Bitcoin: wire_cst_ListPaymentDetails_Bitcoin,
14607        nil__: (),
14608    }
14609    #[repr(C)]
14610    #[derive(Clone, Copy)]
14611    pub struct wire_cst_ListPaymentDetails_Liquid {
14612        asset_id: *mut wire_cst_list_prim_u_8_strict,
14613        destination: *mut wire_cst_list_prim_u_8_strict,
14614    }
14615    #[repr(C)]
14616    #[derive(Clone, Copy)]
14617    pub struct wire_cst_ListPaymentDetails_Bitcoin {
14618        address: *mut wire_cst_list_prim_u_8_strict,
14619    }
14620    #[repr(C)]
14621    #[derive(Clone, Copy)]
14622    pub struct wire_cst_list_payment_state {
14623        ptr: *mut i32,
14624        len: i32,
14625    }
14626    #[repr(C)]
14627    #[derive(Clone, Copy)]
14628    pub struct wire_cst_list_payment_type {
14629        ptr: *mut i32,
14630        len: i32,
14631    }
14632    #[repr(C)]
14633    #[derive(Clone, Copy)]
14634    pub struct wire_cst_list_payments_request {
14635        filters: *mut wire_cst_list_payment_type,
14636        states: *mut wire_cst_list_payment_state,
14637        from_timestamp: *mut i64,
14638        to_timestamp: *mut i64,
14639        offset: *mut u32,
14640        limit: *mut u32,
14641        details: *mut wire_cst_list_payment_details,
14642        sort_ascending: *mut bool,
14643    }
14644    #[repr(C)]
14645    #[derive(Clone, Copy)]
14646    pub struct wire_cst_list_prim_u_8_strict {
14647        ptr: *mut u8,
14648        len: i32,
14649    }
14650    #[repr(C)]
14651    #[derive(Clone, Copy)]
14652    pub struct wire_cst_list_rate {
14653        ptr: *mut wire_cst_rate,
14654        len: i32,
14655    }
14656    #[repr(C)]
14657    #[derive(Clone, Copy)]
14658    pub struct wire_cst_list_refundable_swap {
14659        ptr: *mut wire_cst_refundable_swap,
14660        len: i32,
14661    }
14662    #[repr(C)]
14663    #[derive(Clone, Copy)]
14664    pub struct wire_cst_list_route_hint {
14665        ptr: *mut wire_cst_route_hint,
14666        len: i32,
14667    }
14668    #[repr(C)]
14669    #[derive(Clone, Copy)]
14670    pub struct wire_cst_list_route_hint_hop {
14671        ptr: *mut wire_cst_route_hint_hop,
14672        len: i32,
14673    }
14674    #[repr(C)]
14675    #[derive(Clone, Copy)]
14676    pub struct wire_cst_ln_invoice {
14677        bolt11: *mut wire_cst_list_prim_u_8_strict,
14678        network: i32,
14679        payee_pubkey: *mut wire_cst_list_prim_u_8_strict,
14680        payment_hash: *mut wire_cst_list_prim_u_8_strict,
14681        description: *mut wire_cst_list_prim_u_8_strict,
14682        description_hash: *mut wire_cst_list_prim_u_8_strict,
14683        amount_msat: *mut u64,
14684        timestamp: u64,
14685        expiry: u64,
14686        routing_hints: *mut wire_cst_list_route_hint,
14687        payment_secret: *mut wire_cst_list_prim_u_8_strict,
14688        min_final_cltv_expiry_delta: u64,
14689    }
14690    #[repr(C)]
14691    #[derive(Clone, Copy)]
14692    pub struct wire_cst_ln_offer {
14693        offer: *mut wire_cst_list_prim_u_8_strict,
14694        chains: *mut wire_cst_list_String,
14695        min_amount: *mut wire_cst_amount,
14696        description: *mut wire_cst_list_prim_u_8_strict,
14697        absolute_expiry: *mut u64,
14698        issuer: *mut wire_cst_list_prim_u_8_strict,
14699        signing_pubkey: *mut wire_cst_list_prim_u_8_strict,
14700        paths: *mut wire_cst_list_ln_offer_blinded_path,
14701    }
14702    #[repr(C)]
14703    #[derive(Clone, Copy)]
14704    pub struct wire_cst_ln_offer_blinded_path {
14705        blinded_hops: *mut wire_cst_list_String,
14706    }
14707    #[repr(C)]
14708    #[derive(Clone, Copy)]
14709    pub struct wire_cst_ln_url_auth_error {
14710        tag: i32,
14711        kind: LnUrlAuthErrorKind,
14712    }
14713    #[repr(C)]
14714    #[derive(Clone, Copy)]
14715    pub union LnUrlAuthErrorKind {
14716        Generic: wire_cst_LnUrlAuthError_Generic,
14717        InvalidUri: wire_cst_LnUrlAuthError_InvalidUri,
14718        ServiceConnectivity: wire_cst_LnUrlAuthError_ServiceConnectivity,
14719        nil__: (),
14720    }
14721    #[repr(C)]
14722    #[derive(Clone, Copy)]
14723    pub struct wire_cst_LnUrlAuthError_Generic {
14724        err: *mut wire_cst_list_prim_u_8_strict,
14725    }
14726    #[repr(C)]
14727    #[derive(Clone, Copy)]
14728    pub struct wire_cst_LnUrlAuthError_InvalidUri {
14729        err: *mut wire_cst_list_prim_u_8_strict,
14730    }
14731    #[repr(C)]
14732    #[derive(Clone, Copy)]
14733    pub struct wire_cst_LnUrlAuthError_ServiceConnectivity {
14734        err: *mut wire_cst_list_prim_u_8_strict,
14735    }
14736    #[repr(C)]
14737    #[derive(Clone, Copy)]
14738    pub struct wire_cst_ln_url_auth_request_data {
14739        k1: *mut wire_cst_list_prim_u_8_strict,
14740        action: *mut wire_cst_list_prim_u_8_strict,
14741        domain: *mut wire_cst_list_prim_u_8_strict,
14742        url: *mut wire_cst_list_prim_u_8_strict,
14743    }
14744    #[repr(C)]
14745    #[derive(Clone, Copy)]
14746    pub struct wire_cst_ln_url_callback_status {
14747        tag: i32,
14748        kind: LnUrlCallbackStatusKind,
14749    }
14750    #[repr(C)]
14751    #[derive(Clone, Copy)]
14752    pub union LnUrlCallbackStatusKind {
14753        ErrorStatus: wire_cst_LnUrlCallbackStatus_ErrorStatus,
14754        nil__: (),
14755    }
14756    #[repr(C)]
14757    #[derive(Clone, Copy)]
14758    pub struct wire_cst_LnUrlCallbackStatus_ErrorStatus {
14759        data: *mut wire_cst_ln_url_error_data,
14760    }
14761    #[repr(C)]
14762    #[derive(Clone, Copy)]
14763    pub struct wire_cst_ln_url_error_data {
14764        reason: *mut wire_cst_list_prim_u_8_strict,
14765    }
14766    #[repr(C)]
14767    #[derive(Clone, Copy)]
14768    pub struct wire_cst_ln_url_info {
14769        ln_address: *mut wire_cst_list_prim_u_8_strict,
14770        lnurl_pay_comment: *mut wire_cst_list_prim_u_8_strict,
14771        lnurl_pay_domain: *mut wire_cst_list_prim_u_8_strict,
14772        lnurl_pay_metadata: *mut wire_cst_list_prim_u_8_strict,
14773        lnurl_pay_success_action: *mut wire_cst_success_action_processed,
14774        lnurl_pay_unprocessed_success_action: *mut wire_cst_success_action,
14775        lnurl_withdraw_endpoint: *mut wire_cst_list_prim_u_8_strict,
14776    }
14777    #[repr(C)]
14778    #[derive(Clone, Copy)]
14779    pub struct wire_cst_ln_url_pay_error {
14780        tag: i32,
14781        kind: LnUrlPayErrorKind,
14782    }
14783    #[repr(C)]
14784    #[derive(Clone, Copy)]
14785    pub union LnUrlPayErrorKind {
14786        Generic: wire_cst_LnUrlPayError_Generic,
14787        InsufficientBalance: wire_cst_LnUrlPayError_InsufficientBalance,
14788        InvalidAmount: wire_cst_LnUrlPayError_InvalidAmount,
14789        InvalidInvoice: wire_cst_LnUrlPayError_InvalidInvoice,
14790        InvalidNetwork: wire_cst_LnUrlPayError_InvalidNetwork,
14791        InvalidUri: wire_cst_LnUrlPayError_InvalidUri,
14792        InvoiceExpired: wire_cst_LnUrlPayError_InvoiceExpired,
14793        PaymentFailed: wire_cst_LnUrlPayError_PaymentFailed,
14794        PaymentTimeout: wire_cst_LnUrlPayError_PaymentTimeout,
14795        RouteNotFound: wire_cst_LnUrlPayError_RouteNotFound,
14796        RouteTooExpensive: wire_cst_LnUrlPayError_RouteTooExpensive,
14797        ServiceConnectivity: wire_cst_LnUrlPayError_ServiceConnectivity,
14798        nil__: (),
14799    }
14800    #[repr(C)]
14801    #[derive(Clone, Copy)]
14802    pub struct wire_cst_LnUrlPayError_Generic {
14803        err: *mut wire_cst_list_prim_u_8_strict,
14804    }
14805    #[repr(C)]
14806    #[derive(Clone, Copy)]
14807    pub struct wire_cst_LnUrlPayError_InsufficientBalance {
14808        err: *mut wire_cst_list_prim_u_8_strict,
14809    }
14810    #[repr(C)]
14811    #[derive(Clone, Copy)]
14812    pub struct wire_cst_LnUrlPayError_InvalidAmount {
14813        err: *mut wire_cst_list_prim_u_8_strict,
14814    }
14815    #[repr(C)]
14816    #[derive(Clone, Copy)]
14817    pub struct wire_cst_LnUrlPayError_InvalidInvoice {
14818        err: *mut wire_cst_list_prim_u_8_strict,
14819    }
14820    #[repr(C)]
14821    #[derive(Clone, Copy)]
14822    pub struct wire_cst_LnUrlPayError_InvalidNetwork {
14823        err: *mut wire_cst_list_prim_u_8_strict,
14824    }
14825    #[repr(C)]
14826    #[derive(Clone, Copy)]
14827    pub struct wire_cst_LnUrlPayError_InvalidUri {
14828        err: *mut wire_cst_list_prim_u_8_strict,
14829    }
14830    #[repr(C)]
14831    #[derive(Clone, Copy)]
14832    pub struct wire_cst_LnUrlPayError_InvoiceExpired {
14833        err: *mut wire_cst_list_prim_u_8_strict,
14834    }
14835    #[repr(C)]
14836    #[derive(Clone, Copy)]
14837    pub struct wire_cst_LnUrlPayError_PaymentFailed {
14838        err: *mut wire_cst_list_prim_u_8_strict,
14839    }
14840    #[repr(C)]
14841    #[derive(Clone, Copy)]
14842    pub struct wire_cst_LnUrlPayError_PaymentTimeout {
14843        err: *mut wire_cst_list_prim_u_8_strict,
14844    }
14845    #[repr(C)]
14846    #[derive(Clone, Copy)]
14847    pub struct wire_cst_LnUrlPayError_RouteNotFound {
14848        err: *mut wire_cst_list_prim_u_8_strict,
14849    }
14850    #[repr(C)]
14851    #[derive(Clone, Copy)]
14852    pub struct wire_cst_LnUrlPayError_RouteTooExpensive {
14853        err: *mut wire_cst_list_prim_u_8_strict,
14854    }
14855    #[repr(C)]
14856    #[derive(Clone, Copy)]
14857    pub struct wire_cst_LnUrlPayError_ServiceConnectivity {
14858        err: *mut wire_cst_list_prim_u_8_strict,
14859    }
14860    #[repr(C)]
14861    #[derive(Clone, Copy)]
14862    pub struct wire_cst_ln_url_pay_error_data {
14863        payment_hash: *mut wire_cst_list_prim_u_8_strict,
14864        reason: *mut wire_cst_list_prim_u_8_strict,
14865    }
14866    #[repr(C)]
14867    #[derive(Clone, Copy)]
14868    pub struct wire_cst_ln_url_pay_request {
14869        prepare_response: wire_cst_prepare_ln_url_pay_response,
14870    }
14871    #[repr(C)]
14872    #[derive(Clone, Copy)]
14873    pub struct wire_cst_ln_url_pay_request_data {
14874        callback: *mut wire_cst_list_prim_u_8_strict,
14875        min_sendable: u64,
14876        max_sendable: u64,
14877        metadata_str: *mut wire_cst_list_prim_u_8_strict,
14878        comment_allowed: u16,
14879        domain: *mut wire_cst_list_prim_u_8_strict,
14880        allows_nostr: bool,
14881        nostr_pubkey: *mut wire_cst_list_prim_u_8_strict,
14882        ln_address: *mut wire_cst_list_prim_u_8_strict,
14883    }
14884    #[repr(C)]
14885    #[derive(Clone, Copy)]
14886    pub struct wire_cst_ln_url_pay_result {
14887        tag: i32,
14888        kind: LnUrlPayResultKind,
14889    }
14890    #[repr(C)]
14891    #[derive(Clone, Copy)]
14892    pub union LnUrlPayResultKind {
14893        EndpointSuccess: wire_cst_LnUrlPayResult_EndpointSuccess,
14894        EndpointError: wire_cst_LnUrlPayResult_EndpointError,
14895        PayError: wire_cst_LnUrlPayResult_PayError,
14896        nil__: (),
14897    }
14898    #[repr(C)]
14899    #[derive(Clone, Copy)]
14900    pub struct wire_cst_LnUrlPayResult_EndpointSuccess {
14901        data: *mut wire_cst_ln_url_pay_success_data,
14902    }
14903    #[repr(C)]
14904    #[derive(Clone, Copy)]
14905    pub struct wire_cst_LnUrlPayResult_EndpointError {
14906        data: *mut wire_cst_ln_url_error_data,
14907    }
14908    #[repr(C)]
14909    #[derive(Clone, Copy)]
14910    pub struct wire_cst_LnUrlPayResult_PayError {
14911        data: *mut wire_cst_ln_url_pay_error_data,
14912    }
14913    #[repr(C)]
14914    #[derive(Clone, Copy)]
14915    pub struct wire_cst_ln_url_pay_success_data {
14916        payment: wire_cst_payment,
14917        success_action: *mut wire_cst_success_action_processed,
14918    }
14919    #[repr(C)]
14920    #[derive(Clone, Copy)]
14921    pub struct wire_cst_ln_url_withdraw_error {
14922        tag: i32,
14923        kind: LnUrlWithdrawErrorKind,
14924    }
14925    #[repr(C)]
14926    #[derive(Clone, Copy)]
14927    pub union LnUrlWithdrawErrorKind {
14928        Generic: wire_cst_LnUrlWithdrawError_Generic,
14929        InvalidAmount: wire_cst_LnUrlWithdrawError_InvalidAmount,
14930        InvalidInvoice: wire_cst_LnUrlWithdrawError_InvalidInvoice,
14931        InvalidUri: wire_cst_LnUrlWithdrawError_InvalidUri,
14932        InvoiceNoRoutingHints: wire_cst_LnUrlWithdrawError_InvoiceNoRoutingHints,
14933        ServiceConnectivity: wire_cst_LnUrlWithdrawError_ServiceConnectivity,
14934        nil__: (),
14935    }
14936    #[repr(C)]
14937    #[derive(Clone, Copy)]
14938    pub struct wire_cst_LnUrlWithdrawError_Generic {
14939        err: *mut wire_cst_list_prim_u_8_strict,
14940    }
14941    #[repr(C)]
14942    #[derive(Clone, Copy)]
14943    pub struct wire_cst_LnUrlWithdrawError_InvalidAmount {
14944        err: *mut wire_cst_list_prim_u_8_strict,
14945    }
14946    #[repr(C)]
14947    #[derive(Clone, Copy)]
14948    pub struct wire_cst_LnUrlWithdrawError_InvalidInvoice {
14949        err: *mut wire_cst_list_prim_u_8_strict,
14950    }
14951    #[repr(C)]
14952    #[derive(Clone, Copy)]
14953    pub struct wire_cst_LnUrlWithdrawError_InvalidUri {
14954        err: *mut wire_cst_list_prim_u_8_strict,
14955    }
14956    #[repr(C)]
14957    #[derive(Clone, Copy)]
14958    pub struct wire_cst_LnUrlWithdrawError_InvoiceNoRoutingHints {
14959        err: *mut wire_cst_list_prim_u_8_strict,
14960    }
14961    #[repr(C)]
14962    #[derive(Clone, Copy)]
14963    pub struct wire_cst_LnUrlWithdrawError_ServiceConnectivity {
14964        err: *mut wire_cst_list_prim_u_8_strict,
14965    }
14966    #[repr(C)]
14967    #[derive(Clone, Copy)]
14968    pub struct wire_cst_ln_url_withdraw_request {
14969        data: wire_cst_ln_url_withdraw_request_data,
14970        amount_msat: u64,
14971        description: *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_data {
14976        callback: *mut wire_cst_list_prim_u_8_strict,
14977        k1: *mut wire_cst_list_prim_u_8_strict,
14978        default_description: *mut wire_cst_list_prim_u_8_strict,
14979        min_withdrawable: u64,
14980        max_withdrawable: u64,
14981    }
14982    #[repr(C)]
14983    #[derive(Clone, Copy)]
14984    pub struct wire_cst_ln_url_withdraw_result {
14985        tag: i32,
14986        kind: LnUrlWithdrawResultKind,
14987    }
14988    #[repr(C)]
14989    #[derive(Clone, Copy)]
14990    pub union LnUrlWithdrawResultKind {
14991        Ok: wire_cst_LnUrlWithdrawResult_Ok,
14992        Timeout: wire_cst_LnUrlWithdrawResult_Timeout,
14993        ErrorStatus: wire_cst_LnUrlWithdrawResult_ErrorStatus,
14994        nil__: (),
14995    }
14996    #[repr(C)]
14997    #[derive(Clone, Copy)]
14998    pub struct wire_cst_LnUrlWithdrawResult_Ok {
14999        data: *mut wire_cst_ln_url_withdraw_success_data,
15000    }
15001    #[repr(C)]
15002    #[derive(Clone, Copy)]
15003    pub struct wire_cst_LnUrlWithdrawResult_Timeout {
15004        data: *mut wire_cst_ln_url_withdraw_success_data,
15005    }
15006    #[repr(C)]
15007    #[derive(Clone, Copy)]
15008    pub struct wire_cst_LnUrlWithdrawResult_ErrorStatus {
15009        data: *mut wire_cst_ln_url_error_data,
15010    }
15011    #[repr(C)]
15012    #[derive(Clone, Copy)]
15013    pub struct wire_cst_ln_url_withdraw_success_data {
15014        invoice: wire_cst_ln_invoice,
15015    }
15016    #[repr(C)]
15017    #[derive(Clone, Copy)]
15018    pub struct wire_cst_locale_overrides {
15019        locale: *mut wire_cst_list_prim_u_8_strict,
15020        spacing: *mut u32,
15021        symbol: wire_cst_symbol,
15022    }
15023    #[repr(C)]
15024    #[derive(Clone, Copy)]
15025    pub struct wire_cst_localized_name {
15026        locale: *mut wire_cst_list_prim_u_8_strict,
15027        name: *mut wire_cst_list_prim_u_8_strict,
15028    }
15029    #[repr(C)]
15030    #[derive(Clone, Copy)]
15031    pub struct wire_cst_log_entry {
15032        line: *mut wire_cst_list_prim_u_8_strict,
15033        level: *mut wire_cst_list_prim_u_8_strict,
15034    }
15035    #[repr(C)]
15036    #[derive(Clone, Copy)]
15037    pub struct wire_cst_message_success_action_data {
15038        message: *mut wire_cst_list_prim_u_8_strict,
15039    }
15040    #[repr(C)]
15041    #[derive(Clone, Copy)]
15042    pub struct wire_cst_onchain_payment_limits_response {
15043        send: wire_cst_limits,
15044        receive: wire_cst_limits,
15045    }
15046    #[repr(C)]
15047    #[derive(Clone, Copy)]
15048    pub struct wire_cst_pay_amount {
15049        tag: i32,
15050        kind: PayAmountKind,
15051    }
15052    #[repr(C)]
15053    #[derive(Clone, Copy)]
15054    pub union PayAmountKind {
15055        Bitcoin: wire_cst_PayAmount_Bitcoin,
15056        Asset: wire_cst_PayAmount_Asset,
15057        nil__: (),
15058    }
15059    #[repr(C)]
15060    #[derive(Clone, Copy)]
15061    pub struct wire_cst_PayAmount_Bitcoin {
15062        receiver_amount_sat: u64,
15063    }
15064    #[repr(C)]
15065    #[derive(Clone, Copy)]
15066    pub struct wire_cst_PayAmount_Asset {
15067        asset_id: *mut wire_cst_list_prim_u_8_strict,
15068        receiver_amount: f64,
15069        estimate_asset_fees: *mut bool,
15070    }
15071    #[repr(C)]
15072    #[derive(Clone, Copy)]
15073    pub struct wire_cst_pay_onchain_request {
15074        address: *mut wire_cst_list_prim_u_8_strict,
15075        prepare_response: wire_cst_prepare_pay_onchain_response,
15076    }
15077    #[repr(C)]
15078    #[derive(Clone, Copy)]
15079    pub struct wire_cst_payment {
15080        destination: *mut wire_cst_list_prim_u_8_strict,
15081        tx_id: *mut wire_cst_list_prim_u_8_strict,
15082        unblinding_data: *mut wire_cst_list_prim_u_8_strict,
15083        timestamp: u32,
15084        amount_sat: u64,
15085        fees_sat: u64,
15086        swapper_fees_sat: *mut u64,
15087        payment_type: i32,
15088        status: i32,
15089        details: wire_cst_payment_details,
15090    }
15091    #[repr(C)]
15092    #[derive(Clone, Copy)]
15093    pub struct wire_cst_payment_details {
15094        tag: i32,
15095        kind: PaymentDetailsKind,
15096    }
15097    #[repr(C)]
15098    #[derive(Clone, Copy)]
15099    pub union PaymentDetailsKind {
15100        Lightning: wire_cst_PaymentDetails_Lightning,
15101        Liquid: wire_cst_PaymentDetails_Liquid,
15102        Bitcoin: wire_cst_PaymentDetails_Bitcoin,
15103        nil__: (),
15104    }
15105    #[repr(C)]
15106    #[derive(Clone, Copy)]
15107    pub struct wire_cst_PaymentDetails_Lightning {
15108        swap_id: *mut wire_cst_list_prim_u_8_strict,
15109        description: *mut wire_cst_list_prim_u_8_strict,
15110        liquid_expiration_blockheight: u32,
15111        preimage: *mut wire_cst_list_prim_u_8_strict,
15112        invoice: *mut wire_cst_list_prim_u_8_strict,
15113        bolt12_offer: *mut wire_cst_list_prim_u_8_strict,
15114        payment_hash: *mut wire_cst_list_prim_u_8_strict,
15115        destination_pubkey: *mut wire_cst_list_prim_u_8_strict,
15116        lnurl_info: *mut wire_cst_ln_url_info,
15117        bip353_address: *mut wire_cst_list_prim_u_8_strict,
15118        payer_note: *mut wire_cst_list_prim_u_8_strict,
15119        claim_tx_id: *mut wire_cst_list_prim_u_8_strict,
15120        refund_tx_id: *mut wire_cst_list_prim_u_8_strict,
15121        refund_tx_amount_sat: *mut u64,
15122    }
15123    #[repr(C)]
15124    #[derive(Clone, Copy)]
15125    pub struct wire_cst_PaymentDetails_Liquid {
15126        destination: *mut wire_cst_list_prim_u_8_strict,
15127        description: *mut wire_cst_list_prim_u_8_strict,
15128        asset_id: *mut wire_cst_list_prim_u_8_strict,
15129        asset_info: *mut wire_cst_asset_info,
15130        lnurl_info: *mut wire_cst_ln_url_info,
15131        bip353_address: *mut wire_cst_list_prim_u_8_strict,
15132        payer_note: *mut wire_cst_list_prim_u_8_strict,
15133    }
15134    #[repr(C)]
15135    #[derive(Clone, Copy)]
15136    pub struct wire_cst_PaymentDetails_Bitcoin {
15137        swap_id: *mut wire_cst_list_prim_u_8_strict,
15138        bitcoin_address: *mut wire_cst_list_prim_u_8_strict,
15139        description: *mut wire_cst_list_prim_u_8_strict,
15140        auto_accepted_fees: bool,
15141        liquid_expiration_blockheight: *mut u32,
15142        bitcoin_expiration_blockheight: *mut u32,
15143        lockup_tx_id: *mut wire_cst_list_prim_u_8_strict,
15144        claim_tx_id: *mut wire_cst_list_prim_u_8_strict,
15145        refund_tx_id: *mut wire_cst_list_prim_u_8_strict,
15146        refund_tx_amount_sat: *mut u64,
15147    }
15148    #[repr(C)]
15149    #[derive(Clone, Copy)]
15150    pub struct wire_cst_payment_error {
15151        tag: i32,
15152        kind: PaymentErrorKind,
15153    }
15154    #[repr(C)]
15155    #[derive(Clone, Copy)]
15156    pub union PaymentErrorKind {
15157        AmountOutOfRange: wire_cst_PaymentError_AmountOutOfRange,
15158        AmountMissing: wire_cst_PaymentError_AmountMissing,
15159        AssetError: wire_cst_PaymentError_AssetError,
15160        InvalidNetwork: wire_cst_PaymentError_InvalidNetwork,
15161        Generic: wire_cst_PaymentError_Generic,
15162        InvalidDescription: wire_cst_PaymentError_InvalidDescription,
15163        InvalidInvoice: wire_cst_PaymentError_InvalidInvoice,
15164        ReceiveError: wire_cst_PaymentError_ReceiveError,
15165        Refunded: wire_cst_PaymentError_Refunded,
15166        SendError: wire_cst_PaymentError_SendError,
15167        SignerError: wire_cst_PaymentError_SignerError,
15168        nil__: (),
15169    }
15170    #[repr(C)]
15171    #[derive(Clone, Copy)]
15172    pub struct wire_cst_PaymentError_AmountOutOfRange {
15173        min: u64,
15174        max: u64,
15175    }
15176    #[repr(C)]
15177    #[derive(Clone, Copy)]
15178    pub struct wire_cst_PaymentError_AmountMissing {
15179        err: *mut wire_cst_list_prim_u_8_strict,
15180    }
15181    #[repr(C)]
15182    #[derive(Clone, Copy)]
15183    pub struct wire_cst_PaymentError_AssetError {
15184        err: *mut wire_cst_list_prim_u_8_strict,
15185    }
15186    #[repr(C)]
15187    #[derive(Clone, Copy)]
15188    pub struct wire_cst_PaymentError_InvalidNetwork {
15189        err: *mut wire_cst_list_prim_u_8_strict,
15190    }
15191    #[repr(C)]
15192    #[derive(Clone, Copy)]
15193    pub struct wire_cst_PaymentError_Generic {
15194        err: *mut wire_cst_list_prim_u_8_strict,
15195    }
15196    #[repr(C)]
15197    #[derive(Clone, Copy)]
15198    pub struct wire_cst_PaymentError_InvalidDescription {
15199        err: *mut wire_cst_list_prim_u_8_strict,
15200    }
15201    #[repr(C)]
15202    #[derive(Clone, Copy)]
15203    pub struct wire_cst_PaymentError_InvalidInvoice {
15204        err: *mut wire_cst_list_prim_u_8_strict,
15205    }
15206    #[repr(C)]
15207    #[derive(Clone, Copy)]
15208    pub struct wire_cst_PaymentError_ReceiveError {
15209        err: *mut wire_cst_list_prim_u_8_strict,
15210    }
15211    #[repr(C)]
15212    #[derive(Clone, Copy)]
15213    pub struct wire_cst_PaymentError_Refunded {
15214        err: *mut wire_cst_list_prim_u_8_strict,
15215        refund_tx_id: *mut wire_cst_list_prim_u_8_strict,
15216    }
15217    #[repr(C)]
15218    #[derive(Clone, Copy)]
15219    pub struct wire_cst_PaymentError_SendError {
15220        err: *mut wire_cst_list_prim_u_8_strict,
15221    }
15222    #[repr(C)]
15223    #[derive(Clone, Copy)]
15224    pub struct wire_cst_PaymentError_SignerError {
15225        err: *mut wire_cst_list_prim_u_8_strict,
15226    }
15227    #[repr(C)]
15228    #[derive(Clone, Copy)]
15229    pub struct wire_cst_prepare_buy_bitcoin_request {
15230        provider: i32,
15231        amount_sat: u64,
15232    }
15233    #[repr(C)]
15234    #[derive(Clone, Copy)]
15235    pub struct wire_cst_prepare_buy_bitcoin_response {
15236        provider: i32,
15237        amount_sat: u64,
15238        fees_sat: u64,
15239    }
15240    #[repr(C)]
15241    #[derive(Clone, Copy)]
15242    pub struct wire_cst_prepare_ln_url_pay_request {
15243        data: wire_cst_ln_url_pay_request_data,
15244        amount: wire_cst_pay_amount,
15245        bip353_address: *mut wire_cst_list_prim_u_8_strict,
15246        comment: *mut wire_cst_list_prim_u_8_strict,
15247        validate_success_action_url: *mut bool,
15248    }
15249    #[repr(C)]
15250    #[derive(Clone, Copy)]
15251    pub struct wire_cst_prepare_ln_url_pay_response {
15252        destination: wire_cst_send_destination,
15253        fees_sat: u64,
15254        data: wire_cst_ln_url_pay_request_data,
15255        amount: wire_cst_pay_amount,
15256        comment: *mut wire_cst_list_prim_u_8_strict,
15257        success_action: *mut wire_cst_success_action,
15258    }
15259    #[repr(C)]
15260    #[derive(Clone, Copy)]
15261    pub struct wire_cst_prepare_pay_onchain_request {
15262        amount: wire_cst_pay_amount,
15263        fee_rate_sat_per_vbyte: *mut u32,
15264    }
15265    #[repr(C)]
15266    #[derive(Clone, Copy)]
15267    pub struct wire_cst_prepare_pay_onchain_response {
15268        receiver_amount_sat: u64,
15269        claim_fees_sat: u64,
15270        total_fees_sat: u64,
15271    }
15272    #[repr(C)]
15273    #[derive(Clone, Copy)]
15274    pub struct wire_cst_prepare_receive_request {
15275        payment_method: i32,
15276        amount: *mut wire_cst_receive_amount,
15277    }
15278    #[repr(C)]
15279    #[derive(Clone, Copy)]
15280    pub struct wire_cst_prepare_receive_response {
15281        payment_method: i32,
15282        fees_sat: u64,
15283        amount: *mut wire_cst_receive_amount,
15284        min_payer_amount_sat: *mut u64,
15285        max_payer_amount_sat: *mut u64,
15286        swapper_feerate: *mut f64,
15287    }
15288    #[repr(C)]
15289    #[derive(Clone, Copy)]
15290    pub struct wire_cst_prepare_refund_request {
15291        swap_address: *mut wire_cst_list_prim_u_8_strict,
15292        refund_address: *mut wire_cst_list_prim_u_8_strict,
15293        fee_rate_sat_per_vbyte: u32,
15294    }
15295    #[repr(C)]
15296    #[derive(Clone, Copy)]
15297    pub struct wire_cst_prepare_refund_response {
15298        tx_vsize: u32,
15299        tx_fee_sat: u64,
15300        last_refund_tx_id: *mut wire_cst_list_prim_u_8_strict,
15301    }
15302    #[repr(C)]
15303    #[derive(Clone, Copy)]
15304    pub struct wire_cst_prepare_send_request {
15305        destination: *mut wire_cst_list_prim_u_8_strict,
15306        amount: *mut wire_cst_pay_amount,
15307    }
15308    #[repr(C)]
15309    #[derive(Clone, Copy)]
15310    pub struct wire_cst_prepare_send_response {
15311        destination: wire_cst_send_destination,
15312        amount: *mut wire_cst_pay_amount,
15313        fees_sat: *mut u64,
15314        estimated_asset_fees: *mut f64,
15315    }
15316    #[repr(C)]
15317    #[derive(Clone, Copy)]
15318    pub struct wire_cst_rate {
15319        coin: *mut wire_cst_list_prim_u_8_strict,
15320        value: f64,
15321    }
15322    #[repr(C)]
15323    #[derive(Clone, Copy)]
15324    pub struct wire_cst_receive_amount {
15325        tag: i32,
15326        kind: ReceiveAmountKind,
15327    }
15328    #[repr(C)]
15329    #[derive(Clone, Copy)]
15330    pub union ReceiveAmountKind {
15331        Bitcoin: wire_cst_ReceiveAmount_Bitcoin,
15332        Asset: wire_cst_ReceiveAmount_Asset,
15333        nil__: (),
15334    }
15335    #[repr(C)]
15336    #[derive(Clone, Copy)]
15337    pub struct wire_cst_ReceiveAmount_Bitcoin {
15338        payer_amount_sat: u64,
15339    }
15340    #[repr(C)]
15341    #[derive(Clone, Copy)]
15342    pub struct wire_cst_ReceiveAmount_Asset {
15343        asset_id: *mut wire_cst_list_prim_u_8_strict,
15344        payer_amount: *mut f64,
15345    }
15346    #[repr(C)]
15347    #[derive(Clone, Copy)]
15348    pub struct wire_cst_receive_payment_request {
15349        prepare_response: wire_cst_prepare_receive_response,
15350        description: *mut wire_cst_list_prim_u_8_strict,
15351        use_description_hash: *mut bool,
15352        payer_note: *mut wire_cst_list_prim_u_8_strict,
15353    }
15354    #[repr(C)]
15355    #[derive(Clone, Copy)]
15356    pub struct wire_cst_receive_payment_response {
15357        destination: *mut wire_cst_list_prim_u_8_strict,
15358    }
15359    #[repr(C)]
15360    #[derive(Clone, Copy)]
15361    pub struct wire_cst_recommended_fees {
15362        fastest_fee: u64,
15363        half_hour_fee: u64,
15364        hour_fee: u64,
15365        economy_fee: u64,
15366        minimum_fee: u64,
15367    }
15368    #[repr(C)]
15369    #[derive(Clone, Copy)]
15370    pub struct wire_cst_refund_request {
15371        swap_address: *mut wire_cst_list_prim_u_8_strict,
15372        refund_address: *mut wire_cst_list_prim_u_8_strict,
15373        fee_rate_sat_per_vbyte: u32,
15374    }
15375    #[repr(C)]
15376    #[derive(Clone, Copy)]
15377    pub struct wire_cst_refund_response {
15378        refund_tx_id: *mut wire_cst_list_prim_u_8_strict,
15379    }
15380    #[repr(C)]
15381    #[derive(Clone, Copy)]
15382    pub struct wire_cst_refundable_swap {
15383        swap_address: *mut wire_cst_list_prim_u_8_strict,
15384        timestamp: u32,
15385        amount_sat: u64,
15386        last_refund_tx_id: *mut wire_cst_list_prim_u_8_strict,
15387    }
15388    #[repr(C)]
15389    #[derive(Clone, Copy)]
15390    pub struct wire_cst_restore_request {
15391        backup_path: *mut wire_cst_list_prim_u_8_strict,
15392    }
15393    #[repr(C)]
15394    #[derive(Clone, Copy)]
15395    pub struct wire_cst_route_hint {
15396        hops: *mut wire_cst_list_route_hint_hop,
15397    }
15398    #[repr(C)]
15399    #[derive(Clone, Copy)]
15400    pub struct wire_cst_route_hint_hop {
15401        src_node_id: *mut wire_cst_list_prim_u_8_strict,
15402        short_channel_id: *mut wire_cst_list_prim_u_8_strict,
15403        fees_base_msat: u32,
15404        fees_proportional_millionths: u32,
15405        cltv_expiry_delta: u64,
15406        htlc_minimum_msat: *mut u64,
15407        htlc_maximum_msat: *mut u64,
15408    }
15409    #[repr(C)]
15410    #[derive(Clone, Copy)]
15411    pub struct wire_cst_sdk_error {
15412        tag: i32,
15413        kind: SdkErrorKind,
15414    }
15415    #[repr(C)]
15416    #[derive(Clone, Copy)]
15417    pub union SdkErrorKind {
15418        Generic: wire_cst_SdkError_Generic,
15419        ServiceConnectivity: wire_cst_SdkError_ServiceConnectivity,
15420        nil__: (),
15421    }
15422    #[repr(C)]
15423    #[derive(Clone, Copy)]
15424    pub struct wire_cst_SdkError_Generic {
15425        err: *mut wire_cst_list_prim_u_8_strict,
15426    }
15427    #[repr(C)]
15428    #[derive(Clone, Copy)]
15429    pub struct wire_cst_SdkError_ServiceConnectivity {
15430        err: *mut wire_cst_list_prim_u_8_strict,
15431    }
15432    #[repr(C)]
15433    #[derive(Clone, Copy)]
15434    pub struct wire_cst_sdk_event {
15435        tag: i32,
15436        kind: SdkEventKind,
15437    }
15438    #[repr(C)]
15439    #[derive(Clone, Copy)]
15440    pub union SdkEventKind {
15441        PaymentFailed: wire_cst_SdkEvent_PaymentFailed,
15442        PaymentPending: wire_cst_SdkEvent_PaymentPending,
15443        PaymentRefundable: wire_cst_SdkEvent_PaymentRefundable,
15444        PaymentRefunded: wire_cst_SdkEvent_PaymentRefunded,
15445        PaymentRefundPending: wire_cst_SdkEvent_PaymentRefundPending,
15446        PaymentSucceeded: wire_cst_SdkEvent_PaymentSucceeded,
15447        PaymentWaitingConfirmation: wire_cst_SdkEvent_PaymentWaitingConfirmation,
15448        PaymentWaitingFeeAcceptance: wire_cst_SdkEvent_PaymentWaitingFeeAcceptance,
15449        DataSynced: wire_cst_SdkEvent_DataSynced,
15450        nil__: (),
15451    }
15452    #[repr(C)]
15453    #[derive(Clone, Copy)]
15454    pub struct wire_cst_SdkEvent_PaymentFailed {
15455        details: *mut wire_cst_payment,
15456    }
15457    #[repr(C)]
15458    #[derive(Clone, Copy)]
15459    pub struct wire_cst_SdkEvent_PaymentPending {
15460        details: *mut wire_cst_payment,
15461    }
15462    #[repr(C)]
15463    #[derive(Clone, Copy)]
15464    pub struct wire_cst_SdkEvent_PaymentRefundable {
15465        details: *mut wire_cst_payment,
15466    }
15467    #[repr(C)]
15468    #[derive(Clone, Copy)]
15469    pub struct wire_cst_SdkEvent_PaymentRefunded {
15470        details: *mut wire_cst_payment,
15471    }
15472    #[repr(C)]
15473    #[derive(Clone, Copy)]
15474    pub struct wire_cst_SdkEvent_PaymentRefundPending {
15475        details: *mut wire_cst_payment,
15476    }
15477    #[repr(C)]
15478    #[derive(Clone, Copy)]
15479    pub struct wire_cst_SdkEvent_PaymentSucceeded {
15480        details: *mut wire_cst_payment,
15481    }
15482    #[repr(C)]
15483    #[derive(Clone, Copy)]
15484    pub struct wire_cst_SdkEvent_PaymentWaitingConfirmation {
15485        details: *mut wire_cst_payment,
15486    }
15487    #[repr(C)]
15488    #[derive(Clone, Copy)]
15489    pub struct wire_cst_SdkEvent_PaymentWaitingFeeAcceptance {
15490        details: *mut wire_cst_payment,
15491    }
15492    #[repr(C)]
15493    #[derive(Clone, Copy)]
15494    pub struct wire_cst_SdkEvent_DataSynced {
15495        did_pull_new_records: bool,
15496    }
15497    #[repr(C)]
15498    #[derive(Clone, Copy)]
15499    pub struct wire_cst_send_destination {
15500        tag: i32,
15501        kind: SendDestinationKind,
15502    }
15503    #[repr(C)]
15504    #[derive(Clone, Copy)]
15505    pub union SendDestinationKind {
15506        LiquidAddress: wire_cst_SendDestination_LiquidAddress,
15507        Bolt11: wire_cst_SendDestination_Bolt11,
15508        Bolt12: wire_cst_SendDestination_Bolt12,
15509        nil__: (),
15510    }
15511    #[repr(C)]
15512    #[derive(Clone, Copy)]
15513    pub struct wire_cst_SendDestination_LiquidAddress {
15514        address_data: *mut wire_cst_liquid_address_data,
15515        bip353_address: *mut wire_cst_list_prim_u_8_strict,
15516    }
15517    #[repr(C)]
15518    #[derive(Clone, Copy)]
15519    pub struct wire_cst_SendDestination_Bolt11 {
15520        invoice: *mut wire_cst_ln_invoice,
15521        bip353_address: *mut wire_cst_list_prim_u_8_strict,
15522    }
15523    #[repr(C)]
15524    #[derive(Clone, Copy)]
15525    pub struct wire_cst_SendDestination_Bolt12 {
15526        offer: *mut wire_cst_ln_offer,
15527        receiver_amount_sat: u64,
15528        bip353_address: *mut wire_cst_list_prim_u_8_strict,
15529    }
15530    #[repr(C)]
15531    #[derive(Clone, Copy)]
15532    pub struct wire_cst_send_payment_request {
15533        prepare_response: wire_cst_prepare_send_response,
15534        use_asset_fees: *mut bool,
15535        payer_note: *mut wire_cst_list_prim_u_8_strict,
15536    }
15537    #[repr(C)]
15538    #[derive(Clone, Copy)]
15539    pub struct wire_cst_send_payment_response {
15540        payment: wire_cst_payment,
15541    }
15542    #[repr(C)]
15543    #[derive(Clone, Copy)]
15544    pub struct wire_cst_sign_message_request {
15545        message: *mut wire_cst_list_prim_u_8_strict,
15546    }
15547    #[repr(C)]
15548    #[derive(Clone, Copy)]
15549    pub struct wire_cst_sign_message_response {
15550        signature: *mut wire_cst_list_prim_u_8_strict,
15551    }
15552    #[repr(C)]
15553    #[derive(Clone, Copy)]
15554    pub struct wire_cst_success_action {
15555        tag: i32,
15556        kind: SuccessActionKind,
15557    }
15558    #[repr(C)]
15559    #[derive(Clone, Copy)]
15560    pub union SuccessActionKind {
15561        Aes: wire_cst_SuccessAction_Aes,
15562        Message: wire_cst_SuccessAction_Message,
15563        Url: wire_cst_SuccessAction_Url,
15564        nil__: (),
15565    }
15566    #[repr(C)]
15567    #[derive(Clone, Copy)]
15568    pub struct wire_cst_SuccessAction_Aes {
15569        data: *mut wire_cst_aes_success_action_data,
15570    }
15571    #[repr(C)]
15572    #[derive(Clone, Copy)]
15573    pub struct wire_cst_SuccessAction_Message {
15574        data: *mut wire_cst_message_success_action_data,
15575    }
15576    #[repr(C)]
15577    #[derive(Clone, Copy)]
15578    pub struct wire_cst_SuccessAction_Url {
15579        data: *mut wire_cst_url_success_action_data,
15580    }
15581    #[repr(C)]
15582    #[derive(Clone, Copy)]
15583    pub struct wire_cst_success_action_processed {
15584        tag: i32,
15585        kind: SuccessActionProcessedKind,
15586    }
15587    #[repr(C)]
15588    #[derive(Clone, Copy)]
15589    pub union SuccessActionProcessedKind {
15590        Aes: wire_cst_SuccessActionProcessed_Aes,
15591        Message: wire_cst_SuccessActionProcessed_Message,
15592        Url: wire_cst_SuccessActionProcessed_Url,
15593        nil__: (),
15594    }
15595    #[repr(C)]
15596    #[derive(Clone, Copy)]
15597    pub struct wire_cst_SuccessActionProcessed_Aes {
15598        result: *mut wire_cst_aes_success_action_data_result,
15599    }
15600    #[repr(C)]
15601    #[derive(Clone, Copy)]
15602    pub struct wire_cst_SuccessActionProcessed_Message {
15603        data: *mut wire_cst_message_success_action_data,
15604    }
15605    #[repr(C)]
15606    #[derive(Clone, Copy)]
15607    pub struct wire_cst_SuccessActionProcessed_Url {
15608        data: *mut wire_cst_url_success_action_data,
15609    }
15610    #[repr(C)]
15611    #[derive(Clone, Copy)]
15612    pub struct wire_cst_symbol {
15613        grapheme: *mut wire_cst_list_prim_u_8_strict,
15614        template: *mut wire_cst_list_prim_u_8_strict,
15615        rtl: *mut bool,
15616        position: *mut u32,
15617    }
15618    #[repr(C)]
15619    #[derive(Clone, Copy)]
15620    pub struct wire_cst_url_success_action_data {
15621        description: *mut wire_cst_list_prim_u_8_strict,
15622        url: *mut wire_cst_list_prim_u_8_strict,
15623        matches_callback_domain: bool,
15624    }
15625    #[repr(C)]
15626    #[derive(Clone, Copy)]
15627    pub struct wire_cst_wallet_info {
15628        balance_sat: u64,
15629        pending_send_sat: u64,
15630        pending_receive_sat: u64,
15631        fingerprint: *mut wire_cst_list_prim_u_8_strict,
15632        pubkey: *mut wire_cst_list_prim_u_8_strict,
15633        asset_balances: *mut wire_cst_list_asset_balance,
15634    }
15635}
15636#[cfg(not(target_family = "wasm"))]
15637pub use io::*;