breez_sdk_liquid/
frb_generated.rs

1// This file is automatically generated, so please do not edit it.
2// @generated by `flutter_rust_bridge`@ 2.9.0.
3
4#![allow(
5    non_camel_case_types,
6    unused,
7    non_snake_case,
8    clippy::needless_return,
9    clippy::redundant_closure_call,
10    clippy::redundant_closure,
11    clippy::useless_conversion,
12    clippy::unit_arg,
13    clippy::unused_unit,
14    clippy::double_parens,
15    clippy::let_and_return,
16    clippy::too_many_arguments,
17    clippy::match_single_binding,
18    clippy::clone_on_copy,
19    clippy::let_unit_value,
20    clippy::deref_addrof,
21    clippy::explicit_auto_deref,
22    clippy::borrow_deref_ref,
23    clippy::needless_borrow
24)]
25
26// Section: imports
27
28use crate::bindings::*;
29use crate::model::EventListener;
30use flutter_rust_bridge::for_generated::byteorder::{NativeEndian, ReadBytesExt, WriteBytesExt};
31use flutter_rust_bridge::for_generated::{transform_result_dco, Lifetimeable, Lockable};
32use flutter_rust_bridge::{Handler, IntoIntoDart};
33
34// Section: boilerplate
35
36flutter_rust_bridge::frb_generated_boilerplate!(
37    default_stream_sink_codec = DcoCodec,
38    default_rust_opaque = RustOpaqueNom,
39    default_rust_auto_opaque = RustAutoOpaqueNom,
40);
41pub(crate) const FLUTTER_RUST_BRIDGE_CODEGEN_VERSION: &str = "2.9.0";
42pub(crate) const FLUTTER_RUST_BRIDGE_CODEGEN_CONTENT_HASH: i32 = 464449310;
43
44// Section: executor
45
46flutter_rust_bridge::frb_generated_default_handler!();
47
48// Section: wire_funcs
49
50fn wire__crate__bindings__BindingLiquidSdk_accept_payment_proposed_fees_impl(
51    port_: flutter_rust_bridge::for_generated::MessagePort,
52    that: impl CstDecode<
53        RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
54    >,
55    req: impl CstDecode<crate::model::AcceptPaymentProposedFeesRequest>,
56) {
57    FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
58        flutter_rust_bridge::for_generated::TaskInfo {
59            debug_name: "BindingLiquidSdk_accept_payment_proposed_fees",
60            port: Some(port_),
61            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
62        },
63        move || {
64            let api_that = that.cst_decode();
65            let api_req = req.cst_decode();
66            move |context| async move {
67                transform_result_dco::<_, _, crate::error::PaymentError>(
68                    (move || async move {
69                        let mut api_that_guard = None;
70                        let decode_indices_ =
71                            flutter_rust_bridge::for_generated::lockable_compute_decode_order(
72                                vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
73                                    &api_that, 0, false,
74                                )],
75                            );
76                        for i in decode_indices_ {
77                            match i {
78                                0 => {
79                                    api_that_guard =
80                                        Some(api_that.lockable_decode_async_ref().await)
81                                }
82                                _ => unreachable!(),
83                            }
84                        }
85                        let api_that_guard = api_that_guard.unwrap();
86                        let output_ok =
87                            crate::bindings::BindingLiquidSdk::accept_payment_proposed_fees(
88                                &*api_that_guard,
89                                api_req,
90                            )
91                            .await?;
92                        Ok(output_ok)
93                    })()
94                    .await,
95                )
96            }
97        },
98    )
99}
100fn wire__crate__bindings__BindingLiquidSdk_add_event_listener_impl(
101    port_: flutter_rust_bridge::for_generated::MessagePort,
102    that: impl CstDecode<
103        RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
104    >,
105    listener: impl CstDecode<
106        StreamSink<crate::model::SdkEvent, flutter_rust_bridge::for_generated::DcoCodec>,
107    >,
108) {
109    FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
110        flutter_rust_bridge::for_generated::TaskInfo {
111            debug_name: "BindingLiquidSdk_add_event_listener",
112            port: Some(port_),
113            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
114        },
115        move || {
116            let api_that = that.cst_decode();
117            let api_listener = listener.cst_decode();
118            move |context| async move {
119                transform_result_dco::<_, _, crate::error::SdkError>(
120                    (move || async move {
121                        let mut api_that_guard = None;
122                        let decode_indices_ =
123                            flutter_rust_bridge::for_generated::lockable_compute_decode_order(
124                                vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
125                                    &api_that, 0, false,
126                                )],
127                            );
128                        for i in decode_indices_ {
129                            match i {
130                                0 => {
131                                    api_that_guard =
132                                        Some(api_that.lockable_decode_async_ref().await)
133                                }
134                                _ => unreachable!(),
135                            }
136                        }
137                        let api_that_guard = api_that_guard.unwrap();
138                        let output_ok = crate::bindings::BindingLiquidSdk::add_event_listener(
139                            &*api_that_guard,
140                            api_listener,
141                        )
142                        .await?;
143                        Ok(output_ok)
144                    })()
145                    .await,
146                )
147            }
148        },
149    )
150}
151fn wire__crate__bindings__BindingLiquidSdk_backup_impl(
152    that: impl CstDecode<
153        RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
154    >,
155    req: impl CstDecode<crate::model::BackupRequest>,
156) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
157    FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::DcoCodec, _>(
158        flutter_rust_bridge::for_generated::TaskInfo {
159            debug_name: "BindingLiquidSdk_backup",
160            port: None,
161            mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync,
162        },
163        move || {
164            let api_that = that.cst_decode();
165            let api_req = req.cst_decode();
166            transform_result_dco::<_, _, crate::error::SdkError>((move || {
167                let mut api_that_guard = None;
168                let decode_indices_ =
169                    flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![
170                        flutter_rust_bridge::for_generated::LockableOrderInfo::new(
171                            &api_that, 0, false,
172                        ),
173                    ]);
174                for i in decode_indices_ {
175                    match i {
176                        0 => api_that_guard = Some(api_that.lockable_decode_sync_ref()),
177                        _ => unreachable!(),
178                    }
179                }
180                let api_that_guard = api_that_guard.unwrap();
181                let output_ok =
182                    crate::bindings::BindingLiquidSdk::backup(&*api_that_guard, api_req)?;
183                Ok(output_ok)
184            })())
185        },
186    )
187}
188fn wire__crate__bindings__BindingLiquidSdk_buy_bitcoin_impl(
189    port_: flutter_rust_bridge::for_generated::MessagePort,
190    that: impl CstDecode<
191        RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
192    >,
193    req: impl CstDecode<crate::model::BuyBitcoinRequest>,
194) {
195    FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
196        flutter_rust_bridge::for_generated::TaskInfo {
197            debug_name: "BindingLiquidSdk_buy_bitcoin",
198            port: Some(port_),
199            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
200        },
201        move || {
202            let api_that = that.cst_decode();
203            let api_req = req.cst_decode();
204            move |context| async move {
205                transform_result_dco::<_, _, crate::error::PaymentError>(
206                    (move || async move {
207                        let mut api_that_guard = None;
208                        let decode_indices_ =
209                            flutter_rust_bridge::for_generated::lockable_compute_decode_order(
210                                vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
211                                    &api_that, 0, false,
212                                )],
213                            );
214                        for i in decode_indices_ {
215                            match i {
216                                0 => {
217                                    api_that_guard =
218                                        Some(api_that.lockable_decode_async_ref().await)
219                                }
220                                _ => unreachable!(),
221                            }
222                        }
223                        let api_that_guard = api_that_guard.unwrap();
224                        let output_ok = crate::bindings::BindingLiquidSdk::buy_bitcoin(
225                            &*api_that_guard,
226                            api_req,
227                        )
228                        .await?;
229                        Ok(output_ok)
230                    })()
231                    .await,
232                )
233            }
234        },
235    )
236}
237fn wire__crate__bindings__BindingLiquidSdk_check_message_impl(
238    that: impl CstDecode<
239        RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
240    >,
241    req: impl CstDecode<crate::model::CheckMessageRequest>,
242) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
243    FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::DcoCodec, _>(
244        flutter_rust_bridge::for_generated::TaskInfo {
245            debug_name: "BindingLiquidSdk_check_message",
246            port: None,
247            mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync,
248        },
249        move || {
250            let api_that = that.cst_decode();
251            let api_req = req.cst_decode();
252            transform_result_dco::<_, _, crate::error::SdkError>((move || {
253                let mut api_that_guard = None;
254                let decode_indices_ =
255                    flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![
256                        flutter_rust_bridge::for_generated::LockableOrderInfo::new(
257                            &api_that, 0, false,
258                        ),
259                    ]);
260                for i in decode_indices_ {
261                    match i {
262                        0 => api_that_guard = Some(api_that.lockable_decode_sync_ref()),
263                        _ => unreachable!(),
264                    }
265                }
266                let api_that_guard = api_that_guard.unwrap();
267                let output_ok =
268                    crate::bindings::BindingLiquidSdk::check_message(&*api_that_guard, api_req)?;
269                Ok(output_ok)
270            })())
271        },
272    )
273}
274fn wire__crate__bindings__BindingLiquidSdk_create_bolt12_invoice_impl(
275    port_: flutter_rust_bridge::for_generated::MessagePort,
276    that: impl CstDecode<
277        RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
278    >,
279    req: impl CstDecode<crate::model::CreateBolt12InvoiceRequest>,
280) {
281    FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
282        flutter_rust_bridge::for_generated::TaskInfo {
283            debug_name: "BindingLiquidSdk_create_bolt12_invoice",
284            port: Some(port_),
285            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
286        },
287        move || {
288            let api_that = that.cst_decode();
289            let api_req = req.cst_decode();
290            move |context| async move {
291                transform_result_dco::<_, _, crate::error::PaymentError>(
292                    (move || async move {
293                        let mut api_that_guard = None;
294                        let decode_indices_ =
295                            flutter_rust_bridge::for_generated::lockable_compute_decode_order(
296                                vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
297                                    &api_that, 0, false,
298                                )],
299                            );
300                        for i in decode_indices_ {
301                            match i {
302                                0 => {
303                                    api_that_guard =
304                                        Some(api_that.lockable_decode_async_ref().await)
305                                }
306                                _ => unreachable!(),
307                            }
308                        }
309                        let api_that_guard = api_that_guard.unwrap();
310                        let output_ok = crate::bindings::BindingLiquidSdk::create_bolt12_invoice(
311                            &*api_that_guard,
312                            api_req,
313                        )
314                        .await?;
315                        Ok(output_ok)
316                    })()
317                    .await,
318                )
319            }
320        },
321    )
322}
323fn wire__crate__bindings__BindingLiquidSdk_disconnect_impl(
324    port_: flutter_rust_bridge::for_generated::MessagePort,
325    that: impl CstDecode<
326        RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
327    >,
328) {
329    FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
330        flutter_rust_bridge::for_generated::TaskInfo {
331            debug_name: "BindingLiquidSdk_disconnect",
332            port: Some(port_),
333            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
334        },
335        move || {
336            let api_that = that.cst_decode();
337            move |context| async move {
338                transform_result_dco::<_, _, crate::error::SdkError>(
339                    (move || async move {
340                        let mut api_that_guard = None;
341                        let decode_indices_ =
342                            flutter_rust_bridge::for_generated::lockable_compute_decode_order(
343                                vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
344                                    &api_that, 0, false,
345                                )],
346                            );
347                        for i in decode_indices_ {
348                            match i {
349                                0 => {
350                                    api_that_guard =
351                                        Some(api_that.lockable_decode_async_ref().await)
352                                }
353                                _ => unreachable!(),
354                            }
355                        }
356                        let api_that_guard = api_that_guard.unwrap();
357                        let output_ok =
358                            crate::bindings::BindingLiquidSdk::disconnect(&*api_that_guard).await?;
359                        Ok(output_ok)
360                    })()
361                    .await,
362                )
363            }
364        },
365    )
366}
367fn wire__crate__bindings__BindingLiquidSdk_empty_wallet_cache_impl(
368    that: impl CstDecode<
369        RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
370    >,
371) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
372    FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::DcoCodec, _>(
373        flutter_rust_bridge::for_generated::TaskInfo {
374            debug_name: "BindingLiquidSdk_empty_wallet_cache",
375            port: None,
376            mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync,
377        },
378        move || {
379            let api_that = that.cst_decode();
380            transform_result_dco::<_, _, crate::error::SdkError>((move || {
381                let mut api_that_guard = None;
382                let decode_indices_ =
383                    flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![
384                        flutter_rust_bridge::for_generated::LockableOrderInfo::new(
385                            &api_that, 0, false,
386                        ),
387                    ]);
388                for i in decode_indices_ {
389                    match i {
390                        0 => api_that_guard = Some(api_that.lockable_decode_sync_ref()),
391                        _ => unreachable!(),
392                    }
393                }
394                let api_that_guard = api_that_guard.unwrap();
395                let output_ok =
396                    crate::bindings::BindingLiquidSdk::empty_wallet_cache(&*api_that_guard)?;
397                Ok(output_ok)
398            })())
399        },
400    )
401}
402fn wire__crate__bindings__BindingLiquidSdk_fetch_fiat_rates_impl(
403    port_: flutter_rust_bridge::for_generated::MessagePort,
404    that: impl CstDecode<
405        RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
406    >,
407) {
408    FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
409        flutter_rust_bridge::for_generated::TaskInfo {
410            debug_name: "BindingLiquidSdk_fetch_fiat_rates",
411            port: Some(port_),
412            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
413        },
414        move || {
415            let api_that = that.cst_decode();
416            move |context| async move {
417                transform_result_dco::<_, _, crate::error::SdkError>(
418                    (move || async move {
419                        let mut api_that_guard = None;
420                        let decode_indices_ =
421                            flutter_rust_bridge::for_generated::lockable_compute_decode_order(
422                                vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
423                                    &api_that, 0, false,
424                                )],
425                            );
426                        for i in decode_indices_ {
427                            match i {
428                                0 => {
429                                    api_that_guard =
430                                        Some(api_that.lockable_decode_async_ref().await)
431                                }
432                                _ => unreachable!(),
433                            }
434                        }
435                        let api_that_guard = api_that_guard.unwrap();
436                        let output_ok =
437                            crate::bindings::BindingLiquidSdk::fetch_fiat_rates(&*api_that_guard)
438                                .await?;
439                        Ok(output_ok)
440                    })()
441                    .await,
442                )
443            }
444        },
445    )
446}
447fn wire__crate__bindings__BindingLiquidSdk_fetch_lightning_limits_impl(
448    port_: flutter_rust_bridge::for_generated::MessagePort,
449    that: impl CstDecode<
450        RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
451    >,
452) {
453    FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
454        flutter_rust_bridge::for_generated::TaskInfo {
455            debug_name: "BindingLiquidSdk_fetch_lightning_limits",
456            port: Some(port_),
457            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
458        },
459        move || {
460            let api_that = that.cst_decode();
461            move |context| async move {
462                transform_result_dco::<_, _, crate::error::PaymentError>(
463                    (move || async move {
464                        let mut api_that_guard = None;
465                        let decode_indices_ =
466                            flutter_rust_bridge::for_generated::lockable_compute_decode_order(
467                                vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
468                                    &api_that, 0, false,
469                                )],
470                            );
471                        for i in decode_indices_ {
472                            match i {
473                                0 => {
474                                    api_that_guard =
475                                        Some(api_that.lockable_decode_async_ref().await)
476                                }
477                                _ => unreachable!(),
478                            }
479                        }
480                        let api_that_guard = api_that_guard.unwrap();
481                        let output_ok = crate::bindings::BindingLiquidSdk::fetch_lightning_limits(
482                            &*api_that_guard,
483                        )
484                        .await?;
485                        Ok(output_ok)
486                    })()
487                    .await,
488                )
489            }
490        },
491    )
492}
493fn wire__crate__bindings__BindingLiquidSdk_fetch_onchain_limits_impl(
494    port_: flutter_rust_bridge::for_generated::MessagePort,
495    that: impl CstDecode<
496        RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
497    >,
498) {
499    FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
500        flutter_rust_bridge::for_generated::TaskInfo {
501            debug_name: "BindingLiquidSdk_fetch_onchain_limits",
502            port: Some(port_),
503            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
504        },
505        move || {
506            let api_that = that.cst_decode();
507            move |context| async move {
508                transform_result_dco::<_, _, crate::error::PaymentError>(
509                    (move || async move {
510                        let mut api_that_guard = None;
511                        let decode_indices_ =
512                            flutter_rust_bridge::for_generated::lockable_compute_decode_order(
513                                vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
514                                    &api_that, 0, false,
515                                )],
516                            );
517                        for i in decode_indices_ {
518                            match i {
519                                0 => {
520                                    api_that_guard =
521                                        Some(api_that.lockable_decode_async_ref().await)
522                                }
523                                _ => unreachable!(),
524                            }
525                        }
526                        let api_that_guard = api_that_guard.unwrap();
527                        let output_ok = crate::bindings::BindingLiquidSdk::fetch_onchain_limits(
528                            &*api_that_guard,
529                        )
530                        .await?;
531                        Ok(output_ok)
532                    })()
533                    .await,
534                )
535            }
536        },
537    )
538}
539fn wire__crate__bindings__BindingLiquidSdk_fetch_payment_proposed_fees_impl(
540    port_: flutter_rust_bridge::for_generated::MessagePort,
541    that: impl CstDecode<
542        RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
543    >,
544    req: impl CstDecode<crate::model::FetchPaymentProposedFeesRequest>,
545) {
546    FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
547        flutter_rust_bridge::for_generated::TaskInfo {
548            debug_name: "BindingLiquidSdk_fetch_payment_proposed_fees",
549            port: Some(port_),
550            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
551        },
552        move || {
553            let api_that = that.cst_decode();
554            let api_req = req.cst_decode();
555            move |context| async move {
556                transform_result_dco::<_, _, crate::error::SdkError>(
557                    (move || async move {
558                        let mut api_that_guard = None;
559                        let decode_indices_ =
560                            flutter_rust_bridge::for_generated::lockable_compute_decode_order(
561                                vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
562                                    &api_that, 0, false,
563                                )],
564                            );
565                        for i in decode_indices_ {
566                            match i {
567                                0 => {
568                                    api_that_guard =
569                                        Some(api_that.lockable_decode_async_ref().await)
570                                }
571                                _ => unreachable!(),
572                            }
573                        }
574                        let api_that_guard = api_that_guard.unwrap();
575                        let output_ok =
576                            crate::bindings::BindingLiquidSdk::fetch_payment_proposed_fees(
577                                &*api_that_guard,
578                                api_req,
579                            )
580                            .await?;
581                        Ok(output_ok)
582                    })()
583                    .await,
584                )
585            }
586        },
587    )
588}
589fn wire__crate__bindings__BindingLiquidSdk_get_info_impl(
590    port_: flutter_rust_bridge::for_generated::MessagePort,
591    that: impl CstDecode<
592        RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
593    >,
594) {
595    FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
596        flutter_rust_bridge::for_generated::TaskInfo {
597            debug_name: "BindingLiquidSdk_get_info",
598            port: Some(port_),
599            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
600        },
601        move || {
602            let api_that = that.cst_decode();
603            move |context| async move {
604                transform_result_dco::<_, _, crate::error::SdkError>(
605                    (move || async move {
606                        let mut api_that_guard = None;
607                        let decode_indices_ =
608                            flutter_rust_bridge::for_generated::lockable_compute_decode_order(
609                                vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
610                                    &api_that, 0, false,
611                                )],
612                            );
613                        for i in decode_indices_ {
614                            match i {
615                                0 => {
616                                    api_that_guard =
617                                        Some(api_that.lockable_decode_async_ref().await)
618                                }
619                                _ => unreachable!(),
620                            }
621                        }
622                        let api_that_guard = api_that_guard.unwrap();
623                        let output_ok =
624                            crate::bindings::BindingLiquidSdk::get_info(&*api_that_guard).await?;
625                        Ok(output_ok)
626                    })()
627                    .await,
628                )
629            }
630        },
631    )
632}
633fn wire__crate__bindings__BindingLiquidSdk_get_payment_impl(
634    port_: flutter_rust_bridge::for_generated::MessagePort,
635    that: impl CstDecode<
636        RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
637    >,
638    req: impl CstDecode<crate::model::GetPaymentRequest>,
639) {
640    FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
641        flutter_rust_bridge::for_generated::TaskInfo {
642            debug_name: "BindingLiquidSdk_get_payment",
643            port: Some(port_),
644            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
645        },
646        move || {
647            let api_that = that.cst_decode();
648            let api_req = req.cst_decode();
649            move |context| async move {
650                transform_result_dco::<_, _, crate::error::PaymentError>(
651                    (move || async move {
652                        let mut api_that_guard = None;
653                        let decode_indices_ =
654                            flutter_rust_bridge::for_generated::lockable_compute_decode_order(
655                                vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
656                                    &api_that, 0, false,
657                                )],
658                            );
659                        for i in decode_indices_ {
660                            match i {
661                                0 => {
662                                    api_that_guard =
663                                        Some(api_that.lockable_decode_async_ref().await)
664                                }
665                                _ => unreachable!(),
666                            }
667                        }
668                        let api_that_guard = api_that_guard.unwrap();
669                        let output_ok = crate::bindings::BindingLiquidSdk::get_payment(
670                            &*api_that_guard,
671                            api_req,
672                        )
673                        .await?;
674                        Ok(output_ok)
675                    })()
676                    .await,
677                )
678            }
679        },
680    )
681}
682fn wire__crate__bindings__BindingLiquidSdk_list_fiat_currencies_impl(
683    port_: flutter_rust_bridge::for_generated::MessagePort,
684    that: impl CstDecode<
685        RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
686    >,
687) {
688    FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
689        flutter_rust_bridge::for_generated::TaskInfo {
690            debug_name: "BindingLiquidSdk_list_fiat_currencies",
691            port: Some(port_),
692            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
693        },
694        move || {
695            let api_that = that.cst_decode();
696            move |context| async move {
697                transform_result_dco::<_, _, crate::error::SdkError>(
698                    (move || async move {
699                        let mut api_that_guard = None;
700                        let decode_indices_ =
701                            flutter_rust_bridge::for_generated::lockable_compute_decode_order(
702                                vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
703                                    &api_that, 0, false,
704                                )],
705                            );
706                        for i in decode_indices_ {
707                            match i {
708                                0 => {
709                                    api_that_guard =
710                                        Some(api_that.lockable_decode_async_ref().await)
711                                }
712                                _ => unreachable!(),
713                            }
714                        }
715                        let api_that_guard = api_that_guard.unwrap();
716                        let output_ok = crate::bindings::BindingLiquidSdk::list_fiat_currencies(
717                            &*api_that_guard,
718                        )
719                        .await?;
720                        Ok(output_ok)
721                    })()
722                    .await,
723                )
724            }
725        },
726    )
727}
728fn wire__crate__bindings__BindingLiquidSdk_list_payments_impl(
729    port_: flutter_rust_bridge::for_generated::MessagePort,
730    that: impl CstDecode<
731        RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
732    >,
733    req: impl CstDecode<crate::model::ListPaymentsRequest>,
734) {
735    FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
736        flutter_rust_bridge::for_generated::TaskInfo {
737            debug_name: "BindingLiquidSdk_list_payments",
738            port: Some(port_),
739            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
740        },
741        move || {
742            let api_that = that.cst_decode();
743            let api_req = req.cst_decode();
744            move |context| async move {
745                transform_result_dco::<_, _, crate::error::PaymentError>(
746                    (move || async move {
747                        let mut api_that_guard = None;
748                        let decode_indices_ =
749                            flutter_rust_bridge::for_generated::lockable_compute_decode_order(
750                                vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
751                                    &api_that, 0, false,
752                                )],
753                            );
754                        for i in decode_indices_ {
755                            match i {
756                                0 => {
757                                    api_that_guard =
758                                        Some(api_that.lockable_decode_async_ref().await)
759                                }
760                                _ => unreachable!(),
761                            }
762                        }
763                        let api_that_guard = api_that_guard.unwrap();
764                        let output_ok = crate::bindings::BindingLiquidSdk::list_payments(
765                            &*api_that_guard,
766                            api_req,
767                        )
768                        .await?;
769                        Ok(output_ok)
770                    })()
771                    .await,
772                )
773            }
774        },
775    )
776}
777fn wire__crate__bindings__BindingLiquidSdk_list_refundables_impl(
778    port_: flutter_rust_bridge::for_generated::MessagePort,
779    that: impl CstDecode<
780        RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
781    >,
782) {
783    FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
784        flutter_rust_bridge::for_generated::TaskInfo {
785            debug_name: "BindingLiquidSdk_list_refundables",
786            port: Some(port_),
787            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
788        },
789        move || {
790            let api_that = that.cst_decode();
791            move |context| async move {
792                transform_result_dco::<_, _, crate::error::SdkError>(
793                    (move || async move {
794                        let mut api_that_guard = None;
795                        let decode_indices_ =
796                            flutter_rust_bridge::for_generated::lockable_compute_decode_order(
797                                vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
798                                    &api_that, 0, false,
799                                )],
800                            );
801                        for i in decode_indices_ {
802                            match i {
803                                0 => {
804                                    api_that_guard =
805                                        Some(api_that.lockable_decode_async_ref().await)
806                                }
807                                _ => unreachable!(),
808                            }
809                        }
810                        let api_that_guard = api_that_guard.unwrap();
811                        let output_ok =
812                            crate::bindings::BindingLiquidSdk::list_refundables(&*api_that_guard)
813                                .await?;
814                        Ok(output_ok)
815                    })()
816                    .await,
817                )
818            }
819        },
820    )
821}
822fn wire__crate__bindings__BindingLiquidSdk_lnurl_auth_impl(
823    port_: flutter_rust_bridge::for_generated::MessagePort,
824    that: impl CstDecode<
825        RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
826    >,
827    req_data: impl CstDecode<crate::bindings::LnUrlAuthRequestData>,
828) {
829    FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
830        flutter_rust_bridge::for_generated::TaskInfo {
831            debug_name: "BindingLiquidSdk_lnurl_auth",
832            port: Some(port_),
833            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
834        },
835        move || {
836            let api_that = that.cst_decode();
837            let api_req_data = req_data.cst_decode();
838            move |context| async move {
839                transform_result_dco::<_, _, crate::bindings::duplicates::LnUrlAuthError>(
840                    (move || async move {
841                        let mut api_that_guard = None;
842                        let decode_indices_ =
843                            flutter_rust_bridge::for_generated::lockable_compute_decode_order(
844                                vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
845                                    &api_that, 0, false,
846                                )],
847                            );
848                        for i in decode_indices_ {
849                            match i {
850                                0 => {
851                                    api_that_guard =
852                                        Some(api_that.lockable_decode_async_ref().await)
853                                }
854                                _ => unreachable!(),
855                            }
856                        }
857                        let api_that_guard = api_that_guard.unwrap();
858                        let output_ok = crate::bindings::BindingLiquidSdk::lnurl_auth(
859                            &*api_that_guard,
860                            api_req_data,
861                        )
862                        .await?;
863                        Ok(output_ok)
864                    })()
865                    .await,
866                )
867            }
868        },
869    )
870}
871fn wire__crate__bindings__BindingLiquidSdk_lnurl_pay_impl(
872    port_: flutter_rust_bridge::for_generated::MessagePort,
873    that: impl CstDecode<
874        RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
875    >,
876    req: impl CstDecode<crate::model::LnUrlPayRequest>,
877) {
878    FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
879        flutter_rust_bridge::for_generated::TaskInfo {
880            debug_name: "BindingLiquidSdk_lnurl_pay",
881            port: Some(port_),
882            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
883        },
884        move || {
885            let api_that = that.cst_decode();
886            let api_req = req.cst_decode();
887            move |context| async move {
888                transform_result_dco::<_, _, crate::bindings::duplicates::LnUrlPayError>(
889                    (move || async move {
890                        let mut api_that_guard = None;
891                        let decode_indices_ =
892                            flutter_rust_bridge::for_generated::lockable_compute_decode_order(
893                                vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
894                                    &api_that, 0, false,
895                                )],
896                            );
897                        for i in decode_indices_ {
898                            match i {
899                                0 => {
900                                    api_that_guard =
901                                        Some(api_that.lockable_decode_async_ref().await)
902                                }
903                                _ => unreachable!(),
904                            }
905                        }
906                        let api_that_guard = api_that_guard.unwrap();
907                        let output_ok =
908                            crate::bindings::BindingLiquidSdk::lnurl_pay(&*api_that_guard, api_req)
909                                .await?;
910                        Ok(output_ok)
911                    })()
912                    .await,
913                )
914            }
915        },
916    )
917}
918fn wire__crate__bindings__BindingLiquidSdk_lnurl_withdraw_impl(
919    port_: flutter_rust_bridge::for_generated::MessagePort,
920    that: impl CstDecode<
921        RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
922    >,
923    req: impl CstDecode<crate::bindings::LnUrlWithdrawRequest>,
924) {
925    FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
926        flutter_rust_bridge::for_generated::TaskInfo {
927            debug_name: "BindingLiquidSdk_lnurl_withdraw",
928            port: Some(port_),
929            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
930        },
931        move || {
932            let api_that = that.cst_decode();
933            let api_req = req.cst_decode();
934            move |context| async move {
935                transform_result_dco::<_, _, crate::bindings::duplicates::LnUrlWithdrawError>(
936                    (move || async move {
937                        let mut api_that_guard = None;
938                        let decode_indices_ =
939                            flutter_rust_bridge::for_generated::lockable_compute_decode_order(
940                                vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
941                                    &api_that, 0, false,
942                                )],
943                            );
944                        for i in decode_indices_ {
945                            match i {
946                                0 => {
947                                    api_that_guard =
948                                        Some(api_that.lockable_decode_async_ref().await)
949                                }
950                                _ => unreachable!(),
951                            }
952                        }
953                        let api_that_guard = api_that_guard.unwrap();
954                        let output_ok = crate::bindings::BindingLiquidSdk::lnurl_withdraw(
955                            &*api_that_guard,
956                            api_req,
957                        )
958                        .await?;
959                        Ok(output_ok)
960                    })()
961                    .await,
962                )
963            }
964        },
965    )
966}
967fn wire__crate__bindings__BindingLiquidSdk_parse_impl(
968    port_: flutter_rust_bridge::for_generated::MessagePort,
969    that: impl CstDecode<
970        RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
971    >,
972    input: impl CstDecode<String>,
973) {
974    FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
975        flutter_rust_bridge::for_generated::TaskInfo {
976            debug_name: "BindingLiquidSdk_parse",
977            port: Some(port_),
978            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
979        },
980        move || {
981            let api_that = that.cst_decode();
982            let api_input = input.cst_decode();
983            move |context| async move {
984                transform_result_dco::<_, _, crate::error::PaymentError>(
985                    (move || async move {
986                        let mut api_that_guard = None;
987                        let decode_indices_ =
988                            flutter_rust_bridge::for_generated::lockable_compute_decode_order(
989                                vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
990                                    &api_that, 0, false,
991                                )],
992                            );
993                        for i in decode_indices_ {
994                            match i {
995                                0 => {
996                                    api_that_guard =
997                                        Some(api_that.lockable_decode_async_ref().await)
998                                }
999                                _ => unreachable!(),
1000                            }
1001                        }
1002                        let api_that_guard = api_that_guard.unwrap();
1003                        let output_ok =
1004                            crate::bindings::BindingLiquidSdk::parse(&*api_that_guard, api_input)
1005                                .await?;
1006                        Ok(output_ok)
1007                    })()
1008                    .await,
1009                )
1010            }
1011        },
1012    )
1013}
1014fn wire__crate__bindings__BindingLiquidSdk_pay_onchain_impl(
1015    port_: flutter_rust_bridge::for_generated::MessagePort,
1016    that: impl CstDecode<
1017        RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
1018    >,
1019    req: impl CstDecode<crate::model::PayOnchainRequest>,
1020) {
1021    FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
1022        flutter_rust_bridge::for_generated::TaskInfo {
1023            debug_name: "BindingLiquidSdk_pay_onchain",
1024            port: Some(port_),
1025            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
1026        },
1027        move || {
1028            let api_that = that.cst_decode();
1029            let api_req = req.cst_decode();
1030            move |context| async move {
1031                transform_result_dco::<_, _, crate::error::PaymentError>(
1032                    (move || async move {
1033                        let mut api_that_guard = None;
1034                        let decode_indices_ =
1035                            flutter_rust_bridge::for_generated::lockable_compute_decode_order(
1036                                vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
1037                                    &api_that, 0, false,
1038                                )],
1039                            );
1040                        for i in decode_indices_ {
1041                            match i {
1042                                0 => {
1043                                    api_that_guard =
1044                                        Some(api_that.lockable_decode_async_ref().await)
1045                                }
1046                                _ => unreachable!(),
1047                            }
1048                        }
1049                        let api_that_guard = api_that_guard.unwrap();
1050                        let output_ok = crate::bindings::BindingLiquidSdk::pay_onchain(
1051                            &*api_that_guard,
1052                            api_req,
1053                        )
1054                        .await?;
1055                        Ok(output_ok)
1056                    })()
1057                    .await,
1058                )
1059            }
1060        },
1061    )
1062}
1063fn wire__crate__bindings__BindingLiquidSdk_prepare_buy_bitcoin_impl(
1064    port_: flutter_rust_bridge::for_generated::MessagePort,
1065    that: impl CstDecode<
1066        RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
1067    >,
1068    req: impl CstDecode<crate::model::PrepareBuyBitcoinRequest>,
1069) {
1070    FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
1071        flutter_rust_bridge::for_generated::TaskInfo {
1072            debug_name: "BindingLiquidSdk_prepare_buy_bitcoin",
1073            port: Some(port_),
1074            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
1075        },
1076        move || {
1077            let api_that = that.cst_decode();
1078            let api_req = req.cst_decode();
1079            move |context| async move {
1080                transform_result_dco::<_, _, crate::error::PaymentError>(
1081                    (move || async move {
1082                        let mut api_that_guard = None;
1083                        let decode_indices_ =
1084                            flutter_rust_bridge::for_generated::lockable_compute_decode_order(
1085                                vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
1086                                    &api_that, 0, false,
1087                                )],
1088                            );
1089                        for i in decode_indices_ {
1090                            match i {
1091                                0 => {
1092                                    api_that_guard =
1093                                        Some(api_that.lockable_decode_async_ref().await)
1094                                }
1095                                _ => unreachable!(),
1096                            }
1097                        }
1098                        let api_that_guard = api_that_guard.unwrap();
1099                        let output_ok = crate::bindings::BindingLiquidSdk::prepare_buy_bitcoin(
1100                            &*api_that_guard,
1101                            api_req,
1102                        )
1103                        .await?;
1104                        Ok(output_ok)
1105                    })()
1106                    .await,
1107                )
1108            }
1109        },
1110    )
1111}
1112fn wire__crate__bindings__BindingLiquidSdk_prepare_lnurl_pay_impl(
1113    port_: flutter_rust_bridge::for_generated::MessagePort,
1114    that: impl CstDecode<
1115        RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
1116    >,
1117    req: impl CstDecode<crate::model::PrepareLnUrlPayRequest>,
1118) {
1119    FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
1120        flutter_rust_bridge::for_generated::TaskInfo {
1121            debug_name: "BindingLiquidSdk_prepare_lnurl_pay",
1122            port: Some(port_),
1123            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
1124        },
1125        move || {
1126            let api_that = that.cst_decode();
1127            let api_req = req.cst_decode();
1128            move |context| async move {
1129                transform_result_dco::<_, _, crate::bindings::duplicates::LnUrlPayError>(
1130                    (move || async move {
1131                        let mut api_that_guard = None;
1132                        let decode_indices_ =
1133                            flutter_rust_bridge::for_generated::lockable_compute_decode_order(
1134                                vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
1135                                    &api_that, 0, false,
1136                                )],
1137                            );
1138                        for i in decode_indices_ {
1139                            match i {
1140                                0 => {
1141                                    api_that_guard =
1142                                        Some(api_that.lockable_decode_async_ref().await)
1143                                }
1144                                _ => unreachable!(),
1145                            }
1146                        }
1147                        let api_that_guard = api_that_guard.unwrap();
1148                        let output_ok = crate::bindings::BindingLiquidSdk::prepare_lnurl_pay(
1149                            &*api_that_guard,
1150                            api_req,
1151                        )
1152                        .await?;
1153                        Ok(output_ok)
1154                    })()
1155                    .await,
1156                )
1157            }
1158        },
1159    )
1160}
1161fn wire__crate__bindings__BindingLiquidSdk_prepare_pay_onchain_impl(
1162    port_: flutter_rust_bridge::for_generated::MessagePort,
1163    that: impl CstDecode<
1164        RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
1165    >,
1166    req: impl CstDecode<crate::model::PreparePayOnchainRequest>,
1167) {
1168    FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
1169        flutter_rust_bridge::for_generated::TaskInfo {
1170            debug_name: "BindingLiquidSdk_prepare_pay_onchain",
1171            port: Some(port_),
1172            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
1173        },
1174        move || {
1175            let api_that = that.cst_decode();
1176            let api_req = req.cst_decode();
1177            move |context| async move {
1178                transform_result_dco::<_, _, crate::error::PaymentError>(
1179                    (move || async move {
1180                        let mut api_that_guard = None;
1181                        let decode_indices_ =
1182                            flutter_rust_bridge::for_generated::lockable_compute_decode_order(
1183                                vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
1184                                    &api_that, 0, false,
1185                                )],
1186                            );
1187                        for i in decode_indices_ {
1188                            match i {
1189                                0 => {
1190                                    api_that_guard =
1191                                        Some(api_that.lockable_decode_async_ref().await)
1192                                }
1193                                _ => unreachable!(),
1194                            }
1195                        }
1196                        let api_that_guard = api_that_guard.unwrap();
1197                        let output_ok = crate::bindings::BindingLiquidSdk::prepare_pay_onchain(
1198                            &*api_that_guard,
1199                            api_req,
1200                        )
1201                        .await?;
1202                        Ok(output_ok)
1203                    })()
1204                    .await,
1205                )
1206            }
1207        },
1208    )
1209}
1210fn wire__crate__bindings__BindingLiquidSdk_prepare_receive_payment_impl(
1211    port_: flutter_rust_bridge::for_generated::MessagePort,
1212    that: impl CstDecode<
1213        RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
1214    >,
1215    req: impl CstDecode<crate::model::PrepareReceiveRequest>,
1216) {
1217    FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
1218        flutter_rust_bridge::for_generated::TaskInfo {
1219            debug_name: "BindingLiquidSdk_prepare_receive_payment",
1220            port: Some(port_),
1221            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
1222        },
1223        move || {
1224            let api_that = that.cst_decode();
1225            let api_req = req.cst_decode();
1226            move |context| async move {
1227                transform_result_dco::<_, _, crate::error::PaymentError>(
1228                    (move || async move {
1229                        let mut api_that_guard = None;
1230                        let decode_indices_ =
1231                            flutter_rust_bridge::for_generated::lockable_compute_decode_order(
1232                                vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
1233                                    &api_that, 0, false,
1234                                )],
1235                            );
1236                        for i in decode_indices_ {
1237                            match i {
1238                                0 => {
1239                                    api_that_guard =
1240                                        Some(api_that.lockable_decode_async_ref().await)
1241                                }
1242                                _ => unreachable!(),
1243                            }
1244                        }
1245                        let api_that_guard = api_that_guard.unwrap();
1246                        let output_ok = crate::bindings::BindingLiquidSdk::prepare_receive_payment(
1247                            &*api_that_guard,
1248                            api_req,
1249                        )
1250                        .await?;
1251                        Ok(output_ok)
1252                    })()
1253                    .await,
1254                )
1255            }
1256        },
1257    )
1258}
1259fn wire__crate__bindings__BindingLiquidSdk_prepare_refund_impl(
1260    port_: flutter_rust_bridge::for_generated::MessagePort,
1261    that: impl CstDecode<
1262        RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
1263    >,
1264    req: impl CstDecode<crate::model::PrepareRefundRequest>,
1265) {
1266    FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
1267        flutter_rust_bridge::for_generated::TaskInfo {
1268            debug_name: "BindingLiquidSdk_prepare_refund",
1269            port: Some(port_),
1270            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
1271        },
1272        move || {
1273            let api_that = that.cst_decode();
1274            let api_req = req.cst_decode();
1275            move |context| async move {
1276                transform_result_dco::<_, _, crate::error::SdkError>(
1277                    (move || async move {
1278                        let mut api_that_guard = None;
1279                        let decode_indices_ =
1280                            flutter_rust_bridge::for_generated::lockable_compute_decode_order(
1281                                vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
1282                                    &api_that, 0, false,
1283                                )],
1284                            );
1285                        for i in decode_indices_ {
1286                            match i {
1287                                0 => {
1288                                    api_that_guard =
1289                                        Some(api_that.lockable_decode_async_ref().await)
1290                                }
1291                                _ => unreachable!(),
1292                            }
1293                        }
1294                        let api_that_guard = api_that_guard.unwrap();
1295                        let output_ok = crate::bindings::BindingLiquidSdk::prepare_refund(
1296                            &*api_that_guard,
1297                            api_req,
1298                        )
1299                        .await?;
1300                        Ok(output_ok)
1301                    })()
1302                    .await,
1303                )
1304            }
1305        },
1306    )
1307}
1308fn wire__crate__bindings__BindingLiquidSdk_prepare_send_payment_impl(
1309    port_: flutter_rust_bridge::for_generated::MessagePort,
1310    that: impl CstDecode<
1311        RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
1312    >,
1313    req: impl CstDecode<crate::model::PrepareSendRequest>,
1314) {
1315    FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
1316        flutter_rust_bridge::for_generated::TaskInfo {
1317            debug_name: "BindingLiquidSdk_prepare_send_payment",
1318            port: Some(port_),
1319            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
1320        },
1321        move || {
1322            let api_that = that.cst_decode();
1323            let api_req = req.cst_decode();
1324            move |context| async move {
1325                transform_result_dco::<_, _, crate::error::PaymentError>(
1326                    (move || async move {
1327                        let mut api_that_guard = None;
1328                        let decode_indices_ =
1329                            flutter_rust_bridge::for_generated::lockable_compute_decode_order(
1330                                vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
1331                                    &api_that, 0, false,
1332                                )],
1333                            );
1334                        for i in decode_indices_ {
1335                            match i {
1336                                0 => {
1337                                    api_that_guard =
1338                                        Some(api_that.lockable_decode_async_ref().await)
1339                                }
1340                                _ => unreachable!(),
1341                            }
1342                        }
1343                        let api_that_guard = api_that_guard.unwrap();
1344                        let output_ok = crate::bindings::BindingLiquidSdk::prepare_send_payment(
1345                            &*api_that_guard,
1346                            api_req,
1347                        )
1348                        .await?;
1349                        Ok(output_ok)
1350                    })()
1351                    .await,
1352                )
1353            }
1354        },
1355    )
1356}
1357fn wire__crate__bindings__BindingLiquidSdk_receive_payment_impl(
1358    port_: flutter_rust_bridge::for_generated::MessagePort,
1359    that: impl CstDecode<
1360        RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
1361    >,
1362    req: impl CstDecode<crate::model::ReceivePaymentRequest>,
1363) {
1364    FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
1365        flutter_rust_bridge::for_generated::TaskInfo {
1366            debug_name: "BindingLiquidSdk_receive_payment",
1367            port: Some(port_),
1368            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
1369        },
1370        move || {
1371            let api_that = that.cst_decode();
1372            let api_req = req.cst_decode();
1373            move |context| async move {
1374                transform_result_dco::<_, _, crate::error::PaymentError>(
1375                    (move || async move {
1376                        let mut api_that_guard = None;
1377                        let decode_indices_ =
1378                            flutter_rust_bridge::for_generated::lockable_compute_decode_order(
1379                                vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
1380                                    &api_that, 0, false,
1381                                )],
1382                            );
1383                        for i in decode_indices_ {
1384                            match i {
1385                                0 => {
1386                                    api_that_guard =
1387                                        Some(api_that.lockable_decode_async_ref().await)
1388                                }
1389                                _ => unreachable!(),
1390                            }
1391                        }
1392                        let api_that_guard = api_that_guard.unwrap();
1393                        let output_ok = crate::bindings::BindingLiquidSdk::receive_payment(
1394                            &*api_that_guard,
1395                            api_req,
1396                        )
1397                        .await?;
1398                        Ok(output_ok)
1399                    })()
1400                    .await,
1401                )
1402            }
1403        },
1404    )
1405}
1406fn wire__crate__bindings__BindingLiquidSdk_recommended_fees_impl(
1407    port_: flutter_rust_bridge::for_generated::MessagePort,
1408    that: impl CstDecode<
1409        RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
1410    >,
1411) {
1412    FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
1413        flutter_rust_bridge::for_generated::TaskInfo {
1414            debug_name: "BindingLiquidSdk_recommended_fees",
1415            port: Some(port_),
1416            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
1417        },
1418        move || {
1419            let api_that = that.cst_decode();
1420            move |context| async move {
1421                transform_result_dco::<_, _, crate::error::SdkError>(
1422                    (move || async move {
1423                        let mut api_that_guard = None;
1424                        let decode_indices_ =
1425                            flutter_rust_bridge::for_generated::lockable_compute_decode_order(
1426                                vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
1427                                    &api_that, 0, false,
1428                                )],
1429                            );
1430                        for i in decode_indices_ {
1431                            match i {
1432                                0 => {
1433                                    api_that_guard =
1434                                        Some(api_that.lockable_decode_async_ref().await)
1435                                }
1436                                _ => unreachable!(),
1437                            }
1438                        }
1439                        let api_that_guard = api_that_guard.unwrap();
1440                        let output_ok =
1441                            crate::bindings::BindingLiquidSdk::recommended_fees(&*api_that_guard)
1442                                .await?;
1443                        Ok(output_ok)
1444                    })()
1445                    .await,
1446                )
1447            }
1448        },
1449    )
1450}
1451fn wire__crate__bindings__BindingLiquidSdk_refund_impl(
1452    port_: flutter_rust_bridge::for_generated::MessagePort,
1453    that: impl CstDecode<
1454        RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
1455    >,
1456    req: impl CstDecode<crate::model::RefundRequest>,
1457) {
1458    FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
1459        flutter_rust_bridge::for_generated::TaskInfo {
1460            debug_name: "BindingLiquidSdk_refund",
1461            port: Some(port_),
1462            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
1463        },
1464        move || {
1465            let api_that = that.cst_decode();
1466            let api_req = req.cst_decode();
1467            move |context| async move {
1468                transform_result_dco::<_, _, crate::error::PaymentError>(
1469                    (move || async move {
1470                        let mut api_that_guard = None;
1471                        let decode_indices_ =
1472                            flutter_rust_bridge::for_generated::lockable_compute_decode_order(
1473                                vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
1474                                    &api_that, 0, false,
1475                                )],
1476                            );
1477                        for i in decode_indices_ {
1478                            match i {
1479                                0 => {
1480                                    api_that_guard =
1481                                        Some(api_that.lockable_decode_async_ref().await)
1482                                }
1483                                _ => unreachable!(),
1484                            }
1485                        }
1486                        let api_that_guard = api_that_guard.unwrap();
1487                        let output_ok =
1488                            crate::bindings::BindingLiquidSdk::refund(&*api_that_guard, api_req)
1489                                .await?;
1490                        Ok(output_ok)
1491                    })()
1492                    .await,
1493                )
1494            }
1495        },
1496    )
1497}
1498fn wire__crate__bindings__BindingLiquidSdk_register_webhook_impl(
1499    port_: flutter_rust_bridge::for_generated::MessagePort,
1500    that: impl CstDecode<
1501        RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
1502    >,
1503    webhook_url: impl CstDecode<String>,
1504) {
1505    FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
1506        flutter_rust_bridge::for_generated::TaskInfo {
1507            debug_name: "BindingLiquidSdk_register_webhook",
1508            port: Some(port_),
1509            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
1510        },
1511        move || {
1512            let api_that = that.cst_decode();
1513            let api_webhook_url = webhook_url.cst_decode();
1514            move |context| async move {
1515                transform_result_dco::<_, _, crate::error::SdkError>(
1516                    (move || async move {
1517                        let mut api_that_guard = None;
1518                        let decode_indices_ =
1519                            flutter_rust_bridge::for_generated::lockable_compute_decode_order(
1520                                vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
1521                                    &api_that, 0, false,
1522                                )],
1523                            );
1524                        for i in decode_indices_ {
1525                            match i {
1526                                0 => {
1527                                    api_that_guard =
1528                                        Some(api_that.lockable_decode_async_ref().await)
1529                                }
1530                                _ => unreachable!(),
1531                            }
1532                        }
1533                        let api_that_guard = api_that_guard.unwrap();
1534                        let output_ok = crate::bindings::BindingLiquidSdk::register_webhook(
1535                            &*api_that_guard,
1536                            api_webhook_url,
1537                        )
1538                        .await?;
1539                        Ok(output_ok)
1540                    })()
1541                    .await,
1542                )
1543            }
1544        },
1545    )
1546}
1547fn wire__crate__bindings__BindingLiquidSdk_rescan_onchain_swaps_impl(
1548    port_: flutter_rust_bridge::for_generated::MessagePort,
1549    that: impl CstDecode<
1550        RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
1551    >,
1552) {
1553    FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
1554        flutter_rust_bridge::for_generated::TaskInfo {
1555            debug_name: "BindingLiquidSdk_rescan_onchain_swaps",
1556            port: Some(port_),
1557            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
1558        },
1559        move || {
1560            let api_that = that.cst_decode();
1561            move |context| async move {
1562                transform_result_dco::<_, _, crate::error::SdkError>(
1563                    (move || async move {
1564                        let mut api_that_guard = None;
1565                        let decode_indices_ =
1566                            flutter_rust_bridge::for_generated::lockable_compute_decode_order(
1567                                vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
1568                                    &api_that, 0, false,
1569                                )],
1570                            );
1571                        for i in decode_indices_ {
1572                            match i {
1573                                0 => {
1574                                    api_that_guard =
1575                                        Some(api_that.lockable_decode_async_ref().await)
1576                                }
1577                                _ => unreachable!(),
1578                            }
1579                        }
1580                        let api_that_guard = api_that_guard.unwrap();
1581                        let output_ok = crate::bindings::BindingLiquidSdk::rescan_onchain_swaps(
1582                            &*api_that_guard,
1583                        )
1584                        .await?;
1585                        Ok(output_ok)
1586                    })()
1587                    .await,
1588                )
1589            }
1590        },
1591    )
1592}
1593fn wire__crate__bindings__BindingLiquidSdk_restore_impl(
1594    that: impl CstDecode<
1595        RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
1596    >,
1597    req: impl CstDecode<crate::model::RestoreRequest>,
1598) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
1599    FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::DcoCodec, _>(
1600        flutter_rust_bridge::for_generated::TaskInfo {
1601            debug_name: "BindingLiquidSdk_restore",
1602            port: None,
1603            mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync,
1604        },
1605        move || {
1606            let api_that = that.cst_decode();
1607            let api_req = req.cst_decode();
1608            transform_result_dco::<_, _, crate::error::SdkError>((move || {
1609                let mut api_that_guard = None;
1610                let decode_indices_ =
1611                    flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![
1612                        flutter_rust_bridge::for_generated::LockableOrderInfo::new(
1613                            &api_that, 0, false,
1614                        ),
1615                    ]);
1616                for i in decode_indices_ {
1617                    match i {
1618                        0 => api_that_guard = Some(api_that.lockable_decode_sync_ref()),
1619                        _ => unreachable!(),
1620                    }
1621                }
1622                let api_that_guard = api_that_guard.unwrap();
1623                let output_ok =
1624                    crate::bindings::BindingLiquidSdk::restore(&*api_that_guard, api_req)?;
1625                Ok(output_ok)
1626            })())
1627        },
1628    )
1629}
1630fn wire__crate__bindings__BindingLiquidSdk_send_payment_impl(
1631    port_: flutter_rust_bridge::for_generated::MessagePort,
1632    that: impl CstDecode<
1633        RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
1634    >,
1635    req: impl CstDecode<crate::model::SendPaymentRequest>,
1636) {
1637    FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
1638        flutter_rust_bridge::for_generated::TaskInfo {
1639            debug_name: "BindingLiquidSdk_send_payment",
1640            port: Some(port_),
1641            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
1642        },
1643        move || {
1644            let api_that = that.cst_decode();
1645            let api_req = req.cst_decode();
1646            move |context| async move {
1647                transform_result_dco::<_, _, crate::error::PaymentError>(
1648                    (move || async move {
1649                        let mut api_that_guard = None;
1650                        let decode_indices_ =
1651                            flutter_rust_bridge::for_generated::lockable_compute_decode_order(
1652                                vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
1653                                    &api_that, 0, false,
1654                                )],
1655                            );
1656                        for i in decode_indices_ {
1657                            match i {
1658                                0 => {
1659                                    api_that_guard =
1660                                        Some(api_that.lockable_decode_async_ref().await)
1661                                }
1662                                _ => unreachable!(),
1663                            }
1664                        }
1665                        let api_that_guard = api_that_guard.unwrap();
1666                        let output_ok = crate::bindings::BindingLiquidSdk::send_payment(
1667                            &*api_that_guard,
1668                            api_req,
1669                        )
1670                        .await?;
1671                        Ok(output_ok)
1672                    })()
1673                    .await,
1674                )
1675            }
1676        },
1677    )
1678}
1679fn wire__crate__bindings__BindingLiquidSdk_sign_message_impl(
1680    that: impl CstDecode<
1681        RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
1682    >,
1683    req: impl CstDecode<crate::model::SignMessageRequest>,
1684) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
1685    FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::DcoCodec, _>(
1686        flutter_rust_bridge::for_generated::TaskInfo {
1687            debug_name: "BindingLiquidSdk_sign_message",
1688            port: None,
1689            mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync,
1690        },
1691        move || {
1692            let api_that = that.cst_decode();
1693            let api_req = req.cst_decode();
1694            transform_result_dco::<_, _, crate::error::SdkError>((move || {
1695                let mut api_that_guard = None;
1696                let decode_indices_ =
1697                    flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![
1698                        flutter_rust_bridge::for_generated::LockableOrderInfo::new(
1699                            &api_that, 0, false,
1700                        ),
1701                    ]);
1702                for i in decode_indices_ {
1703                    match i {
1704                        0 => api_that_guard = Some(api_that.lockable_decode_sync_ref()),
1705                        _ => unreachable!(),
1706                    }
1707                }
1708                let api_that_guard = api_that_guard.unwrap();
1709                let output_ok =
1710                    crate::bindings::BindingLiquidSdk::sign_message(&*api_that_guard, api_req)?;
1711                Ok(output_ok)
1712            })())
1713        },
1714    )
1715}
1716fn wire__crate__bindings__BindingLiquidSdk_sync_impl(
1717    port_: flutter_rust_bridge::for_generated::MessagePort,
1718    that: impl CstDecode<
1719        RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
1720    >,
1721) {
1722    FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
1723        flutter_rust_bridge::for_generated::TaskInfo {
1724            debug_name: "BindingLiquidSdk_sync(dart_style=sync)",
1725            port: Some(port_),
1726            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
1727        },
1728        move || {
1729            let api_that = that.cst_decode();
1730            move |context| async move {
1731                transform_result_dco::<_, _, crate::error::SdkError>(
1732                    (move || async move {
1733                        let mut api_that_guard = None;
1734                        let decode_indices_ =
1735                            flutter_rust_bridge::for_generated::lockable_compute_decode_order(
1736                                vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
1737                                    &api_that, 0, false,
1738                                )],
1739                            );
1740                        for i in decode_indices_ {
1741                            match i {
1742                                0 => {
1743                                    api_that_guard =
1744                                        Some(api_that.lockable_decode_async_ref().await)
1745                                }
1746                                _ => unreachable!(),
1747                            }
1748                        }
1749                        let api_that_guard = api_that_guard.unwrap();
1750                        let output_ok =
1751                            crate::bindings::BindingLiquidSdk::sync(&*api_that_guard).await?;
1752                        Ok(output_ok)
1753                    })()
1754                    .await,
1755                )
1756            }
1757        },
1758    )
1759}
1760fn wire__crate__bindings__BindingLiquidSdk_unregister_webhook_impl(
1761    port_: flutter_rust_bridge::for_generated::MessagePort,
1762    that: impl CstDecode<
1763        RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
1764    >,
1765) {
1766    FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
1767        flutter_rust_bridge::for_generated::TaskInfo {
1768            debug_name: "BindingLiquidSdk_unregister_webhook",
1769            port: Some(port_),
1770            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
1771        },
1772        move || {
1773            let api_that = that.cst_decode();
1774            move |context| async move {
1775                transform_result_dco::<_, _, crate::error::SdkError>(
1776                    (move || async move {
1777                        let mut api_that_guard = None;
1778                        let decode_indices_ =
1779                            flutter_rust_bridge::for_generated::lockable_compute_decode_order(
1780                                vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
1781                                    &api_that, 0, false,
1782                                )],
1783                            );
1784                        for i in decode_indices_ {
1785                            match i {
1786                                0 => {
1787                                    api_that_guard =
1788                                        Some(api_that.lockable_decode_async_ref().await)
1789                                }
1790                                _ => unreachable!(),
1791                            }
1792                        }
1793                        let api_that_guard = api_that_guard.unwrap();
1794                        let output_ok =
1795                            crate::bindings::BindingLiquidSdk::unregister_webhook(&*api_that_guard)
1796                                .await?;
1797                        Ok(output_ok)
1798                    })()
1799                    .await,
1800                )
1801            }
1802        },
1803    )
1804}
1805fn wire__crate__bindings__binding_event_listener_on_event_impl(
1806    port_: flutter_rust_bridge::for_generated::MessagePort,
1807    that: impl CstDecode<crate::bindings::BindingEventListener>,
1808    e: impl CstDecode<crate::model::SdkEvent>,
1809) {
1810    FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::<flutter_rust_bridge::for_generated::DcoCodec, _, _>(
1811        flutter_rust_bridge::for_generated::TaskInfo {
1812            debug_name: "binding_event_listener_on_event",
1813            port: Some(port_),
1814            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
1815        },
1816        move || {
1817            let api_that = that.cst_decode();
1818            let api_e = e.cst_decode();
1819            move |context| {
1820                transform_result_dco::<_, _, ()>((move || {
1821                    let output_ok = Result::<_, ()>::Ok({
1822                        crate::bindings::BindingEventListener::on_event(&api_that, api_e);
1823                    })?;
1824                    Ok(output_ok)
1825                })())
1826            }
1827        },
1828    )
1829}
1830fn wire__crate__bindings__breez_log_stream_impl(
1831    port_: flutter_rust_bridge::for_generated::MessagePort,
1832    s: impl CstDecode<StreamSink<crate::model::LogEntry, flutter_rust_bridge::for_generated::DcoCodec>>,
1833) {
1834    FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::<flutter_rust_bridge::for_generated::DcoCodec, _, _>(
1835        flutter_rust_bridge::for_generated::TaskInfo {
1836            debug_name: "breez_log_stream",
1837            port: Some(port_),
1838            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
1839        },
1840        move || {
1841            let api_s = s.cst_decode();
1842            move |context| {
1843                transform_result_dco::<_, _, flutter_rust_bridge::for_generated::anyhow::Error>(
1844                    (move || {
1845                        let output_ok = crate::bindings::breez_log_stream(api_s)?;
1846                        Ok(output_ok)
1847                    })(),
1848                )
1849            }
1850        },
1851    )
1852}
1853fn wire__crate__bindings__connect_impl(
1854    port_: flutter_rust_bridge::for_generated::MessagePort,
1855    req: impl CstDecode<crate::model::ConnectRequest>,
1856) {
1857    FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
1858        flutter_rust_bridge::for_generated::TaskInfo {
1859            debug_name: "connect",
1860            port: Some(port_),
1861            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
1862        },
1863        move || {
1864            let api_req = req.cst_decode();
1865            move |context| async move {
1866                transform_result_dco::<_, _, crate::error::SdkError>(
1867                    (move || async move {
1868                        let output_ok = crate::bindings::connect(api_req).await?;
1869                        Ok(output_ok)
1870                    })()
1871                    .await,
1872                )
1873            }
1874        },
1875    )
1876}
1877fn wire__crate__bindings__default_config_impl(
1878    network: impl CstDecode<crate::model::LiquidNetwork>,
1879    breez_api_key: impl CstDecode<Option<String>>,
1880) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
1881    FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::DcoCodec, _>(
1882        flutter_rust_bridge::for_generated::TaskInfo {
1883            debug_name: "default_config",
1884            port: None,
1885            mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync,
1886        },
1887        move || {
1888            let api_network = network.cst_decode();
1889            let api_breez_api_key = breez_api_key.cst_decode();
1890            transform_result_dco::<_, _, crate::error::SdkError>((move || {
1891                let output_ok = crate::bindings::default_config(api_network, api_breez_api_key)?;
1892                Ok(output_ok)
1893            })())
1894        },
1895    )
1896}
1897fn wire__crate__bindings__parse_invoice_impl(
1898    input: impl CstDecode<String>,
1899) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
1900    FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::DcoCodec, _>(
1901        flutter_rust_bridge::for_generated::TaskInfo {
1902            debug_name: "parse_invoice",
1903            port: None,
1904            mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync,
1905        },
1906        move || {
1907            let api_input = input.cst_decode();
1908            transform_result_dco::<_, _, crate::error::PaymentError>((move || {
1909                let output_ok = crate::bindings::parse_invoice(api_input)?;
1910                Ok(output_ok)
1911            })())
1912        },
1913    )
1914}
1915
1916// Section: static_checks
1917
1918#[allow(clippy::unnecessary_literal_unwrap)]
1919const _: fn() = || {
1920    {
1921        let AesSuccessActionData = None::<crate::bindings::AesSuccessActionData>.unwrap();
1922        let _: String = AesSuccessActionData.description;
1923        let _: String = AesSuccessActionData.ciphertext;
1924        let _: String = AesSuccessActionData.iv;
1925    }
1926    {
1927        let AesSuccessActionDataDecrypted =
1928            None::<crate::bindings::AesSuccessActionDataDecrypted>.unwrap();
1929        let _: String = AesSuccessActionDataDecrypted.description;
1930        let _: String = AesSuccessActionDataDecrypted.plaintext;
1931    }
1932    match None::<crate::bindings::AesSuccessActionDataResult>.unwrap() {
1933        crate::bindings::AesSuccessActionDataResult::Decrypted { data } => {
1934            let _: crate::bindings::AesSuccessActionDataDecrypted = data;
1935        }
1936        crate::bindings::AesSuccessActionDataResult::ErrorStatus { reason } => {
1937            let _: String = reason;
1938        }
1939    }
1940    match None::<crate::bindings::Amount>.unwrap() {
1941        crate::bindings::Amount::Bitcoin { amount_msat } => {
1942            let _: u64 = amount_msat;
1943        }
1944        crate::bindings::Amount::Currency {
1945            iso4217_code,
1946            fractional_amount,
1947        } => {
1948            let _: String = iso4217_code;
1949            let _: u64 = fractional_amount;
1950        }
1951    }
1952    {
1953        let BitcoinAddressData = None::<crate::bindings::BitcoinAddressData>.unwrap();
1954        let _: String = BitcoinAddressData.address;
1955        let _: crate::bindings::Network = BitcoinAddressData.network;
1956        let _: Option<u64> = BitcoinAddressData.amount_sat;
1957        let _: Option<String> = BitcoinAddressData.label;
1958        let _: Option<String> = BitcoinAddressData.message;
1959    }
1960    {
1961        let CurrencyInfo = None::<crate::bindings::CurrencyInfo>.unwrap();
1962        let _: String = CurrencyInfo.name;
1963        let _: u32 = CurrencyInfo.fraction_size;
1964        let _: Option<u32> = CurrencyInfo.spacing;
1965        let _: Option<crate::bindings::Symbol> = CurrencyInfo.symbol;
1966        let _: Option<crate::bindings::Symbol> = CurrencyInfo.uniq_symbol;
1967        let _: Vec<crate::bindings::LocalizedName> = CurrencyInfo.localized_name;
1968        let _: Vec<crate::bindings::LocaleOverrides> = CurrencyInfo.locale_overrides;
1969    }
1970    {
1971        let ExternalInputParser = None::<crate::bindings::ExternalInputParser>.unwrap();
1972        let _: String = ExternalInputParser.provider_id;
1973        let _: String = ExternalInputParser.input_regex;
1974        let _: String = ExternalInputParser.parser_url;
1975    }
1976    {
1977        let FiatCurrency = None::<crate::bindings::FiatCurrency>.unwrap();
1978        let _: String = FiatCurrency.id;
1979        let _: crate::bindings::CurrencyInfo = FiatCurrency.info;
1980    }
1981    match None::<crate::bindings::InputType>.unwrap() {
1982        crate::bindings::InputType::BitcoinAddress { address } => {
1983            let _: crate::bindings::BitcoinAddressData = address;
1984        }
1985        crate::bindings::InputType::LiquidAddress { address } => {
1986            let _: crate::bindings::LiquidAddressData = address;
1987        }
1988        crate::bindings::InputType::Bolt11 { invoice } => {
1989            let _: crate::bindings::LNInvoice = invoice;
1990        }
1991        crate::bindings::InputType::Bolt12Offer {
1992            offer,
1993            bip353_address,
1994        } => {
1995            let _: crate::bindings::LNOffer = offer;
1996            let _: Option<String> = bip353_address;
1997        }
1998        crate::bindings::InputType::NodeId { node_id } => {
1999            let _: String = node_id;
2000        }
2001        crate::bindings::InputType::Url { url } => {
2002            let _: String = url;
2003        }
2004        crate::bindings::InputType::LnUrlPay {
2005            data,
2006            bip353_address,
2007        } => {
2008            let _: crate::bindings::LnUrlPayRequestData = data;
2009            let _: Option<String> = bip353_address;
2010        }
2011        crate::bindings::InputType::LnUrlWithdraw { data } => {
2012            let _: crate::bindings::LnUrlWithdrawRequestData = data;
2013        }
2014        crate::bindings::InputType::LnUrlAuth { data } => {
2015            let _: crate::bindings::LnUrlAuthRequestData = data;
2016        }
2017        crate::bindings::InputType::LnUrlError { data } => {
2018            let _: crate::bindings::LnUrlErrorData = data;
2019        }
2020    }
2021    {
2022        let LiquidAddressData = None::<crate::bindings::LiquidAddressData>.unwrap();
2023        let _: String = LiquidAddressData.address;
2024        let _: crate::bindings::Network = LiquidAddressData.network;
2025        let _: Option<String> = LiquidAddressData.asset_id;
2026        let _: Option<f64> = LiquidAddressData.amount;
2027        let _: Option<u64> = LiquidAddressData.amount_sat;
2028        let _: Option<String> = LiquidAddressData.label;
2029        let _: Option<String> = LiquidAddressData.message;
2030    }
2031    {
2032        let LNInvoice = None::<crate::bindings::LNInvoice>.unwrap();
2033        let _: String = LNInvoice.bolt11;
2034        let _: crate::bindings::Network = LNInvoice.network;
2035        let _: String = LNInvoice.payee_pubkey;
2036        let _: String = LNInvoice.payment_hash;
2037        let _: Option<String> = LNInvoice.description;
2038        let _: Option<String> = LNInvoice.description_hash;
2039        let _: Option<u64> = LNInvoice.amount_msat;
2040        let _: u64 = LNInvoice.timestamp;
2041        let _: u64 = LNInvoice.expiry;
2042        let _: Vec<crate::bindings::RouteHint> = LNInvoice.routing_hints;
2043        let _: Vec<u8> = LNInvoice.payment_secret;
2044        let _: u64 = LNInvoice.min_final_cltv_expiry_delta;
2045    }
2046    {
2047        let LNOffer = None::<crate::bindings::LNOffer>.unwrap();
2048        let _: String = LNOffer.offer;
2049        let _: Vec<String> = LNOffer.chains;
2050        let _: Option<crate::bindings::Amount> = LNOffer.min_amount;
2051        let _: Option<String> = LNOffer.description;
2052        let _: Option<u64> = LNOffer.absolute_expiry;
2053        let _: Option<String> = LNOffer.issuer;
2054        let _: Option<String> = LNOffer.signing_pubkey;
2055        let _: Vec<crate::bindings::LnOfferBlindedPath> = LNOffer.paths;
2056    }
2057    {
2058        let LnOfferBlindedPath = None::<crate::bindings::LnOfferBlindedPath>.unwrap();
2059        let _: Vec<String> = LnOfferBlindedPath.blinded_hops;
2060    }
2061    {
2062        let LnUrlAuthRequestData = None::<crate::bindings::LnUrlAuthRequestData>.unwrap();
2063        let _: String = LnUrlAuthRequestData.k1;
2064        let _: Option<String> = LnUrlAuthRequestData.action;
2065        let _: String = LnUrlAuthRequestData.domain;
2066        let _: String = LnUrlAuthRequestData.url;
2067    }
2068    {
2069        let LnUrlErrorData = None::<crate::bindings::LnUrlErrorData>.unwrap();
2070        let _: String = LnUrlErrorData.reason;
2071    }
2072    {
2073        let LnUrlPayErrorData = None::<crate::bindings::LnUrlPayErrorData>.unwrap();
2074        let _: String = LnUrlPayErrorData.payment_hash;
2075        let _: String = LnUrlPayErrorData.reason;
2076    }
2077    {
2078        let LnUrlPayRequestData = None::<crate::bindings::LnUrlPayRequestData>.unwrap();
2079        let _: String = LnUrlPayRequestData.callback;
2080        let _: u64 = LnUrlPayRequestData.min_sendable;
2081        let _: u64 = LnUrlPayRequestData.max_sendable;
2082        let _: String = LnUrlPayRequestData.metadata_str;
2083        let _: u16 = LnUrlPayRequestData.comment_allowed;
2084        let _: String = LnUrlPayRequestData.domain;
2085        let _: bool = LnUrlPayRequestData.allows_nostr;
2086        let _: Option<String> = LnUrlPayRequestData.nostr_pubkey;
2087        let _: Option<String> = LnUrlPayRequestData.ln_address;
2088    }
2089    {
2090        let LnUrlWithdrawRequest = None::<crate::bindings::LnUrlWithdrawRequest>.unwrap();
2091        let _: crate::bindings::LnUrlWithdrawRequestData = LnUrlWithdrawRequest.data;
2092        let _: u64 = LnUrlWithdrawRequest.amount_msat;
2093        let _: Option<String> = LnUrlWithdrawRequest.description;
2094    }
2095    {
2096        let LnUrlWithdrawRequestData = None::<crate::bindings::LnUrlWithdrawRequestData>.unwrap();
2097        let _: String = LnUrlWithdrawRequestData.callback;
2098        let _: String = LnUrlWithdrawRequestData.k1;
2099        let _: String = LnUrlWithdrawRequestData.default_description;
2100        let _: u64 = LnUrlWithdrawRequestData.min_withdrawable;
2101        let _: u64 = LnUrlWithdrawRequestData.max_withdrawable;
2102    }
2103    {
2104        let LocaleOverrides = None::<crate::bindings::LocaleOverrides>.unwrap();
2105        let _: String = LocaleOverrides.locale;
2106        let _: Option<u32> = LocaleOverrides.spacing;
2107        let _: crate::bindings::Symbol = LocaleOverrides.symbol;
2108    }
2109    {
2110        let LocalizedName = None::<crate::bindings::LocalizedName>.unwrap();
2111        let _: String = LocalizedName.locale;
2112        let _: String = LocalizedName.name;
2113    }
2114    {
2115        let MessageSuccessActionData = None::<crate::bindings::MessageSuccessActionData>.unwrap();
2116        let _: String = MessageSuccessActionData.message;
2117    }
2118    {
2119        let Rate = None::<crate::bindings::Rate>.unwrap();
2120        let _: String = Rate.coin;
2121        let _: f64 = Rate.value;
2122    }
2123    {
2124        let RouteHint = None::<crate::bindings::RouteHint>.unwrap();
2125        let _: Vec<crate::bindings::RouteHintHop> = RouteHint.hops;
2126    }
2127    {
2128        let RouteHintHop = None::<crate::bindings::RouteHintHop>.unwrap();
2129        let _: String = RouteHintHop.src_node_id;
2130        let _: String = RouteHintHop.short_channel_id;
2131        let _: u32 = RouteHintHop.fees_base_msat;
2132        let _: u32 = RouteHintHop.fees_proportional_millionths;
2133        let _: u64 = RouteHintHop.cltv_expiry_delta;
2134        let _: Option<u64> = RouteHintHop.htlc_minimum_msat;
2135        let _: Option<u64> = RouteHintHop.htlc_maximum_msat;
2136    }
2137    match None::<crate::bindings::SuccessAction>.unwrap() {
2138        crate::bindings::SuccessAction::Aes { data } => {
2139            let _: crate::bindings::AesSuccessActionData = data;
2140        }
2141        crate::bindings::SuccessAction::Message { data } => {
2142            let _: crate::bindings::MessageSuccessActionData = data;
2143        }
2144        crate::bindings::SuccessAction::Url { data } => {
2145            let _: crate::bindings::UrlSuccessActionData = data;
2146        }
2147    }
2148    match None::<crate::bindings::SuccessActionProcessed>.unwrap() {
2149        crate::bindings::SuccessActionProcessed::Aes { result } => {
2150            let _: crate::bindings::AesSuccessActionDataResult = result;
2151        }
2152        crate::bindings::SuccessActionProcessed::Message { data } => {
2153            let _: crate::bindings::MessageSuccessActionData = data;
2154        }
2155        crate::bindings::SuccessActionProcessed::Url { data } => {
2156            let _: crate::bindings::UrlSuccessActionData = data;
2157        }
2158    }
2159    {
2160        let Symbol = None::<crate::bindings::Symbol>.unwrap();
2161        let _: Option<String> = Symbol.grapheme;
2162        let _: Option<String> = Symbol.template;
2163        let _: Option<bool> = Symbol.rtl;
2164        let _: Option<u32> = Symbol.position;
2165    }
2166    {
2167        let UrlSuccessActionData = None::<crate::bindings::UrlSuccessActionData>.unwrap();
2168        let _: String = UrlSuccessActionData.description;
2169        let _: String = UrlSuccessActionData.url;
2170        let _: bool = UrlSuccessActionData.matches_callback_domain;
2171    }
2172};
2173
2174// Section: dart2rust
2175
2176impl CstDecode<bool> for bool {
2177    // Codec=Cst (C-struct based), see doc to use other codecs
2178    fn cst_decode(self) -> bool {
2179        self
2180    }
2181}
2182impl CstDecode<crate::model::BuyBitcoinProvider> for i32 {
2183    // Codec=Cst (C-struct based), see doc to use other codecs
2184    fn cst_decode(self) -> crate::model::BuyBitcoinProvider {
2185        match self {
2186            0 => crate::model::BuyBitcoinProvider::Moonpay,
2187            _ => unreachable!("Invalid variant for BuyBitcoinProvider: {}", self),
2188        }
2189    }
2190}
2191impl CstDecode<f64> for f64 {
2192    // Codec=Cst (C-struct based), see doc to use other codecs
2193    fn cst_decode(self) -> f64 {
2194        self
2195    }
2196}
2197impl CstDecode<i32> for i32 {
2198    // Codec=Cst (C-struct based), see doc to use other codecs
2199    fn cst_decode(self) -> i32 {
2200        self
2201    }
2202}
2203impl CstDecode<i64> for i64 {
2204    // Codec=Cst (C-struct based), see doc to use other codecs
2205    fn cst_decode(self) -> i64 {
2206        self
2207    }
2208}
2209impl CstDecode<crate::model::LiquidNetwork> for i32 {
2210    // Codec=Cst (C-struct based), see doc to use other codecs
2211    fn cst_decode(self) -> crate::model::LiquidNetwork {
2212        match self {
2213            0 => crate::model::LiquidNetwork::Mainnet,
2214            1 => crate::model::LiquidNetwork::Testnet,
2215            2 => crate::model::LiquidNetwork::Regtest,
2216            _ => unreachable!("Invalid variant for LiquidNetwork: {}", self),
2217        }
2218    }
2219}
2220impl CstDecode<crate::bindings::Network> for i32 {
2221    // Codec=Cst (C-struct based), see doc to use other codecs
2222    fn cst_decode(self) -> crate::bindings::Network {
2223        match self {
2224            0 => crate::bindings::Network::Bitcoin,
2225            1 => crate::bindings::Network::Testnet,
2226            2 => crate::bindings::Network::Signet,
2227            3 => crate::bindings::Network::Regtest,
2228            _ => unreachable!("Invalid variant for Network: {}", self),
2229        }
2230    }
2231}
2232impl CstDecode<crate::model::PaymentMethod> for i32 {
2233    // Codec=Cst (C-struct based), see doc to use other codecs
2234    fn cst_decode(self) -> crate::model::PaymentMethod {
2235        match self {
2236            0 => crate::model::PaymentMethod::Lightning,
2237            1 => crate::model::PaymentMethod::Bolt11Invoice,
2238            2 => crate::model::PaymentMethod::Bolt12Offer,
2239            3 => crate::model::PaymentMethod::BitcoinAddress,
2240            4 => crate::model::PaymentMethod::LiquidAddress,
2241            _ => unreachable!("Invalid variant for PaymentMethod: {}", self),
2242        }
2243    }
2244}
2245impl CstDecode<crate::model::PaymentState> for i32 {
2246    // Codec=Cst (C-struct based), see doc to use other codecs
2247    fn cst_decode(self) -> crate::model::PaymentState {
2248        match self {
2249            0 => crate::model::PaymentState::Created,
2250            1 => crate::model::PaymentState::Pending,
2251            2 => crate::model::PaymentState::Complete,
2252            3 => crate::model::PaymentState::Failed,
2253            4 => crate::model::PaymentState::TimedOut,
2254            5 => crate::model::PaymentState::Refundable,
2255            6 => crate::model::PaymentState::RefundPending,
2256            7 => crate::model::PaymentState::WaitingFeeAcceptance,
2257            _ => unreachable!("Invalid variant for PaymentState: {}", self),
2258        }
2259    }
2260}
2261impl CstDecode<crate::model::PaymentType> for i32 {
2262    // Codec=Cst (C-struct based), see doc to use other codecs
2263    fn cst_decode(self) -> crate::model::PaymentType {
2264        match self {
2265            0 => crate::model::PaymentType::Receive,
2266            1 => crate::model::PaymentType::Send,
2267            _ => unreachable!("Invalid variant for PaymentType: {}", self),
2268        }
2269    }
2270}
2271impl CstDecode<u16> for u16 {
2272    // Codec=Cst (C-struct based), see doc to use other codecs
2273    fn cst_decode(self) -> u16 {
2274        self
2275    }
2276}
2277impl CstDecode<u32> for u32 {
2278    // Codec=Cst (C-struct based), see doc to use other codecs
2279    fn cst_decode(self) -> u32 {
2280        self
2281    }
2282}
2283impl CstDecode<u64> for u64 {
2284    // Codec=Cst (C-struct based), see doc to use other codecs
2285    fn cst_decode(self) -> u64 {
2286        self
2287    }
2288}
2289impl CstDecode<u8> for u8 {
2290    // Codec=Cst (C-struct based), see doc to use other codecs
2291    fn cst_decode(self) -> u8 {
2292        self
2293    }
2294}
2295impl CstDecode<usize> for usize {
2296    // Codec=Cst (C-struct based), see doc to use other codecs
2297    fn cst_decode(self) -> usize {
2298        self
2299    }
2300}
2301impl SseDecode for flutter_rust_bridge::for_generated::anyhow::Error {
2302    // Codec=Sse (Serialization based), see doc to use other codecs
2303    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2304        let mut inner = <String>::sse_decode(deserializer);
2305        return flutter_rust_bridge::for_generated::anyhow::anyhow!("{}", inner);
2306    }
2307}
2308
2309impl SseDecode for BindingLiquidSdk {
2310    // Codec=Sse (Serialization based), see doc to use other codecs
2311    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2312        let mut inner = <RustOpaqueNom<
2313            flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>,
2314        >>::sse_decode(deserializer);
2315        return flutter_rust_bridge::for_generated::rust_auto_opaque_decode_owned(inner);
2316    }
2317}
2318
2319impl SseDecode
2320    for RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>
2321{
2322    // Codec=Sse (Serialization based), see doc to use other codecs
2323    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2324        let mut inner = <usize>::sse_decode(deserializer);
2325        return unsafe { decode_rust_opaque_nom(inner) };
2326    }
2327}
2328
2329impl SseDecode
2330    for StreamSink<crate::model::LogEntry, flutter_rust_bridge::for_generated::DcoCodec>
2331{
2332    // Codec=Sse (Serialization based), see doc to use other codecs
2333    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2334        let mut inner = <String>::sse_decode(deserializer);
2335        return StreamSink::deserialize(inner);
2336    }
2337}
2338
2339impl SseDecode
2340    for StreamSink<crate::model::SdkEvent, flutter_rust_bridge::for_generated::DcoCodec>
2341{
2342    // Codec=Sse (Serialization based), see doc to use other codecs
2343    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2344        let mut inner = <String>::sse_decode(deserializer);
2345        return StreamSink::deserialize(inner);
2346    }
2347}
2348
2349impl SseDecode for String {
2350    // Codec=Sse (Serialization based), see doc to use other codecs
2351    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2352        let mut inner = <Vec<u8>>::sse_decode(deserializer);
2353        return String::from_utf8(inner).unwrap();
2354    }
2355}
2356
2357impl SseDecode for crate::model::AcceptPaymentProposedFeesRequest {
2358    // Codec=Sse (Serialization based), see doc to use other codecs
2359    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2360        let mut var_response =
2361            <crate::model::FetchPaymentProposedFeesResponse>::sse_decode(deserializer);
2362        return crate::model::AcceptPaymentProposedFeesRequest {
2363            response: var_response,
2364        };
2365    }
2366}
2367
2368impl SseDecode for crate::bindings::AesSuccessActionData {
2369    // Codec=Sse (Serialization based), see doc to use other codecs
2370    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2371        let mut var_description = <String>::sse_decode(deserializer);
2372        let mut var_ciphertext = <String>::sse_decode(deserializer);
2373        let mut var_iv = <String>::sse_decode(deserializer);
2374        return crate::bindings::AesSuccessActionData {
2375            description: var_description,
2376            ciphertext: var_ciphertext,
2377            iv: var_iv,
2378        };
2379    }
2380}
2381
2382impl SseDecode for crate::bindings::AesSuccessActionDataDecrypted {
2383    // Codec=Sse (Serialization based), see doc to use other codecs
2384    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2385        let mut var_description = <String>::sse_decode(deserializer);
2386        let mut var_plaintext = <String>::sse_decode(deserializer);
2387        return crate::bindings::AesSuccessActionDataDecrypted {
2388            description: var_description,
2389            plaintext: var_plaintext,
2390        };
2391    }
2392}
2393
2394impl SseDecode for crate::bindings::AesSuccessActionDataResult {
2395    // Codec=Sse (Serialization based), see doc to use other codecs
2396    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2397        let mut tag_ = <i32>::sse_decode(deserializer);
2398        match tag_ {
2399            0 => {
2400                let mut var_data =
2401                    <crate::bindings::AesSuccessActionDataDecrypted>::sse_decode(deserializer);
2402                return crate::bindings::AesSuccessActionDataResult::Decrypted { data: var_data };
2403            }
2404            1 => {
2405                let mut var_reason = <String>::sse_decode(deserializer);
2406                return crate::bindings::AesSuccessActionDataResult::ErrorStatus {
2407                    reason: var_reason,
2408                };
2409            }
2410            _ => {
2411                unimplemented!("");
2412            }
2413        }
2414    }
2415}
2416
2417impl SseDecode for crate::bindings::Amount {
2418    // Codec=Sse (Serialization based), see doc to use other codecs
2419    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2420        let mut tag_ = <i32>::sse_decode(deserializer);
2421        match tag_ {
2422            0 => {
2423                let mut var_amountMsat = <u64>::sse_decode(deserializer);
2424                return crate::bindings::Amount::Bitcoin {
2425                    amount_msat: var_amountMsat,
2426                };
2427            }
2428            1 => {
2429                let mut var_iso4217Code = <String>::sse_decode(deserializer);
2430                let mut var_fractionalAmount = <u64>::sse_decode(deserializer);
2431                return crate::bindings::Amount::Currency {
2432                    iso4217_code: var_iso4217Code,
2433                    fractional_amount: var_fractionalAmount,
2434                };
2435            }
2436            _ => {
2437                unimplemented!("");
2438            }
2439        }
2440    }
2441}
2442
2443impl SseDecode for crate::model::AssetBalance {
2444    // Codec=Sse (Serialization based), see doc to use other codecs
2445    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2446        let mut var_assetId = <String>::sse_decode(deserializer);
2447        let mut var_balanceSat = <u64>::sse_decode(deserializer);
2448        let mut var_name = <Option<String>>::sse_decode(deserializer);
2449        let mut var_ticker = <Option<String>>::sse_decode(deserializer);
2450        let mut var_balance = <Option<f64>>::sse_decode(deserializer);
2451        return crate::model::AssetBalance {
2452            asset_id: var_assetId,
2453            balance_sat: var_balanceSat,
2454            name: var_name,
2455            ticker: var_ticker,
2456            balance: var_balance,
2457        };
2458    }
2459}
2460
2461impl SseDecode for crate::model::AssetInfo {
2462    // Codec=Sse (Serialization based), see doc to use other codecs
2463    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2464        let mut var_name = <String>::sse_decode(deserializer);
2465        let mut var_ticker = <String>::sse_decode(deserializer);
2466        let mut var_amount = <f64>::sse_decode(deserializer);
2467        let mut var_fees = <Option<f64>>::sse_decode(deserializer);
2468        return crate::model::AssetInfo {
2469            name: var_name,
2470            ticker: var_ticker,
2471            amount: var_amount,
2472            fees: var_fees,
2473        };
2474    }
2475}
2476
2477impl SseDecode for crate::model::AssetMetadata {
2478    // Codec=Sse (Serialization based), see doc to use other codecs
2479    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2480        let mut var_assetId = <String>::sse_decode(deserializer);
2481        let mut var_name = <String>::sse_decode(deserializer);
2482        let mut var_ticker = <String>::sse_decode(deserializer);
2483        let mut var_precision = <u8>::sse_decode(deserializer);
2484        let mut var_fiatId = <Option<String>>::sse_decode(deserializer);
2485        return crate::model::AssetMetadata {
2486            asset_id: var_assetId,
2487            name: var_name,
2488            ticker: var_ticker,
2489            precision: var_precision,
2490            fiat_id: var_fiatId,
2491        };
2492    }
2493}
2494
2495impl SseDecode for crate::model::BackupRequest {
2496    // Codec=Sse (Serialization based), see doc to use other codecs
2497    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2498        let mut var_backupPath = <Option<String>>::sse_decode(deserializer);
2499        return crate::model::BackupRequest {
2500            backup_path: var_backupPath,
2501        };
2502    }
2503}
2504
2505impl SseDecode for crate::bindings::BindingEventListener {
2506    // Codec=Sse (Serialization based), see doc to use other codecs
2507    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2508        let mut var_stream = <StreamSink<
2509            crate::model::SdkEvent,
2510            flutter_rust_bridge::for_generated::DcoCodec,
2511        >>::sse_decode(deserializer);
2512        return crate::bindings::BindingEventListener { stream: var_stream };
2513    }
2514}
2515
2516impl SseDecode for crate::bindings::BitcoinAddressData {
2517    // Codec=Sse (Serialization based), see doc to use other codecs
2518    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2519        let mut var_address = <String>::sse_decode(deserializer);
2520        let mut var_network = <crate::bindings::Network>::sse_decode(deserializer);
2521        let mut var_amountSat = <Option<u64>>::sse_decode(deserializer);
2522        let mut var_label = <Option<String>>::sse_decode(deserializer);
2523        let mut var_message = <Option<String>>::sse_decode(deserializer);
2524        return crate::bindings::BitcoinAddressData {
2525            address: var_address,
2526            network: var_network,
2527            amount_sat: var_amountSat,
2528            label: var_label,
2529            message: var_message,
2530        };
2531    }
2532}
2533
2534impl SseDecode for crate::model::BlockchainExplorer {
2535    // Codec=Sse (Serialization based), see doc to use other codecs
2536    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2537        let mut tag_ = <i32>::sse_decode(deserializer);
2538        match tag_ {
2539            0 => {
2540                let mut var_url = <String>::sse_decode(deserializer);
2541                return crate::model::BlockchainExplorer::Electrum { url: var_url };
2542            }
2543            1 => {
2544                let mut var_url = <String>::sse_decode(deserializer);
2545                let mut var_useWaterfalls = <bool>::sse_decode(deserializer);
2546                return crate::model::BlockchainExplorer::Esplora {
2547                    url: var_url,
2548                    use_waterfalls: var_useWaterfalls,
2549                };
2550            }
2551            _ => {
2552                unimplemented!("");
2553            }
2554        }
2555    }
2556}
2557
2558impl SseDecode for crate::model::BlockchainInfo {
2559    // Codec=Sse (Serialization based), see doc to use other codecs
2560    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2561        let mut var_liquidTip = <u32>::sse_decode(deserializer);
2562        let mut var_bitcoinTip = <u32>::sse_decode(deserializer);
2563        return crate::model::BlockchainInfo {
2564            liquid_tip: var_liquidTip,
2565            bitcoin_tip: var_bitcoinTip,
2566        };
2567    }
2568}
2569
2570impl SseDecode for bool {
2571    // Codec=Sse (Serialization based), see doc to use other codecs
2572    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2573        deserializer.cursor.read_u8().unwrap() != 0
2574    }
2575}
2576
2577impl SseDecode for crate::model::BuyBitcoinProvider {
2578    // Codec=Sse (Serialization based), see doc to use other codecs
2579    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2580        let mut inner = <i32>::sse_decode(deserializer);
2581        return match inner {
2582            0 => crate::model::BuyBitcoinProvider::Moonpay,
2583            _ => unreachable!("Invalid variant for BuyBitcoinProvider: {}", inner),
2584        };
2585    }
2586}
2587
2588impl SseDecode for crate::model::BuyBitcoinRequest {
2589    // Codec=Sse (Serialization based), see doc to use other codecs
2590    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2591        let mut var_prepareResponse =
2592            <crate::model::PrepareBuyBitcoinResponse>::sse_decode(deserializer);
2593        let mut var_redirectUrl = <Option<String>>::sse_decode(deserializer);
2594        return crate::model::BuyBitcoinRequest {
2595            prepare_response: var_prepareResponse,
2596            redirect_url: var_redirectUrl,
2597        };
2598    }
2599}
2600
2601impl SseDecode for crate::model::CheckMessageRequest {
2602    // Codec=Sse (Serialization based), see doc to use other codecs
2603    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2604        let mut var_message = <String>::sse_decode(deserializer);
2605        let mut var_pubkey = <String>::sse_decode(deserializer);
2606        let mut var_signature = <String>::sse_decode(deserializer);
2607        return crate::model::CheckMessageRequest {
2608            message: var_message,
2609            pubkey: var_pubkey,
2610            signature: var_signature,
2611        };
2612    }
2613}
2614
2615impl SseDecode for crate::model::CheckMessageResponse {
2616    // Codec=Sse (Serialization based), see doc to use other codecs
2617    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2618        let mut var_isValid = <bool>::sse_decode(deserializer);
2619        return crate::model::CheckMessageResponse {
2620            is_valid: var_isValid,
2621        };
2622    }
2623}
2624
2625impl SseDecode for crate::model::Config {
2626    // Codec=Sse (Serialization based), see doc to use other codecs
2627    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2628        let mut var_liquidExplorer = <crate::model::BlockchainExplorer>::sse_decode(deserializer);
2629        let mut var_bitcoinExplorer = <crate::model::BlockchainExplorer>::sse_decode(deserializer);
2630        let mut var_workingDir = <String>::sse_decode(deserializer);
2631        let mut var_cacheDir = <Option<String>>::sse_decode(deserializer);
2632        let mut var_network = <crate::model::LiquidNetwork>::sse_decode(deserializer);
2633        let mut var_paymentTimeoutSec = <u64>::sse_decode(deserializer);
2634        let mut var_syncServiceUrl = <Option<String>>::sse_decode(deserializer);
2635        let mut var_zeroConfMaxAmountSat = <Option<u64>>::sse_decode(deserializer);
2636        let mut var_breezApiKey = <Option<String>>::sse_decode(deserializer);
2637        let mut var_externalInputParsers =
2638            <Option<Vec<crate::bindings::ExternalInputParser>>>::sse_decode(deserializer);
2639        let mut var_useDefaultExternalInputParsers = <bool>::sse_decode(deserializer);
2640        let mut var_onchainFeeRateLeewaySatPerVbyte = <Option<u32>>::sse_decode(deserializer);
2641        let mut var_assetMetadata =
2642            <Option<Vec<crate::model::AssetMetadata>>>::sse_decode(deserializer);
2643        let mut var_sideswapApiKey = <Option<String>>::sse_decode(deserializer);
2644        return crate::model::Config {
2645            liquid_explorer: var_liquidExplorer,
2646            bitcoin_explorer: var_bitcoinExplorer,
2647            working_dir: var_workingDir,
2648            cache_dir: var_cacheDir,
2649            network: var_network,
2650            payment_timeout_sec: var_paymentTimeoutSec,
2651            sync_service_url: var_syncServiceUrl,
2652            zero_conf_max_amount_sat: var_zeroConfMaxAmountSat,
2653            breez_api_key: var_breezApiKey,
2654            external_input_parsers: var_externalInputParsers,
2655            use_default_external_input_parsers: var_useDefaultExternalInputParsers,
2656            onchain_fee_rate_leeway_sat_per_vbyte: var_onchainFeeRateLeewaySatPerVbyte,
2657            asset_metadata: var_assetMetadata,
2658            sideswap_api_key: var_sideswapApiKey,
2659        };
2660    }
2661}
2662
2663impl SseDecode for crate::model::ConnectRequest {
2664    // Codec=Sse (Serialization based), see doc to use other codecs
2665    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2666        let mut var_config = <crate::model::Config>::sse_decode(deserializer);
2667        let mut var_mnemonic = <Option<String>>::sse_decode(deserializer);
2668        let mut var_passphrase = <Option<String>>::sse_decode(deserializer);
2669        let mut var_seed = <Option<Vec<u8>>>::sse_decode(deserializer);
2670        return crate::model::ConnectRequest {
2671            config: var_config,
2672            mnemonic: var_mnemonic,
2673            passphrase: var_passphrase,
2674            seed: var_seed,
2675        };
2676    }
2677}
2678
2679impl SseDecode for crate::model::CreateBolt12InvoiceRequest {
2680    // Codec=Sse (Serialization based), see doc to use other codecs
2681    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2682        let mut var_offer = <String>::sse_decode(deserializer);
2683        let mut var_invoiceRequest = <String>::sse_decode(deserializer);
2684        return crate::model::CreateBolt12InvoiceRequest {
2685            offer: var_offer,
2686            invoice_request: var_invoiceRequest,
2687        };
2688    }
2689}
2690
2691impl SseDecode for crate::model::CreateBolt12InvoiceResponse {
2692    // Codec=Sse (Serialization based), see doc to use other codecs
2693    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2694        let mut var_invoice = <String>::sse_decode(deserializer);
2695        return crate::model::CreateBolt12InvoiceResponse {
2696            invoice: var_invoice,
2697        };
2698    }
2699}
2700
2701impl SseDecode for crate::bindings::CurrencyInfo {
2702    // Codec=Sse (Serialization based), see doc to use other codecs
2703    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2704        let mut var_name = <String>::sse_decode(deserializer);
2705        let mut var_fractionSize = <u32>::sse_decode(deserializer);
2706        let mut var_spacing = <Option<u32>>::sse_decode(deserializer);
2707        let mut var_symbol = <Option<crate::bindings::Symbol>>::sse_decode(deserializer);
2708        let mut var_uniqSymbol = <Option<crate::bindings::Symbol>>::sse_decode(deserializer);
2709        let mut var_localizedName = <Vec<crate::bindings::LocalizedName>>::sse_decode(deserializer);
2710        let mut var_localeOverrides =
2711            <Vec<crate::bindings::LocaleOverrides>>::sse_decode(deserializer);
2712        return crate::bindings::CurrencyInfo {
2713            name: var_name,
2714            fraction_size: var_fractionSize,
2715            spacing: var_spacing,
2716            symbol: var_symbol,
2717            uniq_symbol: var_uniqSymbol,
2718            localized_name: var_localizedName,
2719            locale_overrides: var_localeOverrides,
2720        };
2721    }
2722}
2723
2724impl SseDecode for crate::bindings::ExternalInputParser {
2725    // Codec=Sse (Serialization based), see doc to use other codecs
2726    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2727        let mut var_providerId = <String>::sse_decode(deserializer);
2728        let mut var_inputRegex = <String>::sse_decode(deserializer);
2729        let mut var_parserUrl = <String>::sse_decode(deserializer);
2730        return crate::bindings::ExternalInputParser {
2731            provider_id: var_providerId,
2732            input_regex: var_inputRegex,
2733            parser_url: var_parserUrl,
2734        };
2735    }
2736}
2737
2738impl SseDecode for f64 {
2739    // Codec=Sse (Serialization based), see doc to use other codecs
2740    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2741        deserializer.cursor.read_f64::<NativeEndian>().unwrap()
2742    }
2743}
2744
2745impl SseDecode for crate::model::FetchPaymentProposedFeesRequest {
2746    // Codec=Sse (Serialization based), see doc to use other codecs
2747    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2748        let mut var_swapId = <String>::sse_decode(deserializer);
2749        return crate::model::FetchPaymentProposedFeesRequest {
2750            swap_id: var_swapId,
2751        };
2752    }
2753}
2754
2755impl SseDecode for crate::model::FetchPaymentProposedFeesResponse {
2756    // Codec=Sse (Serialization based), see doc to use other codecs
2757    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2758        let mut var_swapId = <String>::sse_decode(deserializer);
2759        let mut var_feesSat = <u64>::sse_decode(deserializer);
2760        let mut var_payerAmountSat = <u64>::sse_decode(deserializer);
2761        let mut var_receiverAmountSat = <u64>::sse_decode(deserializer);
2762        return crate::model::FetchPaymentProposedFeesResponse {
2763            swap_id: var_swapId,
2764            fees_sat: var_feesSat,
2765            payer_amount_sat: var_payerAmountSat,
2766            receiver_amount_sat: var_receiverAmountSat,
2767        };
2768    }
2769}
2770
2771impl SseDecode for crate::bindings::FiatCurrency {
2772    // Codec=Sse (Serialization based), see doc to use other codecs
2773    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2774        let mut var_id = <String>::sse_decode(deserializer);
2775        let mut var_info = <crate::bindings::CurrencyInfo>::sse_decode(deserializer);
2776        return crate::bindings::FiatCurrency {
2777            id: var_id,
2778            info: var_info,
2779        };
2780    }
2781}
2782
2783impl SseDecode for crate::model::GetInfoResponse {
2784    // Codec=Sse (Serialization based), see doc to use other codecs
2785    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2786        let mut var_walletInfo = <crate::model::WalletInfo>::sse_decode(deserializer);
2787        let mut var_blockchainInfo = <crate::model::BlockchainInfo>::sse_decode(deserializer);
2788        return crate::model::GetInfoResponse {
2789            wallet_info: var_walletInfo,
2790            blockchain_info: var_blockchainInfo,
2791        };
2792    }
2793}
2794
2795impl SseDecode for crate::model::GetPaymentRequest {
2796    // Codec=Sse (Serialization based), see doc to use other codecs
2797    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2798        let mut tag_ = <i32>::sse_decode(deserializer);
2799        match tag_ {
2800            0 => {
2801                let mut var_paymentHash = <String>::sse_decode(deserializer);
2802                return crate::model::GetPaymentRequest::PaymentHash {
2803                    payment_hash: var_paymentHash,
2804                };
2805            }
2806            1 => {
2807                let mut var_swapId = <String>::sse_decode(deserializer);
2808                return crate::model::GetPaymentRequest::SwapId {
2809                    swap_id: var_swapId,
2810                };
2811            }
2812            _ => {
2813                unimplemented!("");
2814            }
2815        }
2816    }
2817}
2818
2819impl SseDecode for i32 {
2820    // Codec=Sse (Serialization based), see doc to use other codecs
2821    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2822        deserializer.cursor.read_i32::<NativeEndian>().unwrap()
2823    }
2824}
2825
2826impl SseDecode for i64 {
2827    // Codec=Sse (Serialization based), see doc to use other codecs
2828    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2829        deserializer.cursor.read_i64::<NativeEndian>().unwrap()
2830    }
2831}
2832
2833impl SseDecode for crate::bindings::InputType {
2834    // Codec=Sse (Serialization based), see doc to use other codecs
2835    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2836        let mut tag_ = <i32>::sse_decode(deserializer);
2837        match tag_ {
2838            0 => {
2839                let mut var_address =
2840                    <crate::bindings::BitcoinAddressData>::sse_decode(deserializer);
2841                return crate::bindings::InputType::BitcoinAddress {
2842                    address: var_address,
2843                };
2844            }
2845            1 => {
2846                let mut var_address =
2847                    <crate::bindings::LiquidAddressData>::sse_decode(deserializer);
2848                return crate::bindings::InputType::LiquidAddress {
2849                    address: var_address,
2850                };
2851            }
2852            2 => {
2853                let mut var_invoice = <crate::bindings::LNInvoice>::sse_decode(deserializer);
2854                return crate::bindings::InputType::Bolt11 {
2855                    invoice: var_invoice,
2856                };
2857            }
2858            3 => {
2859                let mut var_offer = <crate::bindings::LNOffer>::sse_decode(deserializer);
2860                let mut var_bip353Address = <Option<String>>::sse_decode(deserializer);
2861                return crate::bindings::InputType::Bolt12Offer {
2862                    offer: var_offer,
2863                    bip353_address: var_bip353Address,
2864                };
2865            }
2866            4 => {
2867                let mut var_nodeId = <String>::sse_decode(deserializer);
2868                return crate::bindings::InputType::NodeId {
2869                    node_id: var_nodeId,
2870                };
2871            }
2872            5 => {
2873                let mut var_url = <String>::sse_decode(deserializer);
2874                return crate::bindings::InputType::Url { url: var_url };
2875            }
2876            6 => {
2877                let mut var_data = <crate::bindings::LnUrlPayRequestData>::sse_decode(deserializer);
2878                let mut var_bip353Address = <Option<String>>::sse_decode(deserializer);
2879                return crate::bindings::InputType::LnUrlPay {
2880                    data: var_data,
2881                    bip353_address: var_bip353Address,
2882                };
2883            }
2884            7 => {
2885                let mut var_data =
2886                    <crate::bindings::LnUrlWithdrawRequestData>::sse_decode(deserializer);
2887                return crate::bindings::InputType::LnUrlWithdraw { data: var_data };
2888            }
2889            8 => {
2890                let mut var_data =
2891                    <crate::bindings::LnUrlAuthRequestData>::sse_decode(deserializer);
2892                return crate::bindings::InputType::LnUrlAuth { data: var_data };
2893            }
2894            9 => {
2895                let mut var_data = <crate::bindings::LnUrlErrorData>::sse_decode(deserializer);
2896                return crate::bindings::InputType::LnUrlError { data: var_data };
2897            }
2898            _ => {
2899                unimplemented!("");
2900            }
2901        }
2902    }
2903}
2904
2905impl SseDecode for crate::model::LightningPaymentLimitsResponse {
2906    // Codec=Sse (Serialization based), see doc to use other codecs
2907    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2908        let mut var_send = <crate::model::Limits>::sse_decode(deserializer);
2909        let mut var_receive = <crate::model::Limits>::sse_decode(deserializer);
2910        return crate::model::LightningPaymentLimitsResponse {
2911            send: var_send,
2912            receive: var_receive,
2913        };
2914    }
2915}
2916
2917impl SseDecode for crate::model::Limits {
2918    // Codec=Sse (Serialization based), see doc to use other codecs
2919    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2920        let mut var_minSat = <u64>::sse_decode(deserializer);
2921        let mut var_maxSat = <u64>::sse_decode(deserializer);
2922        let mut var_maxZeroConfSat = <u64>::sse_decode(deserializer);
2923        return crate::model::Limits {
2924            min_sat: var_minSat,
2925            max_sat: var_maxSat,
2926            max_zero_conf_sat: var_maxZeroConfSat,
2927        };
2928    }
2929}
2930
2931impl SseDecode for crate::bindings::LiquidAddressData {
2932    // Codec=Sse (Serialization based), see doc to use other codecs
2933    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2934        let mut var_address = <String>::sse_decode(deserializer);
2935        let mut var_network = <crate::bindings::Network>::sse_decode(deserializer);
2936        let mut var_assetId = <Option<String>>::sse_decode(deserializer);
2937        let mut var_amount = <Option<f64>>::sse_decode(deserializer);
2938        let mut var_amountSat = <Option<u64>>::sse_decode(deserializer);
2939        let mut var_label = <Option<String>>::sse_decode(deserializer);
2940        let mut var_message = <Option<String>>::sse_decode(deserializer);
2941        return crate::bindings::LiquidAddressData {
2942            address: var_address,
2943            network: var_network,
2944            asset_id: var_assetId,
2945            amount: var_amount,
2946            amount_sat: var_amountSat,
2947            label: var_label,
2948            message: var_message,
2949        };
2950    }
2951}
2952
2953impl SseDecode for crate::model::LiquidNetwork {
2954    // Codec=Sse (Serialization based), see doc to use other codecs
2955    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2956        let mut inner = <i32>::sse_decode(deserializer);
2957        return match inner {
2958            0 => crate::model::LiquidNetwork::Mainnet,
2959            1 => crate::model::LiquidNetwork::Testnet,
2960            2 => crate::model::LiquidNetwork::Regtest,
2961            _ => unreachable!("Invalid variant for LiquidNetwork: {}", inner),
2962        };
2963    }
2964}
2965
2966impl SseDecode for Vec<String> {
2967    // Codec=Sse (Serialization based), see doc to use other codecs
2968    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2969        let mut len_ = <i32>::sse_decode(deserializer);
2970        let mut ans_ = vec![];
2971        for idx_ in 0..len_ {
2972            ans_.push(<String>::sse_decode(deserializer));
2973        }
2974        return ans_;
2975    }
2976}
2977
2978impl SseDecode for Vec<crate::model::AssetBalance> {
2979    // Codec=Sse (Serialization based), see doc to use other codecs
2980    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2981        let mut len_ = <i32>::sse_decode(deserializer);
2982        let mut ans_ = vec![];
2983        for idx_ in 0..len_ {
2984            ans_.push(<crate::model::AssetBalance>::sse_decode(deserializer));
2985        }
2986        return ans_;
2987    }
2988}
2989
2990impl SseDecode for Vec<crate::model::AssetMetadata> {
2991    // Codec=Sse (Serialization based), see doc to use other codecs
2992    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2993        let mut len_ = <i32>::sse_decode(deserializer);
2994        let mut ans_ = vec![];
2995        for idx_ in 0..len_ {
2996            ans_.push(<crate::model::AssetMetadata>::sse_decode(deserializer));
2997        }
2998        return ans_;
2999    }
3000}
3001
3002impl SseDecode for Vec<crate::bindings::ExternalInputParser> {
3003    // Codec=Sse (Serialization based), see doc to use other codecs
3004    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3005        let mut len_ = <i32>::sse_decode(deserializer);
3006        let mut ans_ = vec![];
3007        for idx_ in 0..len_ {
3008            ans_.push(<crate::bindings::ExternalInputParser>::sse_decode(
3009                deserializer,
3010            ));
3011        }
3012        return ans_;
3013    }
3014}
3015
3016impl SseDecode for Vec<crate::bindings::FiatCurrency> {
3017    // Codec=Sse (Serialization based), see doc to use other codecs
3018    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3019        let mut len_ = <i32>::sse_decode(deserializer);
3020        let mut ans_ = vec![];
3021        for idx_ in 0..len_ {
3022            ans_.push(<crate::bindings::FiatCurrency>::sse_decode(deserializer));
3023        }
3024        return ans_;
3025    }
3026}
3027
3028impl SseDecode for Vec<crate::bindings::LnOfferBlindedPath> {
3029    // Codec=Sse (Serialization based), see doc to use other codecs
3030    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3031        let mut len_ = <i32>::sse_decode(deserializer);
3032        let mut ans_ = vec![];
3033        for idx_ in 0..len_ {
3034            ans_.push(<crate::bindings::LnOfferBlindedPath>::sse_decode(
3035                deserializer,
3036            ));
3037        }
3038        return ans_;
3039    }
3040}
3041
3042impl SseDecode for Vec<crate::bindings::LocaleOverrides> {
3043    // Codec=Sse (Serialization based), see doc to use other codecs
3044    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3045        let mut len_ = <i32>::sse_decode(deserializer);
3046        let mut ans_ = vec![];
3047        for idx_ in 0..len_ {
3048            ans_.push(<crate::bindings::LocaleOverrides>::sse_decode(deserializer));
3049        }
3050        return ans_;
3051    }
3052}
3053
3054impl SseDecode for Vec<crate::bindings::LocalizedName> {
3055    // Codec=Sse (Serialization based), see doc to use other codecs
3056    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3057        let mut len_ = <i32>::sse_decode(deserializer);
3058        let mut ans_ = vec![];
3059        for idx_ in 0..len_ {
3060            ans_.push(<crate::bindings::LocalizedName>::sse_decode(deserializer));
3061        }
3062        return ans_;
3063    }
3064}
3065
3066impl SseDecode for Vec<crate::model::Payment> {
3067    // Codec=Sse (Serialization based), see doc to use other codecs
3068    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3069        let mut len_ = <i32>::sse_decode(deserializer);
3070        let mut ans_ = vec![];
3071        for idx_ in 0..len_ {
3072            ans_.push(<crate::model::Payment>::sse_decode(deserializer));
3073        }
3074        return ans_;
3075    }
3076}
3077
3078impl SseDecode for crate::model::ListPaymentDetails {
3079    // Codec=Sse (Serialization based), see doc to use other codecs
3080    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3081        let mut tag_ = <i32>::sse_decode(deserializer);
3082        match tag_ {
3083            0 => {
3084                let mut var_assetId = <Option<String>>::sse_decode(deserializer);
3085                let mut var_destination = <Option<String>>::sse_decode(deserializer);
3086                return crate::model::ListPaymentDetails::Liquid {
3087                    asset_id: var_assetId,
3088                    destination: var_destination,
3089                };
3090            }
3091            1 => {
3092                let mut var_address = <Option<String>>::sse_decode(deserializer);
3093                return crate::model::ListPaymentDetails::Bitcoin {
3094                    address: var_address,
3095                };
3096            }
3097            _ => {
3098                unimplemented!("");
3099            }
3100        }
3101    }
3102}
3103
3104impl SseDecode for Vec<crate::model::PaymentState> {
3105    // Codec=Sse (Serialization based), see doc to use other codecs
3106    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3107        let mut len_ = <i32>::sse_decode(deserializer);
3108        let mut ans_ = vec![];
3109        for idx_ in 0..len_ {
3110            ans_.push(<crate::model::PaymentState>::sse_decode(deserializer));
3111        }
3112        return ans_;
3113    }
3114}
3115
3116impl SseDecode for Vec<crate::model::PaymentType> {
3117    // Codec=Sse (Serialization based), see doc to use other codecs
3118    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3119        let mut len_ = <i32>::sse_decode(deserializer);
3120        let mut ans_ = vec![];
3121        for idx_ in 0..len_ {
3122            ans_.push(<crate::model::PaymentType>::sse_decode(deserializer));
3123        }
3124        return ans_;
3125    }
3126}
3127
3128impl SseDecode for crate::model::ListPaymentsRequest {
3129    // Codec=Sse (Serialization based), see doc to use other codecs
3130    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3131        let mut var_filters = <Option<Vec<crate::model::PaymentType>>>::sse_decode(deserializer);
3132        let mut var_states = <Option<Vec<crate::model::PaymentState>>>::sse_decode(deserializer);
3133        let mut var_fromTimestamp = <Option<i64>>::sse_decode(deserializer);
3134        let mut var_toTimestamp = <Option<i64>>::sse_decode(deserializer);
3135        let mut var_offset = <Option<u32>>::sse_decode(deserializer);
3136        let mut var_limit = <Option<u32>>::sse_decode(deserializer);
3137        let mut var_details = <Option<crate::model::ListPaymentDetails>>::sse_decode(deserializer);
3138        let mut var_sortAscending = <Option<bool>>::sse_decode(deserializer);
3139        return crate::model::ListPaymentsRequest {
3140            filters: var_filters,
3141            states: var_states,
3142            from_timestamp: var_fromTimestamp,
3143            to_timestamp: var_toTimestamp,
3144            offset: var_offset,
3145            limit: var_limit,
3146            details: var_details,
3147            sort_ascending: var_sortAscending,
3148        };
3149    }
3150}
3151
3152impl SseDecode for Vec<u8> {
3153    // Codec=Sse (Serialization based), see doc to use other codecs
3154    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3155        let mut len_ = <i32>::sse_decode(deserializer);
3156        let mut ans_ = vec![];
3157        for idx_ in 0..len_ {
3158            ans_.push(<u8>::sse_decode(deserializer));
3159        }
3160        return ans_;
3161    }
3162}
3163
3164impl SseDecode for Vec<crate::bindings::Rate> {
3165    // Codec=Sse (Serialization based), see doc to use other codecs
3166    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3167        let mut len_ = <i32>::sse_decode(deserializer);
3168        let mut ans_ = vec![];
3169        for idx_ in 0..len_ {
3170            ans_.push(<crate::bindings::Rate>::sse_decode(deserializer));
3171        }
3172        return ans_;
3173    }
3174}
3175
3176impl SseDecode for Vec<crate::model::RefundableSwap> {
3177    // Codec=Sse (Serialization based), see doc to use other codecs
3178    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3179        let mut len_ = <i32>::sse_decode(deserializer);
3180        let mut ans_ = vec![];
3181        for idx_ in 0..len_ {
3182            ans_.push(<crate::model::RefundableSwap>::sse_decode(deserializer));
3183        }
3184        return ans_;
3185    }
3186}
3187
3188impl SseDecode for Vec<crate::bindings::RouteHint> {
3189    // Codec=Sse (Serialization based), see doc to use other codecs
3190    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3191        let mut len_ = <i32>::sse_decode(deserializer);
3192        let mut ans_ = vec![];
3193        for idx_ in 0..len_ {
3194            ans_.push(<crate::bindings::RouteHint>::sse_decode(deserializer));
3195        }
3196        return ans_;
3197    }
3198}
3199
3200impl SseDecode for Vec<crate::bindings::RouteHintHop> {
3201    // Codec=Sse (Serialization based), see doc to use other codecs
3202    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3203        let mut len_ = <i32>::sse_decode(deserializer);
3204        let mut ans_ = vec![];
3205        for idx_ in 0..len_ {
3206            ans_.push(<crate::bindings::RouteHintHop>::sse_decode(deserializer));
3207        }
3208        return ans_;
3209    }
3210}
3211
3212impl SseDecode for crate::bindings::LNInvoice {
3213    // Codec=Sse (Serialization based), see doc to use other codecs
3214    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3215        let mut var_bolt11 = <String>::sse_decode(deserializer);
3216        let mut var_network = <crate::bindings::Network>::sse_decode(deserializer);
3217        let mut var_payeePubkey = <String>::sse_decode(deserializer);
3218        let mut var_paymentHash = <String>::sse_decode(deserializer);
3219        let mut var_description = <Option<String>>::sse_decode(deserializer);
3220        let mut var_descriptionHash = <Option<String>>::sse_decode(deserializer);
3221        let mut var_amountMsat = <Option<u64>>::sse_decode(deserializer);
3222        let mut var_timestamp = <u64>::sse_decode(deserializer);
3223        let mut var_expiry = <u64>::sse_decode(deserializer);
3224        let mut var_routingHints = <Vec<crate::bindings::RouteHint>>::sse_decode(deserializer);
3225        let mut var_paymentSecret = <Vec<u8>>::sse_decode(deserializer);
3226        let mut var_minFinalCltvExpiryDelta = <u64>::sse_decode(deserializer);
3227        return crate::bindings::LNInvoice {
3228            bolt11: var_bolt11,
3229            network: var_network,
3230            payee_pubkey: var_payeePubkey,
3231            payment_hash: var_paymentHash,
3232            description: var_description,
3233            description_hash: var_descriptionHash,
3234            amount_msat: var_amountMsat,
3235            timestamp: var_timestamp,
3236            expiry: var_expiry,
3237            routing_hints: var_routingHints,
3238            payment_secret: var_paymentSecret,
3239            min_final_cltv_expiry_delta: var_minFinalCltvExpiryDelta,
3240        };
3241    }
3242}
3243
3244impl SseDecode for crate::bindings::LNOffer {
3245    // Codec=Sse (Serialization based), see doc to use other codecs
3246    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3247        let mut var_offer = <String>::sse_decode(deserializer);
3248        let mut var_chains = <Vec<String>>::sse_decode(deserializer);
3249        let mut var_minAmount = <Option<crate::bindings::Amount>>::sse_decode(deserializer);
3250        let mut var_description = <Option<String>>::sse_decode(deserializer);
3251        let mut var_absoluteExpiry = <Option<u64>>::sse_decode(deserializer);
3252        let mut var_issuer = <Option<String>>::sse_decode(deserializer);
3253        let mut var_signingPubkey = <Option<String>>::sse_decode(deserializer);
3254        let mut var_paths = <Vec<crate::bindings::LnOfferBlindedPath>>::sse_decode(deserializer);
3255        return crate::bindings::LNOffer {
3256            offer: var_offer,
3257            chains: var_chains,
3258            min_amount: var_minAmount,
3259            description: var_description,
3260            absolute_expiry: var_absoluteExpiry,
3261            issuer: var_issuer,
3262            signing_pubkey: var_signingPubkey,
3263            paths: var_paths,
3264        };
3265    }
3266}
3267
3268impl SseDecode for crate::bindings::LnOfferBlindedPath {
3269    // Codec=Sse (Serialization based), see doc to use other codecs
3270    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3271        let mut var_blindedHops = <Vec<String>>::sse_decode(deserializer);
3272        return crate::bindings::LnOfferBlindedPath {
3273            blinded_hops: var_blindedHops,
3274        };
3275    }
3276}
3277
3278impl SseDecode for crate::bindings::duplicates::LnUrlAuthError {
3279    // Codec=Sse (Serialization based), see doc to use other codecs
3280    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3281        let mut tag_ = <i32>::sse_decode(deserializer);
3282        match tag_ {
3283            0 => {
3284                let mut var_err = <String>::sse_decode(deserializer);
3285                return crate::bindings::duplicates::LnUrlAuthError::Generic { err: var_err };
3286            }
3287            1 => {
3288                let mut var_err = <String>::sse_decode(deserializer);
3289                return crate::bindings::duplicates::LnUrlAuthError::InvalidUri { err: var_err };
3290            }
3291            2 => {
3292                let mut var_err = <String>::sse_decode(deserializer);
3293                return crate::bindings::duplicates::LnUrlAuthError::ServiceConnectivity {
3294                    err: var_err,
3295                };
3296            }
3297            _ => {
3298                unimplemented!("");
3299            }
3300        }
3301    }
3302}
3303
3304impl SseDecode for crate::bindings::LnUrlAuthRequestData {
3305    // Codec=Sse (Serialization based), see doc to use other codecs
3306    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3307        let mut var_k1 = <String>::sse_decode(deserializer);
3308        let mut var_action = <Option<String>>::sse_decode(deserializer);
3309        let mut var_domain = <String>::sse_decode(deserializer);
3310        let mut var_url = <String>::sse_decode(deserializer);
3311        return crate::bindings::LnUrlAuthRequestData {
3312            k1: var_k1,
3313            action: var_action,
3314            domain: var_domain,
3315            url: var_url,
3316        };
3317    }
3318}
3319
3320impl SseDecode for crate::bindings::duplicates::LnUrlCallbackStatus {
3321    // Codec=Sse (Serialization based), see doc to use other codecs
3322    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3323        let mut tag_ = <i32>::sse_decode(deserializer);
3324        match tag_ {
3325            0 => {
3326                return crate::bindings::duplicates::LnUrlCallbackStatus::Ok;
3327            }
3328            1 => {
3329                let mut var_data = <crate::bindings::LnUrlErrorData>::sse_decode(deserializer);
3330                return crate::bindings::duplicates::LnUrlCallbackStatus::ErrorStatus {
3331                    data: var_data,
3332                };
3333            }
3334            _ => {
3335                unimplemented!("");
3336            }
3337        }
3338    }
3339}
3340
3341impl SseDecode for crate::bindings::LnUrlErrorData {
3342    // Codec=Sse (Serialization based), see doc to use other codecs
3343    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3344        let mut var_reason = <String>::sse_decode(deserializer);
3345        return crate::bindings::LnUrlErrorData { reason: var_reason };
3346    }
3347}
3348
3349impl SseDecode for crate::model::LnUrlInfo {
3350    // Codec=Sse (Serialization based), see doc to use other codecs
3351    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3352        let mut var_lnAddress = <Option<String>>::sse_decode(deserializer);
3353        let mut var_lnurlPayComment = <Option<String>>::sse_decode(deserializer);
3354        let mut var_lnurlPayDomain = <Option<String>>::sse_decode(deserializer);
3355        let mut var_lnurlPayMetadata = <Option<String>>::sse_decode(deserializer);
3356        let mut var_lnurlPaySuccessAction =
3357            <Option<crate::bindings::SuccessActionProcessed>>::sse_decode(deserializer);
3358        let mut var_lnurlPayUnprocessedSuccessAction =
3359            <Option<crate::bindings::SuccessAction>>::sse_decode(deserializer);
3360        let mut var_lnurlWithdrawEndpoint = <Option<String>>::sse_decode(deserializer);
3361        return crate::model::LnUrlInfo {
3362            ln_address: var_lnAddress,
3363            lnurl_pay_comment: var_lnurlPayComment,
3364            lnurl_pay_domain: var_lnurlPayDomain,
3365            lnurl_pay_metadata: var_lnurlPayMetadata,
3366            lnurl_pay_success_action: var_lnurlPaySuccessAction,
3367            lnurl_pay_unprocessed_success_action: var_lnurlPayUnprocessedSuccessAction,
3368            lnurl_withdraw_endpoint: var_lnurlWithdrawEndpoint,
3369        };
3370    }
3371}
3372
3373impl SseDecode for crate::bindings::duplicates::LnUrlPayError {
3374    // Codec=Sse (Serialization based), see doc to use other codecs
3375    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3376        let mut tag_ = <i32>::sse_decode(deserializer);
3377        match tag_ {
3378            0 => {
3379                return crate::bindings::duplicates::LnUrlPayError::AlreadyPaid;
3380            }
3381            1 => {
3382                let mut var_err = <String>::sse_decode(deserializer);
3383                return crate::bindings::duplicates::LnUrlPayError::Generic { err: var_err };
3384            }
3385            2 => {
3386                let mut var_err = <String>::sse_decode(deserializer);
3387                return crate::bindings::duplicates::LnUrlPayError::InsufficientBalance {
3388                    err: var_err,
3389                };
3390            }
3391            3 => {
3392                let mut var_err = <String>::sse_decode(deserializer);
3393                return crate::bindings::duplicates::LnUrlPayError::InvalidAmount { err: var_err };
3394            }
3395            4 => {
3396                let mut var_err = <String>::sse_decode(deserializer);
3397                return crate::bindings::duplicates::LnUrlPayError::InvalidInvoice { err: var_err };
3398            }
3399            5 => {
3400                let mut var_err = <String>::sse_decode(deserializer);
3401                return crate::bindings::duplicates::LnUrlPayError::InvalidNetwork { err: var_err };
3402            }
3403            6 => {
3404                let mut var_err = <String>::sse_decode(deserializer);
3405                return crate::bindings::duplicates::LnUrlPayError::InvalidUri { err: var_err };
3406            }
3407            7 => {
3408                let mut var_err = <String>::sse_decode(deserializer);
3409                return crate::bindings::duplicates::LnUrlPayError::InvoiceExpired { err: var_err };
3410            }
3411            8 => {
3412                let mut var_err = <String>::sse_decode(deserializer);
3413                return crate::bindings::duplicates::LnUrlPayError::PaymentFailed { err: var_err };
3414            }
3415            9 => {
3416                let mut var_err = <String>::sse_decode(deserializer);
3417                return crate::bindings::duplicates::LnUrlPayError::PaymentTimeout { err: var_err };
3418            }
3419            10 => {
3420                let mut var_err = <String>::sse_decode(deserializer);
3421                return crate::bindings::duplicates::LnUrlPayError::RouteNotFound { err: var_err };
3422            }
3423            11 => {
3424                let mut var_err = <String>::sse_decode(deserializer);
3425                return crate::bindings::duplicates::LnUrlPayError::RouteTooExpensive {
3426                    err: var_err,
3427                };
3428            }
3429            12 => {
3430                let mut var_err = <String>::sse_decode(deserializer);
3431                return crate::bindings::duplicates::LnUrlPayError::ServiceConnectivity {
3432                    err: var_err,
3433                };
3434            }
3435            _ => {
3436                unimplemented!("");
3437            }
3438        }
3439    }
3440}
3441
3442impl SseDecode for crate::bindings::LnUrlPayErrorData {
3443    // Codec=Sse (Serialization based), see doc to use other codecs
3444    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3445        let mut var_paymentHash = <String>::sse_decode(deserializer);
3446        let mut var_reason = <String>::sse_decode(deserializer);
3447        return crate::bindings::LnUrlPayErrorData {
3448            payment_hash: var_paymentHash,
3449            reason: var_reason,
3450        };
3451    }
3452}
3453
3454impl SseDecode for crate::model::LnUrlPayRequest {
3455    // Codec=Sse (Serialization based), see doc to use other codecs
3456    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3457        let mut var_prepareResponse =
3458            <crate::model::PrepareLnUrlPayResponse>::sse_decode(deserializer);
3459        return crate::model::LnUrlPayRequest {
3460            prepare_response: var_prepareResponse,
3461        };
3462    }
3463}
3464
3465impl SseDecode for crate::bindings::LnUrlPayRequestData {
3466    // Codec=Sse (Serialization based), see doc to use other codecs
3467    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3468        let mut var_callback = <String>::sse_decode(deserializer);
3469        let mut var_minSendable = <u64>::sse_decode(deserializer);
3470        let mut var_maxSendable = <u64>::sse_decode(deserializer);
3471        let mut var_metadataStr = <String>::sse_decode(deserializer);
3472        let mut var_commentAllowed = <u16>::sse_decode(deserializer);
3473        let mut var_domain = <String>::sse_decode(deserializer);
3474        let mut var_allowsNostr = <bool>::sse_decode(deserializer);
3475        let mut var_nostrPubkey = <Option<String>>::sse_decode(deserializer);
3476        let mut var_lnAddress = <Option<String>>::sse_decode(deserializer);
3477        return crate::bindings::LnUrlPayRequestData {
3478            callback: var_callback,
3479            min_sendable: var_minSendable,
3480            max_sendable: var_maxSendable,
3481            metadata_str: var_metadataStr,
3482            comment_allowed: var_commentAllowed,
3483            domain: var_domain,
3484            allows_nostr: var_allowsNostr,
3485            nostr_pubkey: var_nostrPubkey,
3486            ln_address: var_lnAddress,
3487        };
3488    }
3489}
3490
3491impl SseDecode for crate::model::LnUrlPayResult {
3492    // Codec=Sse (Serialization based), see doc to use other codecs
3493    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3494        let mut tag_ = <i32>::sse_decode(deserializer);
3495        match tag_ {
3496            0 => {
3497                let mut var_data = <crate::model::LnUrlPaySuccessData>::sse_decode(deserializer);
3498                return crate::model::LnUrlPayResult::EndpointSuccess { data: var_data };
3499            }
3500            1 => {
3501                let mut var_data = <crate::bindings::LnUrlErrorData>::sse_decode(deserializer);
3502                return crate::model::LnUrlPayResult::EndpointError { data: var_data };
3503            }
3504            2 => {
3505                let mut var_data = <crate::bindings::LnUrlPayErrorData>::sse_decode(deserializer);
3506                return crate::model::LnUrlPayResult::PayError { data: var_data };
3507            }
3508            _ => {
3509                unimplemented!("");
3510            }
3511        }
3512    }
3513}
3514
3515impl SseDecode for crate::model::LnUrlPaySuccessData {
3516    // Codec=Sse (Serialization based), see doc to use other codecs
3517    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3518        let mut var_payment = <crate::model::Payment>::sse_decode(deserializer);
3519        let mut var_successAction =
3520            <Option<crate::bindings::SuccessActionProcessed>>::sse_decode(deserializer);
3521        return crate::model::LnUrlPaySuccessData {
3522            payment: var_payment,
3523            success_action: var_successAction,
3524        };
3525    }
3526}
3527
3528impl SseDecode for crate::bindings::duplicates::LnUrlWithdrawError {
3529    // Codec=Sse (Serialization based), see doc to use other codecs
3530    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3531        let mut tag_ = <i32>::sse_decode(deserializer);
3532        match tag_ {
3533            0 => {
3534                let mut var_err = <String>::sse_decode(deserializer);
3535                return crate::bindings::duplicates::LnUrlWithdrawError::Generic { err: var_err };
3536            }
3537            1 => {
3538                let mut var_err = <String>::sse_decode(deserializer);
3539                return crate::bindings::duplicates::LnUrlWithdrawError::InvalidAmount {
3540                    err: var_err,
3541                };
3542            }
3543            2 => {
3544                let mut var_err = <String>::sse_decode(deserializer);
3545                return crate::bindings::duplicates::LnUrlWithdrawError::InvalidInvoice {
3546                    err: var_err,
3547                };
3548            }
3549            3 => {
3550                let mut var_err = <String>::sse_decode(deserializer);
3551                return crate::bindings::duplicates::LnUrlWithdrawError::InvalidUri {
3552                    err: var_err,
3553                };
3554            }
3555            4 => {
3556                let mut var_err = <String>::sse_decode(deserializer);
3557                return crate::bindings::duplicates::LnUrlWithdrawError::InvoiceNoRoutingHints {
3558                    err: var_err,
3559                };
3560            }
3561            5 => {
3562                let mut var_err = <String>::sse_decode(deserializer);
3563                return crate::bindings::duplicates::LnUrlWithdrawError::ServiceConnectivity {
3564                    err: var_err,
3565                };
3566            }
3567            _ => {
3568                unimplemented!("");
3569            }
3570        }
3571    }
3572}
3573
3574impl SseDecode for crate::bindings::LnUrlWithdrawRequest {
3575    // Codec=Sse (Serialization based), see doc to use other codecs
3576    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3577        let mut var_data = <crate::bindings::LnUrlWithdrawRequestData>::sse_decode(deserializer);
3578        let mut var_amountMsat = <u64>::sse_decode(deserializer);
3579        let mut var_description = <Option<String>>::sse_decode(deserializer);
3580        return crate::bindings::LnUrlWithdrawRequest {
3581            data: var_data,
3582            amount_msat: var_amountMsat,
3583            description: var_description,
3584        };
3585    }
3586}
3587
3588impl SseDecode for crate::bindings::LnUrlWithdrawRequestData {
3589    // Codec=Sse (Serialization based), see doc to use other codecs
3590    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3591        let mut var_callback = <String>::sse_decode(deserializer);
3592        let mut var_k1 = <String>::sse_decode(deserializer);
3593        let mut var_defaultDescription = <String>::sse_decode(deserializer);
3594        let mut var_minWithdrawable = <u64>::sse_decode(deserializer);
3595        let mut var_maxWithdrawable = <u64>::sse_decode(deserializer);
3596        return crate::bindings::LnUrlWithdrawRequestData {
3597            callback: var_callback,
3598            k1: var_k1,
3599            default_description: var_defaultDescription,
3600            min_withdrawable: var_minWithdrawable,
3601            max_withdrawable: var_maxWithdrawable,
3602        };
3603    }
3604}
3605
3606impl SseDecode for crate::bindings::duplicates::LnUrlWithdrawResult {
3607    // Codec=Sse (Serialization based), see doc to use other codecs
3608    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3609        let mut tag_ = <i32>::sse_decode(deserializer);
3610        match tag_ {
3611            0 => {
3612                let mut var_data =
3613                    <crate::bindings::duplicates::LnUrlWithdrawSuccessData>::sse_decode(
3614                        deserializer,
3615                    );
3616                return crate::bindings::duplicates::LnUrlWithdrawResult::Ok { data: var_data };
3617            }
3618            1 => {
3619                let mut var_data =
3620                    <crate::bindings::duplicates::LnUrlWithdrawSuccessData>::sse_decode(
3621                        deserializer,
3622                    );
3623                return crate::bindings::duplicates::LnUrlWithdrawResult::Timeout {
3624                    data: var_data,
3625                };
3626            }
3627            2 => {
3628                let mut var_data = <crate::bindings::LnUrlErrorData>::sse_decode(deserializer);
3629                return crate::bindings::duplicates::LnUrlWithdrawResult::ErrorStatus {
3630                    data: var_data,
3631                };
3632            }
3633            _ => {
3634                unimplemented!("");
3635            }
3636        }
3637    }
3638}
3639
3640impl SseDecode for crate::bindings::duplicates::LnUrlWithdrawSuccessData {
3641    // Codec=Sse (Serialization based), see doc to use other codecs
3642    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3643        let mut var_invoice = <crate::bindings::LNInvoice>::sse_decode(deserializer);
3644        return crate::bindings::duplicates::LnUrlWithdrawSuccessData {
3645            invoice: var_invoice,
3646        };
3647    }
3648}
3649
3650impl SseDecode for crate::bindings::LocaleOverrides {
3651    // Codec=Sse (Serialization based), see doc to use other codecs
3652    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3653        let mut var_locale = <String>::sse_decode(deserializer);
3654        let mut var_spacing = <Option<u32>>::sse_decode(deserializer);
3655        let mut var_symbol = <crate::bindings::Symbol>::sse_decode(deserializer);
3656        return crate::bindings::LocaleOverrides {
3657            locale: var_locale,
3658            spacing: var_spacing,
3659            symbol: var_symbol,
3660        };
3661    }
3662}
3663
3664impl SseDecode for crate::bindings::LocalizedName {
3665    // Codec=Sse (Serialization based), see doc to use other codecs
3666    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3667        let mut var_locale = <String>::sse_decode(deserializer);
3668        let mut var_name = <String>::sse_decode(deserializer);
3669        return crate::bindings::LocalizedName {
3670            locale: var_locale,
3671            name: var_name,
3672        };
3673    }
3674}
3675
3676impl SseDecode for crate::model::LogEntry {
3677    // Codec=Sse (Serialization based), see doc to use other codecs
3678    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3679        let mut var_line = <String>::sse_decode(deserializer);
3680        let mut var_level = <String>::sse_decode(deserializer);
3681        return crate::model::LogEntry {
3682            line: var_line,
3683            level: var_level,
3684        };
3685    }
3686}
3687
3688impl SseDecode for crate::bindings::MessageSuccessActionData {
3689    // Codec=Sse (Serialization based), see doc to use other codecs
3690    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3691        let mut var_message = <String>::sse_decode(deserializer);
3692        return crate::bindings::MessageSuccessActionData {
3693            message: var_message,
3694        };
3695    }
3696}
3697
3698impl SseDecode for crate::bindings::Network {
3699    // Codec=Sse (Serialization based), see doc to use other codecs
3700    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3701        let mut inner = <i32>::sse_decode(deserializer);
3702        return match inner {
3703            0 => crate::bindings::Network::Bitcoin,
3704            1 => crate::bindings::Network::Testnet,
3705            2 => crate::bindings::Network::Signet,
3706            3 => crate::bindings::Network::Regtest,
3707            _ => unreachable!("Invalid variant for Network: {}", inner),
3708        };
3709    }
3710}
3711
3712impl SseDecode for crate::model::OnchainPaymentLimitsResponse {
3713    // Codec=Sse (Serialization based), see doc to use other codecs
3714    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3715        let mut var_send = <crate::model::Limits>::sse_decode(deserializer);
3716        let mut var_receive = <crate::model::Limits>::sse_decode(deserializer);
3717        return crate::model::OnchainPaymentLimitsResponse {
3718            send: var_send,
3719            receive: var_receive,
3720        };
3721    }
3722}
3723
3724impl SseDecode for Option<String> {
3725    // Codec=Sse (Serialization based), see doc to use other codecs
3726    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3727        if (<bool>::sse_decode(deserializer)) {
3728            return Some(<String>::sse_decode(deserializer));
3729        } else {
3730            return None;
3731        }
3732    }
3733}
3734
3735impl SseDecode for Option<crate::bindings::Amount> {
3736    // Codec=Sse (Serialization based), see doc to use other codecs
3737    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3738        if (<bool>::sse_decode(deserializer)) {
3739            return Some(<crate::bindings::Amount>::sse_decode(deserializer));
3740        } else {
3741            return None;
3742        }
3743    }
3744}
3745
3746impl SseDecode for Option<crate::model::AssetInfo> {
3747    // Codec=Sse (Serialization based), see doc to use other codecs
3748    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3749        if (<bool>::sse_decode(deserializer)) {
3750            return Some(<crate::model::AssetInfo>::sse_decode(deserializer));
3751        } else {
3752            return None;
3753        }
3754    }
3755}
3756
3757impl SseDecode for Option<bool> {
3758    // Codec=Sse (Serialization based), see doc to use other codecs
3759    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3760        if (<bool>::sse_decode(deserializer)) {
3761            return Some(<bool>::sse_decode(deserializer));
3762        } else {
3763            return None;
3764        }
3765    }
3766}
3767
3768impl SseDecode for Option<f64> {
3769    // Codec=Sse (Serialization based), see doc to use other codecs
3770    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3771        if (<bool>::sse_decode(deserializer)) {
3772            return Some(<f64>::sse_decode(deserializer));
3773        } else {
3774            return None;
3775        }
3776    }
3777}
3778
3779impl SseDecode for Option<i64> {
3780    // Codec=Sse (Serialization based), see doc to use other codecs
3781    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3782        if (<bool>::sse_decode(deserializer)) {
3783            return Some(<i64>::sse_decode(deserializer));
3784        } else {
3785            return None;
3786        }
3787    }
3788}
3789
3790impl SseDecode for Option<crate::model::ListPaymentDetails> {
3791    // Codec=Sse (Serialization based), see doc to use other codecs
3792    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3793        if (<bool>::sse_decode(deserializer)) {
3794            return Some(<crate::model::ListPaymentDetails>::sse_decode(deserializer));
3795        } else {
3796            return None;
3797        }
3798    }
3799}
3800
3801impl SseDecode for Option<crate::model::LnUrlInfo> {
3802    // Codec=Sse (Serialization based), see doc to use other codecs
3803    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3804        if (<bool>::sse_decode(deserializer)) {
3805            return Some(<crate::model::LnUrlInfo>::sse_decode(deserializer));
3806        } else {
3807            return None;
3808        }
3809    }
3810}
3811
3812impl SseDecode for Option<crate::model::PayAmount> {
3813    // Codec=Sse (Serialization based), see doc to use other codecs
3814    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3815        if (<bool>::sse_decode(deserializer)) {
3816            return Some(<crate::model::PayAmount>::sse_decode(deserializer));
3817        } else {
3818            return None;
3819        }
3820    }
3821}
3822
3823impl SseDecode for Option<crate::model::Payment> {
3824    // Codec=Sse (Serialization based), see doc to use other codecs
3825    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3826        if (<bool>::sse_decode(deserializer)) {
3827            return Some(<crate::model::Payment>::sse_decode(deserializer));
3828        } else {
3829            return None;
3830        }
3831    }
3832}
3833
3834impl SseDecode for Option<crate::model::ReceiveAmount> {
3835    // Codec=Sse (Serialization based), see doc to use other codecs
3836    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3837        if (<bool>::sse_decode(deserializer)) {
3838            return Some(<crate::model::ReceiveAmount>::sse_decode(deserializer));
3839        } else {
3840            return None;
3841        }
3842    }
3843}
3844
3845impl SseDecode for Option<crate::bindings::SuccessAction> {
3846    // Codec=Sse (Serialization based), see doc to use other codecs
3847    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3848        if (<bool>::sse_decode(deserializer)) {
3849            return Some(<crate::bindings::SuccessAction>::sse_decode(deserializer));
3850        } else {
3851            return None;
3852        }
3853    }
3854}
3855
3856impl SseDecode for Option<crate::bindings::SuccessActionProcessed> {
3857    // Codec=Sse (Serialization based), see doc to use other codecs
3858    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3859        if (<bool>::sse_decode(deserializer)) {
3860            return Some(<crate::bindings::SuccessActionProcessed>::sse_decode(
3861                deserializer,
3862            ));
3863        } else {
3864            return None;
3865        }
3866    }
3867}
3868
3869impl SseDecode for Option<crate::bindings::Symbol> {
3870    // Codec=Sse (Serialization based), see doc to use other codecs
3871    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3872        if (<bool>::sse_decode(deserializer)) {
3873            return Some(<crate::bindings::Symbol>::sse_decode(deserializer));
3874        } else {
3875            return None;
3876        }
3877    }
3878}
3879
3880impl SseDecode for Option<u32> {
3881    // Codec=Sse (Serialization based), see doc to use other codecs
3882    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3883        if (<bool>::sse_decode(deserializer)) {
3884            return Some(<u32>::sse_decode(deserializer));
3885        } else {
3886            return None;
3887        }
3888    }
3889}
3890
3891impl SseDecode for Option<u64> {
3892    // Codec=Sse (Serialization based), see doc to use other codecs
3893    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3894        if (<bool>::sse_decode(deserializer)) {
3895            return Some(<u64>::sse_decode(deserializer));
3896        } else {
3897            return None;
3898        }
3899    }
3900}
3901
3902impl SseDecode for Option<Vec<crate::model::AssetMetadata>> {
3903    // Codec=Sse (Serialization based), see doc to use other codecs
3904    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3905        if (<bool>::sse_decode(deserializer)) {
3906            return Some(<Vec<crate::model::AssetMetadata>>::sse_decode(deserializer));
3907        } else {
3908            return None;
3909        }
3910    }
3911}
3912
3913impl SseDecode for Option<Vec<crate::bindings::ExternalInputParser>> {
3914    // Codec=Sse (Serialization based), see doc to use other codecs
3915    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3916        if (<bool>::sse_decode(deserializer)) {
3917            return Some(<Vec<crate::bindings::ExternalInputParser>>::sse_decode(
3918                deserializer,
3919            ));
3920        } else {
3921            return None;
3922        }
3923    }
3924}
3925
3926impl SseDecode for Option<Vec<crate::model::PaymentState>> {
3927    // Codec=Sse (Serialization based), see doc to use other codecs
3928    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3929        if (<bool>::sse_decode(deserializer)) {
3930            return Some(<Vec<crate::model::PaymentState>>::sse_decode(deserializer));
3931        } else {
3932            return None;
3933        }
3934    }
3935}
3936
3937impl SseDecode for Option<Vec<crate::model::PaymentType>> {
3938    // Codec=Sse (Serialization based), see doc to use other codecs
3939    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3940        if (<bool>::sse_decode(deserializer)) {
3941            return Some(<Vec<crate::model::PaymentType>>::sse_decode(deserializer));
3942        } else {
3943            return None;
3944        }
3945    }
3946}
3947
3948impl SseDecode for Option<Vec<u8>> {
3949    // Codec=Sse (Serialization based), see doc to use other codecs
3950    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3951        if (<bool>::sse_decode(deserializer)) {
3952            return Some(<Vec<u8>>::sse_decode(deserializer));
3953        } else {
3954            return None;
3955        }
3956    }
3957}
3958
3959impl SseDecode for crate::model::PayAmount {
3960    // Codec=Sse (Serialization based), see doc to use other codecs
3961    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3962        let mut tag_ = <i32>::sse_decode(deserializer);
3963        match tag_ {
3964            0 => {
3965                let mut var_receiverAmountSat = <u64>::sse_decode(deserializer);
3966                return crate::model::PayAmount::Bitcoin {
3967                    receiver_amount_sat: var_receiverAmountSat,
3968                };
3969            }
3970            1 => {
3971                let mut var_assetId = <String>::sse_decode(deserializer);
3972                let mut var_receiverAmount = <f64>::sse_decode(deserializer);
3973                let mut var_estimateAssetFees = <Option<bool>>::sse_decode(deserializer);
3974                return crate::model::PayAmount::Asset {
3975                    asset_id: var_assetId,
3976                    receiver_amount: var_receiverAmount,
3977                    estimate_asset_fees: var_estimateAssetFees,
3978                };
3979            }
3980            2 => {
3981                return crate::model::PayAmount::Drain;
3982            }
3983            _ => {
3984                unimplemented!("");
3985            }
3986        }
3987    }
3988}
3989
3990impl SseDecode for crate::model::PayOnchainRequest {
3991    // Codec=Sse (Serialization based), see doc to use other codecs
3992    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3993        let mut var_address = <String>::sse_decode(deserializer);
3994        let mut var_prepareResponse =
3995            <crate::model::PreparePayOnchainResponse>::sse_decode(deserializer);
3996        return crate::model::PayOnchainRequest {
3997            address: var_address,
3998            prepare_response: var_prepareResponse,
3999        };
4000    }
4001}
4002
4003impl SseDecode for crate::model::Payment {
4004    // Codec=Sse (Serialization based), see doc to use other codecs
4005    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4006        let mut var_destination = <Option<String>>::sse_decode(deserializer);
4007        let mut var_txId = <Option<String>>::sse_decode(deserializer);
4008        let mut var_unblindingData = <Option<String>>::sse_decode(deserializer);
4009        let mut var_timestamp = <u32>::sse_decode(deserializer);
4010        let mut var_amountSat = <u64>::sse_decode(deserializer);
4011        let mut var_feesSat = <u64>::sse_decode(deserializer);
4012        let mut var_swapperFeesSat = <Option<u64>>::sse_decode(deserializer);
4013        let mut var_paymentType = <crate::model::PaymentType>::sse_decode(deserializer);
4014        let mut var_status = <crate::model::PaymentState>::sse_decode(deserializer);
4015        let mut var_details = <crate::model::PaymentDetails>::sse_decode(deserializer);
4016        return crate::model::Payment {
4017            destination: var_destination,
4018            tx_id: var_txId,
4019            unblinding_data: var_unblindingData,
4020            timestamp: var_timestamp,
4021            amount_sat: var_amountSat,
4022            fees_sat: var_feesSat,
4023            swapper_fees_sat: var_swapperFeesSat,
4024            payment_type: var_paymentType,
4025            status: var_status,
4026            details: var_details,
4027        };
4028    }
4029}
4030
4031impl SseDecode for crate::model::PaymentDetails {
4032    // Codec=Sse (Serialization based), see doc to use other codecs
4033    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4034        let mut tag_ = <i32>::sse_decode(deserializer);
4035        match tag_ {
4036            0 => {
4037                let mut var_swapId = <String>::sse_decode(deserializer);
4038                let mut var_description = <String>::sse_decode(deserializer);
4039                let mut var_liquidExpirationBlockheight = <u32>::sse_decode(deserializer);
4040                let mut var_preimage = <Option<String>>::sse_decode(deserializer);
4041                let mut var_invoice = <Option<String>>::sse_decode(deserializer);
4042                let mut var_bolt12Offer = <Option<String>>::sse_decode(deserializer);
4043                let mut var_paymentHash = <Option<String>>::sse_decode(deserializer);
4044                let mut var_destinationPubkey = <Option<String>>::sse_decode(deserializer);
4045                let mut var_lnurlInfo = <Option<crate::model::LnUrlInfo>>::sse_decode(deserializer);
4046                let mut var_bip353Address = <Option<String>>::sse_decode(deserializer);
4047                let mut var_claimTxId = <Option<String>>::sse_decode(deserializer);
4048                let mut var_refundTxId = <Option<String>>::sse_decode(deserializer);
4049                let mut var_refundTxAmountSat = <Option<u64>>::sse_decode(deserializer);
4050                return crate::model::PaymentDetails::Lightning {
4051                    swap_id: var_swapId,
4052                    description: var_description,
4053                    liquid_expiration_blockheight: var_liquidExpirationBlockheight,
4054                    preimage: var_preimage,
4055                    invoice: var_invoice,
4056                    bolt12_offer: var_bolt12Offer,
4057                    payment_hash: var_paymentHash,
4058                    destination_pubkey: var_destinationPubkey,
4059                    lnurl_info: var_lnurlInfo,
4060                    bip353_address: var_bip353Address,
4061                    claim_tx_id: var_claimTxId,
4062                    refund_tx_id: var_refundTxId,
4063                    refund_tx_amount_sat: var_refundTxAmountSat,
4064                };
4065            }
4066            1 => {
4067                let mut var_destination = <String>::sse_decode(deserializer);
4068                let mut var_description = <String>::sse_decode(deserializer);
4069                let mut var_assetId = <String>::sse_decode(deserializer);
4070                let mut var_assetInfo = <Option<crate::model::AssetInfo>>::sse_decode(deserializer);
4071                let mut var_lnurlInfo = <Option<crate::model::LnUrlInfo>>::sse_decode(deserializer);
4072                let mut var_bip353Address = <Option<String>>::sse_decode(deserializer);
4073                return crate::model::PaymentDetails::Liquid {
4074                    destination: var_destination,
4075                    description: var_description,
4076                    asset_id: var_assetId,
4077                    asset_info: var_assetInfo,
4078                    lnurl_info: var_lnurlInfo,
4079                    bip353_address: var_bip353Address,
4080                };
4081            }
4082            2 => {
4083                let mut var_swapId = <String>::sse_decode(deserializer);
4084                let mut var_description = <String>::sse_decode(deserializer);
4085                let mut var_autoAcceptedFees = <bool>::sse_decode(deserializer);
4086                let mut var_liquidExpirationBlockheight = <Option<u32>>::sse_decode(deserializer);
4087                let mut var_bitcoinExpirationBlockheight = <Option<u32>>::sse_decode(deserializer);
4088                let mut var_lockupTxId = <Option<String>>::sse_decode(deserializer);
4089                let mut var_claimTxId = <Option<String>>::sse_decode(deserializer);
4090                let mut var_refundTxId = <Option<String>>::sse_decode(deserializer);
4091                let mut var_refundTxAmountSat = <Option<u64>>::sse_decode(deserializer);
4092                return crate::model::PaymentDetails::Bitcoin {
4093                    swap_id: var_swapId,
4094                    description: var_description,
4095                    auto_accepted_fees: var_autoAcceptedFees,
4096                    liquid_expiration_blockheight: var_liquidExpirationBlockheight,
4097                    bitcoin_expiration_blockheight: var_bitcoinExpirationBlockheight,
4098                    lockup_tx_id: var_lockupTxId,
4099                    claim_tx_id: var_claimTxId,
4100                    refund_tx_id: var_refundTxId,
4101                    refund_tx_amount_sat: var_refundTxAmountSat,
4102                };
4103            }
4104            _ => {
4105                unimplemented!("");
4106            }
4107        }
4108    }
4109}
4110
4111impl SseDecode for crate::error::PaymentError {
4112    // Codec=Sse (Serialization based), see doc to use other codecs
4113    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4114        let mut tag_ = <i32>::sse_decode(deserializer);
4115        match tag_ {
4116            0 => {
4117                return crate::error::PaymentError::AlreadyClaimed;
4118            }
4119            1 => {
4120                return crate::error::PaymentError::AlreadyPaid;
4121            }
4122            2 => {
4123                return crate::error::PaymentError::PaymentInProgress;
4124            }
4125            3 => {
4126                let mut var_min = <u64>::sse_decode(deserializer);
4127                let mut var_max = <u64>::sse_decode(deserializer);
4128                return crate::error::PaymentError::AmountOutOfRange {
4129                    min: var_min,
4130                    max: var_max,
4131                };
4132            }
4133            4 => {
4134                let mut var_err = <String>::sse_decode(deserializer);
4135                return crate::error::PaymentError::AmountMissing { err: var_err };
4136            }
4137            5 => {
4138                let mut var_err = <String>::sse_decode(deserializer);
4139                return crate::error::PaymentError::AssetError { err: var_err };
4140            }
4141            6 => {
4142                let mut var_err = <String>::sse_decode(deserializer);
4143                return crate::error::PaymentError::InvalidNetwork { err: var_err };
4144            }
4145            7 => {
4146                let mut var_err = <String>::sse_decode(deserializer);
4147                return crate::error::PaymentError::Generic { err: var_err };
4148            }
4149            8 => {
4150                return crate::error::PaymentError::InvalidOrExpiredFees;
4151            }
4152            9 => {
4153                return crate::error::PaymentError::InsufficientFunds;
4154            }
4155            10 => {
4156                let mut var_err = <String>::sse_decode(deserializer);
4157                return crate::error::PaymentError::InvalidDescription { err: var_err };
4158            }
4159            11 => {
4160                let mut var_err = <String>::sse_decode(deserializer);
4161                return crate::error::PaymentError::InvalidInvoice { err: var_err };
4162            }
4163            12 => {
4164                return crate::error::PaymentError::InvalidPreimage;
4165            }
4166            13 => {
4167                return crate::error::PaymentError::PairsNotFound;
4168            }
4169            14 => {
4170                return crate::error::PaymentError::PaymentTimeout;
4171            }
4172            15 => {
4173                return crate::error::PaymentError::PersistError;
4174            }
4175            16 => {
4176                let mut var_err = <String>::sse_decode(deserializer);
4177                return crate::error::PaymentError::ReceiveError { err: var_err };
4178            }
4179            17 => {
4180                let mut var_err = <String>::sse_decode(deserializer);
4181                let mut var_refundTxId = <String>::sse_decode(deserializer);
4182                return crate::error::PaymentError::Refunded {
4183                    err: var_err,
4184                    refund_tx_id: var_refundTxId,
4185                };
4186            }
4187            18 => {
4188                return crate::error::PaymentError::SelfTransferNotSupported;
4189            }
4190            19 => {
4191                let mut var_err = <String>::sse_decode(deserializer);
4192                return crate::error::PaymentError::SendError { err: var_err };
4193            }
4194            20 => {
4195                let mut var_err = <String>::sse_decode(deserializer);
4196                return crate::error::PaymentError::SignerError { err: var_err };
4197            }
4198            _ => {
4199                unimplemented!("");
4200            }
4201        }
4202    }
4203}
4204
4205impl SseDecode for crate::model::PaymentMethod {
4206    // Codec=Sse (Serialization based), see doc to use other codecs
4207    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4208        let mut inner = <i32>::sse_decode(deserializer);
4209        return match inner {
4210            0 => crate::model::PaymentMethod::Lightning,
4211            1 => crate::model::PaymentMethod::Bolt11Invoice,
4212            2 => crate::model::PaymentMethod::Bolt12Offer,
4213            3 => crate::model::PaymentMethod::BitcoinAddress,
4214            4 => crate::model::PaymentMethod::LiquidAddress,
4215            _ => unreachable!("Invalid variant for PaymentMethod: {}", inner),
4216        };
4217    }
4218}
4219
4220impl SseDecode for crate::model::PaymentState {
4221    // Codec=Sse (Serialization based), see doc to use other codecs
4222    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4223        let mut inner = <i32>::sse_decode(deserializer);
4224        return match inner {
4225            0 => crate::model::PaymentState::Created,
4226            1 => crate::model::PaymentState::Pending,
4227            2 => crate::model::PaymentState::Complete,
4228            3 => crate::model::PaymentState::Failed,
4229            4 => crate::model::PaymentState::TimedOut,
4230            5 => crate::model::PaymentState::Refundable,
4231            6 => crate::model::PaymentState::RefundPending,
4232            7 => crate::model::PaymentState::WaitingFeeAcceptance,
4233            _ => unreachable!("Invalid variant for PaymentState: {}", inner),
4234        };
4235    }
4236}
4237
4238impl SseDecode for crate::model::PaymentType {
4239    // Codec=Sse (Serialization based), see doc to use other codecs
4240    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4241        let mut inner = <i32>::sse_decode(deserializer);
4242        return match inner {
4243            0 => crate::model::PaymentType::Receive,
4244            1 => crate::model::PaymentType::Send,
4245            _ => unreachable!("Invalid variant for PaymentType: {}", inner),
4246        };
4247    }
4248}
4249
4250impl SseDecode for crate::model::PrepareBuyBitcoinRequest {
4251    // Codec=Sse (Serialization based), see doc to use other codecs
4252    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4253        let mut var_provider = <crate::model::BuyBitcoinProvider>::sse_decode(deserializer);
4254        let mut var_amountSat = <u64>::sse_decode(deserializer);
4255        return crate::model::PrepareBuyBitcoinRequest {
4256            provider: var_provider,
4257            amount_sat: var_amountSat,
4258        };
4259    }
4260}
4261
4262impl SseDecode for crate::model::PrepareBuyBitcoinResponse {
4263    // Codec=Sse (Serialization based), see doc to use other codecs
4264    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4265        let mut var_provider = <crate::model::BuyBitcoinProvider>::sse_decode(deserializer);
4266        let mut var_amountSat = <u64>::sse_decode(deserializer);
4267        let mut var_feesSat = <u64>::sse_decode(deserializer);
4268        return crate::model::PrepareBuyBitcoinResponse {
4269            provider: var_provider,
4270            amount_sat: var_amountSat,
4271            fees_sat: var_feesSat,
4272        };
4273    }
4274}
4275
4276impl SseDecode for crate::model::PrepareLnUrlPayRequest {
4277    // Codec=Sse (Serialization based), see doc to use other codecs
4278    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4279        let mut var_data = <crate::bindings::LnUrlPayRequestData>::sse_decode(deserializer);
4280        let mut var_amount = <crate::model::PayAmount>::sse_decode(deserializer);
4281        let mut var_bip353Address = <Option<String>>::sse_decode(deserializer);
4282        let mut var_comment = <Option<String>>::sse_decode(deserializer);
4283        let mut var_validateSuccessActionUrl = <Option<bool>>::sse_decode(deserializer);
4284        return crate::model::PrepareLnUrlPayRequest {
4285            data: var_data,
4286            amount: var_amount,
4287            bip353_address: var_bip353Address,
4288            comment: var_comment,
4289            validate_success_action_url: var_validateSuccessActionUrl,
4290        };
4291    }
4292}
4293
4294impl SseDecode for crate::model::PrepareLnUrlPayResponse {
4295    // Codec=Sse (Serialization based), see doc to use other codecs
4296    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4297        let mut var_destination = <crate::model::SendDestination>::sse_decode(deserializer);
4298        let mut var_feesSat = <u64>::sse_decode(deserializer);
4299        let mut var_data = <crate::bindings::LnUrlPayRequestData>::sse_decode(deserializer);
4300        let mut var_amount = <crate::model::PayAmount>::sse_decode(deserializer);
4301        let mut var_comment = <Option<String>>::sse_decode(deserializer);
4302        let mut var_successAction =
4303            <Option<crate::bindings::SuccessAction>>::sse_decode(deserializer);
4304        return crate::model::PrepareLnUrlPayResponse {
4305            destination: var_destination,
4306            fees_sat: var_feesSat,
4307            data: var_data,
4308            amount: var_amount,
4309            comment: var_comment,
4310            success_action: var_successAction,
4311        };
4312    }
4313}
4314
4315impl SseDecode for crate::model::PreparePayOnchainRequest {
4316    // Codec=Sse (Serialization based), see doc to use other codecs
4317    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4318        let mut var_amount = <crate::model::PayAmount>::sse_decode(deserializer);
4319        let mut var_feeRateSatPerVbyte = <Option<u32>>::sse_decode(deserializer);
4320        return crate::model::PreparePayOnchainRequest {
4321            amount: var_amount,
4322            fee_rate_sat_per_vbyte: var_feeRateSatPerVbyte,
4323        };
4324    }
4325}
4326
4327impl SseDecode for crate::model::PreparePayOnchainResponse {
4328    // Codec=Sse (Serialization based), see doc to use other codecs
4329    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4330        let mut var_receiverAmountSat = <u64>::sse_decode(deserializer);
4331        let mut var_claimFeesSat = <u64>::sse_decode(deserializer);
4332        let mut var_totalFeesSat = <u64>::sse_decode(deserializer);
4333        return crate::model::PreparePayOnchainResponse {
4334            receiver_amount_sat: var_receiverAmountSat,
4335            claim_fees_sat: var_claimFeesSat,
4336            total_fees_sat: var_totalFeesSat,
4337        };
4338    }
4339}
4340
4341impl SseDecode for crate::model::PrepareReceiveRequest {
4342    // Codec=Sse (Serialization based), see doc to use other codecs
4343    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4344        let mut var_paymentMethod = <crate::model::PaymentMethod>::sse_decode(deserializer);
4345        let mut var_amount = <Option<crate::model::ReceiveAmount>>::sse_decode(deserializer);
4346        return crate::model::PrepareReceiveRequest {
4347            payment_method: var_paymentMethod,
4348            amount: var_amount,
4349        };
4350    }
4351}
4352
4353impl SseDecode for crate::model::PrepareReceiveResponse {
4354    // Codec=Sse (Serialization based), see doc to use other codecs
4355    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4356        let mut var_paymentMethod = <crate::model::PaymentMethod>::sse_decode(deserializer);
4357        let mut var_feesSat = <u64>::sse_decode(deserializer);
4358        let mut var_amount = <Option<crate::model::ReceiveAmount>>::sse_decode(deserializer);
4359        let mut var_minPayerAmountSat = <Option<u64>>::sse_decode(deserializer);
4360        let mut var_maxPayerAmountSat = <Option<u64>>::sse_decode(deserializer);
4361        let mut var_swapperFeerate = <Option<f64>>::sse_decode(deserializer);
4362        return crate::model::PrepareReceiveResponse {
4363            payment_method: var_paymentMethod,
4364            fees_sat: var_feesSat,
4365            amount: var_amount,
4366            min_payer_amount_sat: var_minPayerAmountSat,
4367            max_payer_amount_sat: var_maxPayerAmountSat,
4368            swapper_feerate: var_swapperFeerate,
4369        };
4370    }
4371}
4372
4373impl SseDecode for crate::model::PrepareRefundRequest {
4374    // Codec=Sse (Serialization based), see doc to use other codecs
4375    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4376        let mut var_swapAddress = <String>::sse_decode(deserializer);
4377        let mut var_refundAddress = <String>::sse_decode(deserializer);
4378        let mut var_feeRateSatPerVbyte = <u32>::sse_decode(deserializer);
4379        return crate::model::PrepareRefundRequest {
4380            swap_address: var_swapAddress,
4381            refund_address: var_refundAddress,
4382            fee_rate_sat_per_vbyte: var_feeRateSatPerVbyte,
4383        };
4384    }
4385}
4386
4387impl SseDecode for crate::model::PrepareRefundResponse {
4388    // Codec=Sse (Serialization based), see doc to use other codecs
4389    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4390        let mut var_txVsize = <u32>::sse_decode(deserializer);
4391        let mut var_txFeeSat = <u64>::sse_decode(deserializer);
4392        let mut var_lastRefundTxId = <Option<String>>::sse_decode(deserializer);
4393        return crate::model::PrepareRefundResponse {
4394            tx_vsize: var_txVsize,
4395            tx_fee_sat: var_txFeeSat,
4396            last_refund_tx_id: var_lastRefundTxId,
4397        };
4398    }
4399}
4400
4401impl SseDecode for crate::model::PrepareSendRequest {
4402    // Codec=Sse (Serialization based), see doc to use other codecs
4403    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4404        let mut var_destination = <String>::sse_decode(deserializer);
4405        let mut var_amount = <Option<crate::model::PayAmount>>::sse_decode(deserializer);
4406        return crate::model::PrepareSendRequest {
4407            destination: var_destination,
4408            amount: var_amount,
4409        };
4410    }
4411}
4412
4413impl SseDecode for crate::model::PrepareSendResponse {
4414    // Codec=Sse (Serialization based), see doc to use other codecs
4415    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4416        let mut var_destination = <crate::model::SendDestination>::sse_decode(deserializer);
4417        let mut var_amount = <Option<crate::model::PayAmount>>::sse_decode(deserializer);
4418        let mut var_feesSat = <Option<u64>>::sse_decode(deserializer);
4419        let mut var_estimatedAssetFees = <Option<f64>>::sse_decode(deserializer);
4420        return crate::model::PrepareSendResponse {
4421            destination: var_destination,
4422            amount: var_amount,
4423            fees_sat: var_feesSat,
4424            estimated_asset_fees: var_estimatedAssetFees,
4425        };
4426    }
4427}
4428
4429impl SseDecode for crate::bindings::Rate {
4430    // Codec=Sse (Serialization based), see doc to use other codecs
4431    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4432        let mut var_coin = <String>::sse_decode(deserializer);
4433        let mut var_value = <f64>::sse_decode(deserializer);
4434        return crate::bindings::Rate {
4435            coin: var_coin,
4436            value: var_value,
4437        };
4438    }
4439}
4440
4441impl SseDecode for crate::model::ReceiveAmount {
4442    // Codec=Sse (Serialization based), see doc to use other codecs
4443    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4444        let mut tag_ = <i32>::sse_decode(deserializer);
4445        match tag_ {
4446            0 => {
4447                let mut var_payerAmountSat = <u64>::sse_decode(deserializer);
4448                return crate::model::ReceiveAmount::Bitcoin {
4449                    payer_amount_sat: var_payerAmountSat,
4450                };
4451            }
4452            1 => {
4453                let mut var_assetId = <String>::sse_decode(deserializer);
4454                let mut var_payerAmount = <Option<f64>>::sse_decode(deserializer);
4455                return crate::model::ReceiveAmount::Asset {
4456                    asset_id: var_assetId,
4457                    payer_amount: var_payerAmount,
4458                };
4459            }
4460            _ => {
4461                unimplemented!("");
4462            }
4463        }
4464    }
4465}
4466
4467impl SseDecode for crate::model::ReceivePaymentRequest {
4468    // Codec=Sse (Serialization based), see doc to use other codecs
4469    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4470        let mut var_prepareResponse =
4471            <crate::model::PrepareReceiveResponse>::sse_decode(deserializer);
4472        let mut var_description = <Option<String>>::sse_decode(deserializer);
4473        let mut var_useDescriptionHash = <Option<bool>>::sse_decode(deserializer);
4474        return crate::model::ReceivePaymentRequest {
4475            prepare_response: var_prepareResponse,
4476            description: var_description,
4477            use_description_hash: var_useDescriptionHash,
4478        };
4479    }
4480}
4481
4482impl SseDecode for crate::model::ReceivePaymentResponse {
4483    // Codec=Sse (Serialization based), see doc to use other codecs
4484    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4485        let mut var_destination = <String>::sse_decode(deserializer);
4486        return crate::model::ReceivePaymentResponse {
4487            destination: var_destination,
4488        };
4489    }
4490}
4491
4492impl SseDecode for crate::model::RecommendedFees {
4493    // Codec=Sse (Serialization based), see doc to use other codecs
4494    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4495        let mut var_fastestFee = <u64>::sse_decode(deserializer);
4496        let mut var_halfHourFee = <u64>::sse_decode(deserializer);
4497        let mut var_hourFee = <u64>::sse_decode(deserializer);
4498        let mut var_economyFee = <u64>::sse_decode(deserializer);
4499        let mut var_minimumFee = <u64>::sse_decode(deserializer);
4500        return crate::model::RecommendedFees {
4501            fastest_fee: var_fastestFee,
4502            half_hour_fee: var_halfHourFee,
4503            hour_fee: var_hourFee,
4504            economy_fee: var_economyFee,
4505            minimum_fee: var_minimumFee,
4506        };
4507    }
4508}
4509
4510impl SseDecode for crate::model::RefundRequest {
4511    // Codec=Sse (Serialization based), see doc to use other codecs
4512    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4513        let mut var_swapAddress = <String>::sse_decode(deserializer);
4514        let mut var_refundAddress = <String>::sse_decode(deserializer);
4515        let mut var_feeRateSatPerVbyte = <u32>::sse_decode(deserializer);
4516        return crate::model::RefundRequest {
4517            swap_address: var_swapAddress,
4518            refund_address: var_refundAddress,
4519            fee_rate_sat_per_vbyte: var_feeRateSatPerVbyte,
4520        };
4521    }
4522}
4523
4524impl SseDecode for crate::model::RefundResponse {
4525    // Codec=Sse (Serialization based), see doc to use other codecs
4526    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4527        let mut var_refundTxId = <String>::sse_decode(deserializer);
4528        return crate::model::RefundResponse {
4529            refund_tx_id: var_refundTxId,
4530        };
4531    }
4532}
4533
4534impl SseDecode for crate::model::RefundableSwap {
4535    // Codec=Sse (Serialization based), see doc to use other codecs
4536    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4537        let mut var_swapAddress = <String>::sse_decode(deserializer);
4538        let mut var_timestamp = <u32>::sse_decode(deserializer);
4539        let mut var_amountSat = <u64>::sse_decode(deserializer);
4540        let mut var_lastRefundTxId = <Option<String>>::sse_decode(deserializer);
4541        return crate::model::RefundableSwap {
4542            swap_address: var_swapAddress,
4543            timestamp: var_timestamp,
4544            amount_sat: var_amountSat,
4545            last_refund_tx_id: var_lastRefundTxId,
4546        };
4547    }
4548}
4549
4550impl SseDecode for crate::model::RestoreRequest {
4551    // Codec=Sse (Serialization based), see doc to use other codecs
4552    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4553        let mut var_backupPath = <Option<String>>::sse_decode(deserializer);
4554        return crate::model::RestoreRequest {
4555            backup_path: var_backupPath,
4556        };
4557    }
4558}
4559
4560impl SseDecode for crate::bindings::RouteHint {
4561    // Codec=Sse (Serialization based), see doc to use other codecs
4562    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4563        let mut var_hops = <Vec<crate::bindings::RouteHintHop>>::sse_decode(deserializer);
4564        return crate::bindings::RouteHint { hops: var_hops };
4565    }
4566}
4567
4568impl SseDecode for crate::bindings::RouteHintHop {
4569    // Codec=Sse (Serialization based), see doc to use other codecs
4570    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4571        let mut var_srcNodeId = <String>::sse_decode(deserializer);
4572        let mut var_shortChannelId = <String>::sse_decode(deserializer);
4573        let mut var_feesBaseMsat = <u32>::sse_decode(deserializer);
4574        let mut var_feesProportionalMillionths = <u32>::sse_decode(deserializer);
4575        let mut var_cltvExpiryDelta = <u64>::sse_decode(deserializer);
4576        let mut var_htlcMinimumMsat = <Option<u64>>::sse_decode(deserializer);
4577        let mut var_htlcMaximumMsat = <Option<u64>>::sse_decode(deserializer);
4578        return crate::bindings::RouteHintHop {
4579            src_node_id: var_srcNodeId,
4580            short_channel_id: var_shortChannelId,
4581            fees_base_msat: var_feesBaseMsat,
4582            fees_proportional_millionths: var_feesProportionalMillionths,
4583            cltv_expiry_delta: var_cltvExpiryDelta,
4584            htlc_minimum_msat: var_htlcMinimumMsat,
4585            htlc_maximum_msat: var_htlcMaximumMsat,
4586        };
4587    }
4588}
4589
4590impl SseDecode for crate::error::SdkError {
4591    // Codec=Sse (Serialization based), see doc to use other codecs
4592    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4593        let mut tag_ = <i32>::sse_decode(deserializer);
4594        match tag_ {
4595            0 => {
4596                return crate::error::SdkError::AlreadyStarted;
4597            }
4598            1 => {
4599                let mut var_err = <String>::sse_decode(deserializer);
4600                return crate::error::SdkError::Generic { err: var_err };
4601            }
4602            2 => {
4603                return crate::error::SdkError::NotStarted;
4604            }
4605            3 => {
4606                let mut var_err = <String>::sse_decode(deserializer);
4607                return crate::error::SdkError::ServiceConnectivity { err: var_err };
4608            }
4609            _ => {
4610                unimplemented!("");
4611            }
4612        }
4613    }
4614}
4615
4616impl SseDecode for crate::model::SdkEvent {
4617    // Codec=Sse (Serialization based), see doc to use other codecs
4618    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4619        let mut tag_ = <i32>::sse_decode(deserializer);
4620        match tag_ {
4621            0 => {
4622                let mut var_details = <crate::model::Payment>::sse_decode(deserializer);
4623                return crate::model::SdkEvent::PaymentFailed {
4624                    details: var_details,
4625                };
4626            }
4627            1 => {
4628                let mut var_details = <crate::model::Payment>::sse_decode(deserializer);
4629                return crate::model::SdkEvent::PaymentPending {
4630                    details: var_details,
4631                };
4632            }
4633            2 => {
4634                let mut var_details = <crate::model::Payment>::sse_decode(deserializer);
4635                return crate::model::SdkEvent::PaymentRefundable {
4636                    details: var_details,
4637                };
4638            }
4639            3 => {
4640                let mut var_details = <crate::model::Payment>::sse_decode(deserializer);
4641                return crate::model::SdkEvent::PaymentRefunded {
4642                    details: var_details,
4643                };
4644            }
4645            4 => {
4646                let mut var_details = <crate::model::Payment>::sse_decode(deserializer);
4647                return crate::model::SdkEvent::PaymentRefundPending {
4648                    details: var_details,
4649                };
4650            }
4651            5 => {
4652                let mut var_details = <crate::model::Payment>::sse_decode(deserializer);
4653                return crate::model::SdkEvent::PaymentSucceeded {
4654                    details: var_details,
4655                };
4656            }
4657            6 => {
4658                let mut var_details = <crate::model::Payment>::sse_decode(deserializer);
4659                return crate::model::SdkEvent::PaymentWaitingConfirmation {
4660                    details: var_details,
4661                };
4662            }
4663            7 => {
4664                let mut var_details = <crate::model::Payment>::sse_decode(deserializer);
4665                return crate::model::SdkEvent::PaymentWaitingFeeAcceptance {
4666                    details: var_details,
4667                };
4668            }
4669            8 => {
4670                return crate::model::SdkEvent::Synced;
4671            }
4672            9 => {
4673                let mut var_didPullNewRecords = <bool>::sse_decode(deserializer);
4674                return crate::model::SdkEvent::DataSynced {
4675                    did_pull_new_records: var_didPullNewRecords,
4676                };
4677            }
4678            _ => {
4679                unimplemented!("");
4680            }
4681        }
4682    }
4683}
4684
4685impl SseDecode for crate::model::SendDestination {
4686    // Codec=Sse (Serialization based), see doc to use other codecs
4687    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4688        let mut tag_ = <i32>::sse_decode(deserializer);
4689        match tag_ {
4690            0 => {
4691                let mut var_addressData =
4692                    <crate::bindings::LiquidAddressData>::sse_decode(deserializer);
4693                let mut var_bip353Address = <Option<String>>::sse_decode(deserializer);
4694                return crate::model::SendDestination::LiquidAddress {
4695                    address_data: var_addressData,
4696                    bip353_address: var_bip353Address,
4697                };
4698            }
4699            1 => {
4700                let mut var_invoice = <crate::bindings::LNInvoice>::sse_decode(deserializer);
4701                let mut var_bip353Address = <Option<String>>::sse_decode(deserializer);
4702                return crate::model::SendDestination::Bolt11 {
4703                    invoice: var_invoice,
4704                    bip353_address: var_bip353Address,
4705                };
4706            }
4707            2 => {
4708                let mut var_offer = <crate::bindings::LNOffer>::sse_decode(deserializer);
4709                let mut var_receiverAmountSat = <u64>::sse_decode(deserializer);
4710                let mut var_bip353Address = <Option<String>>::sse_decode(deserializer);
4711                return crate::model::SendDestination::Bolt12 {
4712                    offer: var_offer,
4713                    receiver_amount_sat: var_receiverAmountSat,
4714                    bip353_address: var_bip353Address,
4715                };
4716            }
4717            _ => {
4718                unimplemented!("");
4719            }
4720        }
4721    }
4722}
4723
4724impl SseDecode for crate::model::SendPaymentRequest {
4725    // Codec=Sse (Serialization based), see doc to use other codecs
4726    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4727        let mut var_prepareResponse = <crate::model::PrepareSendResponse>::sse_decode(deserializer);
4728        let mut var_useAssetFees = <Option<bool>>::sse_decode(deserializer);
4729        return crate::model::SendPaymentRequest {
4730            prepare_response: var_prepareResponse,
4731            use_asset_fees: var_useAssetFees,
4732        };
4733    }
4734}
4735
4736impl SseDecode for crate::model::SendPaymentResponse {
4737    // Codec=Sse (Serialization based), see doc to use other codecs
4738    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4739        let mut var_payment = <crate::model::Payment>::sse_decode(deserializer);
4740        return crate::model::SendPaymentResponse {
4741            payment: var_payment,
4742        };
4743    }
4744}
4745
4746impl SseDecode for crate::model::SignMessageRequest {
4747    // Codec=Sse (Serialization based), see doc to use other codecs
4748    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4749        let mut var_message = <String>::sse_decode(deserializer);
4750        return crate::model::SignMessageRequest {
4751            message: var_message,
4752        };
4753    }
4754}
4755
4756impl SseDecode for crate::model::SignMessageResponse {
4757    // Codec=Sse (Serialization based), see doc to use other codecs
4758    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4759        let mut var_signature = <String>::sse_decode(deserializer);
4760        return crate::model::SignMessageResponse {
4761            signature: var_signature,
4762        };
4763    }
4764}
4765
4766impl SseDecode for crate::bindings::SuccessAction {
4767    // Codec=Sse (Serialization based), see doc to use other codecs
4768    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4769        let mut tag_ = <i32>::sse_decode(deserializer);
4770        match tag_ {
4771            0 => {
4772                let mut var_data =
4773                    <crate::bindings::AesSuccessActionData>::sse_decode(deserializer);
4774                return crate::bindings::SuccessAction::Aes { data: var_data };
4775            }
4776            1 => {
4777                let mut var_data =
4778                    <crate::bindings::MessageSuccessActionData>::sse_decode(deserializer);
4779                return crate::bindings::SuccessAction::Message { data: var_data };
4780            }
4781            2 => {
4782                let mut var_data =
4783                    <crate::bindings::UrlSuccessActionData>::sse_decode(deserializer);
4784                return crate::bindings::SuccessAction::Url { data: var_data };
4785            }
4786            _ => {
4787                unimplemented!("");
4788            }
4789        }
4790    }
4791}
4792
4793impl SseDecode for crate::bindings::SuccessActionProcessed {
4794    // Codec=Sse (Serialization based), see doc to use other codecs
4795    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4796        let mut tag_ = <i32>::sse_decode(deserializer);
4797        match tag_ {
4798            0 => {
4799                let mut var_result =
4800                    <crate::bindings::AesSuccessActionDataResult>::sse_decode(deserializer);
4801                return crate::bindings::SuccessActionProcessed::Aes { result: var_result };
4802            }
4803            1 => {
4804                let mut var_data =
4805                    <crate::bindings::MessageSuccessActionData>::sse_decode(deserializer);
4806                return crate::bindings::SuccessActionProcessed::Message { data: var_data };
4807            }
4808            2 => {
4809                let mut var_data =
4810                    <crate::bindings::UrlSuccessActionData>::sse_decode(deserializer);
4811                return crate::bindings::SuccessActionProcessed::Url { data: var_data };
4812            }
4813            _ => {
4814                unimplemented!("");
4815            }
4816        }
4817    }
4818}
4819
4820impl SseDecode for crate::bindings::Symbol {
4821    // Codec=Sse (Serialization based), see doc to use other codecs
4822    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4823        let mut var_grapheme = <Option<String>>::sse_decode(deserializer);
4824        let mut var_template = <Option<String>>::sse_decode(deserializer);
4825        let mut var_rtl = <Option<bool>>::sse_decode(deserializer);
4826        let mut var_position = <Option<u32>>::sse_decode(deserializer);
4827        return crate::bindings::Symbol {
4828            grapheme: var_grapheme,
4829            template: var_template,
4830            rtl: var_rtl,
4831            position: var_position,
4832        };
4833    }
4834}
4835
4836impl SseDecode for u16 {
4837    // Codec=Sse (Serialization based), see doc to use other codecs
4838    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4839        deserializer.cursor.read_u16::<NativeEndian>().unwrap()
4840    }
4841}
4842
4843impl SseDecode for u32 {
4844    // Codec=Sse (Serialization based), see doc to use other codecs
4845    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4846        deserializer.cursor.read_u32::<NativeEndian>().unwrap()
4847    }
4848}
4849
4850impl SseDecode for u64 {
4851    // Codec=Sse (Serialization based), see doc to use other codecs
4852    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4853        deserializer.cursor.read_u64::<NativeEndian>().unwrap()
4854    }
4855}
4856
4857impl SseDecode for u8 {
4858    // Codec=Sse (Serialization based), see doc to use other codecs
4859    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4860        deserializer.cursor.read_u8().unwrap()
4861    }
4862}
4863
4864impl SseDecode for () {
4865    // Codec=Sse (Serialization based), see doc to use other codecs
4866    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {}
4867}
4868
4869impl SseDecode for crate::bindings::UrlSuccessActionData {
4870    // Codec=Sse (Serialization based), see doc to use other codecs
4871    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4872        let mut var_description = <String>::sse_decode(deserializer);
4873        let mut var_url = <String>::sse_decode(deserializer);
4874        let mut var_matchesCallbackDomain = <bool>::sse_decode(deserializer);
4875        return crate::bindings::UrlSuccessActionData {
4876            description: var_description,
4877            url: var_url,
4878            matches_callback_domain: var_matchesCallbackDomain,
4879        };
4880    }
4881}
4882
4883impl SseDecode for usize {
4884    // Codec=Sse (Serialization based), see doc to use other codecs
4885    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4886        deserializer.cursor.read_u64::<NativeEndian>().unwrap() as _
4887    }
4888}
4889
4890impl SseDecode for crate::model::WalletInfo {
4891    // Codec=Sse (Serialization based), see doc to use other codecs
4892    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4893        let mut var_balanceSat = <u64>::sse_decode(deserializer);
4894        let mut var_pendingSendSat = <u64>::sse_decode(deserializer);
4895        let mut var_pendingReceiveSat = <u64>::sse_decode(deserializer);
4896        let mut var_fingerprint = <String>::sse_decode(deserializer);
4897        let mut var_pubkey = <String>::sse_decode(deserializer);
4898        let mut var_assetBalances = <Vec<crate::model::AssetBalance>>::sse_decode(deserializer);
4899        return crate::model::WalletInfo {
4900            balance_sat: var_balanceSat,
4901            pending_send_sat: var_pendingSendSat,
4902            pending_receive_sat: var_pendingReceiveSat,
4903            fingerprint: var_fingerprint,
4904            pubkey: var_pubkey,
4905            asset_balances: var_assetBalances,
4906        };
4907    }
4908}
4909
4910fn pde_ffi_dispatcher_primary_impl(
4911    func_id: i32,
4912    port: flutter_rust_bridge::for_generated::MessagePort,
4913    ptr: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
4914    rust_vec_len: i32,
4915    data_len: i32,
4916) {
4917    // Codec=Pde (Serialization + dispatch), see doc to use other codecs
4918    match func_id {
4919        _ => unreachable!(),
4920    }
4921}
4922
4923fn pde_ffi_dispatcher_sync_impl(
4924    func_id: i32,
4925    ptr: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
4926    rust_vec_len: i32,
4927    data_len: i32,
4928) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
4929    // Codec=Pde (Serialization + dispatch), see doc to use other codecs
4930    match func_id {
4931        _ => unreachable!(),
4932    }
4933}
4934
4935// Section: rust2dart
4936
4937// Codec=Dco (DartCObject based), see doc to use other codecs
4938impl flutter_rust_bridge::IntoDart for FrbWrapper<BindingLiquidSdk> {
4939    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
4940        flutter_rust_bridge::for_generated::rust_auto_opaque_encode::<_, StdArc<_>>(self.0)
4941            .into_dart()
4942    }
4943}
4944impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for FrbWrapper<BindingLiquidSdk> {}
4945
4946impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<BindingLiquidSdk>> for BindingLiquidSdk {
4947    fn into_into_dart(self) -> FrbWrapper<BindingLiquidSdk> {
4948        self.into()
4949    }
4950}
4951
4952// Codec=Dco (DartCObject based), see doc to use other codecs
4953impl flutter_rust_bridge::IntoDart for crate::model::AcceptPaymentProposedFeesRequest {
4954    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
4955        [self.response.into_into_dart().into_dart()].into_dart()
4956    }
4957}
4958impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
4959    for crate::model::AcceptPaymentProposedFeesRequest
4960{
4961}
4962impl flutter_rust_bridge::IntoIntoDart<crate::model::AcceptPaymentProposedFeesRequest>
4963    for crate::model::AcceptPaymentProposedFeesRequest
4964{
4965    fn into_into_dart(self) -> crate::model::AcceptPaymentProposedFeesRequest {
4966        self
4967    }
4968}
4969// Codec=Dco (DartCObject based), see doc to use other codecs
4970impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::AesSuccessActionData> {
4971    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
4972        [
4973            self.0.description.into_into_dart().into_dart(),
4974            self.0.ciphertext.into_into_dart().into_dart(),
4975            self.0.iv.into_into_dart().into_dart(),
4976        ]
4977        .into_dart()
4978    }
4979}
4980impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
4981    for FrbWrapper<crate::bindings::AesSuccessActionData>
4982{
4983}
4984impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::AesSuccessActionData>>
4985    for crate::bindings::AesSuccessActionData
4986{
4987    fn into_into_dart(self) -> FrbWrapper<crate::bindings::AesSuccessActionData> {
4988        self.into()
4989    }
4990}
4991// Codec=Dco (DartCObject based), see doc to use other codecs
4992impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::AesSuccessActionDataDecrypted> {
4993    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
4994        [
4995            self.0.description.into_into_dart().into_dart(),
4996            self.0.plaintext.into_into_dart().into_dart(),
4997        ]
4998        .into_dart()
4999    }
5000}
5001impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5002    for FrbWrapper<crate::bindings::AesSuccessActionDataDecrypted>
5003{
5004}
5005impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::AesSuccessActionDataDecrypted>>
5006    for crate::bindings::AesSuccessActionDataDecrypted
5007{
5008    fn into_into_dart(self) -> FrbWrapper<crate::bindings::AesSuccessActionDataDecrypted> {
5009        self.into()
5010    }
5011}
5012// Codec=Dco (DartCObject based), see doc to use other codecs
5013impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::AesSuccessActionDataResult> {
5014    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5015        match self.0 {
5016            crate::bindings::AesSuccessActionDataResult::Decrypted { data } => {
5017                [0.into_dart(), data.into_into_dart().into_dart()].into_dart()
5018            }
5019            crate::bindings::AesSuccessActionDataResult::ErrorStatus { reason } => {
5020                [1.into_dart(), reason.into_into_dart().into_dart()].into_dart()
5021            }
5022            _ => {
5023                unimplemented!("");
5024            }
5025        }
5026    }
5027}
5028impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5029    for FrbWrapper<crate::bindings::AesSuccessActionDataResult>
5030{
5031}
5032impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::AesSuccessActionDataResult>>
5033    for crate::bindings::AesSuccessActionDataResult
5034{
5035    fn into_into_dart(self) -> FrbWrapper<crate::bindings::AesSuccessActionDataResult> {
5036        self.into()
5037    }
5038}
5039// Codec=Dco (DartCObject based), see doc to use other codecs
5040impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::Amount> {
5041    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5042        match self.0 {
5043            crate::bindings::Amount::Bitcoin { amount_msat } => {
5044                [0.into_dart(), amount_msat.into_into_dart().into_dart()].into_dart()
5045            }
5046            crate::bindings::Amount::Currency {
5047                iso4217_code,
5048                fractional_amount,
5049            } => [
5050                1.into_dart(),
5051                iso4217_code.into_into_dart().into_dart(),
5052                fractional_amount.into_into_dart().into_dart(),
5053            ]
5054            .into_dart(),
5055            _ => {
5056                unimplemented!("");
5057            }
5058        }
5059    }
5060}
5061impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5062    for FrbWrapper<crate::bindings::Amount>
5063{
5064}
5065impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::Amount>>
5066    for crate::bindings::Amount
5067{
5068    fn into_into_dart(self) -> FrbWrapper<crate::bindings::Amount> {
5069        self.into()
5070    }
5071}
5072// Codec=Dco (DartCObject based), see doc to use other codecs
5073impl flutter_rust_bridge::IntoDart for crate::model::AssetBalance {
5074    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5075        [
5076            self.asset_id.into_into_dart().into_dart(),
5077            self.balance_sat.into_into_dart().into_dart(),
5078            self.name.into_into_dart().into_dart(),
5079            self.ticker.into_into_dart().into_dart(),
5080            self.balance.into_into_dart().into_dart(),
5081        ]
5082        .into_dart()
5083    }
5084}
5085impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::AssetBalance {}
5086impl flutter_rust_bridge::IntoIntoDart<crate::model::AssetBalance> for crate::model::AssetBalance {
5087    fn into_into_dart(self) -> crate::model::AssetBalance {
5088        self
5089    }
5090}
5091// Codec=Dco (DartCObject based), see doc to use other codecs
5092impl flutter_rust_bridge::IntoDart for crate::model::AssetInfo {
5093    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5094        [
5095            self.name.into_into_dart().into_dart(),
5096            self.ticker.into_into_dart().into_dart(),
5097            self.amount.into_into_dart().into_dart(),
5098            self.fees.into_into_dart().into_dart(),
5099        ]
5100        .into_dart()
5101    }
5102}
5103impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::AssetInfo {}
5104impl flutter_rust_bridge::IntoIntoDart<crate::model::AssetInfo> for crate::model::AssetInfo {
5105    fn into_into_dart(self) -> crate::model::AssetInfo {
5106        self
5107    }
5108}
5109// Codec=Dco (DartCObject based), see doc to use other codecs
5110impl flutter_rust_bridge::IntoDart for crate::model::AssetMetadata {
5111    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5112        [
5113            self.asset_id.into_into_dart().into_dart(),
5114            self.name.into_into_dart().into_dart(),
5115            self.ticker.into_into_dart().into_dart(),
5116            self.precision.into_into_dart().into_dart(),
5117            self.fiat_id.into_into_dart().into_dart(),
5118        ]
5119        .into_dart()
5120    }
5121}
5122impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::AssetMetadata {}
5123impl flutter_rust_bridge::IntoIntoDart<crate::model::AssetMetadata>
5124    for crate::model::AssetMetadata
5125{
5126    fn into_into_dart(self) -> crate::model::AssetMetadata {
5127        self
5128    }
5129}
5130// Codec=Dco (DartCObject based), see doc to use other codecs
5131impl flutter_rust_bridge::IntoDart for crate::model::BackupRequest {
5132    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5133        [self.backup_path.into_into_dart().into_dart()].into_dart()
5134    }
5135}
5136impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::BackupRequest {}
5137impl flutter_rust_bridge::IntoIntoDart<crate::model::BackupRequest>
5138    for crate::model::BackupRequest
5139{
5140    fn into_into_dart(self) -> crate::model::BackupRequest {
5141        self
5142    }
5143}
5144// Codec=Dco (DartCObject based), see doc to use other codecs
5145impl flutter_rust_bridge::IntoDart for crate::bindings::BindingEventListener {
5146    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5147        [self.stream.into_into_dart().into_dart()].into_dart()
5148    }
5149}
5150impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5151    for crate::bindings::BindingEventListener
5152{
5153}
5154impl flutter_rust_bridge::IntoIntoDart<crate::bindings::BindingEventListener>
5155    for crate::bindings::BindingEventListener
5156{
5157    fn into_into_dart(self) -> crate::bindings::BindingEventListener {
5158        self
5159    }
5160}
5161// Codec=Dco (DartCObject based), see doc to use other codecs
5162impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::BitcoinAddressData> {
5163    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5164        [
5165            self.0.address.into_into_dart().into_dart(),
5166            self.0.network.into_into_dart().into_dart(),
5167            self.0.amount_sat.into_into_dart().into_dart(),
5168            self.0.label.into_into_dart().into_dart(),
5169            self.0.message.into_into_dart().into_dart(),
5170        ]
5171        .into_dart()
5172    }
5173}
5174impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5175    for FrbWrapper<crate::bindings::BitcoinAddressData>
5176{
5177}
5178impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::BitcoinAddressData>>
5179    for crate::bindings::BitcoinAddressData
5180{
5181    fn into_into_dart(self) -> FrbWrapper<crate::bindings::BitcoinAddressData> {
5182        self.into()
5183    }
5184}
5185// Codec=Dco (DartCObject based), see doc to use other codecs
5186impl flutter_rust_bridge::IntoDart for crate::model::BlockchainExplorer {
5187    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5188        match self {
5189            crate::model::BlockchainExplorer::Electrum { url } => {
5190                [0.into_dart(), url.into_into_dart().into_dart()].into_dart()
5191            }
5192            crate::model::BlockchainExplorer::Esplora {
5193                url,
5194                use_waterfalls,
5195            } => [
5196                1.into_dart(),
5197                url.into_into_dart().into_dart(),
5198                use_waterfalls.into_into_dart().into_dart(),
5199            ]
5200            .into_dart(),
5201            _ => {
5202                unimplemented!("");
5203            }
5204        }
5205    }
5206}
5207impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5208    for crate::model::BlockchainExplorer
5209{
5210}
5211impl flutter_rust_bridge::IntoIntoDart<crate::model::BlockchainExplorer>
5212    for crate::model::BlockchainExplorer
5213{
5214    fn into_into_dart(self) -> crate::model::BlockchainExplorer {
5215        self
5216    }
5217}
5218// Codec=Dco (DartCObject based), see doc to use other codecs
5219impl flutter_rust_bridge::IntoDart for crate::model::BlockchainInfo {
5220    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5221        [
5222            self.liquid_tip.into_into_dart().into_dart(),
5223            self.bitcoin_tip.into_into_dart().into_dart(),
5224        ]
5225        .into_dart()
5226    }
5227}
5228impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::BlockchainInfo {}
5229impl flutter_rust_bridge::IntoIntoDart<crate::model::BlockchainInfo>
5230    for crate::model::BlockchainInfo
5231{
5232    fn into_into_dart(self) -> crate::model::BlockchainInfo {
5233        self
5234    }
5235}
5236// Codec=Dco (DartCObject based), see doc to use other codecs
5237impl flutter_rust_bridge::IntoDart for crate::model::BuyBitcoinProvider {
5238    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5239        match self {
5240            Self::Moonpay => 0.into_dart(),
5241            _ => unreachable!(),
5242        }
5243    }
5244}
5245impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5246    for crate::model::BuyBitcoinProvider
5247{
5248}
5249impl flutter_rust_bridge::IntoIntoDart<crate::model::BuyBitcoinProvider>
5250    for crate::model::BuyBitcoinProvider
5251{
5252    fn into_into_dart(self) -> crate::model::BuyBitcoinProvider {
5253        self
5254    }
5255}
5256// Codec=Dco (DartCObject based), see doc to use other codecs
5257impl flutter_rust_bridge::IntoDart for crate::model::BuyBitcoinRequest {
5258    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5259        [
5260            self.prepare_response.into_into_dart().into_dart(),
5261            self.redirect_url.into_into_dart().into_dart(),
5262        ]
5263        .into_dart()
5264    }
5265}
5266impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5267    for crate::model::BuyBitcoinRequest
5268{
5269}
5270impl flutter_rust_bridge::IntoIntoDart<crate::model::BuyBitcoinRequest>
5271    for crate::model::BuyBitcoinRequest
5272{
5273    fn into_into_dart(self) -> crate::model::BuyBitcoinRequest {
5274        self
5275    }
5276}
5277// Codec=Dco (DartCObject based), see doc to use other codecs
5278impl flutter_rust_bridge::IntoDart for crate::model::CheckMessageRequest {
5279    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5280        [
5281            self.message.into_into_dart().into_dart(),
5282            self.pubkey.into_into_dart().into_dart(),
5283            self.signature.into_into_dart().into_dart(),
5284        ]
5285        .into_dart()
5286    }
5287}
5288impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5289    for crate::model::CheckMessageRequest
5290{
5291}
5292impl flutter_rust_bridge::IntoIntoDart<crate::model::CheckMessageRequest>
5293    for crate::model::CheckMessageRequest
5294{
5295    fn into_into_dart(self) -> crate::model::CheckMessageRequest {
5296        self
5297    }
5298}
5299// Codec=Dco (DartCObject based), see doc to use other codecs
5300impl flutter_rust_bridge::IntoDart for crate::model::CheckMessageResponse {
5301    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5302        [self.is_valid.into_into_dart().into_dart()].into_dart()
5303    }
5304}
5305impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5306    for crate::model::CheckMessageResponse
5307{
5308}
5309impl flutter_rust_bridge::IntoIntoDart<crate::model::CheckMessageResponse>
5310    for crate::model::CheckMessageResponse
5311{
5312    fn into_into_dart(self) -> crate::model::CheckMessageResponse {
5313        self
5314    }
5315}
5316// Codec=Dco (DartCObject based), see doc to use other codecs
5317impl flutter_rust_bridge::IntoDart for crate::model::Config {
5318    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5319        [
5320            self.liquid_explorer.into_into_dart().into_dart(),
5321            self.bitcoin_explorer.into_into_dart().into_dart(),
5322            self.working_dir.into_into_dart().into_dart(),
5323            self.cache_dir.into_into_dart().into_dart(),
5324            self.network.into_into_dart().into_dart(),
5325            self.payment_timeout_sec.into_into_dart().into_dart(),
5326            self.sync_service_url.into_into_dart().into_dart(),
5327            self.zero_conf_max_amount_sat.into_into_dart().into_dart(),
5328            self.breez_api_key.into_into_dart().into_dart(),
5329            self.external_input_parsers.into_into_dart().into_dart(),
5330            self.use_default_external_input_parsers
5331                .into_into_dart()
5332                .into_dart(),
5333            self.onchain_fee_rate_leeway_sat_per_vbyte
5334                .into_into_dart()
5335                .into_dart(),
5336            self.asset_metadata.into_into_dart().into_dart(),
5337            self.sideswap_api_key.into_into_dart().into_dart(),
5338        ]
5339        .into_dart()
5340    }
5341}
5342impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::Config {}
5343impl flutter_rust_bridge::IntoIntoDart<crate::model::Config> for crate::model::Config {
5344    fn into_into_dart(self) -> crate::model::Config {
5345        self
5346    }
5347}
5348// Codec=Dco (DartCObject based), see doc to use other codecs
5349impl flutter_rust_bridge::IntoDart for crate::model::ConnectRequest {
5350    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5351        [
5352            self.config.into_into_dart().into_dart(),
5353            self.mnemonic.into_into_dart().into_dart(),
5354            self.passphrase.into_into_dart().into_dart(),
5355            self.seed.into_into_dart().into_dart(),
5356        ]
5357        .into_dart()
5358    }
5359}
5360impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::ConnectRequest {}
5361impl flutter_rust_bridge::IntoIntoDart<crate::model::ConnectRequest>
5362    for crate::model::ConnectRequest
5363{
5364    fn into_into_dart(self) -> crate::model::ConnectRequest {
5365        self
5366    }
5367}
5368// Codec=Dco (DartCObject based), see doc to use other codecs
5369impl flutter_rust_bridge::IntoDart for crate::model::CreateBolt12InvoiceRequest {
5370    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5371        [
5372            self.offer.into_into_dart().into_dart(),
5373            self.invoice_request.into_into_dart().into_dart(),
5374        ]
5375        .into_dart()
5376    }
5377}
5378impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5379    for crate::model::CreateBolt12InvoiceRequest
5380{
5381}
5382impl flutter_rust_bridge::IntoIntoDart<crate::model::CreateBolt12InvoiceRequest>
5383    for crate::model::CreateBolt12InvoiceRequest
5384{
5385    fn into_into_dart(self) -> crate::model::CreateBolt12InvoiceRequest {
5386        self
5387    }
5388}
5389// Codec=Dco (DartCObject based), see doc to use other codecs
5390impl flutter_rust_bridge::IntoDart for crate::model::CreateBolt12InvoiceResponse {
5391    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5392        [self.invoice.into_into_dart().into_dart()].into_dart()
5393    }
5394}
5395impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5396    for crate::model::CreateBolt12InvoiceResponse
5397{
5398}
5399impl flutter_rust_bridge::IntoIntoDart<crate::model::CreateBolt12InvoiceResponse>
5400    for crate::model::CreateBolt12InvoiceResponse
5401{
5402    fn into_into_dart(self) -> crate::model::CreateBolt12InvoiceResponse {
5403        self
5404    }
5405}
5406// Codec=Dco (DartCObject based), see doc to use other codecs
5407impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::CurrencyInfo> {
5408    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5409        [
5410            self.0.name.into_into_dart().into_dart(),
5411            self.0.fraction_size.into_into_dart().into_dart(),
5412            self.0.spacing.into_into_dart().into_dart(),
5413            self.0.symbol.into_into_dart().into_dart(),
5414            self.0.uniq_symbol.into_into_dart().into_dart(),
5415            self.0.localized_name.into_into_dart().into_dart(),
5416            self.0.locale_overrides.into_into_dart().into_dart(),
5417        ]
5418        .into_dart()
5419    }
5420}
5421impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5422    for FrbWrapper<crate::bindings::CurrencyInfo>
5423{
5424}
5425impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::CurrencyInfo>>
5426    for crate::bindings::CurrencyInfo
5427{
5428    fn into_into_dart(self) -> FrbWrapper<crate::bindings::CurrencyInfo> {
5429        self.into()
5430    }
5431}
5432// Codec=Dco (DartCObject based), see doc to use other codecs
5433impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::ExternalInputParser> {
5434    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5435        [
5436            self.0.provider_id.into_into_dart().into_dart(),
5437            self.0.input_regex.into_into_dart().into_dart(),
5438            self.0.parser_url.into_into_dart().into_dart(),
5439        ]
5440        .into_dart()
5441    }
5442}
5443impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5444    for FrbWrapper<crate::bindings::ExternalInputParser>
5445{
5446}
5447impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::ExternalInputParser>>
5448    for crate::bindings::ExternalInputParser
5449{
5450    fn into_into_dart(self) -> FrbWrapper<crate::bindings::ExternalInputParser> {
5451        self.into()
5452    }
5453}
5454// Codec=Dco (DartCObject based), see doc to use other codecs
5455impl flutter_rust_bridge::IntoDart for crate::model::FetchPaymentProposedFeesRequest {
5456    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5457        [self.swap_id.into_into_dart().into_dart()].into_dart()
5458    }
5459}
5460impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5461    for crate::model::FetchPaymentProposedFeesRequest
5462{
5463}
5464impl flutter_rust_bridge::IntoIntoDart<crate::model::FetchPaymentProposedFeesRequest>
5465    for crate::model::FetchPaymentProposedFeesRequest
5466{
5467    fn into_into_dart(self) -> crate::model::FetchPaymentProposedFeesRequest {
5468        self
5469    }
5470}
5471// Codec=Dco (DartCObject based), see doc to use other codecs
5472impl flutter_rust_bridge::IntoDart for crate::model::FetchPaymentProposedFeesResponse {
5473    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5474        [
5475            self.swap_id.into_into_dart().into_dart(),
5476            self.fees_sat.into_into_dart().into_dart(),
5477            self.payer_amount_sat.into_into_dart().into_dart(),
5478            self.receiver_amount_sat.into_into_dart().into_dart(),
5479        ]
5480        .into_dart()
5481    }
5482}
5483impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5484    for crate::model::FetchPaymentProposedFeesResponse
5485{
5486}
5487impl flutter_rust_bridge::IntoIntoDart<crate::model::FetchPaymentProposedFeesResponse>
5488    for crate::model::FetchPaymentProposedFeesResponse
5489{
5490    fn into_into_dart(self) -> crate::model::FetchPaymentProposedFeesResponse {
5491        self
5492    }
5493}
5494// Codec=Dco (DartCObject based), see doc to use other codecs
5495impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::FiatCurrency> {
5496    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5497        [
5498            self.0.id.into_into_dart().into_dart(),
5499            self.0.info.into_into_dart().into_dart(),
5500        ]
5501        .into_dart()
5502    }
5503}
5504impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5505    for FrbWrapper<crate::bindings::FiatCurrency>
5506{
5507}
5508impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::FiatCurrency>>
5509    for crate::bindings::FiatCurrency
5510{
5511    fn into_into_dart(self) -> FrbWrapper<crate::bindings::FiatCurrency> {
5512        self.into()
5513    }
5514}
5515// Codec=Dco (DartCObject based), see doc to use other codecs
5516impl flutter_rust_bridge::IntoDart for crate::model::GetInfoResponse {
5517    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5518        [
5519            self.wallet_info.into_into_dart().into_dart(),
5520            self.blockchain_info.into_into_dart().into_dart(),
5521        ]
5522        .into_dart()
5523    }
5524}
5525impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::GetInfoResponse {}
5526impl flutter_rust_bridge::IntoIntoDart<crate::model::GetInfoResponse>
5527    for crate::model::GetInfoResponse
5528{
5529    fn into_into_dart(self) -> crate::model::GetInfoResponse {
5530        self
5531    }
5532}
5533// Codec=Dco (DartCObject based), see doc to use other codecs
5534impl flutter_rust_bridge::IntoDart for crate::model::GetPaymentRequest {
5535    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5536        match self {
5537            crate::model::GetPaymentRequest::PaymentHash { payment_hash } => {
5538                [0.into_dart(), payment_hash.into_into_dart().into_dart()].into_dart()
5539            }
5540            crate::model::GetPaymentRequest::SwapId { swap_id } => {
5541                [1.into_dart(), swap_id.into_into_dart().into_dart()].into_dart()
5542            }
5543            _ => {
5544                unimplemented!("");
5545            }
5546        }
5547    }
5548}
5549impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5550    for crate::model::GetPaymentRequest
5551{
5552}
5553impl flutter_rust_bridge::IntoIntoDart<crate::model::GetPaymentRequest>
5554    for crate::model::GetPaymentRequest
5555{
5556    fn into_into_dart(self) -> crate::model::GetPaymentRequest {
5557        self
5558    }
5559}
5560// Codec=Dco (DartCObject based), see doc to use other codecs
5561impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::InputType> {
5562    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5563        match self.0 {
5564            crate::bindings::InputType::BitcoinAddress { address } => {
5565                [0.into_dart(), address.into_into_dart().into_dart()].into_dart()
5566            }
5567            crate::bindings::InputType::LiquidAddress { address } => {
5568                [1.into_dart(), address.into_into_dart().into_dart()].into_dart()
5569            }
5570            crate::bindings::InputType::Bolt11 { invoice } => {
5571                [2.into_dart(), invoice.into_into_dart().into_dart()].into_dart()
5572            }
5573            crate::bindings::InputType::Bolt12Offer {
5574                offer,
5575                bip353_address,
5576            } => [
5577                3.into_dart(),
5578                offer.into_into_dart().into_dart(),
5579                bip353_address.into_into_dart().into_dart(),
5580            ]
5581            .into_dart(),
5582            crate::bindings::InputType::NodeId { node_id } => {
5583                [4.into_dart(), node_id.into_into_dart().into_dart()].into_dart()
5584            }
5585            crate::bindings::InputType::Url { url } => {
5586                [5.into_dart(), url.into_into_dart().into_dart()].into_dart()
5587            }
5588            crate::bindings::InputType::LnUrlPay {
5589                data,
5590                bip353_address,
5591            } => [
5592                6.into_dart(),
5593                data.into_into_dart().into_dart(),
5594                bip353_address.into_into_dart().into_dart(),
5595            ]
5596            .into_dart(),
5597            crate::bindings::InputType::LnUrlWithdraw { data } => {
5598                [7.into_dart(), data.into_into_dart().into_dart()].into_dart()
5599            }
5600            crate::bindings::InputType::LnUrlAuth { data } => {
5601                [8.into_dart(), data.into_into_dart().into_dart()].into_dart()
5602            }
5603            crate::bindings::InputType::LnUrlError { data } => {
5604                [9.into_dart(), data.into_into_dart().into_dart()].into_dart()
5605            }
5606            _ => {
5607                unimplemented!("");
5608            }
5609        }
5610    }
5611}
5612impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5613    for FrbWrapper<crate::bindings::InputType>
5614{
5615}
5616impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::InputType>>
5617    for crate::bindings::InputType
5618{
5619    fn into_into_dart(self) -> FrbWrapper<crate::bindings::InputType> {
5620        self.into()
5621    }
5622}
5623// Codec=Dco (DartCObject based), see doc to use other codecs
5624impl flutter_rust_bridge::IntoDart for crate::model::LightningPaymentLimitsResponse {
5625    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5626        [
5627            self.send.into_into_dart().into_dart(),
5628            self.receive.into_into_dart().into_dart(),
5629        ]
5630        .into_dart()
5631    }
5632}
5633impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5634    for crate::model::LightningPaymentLimitsResponse
5635{
5636}
5637impl flutter_rust_bridge::IntoIntoDart<crate::model::LightningPaymentLimitsResponse>
5638    for crate::model::LightningPaymentLimitsResponse
5639{
5640    fn into_into_dart(self) -> crate::model::LightningPaymentLimitsResponse {
5641        self
5642    }
5643}
5644// Codec=Dco (DartCObject based), see doc to use other codecs
5645impl flutter_rust_bridge::IntoDart for crate::model::Limits {
5646    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5647        [
5648            self.min_sat.into_into_dart().into_dart(),
5649            self.max_sat.into_into_dart().into_dart(),
5650            self.max_zero_conf_sat.into_into_dart().into_dart(),
5651        ]
5652        .into_dart()
5653    }
5654}
5655impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::Limits {}
5656impl flutter_rust_bridge::IntoIntoDart<crate::model::Limits> for crate::model::Limits {
5657    fn into_into_dart(self) -> crate::model::Limits {
5658        self
5659    }
5660}
5661// Codec=Dco (DartCObject based), see doc to use other codecs
5662impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LiquidAddressData> {
5663    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5664        [
5665            self.0.address.into_into_dart().into_dart(),
5666            self.0.network.into_into_dart().into_dart(),
5667            self.0.asset_id.into_into_dart().into_dart(),
5668            self.0.amount.into_into_dart().into_dart(),
5669            self.0.amount_sat.into_into_dart().into_dart(),
5670            self.0.label.into_into_dart().into_dart(),
5671            self.0.message.into_into_dart().into_dart(),
5672        ]
5673        .into_dart()
5674    }
5675}
5676impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5677    for FrbWrapper<crate::bindings::LiquidAddressData>
5678{
5679}
5680impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LiquidAddressData>>
5681    for crate::bindings::LiquidAddressData
5682{
5683    fn into_into_dart(self) -> FrbWrapper<crate::bindings::LiquidAddressData> {
5684        self.into()
5685    }
5686}
5687// Codec=Dco (DartCObject based), see doc to use other codecs
5688impl flutter_rust_bridge::IntoDart for crate::model::LiquidNetwork {
5689    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5690        match self {
5691            Self::Mainnet => 0.into_dart(),
5692            Self::Testnet => 1.into_dart(),
5693            Self::Regtest => 2.into_dart(),
5694            _ => unreachable!(),
5695        }
5696    }
5697}
5698impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::LiquidNetwork {}
5699impl flutter_rust_bridge::IntoIntoDart<crate::model::LiquidNetwork>
5700    for crate::model::LiquidNetwork
5701{
5702    fn into_into_dart(self) -> crate::model::LiquidNetwork {
5703        self
5704    }
5705}
5706// Codec=Dco (DartCObject based), see doc to use other codecs
5707impl flutter_rust_bridge::IntoDart for crate::model::ListPaymentDetails {
5708    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5709        match self {
5710            crate::model::ListPaymentDetails::Liquid {
5711                asset_id,
5712                destination,
5713            } => [
5714                0.into_dart(),
5715                asset_id.into_into_dart().into_dart(),
5716                destination.into_into_dart().into_dart(),
5717            ]
5718            .into_dart(),
5719            crate::model::ListPaymentDetails::Bitcoin { address } => {
5720                [1.into_dart(), address.into_into_dart().into_dart()].into_dart()
5721            }
5722            _ => {
5723                unimplemented!("");
5724            }
5725        }
5726    }
5727}
5728impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5729    for crate::model::ListPaymentDetails
5730{
5731}
5732impl flutter_rust_bridge::IntoIntoDart<crate::model::ListPaymentDetails>
5733    for crate::model::ListPaymentDetails
5734{
5735    fn into_into_dart(self) -> crate::model::ListPaymentDetails {
5736        self
5737    }
5738}
5739// Codec=Dco (DartCObject based), see doc to use other codecs
5740impl flutter_rust_bridge::IntoDart for crate::model::ListPaymentsRequest {
5741    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5742        [
5743            self.filters.into_into_dart().into_dart(),
5744            self.states.into_into_dart().into_dart(),
5745            self.from_timestamp.into_into_dart().into_dart(),
5746            self.to_timestamp.into_into_dart().into_dart(),
5747            self.offset.into_into_dart().into_dart(),
5748            self.limit.into_into_dart().into_dart(),
5749            self.details.into_into_dart().into_dart(),
5750            self.sort_ascending.into_into_dart().into_dart(),
5751        ]
5752        .into_dart()
5753    }
5754}
5755impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5756    for crate::model::ListPaymentsRequest
5757{
5758}
5759impl flutter_rust_bridge::IntoIntoDart<crate::model::ListPaymentsRequest>
5760    for crate::model::ListPaymentsRequest
5761{
5762    fn into_into_dart(self) -> crate::model::ListPaymentsRequest {
5763        self
5764    }
5765}
5766// Codec=Dco (DartCObject based), see doc to use other codecs
5767impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LNInvoice> {
5768    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5769        [
5770            self.0.bolt11.into_into_dart().into_dart(),
5771            self.0.network.into_into_dart().into_dart(),
5772            self.0.payee_pubkey.into_into_dart().into_dart(),
5773            self.0.payment_hash.into_into_dart().into_dart(),
5774            self.0.description.into_into_dart().into_dart(),
5775            self.0.description_hash.into_into_dart().into_dart(),
5776            self.0.amount_msat.into_into_dart().into_dart(),
5777            self.0.timestamp.into_into_dart().into_dart(),
5778            self.0.expiry.into_into_dart().into_dart(),
5779            self.0.routing_hints.into_into_dart().into_dart(),
5780            self.0.payment_secret.into_into_dart().into_dart(),
5781            self.0
5782                .min_final_cltv_expiry_delta
5783                .into_into_dart()
5784                .into_dart(),
5785        ]
5786        .into_dart()
5787    }
5788}
5789impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5790    for FrbWrapper<crate::bindings::LNInvoice>
5791{
5792}
5793impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LNInvoice>>
5794    for crate::bindings::LNInvoice
5795{
5796    fn into_into_dart(self) -> FrbWrapper<crate::bindings::LNInvoice> {
5797        self.into()
5798    }
5799}
5800// Codec=Dco (DartCObject based), see doc to use other codecs
5801impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LNOffer> {
5802    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5803        [
5804            self.0.offer.into_into_dart().into_dart(),
5805            self.0.chains.into_into_dart().into_dart(),
5806            self.0.min_amount.into_into_dart().into_dart(),
5807            self.0.description.into_into_dart().into_dart(),
5808            self.0.absolute_expiry.into_into_dart().into_dart(),
5809            self.0.issuer.into_into_dart().into_dart(),
5810            self.0.signing_pubkey.into_into_dart().into_dart(),
5811            self.0.paths.into_into_dart().into_dart(),
5812        ]
5813        .into_dart()
5814    }
5815}
5816impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5817    for FrbWrapper<crate::bindings::LNOffer>
5818{
5819}
5820impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LNOffer>>
5821    for crate::bindings::LNOffer
5822{
5823    fn into_into_dart(self) -> FrbWrapper<crate::bindings::LNOffer> {
5824        self.into()
5825    }
5826}
5827// Codec=Dco (DartCObject based), see doc to use other codecs
5828impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LnOfferBlindedPath> {
5829    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5830        [self.0.blinded_hops.into_into_dart().into_dart()].into_dart()
5831    }
5832}
5833impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5834    for FrbWrapper<crate::bindings::LnOfferBlindedPath>
5835{
5836}
5837impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LnOfferBlindedPath>>
5838    for crate::bindings::LnOfferBlindedPath
5839{
5840    fn into_into_dart(self) -> FrbWrapper<crate::bindings::LnOfferBlindedPath> {
5841        self.into()
5842    }
5843}
5844// Codec=Dco (DartCObject based), see doc to use other codecs
5845impl flutter_rust_bridge::IntoDart for crate::bindings::duplicates::LnUrlAuthError {
5846    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5847        match self {
5848            crate::bindings::duplicates::LnUrlAuthError::Generic { err } => {
5849                [0.into_dart(), err.into_into_dart().into_dart()].into_dart()
5850            }
5851            crate::bindings::duplicates::LnUrlAuthError::InvalidUri { err } => {
5852                [1.into_dart(), err.into_into_dart().into_dart()].into_dart()
5853            }
5854            crate::bindings::duplicates::LnUrlAuthError::ServiceConnectivity { err } => {
5855                [2.into_dart(), err.into_into_dart().into_dart()].into_dart()
5856            }
5857            _ => {
5858                unimplemented!("");
5859            }
5860        }
5861    }
5862}
5863impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5864    for crate::bindings::duplicates::LnUrlAuthError
5865{
5866}
5867impl flutter_rust_bridge::IntoIntoDart<crate::bindings::duplicates::LnUrlAuthError>
5868    for crate::bindings::duplicates::LnUrlAuthError
5869{
5870    fn into_into_dart(self) -> crate::bindings::duplicates::LnUrlAuthError {
5871        self
5872    }
5873}
5874// Codec=Dco (DartCObject based), see doc to use other codecs
5875impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LnUrlAuthRequestData> {
5876    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5877        [
5878            self.0.k1.into_into_dart().into_dart(),
5879            self.0.action.into_into_dart().into_dart(),
5880            self.0.domain.into_into_dart().into_dart(),
5881            self.0.url.into_into_dart().into_dart(),
5882        ]
5883        .into_dart()
5884    }
5885}
5886impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5887    for FrbWrapper<crate::bindings::LnUrlAuthRequestData>
5888{
5889}
5890impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LnUrlAuthRequestData>>
5891    for crate::bindings::LnUrlAuthRequestData
5892{
5893    fn into_into_dart(self) -> FrbWrapper<crate::bindings::LnUrlAuthRequestData> {
5894        self.into()
5895    }
5896}
5897// Codec=Dco (DartCObject based), see doc to use other codecs
5898impl flutter_rust_bridge::IntoDart for crate::bindings::duplicates::LnUrlCallbackStatus {
5899    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5900        match self {
5901            crate::bindings::duplicates::LnUrlCallbackStatus::Ok => [0.into_dart()].into_dart(),
5902            crate::bindings::duplicates::LnUrlCallbackStatus::ErrorStatus { data } => {
5903                [1.into_dart(), data.into_into_dart().into_dart()].into_dart()
5904            }
5905            _ => {
5906                unimplemented!("");
5907            }
5908        }
5909    }
5910}
5911impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5912    for crate::bindings::duplicates::LnUrlCallbackStatus
5913{
5914}
5915impl flutter_rust_bridge::IntoIntoDart<crate::bindings::duplicates::LnUrlCallbackStatus>
5916    for crate::bindings::duplicates::LnUrlCallbackStatus
5917{
5918    fn into_into_dart(self) -> crate::bindings::duplicates::LnUrlCallbackStatus {
5919        self
5920    }
5921}
5922// Codec=Dco (DartCObject based), see doc to use other codecs
5923impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LnUrlErrorData> {
5924    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5925        [self.0.reason.into_into_dart().into_dart()].into_dart()
5926    }
5927}
5928impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5929    for FrbWrapper<crate::bindings::LnUrlErrorData>
5930{
5931}
5932impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LnUrlErrorData>>
5933    for crate::bindings::LnUrlErrorData
5934{
5935    fn into_into_dart(self) -> FrbWrapper<crate::bindings::LnUrlErrorData> {
5936        self.into()
5937    }
5938}
5939// Codec=Dco (DartCObject based), see doc to use other codecs
5940impl flutter_rust_bridge::IntoDart for crate::model::LnUrlInfo {
5941    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5942        [
5943            self.ln_address.into_into_dart().into_dart(),
5944            self.lnurl_pay_comment.into_into_dart().into_dart(),
5945            self.lnurl_pay_domain.into_into_dart().into_dart(),
5946            self.lnurl_pay_metadata.into_into_dart().into_dart(),
5947            self.lnurl_pay_success_action.into_into_dart().into_dart(),
5948            self.lnurl_pay_unprocessed_success_action
5949                .into_into_dart()
5950                .into_dart(),
5951            self.lnurl_withdraw_endpoint.into_into_dart().into_dart(),
5952        ]
5953        .into_dart()
5954    }
5955}
5956impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::LnUrlInfo {}
5957impl flutter_rust_bridge::IntoIntoDart<crate::model::LnUrlInfo> for crate::model::LnUrlInfo {
5958    fn into_into_dart(self) -> crate::model::LnUrlInfo {
5959        self
5960    }
5961}
5962// Codec=Dco (DartCObject based), see doc to use other codecs
5963impl flutter_rust_bridge::IntoDart for crate::bindings::duplicates::LnUrlPayError {
5964    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5965        match self {
5966            crate::bindings::duplicates::LnUrlPayError::AlreadyPaid => [0.into_dart()].into_dart(),
5967            crate::bindings::duplicates::LnUrlPayError::Generic { err } => {
5968                [1.into_dart(), err.into_into_dart().into_dart()].into_dart()
5969            }
5970            crate::bindings::duplicates::LnUrlPayError::InsufficientBalance { err } => {
5971                [2.into_dart(), err.into_into_dart().into_dart()].into_dart()
5972            }
5973            crate::bindings::duplicates::LnUrlPayError::InvalidAmount { err } => {
5974                [3.into_dart(), err.into_into_dart().into_dart()].into_dart()
5975            }
5976            crate::bindings::duplicates::LnUrlPayError::InvalidInvoice { err } => {
5977                [4.into_dart(), err.into_into_dart().into_dart()].into_dart()
5978            }
5979            crate::bindings::duplicates::LnUrlPayError::InvalidNetwork { err } => {
5980                [5.into_dart(), err.into_into_dart().into_dart()].into_dart()
5981            }
5982            crate::bindings::duplicates::LnUrlPayError::InvalidUri { err } => {
5983                [6.into_dart(), err.into_into_dart().into_dart()].into_dart()
5984            }
5985            crate::bindings::duplicates::LnUrlPayError::InvoiceExpired { err } => {
5986                [7.into_dart(), err.into_into_dart().into_dart()].into_dart()
5987            }
5988            crate::bindings::duplicates::LnUrlPayError::PaymentFailed { err } => {
5989                [8.into_dart(), err.into_into_dart().into_dart()].into_dart()
5990            }
5991            crate::bindings::duplicates::LnUrlPayError::PaymentTimeout { err } => {
5992                [9.into_dart(), err.into_into_dart().into_dart()].into_dart()
5993            }
5994            crate::bindings::duplicates::LnUrlPayError::RouteNotFound { err } => {
5995                [10.into_dart(), err.into_into_dart().into_dart()].into_dart()
5996            }
5997            crate::bindings::duplicates::LnUrlPayError::RouteTooExpensive { err } => {
5998                [11.into_dart(), err.into_into_dart().into_dart()].into_dart()
5999            }
6000            crate::bindings::duplicates::LnUrlPayError::ServiceConnectivity { err } => {
6001                [12.into_dart(), err.into_into_dart().into_dart()].into_dart()
6002            }
6003            _ => {
6004                unimplemented!("");
6005            }
6006        }
6007    }
6008}
6009impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6010    for crate::bindings::duplicates::LnUrlPayError
6011{
6012}
6013impl flutter_rust_bridge::IntoIntoDart<crate::bindings::duplicates::LnUrlPayError>
6014    for crate::bindings::duplicates::LnUrlPayError
6015{
6016    fn into_into_dart(self) -> crate::bindings::duplicates::LnUrlPayError {
6017        self
6018    }
6019}
6020// Codec=Dco (DartCObject based), see doc to use other codecs
6021impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LnUrlPayErrorData> {
6022    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6023        [
6024            self.0.payment_hash.into_into_dart().into_dart(),
6025            self.0.reason.into_into_dart().into_dart(),
6026        ]
6027        .into_dart()
6028    }
6029}
6030impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6031    for FrbWrapper<crate::bindings::LnUrlPayErrorData>
6032{
6033}
6034impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LnUrlPayErrorData>>
6035    for crate::bindings::LnUrlPayErrorData
6036{
6037    fn into_into_dart(self) -> FrbWrapper<crate::bindings::LnUrlPayErrorData> {
6038        self.into()
6039    }
6040}
6041// Codec=Dco (DartCObject based), see doc to use other codecs
6042impl flutter_rust_bridge::IntoDart for crate::model::LnUrlPayRequest {
6043    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6044        [self.prepare_response.into_into_dart().into_dart()].into_dart()
6045    }
6046}
6047impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::LnUrlPayRequest {}
6048impl flutter_rust_bridge::IntoIntoDart<crate::model::LnUrlPayRequest>
6049    for crate::model::LnUrlPayRequest
6050{
6051    fn into_into_dart(self) -> crate::model::LnUrlPayRequest {
6052        self
6053    }
6054}
6055// Codec=Dco (DartCObject based), see doc to use other codecs
6056impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LnUrlPayRequestData> {
6057    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6058        [
6059            self.0.callback.into_into_dart().into_dart(),
6060            self.0.min_sendable.into_into_dart().into_dart(),
6061            self.0.max_sendable.into_into_dart().into_dart(),
6062            self.0.metadata_str.into_into_dart().into_dart(),
6063            self.0.comment_allowed.into_into_dart().into_dart(),
6064            self.0.domain.into_into_dart().into_dart(),
6065            self.0.allows_nostr.into_into_dart().into_dart(),
6066            self.0.nostr_pubkey.into_into_dart().into_dart(),
6067            self.0.ln_address.into_into_dart().into_dart(),
6068        ]
6069        .into_dart()
6070    }
6071}
6072impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6073    for FrbWrapper<crate::bindings::LnUrlPayRequestData>
6074{
6075}
6076impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LnUrlPayRequestData>>
6077    for crate::bindings::LnUrlPayRequestData
6078{
6079    fn into_into_dart(self) -> FrbWrapper<crate::bindings::LnUrlPayRequestData> {
6080        self.into()
6081    }
6082}
6083// Codec=Dco (DartCObject based), see doc to use other codecs
6084impl flutter_rust_bridge::IntoDart for crate::model::LnUrlPayResult {
6085    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6086        match self {
6087            crate::model::LnUrlPayResult::EndpointSuccess { data } => {
6088                [0.into_dart(), data.into_into_dart().into_dart()].into_dart()
6089            }
6090            crate::model::LnUrlPayResult::EndpointError { data } => {
6091                [1.into_dart(), data.into_into_dart().into_dart()].into_dart()
6092            }
6093            crate::model::LnUrlPayResult::PayError { data } => {
6094                [2.into_dart(), data.into_into_dart().into_dart()].into_dart()
6095            }
6096            _ => {
6097                unimplemented!("");
6098            }
6099        }
6100    }
6101}
6102impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::LnUrlPayResult {}
6103impl flutter_rust_bridge::IntoIntoDart<crate::model::LnUrlPayResult>
6104    for crate::model::LnUrlPayResult
6105{
6106    fn into_into_dart(self) -> crate::model::LnUrlPayResult {
6107        self
6108    }
6109}
6110// Codec=Dco (DartCObject based), see doc to use other codecs
6111impl flutter_rust_bridge::IntoDart for crate::model::LnUrlPaySuccessData {
6112    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6113        [
6114            self.payment.into_into_dart().into_dart(),
6115            self.success_action.into_into_dart().into_dart(),
6116        ]
6117        .into_dart()
6118    }
6119}
6120impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6121    for crate::model::LnUrlPaySuccessData
6122{
6123}
6124impl flutter_rust_bridge::IntoIntoDart<crate::model::LnUrlPaySuccessData>
6125    for crate::model::LnUrlPaySuccessData
6126{
6127    fn into_into_dart(self) -> crate::model::LnUrlPaySuccessData {
6128        self
6129    }
6130}
6131// Codec=Dco (DartCObject based), see doc to use other codecs
6132impl flutter_rust_bridge::IntoDart for crate::bindings::duplicates::LnUrlWithdrawError {
6133    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6134        match self {
6135            crate::bindings::duplicates::LnUrlWithdrawError::Generic { err } => {
6136                [0.into_dart(), err.into_into_dart().into_dart()].into_dart()
6137            }
6138            crate::bindings::duplicates::LnUrlWithdrawError::InvalidAmount { err } => {
6139                [1.into_dart(), err.into_into_dart().into_dart()].into_dart()
6140            }
6141            crate::bindings::duplicates::LnUrlWithdrawError::InvalidInvoice { err } => {
6142                [2.into_dart(), err.into_into_dart().into_dart()].into_dart()
6143            }
6144            crate::bindings::duplicates::LnUrlWithdrawError::InvalidUri { err } => {
6145                [3.into_dart(), err.into_into_dart().into_dart()].into_dart()
6146            }
6147            crate::bindings::duplicates::LnUrlWithdrawError::InvoiceNoRoutingHints { err } => {
6148                [4.into_dart(), err.into_into_dart().into_dart()].into_dart()
6149            }
6150            crate::bindings::duplicates::LnUrlWithdrawError::ServiceConnectivity { err } => {
6151                [5.into_dart(), err.into_into_dart().into_dart()].into_dart()
6152            }
6153            _ => {
6154                unimplemented!("");
6155            }
6156        }
6157    }
6158}
6159impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6160    for crate::bindings::duplicates::LnUrlWithdrawError
6161{
6162}
6163impl flutter_rust_bridge::IntoIntoDart<crate::bindings::duplicates::LnUrlWithdrawError>
6164    for crate::bindings::duplicates::LnUrlWithdrawError
6165{
6166    fn into_into_dart(self) -> crate::bindings::duplicates::LnUrlWithdrawError {
6167        self
6168    }
6169}
6170// Codec=Dco (DartCObject based), see doc to use other codecs
6171impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LnUrlWithdrawRequest> {
6172    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6173        [
6174            self.0.data.into_into_dart().into_dart(),
6175            self.0.amount_msat.into_into_dart().into_dart(),
6176            self.0.description.into_into_dart().into_dart(),
6177        ]
6178        .into_dart()
6179    }
6180}
6181impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6182    for FrbWrapper<crate::bindings::LnUrlWithdrawRequest>
6183{
6184}
6185impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LnUrlWithdrawRequest>>
6186    for crate::bindings::LnUrlWithdrawRequest
6187{
6188    fn into_into_dart(self) -> FrbWrapper<crate::bindings::LnUrlWithdrawRequest> {
6189        self.into()
6190    }
6191}
6192// Codec=Dco (DartCObject based), see doc to use other codecs
6193impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LnUrlWithdrawRequestData> {
6194    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6195        [
6196            self.0.callback.into_into_dart().into_dart(),
6197            self.0.k1.into_into_dart().into_dart(),
6198            self.0.default_description.into_into_dart().into_dart(),
6199            self.0.min_withdrawable.into_into_dart().into_dart(),
6200            self.0.max_withdrawable.into_into_dart().into_dart(),
6201        ]
6202        .into_dart()
6203    }
6204}
6205impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6206    for FrbWrapper<crate::bindings::LnUrlWithdrawRequestData>
6207{
6208}
6209impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LnUrlWithdrawRequestData>>
6210    for crate::bindings::LnUrlWithdrawRequestData
6211{
6212    fn into_into_dart(self) -> FrbWrapper<crate::bindings::LnUrlWithdrawRequestData> {
6213        self.into()
6214    }
6215}
6216// Codec=Dco (DartCObject based), see doc to use other codecs
6217impl flutter_rust_bridge::IntoDart for crate::bindings::duplicates::LnUrlWithdrawResult {
6218    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6219        match self {
6220            crate::bindings::duplicates::LnUrlWithdrawResult::Ok { data } => {
6221                [0.into_dart(), data.into_into_dart().into_dart()].into_dart()
6222            }
6223            crate::bindings::duplicates::LnUrlWithdrawResult::Timeout { data } => {
6224                [1.into_dart(), data.into_into_dart().into_dart()].into_dart()
6225            }
6226            crate::bindings::duplicates::LnUrlWithdrawResult::ErrorStatus { data } => {
6227                [2.into_dart(), data.into_into_dart().into_dart()].into_dart()
6228            }
6229            _ => {
6230                unimplemented!("");
6231            }
6232        }
6233    }
6234}
6235impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6236    for crate::bindings::duplicates::LnUrlWithdrawResult
6237{
6238}
6239impl flutter_rust_bridge::IntoIntoDart<crate::bindings::duplicates::LnUrlWithdrawResult>
6240    for crate::bindings::duplicates::LnUrlWithdrawResult
6241{
6242    fn into_into_dart(self) -> crate::bindings::duplicates::LnUrlWithdrawResult {
6243        self
6244    }
6245}
6246// Codec=Dco (DartCObject based), see doc to use other codecs
6247impl flutter_rust_bridge::IntoDart for crate::bindings::duplicates::LnUrlWithdrawSuccessData {
6248    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6249        [self.invoice.into_into_dart().into_dart()].into_dart()
6250    }
6251}
6252impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6253    for crate::bindings::duplicates::LnUrlWithdrawSuccessData
6254{
6255}
6256impl flutter_rust_bridge::IntoIntoDart<crate::bindings::duplicates::LnUrlWithdrawSuccessData>
6257    for crate::bindings::duplicates::LnUrlWithdrawSuccessData
6258{
6259    fn into_into_dart(self) -> crate::bindings::duplicates::LnUrlWithdrawSuccessData {
6260        self
6261    }
6262}
6263// Codec=Dco (DartCObject based), see doc to use other codecs
6264impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LocaleOverrides> {
6265    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6266        [
6267            self.0.locale.into_into_dart().into_dart(),
6268            self.0.spacing.into_into_dart().into_dart(),
6269            self.0.symbol.into_into_dart().into_dart(),
6270        ]
6271        .into_dart()
6272    }
6273}
6274impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6275    for FrbWrapper<crate::bindings::LocaleOverrides>
6276{
6277}
6278impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LocaleOverrides>>
6279    for crate::bindings::LocaleOverrides
6280{
6281    fn into_into_dart(self) -> FrbWrapper<crate::bindings::LocaleOverrides> {
6282        self.into()
6283    }
6284}
6285// Codec=Dco (DartCObject based), see doc to use other codecs
6286impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LocalizedName> {
6287    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6288        [
6289            self.0.locale.into_into_dart().into_dart(),
6290            self.0.name.into_into_dart().into_dart(),
6291        ]
6292        .into_dart()
6293    }
6294}
6295impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6296    for FrbWrapper<crate::bindings::LocalizedName>
6297{
6298}
6299impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LocalizedName>>
6300    for crate::bindings::LocalizedName
6301{
6302    fn into_into_dart(self) -> FrbWrapper<crate::bindings::LocalizedName> {
6303        self.into()
6304    }
6305}
6306// Codec=Dco (DartCObject based), see doc to use other codecs
6307impl flutter_rust_bridge::IntoDart for crate::model::LogEntry {
6308    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6309        [
6310            self.line.into_into_dart().into_dart(),
6311            self.level.into_into_dart().into_dart(),
6312        ]
6313        .into_dart()
6314    }
6315}
6316impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::LogEntry {}
6317impl flutter_rust_bridge::IntoIntoDart<crate::model::LogEntry> for crate::model::LogEntry {
6318    fn into_into_dart(self) -> crate::model::LogEntry {
6319        self
6320    }
6321}
6322// Codec=Dco (DartCObject based), see doc to use other codecs
6323impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::MessageSuccessActionData> {
6324    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6325        [self.0.message.into_into_dart().into_dart()].into_dart()
6326    }
6327}
6328impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6329    for FrbWrapper<crate::bindings::MessageSuccessActionData>
6330{
6331}
6332impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::MessageSuccessActionData>>
6333    for crate::bindings::MessageSuccessActionData
6334{
6335    fn into_into_dart(self) -> FrbWrapper<crate::bindings::MessageSuccessActionData> {
6336        self.into()
6337    }
6338}
6339// Codec=Dco (DartCObject based), see doc to use other codecs
6340impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::Network> {
6341    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6342        match self.0 {
6343            crate::bindings::Network::Bitcoin => 0.into_dart(),
6344            crate::bindings::Network::Testnet => 1.into_dart(),
6345            crate::bindings::Network::Signet => 2.into_dart(),
6346            crate::bindings::Network::Regtest => 3.into_dart(),
6347            _ => unreachable!(),
6348        }
6349    }
6350}
6351impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6352    for FrbWrapper<crate::bindings::Network>
6353{
6354}
6355impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::Network>>
6356    for crate::bindings::Network
6357{
6358    fn into_into_dart(self) -> FrbWrapper<crate::bindings::Network> {
6359        self.into()
6360    }
6361}
6362// Codec=Dco (DartCObject based), see doc to use other codecs
6363impl flutter_rust_bridge::IntoDart for crate::model::OnchainPaymentLimitsResponse {
6364    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6365        [
6366            self.send.into_into_dart().into_dart(),
6367            self.receive.into_into_dart().into_dart(),
6368        ]
6369        .into_dart()
6370    }
6371}
6372impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6373    for crate::model::OnchainPaymentLimitsResponse
6374{
6375}
6376impl flutter_rust_bridge::IntoIntoDart<crate::model::OnchainPaymentLimitsResponse>
6377    for crate::model::OnchainPaymentLimitsResponse
6378{
6379    fn into_into_dart(self) -> crate::model::OnchainPaymentLimitsResponse {
6380        self
6381    }
6382}
6383// Codec=Dco (DartCObject based), see doc to use other codecs
6384impl flutter_rust_bridge::IntoDart for crate::model::PayAmount {
6385    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6386        match self {
6387            crate::model::PayAmount::Bitcoin {
6388                receiver_amount_sat,
6389            } => [
6390                0.into_dart(),
6391                receiver_amount_sat.into_into_dart().into_dart(),
6392            ]
6393            .into_dart(),
6394            crate::model::PayAmount::Asset {
6395                asset_id,
6396                receiver_amount,
6397                estimate_asset_fees,
6398            } => [
6399                1.into_dart(),
6400                asset_id.into_into_dart().into_dart(),
6401                receiver_amount.into_into_dart().into_dart(),
6402                estimate_asset_fees.into_into_dart().into_dart(),
6403            ]
6404            .into_dart(),
6405            crate::model::PayAmount::Drain => [2.into_dart()].into_dart(),
6406            _ => {
6407                unimplemented!("");
6408            }
6409        }
6410    }
6411}
6412impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::PayAmount {}
6413impl flutter_rust_bridge::IntoIntoDart<crate::model::PayAmount> for crate::model::PayAmount {
6414    fn into_into_dart(self) -> crate::model::PayAmount {
6415        self
6416    }
6417}
6418// Codec=Dco (DartCObject based), see doc to use other codecs
6419impl flutter_rust_bridge::IntoDart for crate::model::PayOnchainRequest {
6420    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6421        [
6422            self.address.into_into_dart().into_dart(),
6423            self.prepare_response.into_into_dart().into_dart(),
6424        ]
6425        .into_dart()
6426    }
6427}
6428impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6429    for crate::model::PayOnchainRequest
6430{
6431}
6432impl flutter_rust_bridge::IntoIntoDart<crate::model::PayOnchainRequest>
6433    for crate::model::PayOnchainRequest
6434{
6435    fn into_into_dart(self) -> crate::model::PayOnchainRequest {
6436        self
6437    }
6438}
6439// Codec=Dco (DartCObject based), see doc to use other codecs
6440impl flutter_rust_bridge::IntoDart for crate::model::Payment {
6441    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6442        [
6443            self.destination.into_into_dart().into_dart(),
6444            self.tx_id.into_into_dart().into_dart(),
6445            self.unblinding_data.into_into_dart().into_dart(),
6446            self.timestamp.into_into_dart().into_dart(),
6447            self.amount_sat.into_into_dart().into_dart(),
6448            self.fees_sat.into_into_dart().into_dart(),
6449            self.swapper_fees_sat.into_into_dart().into_dart(),
6450            self.payment_type.into_into_dart().into_dart(),
6451            self.status.into_into_dart().into_dart(),
6452            self.details.into_into_dart().into_dart(),
6453        ]
6454        .into_dart()
6455    }
6456}
6457impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::Payment {}
6458impl flutter_rust_bridge::IntoIntoDart<crate::model::Payment> for crate::model::Payment {
6459    fn into_into_dart(self) -> crate::model::Payment {
6460        self
6461    }
6462}
6463// Codec=Dco (DartCObject based), see doc to use other codecs
6464impl flutter_rust_bridge::IntoDart for crate::model::PaymentDetails {
6465    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6466        match self {
6467            crate::model::PaymentDetails::Lightning {
6468                swap_id,
6469                description,
6470                liquid_expiration_blockheight,
6471                preimage,
6472                invoice,
6473                bolt12_offer,
6474                payment_hash,
6475                destination_pubkey,
6476                lnurl_info,
6477                bip353_address,
6478                claim_tx_id,
6479                refund_tx_id,
6480                refund_tx_amount_sat,
6481            } => [
6482                0.into_dart(),
6483                swap_id.into_into_dart().into_dart(),
6484                description.into_into_dart().into_dart(),
6485                liquid_expiration_blockheight.into_into_dart().into_dart(),
6486                preimage.into_into_dart().into_dart(),
6487                invoice.into_into_dart().into_dart(),
6488                bolt12_offer.into_into_dart().into_dart(),
6489                payment_hash.into_into_dart().into_dart(),
6490                destination_pubkey.into_into_dart().into_dart(),
6491                lnurl_info.into_into_dart().into_dart(),
6492                bip353_address.into_into_dart().into_dart(),
6493                claim_tx_id.into_into_dart().into_dart(),
6494                refund_tx_id.into_into_dart().into_dart(),
6495                refund_tx_amount_sat.into_into_dart().into_dart(),
6496            ]
6497            .into_dart(),
6498            crate::model::PaymentDetails::Liquid {
6499                destination,
6500                description,
6501                asset_id,
6502                asset_info,
6503                lnurl_info,
6504                bip353_address,
6505            } => [
6506                1.into_dart(),
6507                destination.into_into_dart().into_dart(),
6508                description.into_into_dart().into_dart(),
6509                asset_id.into_into_dart().into_dart(),
6510                asset_info.into_into_dart().into_dart(),
6511                lnurl_info.into_into_dart().into_dart(),
6512                bip353_address.into_into_dart().into_dart(),
6513            ]
6514            .into_dart(),
6515            crate::model::PaymentDetails::Bitcoin {
6516                swap_id,
6517                description,
6518                auto_accepted_fees,
6519                liquid_expiration_blockheight,
6520                bitcoin_expiration_blockheight,
6521                lockup_tx_id,
6522                claim_tx_id,
6523                refund_tx_id,
6524                refund_tx_amount_sat,
6525            } => [
6526                2.into_dart(),
6527                swap_id.into_into_dart().into_dart(),
6528                description.into_into_dart().into_dart(),
6529                auto_accepted_fees.into_into_dart().into_dart(),
6530                liquid_expiration_blockheight.into_into_dart().into_dart(),
6531                bitcoin_expiration_blockheight.into_into_dart().into_dart(),
6532                lockup_tx_id.into_into_dart().into_dart(),
6533                claim_tx_id.into_into_dart().into_dart(),
6534                refund_tx_id.into_into_dart().into_dart(),
6535                refund_tx_amount_sat.into_into_dart().into_dart(),
6536            ]
6537            .into_dart(),
6538            _ => {
6539                unimplemented!("");
6540            }
6541        }
6542    }
6543}
6544impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::PaymentDetails {}
6545impl flutter_rust_bridge::IntoIntoDart<crate::model::PaymentDetails>
6546    for crate::model::PaymentDetails
6547{
6548    fn into_into_dart(self) -> crate::model::PaymentDetails {
6549        self
6550    }
6551}
6552// Codec=Dco (DartCObject based), see doc to use other codecs
6553impl flutter_rust_bridge::IntoDart for crate::error::PaymentError {
6554    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6555        match self {
6556            crate::error::PaymentError::AlreadyClaimed => [0.into_dart()].into_dart(),
6557            crate::error::PaymentError::AlreadyPaid => [1.into_dart()].into_dart(),
6558            crate::error::PaymentError::PaymentInProgress => [2.into_dart()].into_dart(),
6559            crate::error::PaymentError::AmountOutOfRange { min, max } => [
6560                3.into_dart(),
6561                min.into_into_dart().into_dart(),
6562                max.into_into_dart().into_dart(),
6563            ]
6564            .into_dart(),
6565            crate::error::PaymentError::AmountMissing { err } => {
6566                [4.into_dart(), err.into_into_dart().into_dart()].into_dart()
6567            }
6568            crate::error::PaymentError::AssetError { err } => {
6569                [5.into_dart(), err.into_into_dart().into_dart()].into_dart()
6570            }
6571            crate::error::PaymentError::InvalidNetwork { err } => {
6572                [6.into_dart(), err.into_into_dart().into_dart()].into_dart()
6573            }
6574            crate::error::PaymentError::Generic { err } => {
6575                [7.into_dart(), err.into_into_dart().into_dart()].into_dart()
6576            }
6577            crate::error::PaymentError::InvalidOrExpiredFees => [8.into_dart()].into_dart(),
6578            crate::error::PaymentError::InsufficientFunds => [9.into_dart()].into_dart(),
6579            crate::error::PaymentError::InvalidDescription { err } => {
6580                [10.into_dart(), err.into_into_dart().into_dart()].into_dart()
6581            }
6582            crate::error::PaymentError::InvalidInvoice { err } => {
6583                [11.into_dart(), err.into_into_dart().into_dart()].into_dart()
6584            }
6585            crate::error::PaymentError::InvalidPreimage => [12.into_dart()].into_dart(),
6586            crate::error::PaymentError::PairsNotFound => [13.into_dart()].into_dart(),
6587            crate::error::PaymentError::PaymentTimeout => [14.into_dart()].into_dart(),
6588            crate::error::PaymentError::PersistError => [15.into_dart()].into_dart(),
6589            crate::error::PaymentError::ReceiveError { err } => {
6590                [16.into_dart(), err.into_into_dart().into_dart()].into_dart()
6591            }
6592            crate::error::PaymentError::Refunded { err, refund_tx_id } => [
6593                17.into_dart(),
6594                err.into_into_dart().into_dart(),
6595                refund_tx_id.into_into_dart().into_dart(),
6596            ]
6597            .into_dart(),
6598            crate::error::PaymentError::SelfTransferNotSupported => [18.into_dart()].into_dart(),
6599            crate::error::PaymentError::SendError { err } => {
6600                [19.into_dart(), err.into_into_dart().into_dart()].into_dart()
6601            }
6602            crate::error::PaymentError::SignerError { err } => {
6603                [20.into_dart(), err.into_into_dart().into_dart()].into_dart()
6604            }
6605            _ => {
6606                unimplemented!("");
6607            }
6608        }
6609    }
6610}
6611impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::error::PaymentError {}
6612impl flutter_rust_bridge::IntoIntoDart<crate::error::PaymentError> for crate::error::PaymentError {
6613    fn into_into_dart(self) -> crate::error::PaymentError {
6614        self
6615    }
6616}
6617// Codec=Dco (DartCObject based), see doc to use other codecs
6618impl flutter_rust_bridge::IntoDart for crate::model::PaymentMethod {
6619    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6620        match self {
6621            Self::Lightning => 0.into_dart(),
6622            Self::Bolt11Invoice => 1.into_dart(),
6623            Self::Bolt12Offer => 2.into_dart(),
6624            Self::BitcoinAddress => 3.into_dart(),
6625            Self::LiquidAddress => 4.into_dart(),
6626            _ => unreachable!(),
6627        }
6628    }
6629}
6630impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::PaymentMethod {}
6631impl flutter_rust_bridge::IntoIntoDart<crate::model::PaymentMethod>
6632    for crate::model::PaymentMethod
6633{
6634    fn into_into_dart(self) -> crate::model::PaymentMethod {
6635        self
6636    }
6637}
6638// Codec=Dco (DartCObject based), see doc to use other codecs
6639impl flutter_rust_bridge::IntoDart for crate::model::PaymentState {
6640    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6641        match self {
6642            Self::Created => 0.into_dart(),
6643            Self::Pending => 1.into_dart(),
6644            Self::Complete => 2.into_dart(),
6645            Self::Failed => 3.into_dart(),
6646            Self::TimedOut => 4.into_dart(),
6647            Self::Refundable => 5.into_dart(),
6648            Self::RefundPending => 6.into_dart(),
6649            Self::WaitingFeeAcceptance => 7.into_dart(),
6650            _ => unreachable!(),
6651        }
6652    }
6653}
6654impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::PaymentState {}
6655impl flutter_rust_bridge::IntoIntoDart<crate::model::PaymentState> for crate::model::PaymentState {
6656    fn into_into_dart(self) -> crate::model::PaymentState {
6657        self
6658    }
6659}
6660// Codec=Dco (DartCObject based), see doc to use other codecs
6661impl flutter_rust_bridge::IntoDart for crate::model::PaymentType {
6662    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6663        match self {
6664            Self::Receive => 0.into_dart(),
6665            Self::Send => 1.into_dart(),
6666            _ => unreachable!(),
6667        }
6668    }
6669}
6670impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::PaymentType {}
6671impl flutter_rust_bridge::IntoIntoDart<crate::model::PaymentType> for crate::model::PaymentType {
6672    fn into_into_dart(self) -> crate::model::PaymentType {
6673        self
6674    }
6675}
6676// Codec=Dco (DartCObject based), see doc to use other codecs
6677impl flutter_rust_bridge::IntoDart for crate::model::PrepareBuyBitcoinRequest {
6678    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6679        [
6680            self.provider.into_into_dart().into_dart(),
6681            self.amount_sat.into_into_dart().into_dart(),
6682        ]
6683        .into_dart()
6684    }
6685}
6686impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6687    for crate::model::PrepareBuyBitcoinRequest
6688{
6689}
6690impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareBuyBitcoinRequest>
6691    for crate::model::PrepareBuyBitcoinRequest
6692{
6693    fn into_into_dart(self) -> crate::model::PrepareBuyBitcoinRequest {
6694        self
6695    }
6696}
6697// Codec=Dco (DartCObject based), see doc to use other codecs
6698impl flutter_rust_bridge::IntoDart for crate::model::PrepareBuyBitcoinResponse {
6699    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6700        [
6701            self.provider.into_into_dart().into_dart(),
6702            self.amount_sat.into_into_dart().into_dart(),
6703            self.fees_sat.into_into_dart().into_dart(),
6704        ]
6705        .into_dart()
6706    }
6707}
6708impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6709    for crate::model::PrepareBuyBitcoinResponse
6710{
6711}
6712impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareBuyBitcoinResponse>
6713    for crate::model::PrepareBuyBitcoinResponse
6714{
6715    fn into_into_dart(self) -> crate::model::PrepareBuyBitcoinResponse {
6716        self
6717    }
6718}
6719// Codec=Dco (DartCObject based), see doc to use other codecs
6720impl flutter_rust_bridge::IntoDart for crate::model::PrepareLnUrlPayRequest {
6721    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6722        [
6723            self.data.into_into_dart().into_dart(),
6724            self.amount.into_into_dart().into_dart(),
6725            self.bip353_address.into_into_dart().into_dart(),
6726            self.comment.into_into_dart().into_dart(),
6727            self.validate_success_action_url
6728                .into_into_dart()
6729                .into_dart(),
6730        ]
6731        .into_dart()
6732    }
6733}
6734impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6735    for crate::model::PrepareLnUrlPayRequest
6736{
6737}
6738impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareLnUrlPayRequest>
6739    for crate::model::PrepareLnUrlPayRequest
6740{
6741    fn into_into_dart(self) -> crate::model::PrepareLnUrlPayRequest {
6742        self
6743    }
6744}
6745// Codec=Dco (DartCObject based), see doc to use other codecs
6746impl flutter_rust_bridge::IntoDart for crate::model::PrepareLnUrlPayResponse {
6747    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6748        [
6749            self.destination.into_into_dart().into_dart(),
6750            self.fees_sat.into_into_dart().into_dart(),
6751            self.data.into_into_dart().into_dart(),
6752            self.amount.into_into_dart().into_dart(),
6753            self.comment.into_into_dart().into_dart(),
6754            self.success_action.into_into_dart().into_dart(),
6755        ]
6756        .into_dart()
6757    }
6758}
6759impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6760    for crate::model::PrepareLnUrlPayResponse
6761{
6762}
6763impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareLnUrlPayResponse>
6764    for crate::model::PrepareLnUrlPayResponse
6765{
6766    fn into_into_dart(self) -> crate::model::PrepareLnUrlPayResponse {
6767        self
6768    }
6769}
6770// Codec=Dco (DartCObject based), see doc to use other codecs
6771impl flutter_rust_bridge::IntoDart for crate::model::PreparePayOnchainRequest {
6772    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6773        [
6774            self.amount.into_into_dart().into_dart(),
6775            self.fee_rate_sat_per_vbyte.into_into_dart().into_dart(),
6776        ]
6777        .into_dart()
6778    }
6779}
6780impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6781    for crate::model::PreparePayOnchainRequest
6782{
6783}
6784impl flutter_rust_bridge::IntoIntoDart<crate::model::PreparePayOnchainRequest>
6785    for crate::model::PreparePayOnchainRequest
6786{
6787    fn into_into_dart(self) -> crate::model::PreparePayOnchainRequest {
6788        self
6789    }
6790}
6791// Codec=Dco (DartCObject based), see doc to use other codecs
6792impl flutter_rust_bridge::IntoDart for crate::model::PreparePayOnchainResponse {
6793    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6794        [
6795            self.receiver_amount_sat.into_into_dart().into_dart(),
6796            self.claim_fees_sat.into_into_dart().into_dart(),
6797            self.total_fees_sat.into_into_dart().into_dart(),
6798        ]
6799        .into_dart()
6800    }
6801}
6802impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6803    for crate::model::PreparePayOnchainResponse
6804{
6805}
6806impl flutter_rust_bridge::IntoIntoDart<crate::model::PreparePayOnchainResponse>
6807    for crate::model::PreparePayOnchainResponse
6808{
6809    fn into_into_dart(self) -> crate::model::PreparePayOnchainResponse {
6810        self
6811    }
6812}
6813// Codec=Dco (DartCObject based), see doc to use other codecs
6814impl flutter_rust_bridge::IntoDart for crate::model::PrepareReceiveRequest {
6815    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6816        [
6817            self.payment_method.into_into_dart().into_dart(),
6818            self.amount.into_into_dart().into_dart(),
6819        ]
6820        .into_dart()
6821    }
6822}
6823impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6824    for crate::model::PrepareReceiveRequest
6825{
6826}
6827impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareReceiveRequest>
6828    for crate::model::PrepareReceiveRequest
6829{
6830    fn into_into_dart(self) -> crate::model::PrepareReceiveRequest {
6831        self
6832    }
6833}
6834// Codec=Dco (DartCObject based), see doc to use other codecs
6835impl flutter_rust_bridge::IntoDart for crate::model::PrepareReceiveResponse {
6836    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6837        [
6838            self.payment_method.into_into_dart().into_dart(),
6839            self.fees_sat.into_into_dart().into_dart(),
6840            self.amount.into_into_dart().into_dart(),
6841            self.min_payer_amount_sat.into_into_dart().into_dart(),
6842            self.max_payer_amount_sat.into_into_dart().into_dart(),
6843            self.swapper_feerate.into_into_dart().into_dart(),
6844        ]
6845        .into_dart()
6846    }
6847}
6848impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6849    for crate::model::PrepareReceiveResponse
6850{
6851}
6852impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareReceiveResponse>
6853    for crate::model::PrepareReceiveResponse
6854{
6855    fn into_into_dart(self) -> crate::model::PrepareReceiveResponse {
6856        self
6857    }
6858}
6859// Codec=Dco (DartCObject based), see doc to use other codecs
6860impl flutter_rust_bridge::IntoDart for crate::model::PrepareRefundRequest {
6861    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6862        [
6863            self.swap_address.into_into_dart().into_dart(),
6864            self.refund_address.into_into_dart().into_dart(),
6865            self.fee_rate_sat_per_vbyte.into_into_dart().into_dart(),
6866        ]
6867        .into_dart()
6868    }
6869}
6870impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6871    for crate::model::PrepareRefundRequest
6872{
6873}
6874impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareRefundRequest>
6875    for crate::model::PrepareRefundRequest
6876{
6877    fn into_into_dart(self) -> crate::model::PrepareRefundRequest {
6878        self
6879    }
6880}
6881// Codec=Dco (DartCObject based), see doc to use other codecs
6882impl flutter_rust_bridge::IntoDart for crate::model::PrepareRefundResponse {
6883    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6884        [
6885            self.tx_vsize.into_into_dart().into_dart(),
6886            self.tx_fee_sat.into_into_dart().into_dart(),
6887            self.last_refund_tx_id.into_into_dart().into_dart(),
6888        ]
6889        .into_dart()
6890    }
6891}
6892impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6893    for crate::model::PrepareRefundResponse
6894{
6895}
6896impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareRefundResponse>
6897    for crate::model::PrepareRefundResponse
6898{
6899    fn into_into_dart(self) -> crate::model::PrepareRefundResponse {
6900        self
6901    }
6902}
6903// Codec=Dco (DartCObject based), see doc to use other codecs
6904impl flutter_rust_bridge::IntoDart for crate::model::PrepareSendRequest {
6905    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6906        [
6907            self.destination.into_into_dart().into_dart(),
6908            self.amount.into_into_dart().into_dart(),
6909        ]
6910        .into_dart()
6911    }
6912}
6913impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6914    for crate::model::PrepareSendRequest
6915{
6916}
6917impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareSendRequest>
6918    for crate::model::PrepareSendRequest
6919{
6920    fn into_into_dart(self) -> crate::model::PrepareSendRequest {
6921        self
6922    }
6923}
6924// Codec=Dco (DartCObject based), see doc to use other codecs
6925impl flutter_rust_bridge::IntoDart for crate::model::PrepareSendResponse {
6926    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6927        [
6928            self.destination.into_into_dart().into_dart(),
6929            self.amount.into_into_dart().into_dart(),
6930            self.fees_sat.into_into_dart().into_dart(),
6931            self.estimated_asset_fees.into_into_dart().into_dart(),
6932        ]
6933        .into_dart()
6934    }
6935}
6936impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6937    for crate::model::PrepareSendResponse
6938{
6939}
6940impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareSendResponse>
6941    for crate::model::PrepareSendResponse
6942{
6943    fn into_into_dart(self) -> crate::model::PrepareSendResponse {
6944        self
6945    }
6946}
6947// Codec=Dco (DartCObject based), see doc to use other codecs
6948impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::Rate> {
6949    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6950        [
6951            self.0.coin.into_into_dart().into_dart(),
6952            self.0.value.into_into_dart().into_dart(),
6953        ]
6954        .into_dart()
6955    }
6956}
6957impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6958    for FrbWrapper<crate::bindings::Rate>
6959{
6960}
6961impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::Rate>>
6962    for crate::bindings::Rate
6963{
6964    fn into_into_dart(self) -> FrbWrapper<crate::bindings::Rate> {
6965        self.into()
6966    }
6967}
6968// Codec=Dco (DartCObject based), see doc to use other codecs
6969impl flutter_rust_bridge::IntoDart for crate::model::ReceiveAmount {
6970    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6971        match self {
6972            crate::model::ReceiveAmount::Bitcoin { payer_amount_sat } => {
6973                [0.into_dart(), payer_amount_sat.into_into_dart().into_dart()].into_dart()
6974            }
6975            crate::model::ReceiveAmount::Asset {
6976                asset_id,
6977                payer_amount,
6978            } => [
6979                1.into_dart(),
6980                asset_id.into_into_dart().into_dart(),
6981                payer_amount.into_into_dart().into_dart(),
6982            ]
6983            .into_dart(),
6984            _ => {
6985                unimplemented!("");
6986            }
6987        }
6988    }
6989}
6990impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::ReceiveAmount {}
6991impl flutter_rust_bridge::IntoIntoDart<crate::model::ReceiveAmount>
6992    for crate::model::ReceiveAmount
6993{
6994    fn into_into_dart(self) -> crate::model::ReceiveAmount {
6995        self
6996    }
6997}
6998// Codec=Dco (DartCObject based), see doc to use other codecs
6999impl flutter_rust_bridge::IntoDart for crate::model::ReceivePaymentRequest {
7000    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7001        [
7002            self.prepare_response.into_into_dart().into_dart(),
7003            self.description.into_into_dart().into_dart(),
7004            self.use_description_hash.into_into_dart().into_dart(),
7005        ]
7006        .into_dart()
7007    }
7008}
7009impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7010    for crate::model::ReceivePaymentRequest
7011{
7012}
7013impl flutter_rust_bridge::IntoIntoDart<crate::model::ReceivePaymentRequest>
7014    for crate::model::ReceivePaymentRequest
7015{
7016    fn into_into_dart(self) -> crate::model::ReceivePaymentRequest {
7017        self
7018    }
7019}
7020// Codec=Dco (DartCObject based), see doc to use other codecs
7021impl flutter_rust_bridge::IntoDart for crate::model::ReceivePaymentResponse {
7022    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7023        [self.destination.into_into_dart().into_dart()].into_dart()
7024    }
7025}
7026impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7027    for crate::model::ReceivePaymentResponse
7028{
7029}
7030impl flutter_rust_bridge::IntoIntoDart<crate::model::ReceivePaymentResponse>
7031    for crate::model::ReceivePaymentResponse
7032{
7033    fn into_into_dart(self) -> crate::model::ReceivePaymentResponse {
7034        self
7035    }
7036}
7037// Codec=Dco (DartCObject based), see doc to use other codecs
7038impl flutter_rust_bridge::IntoDart for crate::model::RecommendedFees {
7039    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7040        [
7041            self.fastest_fee.into_into_dart().into_dart(),
7042            self.half_hour_fee.into_into_dart().into_dart(),
7043            self.hour_fee.into_into_dart().into_dart(),
7044            self.economy_fee.into_into_dart().into_dart(),
7045            self.minimum_fee.into_into_dart().into_dart(),
7046        ]
7047        .into_dart()
7048    }
7049}
7050impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::RecommendedFees {}
7051impl flutter_rust_bridge::IntoIntoDart<crate::model::RecommendedFees>
7052    for crate::model::RecommendedFees
7053{
7054    fn into_into_dart(self) -> crate::model::RecommendedFees {
7055        self
7056    }
7057}
7058// Codec=Dco (DartCObject based), see doc to use other codecs
7059impl flutter_rust_bridge::IntoDart for crate::model::RefundRequest {
7060    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7061        [
7062            self.swap_address.into_into_dart().into_dart(),
7063            self.refund_address.into_into_dart().into_dart(),
7064            self.fee_rate_sat_per_vbyte.into_into_dart().into_dart(),
7065        ]
7066        .into_dart()
7067    }
7068}
7069impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::RefundRequest {}
7070impl flutter_rust_bridge::IntoIntoDart<crate::model::RefundRequest>
7071    for crate::model::RefundRequest
7072{
7073    fn into_into_dart(self) -> crate::model::RefundRequest {
7074        self
7075    }
7076}
7077// Codec=Dco (DartCObject based), see doc to use other codecs
7078impl flutter_rust_bridge::IntoDart for crate::model::RefundResponse {
7079    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7080        [self.refund_tx_id.into_into_dart().into_dart()].into_dart()
7081    }
7082}
7083impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::RefundResponse {}
7084impl flutter_rust_bridge::IntoIntoDart<crate::model::RefundResponse>
7085    for crate::model::RefundResponse
7086{
7087    fn into_into_dart(self) -> crate::model::RefundResponse {
7088        self
7089    }
7090}
7091// Codec=Dco (DartCObject based), see doc to use other codecs
7092impl flutter_rust_bridge::IntoDart for crate::model::RefundableSwap {
7093    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7094        [
7095            self.swap_address.into_into_dart().into_dart(),
7096            self.timestamp.into_into_dart().into_dart(),
7097            self.amount_sat.into_into_dart().into_dart(),
7098            self.last_refund_tx_id.into_into_dart().into_dart(),
7099        ]
7100        .into_dart()
7101    }
7102}
7103impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::RefundableSwap {}
7104impl flutter_rust_bridge::IntoIntoDart<crate::model::RefundableSwap>
7105    for crate::model::RefundableSwap
7106{
7107    fn into_into_dart(self) -> crate::model::RefundableSwap {
7108        self
7109    }
7110}
7111// Codec=Dco (DartCObject based), see doc to use other codecs
7112impl flutter_rust_bridge::IntoDart for crate::model::RestoreRequest {
7113    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7114        [self.backup_path.into_into_dart().into_dart()].into_dart()
7115    }
7116}
7117impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::RestoreRequest {}
7118impl flutter_rust_bridge::IntoIntoDart<crate::model::RestoreRequest>
7119    for crate::model::RestoreRequest
7120{
7121    fn into_into_dart(self) -> crate::model::RestoreRequest {
7122        self
7123    }
7124}
7125// Codec=Dco (DartCObject based), see doc to use other codecs
7126impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::RouteHint> {
7127    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7128        [self.0.hops.into_into_dart().into_dart()].into_dart()
7129    }
7130}
7131impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7132    for FrbWrapper<crate::bindings::RouteHint>
7133{
7134}
7135impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::RouteHint>>
7136    for crate::bindings::RouteHint
7137{
7138    fn into_into_dart(self) -> FrbWrapper<crate::bindings::RouteHint> {
7139        self.into()
7140    }
7141}
7142// Codec=Dco (DartCObject based), see doc to use other codecs
7143impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::RouteHintHop> {
7144    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7145        [
7146            self.0.src_node_id.into_into_dart().into_dart(),
7147            self.0.short_channel_id.into_into_dart().into_dart(),
7148            self.0.fees_base_msat.into_into_dart().into_dart(),
7149            self.0
7150                .fees_proportional_millionths
7151                .into_into_dart()
7152                .into_dart(),
7153            self.0.cltv_expiry_delta.into_into_dart().into_dart(),
7154            self.0.htlc_minimum_msat.into_into_dart().into_dart(),
7155            self.0.htlc_maximum_msat.into_into_dart().into_dart(),
7156        ]
7157        .into_dart()
7158    }
7159}
7160impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7161    for FrbWrapper<crate::bindings::RouteHintHop>
7162{
7163}
7164impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::RouteHintHop>>
7165    for crate::bindings::RouteHintHop
7166{
7167    fn into_into_dart(self) -> FrbWrapper<crate::bindings::RouteHintHop> {
7168        self.into()
7169    }
7170}
7171// Codec=Dco (DartCObject based), see doc to use other codecs
7172impl flutter_rust_bridge::IntoDart for crate::error::SdkError {
7173    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7174        match self {
7175            crate::error::SdkError::AlreadyStarted => [0.into_dart()].into_dart(),
7176            crate::error::SdkError::Generic { err } => {
7177                [1.into_dart(), err.into_into_dart().into_dart()].into_dart()
7178            }
7179            crate::error::SdkError::NotStarted => [2.into_dart()].into_dart(),
7180            crate::error::SdkError::ServiceConnectivity { err } => {
7181                [3.into_dart(), err.into_into_dart().into_dart()].into_dart()
7182            }
7183            _ => {
7184                unimplemented!("");
7185            }
7186        }
7187    }
7188}
7189impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::error::SdkError {}
7190impl flutter_rust_bridge::IntoIntoDart<crate::error::SdkError> for crate::error::SdkError {
7191    fn into_into_dart(self) -> crate::error::SdkError {
7192        self
7193    }
7194}
7195// Codec=Dco (DartCObject based), see doc to use other codecs
7196impl flutter_rust_bridge::IntoDart for crate::model::SdkEvent {
7197    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7198        match self {
7199            crate::model::SdkEvent::PaymentFailed { details } => {
7200                [0.into_dart(), details.into_into_dart().into_dart()].into_dart()
7201            }
7202            crate::model::SdkEvent::PaymentPending { details } => {
7203                [1.into_dart(), details.into_into_dart().into_dart()].into_dart()
7204            }
7205            crate::model::SdkEvent::PaymentRefundable { details } => {
7206                [2.into_dart(), details.into_into_dart().into_dart()].into_dart()
7207            }
7208            crate::model::SdkEvent::PaymentRefunded { details } => {
7209                [3.into_dart(), details.into_into_dart().into_dart()].into_dart()
7210            }
7211            crate::model::SdkEvent::PaymentRefundPending { details } => {
7212                [4.into_dart(), details.into_into_dart().into_dart()].into_dart()
7213            }
7214            crate::model::SdkEvent::PaymentSucceeded { details } => {
7215                [5.into_dart(), details.into_into_dart().into_dart()].into_dart()
7216            }
7217            crate::model::SdkEvent::PaymentWaitingConfirmation { details } => {
7218                [6.into_dart(), details.into_into_dart().into_dart()].into_dart()
7219            }
7220            crate::model::SdkEvent::PaymentWaitingFeeAcceptance { details } => {
7221                [7.into_dart(), details.into_into_dart().into_dart()].into_dart()
7222            }
7223            crate::model::SdkEvent::Synced => [8.into_dart()].into_dart(),
7224            crate::model::SdkEvent::DataSynced {
7225                did_pull_new_records,
7226            } => [
7227                9.into_dart(),
7228                did_pull_new_records.into_into_dart().into_dart(),
7229            ]
7230            .into_dart(),
7231            _ => {
7232                unimplemented!("");
7233            }
7234        }
7235    }
7236}
7237impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::SdkEvent {}
7238impl flutter_rust_bridge::IntoIntoDart<crate::model::SdkEvent> for crate::model::SdkEvent {
7239    fn into_into_dart(self) -> crate::model::SdkEvent {
7240        self
7241    }
7242}
7243// Codec=Dco (DartCObject based), see doc to use other codecs
7244impl flutter_rust_bridge::IntoDart for crate::model::SendDestination {
7245    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7246        match self {
7247            crate::model::SendDestination::LiquidAddress {
7248                address_data,
7249                bip353_address,
7250            } => [
7251                0.into_dart(),
7252                address_data.into_into_dart().into_dart(),
7253                bip353_address.into_into_dart().into_dart(),
7254            ]
7255            .into_dart(),
7256            crate::model::SendDestination::Bolt11 {
7257                invoice,
7258                bip353_address,
7259            } => [
7260                1.into_dart(),
7261                invoice.into_into_dart().into_dart(),
7262                bip353_address.into_into_dart().into_dart(),
7263            ]
7264            .into_dart(),
7265            crate::model::SendDestination::Bolt12 {
7266                offer,
7267                receiver_amount_sat,
7268                bip353_address,
7269            } => [
7270                2.into_dart(),
7271                offer.into_into_dart().into_dart(),
7272                receiver_amount_sat.into_into_dart().into_dart(),
7273                bip353_address.into_into_dart().into_dart(),
7274            ]
7275            .into_dart(),
7276            _ => {
7277                unimplemented!("");
7278            }
7279        }
7280    }
7281}
7282impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::SendDestination {}
7283impl flutter_rust_bridge::IntoIntoDart<crate::model::SendDestination>
7284    for crate::model::SendDestination
7285{
7286    fn into_into_dart(self) -> crate::model::SendDestination {
7287        self
7288    }
7289}
7290// Codec=Dco (DartCObject based), see doc to use other codecs
7291impl flutter_rust_bridge::IntoDart for crate::model::SendPaymentRequest {
7292    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7293        [
7294            self.prepare_response.into_into_dart().into_dart(),
7295            self.use_asset_fees.into_into_dart().into_dart(),
7296        ]
7297        .into_dart()
7298    }
7299}
7300impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7301    for crate::model::SendPaymentRequest
7302{
7303}
7304impl flutter_rust_bridge::IntoIntoDart<crate::model::SendPaymentRequest>
7305    for crate::model::SendPaymentRequest
7306{
7307    fn into_into_dart(self) -> crate::model::SendPaymentRequest {
7308        self
7309    }
7310}
7311// Codec=Dco (DartCObject based), see doc to use other codecs
7312impl flutter_rust_bridge::IntoDart for crate::model::SendPaymentResponse {
7313    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7314        [self.payment.into_into_dart().into_dart()].into_dart()
7315    }
7316}
7317impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7318    for crate::model::SendPaymentResponse
7319{
7320}
7321impl flutter_rust_bridge::IntoIntoDart<crate::model::SendPaymentResponse>
7322    for crate::model::SendPaymentResponse
7323{
7324    fn into_into_dart(self) -> crate::model::SendPaymentResponse {
7325        self
7326    }
7327}
7328// Codec=Dco (DartCObject based), see doc to use other codecs
7329impl flutter_rust_bridge::IntoDart for crate::model::SignMessageRequest {
7330    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7331        [self.message.into_into_dart().into_dart()].into_dart()
7332    }
7333}
7334impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7335    for crate::model::SignMessageRequest
7336{
7337}
7338impl flutter_rust_bridge::IntoIntoDart<crate::model::SignMessageRequest>
7339    for crate::model::SignMessageRequest
7340{
7341    fn into_into_dart(self) -> crate::model::SignMessageRequest {
7342        self
7343    }
7344}
7345// Codec=Dco (DartCObject based), see doc to use other codecs
7346impl flutter_rust_bridge::IntoDart for crate::model::SignMessageResponse {
7347    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7348        [self.signature.into_into_dart().into_dart()].into_dart()
7349    }
7350}
7351impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7352    for crate::model::SignMessageResponse
7353{
7354}
7355impl flutter_rust_bridge::IntoIntoDart<crate::model::SignMessageResponse>
7356    for crate::model::SignMessageResponse
7357{
7358    fn into_into_dart(self) -> crate::model::SignMessageResponse {
7359        self
7360    }
7361}
7362// Codec=Dco (DartCObject based), see doc to use other codecs
7363impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::SuccessAction> {
7364    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7365        match self.0 {
7366            crate::bindings::SuccessAction::Aes { data } => {
7367                [0.into_dart(), data.into_into_dart().into_dart()].into_dart()
7368            }
7369            crate::bindings::SuccessAction::Message { data } => {
7370                [1.into_dart(), data.into_into_dart().into_dart()].into_dart()
7371            }
7372            crate::bindings::SuccessAction::Url { data } => {
7373                [2.into_dart(), data.into_into_dart().into_dart()].into_dart()
7374            }
7375            _ => {
7376                unimplemented!("");
7377            }
7378        }
7379    }
7380}
7381impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7382    for FrbWrapper<crate::bindings::SuccessAction>
7383{
7384}
7385impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::SuccessAction>>
7386    for crate::bindings::SuccessAction
7387{
7388    fn into_into_dart(self) -> FrbWrapper<crate::bindings::SuccessAction> {
7389        self.into()
7390    }
7391}
7392// Codec=Dco (DartCObject based), see doc to use other codecs
7393impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::SuccessActionProcessed> {
7394    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7395        match self.0 {
7396            crate::bindings::SuccessActionProcessed::Aes { result } => {
7397                [0.into_dart(), result.into_into_dart().into_dart()].into_dart()
7398            }
7399            crate::bindings::SuccessActionProcessed::Message { data } => {
7400                [1.into_dart(), data.into_into_dart().into_dart()].into_dart()
7401            }
7402            crate::bindings::SuccessActionProcessed::Url { data } => {
7403                [2.into_dart(), data.into_into_dart().into_dart()].into_dart()
7404            }
7405            _ => {
7406                unimplemented!("");
7407            }
7408        }
7409    }
7410}
7411impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7412    for FrbWrapper<crate::bindings::SuccessActionProcessed>
7413{
7414}
7415impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::SuccessActionProcessed>>
7416    for crate::bindings::SuccessActionProcessed
7417{
7418    fn into_into_dart(self) -> FrbWrapper<crate::bindings::SuccessActionProcessed> {
7419        self.into()
7420    }
7421}
7422// Codec=Dco (DartCObject based), see doc to use other codecs
7423impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::Symbol> {
7424    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7425        [
7426            self.0.grapheme.into_into_dart().into_dart(),
7427            self.0.template.into_into_dart().into_dart(),
7428            self.0.rtl.into_into_dart().into_dart(),
7429            self.0.position.into_into_dart().into_dart(),
7430        ]
7431        .into_dart()
7432    }
7433}
7434impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7435    for FrbWrapper<crate::bindings::Symbol>
7436{
7437}
7438impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::Symbol>>
7439    for crate::bindings::Symbol
7440{
7441    fn into_into_dart(self) -> FrbWrapper<crate::bindings::Symbol> {
7442        self.into()
7443    }
7444}
7445// Codec=Dco (DartCObject based), see doc to use other codecs
7446impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::UrlSuccessActionData> {
7447    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7448        [
7449            self.0.description.into_into_dart().into_dart(),
7450            self.0.url.into_into_dart().into_dart(),
7451            self.0.matches_callback_domain.into_into_dart().into_dart(),
7452        ]
7453        .into_dart()
7454    }
7455}
7456impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7457    for FrbWrapper<crate::bindings::UrlSuccessActionData>
7458{
7459}
7460impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::UrlSuccessActionData>>
7461    for crate::bindings::UrlSuccessActionData
7462{
7463    fn into_into_dart(self) -> FrbWrapper<crate::bindings::UrlSuccessActionData> {
7464        self.into()
7465    }
7466}
7467// Codec=Dco (DartCObject based), see doc to use other codecs
7468impl flutter_rust_bridge::IntoDart for crate::model::WalletInfo {
7469    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7470        [
7471            self.balance_sat.into_into_dart().into_dart(),
7472            self.pending_send_sat.into_into_dart().into_dart(),
7473            self.pending_receive_sat.into_into_dart().into_dart(),
7474            self.fingerprint.into_into_dart().into_dart(),
7475            self.pubkey.into_into_dart().into_dart(),
7476            self.asset_balances.into_into_dart().into_dart(),
7477        ]
7478        .into_dart()
7479    }
7480}
7481impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::WalletInfo {}
7482impl flutter_rust_bridge::IntoIntoDart<crate::model::WalletInfo> for crate::model::WalletInfo {
7483    fn into_into_dart(self) -> crate::model::WalletInfo {
7484        self
7485    }
7486}
7487
7488impl SseEncode for flutter_rust_bridge::for_generated::anyhow::Error {
7489    // Codec=Sse (Serialization based), see doc to use other codecs
7490    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7491        <String>::sse_encode(format!("{:?}", self), serializer);
7492    }
7493}
7494
7495impl SseEncode for BindingLiquidSdk {
7496    // Codec=Sse (Serialization based), see doc to use other codecs
7497    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7498        <RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>>::sse_encode(flutter_rust_bridge::for_generated::rust_auto_opaque_encode::<_, StdArc<_>>(self), serializer);
7499    }
7500}
7501
7502impl SseEncode
7503    for RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>
7504{
7505    // Codec=Sse (Serialization based), see doc to use other codecs
7506    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7507        let (ptr, size) = self.sse_encode_raw();
7508        <usize>::sse_encode(ptr, serializer);
7509        <i32>::sse_encode(size, serializer);
7510    }
7511}
7512
7513impl SseEncode
7514    for StreamSink<crate::model::LogEntry, flutter_rust_bridge::for_generated::DcoCodec>
7515{
7516    // Codec=Sse (Serialization based), see doc to use other codecs
7517    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7518        unimplemented!("")
7519    }
7520}
7521
7522impl SseEncode
7523    for StreamSink<crate::model::SdkEvent, flutter_rust_bridge::for_generated::DcoCodec>
7524{
7525    // Codec=Sse (Serialization based), see doc to use other codecs
7526    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7527        unimplemented!("")
7528    }
7529}
7530
7531impl SseEncode for String {
7532    // Codec=Sse (Serialization based), see doc to use other codecs
7533    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7534        <Vec<u8>>::sse_encode(self.into_bytes(), serializer);
7535    }
7536}
7537
7538impl SseEncode for crate::model::AcceptPaymentProposedFeesRequest {
7539    // Codec=Sse (Serialization based), see doc to use other codecs
7540    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7541        <crate::model::FetchPaymentProposedFeesResponse>::sse_encode(self.response, serializer);
7542    }
7543}
7544
7545impl SseEncode for crate::bindings::AesSuccessActionData {
7546    // Codec=Sse (Serialization based), see doc to use other codecs
7547    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7548        <String>::sse_encode(self.description, serializer);
7549        <String>::sse_encode(self.ciphertext, serializer);
7550        <String>::sse_encode(self.iv, serializer);
7551    }
7552}
7553
7554impl SseEncode for crate::bindings::AesSuccessActionDataDecrypted {
7555    // Codec=Sse (Serialization based), see doc to use other codecs
7556    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7557        <String>::sse_encode(self.description, serializer);
7558        <String>::sse_encode(self.plaintext, serializer);
7559    }
7560}
7561
7562impl SseEncode for crate::bindings::AesSuccessActionDataResult {
7563    // Codec=Sse (Serialization based), see doc to use other codecs
7564    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7565        match self {
7566            crate::bindings::AesSuccessActionDataResult::Decrypted { data } => {
7567                <i32>::sse_encode(0, serializer);
7568                <crate::bindings::AesSuccessActionDataDecrypted>::sse_encode(data, serializer);
7569            }
7570            crate::bindings::AesSuccessActionDataResult::ErrorStatus { reason } => {
7571                <i32>::sse_encode(1, serializer);
7572                <String>::sse_encode(reason, serializer);
7573            }
7574            _ => {
7575                unimplemented!("");
7576            }
7577        }
7578    }
7579}
7580
7581impl SseEncode for crate::bindings::Amount {
7582    // Codec=Sse (Serialization based), see doc to use other codecs
7583    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7584        match self {
7585            crate::bindings::Amount::Bitcoin { amount_msat } => {
7586                <i32>::sse_encode(0, serializer);
7587                <u64>::sse_encode(amount_msat, serializer);
7588            }
7589            crate::bindings::Amount::Currency {
7590                iso4217_code,
7591                fractional_amount,
7592            } => {
7593                <i32>::sse_encode(1, serializer);
7594                <String>::sse_encode(iso4217_code, serializer);
7595                <u64>::sse_encode(fractional_amount, serializer);
7596            }
7597            _ => {
7598                unimplemented!("");
7599            }
7600        }
7601    }
7602}
7603
7604impl SseEncode for crate::model::AssetBalance {
7605    // Codec=Sse (Serialization based), see doc to use other codecs
7606    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7607        <String>::sse_encode(self.asset_id, serializer);
7608        <u64>::sse_encode(self.balance_sat, serializer);
7609        <Option<String>>::sse_encode(self.name, serializer);
7610        <Option<String>>::sse_encode(self.ticker, serializer);
7611        <Option<f64>>::sse_encode(self.balance, serializer);
7612    }
7613}
7614
7615impl SseEncode for crate::model::AssetInfo {
7616    // Codec=Sse (Serialization based), see doc to use other codecs
7617    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7618        <String>::sse_encode(self.name, serializer);
7619        <String>::sse_encode(self.ticker, serializer);
7620        <f64>::sse_encode(self.amount, serializer);
7621        <Option<f64>>::sse_encode(self.fees, serializer);
7622    }
7623}
7624
7625impl SseEncode for crate::model::AssetMetadata {
7626    // Codec=Sse (Serialization based), see doc to use other codecs
7627    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7628        <String>::sse_encode(self.asset_id, serializer);
7629        <String>::sse_encode(self.name, serializer);
7630        <String>::sse_encode(self.ticker, serializer);
7631        <u8>::sse_encode(self.precision, serializer);
7632        <Option<String>>::sse_encode(self.fiat_id, serializer);
7633    }
7634}
7635
7636impl SseEncode for crate::model::BackupRequest {
7637    // Codec=Sse (Serialization based), see doc to use other codecs
7638    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7639        <Option<String>>::sse_encode(self.backup_path, serializer);
7640    }
7641}
7642
7643impl SseEncode for crate::bindings::BindingEventListener {
7644    // Codec=Sse (Serialization based), see doc to use other codecs
7645    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7646        <StreamSink<crate::model::SdkEvent,flutter_rust_bridge::for_generated::DcoCodec>>::sse_encode(self.stream, serializer);
7647    }
7648}
7649
7650impl SseEncode for crate::bindings::BitcoinAddressData {
7651    // Codec=Sse (Serialization based), see doc to use other codecs
7652    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7653        <String>::sse_encode(self.address, serializer);
7654        <crate::bindings::Network>::sse_encode(self.network, serializer);
7655        <Option<u64>>::sse_encode(self.amount_sat, serializer);
7656        <Option<String>>::sse_encode(self.label, serializer);
7657        <Option<String>>::sse_encode(self.message, serializer);
7658    }
7659}
7660
7661impl SseEncode for crate::model::BlockchainExplorer {
7662    // Codec=Sse (Serialization based), see doc to use other codecs
7663    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7664        match self {
7665            crate::model::BlockchainExplorer::Electrum { url } => {
7666                <i32>::sse_encode(0, serializer);
7667                <String>::sse_encode(url, serializer);
7668            }
7669            crate::model::BlockchainExplorer::Esplora {
7670                url,
7671                use_waterfalls,
7672            } => {
7673                <i32>::sse_encode(1, serializer);
7674                <String>::sse_encode(url, serializer);
7675                <bool>::sse_encode(use_waterfalls, serializer);
7676            }
7677            _ => {
7678                unimplemented!("");
7679            }
7680        }
7681    }
7682}
7683
7684impl SseEncode for crate::model::BlockchainInfo {
7685    // Codec=Sse (Serialization based), see doc to use other codecs
7686    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7687        <u32>::sse_encode(self.liquid_tip, serializer);
7688        <u32>::sse_encode(self.bitcoin_tip, serializer);
7689    }
7690}
7691
7692impl SseEncode for bool {
7693    // Codec=Sse (Serialization based), see doc to use other codecs
7694    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7695        serializer.cursor.write_u8(self as _).unwrap();
7696    }
7697}
7698
7699impl SseEncode for crate::model::BuyBitcoinProvider {
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        <i32>::sse_encode(
7703            match self {
7704                crate::model::BuyBitcoinProvider::Moonpay => 0,
7705                _ => {
7706                    unimplemented!("");
7707                }
7708            },
7709            serializer,
7710        );
7711    }
7712}
7713
7714impl SseEncode for crate::model::BuyBitcoinRequest {
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        <crate::model::PrepareBuyBitcoinResponse>::sse_encode(self.prepare_response, serializer);
7718        <Option<String>>::sse_encode(self.redirect_url, serializer);
7719    }
7720}
7721
7722impl SseEncode for crate::model::CheckMessageRequest {
7723    // Codec=Sse (Serialization based), see doc to use other codecs
7724    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7725        <String>::sse_encode(self.message, serializer);
7726        <String>::sse_encode(self.pubkey, serializer);
7727        <String>::sse_encode(self.signature, serializer);
7728    }
7729}
7730
7731impl SseEncode for crate::model::CheckMessageResponse {
7732    // Codec=Sse (Serialization based), see doc to use other codecs
7733    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7734        <bool>::sse_encode(self.is_valid, serializer);
7735    }
7736}
7737
7738impl SseEncode for crate::model::Config {
7739    // Codec=Sse (Serialization based), see doc to use other codecs
7740    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7741        <crate::model::BlockchainExplorer>::sse_encode(self.liquid_explorer, serializer);
7742        <crate::model::BlockchainExplorer>::sse_encode(self.bitcoin_explorer, serializer);
7743        <String>::sse_encode(self.working_dir, serializer);
7744        <Option<String>>::sse_encode(self.cache_dir, serializer);
7745        <crate::model::LiquidNetwork>::sse_encode(self.network, serializer);
7746        <u64>::sse_encode(self.payment_timeout_sec, serializer);
7747        <Option<String>>::sse_encode(self.sync_service_url, serializer);
7748        <Option<u64>>::sse_encode(self.zero_conf_max_amount_sat, serializer);
7749        <Option<String>>::sse_encode(self.breez_api_key, serializer);
7750        <Option<Vec<crate::bindings::ExternalInputParser>>>::sse_encode(
7751            self.external_input_parsers,
7752            serializer,
7753        );
7754        <bool>::sse_encode(self.use_default_external_input_parsers, serializer);
7755        <Option<u32>>::sse_encode(self.onchain_fee_rate_leeway_sat_per_vbyte, serializer);
7756        <Option<Vec<crate::model::AssetMetadata>>>::sse_encode(self.asset_metadata, serializer);
7757        <Option<String>>::sse_encode(self.sideswap_api_key, serializer);
7758    }
7759}
7760
7761impl SseEncode for crate::model::ConnectRequest {
7762    // Codec=Sse (Serialization based), see doc to use other codecs
7763    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7764        <crate::model::Config>::sse_encode(self.config, serializer);
7765        <Option<String>>::sse_encode(self.mnemonic, serializer);
7766        <Option<String>>::sse_encode(self.passphrase, serializer);
7767        <Option<Vec<u8>>>::sse_encode(self.seed, serializer);
7768    }
7769}
7770
7771impl SseEncode for crate::model::CreateBolt12InvoiceRequest {
7772    // Codec=Sse (Serialization based), see doc to use other codecs
7773    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7774        <String>::sse_encode(self.offer, serializer);
7775        <String>::sse_encode(self.invoice_request, serializer);
7776    }
7777}
7778
7779impl SseEncode for crate::model::CreateBolt12InvoiceResponse {
7780    // Codec=Sse (Serialization based), see doc to use other codecs
7781    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7782        <String>::sse_encode(self.invoice, serializer);
7783    }
7784}
7785
7786impl SseEncode for crate::bindings::CurrencyInfo {
7787    // Codec=Sse (Serialization based), see doc to use other codecs
7788    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7789        <String>::sse_encode(self.name, serializer);
7790        <u32>::sse_encode(self.fraction_size, serializer);
7791        <Option<u32>>::sse_encode(self.spacing, serializer);
7792        <Option<crate::bindings::Symbol>>::sse_encode(self.symbol, serializer);
7793        <Option<crate::bindings::Symbol>>::sse_encode(self.uniq_symbol, serializer);
7794        <Vec<crate::bindings::LocalizedName>>::sse_encode(self.localized_name, serializer);
7795        <Vec<crate::bindings::LocaleOverrides>>::sse_encode(self.locale_overrides, serializer);
7796    }
7797}
7798
7799impl SseEncode for crate::bindings::ExternalInputParser {
7800    // Codec=Sse (Serialization based), see doc to use other codecs
7801    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7802        <String>::sse_encode(self.provider_id, serializer);
7803        <String>::sse_encode(self.input_regex, serializer);
7804        <String>::sse_encode(self.parser_url, serializer);
7805    }
7806}
7807
7808impl SseEncode for f64 {
7809    // Codec=Sse (Serialization based), see doc to use other codecs
7810    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7811        serializer.cursor.write_f64::<NativeEndian>(self).unwrap();
7812    }
7813}
7814
7815impl SseEncode for crate::model::FetchPaymentProposedFeesRequest {
7816    // Codec=Sse (Serialization based), see doc to use other codecs
7817    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7818        <String>::sse_encode(self.swap_id, serializer);
7819    }
7820}
7821
7822impl SseEncode for crate::model::FetchPaymentProposedFeesResponse {
7823    // Codec=Sse (Serialization based), see doc to use other codecs
7824    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7825        <String>::sse_encode(self.swap_id, serializer);
7826        <u64>::sse_encode(self.fees_sat, serializer);
7827        <u64>::sse_encode(self.payer_amount_sat, serializer);
7828        <u64>::sse_encode(self.receiver_amount_sat, serializer);
7829    }
7830}
7831
7832impl SseEncode for crate::bindings::FiatCurrency {
7833    // Codec=Sse (Serialization based), see doc to use other codecs
7834    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7835        <String>::sse_encode(self.id, serializer);
7836        <crate::bindings::CurrencyInfo>::sse_encode(self.info, serializer);
7837    }
7838}
7839
7840impl SseEncode for crate::model::GetInfoResponse {
7841    // Codec=Sse (Serialization based), see doc to use other codecs
7842    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7843        <crate::model::WalletInfo>::sse_encode(self.wallet_info, serializer);
7844        <crate::model::BlockchainInfo>::sse_encode(self.blockchain_info, serializer);
7845    }
7846}
7847
7848impl SseEncode for crate::model::GetPaymentRequest {
7849    // Codec=Sse (Serialization based), see doc to use other codecs
7850    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7851        match self {
7852            crate::model::GetPaymentRequest::PaymentHash { payment_hash } => {
7853                <i32>::sse_encode(0, serializer);
7854                <String>::sse_encode(payment_hash, serializer);
7855            }
7856            crate::model::GetPaymentRequest::SwapId { swap_id } => {
7857                <i32>::sse_encode(1, serializer);
7858                <String>::sse_encode(swap_id, serializer);
7859            }
7860            _ => {
7861                unimplemented!("");
7862            }
7863        }
7864    }
7865}
7866
7867impl SseEncode for i32 {
7868    // Codec=Sse (Serialization based), see doc to use other codecs
7869    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7870        serializer.cursor.write_i32::<NativeEndian>(self).unwrap();
7871    }
7872}
7873
7874impl SseEncode for i64 {
7875    // Codec=Sse (Serialization based), see doc to use other codecs
7876    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7877        serializer.cursor.write_i64::<NativeEndian>(self).unwrap();
7878    }
7879}
7880
7881impl SseEncode for crate::bindings::InputType {
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        match self {
7885            crate::bindings::InputType::BitcoinAddress { address } => {
7886                <i32>::sse_encode(0, serializer);
7887                <crate::bindings::BitcoinAddressData>::sse_encode(address, serializer);
7888            }
7889            crate::bindings::InputType::LiquidAddress { address } => {
7890                <i32>::sse_encode(1, serializer);
7891                <crate::bindings::LiquidAddressData>::sse_encode(address, serializer);
7892            }
7893            crate::bindings::InputType::Bolt11 { invoice } => {
7894                <i32>::sse_encode(2, serializer);
7895                <crate::bindings::LNInvoice>::sse_encode(invoice, serializer);
7896            }
7897            crate::bindings::InputType::Bolt12Offer {
7898                offer,
7899                bip353_address,
7900            } => {
7901                <i32>::sse_encode(3, serializer);
7902                <crate::bindings::LNOffer>::sse_encode(offer, serializer);
7903                <Option<String>>::sse_encode(bip353_address, serializer);
7904            }
7905            crate::bindings::InputType::NodeId { node_id } => {
7906                <i32>::sse_encode(4, serializer);
7907                <String>::sse_encode(node_id, serializer);
7908            }
7909            crate::bindings::InputType::Url { url } => {
7910                <i32>::sse_encode(5, serializer);
7911                <String>::sse_encode(url, serializer);
7912            }
7913            crate::bindings::InputType::LnUrlPay {
7914                data,
7915                bip353_address,
7916            } => {
7917                <i32>::sse_encode(6, serializer);
7918                <crate::bindings::LnUrlPayRequestData>::sse_encode(data, serializer);
7919                <Option<String>>::sse_encode(bip353_address, serializer);
7920            }
7921            crate::bindings::InputType::LnUrlWithdraw { data } => {
7922                <i32>::sse_encode(7, serializer);
7923                <crate::bindings::LnUrlWithdrawRequestData>::sse_encode(data, serializer);
7924            }
7925            crate::bindings::InputType::LnUrlAuth { data } => {
7926                <i32>::sse_encode(8, serializer);
7927                <crate::bindings::LnUrlAuthRequestData>::sse_encode(data, serializer);
7928            }
7929            crate::bindings::InputType::LnUrlError { data } => {
7930                <i32>::sse_encode(9, serializer);
7931                <crate::bindings::LnUrlErrorData>::sse_encode(data, serializer);
7932            }
7933            _ => {
7934                unimplemented!("");
7935            }
7936        }
7937    }
7938}
7939
7940impl SseEncode for crate::model::LightningPaymentLimitsResponse {
7941    // Codec=Sse (Serialization based), see doc to use other codecs
7942    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7943        <crate::model::Limits>::sse_encode(self.send, serializer);
7944        <crate::model::Limits>::sse_encode(self.receive, serializer);
7945    }
7946}
7947
7948impl SseEncode for crate::model::Limits {
7949    // Codec=Sse (Serialization based), see doc to use other codecs
7950    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7951        <u64>::sse_encode(self.min_sat, serializer);
7952        <u64>::sse_encode(self.max_sat, serializer);
7953        <u64>::sse_encode(self.max_zero_conf_sat, serializer);
7954    }
7955}
7956
7957impl SseEncode for crate::bindings::LiquidAddressData {
7958    // Codec=Sse (Serialization based), see doc to use other codecs
7959    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7960        <String>::sse_encode(self.address, serializer);
7961        <crate::bindings::Network>::sse_encode(self.network, serializer);
7962        <Option<String>>::sse_encode(self.asset_id, serializer);
7963        <Option<f64>>::sse_encode(self.amount, serializer);
7964        <Option<u64>>::sse_encode(self.amount_sat, serializer);
7965        <Option<String>>::sse_encode(self.label, serializer);
7966        <Option<String>>::sse_encode(self.message, serializer);
7967    }
7968}
7969
7970impl SseEncode for crate::model::LiquidNetwork {
7971    // Codec=Sse (Serialization based), see doc to use other codecs
7972    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7973        <i32>::sse_encode(
7974            match self {
7975                crate::model::LiquidNetwork::Mainnet => 0,
7976                crate::model::LiquidNetwork::Testnet => 1,
7977                crate::model::LiquidNetwork::Regtest => 2,
7978                _ => {
7979                    unimplemented!("");
7980                }
7981            },
7982            serializer,
7983        );
7984    }
7985}
7986
7987impl SseEncode for Vec<String> {
7988    // Codec=Sse (Serialization based), see doc to use other codecs
7989    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7990        <i32>::sse_encode(self.len() as _, serializer);
7991        for item in self {
7992            <String>::sse_encode(item, serializer);
7993        }
7994    }
7995}
7996
7997impl SseEncode for Vec<crate::model::AssetBalance> {
7998    // Codec=Sse (Serialization based), see doc to use other codecs
7999    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8000        <i32>::sse_encode(self.len() as _, serializer);
8001        for item in self {
8002            <crate::model::AssetBalance>::sse_encode(item, serializer);
8003        }
8004    }
8005}
8006
8007impl SseEncode for Vec<crate::model::AssetMetadata> {
8008    // Codec=Sse (Serialization based), see doc to use other codecs
8009    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8010        <i32>::sse_encode(self.len() as _, serializer);
8011        for item in self {
8012            <crate::model::AssetMetadata>::sse_encode(item, serializer);
8013        }
8014    }
8015}
8016
8017impl SseEncode for Vec<crate::bindings::ExternalInputParser> {
8018    // Codec=Sse (Serialization based), see doc to use other codecs
8019    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8020        <i32>::sse_encode(self.len() as _, serializer);
8021        for item in self {
8022            <crate::bindings::ExternalInputParser>::sse_encode(item, serializer);
8023        }
8024    }
8025}
8026
8027impl SseEncode for Vec<crate::bindings::FiatCurrency> {
8028    // Codec=Sse (Serialization based), see doc to use other codecs
8029    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8030        <i32>::sse_encode(self.len() as _, serializer);
8031        for item in self {
8032            <crate::bindings::FiatCurrency>::sse_encode(item, serializer);
8033        }
8034    }
8035}
8036
8037impl SseEncode for Vec<crate::bindings::LnOfferBlindedPath> {
8038    // Codec=Sse (Serialization based), see doc to use other codecs
8039    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8040        <i32>::sse_encode(self.len() as _, serializer);
8041        for item in self {
8042            <crate::bindings::LnOfferBlindedPath>::sse_encode(item, serializer);
8043        }
8044    }
8045}
8046
8047impl SseEncode for Vec<crate::bindings::LocaleOverrides> {
8048    // Codec=Sse (Serialization based), see doc to use other codecs
8049    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8050        <i32>::sse_encode(self.len() as _, serializer);
8051        for item in self {
8052            <crate::bindings::LocaleOverrides>::sse_encode(item, serializer);
8053        }
8054    }
8055}
8056
8057impl SseEncode for Vec<crate::bindings::LocalizedName> {
8058    // Codec=Sse (Serialization based), see doc to use other codecs
8059    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8060        <i32>::sse_encode(self.len() as _, serializer);
8061        for item in self {
8062            <crate::bindings::LocalizedName>::sse_encode(item, serializer);
8063        }
8064    }
8065}
8066
8067impl SseEncode for Vec<crate::model::Payment> {
8068    // Codec=Sse (Serialization based), see doc to use other codecs
8069    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8070        <i32>::sse_encode(self.len() as _, serializer);
8071        for item in self {
8072            <crate::model::Payment>::sse_encode(item, serializer);
8073        }
8074    }
8075}
8076
8077impl SseEncode for crate::model::ListPaymentDetails {
8078    // Codec=Sse (Serialization based), see doc to use other codecs
8079    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8080        match self {
8081            crate::model::ListPaymentDetails::Liquid {
8082                asset_id,
8083                destination,
8084            } => {
8085                <i32>::sse_encode(0, serializer);
8086                <Option<String>>::sse_encode(asset_id, serializer);
8087                <Option<String>>::sse_encode(destination, serializer);
8088            }
8089            crate::model::ListPaymentDetails::Bitcoin { address } => {
8090                <i32>::sse_encode(1, serializer);
8091                <Option<String>>::sse_encode(address, serializer);
8092            }
8093            _ => {
8094                unimplemented!("");
8095            }
8096        }
8097    }
8098}
8099
8100impl SseEncode for Vec<crate::model::PaymentState> {
8101    // Codec=Sse (Serialization based), see doc to use other codecs
8102    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8103        <i32>::sse_encode(self.len() as _, serializer);
8104        for item in self {
8105            <crate::model::PaymentState>::sse_encode(item, serializer);
8106        }
8107    }
8108}
8109
8110impl SseEncode for Vec<crate::model::PaymentType> {
8111    // Codec=Sse (Serialization based), see doc to use other codecs
8112    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8113        <i32>::sse_encode(self.len() as _, serializer);
8114        for item in self {
8115            <crate::model::PaymentType>::sse_encode(item, serializer);
8116        }
8117    }
8118}
8119
8120impl SseEncode for crate::model::ListPaymentsRequest {
8121    // Codec=Sse (Serialization based), see doc to use other codecs
8122    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8123        <Option<Vec<crate::model::PaymentType>>>::sse_encode(self.filters, serializer);
8124        <Option<Vec<crate::model::PaymentState>>>::sse_encode(self.states, serializer);
8125        <Option<i64>>::sse_encode(self.from_timestamp, serializer);
8126        <Option<i64>>::sse_encode(self.to_timestamp, serializer);
8127        <Option<u32>>::sse_encode(self.offset, serializer);
8128        <Option<u32>>::sse_encode(self.limit, serializer);
8129        <Option<crate::model::ListPaymentDetails>>::sse_encode(self.details, serializer);
8130        <Option<bool>>::sse_encode(self.sort_ascending, serializer);
8131    }
8132}
8133
8134impl SseEncode for Vec<u8> {
8135    // Codec=Sse (Serialization based), see doc to use other codecs
8136    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8137        <i32>::sse_encode(self.len() as _, serializer);
8138        for item in self {
8139            <u8>::sse_encode(item, serializer);
8140        }
8141    }
8142}
8143
8144impl SseEncode for Vec<crate::bindings::Rate> {
8145    // Codec=Sse (Serialization based), see doc to use other codecs
8146    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8147        <i32>::sse_encode(self.len() as _, serializer);
8148        for item in self {
8149            <crate::bindings::Rate>::sse_encode(item, serializer);
8150        }
8151    }
8152}
8153
8154impl SseEncode for Vec<crate::model::RefundableSwap> {
8155    // Codec=Sse (Serialization based), see doc to use other codecs
8156    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8157        <i32>::sse_encode(self.len() as _, serializer);
8158        for item in self {
8159            <crate::model::RefundableSwap>::sse_encode(item, serializer);
8160        }
8161    }
8162}
8163
8164impl SseEncode for Vec<crate::bindings::RouteHint> {
8165    // Codec=Sse (Serialization based), see doc to use other codecs
8166    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8167        <i32>::sse_encode(self.len() as _, serializer);
8168        for item in self {
8169            <crate::bindings::RouteHint>::sse_encode(item, serializer);
8170        }
8171    }
8172}
8173
8174impl SseEncode for Vec<crate::bindings::RouteHintHop> {
8175    // Codec=Sse (Serialization based), see doc to use other codecs
8176    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8177        <i32>::sse_encode(self.len() as _, serializer);
8178        for item in self {
8179            <crate::bindings::RouteHintHop>::sse_encode(item, serializer);
8180        }
8181    }
8182}
8183
8184impl SseEncode for crate::bindings::LNInvoice {
8185    // Codec=Sse (Serialization based), see doc to use other codecs
8186    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8187        <String>::sse_encode(self.bolt11, serializer);
8188        <crate::bindings::Network>::sse_encode(self.network, serializer);
8189        <String>::sse_encode(self.payee_pubkey, serializer);
8190        <String>::sse_encode(self.payment_hash, serializer);
8191        <Option<String>>::sse_encode(self.description, serializer);
8192        <Option<String>>::sse_encode(self.description_hash, serializer);
8193        <Option<u64>>::sse_encode(self.amount_msat, serializer);
8194        <u64>::sse_encode(self.timestamp, serializer);
8195        <u64>::sse_encode(self.expiry, serializer);
8196        <Vec<crate::bindings::RouteHint>>::sse_encode(self.routing_hints, serializer);
8197        <Vec<u8>>::sse_encode(self.payment_secret, serializer);
8198        <u64>::sse_encode(self.min_final_cltv_expiry_delta, serializer);
8199    }
8200}
8201
8202impl SseEncode for crate::bindings::LNOffer {
8203    // Codec=Sse (Serialization based), see doc to use other codecs
8204    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8205        <String>::sse_encode(self.offer, serializer);
8206        <Vec<String>>::sse_encode(self.chains, serializer);
8207        <Option<crate::bindings::Amount>>::sse_encode(self.min_amount, serializer);
8208        <Option<String>>::sse_encode(self.description, serializer);
8209        <Option<u64>>::sse_encode(self.absolute_expiry, serializer);
8210        <Option<String>>::sse_encode(self.issuer, serializer);
8211        <Option<String>>::sse_encode(self.signing_pubkey, serializer);
8212        <Vec<crate::bindings::LnOfferBlindedPath>>::sse_encode(self.paths, serializer);
8213    }
8214}
8215
8216impl SseEncode for crate::bindings::LnOfferBlindedPath {
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        <Vec<String>>::sse_encode(self.blinded_hops, serializer);
8220    }
8221}
8222
8223impl SseEncode for crate::bindings::duplicates::LnUrlAuthError {
8224    // Codec=Sse (Serialization based), see doc to use other codecs
8225    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8226        match self {
8227            crate::bindings::duplicates::LnUrlAuthError::Generic { err } => {
8228                <i32>::sse_encode(0, serializer);
8229                <String>::sse_encode(err, serializer);
8230            }
8231            crate::bindings::duplicates::LnUrlAuthError::InvalidUri { err } => {
8232                <i32>::sse_encode(1, serializer);
8233                <String>::sse_encode(err, serializer);
8234            }
8235            crate::bindings::duplicates::LnUrlAuthError::ServiceConnectivity { err } => {
8236                <i32>::sse_encode(2, serializer);
8237                <String>::sse_encode(err, serializer);
8238            }
8239            _ => {
8240                unimplemented!("");
8241            }
8242        }
8243    }
8244}
8245
8246impl SseEncode for crate::bindings::LnUrlAuthRequestData {
8247    // Codec=Sse (Serialization based), see doc to use other codecs
8248    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8249        <String>::sse_encode(self.k1, serializer);
8250        <Option<String>>::sse_encode(self.action, serializer);
8251        <String>::sse_encode(self.domain, serializer);
8252        <String>::sse_encode(self.url, serializer);
8253    }
8254}
8255
8256impl SseEncode for crate::bindings::duplicates::LnUrlCallbackStatus {
8257    // Codec=Sse (Serialization based), see doc to use other codecs
8258    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8259        match self {
8260            crate::bindings::duplicates::LnUrlCallbackStatus::Ok => {
8261                <i32>::sse_encode(0, serializer);
8262            }
8263            crate::bindings::duplicates::LnUrlCallbackStatus::ErrorStatus { data } => {
8264                <i32>::sse_encode(1, serializer);
8265                <crate::bindings::LnUrlErrorData>::sse_encode(data, serializer);
8266            }
8267            _ => {
8268                unimplemented!("");
8269            }
8270        }
8271    }
8272}
8273
8274impl SseEncode for crate::bindings::LnUrlErrorData {
8275    // Codec=Sse (Serialization based), see doc to use other codecs
8276    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8277        <String>::sse_encode(self.reason, serializer);
8278    }
8279}
8280
8281impl SseEncode for crate::model::LnUrlInfo {
8282    // Codec=Sse (Serialization based), see doc to use other codecs
8283    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8284        <Option<String>>::sse_encode(self.ln_address, serializer);
8285        <Option<String>>::sse_encode(self.lnurl_pay_comment, serializer);
8286        <Option<String>>::sse_encode(self.lnurl_pay_domain, serializer);
8287        <Option<String>>::sse_encode(self.lnurl_pay_metadata, serializer);
8288        <Option<crate::bindings::SuccessActionProcessed>>::sse_encode(
8289            self.lnurl_pay_success_action,
8290            serializer,
8291        );
8292        <Option<crate::bindings::SuccessAction>>::sse_encode(
8293            self.lnurl_pay_unprocessed_success_action,
8294            serializer,
8295        );
8296        <Option<String>>::sse_encode(self.lnurl_withdraw_endpoint, serializer);
8297    }
8298}
8299
8300impl SseEncode for crate::bindings::duplicates::LnUrlPayError {
8301    // Codec=Sse (Serialization based), see doc to use other codecs
8302    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8303        match self {
8304            crate::bindings::duplicates::LnUrlPayError::AlreadyPaid => {
8305                <i32>::sse_encode(0, serializer);
8306            }
8307            crate::bindings::duplicates::LnUrlPayError::Generic { err } => {
8308                <i32>::sse_encode(1, serializer);
8309                <String>::sse_encode(err, serializer);
8310            }
8311            crate::bindings::duplicates::LnUrlPayError::InsufficientBalance { err } => {
8312                <i32>::sse_encode(2, serializer);
8313                <String>::sse_encode(err, serializer);
8314            }
8315            crate::bindings::duplicates::LnUrlPayError::InvalidAmount { err } => {
8316                <i32>::sse_encode(3, serializer);
8317                <String>::sse_encode(err, serializer);
8318            }
8319            crate::bindings::duplicates::LnUrlPayError::InvalidInvoice { err } => {
8320                <i32>::sse_encode(4, serializer);
8321                <String>::sse_encode(err, serializer);
8322            }
8323            crate::bindings::duplicates::LnUrlPayError::InvalidNetwork { err } => {
8324                <i32>::sse_encode(5, serializer);
8325                <String>::sse_encode(err, serializer);
8326            }
8327            crate::bindings::duplicates::LnUrlPayError::InvalidUri { err } => {
8328                <i32>::sse_encode(6, serializer);
8329                <String>::sse_encode(err, serializer);
8330            }
8331            crate::bindings::duplicates::LnUrlPayError::InvoiceExpired { err } => {
8332                <i32>::sse_encode(7, serializer);
8333                <String>::sse_encode(err, serializer);
8334            }
8335            crate::bindings::duplicates::LnUrlPayError::PaymentFailed { err } => {
8336                <i32>::sse_encode(8, serializer);
8337                <String>::sse_encode(err, serializer);
8338            }
8339            crate::bindings::duplicates::LnUrlPayError::PaymentTimeout { err } => {
8340                <i32>::sse_encode(9, serializer);
8341                <String>::sse_encode(err, serializer);
8342            }
8343            crate::bindings::duplicates::LnUrlPayError::RouteNotFound { err } => {
8344                <i32>::sse_encode(10, serializer);
8345                <String>::sse_encode(err, serializer);
8346            }
8347            crate::bindings::duplicates::LnUrlPayError::RouteTooExpensive { err } => {
8348                <i32>::sse_encode(11, serializer);
8349                <String>::sse_encode(err, serializer);
8350            }
8351            crate::bindings::duplicates::LnUrlPayError::ServiceConnectivity { err } => {
8352                <i32>::sse_encode(12, serializer);
8353                <String>::sse_encode(err, serializer);
8354            }
8355            _ => {
8356                unimplemented!("");
8357            }
8358        }
8359    }
8360}
8361
8362impl SseEncode for crate::bindings::LnUrlPayErrorData {
8363    // Codec=Sse (Serialization based), see doc to use other codecs
8364    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8365        <String>::sse_encode(self.payment_hash, serializer);
8366        <String>::sse_encode(self.reason, serializer);
8367    }
8368}
8369
8370impl SseEncode for crate::model::LnUrlPayRequest {
8371    // Codec=Sse (Serialization based), see doc to use other codecs
8372    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8373        <crate::model::PrepareLnUrlPayResponse>::sse_encode(self.prepare_response, serializer);
8374    }
8375}
8376
8377impl SseEncode for crate::bindings::LnUrlPayRequestData {
8378    // Codec=Sse (Serialization based), see doc to use other codecs
8379    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8380        <String>::sse_encode(self.callback, serializer);
8381        <u64>::sse_encode(self.min_sendable, serializer);
8382        <u64>::sse_encode(self.max_sendable, serializer);
8383        <String>::sse_encode(self.metadata_str, serializer);
8384        <u16>::sse_encode(self.comment_allowed, serializer);
8385        <String>::sse_encode(self.domain, serializer);
8386        <bool>::sse_encode(self.allows_nostr, serializer);
8387        <Option<String>>::sse_encode(self.nostr_pubkey, serializer);
8388        <Option<String>>::sse_encode(self.ln_address, serializer);
8389    }
8390}
8391
8392impl SseEncode for crate::model::LnUrlPayResult {
8393    // Codec=Sse (Serialization based), see doc to use other codecs
8394    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8395        match self {
8396            crate::model::LnUrlPayResult::EndpointSuccess { data } => {
8397                <i32>::sse_encode(0, serializer);
8398                <crate::model::LnUrlPaySuccessData>::sse_encode(data, serializer);
8399            }
8400            crate::model::LnUrlPayResult::EndpointError { data } => {
8401                <i32>::sse_encode(1, serializer);
8402                <crate::bindings::LnUrlErrorData>::sse_encode(data, serializer);
8403            }
8404            crate::model::LnUrlPayResult::PayError { data } => {
8405                <i32>::sse_encode(2, serializer);
8406                <crate::bindings::LnUrlPayErrorData>::sse_encode(data, serializer);
8407            }
8408            _ => {
8409                unimplemented!("");
8410            }
8411        }
8412    }
8413}
8414
8415impl SseEncode for crate::model::LnUrlPaySuccessData {
8416    // Codec=Sse (Serialization based), see doc to use other codecs
8417    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8418        <crate::model::Payment>::sse_encode(self.payment, serializer);
8419        <Option<crate::bindings::SuccessActionProcessed>>::sse_encode(
8420            self.success_action,
8421            serializer,
8422        );
8423    }
8424}
8425
8426impl SseEncode for crate::bindings::duplicates::LnUrlWithdrawError {
8427    // Codec=Sse (Serialization based), see doc to use other codecs
8428    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8429        match self {
8430            crate::bindings::duplicates::LnUrlWithdrawError::Generic { err } => {
8431                <i32>::sse_encode(0, serializer);
8432                <String>::sse_encode(err, serializer);
8433            }
8434            crate::bindings::duplicates::LnUrlWithdrawError::InvalidAmount { err } => {
8435                <i32>::sse_encode(1, serializer);
8436                <String>::sse_encode(err, serializer);
8437            }
8438            crate::bindings::duplicates::LnUrlWithdrawError::InvalidInvoice { err } => {
8439                <i32>::sse_encode(2, serializer);
8440                <String>::sse_encode(err, serializer);
8441            }
8442            crate::bindings::duplicates::LnUrlWithdrawError::InvalidUri { err } => {
8443                <i32>::sse_encode(3, serializer);
8444                <String>::sse_encode(err, serializer);
8445            }
8446            crate::bindings::duplicates::LnUrlWithdrawError::InvoiceNoRoutingHints { err } => {
8447                <i32>::sse_encode(4, serializer);
8448                <String>::sse_encode(err, serializer);
8449            }
8450            crate::bindings::duplicates::LnUrlWithdrawError::ServiceConnectivity { err } => {
8451                <i32>::sse_encode(5, serializer);
8452                <String>::sse_encode(err, serializer);
8453            }
8454            _ => {
8455                unimplemented!("");
8456            }
8457        }
8458    }
8459}
8460
8461impl SseEncode for crate::bindings::LnUrlWithdrawRequest {
8462    // Codec=Sse (Serialization based), see doc to use other codecs
8463    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8464        <crate::bindings::LnUrlWithdrawRequestData>::sse_encode(self.data, serializer);
8465        <u64>::sse_encode(self.amount_msat, serializer);
8466        <Option<String>>::sse_encode(self.description, serializer);
8467    }
8468}
8469
8470impl SseEncode for crate::bindings::LnUrlWithdrawRequestData {
8471    // Codec=Sse (Serialization based), see doc to use other codecs
8472    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8473        <String>::sse_encode(self.callback, serializer);
8474        <String>::sse_encode(self.k1, serializer);
8475        <String>::sse_encode(self.default_description, serializer);
8476        <u64>::sse_encode(self.min_withdrawable, serializer);
8477        <u64>::sse_encode(self.max_withdrawable, serializer);
8478    }
8479}
8480
8481impl SseEncode for crate::bindings::duplicates::LnUrlWithdrawResult {
8482    // Codec=Sse (Serialization based), see doc to use other codecs
8483    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8484        match self {
8485            crate::bindings::duplicates::LnUrlWithdrawResult::Ok { data } => {
8486                <i32>::sse_encode(0, serializer);
8487                <crate::bindings::duplicates::LnUrlWithdrawSuccessData>::sse_encode(
8488                    data, serializer,
8489                );
8490            }
8491            crate::bindings::duplicates::LnUrlWithdrawResult::Timeout { data } => {
8492                <i32>::sse_encode(1, serializer);
8493                <crate::bindings::duplicates::LnUrlWithdrawSuccessData>::sse_encode(
8494                    data, serializer,
8495                );
8496            }
8497            crate::bindings::duplicates::LnUrlWithdrawResult::ErrorStatus { data } => {
8498                <i32>::sse_encode(2, serializer);
8499                <crate::bindings::LnUrlErrorData>::sse_encode(data, serializer);
8500            }
8501            _ => {
8502                unimplemented!("");
8503            }
8504        }
8505    }
8506}
8507
8508impl SseEncode for crate::bindings::duplicates::LnUrlWithdrawSuccessData {
8509    // Codec=Sse (Serialization based), see doc to use other codecs
8510    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8511        <crate::bindings::LNInvoice>::sse_encode(self.invoice, serializer);
8512    }
8513}
8514
8515impl SseEncode for crate::bindings::LocaleOverrides {
8516    // Codec=Sse (Serialization based), see doc to use other codecs
8517    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8518        <String>::sse_encode(self.locale, serializer);
8519        <Option<u32>>::sse_encode(self.spacing, serializer);
8520        <crate::bindings::Symbol>::sse_encode(self.symbol, serializer);
8521    }
8522}
8523
8524impl SseEncode for crate::bindings::LocalizedName {
8525    // Codec=Sse (Serialization based), see doc to use other codecs
8526    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8527        <String>::sse_encode(self.locale, serializer);
8528        <String>::sse_encode(self.name, serializer);
8529    }
8530}
8531
8532impl SseEncode for crate::model::LogEntry {
8533    // Codec=Sse (Serialization based), see doc to use other codecs
8534    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8535        <String>::sse_encode(self.line, serializer);
8536        <String>::sse_encode(self.level, serializer);
8537    }
8538}
8539
8540impl SseEncode for crate::bindings::MessageSuccessActionData {
8541    // Codec=Sse (Serialization based), see doc to use other codecs
8542    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8543        <String>::sse_encode(self.message, serializer);
8544    }
8545}
8546
8547impl SseEncode for crate::bindings::Network {
8548    // Codec=Sse (Serialization based), see doc to use other codecs
8549    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8550        <i32>::sse_encode(
8551            match self {
8552                crate::bindings::Network::Bitcoin => 0,
8553                crate::bindings::Network::Testnet => 1,
8554                crate::bindings::Network::Signet => 2,
8555                crate::bindings::Network::Regtest => 3,
8556                _ => {
8557                    unimplemented!("");
8558                }
8559            },
8560            serializer,
8561        );
8562    }
8563}
8564
8565impl SseEncode for crate::model::OnchainPaymentLimitsResponse {
8566    // Codec=Sse (Serialization based), see doc to use other codecs
8567    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8568        <crate::model::Limits>::sse_encode(self.send, serializer);
8569        <crate::model::Limits>::sse_encode(self.receive, serializer);
8570    }
8571}
8572
8573impl SseEncode for Option<String> {
8574    // Codec=Sse (Serialization based), see doc to use other codecs
8575    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8576        <bool>::sse_encode(self.is_some(), serializer);
8577        if let Some(value) = self {
8578            <String>::sse_encode(value, serializer);
8579        }
8580    }
8581}
8582
8583impl SseEncode for Option<crate::bindings::Amount> {
8584    // Codec=Sse (Serialization based), see doc to use other codecs
8585    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8586        <bool>::sse_encode(self.is_some(), serializer);
8587        if let Some(value) = self {
8588            <crate::bindings::Amount>::sse_encode(value, serializer);
8589        }
8590    }
8591}
8592
8593impl SseEncode for Option<crate::model::AssetInfo> {
8594    // Codec=Sse (Serialization based), see doc to use other codecs
8595    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8596        <bool>::sse_encode(self.is_some(), serializer);
8597        if let Some(value) = self {
8598            <crate::model::AssetInfo>::sse_encode(value, serializer);
8599        }
8600    }
8601}
8602
8603impl SseEncode for Option<bool> {
8604    // Codec=Sse (Serialization based), see doc to use other codecs
8605    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8606        <bool>::sse_encode(self.is_some(), serializer);
8607        if let Some(value) = self {
8608            <bool>::sse_encode(value, serializer);
8609        }
8610    }
8611}
8612
8613impl SseEncode for Option<f64> {
8614    // Codec=Sse (Serialization based), see doc to use other codecs
8615    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8616        <bool>::sse_encode(self.is_some(), serializer);
8617        if let Some(value) = self {
8618            <f64>::sse_encode(value, serializer);
8619        }
8620    }
8621}
8622
8623impl SseEncode for Option<i64> {
8624    // Codec=Sse (Serialization based), see doc to use other codecs
8625    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8626        <bool>::sse_encode(self.is_some(), serializer);
8627        if let Some(value) = self {
8628            <i64>::sse_encode(value, serializer);
8629        }
8630    }
8631}
8632
8633impl SseEncode for Option<crate::model::ListPaymentDetails> {
8634    // Codec=Sse (Serialization based), see doc to use other codecs
8635    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8636        <bool>::sse_encode(self.is_some(), serializer);
8637        if let Some(value) = self {
8638            <crate::model::ListPaymentDetails>::sse_encode(value, serializer);
8639        }
8640    }
8641}
8642
8643impl SseEncode for Option<crate::model::LnUrlInfo> {
8644    // Codec=Sse (Serialization based), see doc to use other codecs
8645    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8646        <bool>::sse_encode(self.is_some(), serializer);
8647        if let Some(value) = self {
8648            <crate::model::LnUrlInfo>::sse_encode(value, serializer);
8649        }
8650    }
8651}
8652
8653impl SseEncode for Option<crate::model::PayAmount> {
8654    // Codec=Sse (Serialization based), see doc to use other codecs
8655    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8656        <bool>::sse_encode(self.is_some(), serializer);
8657        if let Some(value) = self {
8658            <crate::model::PayAmount>::sse_encode(value, serializer);
8659        }
8660    }
8661}
8662
8663impl SseEncode for Option<crate::model::Payment> {
8664    // Codec=Sse (Serialization based), see doc to use other codecs
8665    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8666        <bool>::sse_encode(self.is_some(), serializer);
8667        if let Some(value) = self {
8668            <crate::model::Payment>::sse_encode(value, serializer);
8669        }
8670    }
8671}
8672
8673impl SseEncode for Option<crate::model::ReceiveAmount> {
8674    // Codec=Sse (Serialization based), see doc to use other codecs
8675    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8676        <bool>::sse_encode(self.is_some(), serializer);
8677        if let Some(value) = self {
8678            <crate::model::ReceiveAmount>::sse_encode(value, serializer);
8679        }
8680    }
8681}
8682
8683impl SseEncode for Option<crate::bindings::SuccessAction> {
8684    // Codec=Sse (Serialization based), see doc to use other codecs
8685    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8686        <bool>::sse_encode(self.is_some(), serializer);
8687        if let Some(value) = self {
8688            <crate::bindings::SuccessAction>::sse_encode(value, serializer);
8689        }
8690    }
8691}
8692
8693impl SseEncode for Option<crate::bindings::SuccessActionProcessed> {
8694    // Codec=Sse (Serialization based), see doc to use other codecs
8695    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8696        <bool>::sse_encode(self.is_some(), serializer);
8697        if let Some(value) = self {
8698            <crate::bindings::SuccessActionProcessed>::sse_encode(value, serializer);
8699        }
8700    }
8701}
8702
8703impl SseEncode for Option<crate::bindings::Symbol> {
8704    // Codec=Sse (Serialization based), see doc to use other codecs
8705    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8706        <bool>::sse_encode(self.is_some(), serializer);
8707        if let Some(value) = self {
8708            <crate::bindings::Symbol>::sse_encode(value, serializer);
8709        }
8710    }
8711}
8712
8713impl SseEncode for Option<u32> {
8714    // Codec=Sse (Serialization based), see doc to use other codecs
8715    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8716        <bool>::sse_encode(self.is_some(), serializer);
8717        if let Some(value) = self {
8718            <u32>::sse_encode(value, serializer);
8719        }
8720    }
8721}
8722
8723impl SseEncode for Option<u64> {
8724    // Codec=Sse (Serialization based), see doc to use other codecs
8725    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8726        <bool>::sse_encode(self.is_some(), serializer);
8727        if let Some(value) = self {
8728            <u64>::sse_encode(value, serializer);
8729        }
8730    }
8731}
8732
8733impl SseEncode for Option<Vec<crate::model::AssetMetadata>> {
8734    // Codec=Sse (Serialization based), see doc to use other codecs
8735    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8736        <bool>::sse_encode(self.is_some(), serializer);
8737        if let Some(value) = self {
8738            <Vec<crate::model::AssetMetadata>>::sse_encode(value, serializer);
8739        }
8740    }
8741}
8742
8743impl SseEncode for Option<Vec<crate::bindings::ExternalInputParser>> {
8744    // Codec=Sse (Serialization based), see doc to use other codecs
8745    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8746        <bool>::sse_encode(self.is_some(), serializer);
8747        if let Some(value) = self {
8748            <Vec<crate::bindings::ExternalInputParser>>::sse_encode(value, serializer);
8749        }
8750    }
8751}
8752
8753impl SseEncode for Option<Vec<crate::model::PaymentState>> {
8754    // Codec=Sse (Serialization based), see doc to use other codecs
8755    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8756        <bool>::sse_encode(self.is_some(), serializer);
8757        if let Some(value) = self {
8758            <Vec<crate::model::PaymentState>>::sse_encode(value, serializer);
8759        }
8760    }
8761}
8762
8763impl SseEncode for Option<Vec<crate::model::PaymentType>> {
8764    // Codec=Sse (Serialization based), see doc to use other codecs
8765    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8766        <bool>::sse_encode(self.is_some(), serializer);
8767        if let Some(value) = self {
8768            <Vec<crate::model::PaymentType>>::sse_encode(value, serializer);
8769        }
8770    }
8771}
8772
8773impl SseEncode for Option<Vec<u8>> {
8774    // Codec=Sse (Serialization based), see doc to use other codecs
8775    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8776        <bool>::sse_encode(self.is_some(), serializer);
8777        if let Some(value) = self {
8778            <Vec<u8>>::sse_encode(value, serializer);
8779        }
8780    }
8781}
8782
8783impl SseEncode for crate::model::PayAmount {
8784    // Codec=Sse (Serialization based), see doc to use other codecs
8785    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8786        match self {
8787            crate::model::PayAmount::Bitcoin {
8788                receiver_amount_sat,
8789            } => {
8790                <i32>::sse_encode(0, serializer);
8791                <u64>::sse_encode(receiver_amount_sat, serializer);
8792            }
8793            crate::model::PayAmount::Asset {
8794                asset_id,
8795                receiver_amount,
8796                estimate_asset_fees,
8797            } => {
8798                <i32>::sse_encode(1, serializer);
8799                <String>::sse_encode(asset_id, serializer);
8800                <f64>::sse_encode(receiver_amount, serializer);
8801                <Option<bool>>::sse_encode(estimate_asset_fees, serializer);
8802            }
8803            crate::model::PayAmount::Drain => {
8804                <i32>::sse_encode(2, serializer);
8805            }
8806            _ => {
8807                unimplemented!("");
8808            }
8809        }
8810    }
8811}
8812
8813impl SseEncode for crate::model::PayOnchainRequest {
8814    // Codec=Sse (Serialization based), see doc to use other codecs
8815    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8816        <String>::sse_encode(self.address, serializer);
8817        <crate::model::PreparePayOnchainResponse>::sse_encode(self.prepare_response, serializer);
8818    }
8819}
8820
8821impl SseEncode for crate::model::Payment {
8822    // Codec=Sse (Serialization based), see doc to use other codecs
8823    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8824        <Option<String>>::sse_encode(self.destination, serializer);
8825        <Option<String>>::sse_encode(self.tx_id, serializer);
8826        <Option<String>>::sse_encode(self.unblinding_data, serializer);
8827        <u32>::sse_encode(self.timestamp, serializer);
8828        <u64>::sse_encode(self.amount_sat, serializer);
8829        <u64>::sse_encode(self.fees_sat, serializer);
8830        <Option<u64>>::sse_encode(self.swapper_fees_sat, serializer);
8831        <crate::model::PaymentType>::sse_encode(self.payment_type, serializer);
8832        <crate::model::PaymentState>::sse_encode(self.status, serializer);
8833        <crate::model::PaymentDetails>::sse_encode(self.details, serializer);
8834    }
8835}
8836
8837impl SseEncode for crate::model::PaymentDetails {
8838    // Codec=Sse (Serialization based), see doc to use other codecs
8839    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8840        match self {
8841            crate::model::PaymentDetails::Lightning {
8842                swap_id,
8843                description,
8844                liquid_expiration_blockheight,
8845                preimage,
8846                invoice,
8847                bolt12_offer,
8848                payment_hash,
8849                destination_pubkey,
8850                lnurl_info,
8851                bip353_address,
8852                claim_tx_id,
8853                refund_tx_id,
8854                refund_tx_amount_sat,
8855            } => {
8856                <i32>::sse_encode(0, serializer);
8857                <String>::sse_encode(swap_id, serializer);
8858                <String>::sse_encode(description, serializer);
8859                <u32>::sse_encode(liquid_expiration_blockheight, serializer);
8860                <Option<String>>::sse_encode(preimage, serializer);
8861                <Option<String>>::sse_encode(invoice, serializer);
8862                <Option<String>>::sse_encode(bolt12_offer, serializer);
8863                <Option<String>>::sse_encode(payment_hash, serializer);
8864                <Option<String>>::sse_encode(destination_pubkey, serializer);
8865                <Option<crate::model::LnUrlInfo>>::sse_encode(lnurl_info, serializer);
8866                <Option<String>>::sse_encode(bip353_address, serializer);
8867                <Option<String>>::sse_encode(claim_tx_id, serializer);
8868                <Option<String>>::sse_encode(refund_tx_id, serializer);
8869                <Option<u64>>::sse_encode(refund_tx_amount_sat, serializer);
8870            }
8871            crate::model::PaymentDetails::Liquid {
8872                destination,
8873                description,
8874                asset_id,
8875                asset_info,
8876                lnurl_info,
8877                bip353_address,
8878            } => {
8879                <i32>::sse_encode(1, serializer);
8880                <String>::sse_encode(destination, serializer);
8881                <String>::sse_encode(description, serializer);
8882                <String>::sse_encode(asset_id, serializer);
8883                <Option<crate::model::AssetInfo>>::sse_encode(asset_info, serializer);
8884                <Option<crate::model::LnUrlInfo>>::sse_encode(lnurl_info, serializer);
8885                <Option<String>>::sse_encode(bip353_address, serializer);
8886            }
8887            crate::model::PaymentDetails::Bitcoin {
8888                swap_id,
8889                description,
8890                auto_accepted_fees,
8891                liquid_expiration_blockheight,
8892                bitcoin_expiration_blockheight,
8893                lockup_tx_id,
8894                claim_tx_id,
8895                refund_tx_id,
8896                refund_tx_amount_sat,
8897            } => {
8898                <i32>::sse_encode(2, serializer);
8899                <String>::sse_encode(swap_id, serializer);
8900                <String>::sse_encode(description, serializer);
8901                <bool>::sse_encode(auto_accepted_fees, serializer);
8902                <Option<u32>>::sse_encode(liquid_expiration_blockheight, serializer);
8903                <Option<u32>>::sse_encode(bitcoin_expiration_blockheight, serializer);
8904                <Option<String>>::sse_encode(lockup_tx_id, serializer);
8905                <Option<String>>::sse_encode(claim_tx_id, serializer);
8906                <Option<String>>::sse_encode(refund_tx_id, serializer);
8907                <Option<u64>>::sse_encode(refund_tx_amount_sat, serializer);
8908            }
8909            _ => {
8910                unimplemented!("");
8911            }
8912        }
8913    }
8914}
8915
8916impl SseEncode for crate::error::PaymentError {
8917    // Codec=Sse (Serialization based), see doc to use other codecs
8918    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8919        match self {
8920            crate::error::PaymentError::AlreadyClaimed => {
8921                <i32>::sse_encode(0, serializer);
8922            }
8923            crate::error::PaymentError::AlreadyPaid => {
8924                <i32>::sse_encode(1, serializer);
8925            }
8926            crate::error::PaymentError::PaymentInProgress => {
8927                <i32>::sse_encode(2, serializer);
8928            }
8929            crate::error::PaymentError::AmountOutOfRange { min, max } => {
8930                <i32>::sse_encode(3, serializer);
8931                <u64>::sse_encode(min, serializer);
8932                <u64>::sse_encode(max, serializer);
8933            }
8934            crate::error::PaymentError::AmountMissing { err } => {
8935                <i32>::sse_encode(4, serializer);
8936                <String>::sse_encode(err, serializer);
8937            }
8938            crate::error::PaymentError::AssetError { err } => {
8939                <i32>::sse_encode(5, serializer);
8940                <String>::sse_encode(err, serializer);
8941            }
8942            crate::error::PaymentError::InvalidNetwork { err } => {
8943                <i32>::sse_encode(6, serializer);
8944                <String>::sse_encode(err, serializer);
8945            }
8946            crate::error::PaymentError::Generic { err } => {
8947                <i32>::sse_encode(7, serializer);
8948                <String>::sse_encode(err, serializer);
8949            }
8950            crate::error::PaymentError::InvalidOrExpiredFees => {
8951                <i32>::sse_encode(8, serializer);
8952            }
8953            crate::error::PaymentError::InsufficientFunds => {
8954                <i32>::sse_encode(9, serializer);
8955            }
8956            crate::error::PaymentError::InvalidDescription { err } => {
8957                <i32>::sse_encode(10, serializer);
8958                <String>::sse_encode(err, serializer);
8959            }
8960            crate::error::PaymentError::InvalidInvoice { err } => {
8961                <i32>::sse_encode(11, serializer);
8962                <String>::sse_encode(err, serializer);
8963            }
8964            crate::error::PaymentError::InvalidPreimage => {
8965                <i32>::sse_encode(12, serializer);
8966            }
8967            crate::error::PaymentError::PairsNotFound => {
8968                <i32>::sse_encode(13, serializer);
8969            }
8970            crate::error::PaymentError::PaymentTimeout => {
8971                <i32>::sse_encode(14, serializer);
8972            }
8973            crate::error::PaymentError::PersistError => {
8974                <i32>::sse_encode(15, serializer);
8975            }
8976            crate::error::PaymentError::ReceiveError { err } => {
8977                <i32>::sse_encode(16, serializer);
8978                <String>::sse_encode(err, serializer);
8979            }
8980            crate::error::PaymentError::Refunded { err, refund_tx_id } => {
8981                <i32>::sse_encode(17, serializer);
8982                <String>::sse_encode(err, serializer);
8983                <String>::sse_encode(refund_tx_id, serializer);
8984            }
8985            crate::error::PaymentError::SelfTransferNotSupported => {
8986                <i32>::sse_encode(18, serializer);
8987            }
8988            crate::error::PaymentError::SendError { err } => {
8989                <i32>::sse_encode(19, serializer);
8990                <String>::sse_encode(err, serializer);
8991            }
8992            crate::error::PaymentError::SignerError { err } => {
8993                <i32>::sse_encode(20, serializer);
8994                <String>::sse_encode(err, serializer);
8995            }
8996            _ => {
8997                unimplemented!("");
8998            }
8999        }
9000    }
9001}
9002
9003impl SseEncode for crate::model::PaymentMethod {
9004    // Codec=Sse (Serialization based), see doc to use other codecs
9005    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9006        <i32>::sse_encode(
9007            match self {
9008                crate::model::PaymentMethod::Lightning => 0,
9009                crate::model::PaymentMethod::Bolt11Invoice => 1,
9010                crate::model::PaymentMethod::Bolt12Offer => 2,
9011                crate::model::PaymentMethod::BitcoinAddress => 3,
9012                crate::model::PaymentMethod::LiquidAddress => 4,
9013                _ => {
9014                    unimplemented!("");
9015                }
9016            },
9017            serializer,
9018        );
9019    }
9020}
9021
9022impl SseEncode for crate::model::PaymentState {
9023    // Codec=Sse (Serialization based), see doc to use other codecs
9024    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9025        <i32>::sse_encode(
9026            match self {
9027                crate::model::PaymentState::Created => 0,
9028                crate::model::PaymentState::Pending => 1,
9029                crate::model::PaymentState::Complete => 2,
9030                crate::model::PaymentState::Failed => 3,
9031                crate::model::PaymentState::TimedOut => 4,
9032                crate::model::PaymentState::Refundable => 5,
9033                crate::model::PaymentState::RefundPending => 6,
9034                crate::model::PaymentState::WaitingFeeAcceptance => 7,
9035                _ => {
9036                    unimplemented!("");
9037                }
9038            },
9039            serializer,
9040        );
9041    }
9042}
9043
9044impl SseEncode for crate::model::PaymentType {
9045    // Codec=Sse (Serialization based), see doc to use other codecs
9046    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9047        <i32>::sse_encode(
9048            match self {
9049                crate::model::PaymentType::Receive => 0,
9050                crate::model::PaymentType::Send => 1,
9051                _ => {
9052                    unimplemented!("");
9053                }
9054            },
9055            serializer,
9056        );
9057    }
9058}
9059
9060impl SseEncode for crate::model::PrepareBuyBitcoinRequest {
9061    // Codec=Sse (Serialization based), see doc to use other codecs
9062    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9063        <crate::model::BuyBitcoinProvider>::sse_encode(self.provider, serializer);
9064        <u64>::sse_encode(self.amount_sat, serializer);
9065    }
9066}
9067
9068impl SseEncode for crate::model::PrepareBuyBitcoinResponse {
9069    // Codec=Sse (Serialization based), see doc to use other codecs
9070    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9071        <crate::model::BuyBitcoinProvider>::sse_encode(self.provider, serializer);
9072        <u64>::sse_encode(self.amount_sat, serializer);
9073        <u64>::sse_encode(self.fees_sat, serializer);
9074    }
9075}
9076
9077impl SseEncode for crate::model::PrepareLnUrlPayRequest {
9078    // Codec=Sse (Serialization based), see doc to use other codecs
9079    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9080        <crate::bindings::LnUrlPayRequestData>::sse_encode(self.data, serializer);
9081        <crate::model::PayAmount>::sse_encode(self.amount, serializer);
9082        <Option<String>>::sse_encode(self.bip353_address, serializer);
9083        <Option<String>>::sse_encode(self.comment, serializer);
9084        <Option<bool>>::sse_encode(self.validate_success_action_url, serializer);
9085    }
9086}
9087
9088impl SseEncode for crate::model::PrepareLnUrlPayResponse {
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::SendDestination>::sse_encode(self.destination, serializer);
9092        <u64>::sse_encode(self.fees_sat, serializer);
9093        <crate::bindings::LnUrlPayRequestData>::sse_encode(self.data, serializer);
9094        <crate::model::PayAmount>::sse_encode(self.amount, serializer);
9095        <Option<String>>::sse_encode(self.comment, serializer);
9096        <Option<crate::bindings::SuccessAction>>::sse_encode(self.success_action, serializer);
9097    }
9098}
9099
9100impl SseEncode for crate::model::PreparePayOnchainRequest {
9101    // Codec=Sse (Serialization based), see doc to use other codecs
9102    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9103        <crate::model::PayAmount>::sse_encode(self.amount, serializer);
9104        <Option<u32>>::sse_encode(self.fee_rate_sat_per_vbyte, serializer);
9105    }
9106}
9107
9108impl SseEncode for crate::model::PreparePayOnchainResponse {
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        <u64>::sse_encode(self.receiver_amount_sat, serializer);
9112        <u64>::sse_encode(self.claim_fees_sat, serializer);
9113        <u64>::sse_encode(self.total_fees_sat, serializer);
9114    }
9115}
9116
9117impl SseEncode for crate::model::PrepareReceiveRequest {
9118    // Codec=Sse (Serialization based), see doc to use other codecs
9119    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9120        <crate::model::PaymentMethod>::sse_encode(self.payment_method, serializer);
9121        <Option<crate::model::ReceiveAmount>>::sse_encode(self.amount, serializer);
9122    }
9123}
9124
9125impl SseEncode for crate::model::PrepareReceiveResponse {
9126    // Codec=Sse (Serialization based), see doc to use other codecs
9127    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9128        <crate::model::PaymentMethod>::sse_encode(self.payment_method, serializer);
9129        <u64>::sse_encode(self.fees_sat, serializer);
9130        <Option<crate::model::ReceiveAmount>>::sse_encode(self.amount, serializer);
9131        <Option<u64>>::sse_encode(self.min_payer_amount_sat, serializer);
9132        <Option<u64>>::sse_encode(self.max_payer_amount_sat, serializer);
9133        <Option<f64>>::sse_encode(self.swapper_feerate, serializer);
9134    }
9135}
9136
9137impl SseEncode for crate::model::PrepareRefundRequest {
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        <String>::sse_encode(self.swap_address, serializer);
9141        <String>::sse_encode(self.refund_address, serializer);
9142        <u32>::sse_encode(self.fee_rate_sat_per_vbyte, serializer);
9143    }
9144}
9145
9146impl SseEncode for crate::model::PrepareRefundResponse {
9147    // Codec=Sse (Serialization based), see doc to use other codecs
9148    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9149        <u32>::sse_encode(self.tx_vsize, serializer);
9150        <u64>::sse_encode(self.tx_fee_sat, serializer);
9151        <Option<String>>::sse_encode(self.last_refund_tx_id, serializer);
9152    }
9153}
9154
9155impl SseEncode for crate::model::PrepareSendRequest {
9156    // Codec=Sse (Serialization based), see doc to use other codecs
9157    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9158        <String>::sse_encode(self.destination, serializer);
9159        <Option<crate::model::PayAmount>>::sse_encode(self.amount, serializer);
9160    }
9161}
9162
9163impl SseEncode for crate::model::PrepareSendResponse {
9164    // Codec=Sse (Serialization based), see doc to use other codecs
9165    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9166        <crate::model::SendDestination>::sse_encode(self.destination, serializer);
9167        <Option<crate::model::PayAmount>>::sse_encode(self.amount, serializer);
9168        <Option<u64>>::sse_encode(self.fees_sat, serializer);
9169        <Option<f64>>::sse_encode(self.estimated_asset_fees, serializer);
9170    }
9171}
9172
9173impl SseEncode for crate::bindings::Rate {
9174    // Codec=Sse (Serialization based), see doc to use other codecs
9175    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9176        <String>::sse_encode(self.coin, serializer);
9177        <f64>::sse_encode(self.value, serializer);
9178    }
9179}
9180
9181impl SseEncode for crate::model::ReceiveAmount {
9182    // Codec=Sse (Serialization based), see doc to use other codecs
9183    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9184        match self {
9185            crate::model::ReceiveAmount::Bitcoin { payer_amount_sat } => {
9186                <i32>::sse_encode(0, serializer);
9187                <u64>::sse_encode(payer_amount_sat, serializer);
9188            }
9189            crate::model::ReceiveAmount::Asset {
9190                asset_id,
9191                payer_amount,
9192            } => {
9193                <i32>::sse_encode(1, serializer);
9194                <String>::sse_encode(asset_id, serializer);
9195                <Option<f64>>::sse_encode(payer_amount, serializer);
9196            }
9197            _ => {
9198                unimplemented!("");
9199            }
9200        }
9201    }
9202}
9203
9204impl SseEncode for crate::model::ReceivePaymentRequest {
9205    // Codec=Sse (Serialization based), see doc to use other codecs
9206    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9207        <crate::model::PrepareReceiveResponse>::sse_encode(self.prepare_response, serializer);
9208        <Option<String>>::sse_encode(self.description, serializer);
9209        <Option<bool>>::sse_encode(self.use_description_hash, serializer);
9210    }
9211}
9212
9213impl SseEncode for crate::model::ReceivePaymentResponse {
9214    // Codec=Sse (Serialization based), see doc to use other codecs
9215    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9216        <String>::sse_encode(self.destination, serializer);
9217    }
9218}
9219
9220impl SseEncode for crate::model::RecommendedFees {
9221    // Codec=Sse (Serialization based), see doc to use other codecs
9222    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9223        <u64>::sse_encode(self.fastest_fee, serializer);
9224        <u64>::sse_encode(self.half_hour_fee, serializer);
9225        <u64>::sse_encode(self.hour_fee, serializer);
9226        <u64>::sse_encode(self.economy_fee, serializer);
9227        <u64>::sse_encode(self.minimum_fee, serializer);
9228    }
9229}
9230
9231impl SseEncode for crate::model::RefundRequest {
9232    // Codec=Sse (Serialization based), see doc to use other codecs
9233    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9234        <String>::sse_encode(self.swap_address, serializer);
9235        <String>::sse_encode(self.refund_address, serializer);
9236        <u32>::sse_encode(self.fee_rate_sat_per_vbyte, serializer);
9237    }
9238}
9239
9240impl SseEncode for crate::model::RefundResponse {
9241    // Codec=Sse (Serialization based), see doc to use other codecs
9242    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9243        <String>::sse_encode(self.refund_tx_id, serializer);
9244    }
9245}
9246
9247impl SseEncode for crate::model::RefundableSwap {
9248    // Codec=Sse (Serialization based), see doc to use other codecs
9249    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9250        <String>::sse_encode(self.swap_address, serializer);
9251        <u32>::sse_encode(self.timestamp, serializer);
9252        <u64>::sse_encode(self.amount_sat, serializer);
9253        <Option<String>>::sse_encode(self.last_refund_tx_id, serializer);
9254    }
9255}
9256
9257impl SseEncode for crate::model::RestoreRequest {
9258    // Codec=Sse (Serialization based), see doc to use other codecs
9259    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9260        <Option<String>>::sse_encode(self.backup_path, serializer);
9261    }
9262}
9263
9264impl SseEncode for crate::bindings::RouteHint {
9265    // Codec=Sse (Serialization based), see doc to use other codecs
9266    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9267        <Vec<crate::bindings::RouteHintHop>>::sse_encode(self.hops, serializer);
9268    }
9269}
9270
9271impl SseEncode for crate::bindings::RouteHintHop {
9272    // Codec=Sse (Serialization based), see doc to use other codecs
9273    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9274        <String>::sse_encode(self.src_node_id, serializer);
9275        <String>::sse_encode(self.short_channel_id, serializer);
9276        <u32>::sse_encode(self.fees_base_msat, serializer);
9277        <u32>::sse_encode(self.fees_proportional_millionths, serializer);
9278        <u64>::sse_encode(self.cltv_expiry_delta, serializer);
9279        <Option<u64>>::sse_encode(self.htlc_minimum_msat, serializer);
9280        <Option<u64>>::sse_encode(self.htlc_maximum_msat, serializer);
9281    }
9282}
9283
9284impl SseEncode for crate::error::SdkError {
9285    // Codec=Sse (Serialization based), see doc to use other codecs
9286    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9287        match self {
9288            crate::error::SdkError::AlreadyStarted => {
9289                <i32>::sse_encode(0, serializer);
9290            }
9291            crate::error::SdkError::Generic { err } => {
9292                <i32>::sse_encode(1, serializer);
9293                <String>::sse_encode(err, serializer);
9294            }
9295            crate::error::SdkError::NotStarted => {
9296                <i32>::sse_encode(2, serializer);
9297            }
9298            crate::error::SdkError::ServiceConnectivity { err } => {
9299                <i32>::sse_encode(3, serializer);
9300                <String>::sse_encode(err, serializer);
9301            }
9302            _ => {
9303                unimplemented!("");
9304            }
9305        }
9306    }
9307}
9308
9309impl SseEncode for crate::model::SdkEvent {
9310    // Codec=Sse (Serialization based), see doc to use other codecs
9311    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9312        match self {
9313            crate::model::SdkEvent::PaymentFailed { details } => {
9314                <i32>::sse_encode(0, serializer);
9315                <crate::model::Payment>::sse_encode(details, serializer);
9316            }
9317            crate::model::SdkEvent::PaymentPending { details } => {
9318                <i32>::sse_encode(1, serializer);
9319                <crate::model::Payment>::sse_encode(details, serializer);
9320            }
9321            crate::model::SdkEvent::PaymentRefundable { details } => {
9322                <i32>::sse_encode(2, serializer);
9323                <crate::model::Payment>::sse_encode(details, serializer);
9324            }
9325            crate::model::SdkEvent::PaymentRefunded { details } => {
9326                <i32>::sse_encode(3, serializer);
9327                <crate::model::Payment>::sse_encode(details, serializer);
9328            }
9329            crate::model::SdkEvent::PaymentRefundPending { details } => {
9330                <i32>::sse_encode(4, serializer);
9331                <crate::model::Payment>::sse_encode(details, serializer);
9332            }
9333            crate::model::SdkEvent::PaymentSucceeded { details } => {
9334                <i32>::sse_encode(5, serializer);
9335                <crate::model::Payment>::sse_encode(details, serializer);
9336            }
9337            crate::model::SdkEvent::PaymentWaitingConfirmation { details } => {
9338                <i32>::sse_encode(6, serializer);
9339                <crate::model::Payment>::sse_encode(details, serializer);
9340            }
9341            crate::model::SdkEvent::PaymentWaitingFeeAcceptance { details } => {
9342                <i32>::sse_encode(7, serializer);
9343                <crate::model::Payment>::sse_encode(details, serializer);
9344            }
9345            crate::model::SdkEvent::Synced => {
9346                <i32>::sse_encode(8, serializer);
9347            }
9348            crate::model::SdkEvent::DataSynced {
9349                did_pull_new_records,
9350            } => {
9351                <i32>::sse_encode(9, serializer);
9352                <bool>::sse_encode(did_pull_new_records, serializer);
9353            }
9354            _ => {
9355                unimplemented!("");
9356            }
9357        }
9358    }
9359}
9360
9361impl SseEncode for crate::model::SendDestination {
9362    // Codec=Sse (Serialization based), see doc to use other codecs
9363    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9364        match self {
9365            crate::model::SendDestination::LiquidAddress {
9366                address_data,
9367                bip353_address,
9368            } => {
9369                <i32>::sse_encode(0, serializer);
9370                <crate::bindings::LiquidAddressData>::sse_encode(address_data, serializer);
9371                <Option<String>>::sse_encode(bip353_address, serializer);
9372            }
9373            crate::model::SendDestination::Bolt11 {
9374                invoice,
9375                bip353_address,
9376            } => {
9377                <i32>::sse_encode(1, serializer);
9378                <crate::bindings::LNInvoice>::sse_encode(invoice, serializer);
9379                <Option<String>>::sse_encode(bip353_address, serializer);
9380            }
9381            crate::model::SendDestination::Bolt12 {
9382                offer,
9383                receiver_amount_sat,
9384                bip353_address,
9385            } => {
9386                <i32>::sse_encode(2, serializer);
9387                <crate::bindings::LNOffer>::sse_encode(offer, serializer);
9388                <u64>::sse_encode(receiver_amount_sat, serializer);
9389                <Option<String>>::sse_encode(bip353_address, serializer);
9390            }
9391            _ => {
9392                unimplemented!("");
9393            }
9394        }
9395    }
9396}
9397
9398impl SseEncode for crate::model::SendPaymentRequest {
9399    // Codec=Sse (Serialization based), see doc to use other codecs
9400    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9401        <crate::model::PrepareSendResponse>::sse_encode(self.prepare_response, serializer);
9402        <Option<bool>>::sse_encode(self.use_asset_fees, serializer);
9403    }
9404}
9405
9406impl SseEncode for crate::model::SendPaymentResponse {
9407    // Codec=Sse (Serialization based), see doc to use other codecs
9408    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9409        <crate::model::Payment>::sse_encode(self.payment, serializer);
9410    }
9411}
9412
9413impl SseEncode for crate::model::SignMessageRequest {
9414    // Codec=Sse (Serialization based), see doc to use other codecs
9415    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9416        <String>::sse_encode(self.message, serializer);
9417    }
9418}
9419
9420impl SseEncode for crate::model::SignMessageResponse {
9421    // Codec=Sse (Serialization based), see doc to use other codecs
9422    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9423        <String>::sse_encode(self.signature, serializer);
9424    }
9425}
9426
9427impl SseEncode for crate::bindings::SuccessAction {
9428    // Codec=Sse (Serialization based), see doc to use other codecs
9429    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9430        match self {
9431            crate::bindings::SuccessAction::Aes { data } => {
9432                <i32>::sse_encode(0, serializer);
9433                <crate::bindings::AesSuccessActionData>::sse_encode(data, serializer);
9434            }
9435            crate::bindings::SuccessAction::Message { data } => {
9436                <i32>::sse_encode(1, serializer);
9437                <crate::bindings::MessageSuccessActionData>::sse_encode(data, serializer);
9438            }
9439            crate::bindings::SuccessAction::Url { data } => {
9440                <i32>::sse_encode(2, serializer);
9441                <crate::bindings::UrlSuccessActionData>::sse_encode(data, serializer);
9442            }
9443            _ => {
9444                unimplemented!("");
9445            }
9446        }
9447    }
9448}
9449
9450impl SseEncode for crate::bindings::SuccessActionProcessed {
9451    // Codec=Sse (Serialization based), see doc to use other codecs
9452    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9453        match self {
9454            crate::bindings::SuccessActionProcessed::Aes { result } => {
9455                <i32>::sse_encode(0, serializer);
9456                <crate::bindings::AesSuccessActionDataResult>::sse_encode(result, serializer);
9457            }
9458            crate::bindings::SuccessActionProcessed::Message { data } => {
9459                <i32>::sse_encode(1, serializer);
9460                <crate::bindings::MessageSuccessActionData>::sse_encode(data, serializer);
9461            }
9462            crate::bindings::SuccessActionProcessed::Url { data } => {
9463                <i32>::sse_encode(2, serializer);
9464                <crate::bindings::UrlSuccessActionData>::sse_encode(data, serializer);
9465            }
9466            _ => {
9467                unimplemented!("");
9468            }
9469        }
9470    }
9471}
9472
9473impl SseEncode for crate::bindings::Symbol {
9474    // Codec=Sse (Serialization based), see doc to use other codecs
9475    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9476        <Option<String>>::sse_encode(self.grapheme, serializer);
9477        <Option<String>>::sse_encode(self.template, serializer);
9478        <Option<bool>>::sse_encode(self.rtl, serializer);
9479        <Option<u32>>::sse_encode(self.position, serializer);
9480    }
9481}
9482
9483impl SseEncode for u16 {
9484    // Codec=Sse (Serialization based), see doc to use other codecs
9485    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9486        serializer.cursor.write_u16::<NativeEndian>(self).unwrap();
9487    }
9488}
9489
9490impl SseEncode for u32 {
9491    // Codec=Sse (Serialization based), see doc to use other codecs
9492    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9493        serializer.cursor.write_u32::<NativeEndian>(self).unwrap();
9494    }
9495}
9496
9497impl SseEncode for u64 {
9498    // Codec=Sse (Serialization based), see doc to use other codecs
9499    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9500        serializer.cursor.write_u64::<NativeEndian>(self).unwrap();
9501    }
9502}
9503
9504impl SseEncode for u8 {
9505    // Codec=Sse (Serialization based), see doc to use other codecs
9506    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9507        serializer.cursor.write_u8(self).unwrap();
9508    }
9509}
9510
9511impl SseEncode for () {
9512    // Codec=Sse (Serialization based), see doc to use other codecs
9513    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {}
9514}
9515
9516impl SseEncode for crate::bindings::UrlSuccessActionData {
9517    // Codec=Sse (Serialization based), see doc to use other codecs
9518    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9519        <String>::sse_encode(self.description, serializer);
9520        <String>::sse_encode(self.url, serializer);
9521        <bool>::sse_encode(self.matches_callback_domain, serializer);
9522    }
9523}
9524
9525impl SseEncode for usize {
9526    // Codec=Sse (Serialization based), see doc to use other codecs
9527    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9528        serializer
9529            .cursor
9530            .write_u64::<NativeEndian>(self as _)
9531            .unwrap();
9532    }
9533}
9534
9535impl SseEncode for crate::model::WalletInfo {
9536    // Codec=Sse (Serialization based), see doc to use other codecs
9537    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9538        <u64>::sse_encode(self.balance_sat, serializer);
9539        <u64>::sse_encode(self.pending_send_sat, serializer);
9540        <u64>::sse_encode(self.pending_receive_sat, serializer);
9541        <String>::sse_encode(self.fingerprint, serializer);
9542        <String>::sse_encode(self.pubkey, serializer);
9543        <Vec<crate::model::AssetBalance>>::sse_encode(self.asset_balances, serializer);
9544    }
9545}
9546
9547#[cfg(not(target_family = "wasm"))]
9548mod io {
9549    // This file is automatically generated, so please do not edit it.
9550    // @generated by `flutter_rust_bridge`@ 2.9.0.
9551
9552    // Section: imports
9553
9554    use super::*;
9555    use crate::bindings::*;
9556    use crate::model::EventListener;
9557    use flutter_rust_bridge::for_generated::byteorder::{
9558        NativeEndian, ReadBytesExt, WriteBytesExt,
9559    };
9560    use flutter_rust_bridge::for_generated::{transform_result_dco, Lifetimeable, Lockable};
9561    use flutter_rust_bridge::{Handler, IntoIntoDart};
9562
9563    // Section: boilerplate
9564
9565    flutter_rust_bridge::frb_generated_boilerplate_io!();
9566
9567    // Section: dart2rust
9568
9569    impl CstDecode<flutter_rust_bridge::for_generated::anyhow::Error>
9570        for *mut wire_cst_list_prim_u_8_strict
9571    {
9572        // Codec=Cst (C-struct based), see doc to use other codecs
9573        fn cst_decode(self) -> flutter_rust_bridge::for_generated::anyhow::Error {
9574            unimplemented!()
9575        }
9576    }
9577    impl CstDecode<BindingLiquidSdk> for usize {
9578        // Codec=Cst (C-struct based), see doc to use other codecs
9579        fn cst_decode(self) -> BindingLiquidSdk {
9580            flutter_rust_bridge::for_generated::rust_auto_opaque_decode_owned(CstDecode::<
9581                RustOpaqueNom<
9582                    flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>,
9583                >,
9584            >::cst_decode(
9585                self
9586            ))
9587        }
9588    }
9589    impl
9590        CstDecode<
9591            RustOpaqueNom<
9592                flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>,
9593            >,
9594        > for usize
9595    {
9596        // Codec=Cst (C-struct based), see doc to use other codecs
9597        fn cst_decode(
9598            self,
9599        ) -> RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>
9600        {
9601            unsafe { decode_rust_opaque_nom(self as _) }
9602        }
9603    }
9604    impl CstDecode<StreamSink<crate::model::LogEntry, flutter_rust_bridge::for_generated::DcoCodec>>
9605        for *mut wire_cst_list_prim_u_8_strict
9606    {
9607        // Codec=Cst (C-struct based), see doc to use other codecs
9608        fn cst_decode(
9609            self,
9610        ) -> StreamSink<crate::model::LogEntry, flutter_rust_bridge::for_generated::DcoCodec>
9611        {
9612            let raw: String = self.cst_decode();
9613            StreamSink::deserialize(raw)
9614        }
9615    }
9616    impl CstDecode<StreamSink<crate::model::SdkEvent, flutter_rust_bridge::for_generated::DcoCodec>>
9617        for *mut wire_cst_list_prim_u_8_strict
9618    {
9619        // Codec=Cst (C-struct based), see doc to use other codecs
9620        fn cst_decode(
9621            self,
9622        ) -> StreamSink<crate::model::SdkEvent, flutter_rust_bridge::for_generated::DcoCodec>
9623        {
9624            let raw: String = self.cst_decode();
9625            StreamSink::deserialize(raw)
9626        }
9627    }
9628    impl CstDecode<String> for *mut wire_cst_list_prim_u_8_strict {
9629        // Codec=Cst (C-struct based), see doc to use other codecs
9630        fn cst_decode(self) -> String {
9631            let vec: Vec<u8> = self.cst_decode();
9632            String::from_utf8(vec).unwrap()
9633        }
9634    }
9635    impl CstDecode<crate::model::AcceptPaymentProposedFeesRequest>
9636        for wire_cst_accept_payment_proposed_fees_request
9637    {
9638        // Codec=Cst (C-struct based), see doc to use other codecs
9639        fn cst_decode(self) -> crate::model::AcceptPaymentProposedFeesRequest {
9640            crate::model::AcceptPaymentProposedFeesRequest {
9641                response: self.response.cst_decode(),
9642            }
9643        }
9644    }
9645    impl CstDecode<crate::bindings::AesSuccessActionData> for wire_cst_aes_success_action_data {
9646        // Codec=Cst (C-struct based), see doc to use other codecs
9647        fn cst_decode(self) -> crate::bindings::AesSuccessActionData {
9648            crate::bindings::AesSuccessActionData {
9649                description: self.description.cst_decode(),
9650                ciphertext: self.ciphertext.cst_decode(),
9651                iv: self.iv.cst_decode(),
9652            }
9653        }
9654    }
9655    impl CstDecode<crate::bindings::AesSuccessActionDataDecrypted>
9656        for wire_cst_aes_success_action_data_decrypted
9657    {
9658        // Codec=Cst (C-struct based), see doc to use other codecs
9659        fn cst_decode(self) -> crate::bindings::AesSuccessActionDataDecrypted {
9660            crate::bindings::AesSuccessActionDataDecrypted {
9661                description: self.description.cst_decode(),
9662                plaintext: self.plaintext.cst_decode(),
9663            }
9664        }
9665    }
9666    impl CstDecode<crate::bindings::AesSuccessActionDataResult>
9667        for wire_cst_aes_success_action_data_result
9668    {
9669        // Codec=Cst (C-struct based), see doc to use other codecs
9670        fn cst_decode(self) -> crate::bindings::AesSuccessActionDataResult {
9671            match self.tag {
9672                0 => {
9673                    let ans = unsafe { self.kind.Decrypted };
9674                    crate::bindings::AesSuccessActionDataResult::Decrypted {
9675                        data: ans.data.cst_decode(),
9676                    }
9677                }
9678                1 => {
9679                    let ans = unsafe { self.kind.ErrorStatus };
9680                    crate::bindings::AesSuccessActionDataResult::ErrorStatus {
9681                        reason: ans.reason.cst_decode(),
9682                    }
9683                }
9684                _ => unreachable!(),
9685            }
9686        }
9687    }
9688    impl CstDecode<crate::bindings::Amount> for wire_cst_amount {
9689        // Codec=Cst (C-struct based), see doc to use other codecs
9690        fn cst_decode(self) -> crate::bindings::Amount {
9691            match self.tag {
9692                0 => {
9693                    let ans = unsafe { self.kind.Bitcoin };
9694                    crate::bindings::Amount::Bitcoin {
9695                        amount_msat: ans.amount_msat.cst_decode(),
9696                    }
9697                }
9698                1 => {
9699                    let ans = unsafe { self.kind.Currency };
9700                    crate::bindings::Amount::Currency {
9701                        iso4217_code: ans.iso4217_code.cst_decode(),
9702                        fractional_amount: ans.fractional_amount.cst_decode(),
9703                    }
9704                }
9705                _ => unreachable!(),
9706            }
9707        }
9708    }
9709    impl CstDecode<crate::model::AssetBalance> for wire_cst_asset_balance {
9710        // Codec=Cst (C-struct based), see doc to use other codecs
9711        fn cst_decode(self) -> crate::model::AssetBalance {
9712            crate::model::AssetBalance {
9713                asset_id: self.asset_id.cst_decode(),
9714                balance_sat: self.balance_sat.cst_decode(),
9715                name: self.name.cst_decode(),
9716                ticker: self.ticker.cst_decode(),
9717                balance: self.balance.cst_decode(),
9718            }
9719        }
9720    }
9721    impl CstDecode<crate::model::AssetInfo> for wire_cst_asset_info {
9722        // Codec=Cst (C-struct based), see doc to use other codecs
9723        fn cst_decode(self) -> crate::model::AssetInfo {
9724            crate::model::AssetInfo {
9725                name: self.name.cst_decode(),
9726                ticker: self.ticker.cst_decode(),
9727                amount: self.amount.cst_decode(),
9728                fees: self.fees.cst_decode(),
9729            }
9730        }
9731    }
9732    impl CstDecode<crate::model::AssetMetadata> for wire_cst_asset_metadata {
9733        // Codec=Cst (C-struct based), see doc to use other codecs
9734        fn cst_decode(self) -> crate::model::AssetMetadata {
9735            crate::model::AssetMetadata {
9736                asset_id: self.asset_id.cst_decode(),
9737                name: self.name.cst_decode(),
9738                ticker: self.ticker.cst_decode(),
9739                precision: self.precision.cst_decode(),
9740                fiat_id: self.fiat_id.cst_decode(),
9741            }
9742        }
9743    }
9744    impl CstDecode<crate::model::BackupRequest> for wire_cst_backup_request {
9745        // Codec=Cst (C-struct based), see doc to use other codecs
9746        fn cst_decode(self) -> crate::model::BackupRequest {
9747            crate::model::BackupRequest {
9748                backup_path: self.backup_path.cst_decode(),
9749            }
9750        }
9751    }
9752    impl CstDecode<crate::bindings::BindingEventListener> for wire_cst_binding_event_listener {
9753        // Codec=Cst (C-struct based), see doc to use other codecs
9754        fn cst_decode(self) -> crate::bindings::BindingEventListener {
9755            crate::bindings::BindingEventListener {
9756                stream: self.stream.cst_decode(),
9757            }
9758        }
9759    }
9760    impl CstDecode<crate::bindings::BitcoinAddressData> for wire_cst_bitcoin_address_data {
9761        // Codec=Cst (C-struct based), see doc to use other codecs
9762        fn cst_decode(self) -> crate::bindings::BitcoinAddressData {
9763            crate::bindings::BitcoinAddressData {
9764                address: self.address.cst_decode(),
9765                network: self.network.cst_decode(),
9766                amount_sat: self.amount_sat.cst_decode(),
9767                label: self.label.cst_decode(),
9768                message: self.message.cst_decode(),
9769            }
9770        }
9771    }
9772    impl CstDecode<crate::model::BlockchainExplorer> for wire_cst_blockchain_explorer {
9773        // Codec=Cst (C-struct based), see doc to use other codecs
9774        fn cst_decode(self) -> crate::model::BlockchainExplorer {
9775            match self.tag {
9776                0 => {
9777                    let ans = unsafe { self.kind.Electrum };
9778                    crate::model::BlockchainExplorer::Electrum {
9779                        url: ans.url.cst_decode(),
9780                    }
9781                }
9782                1 => {
9783                    let ans = unsafe { self.kind.Esplora };
9784                    crate::model::BlockchainExplorer::Esplora {
9785                        url: ans.url.cst_decode(),
9786                        use_waterfalls: ans.use_waterfalls.cst_decode(),
9787                    }
9788                }
9789                _ => unreachable!(),
9790            }
9791        }
9792    }
9793    impl CstDecode<crate::model::BlockchainInfo> for wire_cst_blockchain_info {
9794        // Codec=Cst (C-struct based), see doc to use other codecs
9795        fn cst_decode(self) -> crate::model::BlockchainInfo {
9796            crate::model::BlockchainInfo {
9797                liquid_tip: self.liquid_tip.cst_decode(),
9798                bitcoin_tip: self.bitcoin_tip.cst_decode(),
9799            }
9800        }
9801    }
9802    impl CstDecode<crate::model::AcceptPaymentProposedFeesRequest>
9803        for *mut wire_cst_accept_payment_proposed_fees_request
9804    {
9805        // Codec=Cst (C-struct based), see doc to use other codecs
9806        fn cst_decode(self) -> crate::model::AcceptPaymentProposedFeesRequest {
9807            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9808            CstDecode::<crate::model::AcceptPaymentProposedFeesRequest>::cst_decode(*wrap).into()
9809        }
9810    }
9811    impl CstDecode<crate::bindings::AesSuccessActionData> for *mut wire_cst_aes_success_action_data {
9812        // Codec=Cst (C-struct based), see doc to use other codecs
9813        fn cst_decode(self) -> crate::bindings::AesSuccessActionData {
9814            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9815            CstDecode::<crate::bindings::AesSuccessActionData>::cst_decode(*wrap).into()
9816        }
9817    }
9818    impl CstDecode<crate::bindings::AesSuccessActionDataDecrypted>
9819        for *mut wire_cst_aes_success_action_data_decrypted
9820    {
9821        // Codec=Cst (C-struct based), see doc to use other codecs
9822        fn cst_decode(self) -> crate::bindings::AesSuccessActionDataDecrypted {
9823            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9824            CstDecode::<crate::bindings::AesSuccessActionDataDecrypted>::cst_decode(*wrap).into()
9825        }
9826    }
9827    impl CstDecode<crate::bindings::AesSuccessActionDataResult>
9828        for *mut wire_cst_aes_success_action_data_result
9829    {
9830        // Codec=Cst (C-struct based), see doc to use other codecs
9831        fn cst_decode(self) -> crate::bindings::AesSuccessActionDataResult {
9832            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9833            CstDecode::<crate::bindings::AesSuccessActionDataResult>::cst_decode(*wrap).into()
9834        }
9835    }
9836    impl CstDecode<crate::bindings::Amount> for *mut wire_cst_amount {
9837        // Codec=Cst (C-struct based), see doc to use other codecs
9838        fn cst_decode(self) -> crate::bindings::Amount {
9839            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9840            CstDecode::<crate::bindings::Amount>::cst_decode(*wrap).into()
9841        }
9842    }
9843    impl CstDecode<crate::model::AssetInfo> for *mut wire_cst_asset_info {
9844        // Codec=Cst (C-struct based), see doc to use other codecs
9845        fn cst_decode(self) -> crate::model::AssetInfo {
9846            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9847            CstDecode::<crate::model::AssetInfo>::cst_decode(*wrap).into()
9848        }
9849    }
9850    impl CstDecode<crate::model::BackupRequest> for *mut wire_cst_backup_request {
9851        // Codec=Cst (C-struct based), see doc to use other codecs
9852        fn cst_decode(self) -> crate::model::BackupRequest {
9853            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9854            CstDecode::<crate::model::BackupRequest>::cst_decode(*wrap).into()
9855        }
9856    }
9857    impl CstDecode<crate::bindings::BindingEventListener> for *mut wire_cst_binding_event_listener {
9858        // Codec=Cst (C-struct based), see doc to use other codecs
9859        fn cst_decode(self) -> crate::bindings::BindingEventListener {
9860            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9861            CstDecode::<crate::bindings::BindingEventListener>::cst_decode(*wrap).into()
9862        }
9863    }
9864    impl CstDecode<crate::bindings::BitcoinAddressData> for *mut wire_cst_bitcoin_address_data {
9865        // Codec=Cst (C-struct based), see doc to use other codecs
9866        fn cst_decode(self) -> crate::bindings::BitcoinAddressData {
9867            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9868            CstDecode::<crate::bindings::BitcoinAddressData>::cst_decode(*wrap).into()
9869        }
9870    }
9871    impl CstDecode<bool> for *mut bool {
9872        // Codec=Cst (C-struct based), see doc to use other codecs
9873        fn cst_decode(self) -> bool {
9874            unsafe { *flutter_rust_bridge::for_generated::box_from_leak_ptr(self) }
9875        }
9876    }
9877    impl CstDecode<crate::model::BuyBitcoinRequest> for *mut wire_cst_buy_bitcoin_request {
9878        // Codec=Cst (C-struct based), see doc to use other codecs
9879        fn cst_decode(self) -> crate::model::BuyBitcoinRequest {
9880            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9881            CstDecode::<crate::model::BuyBitcoinRequest>::cst_decode(*wrap).into()
9882        }
9883    }
9884    impl CstDecode<crate::model::CheckMessageRequest> for *mut wire_cst_check_message_request {
9885        // Codec=Cst (C-struct based), see doc to use other codecs
9886        fn cst_decode(self) -> crate::model::CheckMessageRequest {
9887            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9888            CstDecode::<crate::model::CheckMessageRequest>::cst_decode(*wrap).into()
9889        }
9890    }
9891    impl CstDecode<crate::model::ConnectRequest> for *mut wire_cst_connect_request {
9892        // Codec=Cst (C-struct based), see doc to use other codecs
9893        fn cst_decode(self) -> crate::model::ConnectRequest {
9894            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9895            CstDecode::<crate::model::ConnectRequest>::cst_decode(*wrap).into()
9896        }
9897    }
9898    impl CstDecode<crate::model::CreateBolt12InvoiceRequest>
9899        for *mut wire_cst_create_bolt_12_invoice_request
9900    {
9901        // Codec=Cst (C-struct based), see doc to use other codecs
9902        fn cst_decode(self) -> crate::model::CreateBolt12InvoiceRequest {
9903            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9904            CstDecode::<crate::model::CreateBolt12InvoiceRequest>::cst_decode(*wrap).into()
9905        }
9906    }
9907    impl CstDecode<f64> for *mut f64 {
9908        // Codec=Cst (C-struct based), see doc to use other codecs
9909        fn cst_decode(self) -> f64 {
9910            unsafe { *flutter_rust_bridge::for_generated::box_from_leak_ptr(self) }
9911        }
9912    }
9913    impl CstDecode<crate::model::FetchPaymentProposedFeesRequest>
9914        for *mut wire_cst_fetch_payment_proposed_fees_request
9915    {
9916        // Codec=Cst (C-struct based), see doc to use other codecs
9917        fn cst_decode(self) -> crate::model::FetchPaymentProposedFeesRequest {
9918            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9919            CstDecode::<crate::model::FetchPaymentProposedFeesRequest>::cst_decode(*wrap).into()
9920        }
9921    }
9922    impl CstDecode<crate::model::GetPaymentRequest> for *mut wire_cst_get_payment_request {
9923        // Codec=Cst (C-struct based), see doc to use other codecs
9924        fn cst_decode(self) -> crate::model::GetPaymentRequest {
9925            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9926            CstDecode::<crate::model::GetPaymentRequest>::cst_decode(*wrap).into()
9927        }
9928    }
9929    impl CstDecode<i64> for *mut i64 {
9930        // Codec=Cst (C-struct based), see doc to use other codecs
9931        fn cst_decode(self) -> i64 {
9932            unsafe { *flutter_rust_bridge::for_generated::box_from_leak_ptr(self) }
9933        }
9934    }
9935    impl CstDecode<crate::bindings::LiquidAddressData> for *mut wire_cst_liquid_address_data {
9936        // Codec=Cst (C-struct based), see doc to use other codecs
9937        fn cst_decode(self) -> crate::bindings::LiquidAddressData {
9938            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9939            CstDecode::<crate::bindings::LiquidAddressData>::cst_decode(*wrap).into()
9940        }
9941    }
9942    impl CstDecode<crate::model::ListPaymentDetails> for *mut wire_cst_list_payment_details {
9943        // Codec=Cst (C-struct based), see doc to use other codecs
9944        fn cst_decode(self) -> crate::model::ListPaymentDetails {
9945            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9946            CstDecode::<crate::model::ListPaymentDetails>::cst_decode(*wrap).into()
9947        }
9948    }
9949    impl CstDecode<crate::model::ListPaymentsRequest> for *mut wire_cst_list_payments_request {
9950        // Codec=Cst (C-struct based), see doc to use other codecs
9951        fn cst_decode(self) -> crate::model::ListPaymentsRequest {
9952            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9953            CstDecode::<crate::model::ListPaymentsRequest>::cst_decode(*wrap).into()
9954        }
9955    }
9956    impl CstDecode<crate::bindings::LNInvoice> for *mut wire_cst_ln_invoice {
9957        // Codec=Cst (C-struct based), see doc to use other codecs
9958        fn cst_decode(self) -> crate::bindings::LNInvoice {
9959            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9960            CstDecode::<crate::bindings::LNInvoice>::cst_decode(*wrap).into()
9961        }
9962    }
9963    impl CstDecode<crate::bindings::LNOffer> for *mut wire_cst_ln_offer {
9964        // Codec=Cst (C-struct based), see doc to use other codecs
9965        fn cst_decode(self) -> crate::bindings::LNOffer {
9966            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9967            CstDecode::<crate::bindings::LNOffer>::cst_decode(*wrap).into()
9968        }
9969    }
9970    impl CstDecode<crate::bindings::LnUrlAuthRequestData> for *mut wire_cst_ln_url_auth_request_data {
9971        // Codec=Cst (C-struct based), see doc to use other codecs
9972        fn cst_decode(self) -> crate::bindings::LnUrlAuthRequestData {
9973            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9974            CstDecode::<crate::bindings::LnUrlAuthRequestData>::cst_decode(*wrap).into()
9975        }
9976    }
9977    impl CstDecode<crate::bindings::LnUrlErrorData> for *mut wire_cst_ln_url_error_data {
9978        // Codec=Cst (C-struct based), see doc to use other codecs
9979        fn cst_decode(self) -> crate::bindings::LnUrlErrorData {
9980            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9981            CstDecode::<crate::bindings::LnUrlErrorData>::cst_decode(*wrap).into()
9982        }
9983    }
9984    impl CstDecode<crate::model::LnUrlInfo> for *mut wire_cst_ln_url_info {
9985        // Codec=Cst (C-struct based), see doc to use other codecs
9986        fn cst_decode(self) -> crate::model::LnUrlInfo {
9987            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9988            CstDecode::<crate::model::LnUrlInfo>::cst_decode(*wrap).into()
9989        }
9990    }
9991    impl CstDecode<crate::bindings::LnUrlPayErrorData> for *mut wire_cst_ln_url_pay_error_data {
9992        // Codec=Cst (C-struct based), see doc to use other codecs
9993        fn cst_decode(self) -> crate::bindings::LnUrlPayErrorData {
9994            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9995            CstDecode::<crate::bindings::LnUrlPayErrorData>::cst_decode(*wrap).into()
9996        }
9997    }
9998    impl CstDecode<crate::model::LnUrlPayRequest> for *mut wire_cst_ln_url_pay_request {
9999        // Codec=Cst (C-struct based), see doc to use other codecs
10000        fn cst_decode(self) -> crate::model::LnUrlPayRequest {
10001            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10002            CstDecode::<crate::model::LnUrlPayRequest>::cst_decode(*wrap).into()
10003        }
10004    }
10005    impl CstDecode<crate::bindings::LnUrlPayRequestData> for *mut wire_cst_ln_url_pay_request_data {
10006        // Codec=Cst (C-struct based), see doc to use other codecs
10007        fn cst_decode(self) -> crate::bindings::LnUrlPayRequestData {
10008            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10009            CstDecode::<crate::bindings::LnUrlPayRequestData>::cst_decode(*wrap).into()
10010        }
10011    }
10012    impl CstDecode<crate::model::LnUrlPaySuccessData> for *mut wire_cst_ln_url_pay_success_data {
10013        // Codec=Cst (C-struct based), see doc to use other codecs
10014        fn cst_decode(self) -> crate::model::LnUrlPaySuccessData {
10015            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10016            CstDecode::<crate::model::LnUrlPaySuccessData>::cst_decode(*wrap).into()
10017        }
10018    }
10019    impl CstDecode<crate::bindings::LnUrlWithdrawRequest> for *mut wire_cst_ln_url_withdraw_request {
10020        // Codec=Cst (C-struct based), see doc to use other codecs
10021        fn cst_decode(self) -> crate::bindings::LnUrlWithdrawRequest {
10022            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10023            CstDecode::<crate::bindings::LnUrlWithdrawRequest>::cst_decode(*wrap).into()
10024        }
10025    }
10026    impl CstDecode<crate::bindings::LnUrlWithdrawRequestData>
10027        for *mut wire_cst_ln_url_withdraw_request_data
10028    {
10029        // Codec=Cst (C-struct based), see doc to use other codecs
10030        fn cst_decode(self) -> crate::bindings::LnUrlWithdrawRequestData {
10031            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10032            CstDecode::<crate::bindings::LnUrlWithdrawRequestData>::cst_decode(*wrap).into()
10033        }
10034    }
10035    impl CstDecode<crate::bindings::duplicates::LnUrlWithdrawSuccessData>
10036        for *mut wire_cst_ln_url_withdraw_success_data
10037    {
10038        // Codec=Cst (C-struct based), see doc to use other codecs
10039        fn cst_decode(self) -> crate::bindings::duplicates::LnUrlWithdrawSuccessData {
10040            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10041            CstDecode::<crate::bindings::duplicates::LnUrlWithdrawSuccessData>::cst_decode(*wrap)
10042                .into()
10043        }
10044    }
10045    impl CstDecode<crate::bindings::MessageSuccessActionData>
10046        for *mut wire_cst_message_success_action_data
10047    {
10048        // Codec=Cst (C-struct based), see doc to use other codecs
10049        fn cst_decode(self) -> crate::bindings::MessageSuccessActionData {
10050            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10051            CstDecode::<crate::bindings::MessageSuccessActionData>::cst_decode(*wrap).into()
10052        }
10053    }
10054    impl CstDecode<crate::model::PayAmount> for *mut wire_cst_pay_amount {
10055        // Codec=Cst (C-struct based), see doc to use other codecs
10056        fn cst_decode(self) -> crate::model::PayAmount {
10057            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10058            CstDecode::<crate::model::PayAmount>::cst_decode(*wrap).into()
10059        }
10060    }
10061    impl CstDecode<crate::model::PayOnchainRequest> for *mut wire_cst_pay_onchain_request {
10062        // Codec=Cst (C-struct based), see doc to use other codecs
10063        fn cst_decode(self) -> crate::model::PayOnchainRequest {
10064            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10065            CstDecode::<crate::model::PayOnchainRequest>::cst_decode(*wrap).into()
10066        }
10067    }
10068    impl CstDecode<crate::model::Payment> for *mut wire_cst_payment {
10069        // Codec=Cst (C-struct based), see doc to use other codecs
10070        fn cst_decode(self) -> crate::model::Payment {
10071            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10072            CstDecode::<crate::model::Payment>::cst_decode(*wrap).into()
10073        }
10074    }
10075    impl CstDecode<crate::model::PrepareBuyBitcoinRequest>
10076        for *mut wire_cst_prepare_buy_bitcoin_request
10077    {
10078        // Codec=Cst (C-struct based), see doc to use other codecs
10079        fn cst_decode(self) -> crate::model::PrepareBuyBitcoinRequest {
10080            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10081            CstDecode::<crate::model::PrepareBuyBitcoinRequest>::cst_decode(*wrap).into()
10082        }
10083    }
10084    impl CstDecode<crate::model::PrepareLnUrlPayRequest> for *mut wire_cst_prepare_ln_url_pay_request {
10085        // Codec=Cst (C-struct based), see doc to use other codecs
10086        fn cst_decode(self) -> crate::model::PrepareLnUrlPayRequest {
10087            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10088            CstDecode::<crate::model::PrepareLnUrlPayRequest>::cst_decode(*wrap).into()
10089        }
10090    }
10091    impl CstDecode<crate::model::PreparePayOnchainRequest>
10092        for *mut wire_cst_prepare_pay_onchain_request
10093    {
10094        // Codec=Cst (C-struct based), see doc to use other codecs
10095        fn cst_decode(self) -> crate::model::PreparePayOnchainRequest {
10096            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10097            CstDecode::<crate::model::PreparePayOnchainRequest>::cst_decode(*wrap).into()
10098        }
10099    }
10100    impl CstDecode<crate::model::PrepareReceiveRequest> for *mut wire_cst_prepare_receive_request {
10101        // Codec=Cst (C-struct based), see doc to use other codecs
10102        fn cst_decode(self) -> crate::model::PrepareReceiveRequest {
10103            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10104            CstDecode::<crate::model::PrepareReceiveRequest>::cst_decode(*wrap).into()
10105        }
10106    }
10107    impl CstDecode<crate::model::PrepareRefundRequest> for *mut wire_cst_prepare_refund_request {
10108        // Codec=Cst (C-struct based), see doc to use other codecs
10109        fn cst_decode(self) -> crate::model::PrepareRefundRequest {
10110            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10111            CstDecode::<crate::model::PrepareRefundRequest>::cst_decode(*wrap).into()
10112        }
10113    }
10114    impl CstDecode<crate::model::PrepareSendRequest> for *mut wire_cst_prepare_send_request {
10115        // Codec=Cst (C-struct based), see doc to use other codecs
10116        fn cst_decode(self) -> crate::model::PrepareSendRequest {
10117            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10118            CstDecode::<crate::model::PrepareSendRequest>::cst_decode(*wrap).into()
10119        }
10120    }
10121    impl CstDecode<crate::model::ReceiveAmount> for *mut wire_cst_receive_amount {
10122        // Codec=Cst (C-struct based), see doc to use other codecs
10123        fn cst_decode(self) -> crate::model::ReceiveAmount {
10124            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10125            CstDecode::<crate::model::ReceiveAmount>::cst_decode(*wrap).into()
10126        }
10127    }
10128    impl CstDecode<crate::model::ReceivePaymentRequest> for *mut wire_cst_receive_payment_request {
10129        // Codec=Cst (C-struct based), see doc to use other codecs
10130        fn cst_decode(self) -> crate::model::ReceivePaymentRequest {
10131            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10132            CstDecode::<crate::model::ReceivePaymentRequest>::cst_decode(*wrap).into()
10133        }
10134    }
10135    impl CstDecode<crate::model::RefundRequest> for *mut wire_cst_refund_request {
10136        // Codec=Cst (C-struct based), see doc to use other codecs
10137        fn cst_decode(self) -> crate::model::RefundRequest {
10138            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10139            CstDecode::<crate::model::RefundRequest>::cst_decode(*wrap).into()
10140        }
10141    }
10142    impl CstDecode<crate::model::RestoreRequest> for *mut wire_cst_restore_request {
10143        // Codec=Cst (C-struct based), see doc to use other codecs
10144        fn cst_decode(self) -> crate::model::RestoreRequest {
10145            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10146            CstDecode::<crate::model::RestoreRequest>::cst_decode(*wrap).into()
10147        }
10148    }
10149    impl CstDecode<crate::model::SdkEvent> for *mut wire_cst_sdk_event {
10150        // Codec=Cst (C-struct based), see doc to use other codecs
10151        fn cst_decode(self) -> crate::model::SdkEvent {
10152            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10153            CstDecode::<crate::model::SdkEvent>::cst_decode(*wrap).into()
10154        }
10155    }
10156    impl CstDecode<crate::model::SendPaymentRequest> for *mut wire_cst_send_payment_request {
10157        // Codec=Cst (C-struct based), see doc to use other codecs
10158        fn cst_decode(self) -> crate::model::SendPaymentRequest {
10159            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10160            CstDecode::<crate::model::SendPaymentRequest>::cst_decode(*wrap).into()
10161        }
10162    }
10163    impl CstDecode<crate::model::SignMessageRequest> for *mut wire_cst_sign_message_request {
10164        // Codec=Cst (C-struct based), see doc to use other codecs
10165        fn cst_decode(self) -> crate::model::SignMessageRequest {
10166            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10167            CstDecode::<crate::model::SignMessageRequest>::cst_decode(*wrap).into()
10168        }
10169    }
10170    impl CstDecode<crate::bindings::SuccessAction> for *mut wire_cst_success_action {
10171        // Codec=Cst (C-struct based), see doc to use other codecs
10172        fn cst_decode(self) -> crate::bindings::SuccessAction {
10173            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10174            CstDecode::<crate::bindings::SuccessAction>::cst_decode(*wrap).into()
10175        }
10176    }
10177    impl CstDecode<crate::bindings::SuccessActionProcessed> for *mut wire_cst_success_action_processed {
10178        // Codec=Cst (C-struct based), see doc to use other codecs
10179        fn cst_decode(self) -> crate::bindings::SuccessActionProcessed {
10180            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10181            CstDecode::<crate::bindings::SuccessActionProcessed>::cst_decode(*wrap).into()
10182        }
10183    }
10184    impl CstDecode<crate::bindings::Symbol> for *mut wire_cst_symbol {
10185        // Codec=Cst (C-struct based), see doc to use other codecs
10186        fn cst_decode(self) -> crate::bindings::Symbol {
10187            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10188            CstDecode::<crate::bindings::Symbol>::cst_decode(*wrap).into()
10189        }
10190    }
10191    impl CstDecode<u32> for *mut u32 {
10192        // Codec=Cst (C-struct based), see doc to use other codecs
10193        fn cst_decode(self) -> u32 {
10194            unsafe { *flutter_rust_bridge::for_generated::box_from_leak_ptr(self) }
10195        }
10196    }
10197    impl CstDecode<u64> for *mut u64 {
10198        // Codec=Cst (C-struct based), see doc to use other codecs
10199        fn cst_decode(self) -> u64 {
10200            unsafe { *flutter_rust_bridge::for_generated::box_from_leak_ptr(self) }
10201        }
10202    }
10203    impl CstDecode<crate::bindings::UrlSuccessActionData> for *mut wire_cst_url_success_action_data {
10204        // Codec=Cst (C-struct based), see doc to use other codecs
10205        fn cst_decode(self) -> crate::bindings::UrlSuccessActionData {
10206            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10207            CstDecode::<crate::bindings::UrlSuccessActionData>::cst_decode(*wrap).into()
10208        }
10209    }
10210    impl CstDecode<crate::model::BuyBitcoinRequest> for wire_cst_buy_bitcoin_request {
10211        // Codec=Cst (C-struct based), see doc to use other codecs
10212        fn cst_decode(self) -> crate::model::BuyBitcoinRequest {
10213            crate::model::BuyBitcoinRequest {
10214                prepare_response: self.prepare_response.cst_decode(),
10215                redirect_url: self.redirect_url.cst_decode(),
10216            }
10217        }
10218    }
10219    impl CstDecode<crate::model::CheckMessageRequest> for wire_cst_check_message_request {
10220        // Codec=Cst (C-struct based), see doc to use other codecs
10221        fn cst_decode(self) -> crate::model::CheckMessageRequest {
10222            crate::model::CheckMessageRequest {
10223                message: self.message.cst_decode(),
10224                pubkey: self.pubkey.cst_decode(),
10225                signature: self.signature.cst_decode(),
10226            }
10227        }
10228    }
10229    impl CstDecode<crate::model::CheckMessageResponse> for wire_cst_check_message_response {
10230        // Codec=Cst (C-struct based), see doc to use other codecs
10231        fn cst_decode(self) -> crate::model::CheckMessageResponse {
10232            crate::model::CheckMessageResponse {
10233                is_valid: self.is_valid.cst_decode(),
10234            }
10235        }
10236    }
10237    impl CstDecode<crate::model::Config> for wire_cst_config {
10238        // Codec=Cst (C-struct based), see doc to use other codecs
10239        fn cst_decode(self) -> crate::model::Config {
10240            crate::model::Config {
10241                liquid_explorer: self.liquid_explorer.cst_decode(),
10242                bitcoin_explorer: self.bitcoin_explorer.cst_decode(),
10243                working_dir: self.working_dir.cst_decode(),
10244                cache_dir: self.cache_dir.cst_decode(),
10245                network: self.network.cst_decode(),
10246                payment_timeout_sec: self.payment_timeout_sec.cst_decode(),
10247                sync_service_url: self.sync_service_url.cst_decode(),
10248                zero_conf_max_amount_sat: self.zero_conf_max_amount_sat.cst_decode(),
10249                breez_api_key: self.breez_api_key.cst_decode(),
10250                external_input_parsers: self.external_input_parsers.cst_decode(),
10251                use_default_external_input_parsers: self
10252                    .use_default_external_input_parsers
10253                    .cst_decode(),
10254                onchain_fee_rate_leeway_sat_per_vbyte: self
10255                    .onchain_fee_rate_leeway_sat_per_vbyte
10256                    .cst_decode(),
10257                asset_metadata: self.asset_metadata.cst_decode(),
10258                sideswap_api_key: self.sideswap_api_key.cst_decode(),
10259            }
10260        }
10261    }
10262    impl CstDecode<crate::model::ConnectRequest> for wire_cst_connect_request {
10263        // Codec=Cst (C-struct based), see doc to use other codecs
10264        fn cst_decode(self) -> crate::model::ConnectRequest {
10265            crate::model::ConnectRequest {
10266                config: self.config.cst_decode(),
10267                mnemonic: self.mnemonic.cst_decode(),
10268                passphrase: self.passphrase.cst_decode(),
10269                seed: self.seed.cst_decode(),
10270            }
10271        }
10272    }
10273    impl CstDecode<crate::model::CreateBolt12InvoiceRequest>
10274        for wire_cst_create_bolt_12_invoice_request
10275    {
10276        // Codec=Cst (C-struct based), see doc to use other codecs
10277        fn cst_decode(self) -> crate::model::CreateBolt12InvoiceRequest {
10278            crate::model::CreateBolt12InvoiceRequest {
10279                offer: self.offer.cst_decode(),
10280                invoice_request: self.invoice_request.cst_decode(),
10281            }
10282        }
10283    }
10284    impl CstDecode<crate::model::CreateBolt12InvoiceResponse>
10285        for wire_cst_create_bolt_12_invoice_response
10286    {
10287        // Codec=Cst (C-struct based), see doc to use other codecs
10288        fn cst_decode(self) -> crate::model::CreateBolt12InvoiceResponse {
10289            crate::model::CreateBolt12InvoiceResponse {
10290                invoice: self.invoice.cst_decode(),
10291            }
10292        }
10293    }
10294    impl CstDecode<crate::bindings::CurrencyInfo> for wire_cst_currency_info {
10295        // Codec=Cst (C-struct based), see doc to use other codecs
10296        fn cst_decode(self) -> crate::bindings::CurrencyInfo {
10297            crate::bindings::CurrencyInfo {
10298                name: self.name.cst_decode(),
10299                fraction_size: self.fraction_size.cst_decode(),
10300                spacing: self.spacing.cst_decode(),
10301                symbol: self.symbol.cst_decode(),
10302                uniq_symbol: self.uniq_symbol.cst_decode(),
10303                localized_name: self.localized_name.cst_decode(),
10304                locale_overrides: self.locale_overrides.cst_decode(),
10305            }
10306        }
10307    }
10308    impl CstDecode<crate::bindings::ExternalInputParser> for wire_cst_external_input_parser {
10309        // Codec=Cst (C-struct based), see doc to use other codecs
10310        fn cst_decode(self) -> crate::bindings::ExternalInputParser {
10311            crate::bindings::ExternalInputParser {
10312                provider_id: self.provider_id.cst_decode(),
10313                input_regex: self.input_regex.cst_decode(),
10314                parser_url: self.parser_url.cst_decode(),
10315            }
10316        }
10317    }
10318    impl CstDecode<crate::model::FetchPaymentProposedFeesRequest>
10319        for wire_cst_fetch_payment_proposed_fees_request
10320    {
10321        // Codec=Cst (C-struct based), see doc to use other codecs
10322        fn cst_decode(self) -> crate::model::FetchPaymentProposedFeesRequest {
10323            crate::model::FetchPaymentProposedFeesRequest {
10324                swap_id: self.swap_id.cst_decode(),
10325            }
10326        }
10327    }
10328    impl CstDecode<crate::model::FetchPaymentProposedFeesResponse>
10329        for wire_cst_fetch_payment_proposed_fees_response
10330    {
10331        // Codec=Cst (C-struct based), see doc to use other codecs
10332        fn cst_decode(self) -> crate::model::FetchPaymentProposedFeesResponse {
10333            crate::model::FetchPaymentProposedFeesResponse {
10334                swap_id: self.swap_id.cst_decode(),
10335                fees_sat: self.fees_sat.cst_decode(),
10336                payer_amount_sat: self.payer_amount_sat.cst_decode(),
10337                receiver_amount_sat: self.receiver_amount_sat.cst_decode(),
10338            }
10339        }
10340    }
10341    impl CstDecode<crate::bindings::FiatCurrency> for wire_cst_fiat_currency {
10342        // Codec=Cst (C-struct based), see doc to use other codecs
10343        fn cst_decode(self) -> crate::bindings::FiatCurrency {
10344            crate::bindings::FiatCurrency {
10345                id: self.id.cst_decode(),
10346                info: self.info.cst_decode(),
10347            }
10348        }
10349    }
10350    impl CstDecode<crate::model::GetInfoResponse> for wire_cst_get_info_response {
10351        // Codec=Cst (C-struct based), see doc to use other codecs
10352        fn cst_decode(self) -> crate::model::GetInfoResponse {
10353            crate::model::GetInfoResponse {
10354                wallet_info: self.wallet_info.cst_decode(),
10355                blockchain_info: self.blockchain_info.cst_decode(),
10356            }
10357        }
10358    }
10359    impl CstDecode<crate::model::GetPaymentRequest> for wire_cst_get_payment_request {
10360        // Codec=Cst (C-struct based), see doc to use other codecs
10361        fn cst_decode(self) -> crate::model::GetPaymentRequest {
10362            match self.tag {
10363                0 => {
10364                    let ans = unsafe { self.kind.PaymentHash };
10365                    crate::model::GetPaymentRequest::PaymentHash {
10366                        payment_hash: ans.payment_hash.cst_decode(),
10367                    }
10368                }
10369                1 => {
10370                    let ans = unsafe { self.kind.SwapId };
10371                    crate::model::GetPaymentRequest::SwapId {
10372                        swap_id: ans.swap_id.cst_decode(),
10373                    }
10374                }
10375                _ => unreachable!(),
10376            }
10377        }
10378    }
10379    impl CstDecode<crate::bindings::InputType> for wire_cst_input_type {
10380        // Codec=Cst (C-struct based), see doc to use other codecs
10381        fn cst_decode(self) -> crate::bindings::InputType {
10382            match self.tag {
10383                0 => {
10384                    let ans = unsafe { self.kind.BitcoinAddress };
10385                    crate::bindings::InputType::BitcoinAddress {
10386                        address: ans.address.cst_decode(),
10387                    }
10388                }
10389                1 => {
10390                    let ans = unsafe { self.kind.LiquidAddress };
10391                    crate::bindings::InputType::LiquidAddress {
10392                        address: ans.address.cst_decode(),
10393                    }
10394                }
10395                2 => {
10396                    let ans = unsafe { self.kind.Bolt11 };
10397                    crate::bindings::InputType::Bolt11 {
10398                        invoice: ans.invoice.cst_decode(),
10399                    }
10400                }
10401                3 => {
10402                    let ans = unsafe { self.kind.Bolt12Offer };
10403                    crate::bindings::InputType::Bolt12Offer {
10404                        offer: ans.offer.cst_decode(),
10405                        bip353_address: ans.bip353_address.cst_decode(),
10406                    }
10407                }
10408                4 => {
10409                    let ans = unsafe { self.kind.NodeId };
10410                    crate::bindings::InputType::NodeId {
10411                        node_id: ans.node_id.cst_decode(),
10412                    }
10413                }
10414                5 => {
10415                    let ans = unsafe { self.kind.Url };
10416                    crate::bindings::InputType::Url {
10417                        url: ans.url.cst_decode(),
10418                    }
10419                }
10420                6 => {
10421                    let ans = unsafe { self.kind.LnUrlPay };
10422                    crate::bindings::InputType::LnUrlPay {
10423                        data: ans.data.cst_decode(),
10424                        bip353_address: ans.bip353_address.cst_decode(),
10425                    }
10426                }
10427                7 => {
10428                    let ans = unsafe { self.kind.LnUrlWithdraw };
10429                    crate::bindings::InputType::LnUrlWithdraw {
10430                        data: ans.data.cst_decode(),
10431                    }
10432                }
10433                8 => {
10434                    let ans = unsafe { self.kind.LnUrlAuth };
10435                    crate::bindings::InputType::LnUrlAuth {
10436                        data: ans.data.cst_decode(),
10437                    }
10438                }
10439                9 => {
10440                    let ans = unsafe { self.kind.LnUrlError };
10441                    crate::bindings::InputType::LnUrlError {
10442                        data: ans.data.cst_decode(),
10443                    }
10444                }
10445                _ => unreachable!(),
10446            }
10447        }
10448    }
10449    impl CstDecode<crate::model::LightningPaymentLimitsResponse>
10450        for wire_cst_lightning_payment_limits_response
10451    {
10452        // Codec=Cst (C-struct based), see doc to use other codecs
10453        fn cst_decode(self) -> crate::model::LightningPaymentLimitsResponse {
10454            crate::model::LightningPaymentLimitsResponse {
10455                send: self.send.cst_decode(),
10456                receive: self.receive.cst_decode(),
10457            }
10458        }
10459    }
10460    impl CstDecode<crate::model::Limits> for wire_cst_limits {
10461        // Codec=Cst (C-struct based), see doc to use other codecs
10462        fn cst_decode(self) -> crate::model::Limits {
10463            crate::model::Limits {
10464                min_sat: self.min_sat.cst_decode(),
10465                max_sat: self.max_sat.cst_decode(),
10466                max_zero_conf_sat: self.max_zero_conf_sat.cst_decode(),
10467            }
10468        }
10469    }
10470    impl CstDecode<crate::bindings::LiquidAddressData> for wire_cst_liquid_address_data {
10471        // Codec=Cst (C-struct based), see doc to use other codecs
10472        fn cst_decode(self) -> crate::bindings::LiquidAddressData {
10473            crate::bindings::LiquidAddressData {
10474                address: self.address.cst_decode(),
10475                network: self.network.cst_decode(),
10476                asset_id: self.asset_id.cst_decode(),
10477                amount: self.amount.cst_decode(),
10478                amount_sat: self.amount_sat.cst_decode(),
10479                label: self.label.cst_decode(),
10480                message: self.message.cst_decode(),
10481            }
10482        }
10483    }
10484    impl CstDecode<Vec<String>> for *mut wire_cst_list_String {
10485        // Codec=Cst (C-struct based), see doc to use other codecs
10486        fn cst_decode(self) -> Vec<String> {
10487            let vec = unsafe {
10488                let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10489                flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10490            };
10491            vec.into_iter().map(CstDecode::cst_decode).collect()
10492        }
10493    }
10494    impl CstDecode<Vec<crate::model::AssetBalance>> for *mut wire_cst_list_asset_balance {
10495        // Codec=Cst (C-struct based), see doc to use other codecs
10496        fn cst_decode(self) -> Vec<crate::model::AssetBalance> {
10497            let vec = unsafe {
10498                let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10499                flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10500            };
10501            vec.into_iter().map(CstDecode::cst_decode).collect()
10502        }
10503    }
10504    impl CstDecode<Vec<crate::model::AssetMetadata>> for *mut wire_cst_list_asset_metadata {
10505        // Codec=Cst (C-struct based), see doc to use other codecs
10506        fn cst_decode(self) -> Vec<crate::model::AssetMetadata> {
10507            let vec = unsafe {
10508                let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10509                flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10510            };
10511            vec.into_iter().map(CstDecode::cst_decode).collect()
10512        }
10513    }
10514    impl CstDecode<Vec<crate::bindings::ExternalInputParser>>
10515        for *mut wire_cst_list_external_input_parser
10516    {
10517        // Codec=Cst (C-struct based), see doc to use other codecs
10518        fn cst_decode(self) -> Vec<crate::bindings::ExternalInputParser> {
10519            let vec = unsafe {
10520                let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10521                flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10522            };
10523            vec.into_iter().map(CstDecode::cst_decode).collect()
10524        }
10525    }
10526    impl CstDecode<Vec<crate::bindings::FiatCurrency>> for *mut wire_cst_list_fiat_currency {
10527        // Codec=Cst (C-struct based), see doc to use other codecs
10528        fn cst_decode(self) -> Vec<crate::bindings::FiatCurrency> {
10529            let vec = unsafe {
10530                let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10531                flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10532            };
10533            vec.into_iter().map(CstDecode::cst_decode).collect()
10534        }
10535    }
10536    impl CstDecode<Vec<crate::bindings::LnOfferBlindedPath>>
10537        for *mut wire_cst_list_ln_offer_blinded_path
10538    {
10539        // Codec=Cst (C-struct based), see doc to use other codecs
10540        fn cst_decode(self) -> Vec<crate::bindings::LnOfferBlindedPath> {
10541            let vec = unsafe {
10542                let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10543                flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10544            };
10545            vec.into_iter().map(CstDecode::cst_decode).collect()
10546        }
10547    }
10548    impl CstDecode<Vec<crate::bindings::LocaleOverrides>> for *mut wire_cst_list_locale_overrides {
10549        // Codec=Cst (C-struct based), see doc to use other codecs
10550        fn cst_decode(self) -> Vec<crate::bindings::LocaleOverrides> {
10551            let vec = unsafe {
10552                let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10553                flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10554            };
10555            vec.into_iter().map(CstDecode::cst_decode).collect()
10556        }
10557    }
10558    impl CstDecode<Vec<crate::bindings::LocalizedName>> for *mut wire_cst_list_localized_name {
10559        // Codec=Cst (C-struct based), see doc to use other codecs
10560        fn cst_decode(self) -> Vec<crate::bindings::LocalizedName> {
10561            let vec = unsafe {
10562                let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10563                flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10564            };
10565            vec.into_iter().map(CstDecode::cst_decode).collect()
10566        }
10567    }
10568    impl CstDecode<Vec<crate::model::Payment>> for *mut wire_cst_list_payment {
10569        // Codec=Cst (C-struct based), see doc to use other codecs
10570        fn cst_decode(self) -> Vec<crate::model::Payment> {
10571            let vec = unsafe {
10572                let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10573                flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10574            };
10575            vec.into_iter().map(CstDecode::cst_decode).collect()
10576        }
10577    }
10578    impl CstDecode<crate::model::ListPaymentDetails> for wire_cst_list_payment_details {
10579        // Codec=Cst (C-struct based), see doc to use other codecs
10580        fn cst_decode(self) -> crate::model::ListPaymentDetails {
10581            match self.tag {
10582                0 => {
10583                    let ans = unsafe { self.kind.Liquid };
10584                    crate::model::ListPaymentDetails::Liquid {
10585                        asset_id: ans.asset_id.cst_decode(),
10586                        destination: ans.destination.cst_decode(),
10587                    }
10588                }
10589                1 => {
10590                    let ans = unsafe { self.kind.Bitcoin };
10591                    crate::model::ListPaymentDetails::Bitcoin {
10592                        address: ans.address.cst_decode(),
10593                    }
10594                }
10595                _ => unreachable!(),
10596            }
10597        }
10598    }
10599    impl CstDecode<Vec<crate::model::PaymentState>> for *mut wire_cst_list_payment_state {
10600        // Codec=Cst (C-struct based), see doc to use other codecs
10601        fn cst_decode(self) -> Vec<crate::model::PaymentState> {
10602            let vec = unsafe {
10603                let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10604                flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10605            };
10606            vec.into_iter().map(CstDecode::cst_decode).collect()
10607        }
10608    }
10609    impl CstDecode<Vec<crate::model::PaymentType>> for *mut wire_cst_list_payment_type {
10610        // Codec=Cst (C-struct based), see doc to use other codecs
10611        fn cst_decode(self) -> Vec<crate::model::PaymentType> {
10612            let vec = unsafe {
10613                let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10614                flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10615            };
10616            vec.into_iter().map(CstDecode::cst_decode).collect()
10617        }
10618    }
10619    impl CstDecode<crate::model::ListPaymentsRequest> for wire_cst_list_payments_request {
10620        // Codec=Cst (C-struct based), see doc to use other codecs
10621        fn cst_decode(self) -> crate::model::ListPaymentsRequest {
10622            crate::model::ListPaymentsRequest {
10623                filters: self.filters.cst_decode(),
10624                states: self.states.cst_decode(),
10625                from_timestamp: self.from_timestamp.cst_decode(),
10626                to_timestamp: self.to_timestamp.cst_decode(),
10627                offset: self.offset.cst_decode(),
10628                limit: self.limit.cst_decode(),
10629                details: self.details.cst_decode(),
10630                sort_ascending: self.sort_ascending.cst_decode(),
10631            }
10632        }
10633    }
10634    impl CstDecode<Vec<u8>> for *mut wire_cst_list_prim_u_8_strict {
10635        // Codec=Cst (C-struct based), see doc to use other codecs
10636        fn cst_decode(self) -> Vec<u8> {
10637            unsafe {
10638                let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10639                flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10640            }
10641        }
10642    }
10643    impl CstDecode<Vec<crate::bindings::Rate>> for *mut wire_cst_list_rate {
10644        // Codec=Cst (C-struct based), see doc to use other codecs
10645        fn cst_decode(self) -> Vec<crate::bindings::Rate> {
10646            let vec = unsafe {
10647                let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10648                flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10649            };
10650            vec.into_iter().map(CstDecode::cst_decode).collect()
10651        }
10652    }
10653    impl CstDecode<Vec<crate::model::RefundableSwap>> for *mut wire_cst_list_refundable_swap {
10654        // Codec=Cst (C-struct based), see doc to use other codecs
10655        fn cst_decode(self) -> Vec<crate::model::RefundableSwap> {
10656            let vec = 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            vec.into_iter().map(CstDecode::cst_decode).collect()
10661        }
10662    }
10663    impl CstDecode<Vec<crate::bindings::RouteHint>> for *mut wire_cst_list_route_hint {
10664        // Codec=Cst (C-struct based), see doc to use other codecs
10665        fn cst_decode(self) -> Vec<crate::bindings::RouteHint> {
10666            let vec = unsafe {
10667                let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10668                flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10669            };
10670            vec.into_iter().map(CstDecode::cst_decode).collect()
10671        }
10672    }
10673    impl CstDecode<Vec<crate::bindings::RouteHintHop>> for *mut wire_cst_list_route_hint_hop {
10674        // Codec=Cst (C-struct based), see doc to use other codecs
10675        fn cst_decode(self) -> Vec<crate::bindings::RouteHintHop> {
10676            let vec = unsafe {
10677                let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10678                flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10679            };
10680            vec.into_iter().map(CstDecode::cst_decode).collect()
10681        }
10682    }
10683    impl CstDecode<crate::bindings::LNInvoice> for wire_cst_ln_invoice {
10684        // Codec=Cst (C-struct based), see doc to use other codecs
10685        fn cst_decode(self) -> crate::bindings::LNInvoice {
10686            crate::bindings::LNInvoice {
10687                bolt11: self.bolt11.cst_decode(),
10688                network: self.network.cst_decode(),
10689                payee_pubkey: self.payee_pubkey.cst_decode(),
10690                payment_hash: self.payment_hash.cst_decode(),
10691                description: self.description.cst_decode(),
10692                description_hash: self.description_hash.cst_decode(),
10693                amount_msat: self.amount_msat.cst_decode(),
10694                timestamp: self.timestamp.cst_decode(),
10695                expiry: self.expiry.cst_decode(),
10696                routing_hints: self.routing_hints.cst_decode(),
10697                payment_secret: self.payment_secret.cst_decode(),
10698                min_final_cltv_expiry_delta: self.min_final_cltv_expiry_delta.cst_decode(),
10699            }
10700        }
10701    }
10702    impl CstDecode<crate::bindings::LNOffer> for wire_cst_ln_offer {
10703        // Codec=Cst (C-struct based), see doc to use other codecs
10704        fn cst_decode(self) -> crate::bindings::LNOffer {
10705            crate::bindings::LNOffer {
10706                offer: self.offer.cst_decode(),
10707                chains: self.chains.cst_decode(),
10708                min_amount: self.min_amount.cst_decode(),
10709                description: self.description.cst_decode(),
10710                absolute_expiry: self.absolute_expiry.cst_decode(),
10711                issuer: self.issuer.cst_decode(),
10712                signing_pubkey: self.signing_pubkey.cst_decode(),
10713                paths: self.paths.cst_decode(),
10714            }
10715        }
10716    }
10717    impl CstDecode<crate::bindings::LnOfferBlindedPath> for wire_cst_ln_offer_blinded_path {
10718        // Codec=Cst (C-struct based), see doc to use other codecs
10719        fn cst_decode(self) -> crate::bindings::LnOfferBlindedPath {
10720            crate::bindings::LnOfferBlindedPath {
10721                blinded_hops: self.blinded_hops.cst_decode(),
10722            }
10723        }
10724    }
10725    impl CstDecode<crate::bindings::duplicates::LnUrlAuthError> for wire_cst_ln_url_auth_error {
10726        // Codec=Cst (C-struct based), see doc to use other codecs
10727        fn cst_decode(self) -> crate::bindings::duplicates::LnUrlAuthError {
10728            match self.tag {
10729                0 => {
10730                    let ans = unsafe { self.kind.Generic };
10731                    crate::bindings::duplicates::LnUrlAuthError::Generic {
10732                        err: ans.err.cst_decode(),
10733                    }
10734                }
10735                1 => {
10736                    let ans = unsafe { self.kind.InvalidUri };
10737                    crate::bindings::duplicates::LnUrlAuthError::InvalidUri {
10738                        err: ans.err.cst_decode(),
10739                    }
10740                }
10741                2 => {
10742                    let ans = unsafe { self.kind.ServiceConnectivity };
10743                    crate::bindings::duplicates::LnUrlAuthError::ServiceConnectivity {
10744                        err: ans.err.cst_decode(),
10745                    }
10746                }
10747                _ => unreachable!(),
10748            }
10749        }
10750    }
10751    impl CstDecode<crate::bindings::LnUrlAuthRequestData> for wire_cst_ln_url_auth_request_data {
10752        // Codec=Cst (C-struct based), see doc to use other codecs
10753        fn cst_decode(self) -> crate::bindings::LnUrlAuthRequestData {
10754            crate::bindings::LnUrlAuthRequestData {
10755                k1: self.k1.cst_decode(),
10756                action: self.action.cst_decode(),
10757                domain: self.domain.cst_decode(),
10758                url: self.url.cst_decode(),
10759            }
10760        }
10761    }
10762    impl CstDecode<crate::bindings::duplicates::LnUrlCallbackStatus>
10763        for wire_cst_ln_url_callback_status
10764    {
10765        // Codec=Cst (C-struct based), see doc to use other codecs
10766        fn cst_decode(self) -> crate::bindings::duplicates::LnUrlCallbackStatus {
10767            match self.tag {
10768                0 => crate::bindings::duplicates::LnUrlCallbackStatus::Ok,
10769                1 => {
10770                    let ans = unsafe { self.kind.ErrorStatus };
10771                    crate::bindings::duplicates::LnUrlCallbackStatus::ErrorStatus {
10772                        data: ans.data.cst_decode(),
10773                    }
10774                }
10775                _ => unreachable!(),
10776            }
10777        }
10778    }
10779    impl CstDecode<crate::bindings::LnUrlErrorData> for wire_cst_ln_url_error_data {
10780        // Codec=Cst (C-struct based), see doc to use other codecs
10781        fn cst_decode(self) -> crate::bindings::LnUrlErrorData {
10782            crate::bindings::LnUrlErrorData {
10783                reason: self.reason.cst_decode(),
10784            }
10785        }
10786    }
10787    impl CstDecode<crate::model::LnUrlInfo> for wire_cst_ln_url_info {
10788        // Codec=Cst (C-struct based), see doc to use other codecs
10789        fn cst_decode(self) -> crate::model::LnUrlInfo {
10790            crate::model::LnUrlInfo {
10791                ln_address: self.ln_address.cst_decode(),
10792                lnurl_pay_comment: self.lnurl_pay_comment.cst_decode(),
10793                lnurl_pay_domain: self.lnurl_pay_domain.cst_decode(),
10794                lnurl_pay_metadata: self.lnurl_pay_metadata.cst_decode(),
10795                lnurl_pay_success_action: self.lnurl_pay_success_action.cst_decode(),
10796                lnurl_pay_unprocessed_success_action: self
10797                    .lnurl_pay_unprocessed_success_action
10798                    .cst_decode(),
10799                lnurl_withdraw_endpoint: self.lnurl_withdraw_endpoint.cst_decode(),
10800            }
10801        }
10802    }
10803    impl CstDecode<crate::bindings::duplicates::LnUrlPayError> for wire_cst_ln_url_pay_error {
10804        // Codec=Cst (C-struct based), see doc to use other codecs
10805        fn cst_decode(self) -> crate::bindings::duplicates::LnUrlPayError {
10806            match self.tag {
10807                0 => crate::bindings::duplicates::LnUrlPayError::AlreadyPaid,
10808                1 => {
10809                    let ans = unsafe { self.kind.Generic };
10810                    crate::bindings::duplicates::LnUrlPayError::Generic {
10811                        err: ans.err.cst_decode(),
10812                    }
10813                }
10814                2 => {
10815                    let ans = unsafe { self.kind.InsufficientBalance };
10816                    crate::bindings::duplicates::LnUrlPayError::InsufficientBalance {
10817                        err: ans.err.cst_decode(),
10818                    }
10819                }
10820                3 => {
10821                    let ans = unsafe { self.kind.InvalidAmount };
10822                    crate::bindings::duplicates::LnUrlPayError::InvalidAmount {
10823                        err: ans.err.cst_decode(),
10824                    }
10825                }
10826                4 => {
10827                    let ans = unsafe { self.kind.InvalidInvoice };
10828                    crate::bindings::duplicates::LnUrlPayError::InvalidInvoice {
10829                        err: ans.err.cst_decode(),
10830                    }
10831                }
10832                5 => {
10833                    let ans = unsafe { self.kind.InvalidNetwork };
10834                    crate::bindings::duplicates::LnUrlPayError::InvalidNetwork {
10835                        err: ans.err.cst_decode(),
10836                    }
10837                }
10838                6 => {
10839                    let ans = unsafe { self.kind.InvalidUri };
10840                    crate::bindings::duplicates::LnUrlPayError::InvalidUri {
10841                        err: ans.err.cst_decode(),
10842                    }
10843                }
10844                7 => {
10845                    let ans = unsafe { self.kind.InvoiceExpired };
10846                    crate::bindings::duplicates::LnUrlPayError::InvoiceExpired {
10847                        err: ans.err.cst_decode(),
10848                    }
10849                }
10850                8 => {
10851                    let ans = unsafe { self.kind.PaymentFailed };
10852                    crate::bindings::duplicates::LnUrlPayError::PaymentFailed {
10853                        err: ans.err.cst_decode(),
10854                    }
10855                }
10856                9 => {
10857                    let ans = unsafe { self.kind.PaymentTimeout };
10858                    crate::bindings::duplicates::LnUrlPayError::PaymentTimeout {
10859                        err: ans.err.cst_decode(),
10860                    }
10861                }
10862                10 => {
10863                    let ans = unsafe { self.kind.RouteNotFound };
10864                    crate::bindings::duplicates::LnUrlPayError::RouteNotFound {
10865                        err: ans.err.cst_decode(),
10866                    }
10867                }
10868                11 => {
10869                    let ans = unsafe { self.kind.RouteTooExpensive };
10870                    crate::bindings::duplicates::LnUrlPayError::RouteTooExpensive {
10871                        err: ans.err.cst_decode(),
10872                    }
10873                }
10874                12 => {
10875                    let ans = unsafe { self.kind.ServiceConnectivity };
10876                    crate::bindings::duplicates::LnUrlPayError::ServiceConnectivity {
10877                        err: ans.err.cst_decode(),
10878                    }
10879                }
10880                _ => unreachable!(),
10881            }
10882        }
10883    }
10884    impl CstDecode<crate::bindings::LnUrlPayErrorData> for wire_cst_ln_url_pay_error_data {
10885        // Codec=Cst (C-struct based), see doc to use other codecs
10886        fn cst_decode(self) -> crate::bindings::LnUrlPayErrorData {
10887            crate::bindings::LnUrlPayErrorData {
10888                payment_hash: self.payment_hash.cst_decode(),
10889                reason: self.reason.cst_decode(),
10890            }
10891        }
10892    }
10893    impl CstDecode<crate::model::LnUrlPayRequest> for wire_cst_ln_url_pay_request {
10894        // Codec=Cst (C-struct based), see doc to use other codecs
10895        fn cst_decode(self) -> crate::model::LnUrlPayRequest {
10896            crate::model::LnUrlPayRequest {
10897                prepare_response: self.prepare_response.cst_decode(),
10898            }
10899        }
10900    }
10901    impl CstDecode<crate::bindings::LnUrlPayRequestData> for wire_cst_ln_url_pay_request_data {
10902        // Codec=Cst (C-struct based), see doc to use other codecs
10903        fn cst_decode(self) -> crate::bindings::LnUrlPayRequestData {
10904            crate::bindings::LnUrlPayRequestData {
10905                callback: self.callback.cst_decode(),
10906                min_sendable: self.min_sendable.cst_decode(),
10907                max_sendable: self.max_sendable.cst_decode(),
10908                metadata_str: self.metadata_str.cst_decode(),
10909                comment_allowed: self.comment_allowed.cst_decode(),
10910                domain: self.domain.cst_decode(),
10911                allows_nostr: self.allows_nostr.cst_decode(),
10912                nostr_pubkey: self.nostr_pubkey.cst_decode(),
10913                ln_address: self.ln_address.cst_decode(),
10914            }
10915        }
10916    }
10917    impl CstDecode<crate::model::LnUrlPayResult> for wire_cst_ln_url_pay_result {
10918        // Codec=Cst (C-struct based), see doc to use other codecs
10919        fn cst_decode(self) -> crate::model::LnUrlPayResult {
10920            match self.tag {
10921                0 => {
10922                    let ans = unsafe { self.kind.EndpointSuccess };
10923                    crate::model::LnUrlPayResult::EndpointSuccess {
10924                        data: ans.data.cst_decode(),
10925                    }
10926                }
10927                1 => {
10928                    let ans = unsafe { self.kind.EndpointError };
10929                    crate::model::LnUrlPayResult::EndpointError {
10930                        data: ans.data.cst_decode(),
10931                    }
10932                }
10933                2 => {
10934                    let ans = unsafe { self.kind.PayError };
10935                    crate::model::LnUrlPayResult::PayError {
10936                        data: ans.data.cst_decode(),
10937                    }
10938                }
10939                _ => unreachable!(),
10940            }
10941        }
10942    }
10943    impl CstDecode<crate::model::LnUrlPaySuccessData> for wire_cst_ln_url_pay_success_data {
10944        // Codec=Cst (C-struct based), see doc to use other codecs
10945        fn cst_decode(self) -> crate::model::LnUrlPaySuccessData {
10946            crate::model::LnUrlPaySuccessData {
10947                payment: self.payment.cst_decode(),
10948                success_action: self.success_action.cst_decode(),
10949            }
10950        }
10951    }
10952    impl CstDecode<crate::bindings::duplicates::LnUrlWithdrawError> for wire_cst_ln_url_withdraw_error {
10953        // Codec=Cst (C-struct based), see doc to use other codecs
10954        fn cst_decode(self) -> crate::bindings::duplicates::LnUrlWithdrawError {
10955            match self.tag {
10956                0 => {
10957                    let ans = unsafe { self.kind.Generic };
10958                    crate::bindings::duplicates::LnUrlWithdrawError::Generic {
10959                        err: ans.err.cst_decode(),
10960                    }
10961                }
10962                1 => {
10963                    let ans = unsafe { self.kind.InvalidAmount };
10964                    crate::bindings::duplicates::LnUrlWithdrawError::InvalidAmount {
10965                        err: ans.err.cst_decode(),
10966                    }
10967                }
10968                2 => {
10969                    let ans = unsafe { self.kind.InvalidInvoice };
10970                    crate::bindings::duplicates::LnUrlWithdrawError::InvalidInvoice {
10971                        err: ans.err.cst_decode(),
10972                    }
10973                }
10974                3 => {
10975                    let ans = unsafe { self.kind.InvalidUri };
10976                    crate::bindings::duplicates::LnUrlWithdrawError::InvalidUri {
10977                        err: ans.err.cst_decode(),
10978                    }
10979                }
10980                4 => {
10981                    let ans = unsafe { self.kind.InvoiceNoRoutingHints };
10982                    crate::bindings::duplicates::LnUrlWithdrawError::InvoiceNoRoutingHints {
10983                        err: ans.err.cst_decode(),
10984                    }
10985                }
10986                5 => {
10987                    let ans = unsafe { self.kind.ServiceConnectivity };
10988                    crate::bindings::duplicates::LnUrlWithdrawError::ServiceConnectivity {
10989                        err: ans.err.cst_decode(),
10990                    }
10991                }
10992                _ => unreachable!(),
10993            }
10994        }
10995    }
10996    impl CstDecode<crate::bindings::LnUrlWithdrawRequest> for wire_cst_ln_url_withdraw_request {
10997        // Codec=Cst (C-struct based), see doc to use other codecs
10998        fn cst_decode(self) -> crate::bindings::LnUrlWithdrawRequest {
10999            crate::bindings::LnUrlWithdrawRequest {
11000                data: self.data.cst_decode(),
11001                amount_msat: self.amount_msat.cst_decode(),
11002                description: self.description.cst_decode(),
11003            }
11004        }
11005    }
11006    impl CstDecode<crate::bindings::LnUrlWithdrawRequestData>
11007        for wire_cst_ln_url_withdraw_request_data
11008    {
11009        // Codec=Cst (C-struct based), see doc to use other codecs
11010        fn cst_decode(self) -> crate::bindings::LnUrlWithdrawRequestData {
11011            crate::bindings::LnUrlWithdrawRequestData {
11012                callback: self.callback.cst_decode(),
11013                k1: self.k1.cst_decode(),
11014                default_description: self.default_description.cst_decode(),
11015                min_withdrawable: self.min_withdrawable.cst_decode(),
11016                max_withdrawable: self.max_withdrawable.cst_decode(),
11017            }
11018        }
11019    }
11020    impl CstDecode<crate::bindings::duplicates::LnUrlWithdrawResult>
11021        for wire_cst_ln_url_withdraw_result
11022    {
11023        // Codec=Cst (C-struct based), see doc to use other codecs
11024        fn cst_decode(self) -> crate::bindings::duplicates::LnUrlWithdrawResult {
11025            match self.tag {
11026                0 => {
11027                    let ans = unsafe { self.kind.Ok };
11028                    crate::bindings::duplicates::LnUrlWithdrawResult::Ok {
11029                        data: ans.data.cst_decode(),
11030                    }
11031                }
11032                1 => {
11033                    let ans = unsafe { self.kind.Timeout };
11034                    crate::bindings::duplicates::LnUrlWithdrawResult::Timeout {
11035                        data: ans.data.cst_decode(),
11036                    }
11037                }
11038                2 => {
11039                    let ans = unsafe { self.kind.ErrorStatus };
11040                    crate::bindings::duplicates::LnUrlWithdrawResult::ErrorStatus {
11041                        data: ans.data.cst_decode(),
11042                    }
11043                }
11044                _ => unreachable!(),
11045            }
11046        }
11047    }
11048    impl CstDecode<crate::bindings::duplicates::LnUrlWithdrawSuccessData>
11049        for wire_cst_ln_url_withdraw_success_data
11050    {
11051        // Codec=Cst (C-struct based), see doc to use other codecs
11052        fn cst_decode(self) -> crate::bindings::duplicates::LnUrlWithdrawSuccessData {
11053            crate::bindings::duplicates::LnUrlWithdrawSuccessData {
11054                invoice: self.invoice.cst_decode(),
11055            }
11056        }
11057    }
11058    impl CstDecode<crate::bindings::LocaleOverrides> for wire_cst_locale_overrides {
11059        // Codec=Cst (C-struct based), see doc to use other codecs
11060        fn cst_decode(self) -> crate::bindings::LocaleOverrides {
11061            crate::bindings::LocaleOverrides {
11062                locale: self.locale.cst_decode(),
11063                spacing: self.spacing.cst_decode(),
11064                symbol: self.symbol.cst_decode(),
11065            }
11066        }
11067    }
11068    impl CstDecode<crate::bindings::LocalizedName> for wire_cst_localized_name {
11069        // Codec=Cst (C-struct based), see doc to use other codecs
11070        fn cst_decode(self) -> crate::bindings::LocalizedName {
11071            crate::bindings::LocalizedName {
11072                locale: self.locale.cst_decode(),
11073                name: self.name.cst_decode(),
11074            }
11075        }
11076    }
11077    impl CstDecode<crate::model::LogEntry> for wire_cst_log_entry {
11078        // Codec=Cst (C-struct based), see doc to use other codecs
11079        fn cst_decode(self) -> crate::model::LogEntry {
11080            crate::model::LogEntry {
11081                line: self.line.cst_decode(),
11082                level: self.level.cst_decode(),
11083            }
11084        }
11085    }
11086    impl CstDecode<crate::bindings::MessageSuccessActionData> for wire_cst_message_success_action_data {
11087        // Codec=Cst (C-struct based), see doc to use other codecs
11088        fn cst_decode(self) -> crate::bindings::MessageSuccessActionData {
11089            crate::bindings::MessageSuccessActionData {
11090                message: self.message.cst_decode(),
11091            }
11092        }
11093    }
11094    impl CstDecode<crate::model::OnchainPaymentLimitsResponse>
11095        for wire_cst_onchain_payment_limits_response
11096    {
11097        // Codec=Cst (C-struct based), see doc to use other codecs
11098        fn cst_decode(self) -> crate::model::OnchainPaymentLimitsResponse {
11099            crate::model::OnchainPaymentLimitsResponse {
11100                send: self.send.cst_decode(),
11101                receive: self.receive.cst_decode(),
11102            }
11103        }
11104    }
11105    impl CstDecode<crate::model::PayAmount> for wire_cst_pay_amount {
11106        // Codec=Cst (C-struct based), see doc to use other codecs
11107        fn cst_decode(self) -> crate::model::PayAmount {
11108            match self.tag {
11109                0 => {
11110                    let ans = unsafe { self.kind.Bitcoin };
11111                    crate::model::PayAmount::Bitcoin {
11112                        receiver_amount_sat: ans.receiver_amount_sat.cst_decode(),
11113                    }
11114                }
11115                1 => {
11116                    let ans = unsafe { self.kind.Asset };
11117                    crate::model::PayAmount::Asset {
11118                        asset_id: ans.asset_id.cst_decode(),
11119                        receiver_amount: ans.receiver_amount.cst_decode(),
11120                        estimate_asset_fees: ans.estimate_asset_fees.cst_decode(),
11121                    }
11122                }
11123                2 => crate::model::PayAmount::Drain,
11124                _ => unreachable!(),
11125            }
11126        }
11127    }
11128    impl CstDecode<crate::model::PayOnchainRequest> for wire_cst_pay_onchain_request {
11129        // Codec=Cst (C-struct based), see doc to use other codecs
11130        fn cst_decode(self) -> crate::model::PayOnchainRequest {
11131            crate::model::PayOnchainRequest {
11132                address: self.address.cst_decode(),
11133                prepare_response: self.prepare_response.cst_decode(),
11134            }
11135        }
11136    }
11137    impl CstDecode<crate::model::Payment> for wire_cst_payment {
11138        // Codec=Cst (C-struct based), see doc to use other codecs
11139        fn cst_decode(self) -> crate::model::Payment {
11140            crate::model::Payment {
11141                destination: self.destination.cst_decode(),
11142                tx_id: self.tx_id.cst_decode(),
11143                unblinding_data: self.unblinding_data.cst_decode(),
11144                timestamp: self.timestamp.cst_decode(),
11145                amount_sat: self.amount_sat.cst_decode(),
11146                fees_sat: self.fees_sat.cst_decode(),
11147                swapper_fees_sat: self.swapper_fees_sat.cst_decode(),
11148                payment_type: self.payment_type.cst_decode(),
11149                status: self.status.cst_decode(),
11150                details: self.details.cst_decode(),
11151            }
11152        }
11153    }
11154    impl CstDecode<crate::model::PaymentDetails> for wire_cst_payment_details {
11155        // Codec=Cst (C-struct based), see doc to use other codecs
11156        fn cst_decode(self) -> crate::model::PaymentDetails {
11157            match self.tag {
11158                0 => {
11159                    let ans = unsafe { self.kind.Lightning };
11160                    crate::model::PaymentDetails::Lightning {
11161                        swap_id: ans.swap_id.cst_decode(),
11162                        description: ans.description.cst_decode(),
11163                        liquid_expiration_blockheight: ans
11164                            .liquid_expiration_blockheight
11165                            .cst_decode(),
11166                        preimage: ans.preimage.cst_decode(),
11167                        invoice: ans.invoice.cst_decode(),
11168                        bolt12_offer: ans.bolt12_offer.cst_decode(),
11169                        payment_hash: ans.payment_hash.cst_decode(),
11170                        destination_pubkey: ans.destination_pubkey.cst_decode(),
11171                        lnurl_info: ans.lnurl_info.cst_decode(),
11172                        bip353_address: ans.bip353_address.cst_decode(),
11173                        claim_tx_id: ans.claim_tx_id.cst_decode(),
11174                        refund_tx_id: ans.refund_tx_id.cst_decode(),
11175                        refund_tx_amount_sat: ans.refund_tx_amount_sat.cst_decode(),
11176                    }
11177                }
11178                1 => {
11179                    let ans = unsafe { self.kind.Liquid };
11180                    crate::model::PaymentDetails::Liquid {
11181                        destination: ans.destination.cst_decode(),
11182                        description: ans.description.cst_decode(),
11183                        asset_id: ans.asset_id.cst_decode(),
11184                        asset_info: ans.asset_info.cst_decode(),
11185                        lnurl_info: ans.lnurl_info.cst_decode(),
11186                        bip353_address: ans.bip353_address.cst_decode(),
11187                    }
11188                }
11189                2 => {
11190                    let ans = unsafe { self.kind.Bitcoin };
11191                    crate::model::PaymentDetails::Bitcoin {
11192                        swap_id: ans.swap_id.cst_decode(),
11193                        description: ans.description.cst_decode(),
11194                        auto_accepted_fees: ans.auto_accepted_fees.cst_decode(),
11195                        liquid_expiration_blockheight: ans
11196                            .liquid_expiration_blockheight
11197                            .cst_decode(),
11198                        bitcoin_expiration_blockheight: ans
11199                            .bitcoin_expiration_blockheight
11200                            .cst_decode(),
11201                        lockup_tx_id: ans.lockup_tx_id.cst_decode(),
11202                        claim_tx_id: ans.claim_tx_id.cst_decode(),
11203                        refund_tx_id: ans.refund_tx_id.cst_decode(),
11204                        refund_tx_amount_sat: ans.refund_tx_amount_sat.cst_decode(),
11205                    }
11206                }
11207                _ => unreachable!(),
11208            }
11209        }
11210    }
11211    impl CstDecode<crate::error::PaymentError> for wire_cst_payment_error {
11212        // Codec=Cst (C-struct based), see doc to use other codecs
11213        fn cst_decode(self) -> crate::error::PaymentError {
11214            match self.tag {
11215                0 => crate::error::PaymentError::AlreadyClaimed,
11216                1 => crate::error::PaymentError::AlreadyPaid,
11217                2 => crate::error::PaymentError::PaymentInProgress,
11218                3 => {
11219                    let ans = unsafe { self.kind.AmountOutOfRange };
11220                    crate::error::PaymentError::AmountOutOfRange {
11221                        min: ans.min.cst_decode(),
11222                        max: ans.max.cst_decode(),
11223                    }
11224                }
11225                4 => {
11226                    let ans = unsafe { self.kind.AmountMissing };
11227                    crate::error::PaymentError::AmountMissing {
11228                        err: ans.err.cst_decode(),
11229                    }
11230                }
11231                5 => {
11232                    let ans = unsafe { self.kind.AssetError };
11233                    crate::error::PaymentError::AssetError {
11234                        err: ans.err.cst_decode(),
11235                    }
11236                }
11237                6 => {
11238                    let ans = unsafe { self.kind.InvalidNetwork };
11239                    crate::error::PaymentError::InvalidNetwork {
11240                        err: ans.err.cst_decode(),
11241                    }
11242                }
11243                7 => {
11244                    let ans = unsafe { self.kind.Generic };
11245                    crate::error::PaymentError::Generic {
11246                        err: ans.err.cst_decode(),
11247                    }
11248                }
11249                8 => crate::error::PaymentError::InvalidOrExpiredFees,
11250                9 => crate::error::PaymentError::InsufficientFunds,
11251                10 => {
11252                    let ans = unsafe { self.kind.InvalidDescription };
11253                    crate::error::PaymentError::InvalidDescription {
11254                        err: ans.err.cst_decode(),
11255                    }
11256                }
11257                11 => {
11258                    let ans = unsafe { self.kind.InvalidInvoice };
11259                    crate::error::PaymentError::InvalidInvoice {
11260                        err: ans.err.cst_decode(),
11261                    }
11262                }
11263                12 => crate::error::PaymentError::InvalidPreimage,
11264                13 => crate::error::PaymentError::PairsNotFound,
11265                14 => crate::error::PaymentError::PaymentTimeout,
11266                15 => crate::error::PaymentError::PersistError,
11267                16 => {
11268                    let ans = unsafe { self.kind.ReceiveError };
11269                    crate::error::PaymentError::ReceiveError {
11270                        err: ans.err.cst_decode(),
11271                    }
11272                }
11273                17 => {
11274                    let ans = unsafe { self.kind.Refunded };
11275                    crate::error::PaymentError::Refunded {
11276                        err: ans.err.cst_decode(),
11277                        refund_tx_id: ans.refund_tx_id.cst_decode(),
11278                    }
11279                }
11280                18 => crate::error::PaymentError::SelfTransferNotSupported,
11281                19 => {
11282                    let ans = unsafe { self.kind.SendError };
11283                    crate::error::PaymentError::SendError {
11284                        err: ans.err.cst_decode(),
11285                    }
11286                }
11287                20 => {
11288                    let ans = unsafe { self.kind.SignerError };
11289                    crate::error::PaymentError::SignerError {
11290                        err: ans.err.cst_decode(),
11291                    }
11292                }
11293                _ => unreachable!(),
11294            }
11295        }
11296    }
11297    impl CstDecode<crate::model::PrepareBuyBitcoinRequest> for wire_cst_prepare_buy_bitcoin_request {
11298        // Codec=Cst (C-struct based), see doc to use other codecs
11299        fn cst_decode(self) -> crate::model::PrepareBuyBitcoinRequest {
11300            crate::model::PrepareBuyBitcoinRequest {
11301                provider: self.provider.cst_decode(),
11302                amount_sat: self.amount_sat.cst_decode(),
11303            }
11304        }
11305    }
11306    impl CstDecode<crate::model::PrepareBuyBitcoinResponse> for wire_cst_prepare_buy_bitcoin_response {
11307        // Codec=Cst (C-struct based), see doc to use other codecs
11308        fn cst_decode(self) -> crate::model::PrepareBuyBitcoinResponse {
11309            crate::model::PrepareBuyBitcoinResponse {
11310                provider: self.provider.cst_decode(),
11311                amount_sat: self.amount_sat.cst_decode(),
11312                fees_sat: self.fees_sat.cst_decode(),
11313            }
11314        }
11315    }
11316    impl CstDecode<crate::model::PrepareLnUrlPayRequest> for wire_cst_prepare_ln_url_pay_request {
11317        // Codec=Cst (C-struct based), see doc to use other codecs
11318        fn cst_decode(self) -> crate::model::PrepareLnUrlPayRequest {
11319            crate::model::PrepareLnUrlPayRequest {
11320                data: self.data.cst_decode(),
11321                amount: self.amount.cst_decode(),
11322                bip353_address: self.bip353_address.cst_decode(),
11323                comment: self.comment.cst_decode(),
11324                validate_success_action_url: self.validate_success_action_url.cst_decode(),
11325            }
11326        }
11327    }
11328    impl CstDecode<crate::model::PrepareLnUrlPayResponse> for wire_cst_prepare_ln_url_pay_response {
11329        // Codec=Cst (C-struct based), see doc to use other codecs
11330        fn cst_decode(self) -> crate::model::PrepareLnUrlPayResponse {
11331            crate::model::PrepareLnUrlPayResponse {
11332                destination: self.destination.cst_decode(),
11333                fees_sat: self.fees_sat.cst_decode(),
11334                data: self.data.cst_decode(),
11335                amount: self.amount.cst_decode(),
11336                comment: self.comment.cst_decode(),
11337                success_action: self.success_action.cst_decode(),
11338            }
11339        }
11340    }
11341    impl CstDecode<crate::model::PreparePayOnchainRequest> for wire_cst_prepare_pay_onchain_request {
11342        // Codec=Cst (C-struct based), see doc to use other codecs
11343        fn cst_decode(self) -> crate::model::PreparePayOnchainRequest {
11344            crate::model::PreparePayOnchainRequest {
11345                amount: self.amount.cst_decode(),
11346                fee_rate_sat_per_vbyte: self.fee_rate_sat_per_vbyte.cst_decode(),
11347            }
11348        }
11349    }
11350    impl CstDecode<crate::model::PreparePayOnchainResponse> for wire_cst_prepare_pay_onchain_response {
11351        // Codec=Cst (C-struct based), see doc to use other codecs
11352        fn cst_decode(self) -> crate::model::PreparePayOnchainResponse {
11353            crate::model::PreparePayOnchainResponse {
11354                receiver_amount_sat: self.receiver_amount_sat.cst_decode(),
11355                claim_fees_sat: self.claim_fees_sat.cst_decode(),
11356                total_fees_sat: self.total_fees_sat.cst_decode(),
11357            }
11358        }
11359    }
11360    impl CstDecode<crate::model::PrepareReceiveRequest> for wire_cst_prepare_receive_request {
11361        // Codec=Cst (C-struct based), see doc to use other codecs
11362        fn cst_decode(self) -> crate::model::PrepareReceiveRequest {
11363            crate::model::PrepareReceiveRequest {
11364                payment_method: self.payment_method.cst_decode(),
11365                amount: self.amount.cst_decode(),
11366            }
11367        }
11368    }
11369    impl CstDecode<crate::model::PrepareReceiveResponse> for wire_cst_prepare_receive_response {
11370        // Codec=Cst (C-struct based), see doc to use other codecs
11371        fn cst_decode(self) -> crate::model::PrepareReceiveResponse {
11372            crate::model::PrepareReceiveResponse {
11373                payment_method: self.payment_method.cst_decode(),
11374                fees_sat: self.fees_sat.cst_decode(),
11375                amount: self.amount.cst_decode(),
11376                min_payer_amount_sat: self.min_payer_amount_sat.cst_decode(),
11377                max_payer_amount_sat: self.max_payer_amount_sat.cst_decode(),
11378                swapper_feerate: self.swapper_feerate.cst_decode(),
11379            }
11380        }
11381    }
11382    impl CstDecode<crate::model::PrepareRefundRequest> for wire_cst_prepare_refund_request {
11383        // Codec=Cst (C-struct based), see doc to use other codecs
11384        fn cst_decode(self) -> crate::model::PrepareRefundRequest {
11385            crate::model::PrepareRefundRequest {
11386                swap_address: self.swap_address.cst_decode(),
11387                refund_address: self.refund_address.cst_decode(),
11388                fee_rate_sat_per_vbyte: self.fee_rate_sat_per_vbyte.cst_decode(),
11389            }
11390        }
11391    }
11392    impl CstDecode<crate::model::PrepareRefundResponse> for wire_cst_prepare_refund_response {
11393        // Codec=Cst (C-struct based), see doc to use other codecs
11394        fn cst_decode(self) -> crate::model::PrepareRefundResponse {
11395            crate::model::PrepareRefundResponse {
11396                tx_vsize: self.tx_vsize.cst_decode(),
11397                tx_fee_sat: self.tx_fee_sat.cst_decode(),
11398                last_refund_tx_id: self.last_refund_tx_id.cst_decode(),
11399            }
11400        }
11401    }
11402    impl CstDecode<crate::model::PrepareSendRequest> for wire_cst_prepare_send_request {
11403        // Codec=Cst (C-struct based), see doc to use other codecs
11404        fn cst_decode(self) -> crate::model::PrepareSendRequest {
11405            crate::model::PrepareSendRequest {
11406                destination: self.destination.cst_decode(),
11407                amount: self.amount.cst_decode(),
11408            }
11409        }
11410    }
11411    impl CstDecode<crate::model::PrepareSendResponse> for wire_cst_prepare_send_response {
11412        // Codec=Cst (C-struct based), see doc to use other codecs
11413        fn cst_decode(self) -> crate::model::PrepareSendResponse {
11414            crate::model::PrepareSendResponse {
11415                destination: self.destination.cst_decode(),
11416                amount: self.amount.cst_decode(),
11417                fees_sat: self.fees_sat.cst_decode(),
11418                estimated_asset_fees: self.estimated_asset_fees.cst_decode(),
11419            }
11420        }
11421    }
11422    impl CstDecode<crate::bindings::Rate> for wire_cst_rate {
11423        // Codec=Cst (C-struct based), see doc to use other codecs
11424        fn cst_decode(self) -> crate::bindings::Rate {
11425            crate::bindings::Rate {
11426                coin: self.coin.cst_decode(),
11427                value: self.value.cst_decode(),
11428            }
11429        }
11430    }
11431    impl CstDecode<crate::model::ReceiveAmount> for wire_cst_receive_amount {
11432        // Codec=Cst (C-struct based), see doc to use other codecs
11433        fn cst_decode(self) -> crate::model::ReceiveAmount {
11434            match self.tag {
11435                0 => {
11436                    let ans = unsafe { self.kind.Bitcoin };
11437                    crate::model::ReceiveAmount::Bitcoin {
11438                        payer_amount_sat: ans.payer_amount_sat.cst_decode(),
11439                    }
11440                }
11441                1 => {
11442                    let ans = unsafe { self.kind.Asset };
11443                    crate::model::ReceiveAmount::Asset {
11444                        asset_id: ans.asset_id.cst_decode(),
11445                        payer_amount: ans.payer_amount.cst_decode(),
11446                    }
11447                }
11448                _ => unreachable!(),
11449            }
11450        }
11451    }
11452    impl CstDecode<crate::model::ReceivePaymentRequest> for wire_cst_receive_payment_request {
11453        // Codec=Cst (C-struct based), see doc to use other codecs
11454        fn cst_decode(self) -> crate::model::ReceivePaymentRequest {
11455            crate::model::ReceivePaymentRequest {
11456                prepare_response: self.prepare_response.cst_decode(),
11457                description: self.description.cst_decode(),
11458                use_description_hash: self.use_description_hash.cst_decode(),
11459            }
11460        }
11461    }
11462    impl CstDecode<crate::model::ReceivePaymentResponse> for wire_cst_receive_payment_response {
11463        // Codec=Cst (C-struct based), see doc to use other codecs
11464        fn cst_decode(self) -> crate::model::ReceivePaymentResponse {
11465            crate::model::ReceivePaymentResponse {
11466                destination: self.destination.cst_decode(),
11467            }
11468        }
11469    }
11470    impl CstDecode<crate::model::RecommendedFees> for wire_cst_recommended_fees {
11471        // Codec=Cst (C-struct based), see doc to use other codecs
11472        fn cst_decode(self) -> crate::model::RecommendedFees {
11473            crate::model::RecommendedFees {
11474                fastest_fee: self.fastest_fee.cst_decode(),
11475                half_hour_fee: self.half_hour_fee.cst_decode(),
11476                hour_fee: self.hour_fee.cst_decode(),
11477                economy_fee: self.economy_fee.cst_decode(),
11478                minimum_fee: self.minimum_fee.cst_decode(),
11479            }
11480        }
11481    }
11482    impl CstDecode<crate::model::RefundRequest> for wire_cst_refund_request {
11483        // Codec=Cst (C-struct based), see doc to use other codecs
11484        fn cst_decode(self) -> crate::model::RefundRequest {
11485            crate::model::RefundRequest {
11486                swap_address: self.swap_address.cst_decode(),
11487                refund_address: self.refund_address.cst_decode(),
11488                fee_rate_sat_per_vbyte: self.fee_rate_sat_per_vbyte.cst_decode(),
11489            }
11490        }
11491    }
11492    impl CstDecode<crate::model::RefundResponse> for wire_cst_refund_response {
11493        // Codec=Cst (C-struct based), see doc to use other codecs
11494        fn cst_decode(self) -> crate::model::RefundResponse {
11495            crate::model::RefundResponse {
11496                refund_tx_id: self.refund_tx_id.cst_decode(),
11497            }
11498        }
11499    }
11500    impl CstDecode<crate::model::RefundableSwap> for wire_cst_refundable_swap {
11501        // Codec=Cst (C-struct based), see doc to use other codecs
11502        fn cst_decode(self) -> crate::model::RefundableSwap {
11503            crate::model::RefundableSwap {
11504                swap_address: self.swap_address.cst_decode(),
11505                timestamp: self.timestamp.cst_decode(),
11506                amount_sat: self.amount_sat.cst_decode(),
11507                last_refund_tx_id: self.last_refund_tx_id.cst_decode(),
11508            }
11509        }
11510    }
11511    impl CstDecode<crate::model::RestoreRequest> for wire_cst_restore_request {
11512        // Codec=Cst (C-struct based), see doc to use other codecs
11513        fn cst_decode(self) -> crate::model::RestoreRequest {
11514            crate::model::RestoreRequest {
11515                backup_path: self.backup_path.cst_decode(),
11516            }
11517        }
11518    }
11519    impl CstDecode<crate::bindings::RouteHint> for wire_cst_route_hint {
11520        // Codec=Cst (C-struct based), see doc to use other codecs
11521        fn cst_decode(self) -> crate::bindings::RouteHint {
11522            crate::bindings::RouteHint {
11523                hops: self.hops.cst_decode(),
11524            }
11525        }
11526    }
11527    impl CstDecode<crate::bindings::RouteHintHop> for wire_cst_route_hint_hop {
11528        // Codec=Cst (C-struct based), see doc to use other codecs
11529        fn cst_decode(self) -> crate::bindings::RouteHintHop {
11530            crate::bindings::RouteHintHop {
11531                src_node_id: self.src_node_id.cst_decode(),
11532                short_channel_id: self.short_channel_id.cst_decode(),
11533                fees_base_msat: self.fees_base_msat.cst_decode(),
11534                fees_proportional_millionths: self.fees_proportional_millionths.cst_decode(),
11535                cltv_expiry_delta: self.cltv_expiry_delta.cst_decode(),
11536                htlc_minimum_msat: self.htlc_minimum_msat.cst_decode(),
11537                htlc_maximum_msat: self.htlc_maximum_msat.cst_decode(),
11538            }
11539        }
11540    }
11541    impl CstDecode<crate::error::SdkError> for wire_cst_sdk_error {
11542        // Codec=Cst (C-struct based), see doc to use other codecs
11543        fn cst_decode(self) -> crate::error::SdkError {
11544            match self.tag {
11545                0 => crate::error::SdkError::AlreadyStarted,
11546                1 => {
11547                    let ans = unsafe { self.kind.Generic };
11548                    crate::error::SdkError::Generic {
11549                        err: ans.err.cst_decode(),
11550                    }
11551                }
11552                2 => crate::error::SdkError::NotStarted,
11553                3 => {
11554                    let ans = unsafe { self.kind.ServiceConnectivity };
11555                    crate::error::SdkError::ServiceConnectivity {
11556                        err: ans.err.cst_decode(),
11557                    }
11558                }
11559                _ => unreachable!(),
11560            }
11561        }
11562    }
11563    impl CstDecode<crate::model::SdkEvent> for wire_cst_sdk_event {
11564        // Codec=Cst (C-struct based), see doc to use other codecs
11565        fn cst_decode(self) -> crate::model::SdkEvent {
11566            match self.tag {
11567                0 => {
11568                    let ans = unsafe { self.kind.PaymentFailed };
11569                    crate::model::SdkEvent::PaymentFailed {
11570                        details: ans.details.cst_decode(),
11571                    }
11572                }
11573                1 => {
11574                    let ans = unsafe { self.kind.PaymentPending };
11575                    crate::model::SdkEvent::PaymentPending {
11576                        details: ans.details.cst_decode(),
11577                    }
11578                }
11579                2 => {
11580                    let ans = unsafe { self.kind.PaymentRefundable };
11581                    crate::model::SdkEvent::PaymentRefundable {
11582                        details: ans.details.cst_decode(),
11583                    }
11584                }
11585                3 => {
11586                    let ans = unsafe { self.kind.PaymentRefunded };
11587                    crate::model::SdkEvent::PaymentRefunded {
11588                        details: ans.details.cst_decode(),
11589                    }
11590                }
11591                4 => {
11592                    let ans = unsafe { self.kind.PaymentRefundPending };
11593                    crate::model::SdkEvent::PaymentRefundPending {
11594                        details: ans.details.cst_decode(),
11595                    }
11596                }
11597                5 => {
11598                    let ans = unsafe { self.kind.PaymentSucceeded };
11599                    crate::model::SdkEvent::PaymentSucceeded {
11600                        details: ans.details.cst_decode(),
11601                    }
11602                }
11603                6 => {
11604                    let ans = unsafe { self.kind.PaymentWaitingConfirmation };
11605                    crate::model::SdkEvent::PaymentWaitingConfirmation {
11606                        details: ans.details.cst_decode(),
11607                    }
11608                }
11609                7 => {
11610                    let ans = unsafe { self.kind.PaymentWaitingFeeAcceptance };
11611                    crate::model::SdkEvent::PaymentWaitingFeeAcceptance {
11612                        details: ans.details.cst_decode(),
11613                    }
11614                }
11615                8 => crate::model::SdkEvent::Synced,
11616                9 => {
11617                    let ans = unsafe { self.kind.DataSynced };
11618                    crate::model::SdkEvent::DataSynced {
11619                        did_pull_new_records: ans.did_pull_new_records.cst_decode(),
11620                    }
11621                }
11622                _ => unreachable!(),
11623            }
11624        }
11625    }
11626    impl CstDecode<crate::model::SendDestination> for wire_cst_send_destination {
11627        // Codec=Cst (C-struct based), see doc to use other codecs
11628        fn cst_decode(self) -> crate::model::SendDestination {
11629            match self.tag {
11630                0 => {
11631                    let ans = unsafe { self.kind.LiquidAddress };
11632                    crate::model::SendDestination::LiquidAddress {
11633                        address_data: ans.address_data.cst_decode(),
11634                        bip353_address: ans.bip353_address.cst_decode(),
11635                    }
11636                }
11637                1 => {
11638                    let ans = unsafe { self.kind.Bolt11 };
11639                    crate::model::SendDestination::Bolt11 {
11640                        invoice: ans.invoice.cst_decode(),
11641                        bip353_address: ans.bip353_address.cst_decode(),
11642                    }
11643                }
11644                2 => {
11645                    let ans = unsafe { self.kind.Bolt12 };
11646                    crate::model::SendDestination::Bolt12 {
11647                        offer: ans.offer.cst_decode(),
11648                        receiver_amount_sat: ans.receiver_amount_sat.cst_decode(),
11649                        bip353_address: ans.bip353_address.cst_decode(),
11650                    }
11651                }
11652                _ => unreachable!(),
11653            }
11654        }
11655    }
11656    impl CstDecode<crate::model::SendPaymentRequest> for wire_cst_send_payment_request {
11657        // Codec=Cst (C-struct based), see doc to use other codecs
11658        fn cst_decode(self) -> crate::model::SendPaymentRequest {
11659            crate::model::SendPaymentRequest {
11660                prepare_response: self.prepare_response.cst_decode(),
11661                use_asset_fees: self.use_asset_fees.cst_decode(),
11662            }
11663        }
11664    }
11665    impl CstDecode<crate::model::SendPaymentResponse> for wire_cst_send_payment_response {
11666        // Codec=Cst (C-struct based), see doc to use other codecs
11667        fn cst_decode(self) -> crate::model::SendPaymentResponse {
11668            crate::model::SendPaymentResponse {
11669                payment: self.payment.cst_decode(),
11670            }
11671        }
11672    }
11673    impl CstDecode<crate::model::SignMessageRequest> for wire_cst_sign_message_request {
11674        // Codec=Cst (C-struct based), see doc to use other codecs
11675        fn cst_decode(self) -> crate::model::SignMessageRequest {
11676            crate::model::SignMessageRequest {
11677                message: self.message.cst_decode(),
11678            }
11679        }
11680    }
11681    impl CstDecode<crate::model::SignMessageResponse> for wire_cst_sign_message_response {
11682        // Codec=Cst (C-struct based), see doc to use other codecs
11683        fn cst_decode(self) -> crate::model::SignMessageResponse {
11684            crate::model::SignMessageResponse {
11685                signature: self.signature.cst_decode(),
11686            }
11687        }
11688    }
11689    impl CstDecode<crate::bindings::SuccessAction> for wire_cst_success_action {
11690        // Codec=Cst (C-struct based), see doc to use other codecs
11691        fn cst_decode(self) -> crate::bindings::SuccessAction {
11692            match self.tag {
11693                0 => {
11694                    let ans = unsafe { self.kind.Aes };
11695                    crate::bindings::SuccessAction::Aes {
11696                        data: ans.data.cst_decode(),
11697                    }
11698                }
11699                1 => {
11700                    let ans = unsafe { self.kind.Message };
11701                    crate::bindings::SuccessAction::Message {
11702                        data: ans.data.cst_decode(),
11703                    }
11704                }
11705                2 => {
11706                    let ans = unsafe { self.kind.Url };
11707                    crate::bindings::SuccessAction::Url {
11708                        data: ans.data.cst_decode(),
11709                    }
11710                }
11711                _ => unreachable!(),
11712            }
11713        }
11714    }
11715    impl CstDecode<crate::bindings::SuccessActionProcessed> for wire_cst_success_action_processed {
11716        // Codec=Cst (C-struct based), see doc to use other codecs
11717        fn cst_decode(self) -> crate::bindings::SuccessActionProcessed {
11718            match self.tag {
11719                0 => {
11720                    let ans = unsafe { self.kind.Aes };
11721                    crate::bindings::SuccessActionProcessed::Aes {
11722                        result: ans.result.cst_decode(),
11723                    }
11724                }
11725                1 => {
11726                    let ans = unsafe { self.kind.Message };
11727                    crate::bindings::SuccessActionProcessed::Message {
11728                        data: ans.data.cst_decode(),
11729                    }
11730                }
11731                2 => {
11732                    let ans = unsafe { self.kind.Url };
11733                    crate::bindings::SuccessActionProcessed::Url {
11734                        data: ans.data.cst_decode(),
11735                    }
11736                }
11737                _ => unreachable!(),
11738            }
11739        }
11740    }
11741    impl CstDecode<crate::bindings::Symbol> for wire_cst_symbol {
11742        // Codec=Cst (C-struct based), see doc to use other codecs
11743        fn cst_decode(self) -> crate::bindings::Symbol {
11744            crate::bindings::Symbol {
11745                grapheme: self.grapheme.cst_decode(),
11746                template: self.template.cst_decode(),
11747                rtl: self.rtl.cst_decode(),
11748                position: self.position.cst_decode(),
11749            }
11750        }
11751    }
11752    impl CstDecode<crate::bindings::UrlSuccessActionData> for wire_cst_url_success_action_data {
11753        // Codec=Cst (C-struct based), see doc to use other codecs
11754        fn cst_decode(self) -> crate::bindings::UrlSuccessActionData {
11755            crate::bindings::UrlSuccessActionData {
11756                description: self.description.cst_decode(),
11757                url: self.url.cst_decode(),
11758                matches_callback_domain: self.matches_callback_domain.cst_decode(),
11759            }
11760        }
11761    }
11762    impl CstDecode<crate::model::WalletInfo> for wire_cst_wallet_info {
11763        // Codec=Cst (C-struct based), see doc to use other codecs
11764        fn cst_decode(self) -> crate::model::WalletInfo {
11765            crate::model::WalletInfo {
11766                balance_sat: self.balance_sat.cst_decode(),
11767                pending_send_sat: self.pending_send_sat.cst_decode(),
11768                pending_receive_sat: self.pending_receive_sat.cst_decode(),
11769                fingerprint: self.fingerprint.cst_decode(),
11770                pubkey: self.pubkey.cst_decode(),
11771                asset_balances: self.asset_balances.cst_decode(),
11772            }
11773        }
11774    }
11775    impl NewWithNullPtr for wire_cst_accept_payment_proposed_fees_request {
11776        fn new_with_null_ptr() -> Self {
11777            Self {
11778                response: Default::default(),
11779            }
11780        }
11781    }
11782    impl Default for wire_cst_accept_payment_proposed_fees_request {
11783        fn default() -> Self {
11784            Self::new_with_null_ptr()
11785        }
11786    }
11787    impl NewWithNullPtr for wire_cst_aes_success_action_data {
11788        fn new_with_null_ptr() -> Self {
11789            Self {
11790                description: core::ptr::null_mut(),
11791                ciphertext: core::ptr::null_mut(),
11792                iv: core::ptr::null_mut(),
11793            }
11794        }
11795    }
11796    impl Default for wire_cst_aes_success_action_data {
11797        fn default() -> Self {
11798            Self::new_with_null_ptr()
11799        }
11800    }
11801    impl NewWithNullPtr for wire_cst_aes_success_action_data_decrypted {
11802        fn new_with_null_ptr() -> Self {
11803            Self {
11804                description: core::ptr::null_mut(),
11805                plaintext: core::ptr::null_mut(),
11806            }
11807        }
11808    }
11809    impl Default for wire_cst_aes_success_action_data_decrypted {
11810        fn default() -> Self {
11811            Self::new_with_null_ptr()
11812        }
11813    }
11814    impl NewWithNullPtr for wire_cst_aes_success_action_data_result {
11815        fn new_with_null_ptr() -> Self {
11816            Self {
11817                tag: -1,
11818                kind: AesSuccessActionDataResultKind { nil__: () },
11819            }
11820        }
11821    }
11822    impl Default for wire_cst_aes_success_action_data_result {
11823        fn default() -> Self {
11824            Self::new_with_null_ptr()
11825        }
11826    }
11827    impl NewWithNullPtr for wire_cst_amount {
11828        fn new_with_null_ptr() -> Self {
11829            Self {
11830                tag: -1,
11831                kind: AmountKind { nil__: () },
11832            }
11833        }
11834    }
11835    impl Default for wire_cst_amount {
11836        fn default() -> Self {
11837            Self::new_with_null_ptr()
11838        }
11839    }
11840    impl NewWithNullPtr for wire_cst_asset_balance {
11841        fn new_with_null_ptr() -> Self {
11842            Self {
11843                asset_id: core::ptr::null_mut(),
11844                balance_sat: Default::default(),
11845                name: core::ptr::null_mut(),
11846                ticker: core::ptr::null_mut(),
11847                balance: core::ptr::null_mut(),
11848            }
11849        }
11850    }
11851    impl Default for wire_cst_asset_balance {
11852        fn default() -> Self {
11853            Self::new_with_null_ptr()
11854        }
11855    }
11856    impl NewWithNullPtr for wire_cst_asset_info {
11857        fn new_with_null_ptr() -> Self {
11858            Self {
11859                name: core::ptr::null_mut(),
11860                ticker: core::ptr::null_mut(),
11861                amount: Default::default(),
11862                fees: core::ptr::null_mut(),
11863            }
11864        }
11865    }
11866    impl Default for wire_cst_asset_info {
11867        fn default() -> Self {
11868            Self::new_with_null_ptr()
11869        }
11870    }
11871    impl NewWithNullPtr for wire_cst_asset_metadata {
11872        fn new_with_null_ptr() -> Self {
11873            Self {
11874                asset_id: core::ptr::null_mut(),
11875                name: core::ptr::null_mut(),
11876                ticker: core::ptr::null_mut(),
11877                precision: Default::default(),
11878                fiat_id: core::ptr::null_mut(),
11879            }
11880        }
11881    }
11882    impl Default for wire_cst_asset_metadata {
11883        fn default() -> Self {
11884            Self::new_with_null_ptr()
11885        }
11886    }
11887    impl NewWithNullPtr for wire_cst_backup_request {
11888        fn new_with_null_ptr() -> Self {
11889            Self {
11890                backup_path: core::ptr::null_mut(),
11891            }
11892        }
11893    }
11894    impl Default for wire_cst_backup_request {
11895        fn default() -> Self {
11896            Self::new_with_null_ptr()
11897        }
11898    }
11899    impl NewWithNullPtr for wire_cst_binding_event_listener {
11900        fn new_with_null_ptr() -> Self {
11901            Self {
11902                stream: core::ptr::null_mut(),
11903            }
11904        }
11905    }
11906    impl Default for wire_cst_binding_event_listener {
11907        fn default() -> Self {
11908            Self::new_with_null_ptr()
11909        }
11910    }
11911    impl NewWithNullPtr for wire_cst_bitcoin_address_data {
11912        fn new_with_null_ptr() -> Self {
11913            Self {
11914                address: core::ptr::null_mut(),
11915                network: Default::default(),
11916                amount_sat: core::ptr::null_mut(),
11917                label: core::ptr::null_mut(),
11918                message: core::ptr::null_mut(),
11919            }
11920        }
11921    }
11922    impl Default for wire_cst_bitcoin_address_data {
11923        fn default() -> Self {
11924            Self::new_with_null_ptr()
11925        }
11926    }
11927    impl NewWithNullPtr for wire_cst_blockchain_explorer {
11928        fn new_with_null_ptr() -> Self {
11929            Self {
11930                tag: -1,
11931                kind: BlockchainExplorerKind { nil__: () },
11932            }
11933        }
11934    }
11935    impl Default for wire_cst_blockchain_explorer {
11936        fn default() -> Self {
11937            Self::new_with_null_ptr()
11938        }
11939    }
11940    impl NewWithNullPtr for wire_cst_blockchain_info {
11941        fn new_with_null_ptr() -> Self {
11942            Self {
11943                liquid_tip: Default::default(),
11944                bitcoin_tip: Default::default(),
11945            }
11946        }
11947    }
11948    impl Default for wire_cst_blockchain_info {
11949        fn default() -> Self {
11950            Self::new_with_null_ptr()
11951        }
11952    }
11953    impl NewWithNullPtr for wire_cst_buy_bitcoin_request {
11954        fn new_with_null_ptr() -> Self {
11955            Self {
11956                prepare_response: Default::default(),
11957                redirect_url: core::ptr::null_mut(),
11958            }
11959        }
11960    }
11961    impl Default for wire_cst_buy_bitcoin_request {
11962        fn default() -> Self {
11963            Self::new_with_null_ptr()
11964        }
11965    }
11966    impl NewWithNullPtr for wire_cst_check_message_request {
11967        fn new_with_null_ptr() -> Self {
11968            Self {
11969                message: core::ptr::null_mut(),
11970                pubkey: core::ptr::null_mut(),
11971                signature: core::ptr::null_mut(),
11972            }
11973        }
11974    }
11975    impl Default for wire_cst_check_message_request {
11976        fn default() -> Self {
11977            Self::new_with_null_ptr()
11978        }
11979    }
11980    impl NewWithNullPtr for wire_cst_check_message_response {
11981        fn new_with_null_ptr() -> Self {
11982            Self {
11983                is_valid: Default::default(),
11984            }
11985        }
11986    }
11987    impl Default for wire_cst_check_message_response {
11988        fn default() -> Self {
11989            Self::new_with_null_ptr()
11990        }
11991    }
11992    impl NewWithNullPtr for wire_cst_config {
11993        fn new_with_null_ptr() -> Self {
11994            Self {
11995                liquid_explorer: Default::default(),
11996                bitcoin_explorer: Default::default(),
11997                working_dir: core::ptr::null_mut(),
11998                cache_dir: core::ptr::null_mut(),
11999                network: Default::default(),
12000                payment_timeout_sec: Default::default(),
12001                sync_service_url: core::ptr::null_mut(),
12002                zero_conf_max_amount_sat: core::ptr::null_mut(),
12003                breez_api_key: core::ptr::null_mut(),
12004                external_input_parsers: core::ptr::null_mut(),
12005                use_default_external_input_parsers: Default::default(),
12006                onchain_fee_rate_leeway_sat_per_vbyte: core::ptr::null_mut(),
12007                asset_metadata: core::ptr::null_mut(),
12008                sideswap_api_key: core::ptr::null_mut(),
12009            }
12010        }
12011    }
12012    impl Default for wire_cst_config {
12013        fn default() -> Self {
12014            Self::new_with_null_ptr()
12015        }
12016    }
12017    impl NewWithNullPtr for wire_cst_connect_request {
12018        fn new_with_null_ptr() -> Self {
12019            Self {
12020                config: Default::default(),
12021                mnemonic: core::ptr::null_mut(),
12022                passphrase: core::ptr::null_mut(),
12023                seed: core::ptr::null_mut(),
12024            }
12025        }
12026    }
12027    impl Default for wire_cst_connect_request {
12028        fn default() -> Self {
12029            Self::new_with_null_ptr()
12030        }
12031    }
12032    impl NewWithNullPtr for wire_cst_create_bolt_12_invoice_request {
12033        fn new_with_null_ptr() -> Self {
12034            Self {
12035                offer: core::ptr::null_mut(),
12036                invoice_request: core::ptr::null_mut(),
12037            }
12038        }
12039    }
12040    impl Default for wire_cst_create_bolt_12_invoice_request {
12041        fn default() -> Self {
12042            Self::new_with_null_ptr()
12043        }
12044    }
12045    impl NewWithNullPtr for wire_cst_create_bolt_12_invoice_response {
12046        fn new_with_null_ptr() -> Self {
12047            Self {
12048                invoice: core::ptr::null_mut(),
12049            }
12050        }
12051    }
12052    impl Default for wire_cst_create_bolt_12_invoice_response {
12053        fn default() -> Self {
12054            Self::new_with_null_ptr()
12055        }
12056    }
12057    impl NewWithNullPtr for wire_cst_currency_info {
12058        fn new_with_null_ptr() -> Self {
12059            Self {
12060                name: core::ptr::null_mut(),
12061                fraction_size: Default::default(),
12062                spacing: core::ptr::null_mut(),
12063                symbol: core::ptr::null_mut(),
12064                uniq_symbol: core::ptr::null_mut(),
12065                localized_name: core::ptr::null_mut(),
12066                locale_overrides: core::ptr::null_mut(),
12067            }
12068        }
12069    }
12070    impl Default for wire_cst_currency_info {
12071        fn default() -> Self {
12072            Self::new_with_null_ptr()
12073        }
12074    }
12075    impl NewWithNullPtr for wire_cst_external_input_parser {
12076        fn new_with_null_ptr() -> Self {
12077            Self {
12078                provider_id: core::ptr::null_mut(),
12079                input_regex: core::ptr::null_mut(),
12080                parser_url: core::ptr::null_mut(),
12081            }
12082        }
12083    }
12084    impl Default for wire_cst_external_input_parser {
12085        fn default() -> Self {
12086            Self::new_with_null_ptr()
12087        }
12088    }
12089    impl NewWithNullPtr for wire_cst_fetch_payment_proposed_fees_request {
12090        fn new_with_null_ptr() -> Self {
12091            Self {
12092                swap_id: core::ptr::null_mut(),
12093            }
12094        }
12095    }
12096    impl Default for wire_cst_fetch_payment_proposed_fees_request {
12097        fn default() -> Self {
12098            Self::new_with_null_ptr()
12099        }
12100    }
12101    impl NewWithNullPtr for wire_cst_fetch_payment_proposed_fees_response {
12102        fn new_with_null_ptr() -> Self {
12103            Self {
12104                swap_id: core::ptr::null_mut(),
12105                fees_sat: Default::default(),
12106                payer_amount_sat: Default::default(),
12107                receiver_amount_sat: Default::default(),
12108            }
12109        }
12110    }
12111    impl Default for wire_cst_fetch_payment_proposed_fees_response {
12112        fn default() -> Self {
12113            Self::new_with_null_ptr()
12114        }
12115    }
12116    impl NewWithNullPtr for wire_cst_fiat_currency {
12117        fn new_with_null_ptr() -> Self {
12118            Self {
12119                id: core::ptr::null_mut(),
12120                info: Default::default(),
12121            }
12122        }
12123    }
12124    impl Default for wire_cst_fiat_currency {
12125        fn default() -> Self {
12126            Self::new_with_null_ptr()
12127        }
12128    }
12129    impl NewWithNullPtr for wire_cst_get_info_response {
12130        fn new_with_null_ptr() -> Self {
12131            Self {
12132                wallet_info: Default::default(),
12133                blockchain_info: Default::default(),
12134            }
12135        }
12136    }
12137    impl Default for wire_cst_get_info_response {
12138        fn default() -> Self {
12139            Self::new_with_null_ptr()
12140        }
12141    }
12142    impl NewWithNullPtr for wire_cst_get_payment_request {
12143        fn new_with_null_ptr() -> Self {
12144            Self {
12145                tag: -1,
12146                kind: GetPaymentRequestKind { nil__: () },
12147            }
12148        }
12149    }
12150    impl Default for wire_cst_get_payment_request {
12151        fn default() -> Self {
12152            Self::new_with_null_ptr()
12153        }
12154    }
12155    impl NewWithNullPtr for wire_cst_input_type {
12156        fn new_with_null_ptr() -> Self {
12157            Self {
12158                tag: -1,
12159                kind: InputTypeKind { nil__: () },
12160            }
12161        }
12162    }
12163    impl Default for wire_cst_input_type {
12164        fn default() -> Self {
12165            Self::new_with_null_ptr()
12166        }
12167    }
12168    impl NewWithNullPtr for wire_cst_lightning_payment_limits_response {
12169        fn new_with_null_ptr() -> Self {
12170            Self {
12171                send: Default::default(),
12172                receive: Default::default(),
12173            }
12174        }
12175    }
12176    impl Default for wire_cst_lightning_payment_limits_response {
12177        fn default() -> Self {
12178            Self::new_with_null_ptr()
12179        }
12180    }
12181    impl NewWithNullPtr for wire_cst_limits {
12182        fn new_with_null_ptr() -> Self {
12183            Self {
12184                min_sat: Default::default(),
12185                max_sat: Default::default(),
12186                max_zero_conf_sat: Default::default(),
12187            }
12188        }
12189    }
12190    impl Default for wire_cst_limits {
12191        fn default() -> Self {
12192            Self::new_with_null_ptr()
12193        }
12194    }
12195    impl NewWithNullPtr for wire_cst_liquid_address_data {
12196        fn new_with_null_ptr() -> Self {
12197            Self {
12198                address: core::ptr::null_mut(),
12199                network: Default::default(),
12200                asset_id: core::ptr::null_mut(),
12201                amount: core::ptr::null_mut(),
12202                amount_sat: core::ptr::null_mut(),
12203                label: core::ptr::null_mut(),
12204                message: core::ptr::null_mut(),
12205            }
12206        }
12207    }
12208    impl Default for wire_cst_liquid_address_data {
12209        fn default() -> Self {
12210            Self::new_with_null_ptr()
12211        }
12212    }
12213    impl NewWithNullPtr for wire_cst_list_payment_details {
12214        fn new_with_null_ptr() -> Self {
12215            Self {
12216                tag: -1,
12217                kind: ListPaymentDetailsKind { nil__: () },
12218            }
12219        }
12220    }
12221    impl Default for wire_cst_list_payment_details {
12222        fn default() -> Self {
12223            Self::new_with_null_ptr()
12224        }
12225    }
12226    impl NewWithNullPtr for wire_cst_list_payments_request {
12227        fn new_with_null_ptr() -> Self {
12228            Self {
12229                filters: core::ptr::null_mut(),
12230                states: core::ptr::null_mut(),
12231                from_timestamp: core::ptr::null_mut(),
12232                to_timestamp: core::ptr::null_mut(),
12233                offset: core::ptr::null_mut(),
12234                limit: core::ptr::null_mut(),
12235                details: core::ptr::null_mut(),
12236                sort_ascending: core::ptr::null_mut(),
12237            }
12238        }
12239    }
12240    impl Default for wire_cst_list_payments_request {
12241        fn default() -> Self {
12242            Self::new_with_null_ptr()
12243        }
12244    }
12245    impl NewWithNullPtr for wire_cst_ln_invoice {
12246        fn new_with_null_ptr() -> Self {
12247            Self {
12248                bolt11: core::ptr::null_mut(),
12249                network: Default::default(),
12250                payee_pubkey: core::ptr::null_mut(),
12251                payment_hash: core::ptr::null_mut(),
12252                description: core::ptr::null_mut(),
12253                description_hash: core::ptr::null_mut(),
12254                amount_msat: core::ptr::null_mut(),
12255                timestamp: Default::default(),
12256                expiry: Default::default(),
12257                routing_hints: core::ptr::null_mut(),
12258                payment_secret: core::ptr::null_mut(),
12259                min_final_cltv_expiry_delta: Default::default(),
12260            }
12261        }
12262    }
12263    impl Default for wire_cst_ln_invoice {
12264        fn default() -> Self {
12265            Self::new_with_null_ptr()
12266        }
12267    }
12268    impl NewWithNullPtr for wire_cst_ln_offer {
12269        fn new_with_null_ptr() -> Self {
12270            Self {
12271                offer: core::ptr::null_mut(),
12272                chains: core::ptr::null_mut(),
12273                min_amount: core::ptr::null_mut(),
12274                description: core::ptr::null_mut(),
12275                absolute_expiry: core::ptr::null_mut(),
12276                issuer: core::ptr::null_mut(),
12277                signing_pubkey: core::ptr::null_mut(),
12278                paths: core::ptr::null_mut(),
12279            }
12280        }
12281    }
12282    impl Default for wire_cst_ln_offer {
12283        fn default() -> Self {
12284            Self::new_with_null_ptr()
12285        }
12286    }
12287    impl NewWithNullPtr for wire_cst_ln_offer_blinded_path {
12288        fn new_with_null_ptr() -> Self {
12289            Self {
12290                blinded_hops: core::ptr::null_mut(),
12291            }
12292        }
12293    }
12294    impl Default for wire_cst_ln_offer_blinded_path {
12295        fn default() -> Self {
12296            Self::new_with_null_ptr()
12297        }
12298    }
12299    impl NewWithNullPtr for wire_cst_ln_url_auth_error {
12300        fn new_with_null_ptr() -> Self {
12301            Self {
12302                tag: -1,
12303                kind: LnUrlAuthErrorKind { nil__: () },
12304            }
12305        }
12306    }
12307    impl Default for wire_cst_ln_url_auth_error {
12308        fn default() -> Self {
12309            Self::new_with_null_ptr()
12310        }
12311    }
12312    impl NewWithNullPtr for wire_cst_ln_url_auth_request_data {
12313        fn new_with_null_ptr() -> Self {
12314            Self {
12315                k1: core::ptr::null_mut(),
12316                action: core::ptr::null_mut(),
12317                domain: core::ptr::null_mut(),
12318                url: core::ptr::null_mut(),
12319            }
12320        }
12321    }
12322    impl Default for wire_cst_ln_url_auth_request_data {
12323        fn default() -> Self {
12324            Self::new_with_null_ptr()
12325        }
12326    }
12327    impl NewWithNullPtr for wire_cst_ln_url_callback_status {
12328        fn new_with_null_ptr() -> Self {
12329            Self {
12330                tag: -1,
12331                kind: LnUrlCallbackStatusKind { nil__: () },
12332            }
12333        }
12334    }
12335    impl Default for wire_cst_ln_url_callback_status {
12336        fn default() -> Self {
12337            Self::new_with_null_ptr()
12338        }
12339    }
12340    impl NewWithNullPtr for wire_cst_ln_url_error_data {
12341        fn new_with_null_ptr() -> Self {
12342            Self {
12343                reason: core::ptr::null_mut(),
12344            }
12345        }
12346    }
12347    impl Default for wire_cst_ln_url_error_data {
12348        fn default() -> Self {
12349            Self::new_with_null_ptr()
12350        }
12351    }
12352    impl NewWithNullPtr for wire_cst_ln_url_info {
12353        fn new_with_null_ptr() -> Self {
12354            Self {
12355                ln_address: core::ptr::null_mut(),
12356                lnurl_pay_comment: core::ptr::null_mut(),
12357                lnurl_pay_domain: core::ptr::null_mut(),
12358                lnurl_pay_metadata: core::ptr::null_mut(),
12359                lnurl_pay_success_action: core::ptr::null_mut(),
12360                lnurl_pay_unprocessed_success_action: core::ptr::null_mut(),
12361                lnurl_withdraw_endpoint: core::ptr::null_mut(),
12362            }
12363        }
12364    }
12365    impl Default for wire_cst_ln_url_info {
12366        fn default() -> Self {
12367            Self::new_with_null_ptr()
12368        }
12369    }
12370    impl NewWithNullPtr for wire_cst_ln_url_pay_error {
12371        fn new_with_null_ptr() -> Self {
12372            Self {
12373                tag: -1,
12374                kind: LnUrlPayErrorKind { nil__: () },
12375            }
12376        }
12377    }
12378    impl Default for wire_cst_ln_url_pay_error {
12379        fn default() -> Self {
12380            Self::new_with_null_ptr()
12381        }
12382    }
12383    impl NewWithNullPtr for wire_cst_ln_url_pay_error_data {
12384        fn new_with_null_ptr() -> Self {
12385            Self {
12386                payment_hash: core::ptr::null_mut(),
12387                reason: core::ptr::null_mut(),
12388            }
12389        }
12390    }
12391    impl Default for wire_cst_ln_url_pay_error_data {
12392        fn default() -> Self {
12393            Self::new_with_null_ptr()
12394        }
12395    }
12396    impl NewWithNullPtr for wire_cst_ln_url_pay_request {
12397        fn new_with_null_ptr() -> Self {
12398            Self {
12399                prepare_response: Default::default(),
12400            }
12401        }
12402    }
12403    impl Default for wire_cst_ln_url_pay_request {
12404        fn default() -> Self {
12405            Self::new_with_null_ptr()
12406        }
12407    }
12408    impl NewWithNullPtr for wire_cst_ln_url_pay_request_data {
12409        fn new_with_null_ptr() -> Self {
12410            Self {
12411                callback: core::ptr::null_mut(),
12412                min_sendable: Default::default(),
12413                max_sendable: Default::default(),
12414                metadata_str: core::ptr::null_mut(),
12415                comment_allowed: Default::default(),
12416                domain: core::ptr::null_mut(),
12417                allows_nostr: Default::default(),
12418                nostr_pubkey: core::ptr::null_mut(),
12419                ln_address: core::ptr::null_mut(),
12420            }
12421        }
12422    }
12423    impl Default for wire_cst_ln_url_pay_request_data {
12424        fn default() -> Self {
12425            Self::new_with_null_ptr()
12426        }
12427    }
12428    impl NewWithNullPtr for wire_cst_ln_url_pay_result {
12429        fn new_with_null_ptr() -> Self {
12430            Self {
12431                tag: -1,
12432                kind: LnUrlPayResultKind { nil__: () },
12433            }
12434        }
12435    }
12436    impl Default for wire_cst_ln_url_pay_result {
12437        fn default() -> Self {
12438            Self::new_with_null_ptr()
12439        }
12440    }
12441    impl NewWithNullPtr for wire_cst_ln_url_pay_success_data {
12442        fn new_with_null_ptr() -> Self {
12443            Self {
12444                payment: Default::default(),
12445                success_action: core::ptr::null_mut(),
12446            }
12447        }
12448    }
12449    impl Default for wire_cst_ln_url_pay_success_data {
12450        fn default() -> Self {
12451            Self::new_with_null_ptr()
12452        }
12453    }
12454    impl NewWithNullPtr for wire_cst_ln_url_withdraw_error {
12455        fn new_with_null_ptr() -> Self {
12456            Self {
12457                tag: -1,
12458                kind: LnUrlWithdrawErrorKind { nil__: () },
12459            }
12460        }
12461    }
12462    impl Default for wire_cst_ln_url_withdraw_error {
12463        fn default() -> Self {
12464            Self::new_with_null_ptr()
12465        }
12466    }
12467    impl NewWithNullPtr for wire_cst_ln_url_withdraw_request {
12468        fn new_with_null_ptr() -> Self {
12469            Self {
12470                data: Default::default(),
12471                amount_msat: Default::default(),
12472                description: core::ptr::null_mut(),
12473            }
12474        }
12475    }
12476    impl Default for wire_cst_ln_url_withdraw_request {
12477        fn default() -> Self {
12478            Self::new_with_null_ptr()
12479        }
12480    }
12481    impl NewWithNullPtr for wire_cst_ln_url_withdraw_request_data {
12482        fn new_with_null_ptr() -> Self {
12483            Self {
12484                callback: core::ptr::null_mut(),
12485                k1: core::ptr::null_mut(),
12486                default_description: core::ptr::null_mut(),
12487                min_withdrawable: Default::default(),
12488                max_withdrawable: Default::default(),
12489            }
12490        }
12491    }
12492    impl Default for wire_cst_ln_url_withdraw_request_data {
12493        fn default() -> Self {
12494            Self::new_with_null_ptr()
12495        }
12496    }
12497    impl NewWithNullPtr for wire_cst_ln_url_withdraw_result {
12498        fn new_with_null_ptr() -> Self {
12499            Self {
12500                tag: -1,
12501                kind: LnUrlWithdrawResultKind { nil__: () },
12502            }
12503        }
12504    }
12505    impl Default for wire_cst_ln_url_withdraw_result {
12506        fn default() -> Self {
12507            Self::new_with_null_ptr()
12508        }
12509    }
12510    impl NewWithNullPtr for wire_cst_ln_url_withdraw_success_data {
12511        fn new_with_null_ptr() -> Self {
12512            Self {
12513                invoice: Default::default(),
12514            }
12515        }
12516    }
12517    impl Default for wire_cst_ln_url_withdraw_success_data {
12518        fn default() -> Self {
12519            Self::new_with_null_ptr()
12520        }
12521    }
12522    impl NewWithNullPtr for wire_cst_locale_overrides {
12523        fn new_with_null_ptr() -> Self {
12524            Self {
12525                locale: core::ptr::null_mut(),
12526                spacing: core::ptr::null_mut(),
12527                symbol: Default::default(),
12528            }
12529        }
12530    }
12531    impl Default for wire_cst_locale_overrides {
12532        fn default() -> Self {
12533            Self::new_with_null_ptr()
12534        }
12535    }
12536    impl NewWithNullPtr for wire_cst_localized_name {
12537        fn new_with_null_ptr() -> Self {
12538            Self {
12539                locale: core::ptr::null_mut(),
12540                name: core::ptr::null_mut(),
12541            }
12542        }
12543    }
12544    impl Default for wire_cst_localized_name {
12545        fn default() -> Self {
12546            Self::new_with_null_ptr()
12547        }
12548    }
12549    impl NewWithNullPtr for wire_cst_log_entry {
12550        fn new_with_null_ptr() -> Self {
12551            Self {
12552                line: core::ptr::null_mut(),
12553                level: core::ptr::null_mut(),
12554            }
12555        }
12556    }
12557    impl Default for wire_cst_log_entry {
12558        fn default() -> Self {
12559            Self::new_with_null_ptr()
12560        }
12561    }
12562    impl NewWithNullPtr for wire_cst_message_success_action_data {
12563        fn new_with_null_ptr() -> Self {
12564            Self {
12565                message: core::ptr::null_mut(),
12566            }
12567        }
12568    }
12569    impl Default for wire_cst_message_success_action_data {
12570        fn default() -> Self {
12571            Self::new_with_null_ptr()
12572        }
12573    }
12574    impl NewWithNullPtr for wire_cst_onchain_payment_limits_response {
12575        fn new_with_null_ptr() -> Self {
12576            Self {
12577                send: Default::default(),
12578                receive: Default::default(),
12579            }
12580        }
12581    }
12582    impl Default for wire_cst_onchain_payment_limits_response {
12583        fn default() -> Self {
12584            Self::new_with_null_ptr()
12585        }
12586    }
12587    impl NewWithNullPtr for wire_cst_pay_amount {
12588        fn new_with_null_ptr() -> Self {
12589            Self {
12590                tag: -1,
12591                kind: PayAmountKind { nil__: () },
12592            }
12593        }
12594    }
12595    impl Default for wire_cst_pay_amount {
12596        fn default() -> Self {
12597            Self::new_with_null_ptr()
12598        }
12599    }
12600    impl NewWithNullPtr for wire_cst_pay_onchain_request {
12601        fn new_with_null_ptr() -> Self {
12602            Self {
12603                address: core::ptr::null_mut(),
12604                prepare_response: Default::default(),
12605            }
12606        }
12607    }
12608    impl Default for wire_cst_pay_onchain_request {
12609        fn default() -> Self {
12610            Self::new_with_null_ptr()
12611        }
12612    }
12613    impl NewWithNullPtr for wire_cst_payment {
12614        fn new_with_null_ptr() -> Self {
12615            Self {
12616                destination: core::ptr::null_mut(),
12617                tx_id: core::ptr::null_mut(),
12618                unblinding_data: core::ptr::null_mut(),
12619                timestamp: Default::default(),
12620                amount_sat: Default::default(),
12621                fees_sat: Default::default(),
12622                swapper_fees_sat: core::ptr::null_mut(),
12623                payment_type: Default::default(),
12624                status: Default::default(),
12625                details: Default::default(),
12626            }
12627        }
12628    }
12629    impl Default for wire_cst_payment {
12630        fn default() -> Self {
12631            Self::new_with_null_ptr()
12632        }
12633    }
12634    impl NewWithNullPtr for wire_cst_payment_details {
12635        fn new_with_null_ptr() -> Self {
12636            Self {
12637                tag: -1,
12638                kind: PaymentDetailsKind { nil__: () },
12639            }
12640        }
12641    }
12642    impl Default for wire_cst_payment_details {
12643        fn default() -> Self {
12644            Self::new_with_null_ptr()
12645        }
12646    }
12647    impl NewWithNullPtr for wire_cst_payment_error {
12648        fn new_with_null_ptr() -> Self {
12649            Self {
12650                tag: -1,
12651                kind: PaymentErrorKind { nil__: () },
12652            }
12653        }
12654    }
12655    impl Default for wire_cst_payment_error {
12656        fn default() -> Self {
12657            Self::new_with_null_ptr()
12658        }
12659    }
12660    impl NewWithNullPtr for wire_cst_prepare_buy_bitcoin_request {
12661        fn new_with_null_ptr() -> Self {
12662            Self {
12663                provider: Default::default(),
12664                amount_sat: Default::default(),
12665            }
12666        }
12667    }
12668    impl Default for wire_cst_prepare_buy_bitcoin_request {
12669        fn default() -> Self {
12670            Self::new_with_null_ptr()
12671        }
12672    }
12673    impl NewWithNullPtr for wire_cst_prepare_buy_bitcoin_response {
12674        fn new_with_null_ptr() -> Self {
12675            Self {
12676                provider: Default::default(),
12677                amount_sat: Default::default(),
12678                fees_sat: Default::default(),
12679            }
12680        }
12681    }
12682    impl Default for wire_cst_prepare_buy_bitcoin_response {
12683        fn default() -> Self {
12684            Self::new_with_null_ptr()
12685        }
12686    }
12687    impl NewWithNullPtr for wire_cst_prepare_ln_url_pay_request {
12688        fn new_with_null_ptr() -> Self {
12689            Self {
12690                data: Default::default(),
12691                amount: Default::default(),
12692                bip353_address: core::ptr::null_mut(),
12693                comment: core::ptr::null_mut(),
12694                validate_success_action_url: core::ptr::null_mut(),
12695            }
12696        }
12697    }
12698    impl Default for wire_cst_prepare_ln_url_pay_request {
12699        fn default() -> Self {
12700            Self::new_with_null_ptr()
12701        }
12702    }
12703    impl NewWithNullPtr for wire_cst_prepare_ln_url_pay_response {
12704        fn new_with_null_ptr() -> Self {
12705            Self {
12706                destination: Default::default(),
12707                fees_sat: Default::default(),
12708                data: Default::default(),
12709                amount: Default::default(),
12710                comment: core::ptr::null_mut(),
12711                success_action: core::ptr::null_mut(),
12712            }
12713        }
12714    }
12715    impl Default for wire_cst_prepare_ln_url_pay_response {
12716        fn default() -> Self {
12717            Self::new_with_null_ptr()
12718        }
12719    }
12720    impl NewWithNullPtr for wire_cst_prepare_pay_onchain_request {
12721        fn new_with_null_ptr() -> Self {
12722            Self {
12723                amount: Default::default(),
12724                fee_rate_sat_per_vbyte: core::ptr::null_mut(),
12725            }
12726        }
12727    }
12728    impl Default for wire_cst_prepare_pay_onchain_request {
12729        fn default() -> Self {
12730            Self::new_with_null_ptr()
12731        }
12732    }
12733    impl NewWithNullPtr for wire_cst_prepare_pay_onchain_response {
12734        fn new_with_null_ptr() -> Self {
12735            Self {
12736                receiver_amount_sat: Default::default(),
12737                claim_fees_sat: Default::default(),
12738                total_fees_sat: Default::default(),
12739            }
12740        }
12741    }
12742    impl Default for wire_cst_prepare_pay_onchain_response {
12743        fn default() -> Self {
12744            Self::new_with_null_ptr()
12745        }
12746    }
12747    impl NewWithNullPtr for wire_cst_prepare_receive_request {
12748        fn new_with_null_ptr() -> Self {
12749            Self {
12750                payment_method: Default::default(),
12751                amount: core::ptr::null_mut(),
12752            }
12753        }
12754    }
12755    impl Default for wire_cst_prepare_receive_request {
12756        fn default() -> Self {
12757            Self::new_with_null_ptr()
12758        }
12759    }
12760    impl NewWithNullPtr for wire_cst_prepare_receive_response {
12761        fn new_with_null_ptr() -> Self {
12762            Self {
12763                payment_method: Default::default(),
12764                fees_sat: Default::default(),
12765                amount: core::ptr::null_mut(),
12766                min_payer_amount_sat: core::ptr::null_mut(),
12767                max_payer_amount_sat: core::ptr::null_mut(),
12768                swapper_feerate: core::ptr::null_mut(),
12769            }
12770        }
12771    }
12772    impl Default for wire_cst_prepare_receive_response {
12773        fn default() -> Self {
12774            Self::new_with_null_ptr()
12775        }
12776    }
12777    impl NewWithNullPtr for wire_cst_prepare_refund_request {
12778        fn new_with_null_ptr() -> Self {
12779            Self {
12780                swap_address: core::ptr::null_mut(),
12781                refund_address: core::ptr::null_mut(),
12782                fee_rate_sat_per_vbyte: Default::default(),
12783            }
12784        }
12785    }
12786    impl Default for wire_cst_prepare_refund_request {
12787        fn default() -> Self {
12788            Self::new_with_null_ptr()
12789        }
12790    }
12791    impl NewWithNullPtr for wire_cst_prepare_refund_response {
12792        fn new_with_null_ptr() -> Self {
12793            Self {
12794                tx_vsize: Default::default(),
12795                tx_fee_sat: Default::default(),
12796                last_refund_tx_id: core::ptr::null_mut(),
12797            }
12798        }
12799    }
12800    impl Default for wire_cst_prepare_refund_response {
12801        fn default() -> Self {
12802            Self::new_with_null_ptr()
12803        }
12804    }
12805    impl NewWithNullPtr for wire_cst_prepare_send_request {
12806        fn new_with_null_ptr() -> Self {
12807            Self {
12808                destination: core::ptr::null_mut(),
12809                amount: core::ptr::null_mut(),
12810            }
12811        }
12812    }
12813    impl Default for wire_cst_prepare_send_request {
12814        fn default() -> Self {
12815            Self::new_with_null_ptr()
12816        }
12817    }
12818    impl NewWithNullPtr for wire_cst_prepare_send_response {
12819        fn new_with_null_ptr() -> Self {
12820            Self {
12821                destination: Default::default(),
12822                amount: core::ptr::null_mut(),
12823                fees_sat: core::ptr::null_mut(),
12824                estimated_asset_fees: core::ptr::null_mut(),
12825            }
12826        }
12827    }
12828    impl Default for wire_cst_prepare_send_response {
12829        fn default() -> Self {
12830            Self::new_with_null_ptr()
12831        }
12832    }
12833    impl NewWithNullPtr for wire_cst_rate {
12834        fn new_with_null_ptr() -> Self {
12835            Self {
12836                coin: core::ptr::null_mut(),
12837                value: Default::default(),
12838            }
12839        }
12840    }
12841    impl Default for wire_cst_rate {
12842        fn default() -> Self {
12843            Self::new_with_null_ptr()
12844        }
12845    }
12846    impl NewWithNullPtr for wire_cst_receive_amount {
12847        fn new_with_null_ptr() -> Self {
12848            Self {
12849                tag: -1,
12850                kind: ReceiveAmountKind { nil__: () },
12851            }
12852        }
12853    }
12854    impl Default for wire_cst_receive_amount {
12855        fn default() -> Self {
12856            Self::new_with_null_ptr()
12857        }
12858    }
12859    impl NewWithNullPtr for wire_cst_receive_payment_request {
12860        fn new_with_null_ptr() -> Self {
12861            Self {
12862                prepare_response: Default::default(),
12863                description: core::ptr::null_mut(),
12864                use_description_hash: core::ptr::null_mut(),
12865            }
12866        }
12867    }
12868    impl Default for wire_cst_receive_payment_request {
12869        fn default() -> Self {
12870            Self::new_with_null_ptr()
12871        }
12872    }
12873    impl NewWithNullPtr for wire_cst_receive_payment_response {
12874        fn new_with_null_ptr() -> Self {
12875            Self {
12876                destination: core::ptr::null_mut(),
12877            }
12878        }
12879    }
12880    impl Default for wire_cst_receive_payment_response {
12881        fn default() -> Self {
12882            Self::new_with_null_ptr()
12883        }
12884    }
12885    impl NewWithNullPtr for wire_cst_recommended_fees {
12886        fn new_with_null_ptr() -> Self {
12887            Self {
12888                fastest_fee: Default::default(),
12889                half_hour_fee: Default::default(),
12890                hour_fee: Default::default(),
12891                economy_fee: Default::default(),
12892                minimum_fee: Default::default(),
12893            }
12894        }
12895    }
12896    impl Default for wire_cst_recommended_fees {
12897        fn default() -> Self {
12898            Self::new_with_null_ptr()
12899        }
12900    }
12901    impl NewWithNullPtr for wire_cst_refund_request {
12902        fn new_with_null_ptr() -> Self {
12903            Self {
12904                swap_address: core::ptr::null_mut(),
12905                refund_address: core::ptr::null_mut(),
12906                fee_rate_sat_per_vbyte: Default::default(),
12907            }
12908        }
12909    }
12910    impl Default for wire_cst_refund_request {
12911        fn default() -> Self {
12912            Self::new_with_null_ptr()
12913        }
12914    }
12915    impl NewWithNullPtr for wire_cst_refund_response {
12916        fn new_with_null_ptr() -> Self {
12917            Self {
12918                refund_tx_id: core::ptr::null_mut(),
12919            }
12920        }
12921    }
12922    impl Default for wire_cst_refund_response {
12923        fn default() -> Self {
12924            Self::new_with_null_ptr()
12925        }
12926    }
12927    impl NewWithNullPtr for wire_cst_refundable_swap {
12928        fn new_with_null_ptr() -> Self {
12929            Self {
12930                swap_address: core::ptr::null_mut(),
12931                timestamp: Default::default(),
12932                amount_sat: Default::default(),
12933                last_refund_tx_id: core::ptr::null_mut(),
12934            }
12935        }
12936    }
12937    impl Default for wire_cst_refundable_swap {
12938        fn default() -> Self {
12939            Self::new_with_null_ptr()
12940        }
12941    }
12942    impl NewWithNullPtr for wire_cst_restore_request {
12943        fn new_with_null_ptr() -> Self {
12944            Self {
12945                backup_path: core::ptr::null_mut(),
12946            }
12947        }
12948    }
12949    impl Default for wire_cst_restore_request {
12950        fn default() -> Self {
12951            Self::new_with_null_ptr()
12952        }
12953    }
12954    impl NewWithNullPtr for wire_cst_route_hint {
12955        fn new_with_null_ptr() -> Self {
12956            Self {
12957                hops: core::ptr::null_mut(),
12958            }
12959        }
12960    }
12961    impl Default for wire_cst_route_hint {
12962        fn default() -> Self {
12963            Self::new_with_null_ptr()
12964        }
12965    }
12966    impl NewWithNullPtr for wire_cst_route_hint_hop {
12967        fn new_with_null_ptr() -> Self {
12968            Self {
12969                src_node_id: core::ptr::null_mut(),
12970                short_channel_id: core::ptr::null_mut(),
12971                fees_base_msat: Default::default(),
12972                fees_proportional_millionths: Default::default(),
12973                cltv_expiry_delta: Default::default(),
12974                htlc_minimum_msat: core::ptr::null_mut(),
12975                htlc_maximum_msat: core::ptr::null_mut(),
12976            }
12977        }
12978    }
12979    impl Default for wire_cst_route_hint_hop {
12980        fn default() -> Self {
12981            Self::new_with_null_ptr()
12982        }
12983    }
12984    impl NewWithNullPtr for wire_cst_sdk_error {
12985        fn new_with_null_ptr() -> Self {
12986            Self {
12987                tag: -1,
12988                kind: SdkErrorKind { nil__: () },
12989            }
12990        }
12991    }
12992    impl Default for wire_cst_sdk_error {
12993        fn default() -> Self {
12994            Self::new_with_null_ptr()
12995        }
12996    }
12997    impl NewWithNullPtr for wire_cst_sdk_event {
12998        fn new_with_null_ptr() -> Self {
12999            Self {
13000                tag: -1,
13001                kind: SdkEventKind { nil__: () },
13002            }
13003        }
13004    }
13005    impl Default for wire_cst_sdk_event {
13006        fn default() -> Self {
13007            Self::new_with_null_ptr()
13008        }
13009    }
13010    impl NewWithNullPtr for wire_cst_send_destination {
13011        fn new_with_null_ptr() -> Self {
13012            Self {
13013                tag: -1,
13014                kind: SendDestinationKind { nil__: () },
13015            }
13016        }
13017    }
13018    impl Default for wire_cst_send_destination {
13019        fn default() -> Self {
13020            Self::new_with_null_ptr()
13021        }
13022    }
13023    impl NewWithNullPtr for wire_cst_send_payment_request {
13024        fn new_with_null_ptr() -> Self {
13025            Self {
13026                prepare_response: Default::default(),
13027                use_asset_fees: core::ptr::null_mut(),
13028            }
13029        }
13030    }
13031    impl Default for wire_cst_send_payment_request {
13032        fn default() -> Self {
13033            Self::new_with_null_ptr()
13034        }
13035    }
13036    impl NewWithNullPtr for wire_cst_send_payment_response {
13037        fn new_with_null_ptr() -> Self {
13038            Self {
13039                payment: Default::default(),
13040            }
13041        }
13042    }
13043    impl Default for wire_cst_send_payment_response {
13044        fn default() -> Self {
13045            Self::new_with_null_ptr()
13046        }
13047    }
13048    impl NewWithNullPtr for wire_cst_sign_message_request {
13049        fn new_with_null_ptr() -> Self {
13050            Self {
13051                message: core::ptr::null_mut(),
13052            }
13053        }
13054    }
13055    impl Default for wire_cst_sign_message_request {
13056        fn default() -> Self {
13057            Self::new_with_null_ptr()
13058        }
13059    }
13060    impl NewWithNullPtr for wire_cst_sign_message_response {
13061        fn new_with_null_ptr() -> Self {
13062            Self {
13063                signature: core::ptr::null_mut(),
13064            }
13065        }
13066    }
13067    impl Default for wire_cst_sign_message_response {
13068        fn default() -> Self {
13069            Self::new_with_null_ptr()
13070        }
13071    }
13072    impl NewWithNullPtr for wire_cst_success_action {
13073        fn new_with_null_ptr() -> Self {
13074            Self {
13075                tag: -1,
13076                kind: SuccessActionKind { nil__: () },
13077            }
13078        }
13079    }
13080    impl Default for wire_cst_success_action {
13081        fn default() -> Self {
13082            Self::new_with_null_ptr()
13083        }
13084    }
13085    impl NewWithNullPtr for wire_cst_success_action_processed {
13086        fn new_with_null_ptr() -> Self {
13087            Self {
13088                tag: -1,
13089                kind: SuccessActionProcessedKind { nil__: () },
13090            }
13091        }
13092    }
13093    impl Default for wire_cst_success_action_processed {
13094        fn default() -> Self {
13095            Self::new_with_null_ptr()
13096        }
13097    }
13098    impl NewWithNullPtr for wire_cst_symbol {
13099        fn new_with_null_ptr() -> Self {
13100            Self {
13101                grapheme: core::ptr::null_mut(),
13102                template: core::ptr::null_mut(),
13103                rtl: core::ptr::null_mut(),
13104                position: core::ptr::null_mut(),
13105            }
13106        }
13107    }
13108    impl Default for wire_cst_symbol {
13109        fn default() -> Self {
13110            Self::new_with_null_ptr()
13111        }
13112    }
13113    impl NewWithNullPtr for wire_cst_url_success_action_data {
13114        fn new_with_null_ptr() -> Self {
13115            Self {
13116                description: core::ptr::null_mut(),
13117                url: core::ptr::null_mut(),
13118                matches_callback_domain: Default::default(),
13119            }
13120        }
13121    }
13122    impl Default for wire_cst_url_success_action_data {
13123        fn default() -> Self {
13124            Self::new_with_null_ptr()
13125        }
13126    }
13127    impl NewWithNullPtr for wire_cst_wallet_info {
13128        fn new_with_null_ptr() -> Self {
13129            Self {
13130                balance_sat: Default::default(),
13131                pending_send_sat: Default::default(),
13132                pending_receive_sat: Default::default(),
13133                fingerprint: core::ptr::null_mut(),
13134                pubkey: core::ptr::null_mut(),
13135                asset_balances: core::ptr::null_mut(),
13136            }
13137        }
13138    }
13139    impl Default for wire_cst_wallet_info {
13140        fn default() -> Self {
13141            Self::new_with_null_ptr()
13142        }
13143    }
13144
13145    #[unsafe(no_mangle)]
13146    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_accept_payment_proposed_fees(
13147        port_: i64,
13148        that: usize,
13149        req: *mut wire_cst_accept_payment_proposed_fees_request,
13150    ) {
13151        wire__crate__bindings__BindingLiquidSdk_accept_payment_proposed_fees_impl(port_, that, req)
13152    }
13153
13154    #[unsafe(no_mangle)]
13155    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_add_event_listener(
13156        port_: i64,
13157        that: usize,
13158        listener: *mut wire_cst_list_prim_u_8_strict,
13159    ) {
13160        wire__crate__bindings__BindingLiquidSdk_add_event_listener_impl(port_, that, listener)
13161    }
13162
13163    #[unsafe(no_mangle)]
13164    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_backup(
13165        that: usize,
13166        req: *mut wire_cst_backup_request,
13167    ) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
13168        wire__crate__bindings__BindingLiquidSdk_backup_impl(that, req)
13169    }
13170
13171    #[unsafe(no_mangle)]
13172    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_buy_bitcoin(
13173        port_: i64,
13174        that: usize,
13175        req: *mut wire_cst_buy_bitcoin_request,
13176    ) {
13177        wire__crate__bindings__BindingLiquidSdk_buy_bitcoin_impl(port_, that, req)
13178    }
13179
13180    #[unsafe(no_mangle)]
13181    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_check_message(
13182        that: usize,
13183        req: *mut wire_cst_check_message_request,
13184    ) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
13185        wire__crate__bindings__BindingLiquidSdk_check_message_impl(that, req)
13186    }
13187
13188    #[unsafe(no_mangle)]
13189    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_create_bolt12_invoice(
13190        port_: i64,
13191        that: usize,
13192        req: *mut wire_cst_create_bolt_12_invoice_request,
13193    ) {
13194        wire__crate__bindings__BindingLiquidSdk_create_bolt12_invoice_impl(port_, that, req)
13195    }
13196
13197    #[unsafe(no_mangle)]
13198    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_disconnect(
13199        port_: i64,
13200        that: usize,
13201    ) {
13202        wire__crate__bindings__BindingLiquidSdk_disconnect_impl(port_, that)
13203    }
13204
13205    #[unsafe(no_mangle)]
13206    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_empty_wallet_cache(
13207        that: usize,
13208    ) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
13209        wire__crate__bindings__BindingLiquidSdk_empty_wallet_cache_impl(that)
13210    }
13211
13212    #[unsafe(no_mangle)]
13213    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_fetch_fiat_rates(
13214        port_: i64,
13215        that: usize,
13216    ) {
13217        wire__crate__bindings__BindingLiquidSdk_fetch_fiat_rates_impl(port_, that)
13218    }
13219
13220    #[unsafe(no_mangle)]
13221    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_fetch_lightning_limits(
13222        port_: i64,
13223        that: usize,
13224    ) {
13225        wire__crate__bindings__BindingLiquidSdk_fetch_lightning_limits_impl(port_, that)
13226    }
13227
13228    #[unsafe(no_mangle)]
13229    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_fetch_onchain_limits(
13230        port_: i64,
13231        that: usize,
13232    ) {
13233        wire__crate__bindings__BindingLiquidSdk_fetch_onchain_limits_impl(port_, that)
13234    }
13235
13236    #[unsafe(no_mangle)]
13237    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_fetch_payment_proposed_fees(
13238        port_: i64,
13239        that: usize,
13240        req: *mut wire_cst_fetch_payment_proposed_fees_request,
13241    ) {
13242        wire__crate__bindings__BindingLiquidSdk_fetch_payment_proposed_fees_impl(port_, that, req)
13243    }
13244
13245    #[unsafe(no_mangle)]
13246    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_get_info(
13247        port_: i64,
13248        that: usize,
13249    ) {
13250        wire__crate__bindings__BindingLiquidSdk_get_info_impl(port_, that)
13251    }
13252
13253    #[unsafe(no_mangle)]
13254    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_get_payment(
13255        port_: i64,
13256        that: usize,
13257        req: *mut wire_cst_get_payment_request,
13258    ) {
13259        wire__crate__bindings__BindingLiquidSdk_get_payment_impl(port_, that, req)
13260    }
13261
13262    #[unsafe(no_mangle)]
13263    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_list_fiat_currencies(
13264        port_: i64,
13265        that: usize,
13266    ) {
13267        wire__crate__bindings__BindingLiquidSdk_list_fiat_currencies_impl(port_, that)
13268    }
13269
13270    #[unsafe(no_mangle)]
13271    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_list_payments(
13272        port_: i64,
13273        that: usize,
13274        req: *mut wire_cst_list_payments_request,
13275    ) {
13276        wire__crate__bindings__BindingLiquidSdk_list_payments_impl(port_, that, req)
13277    }
13278
13279    #[unsafe(no_mangle)]
13280    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_list_refundables(
13281        port_: i64,
13282        that: usize,
13283    ) {
13284        wire__crate__bindings__BindingLiquidSdk_list_refundables_impl(port_, that)
13285    }
13286
13287    #[unsafe(no_mangle)]
13288    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_lnurl_auth(
13289        port_: i64,
13290        that: usize,
13291        req_data: *mut wire_cst_ln_url_auth_request_data,
13292    ) {
13293        wire__crate__bindings__BindingLiquidSdk_lnurl_auth_impl(port_, that, req_data)
13294    }
13295
13296    #[unsafe(no_mangle)]
13297    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_lnurl_pay(
13298        port_: i64,
13299        that: usize,
13300        req: *mut wire_cst_ln_url_pay_request,
13301    ) {
13302        wire__crate__bindings__BindingLiquidSdk_lnurl_pay_impl(port_, that, req)
13303    }
13304
13305    #[unsafe(no_mangle)]
13306    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_lnurl_withdraw(
13307        port_: i64,
13308        that: usize,
13309        req: *mut wire_cst_ln_url_withdraw_request,
13310    ) {
13311        wire__crate__bindings__BindingLiquidSdk_lnurl_withdraw_impl(port_, that, req)
13312    }
13313
13314    #[unsafe(no_mangle)]
13315    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_parse(
13316        port_: i64,
13317        that: usize,
13318        input: *mut wire_cst_list_prim_u_8_strict,
13319    ) {
13320        wire__crate__bindings__BindingLiquidSdk_parse_impl(port_, that, input)
13321    }
13322
13323    #[unsafe(no_mangle)]
13324    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_pay_onchain(
13325        port_: i64,
13326        that: usize,
13327        req: *mut wire_cst_pay_onchain_request,
13328    ) {
13329        wire__crate__bindings__BindingLiquidSdk_pay_onchain_impl(port_, that, req)
13330    }
13331
13332    #[unsafe(no_mangle)]
13333    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_prepare_buy_bitcoin(
13334        port_: i64,
13335        that: usize,
13336        req: *mut wire_cst_prepare_buy_bitcoin_request,
13337    ) {
13338        wire__crate__bindings__BindingLiquidSdk_prepare_buy_bitcoin_impl(port_, that, req)
13339    }
13340
13341    #[unsafe(no_mangle)]
13342    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_prepare_lnurl_pay(
13343        port_: i64,
13344        that: usize,
13345        req: *mut wire_cst_prepare_ln_url_pay_request,
13346    ) {
13347        wire__crate__bindings__BindingLiquidSdk_prepare_lnurl_pay_impl(port_, that, req)
13348    }
13349
13350    #[unsafe(no_mangle)]
13351    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_prepare_pay_onchain(
13352        port_: i64,
13353        that: usize,
13354        req: *mut wire_cst_prepare_pay_onchain_request,
13355    ) {
13356        wire__crate__bindings__BindingLiquidSdk_prepare_pay_onchain_impl(port_, that, req)
13357    }
13358
13359    #[unsafe(no_mangle)]
13360    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_prepare_receive_payment(
13361        port_: i64,
13362        that: usize,
13363        req: *mut wire_cst_prepare_receive_request,
13364    ) {
13365        wire__crate__bindings__BindingLiquidSdk_prepare_receive_payment_impl(port_, that, req)
13366    }
13367
13368    #[unsafe(no_mangle)]
13369    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_prepare_refund(
13370        port_: i64,
13371        that: usize,
13372        req: *mut wire_cst_prepare_refund_request,
13373    ) {
13374        wire__crate__bindings__BindingLiquidSdk_prepare_refund_impl(port_, that, req)
13375    }
13376
13377    #[unsafe(no_mangle)]
13378    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_prepare_send_payment(
13379        port_: i64,
13380        that: usize,
13381        req: *mut wire_cst_prepare_send_request,
13382    ) {
13383        wire__crate__bindings__BindingLiquidSdk_prepare_send_payment_impl(port_, that, req)
13384    }
13385
13386    #[unsafe(no_mangle)]
13387    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_receive_payment(
13388        port_: i64,
13389        that: usize,
13390        req: *mut wire_cst_receive_payment_request,
13391    ) {
13392        wire__crate__bindings__BindingLiquidSdk_receive_payment_impl(port_, that, req)
13393    }
13394
13395    #[unsafe(no_mangle)]
13396    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_recommended_fees(
13397        port_: i64,
13398        that: usize,
13399    ) {
13400        wire__crate__bindings__BindingLiquidSdk_recommended_fees_impl(port_, that)
13401    }
13402
13403    #[unsafe(no_mangle)]
13404    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_refund(
13405        port_: i64,
13406        that: usize,
13407        req: *mut wire_cst_refund_request,
13408    ) {
13409        wire__crate__bindings__BindingLiquidSdk_refund_impl(port_, that, req)
13410    }
13411
13412    #[unsafe(no_mangle)]
13413    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_register_webhook(
13414        port_: i64,
13415        that: usize,
13416        webhook_url: *mut wire_cst_list_prim_u_8_strict,
13417    ) {
13418        wire__crate__bindings__BindingLiquidSdk_register_webhook_impl(port_, that, webhook_url)
13419    }
13420
13421    #[unsafe(no_mangle)]
13422    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_rescan_onchain_swaps(
13423        port_: i64,
13424        that: usize,
13425    ) {
13426        wire__crate__bindings__BindingLiquidSdk_rescan_onchain_swaps_impl(port_, that)
13427    }
13428
13429    #[unsafe(no_mangle)]
13430    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_restore(
13431        that: usize,
13432        req: *mut wire_cst_restore_request,
13433    ) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
13434        wire__crate__bindings__BindingLiquidSdk_restore_impl(that, req)
13435    }
13436
13437    #[unsafe(no_mangle)]
13438    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_send_payment(
13439        port_: i64,
13440        that: usize,
13441        req: *mut wire_cst_send_payment_request,
13442    ) {
13443        wire__crate__bindings__BindingLiquidSdk_send_payment_impl(port_, that, req)
13444    }
13445
13446    #[unsafe(no_mangle)]
13447    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_sign_message(
13448        that: usize,
13449        req: *mut wire_cst_sign_message_request,
13450    ) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
13451        wire__crate__bindings__BindingLiquidSdk_sign_message_impl(that, req)
13452    }
13453
13454    #[unsafe(no_mangle)]
13455    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_sync(
13456        port_: i64,
13457        that: usize,
13458    ) {
13459        wire__crate__bindings__BindingLiquidSdk_sync_impl(port_, that)
13460    }
13461
13462    #[unsafe(no_mangle)]
13463    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_unregister_webhook(
13464        port_: i64,
13465        that: usize,
13466    ) {
13467        wire__crate__bindings__BindingLiquidSdk_unregister_webhook_impl(port_, that)
13468    }
13469
13470    #[unsafe(no_mangle)]
13471    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__binding_event_listener_on_event(
13472        port_: i64,
13473        that: *mut wire_cst_binding_event_listener,
13474        e: *mut wire_cst_sdk_event,
13475    ) {
13476        wire__crate__bindings__binding_event_listener_on_event_impl(port_, that, e)
13477    }
13478
13479    #[unsafe(no_mangle)]
13480    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__breez_log_stream(
13481        port_: i64,
13482        s: *mut wire_cst_list_prim_u_8_strict,
13483    ) {
13484        wire__crate__bindings__breez_log_stream_impl(port_, s)
13485    }
13486
13487    #[unsafe(no_mangle)]
13488    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__connect(
13489        port_: i64,
13490        req: *mut wire_cst_connect_request,
13491    ) {
13492        wire__crate__bindings__connect_impl(port_, req)
13493    }
13494
13495    #[unsafe(no_mangle)]
13496    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__default_config(
13497        network: i32,
13498        breez_api_key: *mut wire_cst_list_prim_u_8_strict,
13499    ) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
13500        wire__crate__bindings__default_config_impl(network, breez_api_key)
13501    }
13502
13503    #[unsafe(no_mangle)]
13504    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__parse_invoice(
13505        input: *mut wire_cst_list_prim_u_8_strict,
13506    ) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
13507        wire__crate__bindings__parse_invoice_impl(input)
13508    }
13509
13510    #[unsafe(no_mangle)]
13511    pub extern "C" fn frbgen_breez_liquid_rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerBindingLiquidSdk(
13512        ptr: *const std::ffi::c_void,
13513    ) {
13514        unsafe {
13515            StdArc::<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>::increment_strong_count(ptr as _);
13516        }
13517    }
13518
13519    #[unsafe(no_mangle)]
13520    pub extern "C" fn frbgen_breez_liquid_rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerBindingLiquidSdk(
13521        ptr: *const std::ffi::c_void,
13522    ) {
13523        unsafe {
13524            StdArc::<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>::decrement_strong_count(ptr as _);
13525        }
13526    }
13527
13528    #[unsafe(no_mangle)]
13529    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_accept_payment_proposed_fees_request(
13530    ) -> *mut wire_cst_accept_payment_proposed_fees_request {
13531        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13532            wire_cst_accept_payment_proposed_fees_request::new_with_null_ptr(),
13533        )
13534    }
13535
13536    #[unsafe(no_mangle)]
13537    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_aes_success_action_data(
13538    ) -> *mut wire_cst_aes_success_action_data {
13539        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13540            wire_cst_aes_success_action_data::new_with_null_ptr(),
13541        )
13542    }
13543
13544    #[unsafe(no_mangle)]
13545    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_aes_success_action_data_decrypted(
13546    ) -> *mut wire_cst_aes_success_action_data_decrypted {
13547        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13548            wire_cst_aes_success_action_data_decrypted::new_with_null_ptr(),
13549        )
13550    }
13551
13552    #[unsafe(no_mangle)]
13553    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_aes_success_action_data_result(
13554    ) -> *mut wire_cst_aes_success_action_data_result {
13555        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13556            wire_cst_aes_success_action_data_result::new_with_null_ptr(),
13557        )
13558    }
13559
13560    #[unsafe(no_mangle)]
13561    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_amount() -> *mut wire_cst_amount {
13562        flutter_rust_bridge::for_generated::new_leak_box_ptr(wire_cst_amount::new_with_null_ptr())
13563    }
13564
13565    #[unsafe(no_mangle)]
13566    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_asset_info(
13567    ) -> *mut wire_cst_asset_info {
13568        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13569            wire_cst_asset_info::new_with_null_ptr(),
13570        )
13571    }
13572
13573    #[unsafe(no_mangle)]
13574    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_backup_request(
13575    ) -> *mut wire_cst_backup_request {
13576        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13577            wire_cst_backup_request::new_with_null_ptr(),
13578        )
13579    }
13580
13581    #[unsafe(no_mangle)]
13582    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_binding_event_listener(
13583    ) -> *mut wire_cst_binding_event_listener {
13584        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13585            wire_cst_binding_event_listener::new_with_null_ptr(),
13586        )
13587    }
13588
13589    #[unsafe(no_mangle)]
13590    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_bitcoin_address_data(
13591    ) -> *mut wire_cst_bitcoin_address_data {
13592        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13593            wire_cst_bitcoin_address_data::new_with_null_ptr(),
13594        )
13595    }
13596
13597    #[unsafe(no_mangle)]
13598    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_bool(value: bool) -> *mut bool {
13599        flutter_rust_bridge::for_generated::new_leak_box_ptr(value)
13600    }
13601
13602    #[unsafe(no_mangle)]
13603    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_buy_bitcoin_request(
13604    ) -> *mut wire_cst_buy_bitcoin_request {
13605        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13606            wire_cst_buy_bitcoin_request::new_with_null_ptr(),
13607        )
13608    }
13609
13610    #[unsafe(no_mangle)]
13611    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_check_message_request(
13612    ) -> *mut wire_cst_check_message_request {
13613        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13614            wire_cst_check_message_request::new_with_null_ptr(),
13615        )
13616    }
13617
13618    #[unsafe(no_mangle)]
13619    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_connect_request(
13620    ) -> *mut wire_cst_connect_request {
13621        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13622            wire_cst_connect_request::new_with_null_ptr(),
13623        )
13624    }
13625
13626    #[unsafe(no_mangle)]
13627    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_create_bolt_12_invoice_request(
13628    ) -> *mut wire_cst_create_bolt_12_invoice_request {
13629        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13630            wire_cst_create_bolt_12_invoice_request::new_with_null_ptr(),
13631        )
13632    }
13633
13634    #[unsafe(no_mangle)]
13635    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_f_64(value: f64) -> *mut f64 {
13636        flutter_rust_bridge::for_generated::new_leak_box_ptr(value)
13637    }
13638
13639    #[unsafe(no_mangle)]
13640    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_fetch_payment_proposed_fees_request(
13641    ) -> *mut wire_cst_fetch_payment_proposed_fees_request {
13642        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13643            wire_cst_fetch_payment_proposed_fees_request::new_with_null_ptr(),
13644        )
13645    }
13646
13647    #[unsafe(no_mangle)]
13648    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_get_payment_request(
13649    ) -> *mut wire_cst_get_payment_request {
13650        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13651            wire_cst_get_payment_request::new_with_null_ptr(),
13652        )
13653    }
13654
13655    #[unsafe(no_mangle)]
13656    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_i_64(value: i64) -> *mut i64 {
13657        flutter_rust_bridge::for_generated::new_leak_box_ptr(value)
13658    }
13659
13660    #[unsafe(no_mangle)]
13661    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_liquid_address_data(
13662    ) -> *mut wire_cst_liquid_address_data {
13663        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13664            wire_cst_liquid_address_data::new_with_null_ptr(),
13665        )
13666    }
13667
13668    #[unsafe(no_mangle)]
13669    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_list_payment_details(
13670    ) -> *mut wire_cst_list_payment_details {
13671        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13672            wire_cst_list_payment_details::new_with_null_ptr(),
13673        )
13674    }
13675
13676    #[unsafe(no_mangle)]
13677    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_list_payments_request(
13678    ) -> *mut wire_cst_list_payments_request {
13679        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13680            wire_cst_list_payments_request::new_with_null_ptr(),
13681        )
13682    }
13683
13684    #[unsafe(no_mangle)]
13685    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_invoice(
13686    ) -> *mut wire_cst_ln_invoice {
13687        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13688            wire_cst_ln_invoice::new_with_null_ptr(),
13689        )
13690    }
13691
13692    #[unsafe(no_mangle)]
13693    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_offer() -> *mut wire_cst_ln_offer {
13694        flutter_rust_bridge::for_generated::new_leak_box_ptr(wire_cst_ln_offer::new_with_null_ptr())
13695    }
13696
13697    #[unsafe(no_mangle)]
13698    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_url_auth_request_data(
13699    ) -> *mut wire_cst_ln_url_auth_request_data {
13700        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13701            wire_cst_ln_url_auth_request_data::new_with_null_ptr(),
13702        )
13703    }
13704
13705    #[unsafe(no_mangle)]
13706    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_url_error_data(
13707    ) -> *mut wire_cst_ln_url_error_data {
13708        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13709            wire_cst_ln_url_error_data::new_with_null_ptr(),
13710        )
13711    }
13712
13713    #[unsafe(no_mangle)]
13714    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_url_info(
13715    ) -> *mut wire_cst_ln_url_info {
13716        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13717            wire_cst_ln_url_info::new_with_null_ptr(),
13718        )
13719    }
13720
13721    #[unsafe(no_mangle)]
13722    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_url_pay_error_data(
13723    ) -> *mut wire_cst_ln_url_pay_error_data {
13724        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13725            wire_cst_ln_url_pay_error_data::new_with_null_ptr(),
13726        )
13727    }
13728
13729    #[unsafe(no_mangle)]
13730    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_url_pay_request(
13731    ) -> *mut wire_cst_ln_url_pay_request {
13732        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13733            wire_cst_ln_url_pay_request::new_with_null_ptr(),
13734        )
13735    }
13736
13737    #[unsafe(no_mangle)]
13738    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_url_pay_request_data(
13739    ) -> *mut wire_cst_ln_url_pay_request_data {
13740        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13741            wire_cst_ln_url_pay_request_data::new_with_null_ptr(),
13742        )
13743    }
13744
13745    #[unsafe(no_mangle)]
13746    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_url_pay_success_data(
13747    ) -> *mut wire_cst_ln_url_pay_success_data {
13748        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13749            wire_cst_ln_url_pay_success_data::new_with_null_ptr(),
13750        )
13751    }
13752
13753    #[unsafe(no_mangle)]
13754    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_url_withdraw_request(
13755    ) -> *mut wire_cst_ln_url_withdraw_request {
13756        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13757            wire_cst_ln_url_withdraw_request::new_with_null_ptr(),
13758        )
13759    }
13760
13761    #[unsafe(no_mangle)]
13762    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_url_withdraw_request_data(
13763    ) -> *mut wire_cst_ln_url_withdraw_request_data {
13764        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13765            wire_cst_ln_url_withdraw_request_data::new_with_null_ptr(),
13766        )
13767    }
13768
13769    #[unsafe(no_mangle)]
13770    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_url_withdraw_success_data(
13771    ) -> *mut wire_cst_ln_url_withdraw_success_data {
13772        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13773            wire_cst_ln_url_withdraw_success_data::new_with_null_ptr(),
13774        )
13775    }
13776
13777    #[unsafe(no_mangle)]
13778    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_message_success_action_data(
13779    ) -> *mut wire_cst_message_success_action_data {
13780        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13781            wire_cst_message_success_action_data::new_with_null_ptr(),
13782        )
13783    }
13784
13785    #[unsafe(no_mangle)]
13786    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_pay_amount(
13787    ) -> *mut wire_cst_pay_amount {
13788        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13789            wire_cst_pay_amount::new_with_null_ptr(),
13790        )
13791    }
13792
13793    #[unsafe(no_mangle)]
13794    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_pay_onchain_request(
13795    ) -> *mut wire_cst_pay_onchain_request {
13796        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13797            wire_cst_pay_onchain_request::new_with_null_ptr(),
13798        )
13799    }
13800
13801    #[unsafe(no_mangle)]
13802    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_payment() -> *mut wire_cst_payment {
13803        flutter_rust_bridge::for_generated::new_leak_box_ptr(wire_cst_payment::new_with_null_ptr())
13804    }
13805
13806    #[unsafe(no_mangle)]
13807    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_prepare_buy_bitcoin_request(
13808    ) -> *mut wire_cst_prepare_buy_bitcoin_request {
13809        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13810            wire_cst_prepare_buy_bitcoin_request::new_with_null_ptr(),
13811        )
13812    }
13813
13814    #[unsafe(no_mangle)]
13815    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_prepare_ln_url_pay_request(
13816    ) -> *mut wire_cst_prepare_ln_url_pay_request {
13817        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13818            wire_cst_prepare_ln_url_pay_request::new_with_null_ptr(),
13819        )
13820    }
13821
13822    #[unsafe(no_mangle)]
13823    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_prepare_pay_onchain_request(
13824    ) -> *mut wire_cst_prepare_pay_onchain_request {
13825        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13826            wire_cst_prepare_pay_onchain_request::new_with_null_ptr(),
13827        )
13828    }
13829
13830    #[unsafe(no_mangle)]
13831    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_prepare_receive_request(
13832    ) -> *mut wire_cst_prepare_receive_request {
13833        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13834            wire_cst_prepare_receive_request::new_with_null_ptr(),
13835        )
13836    }
13837
13838    #[unsafe(no_mangle)]
13839    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_prepare_refund_request(
13840    ) -> *mut wire_cst_prepare_refund_request {
13841        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13842            wire_cst_prepare_refund_request::new_with_null_ptr(),
13843        )
13844    }
13845
13846    #[unsafe(no_mangle)]
13847    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_prepare_send_request(
13848    ) -> *mut wire_cst_prepare_send_request {
13849        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13850            wire_cst_prepare_send_request::new_with_null_ptr(),
13851        )
13852    }
13853
13854    #[unsafe(no_mangle)]
13855    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_receive_amount(
13856    ) -> *mut wire_cst_receive_amount {
13857        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13858            wire_cst_receive_amount::new_with_null_ptr(),
13859        )
13860    }
13861
13862    #[unsafe(no_mangle)]
13863    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_receive_payment_request(
13864    ) -> *mut wire_cst_receive_payment_request {
13865        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13866            wire_cst_receive_payment_request::new_with_null_ptr(),
13867        )
13868    }
13869
13870    #[unsafe(no_mangle)]
13871    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_refund_request(
13872    ) -> *mut wire_cst_refund_request {
13873        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13874            wire_cst_refund_request::new_with_null_ptr(),
13875        )
13876    }
13877
13878    #[unsafe(no_mangle)]
13879    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_restore_request(
13880    ) -> *mut wire_cst_restore_request {
13881        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13882            wire_cst_restore_request::new_with_null_ptr(),
13883        )
13884    }
13885
13886    #[unsafe(no_mangle)]
13887    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_sdk_event() -> *mut wire_cst_sdk_event
13888    {
13889        flutter_rust_bridge::for_generated::new_leak_box_ptr(wire_cst_sdk_event::new_with_null_ptr())
13890    }
13891
13892    #[unsafe(no_mangle)]
13893    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_send_payment_request(
13894    ) -> *mut wire_cst_send_payment_request {
13895        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13896            wire_cst_send_payment_request::new_with_null_ptr(),
13897        )
13898    }
13899
13900    #[unsafe(no_mangle)]
13901    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_sign_message_request(
13902    ) -> *mut wire_cst_sign_message_request {
13903        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13904            wire_cst_sign_message_request::new_with_null_ptr(),
13905        )
13906    }
13907
13908    #[unsafe(no_mangle)]
13909    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_success_action(
13910    ) -> *mut wire_cst_success_action {
13911        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13912            wire_cst_success_action::new_with_null_ptr(),
13913        )
13914    }
13915
13916    #[unsafe(no_mangle)]
13917    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_success_action_processed(
13918    ) -> *mut wire_cst_success_action_processed {
13919        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13920            wire_cst_success_action_processed::new_with_null_ptr(),
13921        )
13922    }
13923
13924    #[unsafe(no_mangle)]
13925    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_symbol() -> *mut wire_cst_symbol {
13926        flutter_rust_bridge::for_generated::new_leak_box_ptr(wire_cst_symbol::new_with_null_ptr())
13927    }
13928
13929    #[unsafe(no_mangle)]
13930    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_u_32(value: u32) -> *mut u32 {
13931        flutter_rust_bridge::for_generated::new_leak_box_ptr(value)
13932    }
13933
13934    #[unsafe(no_mangle)]
13935    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_u_64(value: u64) -> *mut u64 {
13936        flutter_rust_bridge::for_generated::new_leak_box_ptr(value)
13937    }
13938
13939    #[unsafe(no_mangle)]
13940    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_url_success_action_data(
13941    ) -> *mut wire_cst_url_success_action_data {
13942        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13943            wire_cst_url_success_action_data::new_with_null_ptr(),
13944        )
13945    }
13946
13947    #[unsafe(no_mangle)]
13948    pub extern "C" fn frbgen_breez_liquid_cst_new_list_String(
13949        len: i32,
13950    ) -> *mut wire_cst_list_String {
13951        let wrap = wire_cst_list_String {
13952            ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
13953                <*mut wire_cst_list_prim_u_8_strict>::new_with_null_ptr(),
13954                len,
13955            ),
13956            len,
13957        };
13958        flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
13959    }
13960
13961    #[unsafe(no_mangle)]
13962    pub extern "C" fn frbgen_breez_liquid_cst_new_list_asset_balance(
13963        len: i32,
13964    ) -> *mut wire_cst_list_asset_balance {
13965        let wrap = wire_cst_list_asset_balance {
13966            ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
13967                <wire_cst_asset_balance>::new_with_null_ptr(),
13968                len,
13969            ),
13970            len,
13971        };
13972        flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
13973    }
13974
13975    #[unsafe(no_mangle)]
13976    pub extern "C" fn frbgen_breez_liquid_cst_new_list_asset_metadata(
13977        len: i32,
13978    ) -> *mut wire_cst_list_asset_metadata {
13979        let wrap = wire_cst_list_asset_metadata {
13980            ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
13981                <wire_cst_asset_metadata>::new_with_null_ptr(),
13982                len,
13983            ),
13984            len,
13985        };
13986        flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
13987    }
13988
13989    #[unsafe(no_mangle)]
13990    pub extern "C" fn frbgen_breez_liquid_cst_new_list_external_input_parser(
13991        len: i32,
13992    ) -> *mut wire_cst_list_external_input_parser {
13993        let wrap = wire_cst_list_external_input_parser {
13994            ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
13995                <wire_cst_external_input_parser>::new_with_null_ptr(),
13996                len,
13997            ),
13998            len,
13999        };
14000        flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14001    }
14002
14003    #[unsafe(no_mangle)]
14004    pub extern "C" fn frbgen_breez_liquid_cst_new_list_fiat_currency(
14005        len: i32,
14006    ) -> *mut wire_cst_list_fiat_currency {
14007        let wrap = wire_cst_list_fiat_currency {
14008            ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
14009                <wire_cst_fiat_currency>::new_with_null_ptr(),
14010                len,
14011            ),
14012            len,
14013        };
14014        flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14015    }
14016
14017    #[unsafe(no_mangle)]
14018    pub extern "C" fn frbgen_breez_liquid_cst_new_list_ln_offer_blinded_path(
14019        len: i32,
14020    ) -> *mut wire_cst_list_ln_offer_blinded_path {
14021        let wrap = wire_cst_list_ln_offer_blinded_path {
14022            ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
14023                <wire_cst_ln_offer_blinded_path>::new_with_null_ptr(),
14024                len,
14025            ),
14026            len,
14027        };
14028        flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14029    }
14030
14031    #[unsafe(no_mangle)]
14032    pub extern "C" fn frbgen_breez_liquid_cst_new_list_locale_overrides(
14033        len: i32,
14034    ) -> *mut wire_cst_list_locale_overrides {
14035        let wrap = wire_cst_list_locale_overrides {
14036            ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
14037                <wire_cst_locale_overrides>::new_with_null_ptr(),
14038                len,
14039            ),
14040            len,
14041        };
14042        flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14043    }
14044
14045    #[unsafe(no_mangle)]
14046    pub extern "C" fn frbgen_breez_liquid_cst_new_list_localized_name(
14047        len: i32,
14048    ) -> *mut wire_cst_list_localized_name {
14049        let wrap = wire_cst_list_localized_name {
14050            ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
14051                <wire_cst_localized_name>::new_with_null_ptr(),
14052                len,
14053            ),
14054            len,
14055        };
14056        flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14057    }
14058
14059    #[unsafe(no_mangle)]
14060    pub extern "C" fn frbgen_breez_liquid_cst_new_list_payment(
14061        len: i32,
14062    ) -> *mut wire_cst_list_payment {
14063        let wrap = wire_cst_list_payment {
14064            ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
14065                <wire_cst_payment>::new_with_null_ptr(),
14066                len,
14067            ),
14068            len,
14069        };
14070        flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14071    }
14072
14073    #[unsafe(no_mangle)]
14074    pub extern "C" fn frbgen_breez_liquid_cst_new_list_payment_state(
14075        len: i32,
14076    ) -> *mut wire_cst_list_payment_state {
14077        let wrap = wire_cst_list_payment_state {
14078            ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(Default::default(), len),
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_type(
14086        len: i32,
14087    ) -> *mut wire_cst_list_payment_type {
14088        let wrap = wire_cst_list_payment_type {
14089            ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(Default::default(), len),
14090            len,
14091        };
14092        flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14093    }
14094
14095    #[unsafe(no_mangle)]
14096    pub extern "C" fn frbgen_breez_liquid_cst_new_list_prim_u_8_strict(
14097        len: i32,
14098    ) -> *mut wire_cst_list_prim_u_8_strict {
14099        let ans = wire_cst_list_prim_u_8_strict {
14100            ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(Default::default(), len),
14101            len,
14102        };
14103        flutter_rust_bridge::for_generated::new_leak_box_ptr(ans)
14104    }
14105
14106    #[unsafe(no_mangle)]
14107    pub extern "C" fn frbgen_breez_liquid_cst_new_list_rate(len: i32) -> *mut wire_cst_list_rate {
14108        let wrap = wire_cst_list_rate {
14109            ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
14110                <wire_cst_rate>::new_with_null_ptr(),
14111                len,
14112            ),
14113            len,
14114        };
14115        flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14116    }
14117
14118    #[unsafe(no_mangle)]
14119    pub extern "C" fn frbgen_breez_liquid_cst_new_list_refundable_swap(
14120        len: i32,
14121    ) -> *mut wire_cst_list_refundable_swap {
14122        let wrap = wire_cst_list_refundable_swap {
14123            ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
14124                <wire_cst_refundable_swap>::new_with_null_ptr(),
14125                len,
14126            ),
14127            len,
14128        };
14129        flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14130    }
14131
14132    #[unsafe(no_mangle)]
14133    pub extern "C" fn frbgen_breez_liquid_cst_new_list_route_hint(
14134        len: i32,
14135    ) -> *mut wire_cst_list_route_hint {
14136        let wrap = wire_cst_list_route_hint {
14137            ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
14138                <wire_cst_route_hint>::new_with_null_ptr(),
14139                len,
14140            ),
14141            len,
14142        };
14143        flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14144    }
14145
14146    #[unsafe(no_mangle)]
14147    pub extern "C" fn frbgen_breez_liquid_cst_new_list_route_hint_hop(
14148        len: i32,
14149    ) -> *mut wire_cst_list_route_hint_hop {
14150        let wrap = wire_cst_list_route_hint_hop {
14151            ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
14152                <wire_cst_route_hint_hop>::new_with_null_ptr(),
14153                len,
14154            ),
14155            len,
14156        };
14157        flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14158    }
14159
14160    #[repr(C)]
14161    #[derive(Clone, Copy)]
14162    pub struct wire_cst_accept_payment_proposed_fees_request {
14163        response: wire_cst_fetch_payment_proposed_fees_response,
14164    }
14165    #[repr(C)]
14166    #[derive(Clone, Copy)]
14167    pub struct wire_cst_aes_success_action_data {
14168        description: *mut wire_cst_list_prim_u_8_strict,
14169        ciphertext: *mut wire_cst_list_prim_u_8_strict,
14170        iv: *mut wire_cst_list_prim_u_8_strict,
14171    }
14172    #[repr(C)]
14173    #[derive(Clone, Copy)]
14174    pub struct wire_cst_aes_success_action_data_decrypted {
14175        description: *mut wire_cst_list_prim_u_8_strict,
14176        plaintext: *mut wire_cst_list_prim_u_8_strict,
14177    }
14178    #[repr(C)]
14179    #[derive(Clone, Copy)]
14180    pub struct wire_cst_aes_success_action_data_result {
14181        tag: i32,
14182        kind: AesSuccessActionDataResultKind,
14183    }
14184    #[repr(C)]
14185    #[derive(Clone, Copy)]
14186    pub union AesSuccessActionDataResultKind {
14187        Decrypted: wire_cst_AesSuccessActionDataResult_Decrypted,
14188        ErrorStatus: wire_cst_AesSuccessActionDataResult_ErrorStatus,
14189        nil__: (),
14190    }
14191    #[repr(C)]
14192    #[derive(Clone, Copy)]
14193    pub struct wire_cst_AesSuccessActionDataResult_Decrypted {
14194        data: *mut wire_cst_aes_success_action_data_decrypted,
14195    }
14196    #[repr(C)]
14197    #[derive(Clone, Copy)]
14198    pub struct wire_cst_AesSuccessActionDataResult_ErrorStatus {
14199        reason: *mut wire_cst_list_prim_u_8_strict,
14200    }
14201    #[repr(C)]
14202    #[derive(Clone, Copy)]
14203    pub struct wire_cst_amount {
14204        tag: i32,
14205        kind: AmountKind,
14206    }
14207    #[repr(C)]
14208    #[derive(Clone, Copy)]
14209    pub union AmountKind {
14210        Bitcoin: wire_cst_Amount_Bitcoin,
14211        Currency: wire_cst_Amount_Currency,
14212        nil__: (),
14213    }
14214    #[repr(C)]
14215    #[derive(Clone, Copy)]
14216    pub struct wire_cst_Amount_Bitcoin {
14217        amount_msat: u64,
14218    }
14219    #[repr(C)]
14220    #[derive(Clone, Copy)]
14221    pub struct wire_cst_Amount_Currency {
14222        iso4217_code: *mut wire_cst_list_prim_u_8_strict,
14223        fractional_amount: u64,
14224    }
14225    #[repr(C)]
14226    #[derive(Clone, Copy)]
14227    pub struct wire_cst_asset_balance {
14228        asset_id: *mut wire_cst_list_prim_u_8_strict,
14229        balance_sat: u64,
14230        name: *mut wire_cst_list_prim_u_8_strict,
14231        ticker: *mut wire_cst_list_prim_u_8_strict,
14232        balance: *mut f64,
14233    }
14234    #[repr(C)]
14235    #[derive(Clone, Copy)]
14236    pub struct wire_cst_asset_info {
14237        name: *mut wire_cst_list_prim_u_8_strict,
14238        ticker: *mut wire_cst_list_prim_u_8_strict,
14239        amount: f64,
14240        fees: *mut f64,
14241    }
14242    #[repr(C)]
14243    #[derive(Clone, Copy)]
14244    pub struct wire_cst_asset_metadata {
14245        asset_id: *mut wire_cst_list_prim_u_8_strict,
14246        name: *mut wire_cst_list_prim_u_8_strict,
14247        ticker: *mut wire_cst_list_prim_u_8_strict,
14248        precision: u8,
14249        fiat_id: *mut wire_cst_list_prim_u_8_strict,
14250    }
14251    #[repr(C)]
14252    #[derive(Clone, Copy)]
14253    pub struct wire_cst_backup_request {
14254        backup_path: *mut wire_cst_list_prim_u_8_strict,
14255    }
14256    #[repr(C)]
14257    #[derive(Clone, Copy)]
14258    pub struct wire_cst_binding_event_listener {
14259        stream: *mut wire_cst_list_prim_u_8_strict,
14260    }
14261    #[repr(C)]
14262    #[derive(Clone, Copy)]
14263    pub struct wire_cst_bitcoin_address_data {
14264        address: *mut wire_cst_list_prim_u_8_strict,
14265        network: i32,
14266        amount_sat: *mut u64,
14267        label: *mut wire_cst_list_prim_u_8_strict,
14268        message: *mut wire_cst_list_prim_u_8_strict,
14269    }
14270    #[repr(C)]
14271    #[derive(Clone, Copy)]
14272    pub struct wire_cst_blockchain_explorer {
14273        tag: i32,
14274        kind: BlockchainExplorerKind,
14275    }
14276    #[repr(C)]
14277    #[derive(Clone, Copy)]
14278    pub union BlockchainExplorerKind {
14279        Electrum: wire_cst_BlockchainExplorer_Electrum,
14280        Esplora: wire_cst_BlockchainExplorer_Esplora,
14281        nil__: (),
14282    }
14283    #[repr(C)]
14284    #[derive(Clone, Copy)]
14285    pub struct wire_cst_BlockchainExplorer_Electrum {
14286        url: *mut wire_cst_list_prim_u_8_strict,
14287    }
14288    #[repr(C)]
14289    #[derive(Clone, Copy)]
14290    pub struct wire_cst_BlockchainExplorer_Esplora {
14291        url: *mut wire_cst_list_prim_u_8_strict,
14292        use_waterfalls: bool,
14293    }
14294    #[repr(C)]
14295    #[derive(Clone, Copy)]
14296    pub struct wire_cst_blockchain_info {
14297        liquid_tip: u32,
14298        bitcoin_tip: u32,
14299    }
14300    #[repr(C)]
14301    #[derive(Clone, Copy)]
14302    pub struct wire_cst_buy_bitcoin_request {
14303        prepare_response: wire_cst_prepare_buy_bitcoin_response,
14304        redirect_url: *mut wire_cst_list_prim_u_8_strict,
14305    }
14306    #[repr(C)]
14307    #[derive(Clone, Copy)]
14308    pub struct wire_cst_check_message_request {
14309        message: *mut wire_cst_list_prim_u_8_strict,
14310        pubkey: *mut wire_cst_list_prim_u_8_strict,
14311        signature: *mut wire_cst_list_prim_u_8_strict,
14312    }
14313    #[repr(C)]
14314    #[derive(Clone, Copy)]
14315    pub struct wire_cst_check_message_response {
14316        is_valid: bool,
14317    }
14318    #[repr(C)]
14319    #[derive(Clone, Copy)]
14320    pub struct wire_cst_config {
14321        liquid_explorer: wire_cst_blockchain_explorer,
14322        bitcoin_explorer: wire_cst_blockchain_explorer,
14323        working_dir: *mut wire_cst_list_prim_u_8_strict,
14324        cache_dir: *mut wire_cst_list_prim_u_8_strict,
14325        network: i32,
14326        payment_timeout_sec: u64,
14327        sync_service_url: *mut wire_cst_list_prim_u_8_strict,
14328        zero_conf_max_amount_sat: *mut u64,
14329        breez_api_key: *mut wire_cst_list_prim_u_8_strict,
14330        external_input_parsers: *mut wire_cst_list_external_input_parser,
14331        use_default_external_input_parsers: bool,
14332        onchain_fee_rate_leeway_sat_per_vbyte: *mut u32,
14333        asset_metadata: *mut wire_cst_list_asset_metadata,
14334        sideswap_api_key: *mut wire_cst_list_prim_u_8_strict,
14335    }
14336    #[repr(C)]
14337    #[derive(Clone, Copy)]
14338    pub struct wire_cst_connect_request {
14339        config: wire_cst_config,
14340        mnemonic: *mut wire_cst_list_prim_u_8_strict,
14341        passphrase: *mut wire_cst_list_prim_u_8_strict,
14342        seed: *mut wire_cst_list_prim_u_8_strict,
14343    }
14344    #[repr(C)]
14345    #[derive(Clone, Copy)]
14346    pub struct wire_cst_create_bolt_12_invoice_request {
14347        offer: *mut wire_cst_list_prim_u_8_strict,
14348        invoice_request: *mut wire_cst_list_prim_u_8_strict,
14349    }
14350    #[repr(C)]
14351    #[derive(Clone, Copy)]
14352    pub struct wire_cst_create_bolt_12_invoice_response {
14353        invoice: *mut wire_cst_list_prim_u_8_strict,
14354    }
14355    #[repr(C)]
14356    #[derive(Clone, Copy)]
14357    pub struct wire_cst_currency_info {
14358        name: *mut wire_cst_list_prim_u_8_strict,
14359        fraction_size: u32,
14360        spacing: *mut u32,
14361        symbol: *mut wire_cst_symbol,
14362        uniq_symbol: *mut wire_cst_symbol,
14363        localized_name: *mut wire_cst_list_localized_name,
14364        locale_overrides: *mut wire_cst_list_locale_overrides,
14365    }
14366    #[repr(C)]
14367    #[derive(Clone, Copy)]
14368    pub struct wire_cst_external_input_parser {
14369        provider_id: *mut wire_cst_list_prim_u_8_strict,
14370        input_regex: *mut wire_cst_list_prim_u_8_strict,
14371        parser_url: *mut wire_cst_list_prim_u_8_strict,
14372    }
14373    #[repr(C)]
14374    #[derive(Clone, Copy)]
14375    pub struct wire_cst_fetch_payment_proposed_fees_request {
14376        swap_id: *mut wire_cst_list_prim_u_8_strict,
14377    }
14378    #[repr(C)]
14379    #[derive(Clone, Copy)]
14380    pub struct wire_cst_fetch_payment_proposed_fees_response {
14381        swap_id: *mut wire_cst_list_prim_u_8_strict,
14382        fees_sat: u64,
14383        payer_amount_sat: u64,
14384        receiver_amount_sat: u64,
14385    }
14386    #[repr(C)]
14387    #[derive(Clone, Copy)]
14388    pub struct wire_cst_fiat_currency {
14389        id: *mut wire_cst_list_prim_u_8_strict,
14390        info: wire_cst_currency_info,
14391    }
14392    #[repr(C)]
14393    #[derive(Clone, Copy)]
14394    pub struct wire_cst_get_info_response {
14395        wallet_info: wire_cst_wallet_info,
14396        blockchain_info: wire_cst_blockchain_info,
14397    }
14398    #[repr(C)]
14399    #[derive(Clone, Copy)]
14400    pub struct wire_cst_get_payment_request {
14401        tag: i32,
14402        kind: GetPaymentRequestKind,
14403    }
14404    #[repr(C)]
14405    #[derive(Clone, Copy)]
14406    pub union GetPaymentRequestKind {
14407        PaymentHash: wire_cst_GetPaymentRequest_PaymentHash,
14408        SwapId: wire_cst_GetPaymentRequest_SwapId,
14409        nil__: (),
14410    }
14411    #[repr(C)]
14412    #[derive(Clone, Copy)]
14413    pub struct wire_cst_GetPaymentRequest_PaymentHash {
14414        payment_hash: *mut wire_cst_list_prim_u_8_strict,
14415    }
14416    #[repr(C)]
14417    #[derive(Clone, Copy)]
14418    pub struct wire_cst_GetPaymentRequest_SwapId {
14419        swap_id: *mut wire_cst_list_prim_u_8_strict,
14420    }
14421    #[repr(C)]
14422    #[derive(Clone, Copy)]
14423    pub struct wire_cst_input_type {
14424        tag: i32,
14425        kind: InputTypeKind,
14426    }
14427    #[repr(C)]
14428    #[derive(Clone, Copy)]
14429    pub union InputTypeKind {
14430        BitcoinAddress: wire_cst_InputType_BitcoinAddress,
14431        LiquidAddress: wire_cst_InputType_LiquidAddress,
14432        Bolt11: wire_cst_InputType_Bolt11,
14433        Bolt12Offer: wire_cst_InputType_Bolt12Offer,
14434        NodeId: wire_cst_InputType_NodeId,
14435        Url: wire_cst_InputType_Url,
14436        LnUrlPay: wire_cst_InputType_LnUrlPay,
14437        LnUrlWithdraw: wire_cst_InputType_LnUrlWithdraw,
14438        LnUrlAuth: wire_cst_InputType_LnUrlAuth,
14439        LnUrlError: wire_cst_InputType_LnUrlError,
14440        nil__: (),
14441    }
14442    #[repr(C)]
14443    #[derive(Clone, Copy)]
14444    pub struct wire_cst_InputType_BitcoinAddress {
14445        address: *mut wire_cst_bitcoin_address_data,
14446    }
14447    #[repr(C)]
14448    #[derive(Clone, Copy)]
14449    pub struct wire_cst_InputType_LiquidAddress {
14450        address: *mut wire_cst_liquid_address_data,
14451    }
14452    #[repr(C)]
14453    #[derive(Clone, Copy)]
14454    pub struct wire_cst_InputType_Bolt11 {
14455        invoice: *mut wire_cst_ln_invoice,
14456    }
14457    #[repr(C)]
14458    #[derive(Clone, Copy)]
14459    pub struct wire_cst_InputType_Bolt12Offer {
14460        offer: *mut wire_cst_ln_offer,
14461        bip353_address: *mut wire_cst_list_prim_u_8_strict,
14462    }
14463    #[repr(C)]
14464    #[derive(Clone, Copy)]
14465    pub struct wire_cst_InputType_NodeId {
14466        node_id: *mut wire_cst_list_prim_u_8_strict,
14467    }
14468    #[repr(C)]
14469    #[derive(Clone, Copy)]
14470    pub struct wire_cst_InputType_Url {
14471        url: *mut wire_cst_list_prim_u_8_strict,
14472    }
14473    #[repr(C)]
14474    #[derive(Clone, Copy)]
14475    pub struct wire_cst_InputType_LnUrlPay {
14476        data: *mut wire_cst_ln_url_pay_request_data,
14477        bip353_address: *mut wire_cst_list_prim_u_8_strict,
14478    }
14479    #[repr(C)]
14480    #[derive(Clone, Copy)]
14481    pub struct wire_cst_InputType_LnUrlWithdraw {
14482        data: *mut wire_cst_ln_url_withdraw_request_data,
14483    }
14484    #[repr(C)]
14485    #[derive(Clone, Copy)]
14486    pub struct wire_cst_InputType_LnUrlAuth {
14487        data: *mut wire_cst_ln_url_auth_request_data,
14488    }
14489    #[repr(C)]
14490    #[derive(Clone, Copy)]
14491    pub struct wire_cst_InputType_LnUrlError {
14492        data: *mut wire_cst_ln_url_error_data,
14493    }
14494    #[repr(C)]
14495    #[derive(Clone, Copy)]
14496    pub struct wire_cst_lightning_payment_limits_response {
14497        send: wire_cst_limits,
14498        receive: wire_cst_limits,
14499    }
14500    #[repr(C)]
14501    #[derive(Clone, Copy)]
14502    pub struct wire_cst_limits {
14503        min_sat: u64,
14504        max_sat: u64,
14505        max_zero_conf_sat: u64,
14506    }
14507    #[repr(C)]
14508    #[derive(Clone, Copy)]
14509    pub struct wire_cst_liquid_address_data {
14510        address: *mut wire_cst_list_prim_u_8_strict,
14511        network: i32,
14512        asset_id: *mut wire_cst_list_prim_u_8_strict,
14513        amount: *mut f64,
14514        amount_sat: *mut u64,
14515        label: *mut wire_cst_list_prim_u_8_strict,
14516        message: *mut wire_cst_list_prim_u_8_strict,
14517    }
14518    #[repr(C)]
14519    #[derive(Clone, Copy)]
14520    pub struct wire_cst_list_String {
14521        ptr: *mut *mut wire_cst_list_prim_u_8_strict,
14522        len: i32,
14523    }
14524    #[repr(C)]
14525    #[derive(Clone, Copy)]
14526    pub struct wire_cst_list_asset_balance {
14527        ptr: *mut wire_cst_asset_balance,
14528        len: i32,
14529    }
14530    #[repr(C)]
14531    #[derive(Clone, Copy)]
14532    pub struct wire_cst_list_asset_metadata {
14533        ptr: *mut wire_cst_asset_metadata,
14534        len: i32,
14535    }
14536    #[repr(C)]
14537    #[derive(Clone, Copy)]
14538    pub struct wire_cst_list_external_input_parser {
14539        ptr: *mut wire_cst_external_input_parser,
14540        len: i32,
14541    }
14542    #[repr(C)]
14543    #[derive(Clone, Copy)]
14544    pub struct wire_cst_list_fiat_currency {
14545        ptr: *mut wire_cst_fiat_currency,
14546        len: i32,
14547    }
14548    #[repr(C)]
14549    #[derive(Clone, Copy)]
14550    pub struct wire_cst_list_ln_offer_blinded_path {
14551        ptr: *mut wire_cst_ln_offer_blinded_path,
14552        len: i32,
14553    }
14554    #[repr(C)]
14555    #[derive(Clone, Copy)]
14556    pub struct wire_cst_list_locale_overrides {
14557        ptr: *mut wire_cst_locale_overrides,
14558        len: i32,
14559    }
14560    #[repr(C)]
14561    #[derive(Clone, Copy)]
14562    pub struct wire_cst_list_localized_name {
14563        ptr: *mut wire_cst_localized_name,
14564        len: i32,
14565    }
14566    #[repr(C)]
14567    #[derive(Clone, Copy)]
14568    pub struct wire_cst_list_payment {
14569        ptr: *mut wire_cst_payment,
14570        len: i32,
14571    }
14572    #[repr(C)]
14573    #[derive(Clone, Copy)]
14574    pub struct wire_cst_list_payment_details {
14575        tag: i32,
14576        kind: ListPaymentDetailsKind,
14577    }
14578    #[repr(C)]
14579    #[derive(Clone, Copy)]
14580    pub union ListPaymentDetailsKind {
14581        Liquid: wire_cst_ListPaymentDetails_Liquid,
14582        Bitcoin: wire_cst_ListPaymentDetails_Bitcoin,
14583        nil__: (),
14584    }
14585    #[repr(C)]
14586    #[derive(Clone, Copy)]
14587    pub struct wire_cst_ListPaymentDetails_Liquid {
14588        asset_id: *mut wire_cst_list_prim_u_8_strict,
14589        destination: *mut wire_cst_list_prim_u_8_strict,
14590    }
14591    #[repr(C)]
14592    #[derive(Clone, Copy)]
14593    pub struct wire_cst_ListPaymentDetails_Bitcoin {
14594        address: *mut wire_cst_list_prim_u_8_strict,
14595    }
14596    #[repr(C)]
14597    #[derive(Clone, Copy)]
14598    pub struct wire_cst_list_payment_state {
14599        ptr: *mut i32,
14600        len: i32,
14601    }
14602    #[repr(C)]
14603    #[derive(Clone, Copy)]
14604    pub struct wire_cst_list_payment_type {
14605        ptr: *mut i32,
14606        len: i32,
14607    }
14608    #[repr(C)]
14609    #[derive(Clone, Copy)]
14610    pub struct wire_cst_list_payments_request {
14611        filters: *mut wire_cst_list_payment_type,
14612        states: *mut wire_cst_list_payment_state,
14613        from_timestamp: *mut i64,
14614        to_timestamp: *mut i64,
14615        offset: *mut u32,
14616        limit: *mut u32,
14617        details: *mut wire_cst_list_payment_details,
14618        sort_ascending: *mut bool,
14619    }
14620    #[repr(C)]
14621    #[derive(Clone, Copy)]
14622    pub struct wire_cst_list_prim_u_8_strict {
14623        ptr: *mut u8,
14624        len: i32,
14625    }
14626    #[repr(C)]
14627    #[derive(Clone, Copy)]
14628    pub struct wire_cst_list_rate {
14629        ptr: *mut wire_cst_rate,
14630        len: i32,
14631    }
14632    #[repr(C)]
14633    #[derive(Clone, Copy)]
14634    pub struct wire_cst_list_refundable_swap {
14635        ptr: *mut wire_cst_refundable_swap,
14636        len: i32,
14637    }
14638    #[repr(C)]
14639    #[derive(Clone, Copy)]
14640    pub struct wire_cst_list_route_hint {
14641        ptr: *mut wire_cst_route_hint,
14642        len: i32,
14643    }
14644    #[repr(C)]
14645    #[derive(Clone, Copy)]
14646    pub struct wire_cst_list_route_hint_hop {
14647        ptr: *mut wire_cst_route_hint_hop,
14648        len: i32,
14649    }
14650    #[repr(C)]
14651    #[derive(Clone, Copy)]
14652    pub struct wire_cst_ln_invoice {
14653        bolt11: *mut wire_cst_list_prim_u_8_strict,
14654        network: i32,
14655        payee_pubkey: *mut wire_cst_list_prim_u_8_strict,
14656        payment_hash: *mut wire_cst_list_prim_u_8_strict,
14657        description: *mut wire_cst_list_prim_u_8_strict,
14658        description_hash: *mut wire_cst_list_prim_u_8_strict,
14659        amount_msat: *mut u64,
14660        timestamp: u64,
14661        expiry: u64,
14662        routing_hints: *mut wire_cst_list_route_hint,
14663        payment_secret: *mut wire_cst_list_prim_u_8_strict,
14664        min_final_cltv_expiry_delta: u64,
14665    }
14666    #[repr(C)]
14667    #[derive(Clone, Copy)]
14668    pub struct wire_cst_ln_offer {
14669        offer: *mut wire_cst_list_prim_u_8_strict,
14670        chains: *mut wire_cst_list_String,
14671        min_amount: *mut wire_cst_amount,
14672        description: *mut wire_cst_list_prim_u_8_strict,
14673        absolute_expiry: *mut u64,
14674        issuer: *mut wire_cst_list_prim_u_8_strict,
14675        signing_pubkey: *mut wire_cst_list_prim_u_8_strict,
14676        paths: *mut wire_cst_list_ln_offer_blinded_path,
14677    }
14678    #[repr(C)]
14679    #[derive(Clone, Copy)]
14680    pub struct wire_cst_ln_offer_blinded_path {
14681        blinded_hops: *mut wire_cst_list_String,
14682    }
14683    #[repr(C)]
14684    #[derive(Clone, Copy)]
14685    pub struct wire_cst_ln_url_auth_error {
14686        tag: i32,
14687        kind: LnUrlAuthErrorKind,
14688    }
14689    #[repr(C)]
14690    #[derive(Clone, Copy)]
14691    pub union LnUrlAuthErrorKind {
14692        Generic: wire_cst_LnUrlAuthError_Generic,
14693        InvalidUri: wire_cst_LnUrlAuthError_InvalidUri,
14694        ServiceConnectivity: wire_cst_LnUrlAuthError_ServiceConnectivity,
14695        nil__: (),
14696    }
14697    #[repr(C)]
14698    #[derive(Clone, Copy)]
14699    pub struct wire_cst_LnUrlAuthError_Generic {
14700        err: *mut wire_cst_list_prim_u_8_strict,
14701    }
14702    #[repr(C)]
14703    #[derive(Clone, Copy)]
14704    pub struct wire_cst_LnUrlAuthError_InvalidUri {
14705        err: *mut wire_cst_list_prim_u_8_strict,
14706    }
14707    #[repr(C)]
14708    #[derive(Clone, Copy)]
14709    pub struct wire_cst_LnUrlAuthError_ServiceConnectivity {
14710        err: *mut wire_cst_list_prim_u_8_strict,
14711    }
14712    #[repr(C)]
14713    #[derive(Clone, Copy)]
14714    pub struct wire_cst_ln_url_auth_request_data {
14715        k1: *mut wire_cst_list_prim_u_8_strict,
14716        action: *mut wire_cst_list_prim_u_8_strict,
14717        domain: *mut wire_cst_list_prim_u_8_strict,
14718        url: *mut wire_cst_list_prim_u_8_strict,
14719    }
14720    #[repr(C)]
14721    #[derive(Clone, Copy)]
14722    pub struct wire_cst_ln_url_callback_status {
14723        tag: i32,
14724        kind: LnUrlCallbackStatusKind,
14725    }
14726    #[repr(C)]
14727    #[derive(Clone, Copy)]
14728    pub union LnUrlCallbackStatusKind {
14729        ErrorStatus: wire_cst_LnUrlCallbackStatus_ErrorStatus,
14730        nil__: (),
14731    }
14732    #[repr(C)]
14733    #[derive(Clone, Copy)]
14734    pub struct wire_cst_LnUrlCallbackStatus_ErrorStatus {
14735        data: *mut wire_cst_ln_url_error_data,
14736    }
14737    #[repr(C)]
14738    #[derive(Clone, Copy)]
14739    pub struct wire_cst_ln_url_error_data {
14740        reason: *mut wire_cst_list_prim_u_8_strict,
14741    }
14742    #[repr(C)]
14743    #[derive(Clone, Copy)]
14744    pub struct wire_cst_ln_url_info {
14745        ln_address: *mut wire_cst_list_prim_u_8_strict,
14746        lnurl_pay_comment: *mut wire_cst_list_prim_u_8_strict,
14747        lnurl_pay_domain: *mut wire_cst_list_prim_u_8_strict,
14748        lnurl_pay_metadata: *mut wire_cst_list_prim_u_8_strict,
14749        lnurl_pay_success_action: *mut wire_cst_success_action_processed,
14750        lnurl_pay_unprocessed_success_action: *mut wire_cst_success_action,
14751        lnurl_withdraw_endpoint: *mut wire_cst_list_prim_u_8_strict,
14752    }
14753    #[repr(C)]
14754    #[derive(Clone, Copy)]
14755    pub struct wire_cst_ln_url_pay_error {
14756        tag: i32,
14757        kind: LnUrlPayErrorKind,
14758    }
14759    #[repr(C)]
14760    #[derive(Clone, Copy)]
14761    pub union LnUrlPayErrorKind {
14762        Generic: wire_cst_LnUrlPayError_Generic,
14763        InsufficientBalance: wire_cst_LnUrlPayError_InsufficientBalance,
14764        InvalidAmount: wire_cst_LnUrlPayError_InvalidAmount,
14765        InvalidInvoice: wire_cst_LnUrlPayError_InvalidInvoice,
14766        InvalidNetwork: wire_cst_LnUrlPayError_InvalidNetwork,
14767        InvalidUri: wire_cst_LnUrlPayError_InvalidUri,
14768        InvoiceExpired: wire_cst_LnUrlPayError_InvoiceExpired,
14769        PaymentFailed: wire_cst_LnUrlPayError_PaymentFailed,
14770        PaymentTimeout: wire_cst_LnUrlPayError_PaymentTimeout,
14771        RouteNotFound: wire_cst_LnUrlPayError_RouteNotFound,
14772        RouteTooExpensive: wire_cst_LnUrlPayError_RouteTooExpensive,
14773        ServiceConnectivity: wire_cst_LnUrlPayError_ServiceConnectivity,
14774        nil__: (),
14775    }
14776    #[repr(C)]
14777    #[derive(Clone, Copy)]
14778    pub struct wire_cst_LnUrlPayError_Generic {
14779        err: *mut wire_cst_list_prim_u_8_strict,
14780    }
14781    #[repr(C)]
14782    #[derive(Clone, Copy)]
14783    pub struct wire_cst_LnUrlPayError_InsufficientBalance {
14784        err: *mut wire_cst_list_prim_u_8_strict,
14785    }
14786    #[repr(C)]
14787    #[derive(Clone, Copy)]
14788    pub struct wire_cst_LnUrlPayError_InvalidAmount {
14789        err: *mut wire_cst_list_prim_u_8_strict,
14790    }
14791    #[repr(C)]
14792    #[derive(Clone, Copy)]
14793    pub struct wire_cst_LnUrlPayError_InvalidInvoice {
14794        err: *mut wire_cst_list_prim_u_8_strict,
14795    }
14796    #[repr(C)]
14797    #[derive(Clone, Copy)]
14798    pub struct wire_cst_LnUrlPayError_InvalidNetwork {
14799        err: *mut wire_cst_list_prim_u_8_strict,
14800    }
14801    #[repr(C)]
14802    #[derive(Clone, Copy)]
14803    pub struct wire_cst_LnUrlPayError_InvalidUri {
14804        err: *mut wire_cst_list_prim_u_8_strict,
14805    }
14806    #[repr(C)]
14807    #[derive(Clone, Copy)]
14808    pub struct wire_cst_LnUrlPayError_InvoiceExpired {
14809        err: *mut wire_cst_list_prim_u_8_strict,
14810    }
14811    #[repr(C)]
14812    #[derive(Clone, Copy)]
14813    pub struct wire_cst_LnUrlPayError_PaymentFailed {
14814        err: *mut wire_cst_list_prim_u_8_strict,
14815    }
14816    #[repr(C)]
14817    #[derive(Clone, Copy)]
14818    pub struct wire_cst_LnUrlPayError_PaymentTimeout {
14819        err: *mut wire_cst_list_prim_u_8_strict,
14820    }
14821    #[repr(C)]
14822    #[derive(Clone, Copy)]
14823    pub struct wire_cst_LnUrlPayError_RouteNotFound {
14824        err: *mut wire_cst_list_prim_u_8_strict,
14825    }
14826    #[repr(C)]
14827    #[derive(Clone, Copy)]
14828    pub struct wire_cst_LnUrlPayError_RouteTooExpensive {
14829        err: *mut wire_cst_list_prim_u_8_strict,
14830    }
14831    #[repr(C)]
14832    #[derive(Clone, Copy)]
14833    pub struct wire_cst_LnUrlPayError_ServiceConnectivity {
14834        err: *mut wire_cst_list_prim_u_8_strict,
14835    }
14836    #[repr(C)]
14837    #[derive(Clone, Copy)]
14838    pub struct wire_cst_ln_url_pay_error_data {
14839        payment_hash: *mut wire_cst_list_prim_u_8_strict,
14840        reason: *mut wire_cst_list_prim_u_8_strict,
14841    }
14842    #[repr(C)]
14843    #[derive(Clone, Copy)]
14844    pub struct wire_cst_ln_url_pay_request {
14845        prepare_response: wire_cst_prepare_ln_url_pay_response,
14846    }
14847    #[repr(C)]
14848    #[derive(Clone, Copy)]
14849    pub struct wire_cst_ln_url_pay_request_data {
14850        callback: *mut wire_cst_list_prim_u_8_strict,
14851        min_sendable: u64,
14852        max_sendable: u64,
14853        metadata_str: *mut wire_cst_list_prim_u_8_strict,
14854        comment_allowed: u16,
14855        domain: *mut wire_cst_list_prim_u_8_strict,
14856        allows_nostr: bool,
14857        nostr_pubkey: *mut wire_cst_list_prim_u_8_strict,
14858        ln_address: *mut wire_cst_list_prim_u_8_strict,
14859    }
14860    #[repr(C)]
14861    #[derive(Clone, Copy)]
14862    pub struct wire_cst_ln_url_pay_result {
14863        tag: i32,
14864        kind: LnUrlPayResultKind,
14865    }
14866    #[repr(C)]
14867    #[derive(Clone, Copy)]
14868    pub union LnUrlPayResultKind {
14869        EndpointSuccess: wire_cst_LnUrlPayResult_EndpointSuccess,
14870        EndpointError: wire_cst_LnUrlPayResult_EndpointError,
14871        PayError: wire_cst_LnUrlPayResult_PayError,
14872        nil__: (),
14873    }
14874    #[repr(C)]
14875    #[derive(Clone, Copy)]
14876    pub struct wire_cst_LnUrlPayResult_EndpointSuccess {
14877        data: *mut wire_cst_ln_url_pay_success_data,
14878    }
14879    #[repr(C)]
14880    #[derive(Clone, Copy)]
14881    pub struct wire_cst_LnUrlPayResult_EndpointError {
14882        data: *mut wire_cst_ln_url_error_data,
14883    }
14884    #[repr(C)]
14885    #[derive(Clone, Copy)]
14886    pub struct wire_cst_LnUrlPayResult_PayError {
14887        data: *mut wire_cst_ln_url_pay_error_data,
14888    }
14889    #[repr(C)]
14890    #[derive(Clone, Copy)]
14891    pub struct wire_cst_ln_url_pay_success_data {
14892        payment: wire_cst_payment,
14893        success_action: *mut wire_cst_success_action_processed,
14894    }
14895    #[repr(C)]
14896    #[derive(Clone, Copy)]
14897    pub struct wire_cst_ln_url_withdraw_error {
14898        tag: i32,
14899        kind: LnUrlWithdrawErrorKind,
14900    }
14901    #[repr(C)]
14902    #[derive(Clone, Copy)]
14903    pub union LnUrlWithdrawErrorKind {
14904        Generic: wire_cst_LnUrlWithdrawError_Generic,
14905        InvalidAmount: wire_cst_LnUrlWithdrawError_InvalidAmount,
14906        InvalidInvoice: wire_cst_LnUrlWithdrawError_InvalidInvoice,
14907        InvalidUri: wire_cst_LnUrlWithdrawError_InvalidUri,
14908        InvoiceNoRoutingHints: wire_cst_LnUrlWithdrawError_InvoiceNoRoutingHints,
14909        ServiceConnectivity: wire_cst_LnUrlWithdrawError_ServiceConnectivity,
14910        nil__: (),
14911    }
14912    #[repr(C)]
14913    #[derive(Clone, Copy)]
14914    pub struct wire_cst_LnUrlWithdrawError_Generic {
14915        err: *mut wire_cst_list_prim_u_8_strict,
14916    }
14917    #[repr(C)]
14918    #[derive(Clone, Copy)]
14919    pub struct wire_cst_LnUrlWithdrawError_InvalidAmount {
14920        err: *mut wire_cst_list_prim_u_8_strict,
14921    }
14922    #[repr(C)]
14923    #[derive(Clone, Copy)]
14924    pub struct wire_cst_LnUrlWithdrawError_InvalidInvoice {
14925        err: *mut wire_cst_list_prim_u_8_strict,
14926    }
14927    #[repr(C)]
14928    #[derive(Clone, Copy)]
14929    pub struct wire_cst_LnUrlWithdrawError_InvalidUri {
14930        err: *mut wire_cst_list_prim_u_8_strict,
14931    }
14932    #[repr(C)]
14933    #[derive(Clone, Copy)]
14934    pub struct wire_cst_LnUrlWithdrawError_InvoiceNoRoutingHints {
14935        err: *mut wire_cst_list_prim_u_8_strict,
14936    }
14937    #[repr(C)]
14938    #[derive(Clone, Copy)]
14939    pub struct wire_cst_LnUrlWithdrawError_ServiceConnectivity {
14940        err: *mut wire_cst_list_prim_u_8_strict,
14941    }
14942    #[repr(C)]
14943    #[derive(Clone, Copy)]
14944    pub struct wire_cst_ln_url_withdraw_request {
14945        data: wire_cst_ln_url_withdraw_request_data,
14946        amount_msat: u64,
14947        description: *mut wire_cst_list_prim_u_8_strict,
14948    }
14949    #[repr(C)]
14950    #[derive(Clone, Copy)]
14951    pub struct wire_cst_ln_url_withdraw_request_data {
14952        callback: *mut wire_cst_list_prim_u_8_strict,
14953        k1: *mut wire_cst_list_prim_u_8_strict,
14954        default_description: *mut wire_cst_list_prim_u_8_strict,
14955        min_withdrawable: u64,
14956        max_withdrawable: u64,
14957    }
14958    #[repr(C)]
14959    #[derive(Clone, Copy)]
14960    pub struct wire_cst_ln_url_withdraw_result {
14961        tag: i32,
14962        kind: LnUrlWithdrawResultKind,
14963    }
14964    #[repr(C)]
14965    #[derive(Clone, Copy)]
14966    pub union LnUrlWithdrawResultKind {
14967        Ok: wire_cst_LnUrlWithdrawResult_Ok,
14968        Timeout: wire_cst_LnUrlWithdrawResult_Timeout,
14969        ErrorStatus: wire_cst_LnUrlWithdrawResult_ErrorStatus,
14970        nil__: (),
14971    }
14972    #[repr(C)]
14973    #[derive(Clone, Copy)]
14974    pub struct wire_cst_LnUrlWithdrawResult_Ok {
14975        data: *mut wire_cst_ln_url_withdraw_success_data,
14976    }
14977    #[repr(C)]
14978    #[derive(Clone, Copy)]
14979    pub struct wire_cst_LnUrlWithdrawResult_Timeout {
14980        data: *mut wire_cst_ln_url_withdraw_success_data,
14981    }
14982    #[repr(C)]
14983    #[derive(Clone, Copy)]
14984    pub struct wire_cst_LnUrlWithdrawResult_ErrorStatus {
14985        data: *mut wire_cst_ln_url_error_data,
14986    }
14987    #[repr(C)]
14988    #[derive(Clone, Copy)]
14989    pub struct wire_cst_ln_url_withdraw_success_data {
14990        invoice: wire_cst_ln_invoice,
14991    }
14992    #[repr(C)]
14993    #[derive(Clone, Copy)]
14994    pub struct wire_cst_locale_overrides {
14995        locale: *mut wire_cst_list_prim_u_8_strict,
14996        spacing: *mut u32,
14997        symbol: wire_cst_symbol,
14998    }
14999    #[repr(C)]
15000    #[derive(Clone, Copy)]
15001    pub struct wire_cst_localized_name {
15002        locale: *mut wire_cst_list_prim_u_8_strict,
15003        name: *mut wire_cst_list_prim_u_8_strict,
15004    }
15005    #[repr(C)]
15006    #[derive(Clone, Copy)]
15007    pub struct wire_cst_log_entry {
15008        line: *mut wire_cst_list_prim_u_8_strict,
15009        level: *mut wire_cst_list_prim_u_8_strict,
15010    }
15011    #[repr(C)]
15012    #[derive(Clone, Copy)]
15013    pub struct wire_cst_message_success_action_data {
15014        message: *mut wire_cst_list_prim_u_8_strict,
15015    }
15016    #[repr(C)]
15017    #[derive(Clone, Copy)]
15018    pub struct wire_cst_onchain_payment_limits_response {
15019        send: wire_cst_limits,
15020        receive: wire_cst_limits,
15021    }
15022    #[repr(C)]
15023    #[derive(Clone, Copy)]
15024    pub struct wire_cst_pay_amount {
15025        tag: i32,
15026        kind: PayAmountKind,
15027    }
15028    #[repr(C)]
15029    #[derive(Clone, Copy)]
15030    pub union PayAmountKind {
15031        Bitcoin: wire_cst_PayAmount_Bitcoin,
15032        Asset: wire_cst_PayAmount_Asset,
15033        nil__: (),
15034    }
15035    #[repr(C)]
15036    #[derive(Clone, Copy)]
15037    pub struct wire_cst_PayAmount_Bitcoin {
15038        receiver_amount_sat: u64,
15039    }
15040    #[repr(C)]
15041    #[derive(Clone, Copy)]
15042    pub struct wire_cst_PayAmount_Asset {
15043        asset_id: *mut wire_cst_list_prim_u_8_strict,
15044        receiver_amount: f64,
15045        estimate_asset_fees: *mut bool,
15046    }
15047    #[repr(C)]
15048    #[derive(Clone, Copy)]
15049    pub struct wire_cst_pay_onchain_request {
15050        address: *mut wire_cst_list_prim_u_8_strict,
15051        prepare_response: wire_cst_prepare_pay_onchain_response,
15052    }
15053    #[repr(C)]
15054    #[derive(Clone, Copy)]
15055    pub struct wire_cst_payment {
15056        destination: *mut wire_cst_list_prim_u_8_strict,
15057        tx_id: *mut wire_cst_list_prim_u_8_strict,
15058        unblinding_data: *mut wire_cst_list_prim_u_8_strict,
15059        timestamp: u32,
15060        amount_sat: u64,
15061        fees_sat: u64,
15062        swapper_fees_sat: *mut u64,
15063        payment_type: i32,
15064        status: i32,
15065        details: wire_cst_payment_details,
15066    }
15067    #[repr(C)]
15068    #[derive(Clone, Copy)]
15069    pub struct wire_cst_payment_details {
15070        tag: i32,
15071        kind: PaymentDetailsKind,
15072    }
15073    #[repr(C)]
15074    #[derive(Clone, Copy)]
15075    pub union PaymentDetailsKind {
15076        Lightning: wire_cst_PaymentDetails_Lightning,
15077        Liquid: wire_cst_PaymentDetails_Liquid,
15078        Bitcoin: wire_cst_PaymentDetails_Bitcoin,
15079        nil__: (),
15080    }
15081    #[repr(C)]
15082    #[derive(Clone, Copy)]
15083    pub struct wire_cst_PaymentDetails_Lightning {
15084        swap_id: *mut wire_cst_list_prim_u_8_strict,
15085        description: *mut wire_cst_list_prim_u_8_strict,
15086        liquid_expiration_blockheight: u32,
15087        preimage: *mut wire_cst_list_prim_u_8_strict,
15088        invoice: *mut wire_cst_list_prim_u_8_strict,
15089        bolt12_offer: *mut wire_cst_list_prim_u_8_strict,
15090        payment_hash: *mut wire_cst_list_prim_u_8_strict,
15091        destination_pubkey: *mut wire_cst_list_prim_u_8_strict,
15092        lnurl_info: *mut wire_cst_ln_url_info,
15093        bip353_address: *mut wire_cst_list_prim_u_8_strict,
15094        claim_tx_id: *mut wire_cst_list_prim_u_8_strict,
15095        refund_tx_id: *mut wire_cst_list_prim_u_8_strict,
15096        refund_tx_amount_sat: *mut u64,
15097    }
15098    #[repr(C)]
15099    #[derive(Clone, Copy)]
15100    pub struct wire_cst_PaymentDetails_Liquid {
15101        destination: *mut wire_cst_list_prim_u_8_strict,
15102        description: *mut wire_cst_list_prim_u_8_strict,
15103        asset_id: *mut wire_cst_list_prim_u_8_strict,
15104        asset_info: *mut wire_cst_asset_info,
15105        lnurl_info: *mut wire_cst_ln_url_info,
15106        bip353_address: *mut wire_cst_list_prim_u_8_strict,
15107    }
15108    #[repr(C)]
15109    #[derive(Clone, Copy)]
15110    pub struct wire_cst_PaymentDetails_Bitcoin {
15111        swap_id: *mut wire_cst_list_prim_u_8_strict,
15112        description: *mut wire_cst_list_prim_u_8_strict,
15113        auto_accepted_fees: bool,
15114        liquid_expiration_blockheight: *mut u32,
15115        bitcoin_expiration_blockheight: *mut u32,
15116        lockup_tx_id: *mut wire_cst_list_prim_u_8_strict,
15117        claim_tx_id: *mut wire_cst_list_prim_u_8_strict,
15118        refund_tx_id: *mut wire_cst_list_prim_u_8_strict,
15119        refund_tx_amount_sat: *mut u64,
15120    }
15121    #[repr(C)]
15122    #[derive(Clone, Copy)]
15123    pub struct wire_cst_payment_error {
15124        tag: i32,
15125        kind: PaymentErrorKind,
15126    }
15127    #[repr(C)]
15128    #[derive(Clone, Copy)]
15129    pub union PaymentErrorKind {
15130        AmountOutOfRange: wire_cst_PaymentError_AmountOutOfRange,
15131        AmountMissing: wire_cst_PaymentError_AmountMissing,
15132        AssetError: wire_cst_PaymentError_AssetError,
15133        InvalidNetwork: wire_cst_PaymentError_InvalidNetwork,
15134        Generic: wire_cst_PaymentError_Generic,
15135        InvalidDescription: wire_cst_PaymentError_InvalidDescription,
15136        InvalidInvoice: wire_cst_PaymentError_InvalidInvoice,
15137        ReceiveError: wire_cst_PaymentError_ReceiveError,
15138        Refunded: wire_cst_PaymentError_Refunded,
15139        SendError: wire_cst_PaymentError_SendError,
15140        SignerError: wire_cst_PaymentError_SignerError,
15141        nil__: (),
15142    }
15143    #[repr(C)]
15144    #[derive(Clone, Copy)]
15145    pub struct wire_cst_PaymentError_AmountOutOfRange {
15146        min: u64,
15147        max: u64,
15148    }
15149    #[repr(C)]
15150    #[derive(Clone, Copy)]
15151    pub struct wire_cst_PaymentError_AmountMissing {
15152        err: *mut wire_cst_list_prim_u_8_strict,
15153    }
15154    #[repr(C)]
15155    #[derive(Clone, Copy)]
15156    pub struct wire_cst_PaymentError_AssetError {
15157        err: *mut wire_cst_list_prim_u_8_strict,
15158    }
15159    #[repr(C)]
15160    #[derive(Clone, Copy)]
15161    pub struct wire_cst_PaymentError_InvalidNetwork {
15162        err: *mut wire_cst_list_prim_u_8_strict,
15163    }
15164    #[repr(C)]
15165    #[derive(Clone, Copy)]
15166    pub struct wire_cst_PaymentError_Generic {
15167        err: *mut wire_cst_list_prim_u_8_strict,
15168    }
15169    #[repr(C)]
15170    #[derive(Clone, Copy)]
15171    pub struct wire_cst_PaymentError_InvalidDescription {
15172        err: *mut wire_cst_list_prim_u_8_strict,
15173    }
15174    #[repr(C)]
15175    #[derive(Clone, Copy)]
15176    pub struct wire_cst_PaymentError_InvalidInvoice {
15177        err: *mut wire_cst_list_prim_u_8_strict,
15178    }
15179    #[repr(C)]
15180    #[derive(Clone, Copy)]
15181    pub struct wire_cst_PaymentError_ReceiveError {
15182        err: *mut wire_cst_list_prim_u_8_strict,
15183    }
15184    #[repr(C)]
15185    #[derive(Clone, Copy)]
15186    pub struct wire_cst_PaymentError_Refunded {
15187        err: *mut wire_cst_list_prim_u_8_strict,
15188        refund_tx_id: *mut wire_cst_list_prim_u_8_strict,
15189    }
15190    #[repr(C)]
15191    #[derive(Clone, Copy)]
15192    pub struct wire_cst_PaymentError_SendError {
15193        err: *mut wire_cst_list_prim_u_8_strict,
15194    }
15195    #[repr(C)]
15196    #[derive(Clone, Copy)]
15197    pub struct wire_cst_PaymentError_SignerError {
15198        err: *mut wire_cst_list_prim_u_8_strict,
15199    }
15200    #[repr(C)]
15201    #[derive(Clone, Copy)]
15202    pub struct wire_cst_prepare_buy_bitcoin_request {
15203        provider: i32,
15204        amount_sat: u64,
15205    }
15206    #[repr(C)]
15207    #[derive(Clone, Copy)]
15208    pub struct wire_cst_prepare_buy_bitcoin_response {
15209        provider: i32,
15210        amount_sat: u64,
15211        fees_sat: u64,
15212    }
15213    #[repr(C)]
15214    #[derive(Clone, Copy)]
15215    pub struct wire_cst_prepare_ln_url_pay_request {
15216        data: wire_cst_ln_url_pay_request_data,
15217        amount: wire_cst_pay_amount,
15218        bip353_address: *mut wire_cst_list_prim_u_8_strict,
15219        comment: *mut wire_cst_list_prim_u_8_strict,
15220        validate_success_action_url: *mut bool,
15221    }
15222    #[repr(C)]
15223    #[derive(Clone, Copy)]
15224    pub struct wire_cst_prepare_ln_url_pay_response {
15225        destination: wire_cst_send_destination,
15226        fees_sat: u64,
15227        data: wire_cst_ln_url_pay_request_data,
15228        amount: wire_cst_pay_amount,
15229        comment: *mut wire_cst_list_prim_u_8_strict,
15230        success_action: *mut wire_cst_success_action,
15231    }
15232    #[repr(C)]
15233    #[derive(Clone, Copy)]
15234    pub struct wire_cst_prepare_pay_onchain_request {
15235        amount: wire_cst_pay_amount,
15236        fee_rate_sat_per_vbyte: *mut u32,
15237    }
15238    #[repr(C)]
15239    #[derive(Clone, Copy)]
15240    pub struct wire_cst_prepare_pay_onchain_response {
15241        receiver_amount_sat: u64,
15242        claim_fees_sat: u64,
15243        total_fees_sat: u64,
15244    }
15245    #[repr(C)]
15246    #[derive(Clone, Copy)]
15247    pub struct wire_cst_prepare_receive_request {
15248        payment_method: i32,
15249        amount: *mut wire_cst_receive_amount,
15250    }
15251    #[repr(C)]
15252    #[derive(Clone, Copy)]
15253    pub struct wire_cst_prepare_receive_response {
15254        payment_method: i32,
15255        fees_sat: u64,
15256        amount: *mut wire_cst_receive_amount,
15257        min_payer_amount_sat: *mut u64,
15258        max_payer_amount_sat: *mut u64,
15259        swapper_feerate: *mut f64,
15260    }
15261    #[repr(C)]
15262    #[derive(Clone, Copy)]
15263    pub struct wire_cst_prepare_refund_request {
15264        swap_address: *mut wire_cst_list_prim_u_8_strict,
15265        refund_address: *mut wire_cst_list_prim_u_8_strict,
15266        fee_rate_sat_per_vbyte: u32,
15267    }
15268    #[repr(C)]
15269    #[derive(Clone, Copy)]
15270    pub struct wire_cst_prepare_refund_response {
15271        tx_vsize: u32,
15272        tx_fee_sat: u64,
15273        last_refund_tx_id: *mut wire_cst_list_prim_u_8_strict,
15274    }
15275    #[repr(C)]
15276    #[derive(Clone, Copy)]
15277    pub struct wire_cst_prepare_send_request {
15278        destination: *mut wire_cst_list_prim_u_8_strict,
15279        amount: *mut wire_cst_pay_amount,
15280    }
15281    #[repr(C)]
15282    #[derive(Clone, Copy)]
15283    pub struct wire_cst_prepare_send_response {
15284        destination: wire_cst_send_destination,
15285        amount: *mut wire_cst_pay_amount,
15286        fees_sat: *mut u64,
15287        estimated_asset_fees: *mut f64,
15288    }
15289    #[repr(C)]
15290    #[derive(Clone, Copy)]
15291    pub struct wire_cst_rate {
15292        coin: *mut wire_cst_list_prim_u_8_strict,
15293        value: f64,
15294    }
15295    #[repr(C)]
15296    #[derive(Clone, Copy)]
15297    pub struct wire_cst_receive_amount {
15298        tag: i32,
15299        kind: ReceiveAmountKind,
15300    }
15301    #[repr(C)]
15302    #[derive(Clone, Copy)]
15303    pub union ReceiveAmountKind {
15304        Bitcoin: wire_cst_ReceiveAmount_Bitcoin,
15305        Asset: wire_cst_ReceiveAmount_Asset,
15306        nil__: (),
15307    }
15308    #[repr(C)]
15309    #[derive(Clone, Copy)]
15310    pub struct wire_cst_ReceiveAmount_Bitcoin {
15311        payer_amount_sat: u64,
15312    }
15313    #[repr(C)]
15314    #[derive(Clone, Copy)]
15315    pub struct wire_cst_ReceiveAmount_Asset {
15316        asset_id: *mut wire_cst_list_prim_u_8_strict,
15317        payer_amount: *mut f64,
15318    }
15319    #[repr(C)]
15320    #[derive(Clone, Copy)]
15321    pub struct wire_cst_receive_payment_request {
15322        prepare_response: wire_cst_prepare_receive_response,
15323        description: *mut wire_cst_list_prim_u_8_strict,
15324        use_description_hash: *mut bool,
15325    }
15326    #[repr(C)]
15327    #[derive(Clone, Copy)]
15328    pub struct wire_cst_receive_payment_response {
15329        destination: *mut wire_cst_list_prim_u_8_strict,
15330    }
15331    #[repr(C)]
15332    #[derive(Clone, Copy)]
15333    pub struct wire_cst_recommended_fees {
15334        fastest_fee: u64,
15335        half_hour_fee: u64,
15336        hour_fee: u64,
15337        economy_fee: u64,
15338        minimum_fee: u64,
15339    }
15340    #[repr(C)]
15341    #[derive(Clone, Copy)]
15342    pub struct wire_cst_refund_request {
15343        swap_address: *mut wire_cst_list_prim_u_8_strict,
15344        refund_address: *mut wire_cst_list_prim_u_8_strict,
15345        fee_rate_sat_per_vbyte: u32,
15346    }
15347    #[repr(C)]
15348    #[derive(Clone, Copy)]
15349    pub struct wire_cst_refund_response {
15350        refund_tx_id: *mut wire_cst_list_prim_u_8_strict,
15351    }
15352    #[repr(C)]
15353    #[derive(Clone, Copy)]
15354    pub struct wire_cst_refundable_swap {
15355        swap_address: *mut wire_cst_list_prim_u_8_strict,
15356        timestamp: u32,
15357        amount_sat: u64,
15358        last_refund_tx_id: *mut wire_cst_list_prim_u_8_strict,
15359    }
15360    #[repr(C)]
15361    #[derive(Clone, Copy)]
15362    pub struct wire_cst_restore_request {
15363        backup_path: *mut wire_cst_list_prim_u_8_strict,
15364    }
15365    #[repr(C)]
15366    #[derive(Clone, Copy)]
15367    pub struct wire_cst_route_hint {
15368        hops: *mut wire_cst_list_route_hint_hop,
15369    }
15370    #[repr(C)]
15371    #[derive(Clone, Copy)]
15372    pub struct wire_cst_route_hint_hop {
15373        src_node_id: *mut wire_cst_list_prim_u_8_strict,
15374        short_channel_id: *mut wire_cst_list_prim_u_8_strict,
15375        fees_base_msat: u32,
15376        fees_proportional_millionths: u32,
15377        cltv_expiry_delta: u64,
15378        htlc_minimum_msat: *mut u64,
15379        htlc_maximum_msat: *mut u64,
15380    }
15381    #[repr(C)]
15382    #[derive(Clone, Copy)]
15383    pub struct wire_cst_sdk_error {
15384        tag: i32,
15385        kind: SdkErrorKind,
15386    }
15387    #[repr(C)]
15388    #[derive(Clone, Copy)]
15389    pub union SdkErrorKind {
15390        Generic: wire_cst_SdkError_Generic,
15391        ServiceConnectivity: wire_cst_SdkError_ServiceConnectivity,
15392        nil__: (),
15393    }
15394    #[repr(C)]
15395    #[derive(Clone, Copy)]
15396    pub struct wire_cst_SdkError_Generic {
15397        err: *mut wire_cst_list_prim_u_8_strict,
15398    }
15399    #[repr(C)]
15400    #[derive(Clone, Copy)]
15401    pub struct wire_cst_SdkError_ServiceConnectivity {
15402        err: *mut wire_cst_list_prim_u_8_strict,
15403    }
15404    #[repr(C)]
15405    #[derive(Clone, Copy)]
15406    pub struct wire_cst_sdk_event {
15407        tag: i32,
15408        kind: SdkEventKind,
15409    }
15410    #[repr(C)]
15411    #[derive(Clone, Copy)]
15412    pub union SdkEventKind {
15413        PaymentFailed: wire_cst_SdkEvent_PaymentFailed,
15414        PaymentPending: wire_cst_SdkEvent_PaymentPending,
15415        PaymentRefundable: wire_cst_SdkEvent_PaymentRefundable,
15416        PaymentRefunded: wire_cst_SdkEvent_PaymentRefunded,
15417        PaymentRefundPending: wire_cst_SdkEvent_PaymentRefundPending,
15418        PaymentSucceeded: wire_cst_SdkEvent_PaymentSucceeded,
15419        PaymentWaitingConfirmation: wire_cst_SdkEvent_PaymentWaitingConfirmation,
15420        PaymentWaitingFeeAcceptance: wire_cst_SdkEvent_PaymentWaitingFeeAcceptance,
15421        DataSynced: wire_cst_SdkEvent_DataSynced,
15422        nil__: (),
15423    }
15424    #[repr(C)]
15425    #[derive(Clone, Copy)]
15426    pub struct wire_cst_SdkEvent_PaymentFailed {
15427        details: *mut wire_cst_payment,
15428    }
15429    #[repr(C)]
15430    #[derive(Clone, Copy)]
15431    pub struct wire_cst_SdkEvent_PaymentPending {
15432        details: *mut wire_cst_payment,
15433    }
15434    #[repr(C)]
15435    #[derive(Clone, Copy)]
15436    pub struct wire_cst_SdkEvent_PaymentRefundable {
15437        details: *mut wire_cst_payment,
15438    }
15439    #[repr(C)]
15440    #[derive(Clone, Copy)]
15441    pub struct wire_cst_SdkEvent_PaymentRefunded {
15442        details: *mut wire_cst_payment,
15443    }
15444    #[repr(C)]
15445    #[derive(Clone, Copy)]
15446    pub struct wire_cst_SdkEvent_PaymentRefundPending {
15447        details: *mut wire_cst_payment,
15448    }
15449    #[repr(C)]
15450    #[derive(Clone, Copy)]
15451    pub struct wire_cst_SdkEvent_PaymentSucceeded {
15452        details: *mut wire_cst_payment,
15453    }
15454    #[repr(C)]
15455    #[derive(Clone, Copy)]
15456    pub struct wire_cst_SdkEvent_PaymentWaitingConfirmation {
15457        details: *mut wire_cst_payment,
15458    }
15459    #[repr(C)]
15460    #[derive(Clone, Copy)]
15461    pub struct wire_cst_SdkEvent_PaymentWaitingFeeAcceptance {
15462        details: *mut wire_cst_payment,
15463    }
15464    #[repr(C)]
15465    #[derive(Clone, Copy)]
15466    pub struct wire_cst_SdkEvent_DataSynced {
15467        did_pull_new_records: bool,
15468    }
15469    #[repr(C)]
15470    #[derive(Clone, Copy)]
15471    pub struct wire_cst_send_destination {
15472        tag: i32,
15473        kind: SendDestinationKind,
15474    }
15475    #[repr(C)]
15476    #[derive(Clone, Copy)]
15477    pub union SendDestinationKind {
15478        LiquidAddress: wire_cst_SendDestination_LiquidAddress,
15479        Bolt11: wire_cst_SendDestination_Bolt11,
15480        Bolt12: wire_cst_SendDestination_Bolt12,
15481        nil__: (),
15482    }
15483    #[repr(C)]
15484    #[derive(Clone, Copy)]
15485    pub struct wire_cst_SendDestination_LiquidAddress {
15486        address_data: *mut wire_cst_liquid_address_data,
15487        bip353_address: *mut wire_cst_list_prim_u_8_strict,
15488    }
15489    #[repr(C)]
15490    #[derive(Clone, Copy)]
15491    pub struct wire_cst_SendDestination_Bolt11 {
15492        invoice: *mut wire_cst_ln_invoice,
15493        bip353_address: *mut wire_cst_list_prim_u_8_strict,
15494    }
15495    #[repr(C)]
15496    #[derive(Clone, Copy)]
15497    pub struct wire_cst_SendDestination_Bolt12 {
15498        offer: *mut wire_cst_ln_offer,
15499        receiver_amount_sat: u64,
15500        bip353_address: *mut wire_cst_list_prim_u_8_strict,
15501    }
15502    #[repr(C)]
15503    #[derive(Clone, Copy)]
15504    pub struct wire_cst_send_payment_request {
15505        prepare_response: wire_cst_prepare_send_response,
15506        use_asset_fees: *mut bool,
15507    }
15508    #[repr(C)]
15509    #[derive(Clone, Copy)]
15510    pub struct wire_cst_send_payment_response {
15511        payment: wire_cst_payment,
15512    }
15513    #[repr(C)]
15514    #[derive(Clone, Copy)]
15515    pub struct wire_cst_sign_message_request {
15516        message: *mut wire_cst_list_prim_u_8_strict,
15517    }
15518    #[repr(C)]
15519    #[derive(Clone, Copy)]
15520    pub struct wire_cst_sign_message_response {
15521        signature: *mut wire_cst_list_prim_u_8_strict,
15522    }
15523    #[repr(C)]
15524    #[derive(Clone, Copy)]
15525    pub struct wire_cst_success_action {
15526        tag: i32,
15527        kind: SuccessActionKind,
15528    }
15529    #[repr(C)]
15530    #[derive(Clone, Copy)]
15531    pub union SuccessActionKind {
15532        Aes: wire_cst_SuccessAction_Aes,
15533        Message: wire_cst_SuccessAction_Message,
15534        Url: wire_cst_SuccessAction_Url,
15535        nil__: (),
15536    }
15537    #[repr(C)]
15538    #[derive(Clone, Copy)]
15539    pub struct wire_cst_SuccessAction_Aes {
15540        data: *mut wire_cst_aes_success_action_data,
15541    }
15542    #[repr(C)]
15543    #[derive(Clone, Copy)]
15544    pub struct wire_cst_SuccessAction_Message {
15545        data: *mut wire_cst_message_success_action_data,
15546    }
15547    #[repr(C)]
15548    #[derive(Clone, Copy)]
15549    pub struct wire_cst_SuccessAction_Url {
15550        data: *mut wire_cst_url_success_action_data,
15551    }
15552    #[repr(C)]
15553    #[derive(Clone, Copy)]
15554    pub struct wire_cst_success_action_processed {
15555        tag: i32,
15556        kind: SuccessActionProcessedKind,
15557    }
15558    #[repr(C)]
15559    #[derive(Clone, Copy)]
15560    pub union SuccessActionProcessedKind {
15561        Aes: wire_cst_SuccessActionProcessed_Aes,
15562        Message: wire_cst_SuccessActionProcessed_Message,
15563        Url: wire_cst_SuccessActionProcessed_Url,
15564        nil__: (),
15565    }
15566    #[repr(C)]
15567    #[derive(Clone, Copy)]
15568    pub struct wire_cst_SuccessActionProcessed_Aes {
15569        result: *mut wire_cst_aes_success_action_data_result,
15570    }
15571    #[repr(C)]
15572    #[derive(Clone, Copy)]
15573    pub struct wire_cst_SuccessActionProcessed_Message {
15574        data: *mut wire_cst_message_success_action_data,
15575    }
15576    #[repr(C)]
15577    #[derive(Clone, Copy)]
15578    pub struct wire_cst_SuccessActionProcessed_Url {
15579        data: *mut wire_cst_url_success_action_data,
15580    }
15581    #[repr(C)]
15582    #[derive(Clone, Copy)]
15583    pub struct wire_cst_symbol {
15584        grapheme: *mut wire_cst_list_prim_u_8_strict,
15585        template: *mut wire_cst_list_prim_u_8_strict,
15586        rtl: *mut bool,
15587        position: *mut u32,
15588    }
15589    #[repr(C)]
15590    #[derive(Clone, Copy)]
15591    pub struct wire_cst_url_success_action_data {
15592        description: *mut wire_cst_list_prim_u_8_strict,
15593        url: *mut wire_cst_list_prim_u_8_strict,
15594        matches_callback_domain: bool,
15595    }
15596    #[repr(C)]
15597    #[derive(Clone, Copy)]
15598    pub struct wire_cst_wallet_info {
15599        balance_sat: u64,
15600        pending_send_sat: u64,
15601        pending_receive_sat: u64,
15602        fingerprint: *mut wire_cst_list_prim_u_8_strict,
15603        pubkey: *mut wire_cst_list_prim_u_8_strict,
15604        asset_balances: *mut wire_cst_list_asset_balance,
15605    }
15606}
15607#[cfg(not(target_family = "wasm"))]
15608pub use io::*;