breez_sdk_liquid/
frb_generated.rs

1// This file is automatically generated, so please do not edit it.
2// @generated by `flutter_rust_bridge`@ 2.9.0.
3
4#![allow(
5    non_camel_case_types,
6    unused,
7    non_snake_case,
8    clippy::needless_return,
9    clippy::redundant_closure_call,
10    clippy::redundant_closure,
11    clippy::useless_conversion,
12    clippy::unit_arg,
13    clippy::unused_unit,
14    clippy::double_parens,
15    clippy::let_and_return,
16    clippy::too_many_arguments,
17    clippy::match_single_binding,
18    clippy::clone_on_copy,
19    clippy::let_unit_value,
20    clippy::deref_addrof,
21    clippy::explicit_auto_deref,
22    clippy::borrow_deref_ref,
23    clippy::needless_borrow
24)]
25
26// Section: imports
27
28use crate::bindings::*;
29use crate::model::EventListener;
30use flutter_rust_bridge::for_generated::byteorder::{NativeEndian, ReadBytesExt, WriteBytesExt};
31use flutter_rust_bridge::for_generated::{transform_result_dco, Lifetimeable, Lockable};
32use flutter_rust_bridge::{Handler, IntoIntoDart};
33
34// Section: boilerplate
35
36flutter_rust_bridge::frb_generated_boilerplate!(
37    default_stream_sink_codec = DcoCodec,
38    default_rust_opaque = RustOpaqueNom,
39    default_rust_auto_opaque = RustAutoOpaqueNom,
40);
41pub(crate) const FLUTTER_RUST_BRIDGE_CODEGEN_VERSION: &str = "2.9.0";
42pub(crate) const FLUTTER_RUST_BRIDGE_CODEGEN_CONTENT_HASH: i32 = 464449310;
43
44// Section: executor
45
46flutter_rust_bridge::frb_generated_default_handler!();
47
48// Section: wire_funcs
49
50fn wire__crate__bindings__BindingLiquidSdk_accept_payment_proposed_fees_impl(
51    port_: flutter_rust_bridge::for_generated::MessagePort,
52    that: impl CstDecode<
53        RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
54    >,
55    req: impl CstDecode<crate::model::AcceptPaymentProposedFeesRequest>,
56) {
57    FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
58        flutter_rust_bridge::for_generated::TaskInfo {
59            debug_name: "BindingLiquidSdk_accept_payment_proposed_fees",
60            port: Some(port_),
61            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
62        },
63        move || {
64            let api_that = that.cst_decode();
65            let api_req = req.cst_decode();
66            move |context| async move {
67                transform_result_dco::<_, _, crate::error::PaymentError>(
68                    (move || async move {
69                        let mut api_that_guard = None;
70                        let decode_indices_ =
71                            flutter_rust_bridge::for_generated::lockable_compute_decode_order(
72                                vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
73                                    &api_that, 0, false,
74                                )],
75                            );
76                        for i in decode_indices_ {
77                            match i {
78                                0 => {
79                                    api_that_guard =
80                                        Some(api_that.lockable_decode_async_ref().await)
81                                }
82                                _ => unreachable!(),
83                            }
84                        }
85                        let api_that_guard = api_that_guard.unwrap();
86                        let output_ok =
87                            crate::bindings::BindingLiquidSdk::accept_payment_proposed_fees(
88                                &*api_that_guard,
89                                api_req,
90                            )
91                            .await?;
92                        Ok(output_ok)
93                    })()
94                    .await,
95                )
96            }
97        },
98    )
99}
100fn wire__crate__bindings__BindingLiquidSdk_add_event_listener_impl(
101    port_: flutter_rust_bridge::for_generated::MessagePort,
102    that: impl CstDecode<
103        RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
104    >,
105    listener: impl CstDecode<
106        StreamSink<crate::model::SdkEvent, flutter_rust_bridge::for_generated::DcoCodec>,
107    >,
108) {
109    FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
110        flutter_rust_bridge::for_generated::TaskInfo {
111            debug_name: "BindingLiquidSdk_add_event_listener",
112            port: Some(port_),
113            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
114        },
115        move || {
116            let api_that = that.cst_decode();
117            let api_listener = listener.cst_decode();
118            move |context| async move {
119                transform_result_dco::<_, _, crate::error::SdkError>(
120                    (move || async move {
121                        let mut api_that_guard = None;
122                        let decode_indices_ =
123                            flutter_rust_bridge::for_generated::lockable_compute_decode_order(
124                                vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
125                                    &api_that, 0, false,
126                                )],
127                            );
128                        for i in decode_indices_ {
129                            match i {
130                                0 => {
131                                    api_that_guard =
132                                        Some(api_that.lockable_decode_async_ref().await)
133                                }
134                                _ => unreachable!(),
135                            }
136                        }
137                        let api_that_guard = api_that_guard.unwrap();
138                        let output_ok = crate::bindings::BindingLiquidSdk::add_event_listener(
139                            &*api_that_guard,
140                            api_listener,
141                        )
142                        .await?;
143                        Ok(output_ok)
144                    })()
145                    .await,
146                )
147            }
148        },
149    )
150}
151fn wire__crate__bindings__BindingLiquidSdk_backup_impl(
152    that: impl CstDecode<
153        RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
154    >,
155    req: impl CstDecode<crate::model::BackupRequest>,
156) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
157    FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::DcoCodec, _>(
158        flutter_rust_bridge::for_generated::TaskInfo {
159            debug_name: "BindingLiquidSdk_backup",
160            port: None,
161            mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync,
162        },
163        move || {
164            let api_that = that.cst_decode();
165            let api_req = req.cst_decode();
166            transform_result_dco::<_, _, crate::error::SdkError>((move || {
167                let mut api_that_guard = None;
168                let decode_indices_ =
169                    flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![
170                        flutter_rust_bridge::for_generated::LockableOrderInfo::new(
171                            &api_that, 0, false,
172                        ),
173                    ]);
174                for i in decode_indices_ {
175                    match i {
176                        0 => api_that_guard = Some(api_that.lockable_decode_sync_ref()),
177                        _ => unreachable!(),
178                    }
179                }
180                let api_that_guard = api_that_guard.unwrap();
181                let output_ok =
182                    crate::bindings::BindingLiquidSdk::backup(&*api_that_guard, api_req)?;
183                Ok(output_ok)
184            })())
185        },
186    )
187}
188fn wire__crate__bindings__BindingLiquidSdk_buy_bitcoin_impl(
189    port_: flutter_rust_bridge::for_generated::MessagePort,
190    that: impl CstDecode<
191        RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
192    >,
193    req: impl CstDecode<crate::model::BuyBitcoinRequest>,
194) {
195    FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
196        flutter_rust_bridge::for_generated::TaskInfo {
197            debug_name: "BindingLiquidSdk_buy_bitcoin",
198            port: Some(port_),
199            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
200        },
201        move || {
202            let api_that = that.cst_decode();
203            let api_req = req.cst_decode();
204            move |context| async move {
205                transform_result_dco::<_, _, crate::error::PaymentError>(
206                    (move || async move {
207                        let mut api_that_guard = None;
208                        let decode_indices_ =
209                            flutter_rust_bridge::for_generated::lockable_compute_decode_order(
210                                vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
211                                    &api_that, 0, false,
212                                )],
213                            );
214                        for i in decode_indices_ {
215                            match i {
216                                0 => {
217                                    api_that_guard =
218                                        Some(api_that.lockable_decode_async_ref().await)
219                                }
220                                _ => unreachable!(),
221                            }
222                        }
223                        let api_that_guard = api_that_guard.unwrap();
224                        let output_ok = crate::bindings::BindingLiquidSdk::buy_bitcoin(
225                            &*api_that_guard,
226                            api_req,
227                        )
228                        .await?;
229                        Ok(output_ok)
230                    })()
231                    .await,
232                )
233            }
234        },
235    )
236}
237fn wire__crate__bindings__BindingLiquidSdk_check_message_impl(
238    that: impl CstDecode<
239        RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
240    >,
241    req: impl CstDecode<crate::model::CheckMessageRequest>,
242) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
243    FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::DcoCodec, _>(
244        flutter_rust_bridge::for_generated::TaskInfo {
245            debug_name: "BindingLiquidSdk_check_message",
246            port: None,
247            mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync,
248        },
249        move || {
250            let api_that = that.cst_decode();
251            let api_req = req.cst_decode();
252            transform_result_dco::<_, _, crate::error::SdkError>((move || {
253                let mut api_that_guard = None;
254                let decode_indices_ =
255                    flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![
256                        flutter_rust_bridge::for_generated::LockableOrderInfo::new(
257                            &api_that, 0, false,
258                        ),
259                    ]);
260                for i in decode_indices_ {
261                    match i {
262                        0 => api_that_guard = Some(api_that.lockable_decode_sync_ref()),
263                        _ => unreachable!(),
264                    }
265                }
266                let api_that_guard = api_that_guard.unwrap();
267                let output_ok =
268                    crate::bindings::BindingLiquidSdk::check_message(&*api_that_guard, api_req)?;
269                Ok(output_ok)
270            })())
271        },
272    )
273}
274fn wire__crate__bindings__BindingLiquidSdk_create_bolt12_invoice_impl(
275    port_: flutter_rust_bridge::for_generated::MessagePort,
276    that: impl CstDecode<
277        RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
278    >,
279    req: impl CstDecode<crate::model::CreateBolt12InvoiceRequest>,
280) {
281    FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
282        flutter_rust_bridge::for_generated::TaskInfo {
283            debug_name: "BindingLiquidSdk_create_bolt12_invoice",
284            port: Some(port_),
285            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
286        },
287        move || {
288            let api_that = that.cst_decode();
289            let api_req = req.cst_decode();
290            move |context| async move {
291                transform_result_dco::<_, _, crate::error::PaymentError>(
292                    (move || async move {
293                        let mut api_that_guard = None;
294                        let decode_indices_ =
295                            flutter_rust_bridge::for_generated::lockable_compute_decode_order(
296                                vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
297                                    &api_that, 0, false,
298                                )],
299                            );
300                        for i in decode_indices_ {
301                            match i {
302                                0 => {
303                                    api_that_guard =
304                                        Some(api_that.lockable_decode_async_ref().await)
305                                }
306                                _ => unreachable!(),
307                            }
308                        }
309                        let api_that_guard = api_that_guard.unwrap();
310                        let output_ok = crate::bindings::BindingLiquidSdk::create_bolt12_invoice(
311                            &*api_that_guard,
312                            api_req,
313                        )
314                        .await?;
315                        Ok(output_ok)
316                    })()
317                    .await,
318                )
319            }
320        },
321    )
322}
323fn wire__crate__bindings__BindingLiquidSdk_disconnect_impl(
324    port_: flutter_rust_bridge::for_generated::MessagePort,
325    that: impl CstDecode<
326        RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
327    >,
328) {
329    FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
330        flutter_rust_bridge::for_generated::TaskInfo {
331            debug_name: "BindingLiquidSdk_disconnect",
332            port: Some(port_),
333            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
334        },
335        move || {
336            let api_that = that.cst_decode();
337            move |context| async move {
338                transform_result_dco::<_, _, crate::error::SdkError>(
339                    (move || async move {
340                        let mut api_that_guard = None;
341                        let decode_indices_ =
342                            flutter_rust_bridge::for_generated::lockable_compute_decode_order(
343                                vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
344                                    &api_that, 0, false,
345                                )],
346                            );
347                        for i in decode_indices_ {
348                            match i {
349                                0 => {
350                                    api_that_guard =
351                                        Some(api_that.lockable_decode_async_ref().await)
352                                }
353                                _ => unreachable!(),
354                            }
355                        }
356                        let api_that_guard = api_that_guard.unwrap();
357                        let output_ok =
358                            crate::bindings::BindingLiquidSdk::disconnect(&*api_that_guard).await?;
359                        Ok(output_ok)
360                    })()
361                    .await,
362                )
363            }
364        },
365    )
366}
367fn wire__crate__bindings__BindingLiquidSdk_empty_wallet_cache_impl(
368    that: impl CstDecode<
369        RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
370    >,
371) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
372    FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::DcoCodec, _>(
373        flutter_rust_bridge::for_generated::TaskInfo {
374            debug_name: "BindingLiquidSdk_empty_wallet_cache",
375            port: None,
376            mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync,
377        },
378        move || {
379            let api_that = that.cst_decode();
380            transform_result_dco::<_, _, crate::error::SdkError>((move || {
381                let mut api_that_guard = None;
382                let decode_indices_ =
383                    flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![
384                        flutter_rust_bridge::for_generated::LockableOrderInfo::new(
385                            &api_that, 0, false,
386                        ),
387                    ]);
388                for i in decode_indices_ {
389                    match i {
390                        0 => api_that_guard = Some(api_that.lockable_decode_sync_ref()),
391                        _ => unreachable!(),
392                    }
393                }
394                let api_that_guard = api_that_guard.unwrap();
395                let output_ok =
396                    crate::bindings::BindingLiquidSdk::empty_wallet_cache(&*api_that_guard)?;
397                Ok(output_ok)
398            })())
399        },
400    )
401}
402fn wire__crate__bindings__BindingLiquidSdk_fetch_fiat_rates_impl(
403    port_: flutter_rust_bridge::for_generated::MessagePort,
404    that: impl CstDecode<
405        RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
406    >,
407) {
408    FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
409        flutter_rust_bridge::for_generated::TaskInfo {
410            debug_name: "BindingLiquidSdk_fetch_fiat_rates",
411            port: Some(port_),
412            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
413        },
414        move || {
415            let api_that = that.cst_decode();
416            move |context| async move {
417                transform_result_dco::<_, _, crate::error::SdkError>(
418                    (move || async move {
419                        let mut api_that_guard = None;
420                        let decode_indices_ =
421                            flutter_rust_bridge::for_generated::lockable_compute_decode_order(
422                                vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
423                                    &api_that, 0, false,
424                                )],
425                            );
426                        for i in decode_indices_ {
427                            match i {
428                                0 => {
429                                    api_that_guard =
430                                        Some(api_that.lockable_decode_async_ref().await)
431                                }
432                                _ => unreachable!(),
433                            }
434                        }
435                        let api_that_guard = api_that_guard.unwrap();
436                        let output_ok =
437                            crate::bindings::BindingLiquidSdk::fetch_fiat_rates(&*api_that_guard)
438                                .await?;
439                        Ok(output_ok)
440                    })()
441                    .await,
442                )
443            }
444        },
445    )
446}
447fn wire__crate__bindings__BindingLiquidSdk_fetch_lightning_limits_impl(
448    port_: flutter_rust_bridge::for_generated::MessagePort,
449    that: impl CstDecode<
450        RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
451    >,
452) {
453    FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
454        flutter_rust_bridge::for_generated::TaskInfo {
455            debug_name: "BindingLiquidSdk_fetch_lightning_limits",
456            port: Some(port_),
457            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
458        },
459        move || {
460            let api_that = that.cst_decode();
461            move |context| async move {
462                transform_result_dco::<_, _, crate::error::PaymentError>(
463                    (move || async move {
464                        let mut api_that_guard = None;
465                        let decode_indices_ =
466                            flutter_rust_bridge::for_generated::lockable_compute_decode_order(
467                                vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
468                                    &api_that, 0, false,
469                                )],
470                            );
471                        for i in decode_indices_ {
472                            match i {
473                                0 => {
474                                    api_that_guard =
475                                        Some(api_that.lockable_decode_async_ref().await)
476                                }
477                                _ => unreachable!(),
478                            }
479                        }
480                        let api_that_guard = api_that_guard.unwrap();
481                        let output_ok = crate::bindings::BindingLiquidSdk::fetch_lightning_limits(
482                            &*api_that_guard,
483                        )
484                        .await?;
485                        Ok(output_ok)
486                    })()
487                    .await,
488                )
489            }
490        },
491    )
492}
493fn wire__crate__bindings__BindingLiquidSdk_fetch_onchain_limits_impl(
494    port_: flutter_rust_bridge::for_generated::MessagePort,
495    that: impl CstDecode<
496        RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
497    >,
498) {
499    FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
500        flutter_rust_bridge::for_generated::TaskInfo {
501            debug_name: "BindingLiquidSdk_fetch_onchain_limits",
502            port: Some(port_),
503            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
504        },
505        move || {
506            let api_that = that.cst_decode();
507            move |context| async move {
508                transform_result_dco::<_, _, crate::error::PaymentError>(
509                    (move || async move {
510                        let mut api_that_guard = None;
511                        let decode_indices_ =
512                            flutter_rust_bridge::for_generated::lockable_compute_decode_order(
513                                vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
514                                    &api_that, 0, false,
515                                )],
516                            );
517                        for i in decode_indices_ {
518                            match i {
519                                0 => {
520                                    api_that_guard =
521                                        Some(api_that.lockable_decode_async_ref().await)
522                                }
523                                _ => unreachable!(),
524                            }
525                        }
526                        let api_that_guard = api_that_guard.unwrap();
527                        let output_ok = crate::bindings::BindingLiquidSdk::fetch_onchain_limits(
528                            &*api_that_guard,
529                        )
530                        .await?;
531                        Ok(output_ok)
532                    })()
533                    .await,
534                )
535            }
536        },
537    )
538}
539fn wire__crate__bindings__BindingLiquidSdk_fetch_payment_proposed_fees_impl(
540    port_: flutter_rust_bridge::for_generated::MessagePort,
541    that: impl CstDecode<
542        RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
543    >,
544    req: impl CstDecode<crate::model::FetchPaymentProposedFeesRequest>,
545) {
546    FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
547        flutter_rust_bridge::for_generated::TaskInfo {
548            debug_name: "BindingLiquidSdk_fetch_payment_proposed_fees",
549            port: Some(port_),
550            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
551        },
552        move || {
553            let api_that = that.cst_decode();
554            let api_req = req.cst_decode();
555            move |context| async move {
556                transform_result_dco::<_, _, crate::error::SdkError>(
557                    (move || async move {
558                        let mut api_that_guard = None;
559                        let decode_indices_ =
560                            flutter_rust_bridge::for_generated::lockable_compute_decode_order(
561                                vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
562                                    &api_that, 0, false,
563                                )],
564                            );
565                        for i in decode_indices_ {
566                            match i {
567                                0 => {
568                                    api_that_guard =
569                                        Some(api_that.lockable_decode_async_ref().await)
570                                }
571                                _ => unreachable!(),
572                            }
573                        }
574                        let api_that_guard = api_that_guard.unwrap();
575                        let output_ok =
576                            crate::bindings::BindingLiquidSdk::fetch_payment_proposed_fees(
577                                &*api_that_guard,
578                                api_req,
579                            )
580                            .await?;
581                        Ok(output_ok)
582                    })()
583                    .await,
584                )
585            }
586        },
587    )
588}
589fn wire__crate__bindings__BindingLiquidSdk_get_info_impl(
590    port_: flutter_rust_bridge::for_generated::MessagePort,
591    that: impl CstDecode<
592        RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
593    >,
594) {
595    FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
596        flutter_rust_bridge::for_generated::TaskInfo {
597            debug_name: "BindingLiquidSdk_get_info",
598            port: Some(port_),
599            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
600        },
601        move || {
602            let api_that = that.cst_decode();
603            move |context| async move {
604                transform_result_dco::<_, _, crate::error::SdkError>(
605                    (move || async move {
606                        let mut api_that_guard = None;
607                        let decode_indices_ =
608                            flutter_rust_bridge::for_generated::lockable_compute_decode_order(
609                                vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
610                                    &api_that, 0, false,
611                                )],
612                            );
613                        for i in decode_indices_ {
614                            match i {
615                                0 => {
616                                    api_that_guard =
617                                        Some(api_that.lockable_decode_async_ref().await)
618                                }
619                                _ => unreachable!(),
620                            }
621                        }
622                        let api_that_guard = api_that_guard.unwrap();
623                        let output_ok =
624                            crate::bindings::BindingLiquidSdk::get_info(&*api_that_guard).await?;
625                        Ok(output_ok)
626                    })()
627                    .await,
628                )
629            }
630        },
631    )
632}
633fn wire__crate__bindings__BindingLiquidSdk_get_payment_impl(
634    port_: flutter_rust_bridge::for_generated::MessagePort,
635    that: impl CstDecode<
636        RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
637    >,
638    req: impl CstDecode<crate::model::GetPaymentRequest>,
639) {
640    FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
641        flutter_rust_bridge::for_generated::TaskInfo {
642            debug_name: "BindingLiquidSdk_get_payment",
643            port: Some(port_),
644            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
645        },
646        move || {
647            let api_that = that.cst_decode();
648            let api_req = req.cst_decode();
649            move |context| async move {
650                transform_result_dco::<_, _, crate::error::PaymentError>(
651                    (move || async move {
652                        let mut api_that_guard = None;
653                        let decode_indices_ =
654                            flutter_rust_bridge::for_generated::lockable_compute_decode_order(
655                                vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
656                                    &api_that, 0, false,
657                                )],
658                            );
659                        for i in decode_indices_ {
660                            match i {
661                                0 => {
662                                    api_that_guard =
663                                        Some(api_that.lockable_decode_async_ref().await)
664                                }
665                                _ => unreachable!(),
666                            }
667                        }
668                        let api_that_guard = api_that_guard.unwrap();
669                        let output_ok = crate::bindings::BindingLiquidSdk::get_payment(
670                            &*api_that_guard,
671                            api_req,
672                        )
673                        .await?;
674                        Ok(output_ok)
675                    })()
676                    .await,
677                )
678            }
679        },
680    )
681}
682fn wire__crate__bindings__BindingLiquidSdk_list_fiat_currencies_impl(
683    port_: flutter_rust_bridge::for_generated::MessagePort,
684    that: impl CstDecode<
685        RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
686    >,
687) {
688    FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
689        flutter_rust_bridge::for_generated::TaskInfo {
690            debug_name: "BindingLiquidSdk_list_fiat_currencies",
691            port: Some(port_),
692            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
693        },
694        move || {
695            let api_that = that.cst_decode();
696            move |context| async move {
697                transform_result_dco::<_, _, crate::error::SdkError>(
698                    (move || async move {
699                        let mut api_that_guard = None;
700                        let decode_indices_ =
701                            flutter_rust_bridge::for_generated::lockable_compute_decode_order(
702                                vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
703                                    &api_that, 0, false,
704                                )],
705                            );
706                        for i in decode_indices_ {
707                            match i {
708                                0 => {
709                                    api_that_guard =
710                                        Some(api_that.lockable_decode_async_ref().await)
711                                }
712                                _ => unreachable!(),
713                            }
714                        }
715                        let api_that_guard = api_that_guard.unwrap();
716                        let output_ok = crate::bindings::BindingLiquidSdk::list_fiat_currencies(
717                            &*api_that_guard,
718                        )
719                        .await?;
720                        Ok(output_ok)
721                    })()
722                    .await,
723                )
724            }
725        },
726    )
727}
728fn wire__crate__bindings__BindingLiquidSdk_list_payments_impl(
729    port_: flutter_rust_bridge::for_generated::MessagePort,
730    that: impl CstDecode<
731        RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
732    >,
733    req: impl CstDecode<crate::model::ListPaymentsRequest>,
734) {
735    FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
736        flutter_rust_bridge::for_generated::TaskInfo {
737            debug_name: "BindingLiquidSdk_list_payments",
738            port: Some(port_),
739            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
740        },
741        move || {
742            let api_that = that.cst_decode();
743            let api_req = req.cst_decode();
744            move |context| async move {
745                transform_result_dco::<_, _, crate::error::PaymentError>(
746                    (move || async move {
747                        let mut api_that_guard = None;
748                        let decode_indices_ =
749                            flutter_rust_bridge::for_generated::lockable_compute_decode_order(
750                                vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
751                                    &api_that, 0, false,
752                                )],
753                            );
754                        for i in decode_indices_ {
755                            match i {
756                                0 => {
757                                    api_that_guard =
758                                        Some(api_that.lockable_decode_async_ref().await)
759                                }
760                                _ => unreachable!(),
761                            }
762                        }
763                        let api_that_guard = api_that_guard.unwrap();
764                        let output_ok = crate::bindings::BindingLiquidSdk::list_payments(
765                            &*api_that_guard,
766                            api_req,
767                        )
768                        .await?;
769                        Ok(output_ok)
770                    })()
771                    .await,
772                )
773            }
774        },
775    )
776}
777fn wire__crate__bindings__BindingLiquidSdk_list_refundables_impl(
778    port_: flutter_rust_bridge::for_generated::MessagePort,
779    that: impl CstDecode<
780        RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
781    >,
782) {
783    FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
784        flutter_rust_bridge::for_generated::TaskInfo {
785            debug_name: "BindingLiquidSdk_list_refundables",
786            port: Some(port_),
787            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
788        },
789        move || {
790            let api_that = that.cst_decode();
791            move |context| async move {
792                transform_result_dco::<_, _, crate::error::SdkError>(
793                    (move || async move {
794                        let mut api_that_guard = None;
795                        let decode_indices_ =
796                            flutter_rust_bridge::for_generated::lockable_compute_decode_order(
797                                vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
798                                    &api_that, 0, false,
799                                )],
800                            );
801                        for i in decode_indices_ {
802                            match i {
803                                0 => {
804                                    api_that_guard =
805                                        Some(api_that.lockable_decode_async_ref().await)
806                                }
807                                _ => unreachable!(),
808                            }
809                        }
810                        let api_that_guard = api_that_guard.unwrap();
811                        let output_ok =
812                            crate::bindings::BindingLiquidSdk::list_refundables(&*api_that_guard)
813                                .await?;
814                        Ok(output_ok)
815                    })()
816                    .await,
817                )
818            }
819        },
820    )
821}
822fn wire__crate__bindings__BindingLiquidSdk_lnurl_auth_impl(
823    port_: flutter_rust_bridge::for_generated::MessagePort,
824    that: impl CstDecode<
825        RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
826    >,
827    req_data: impl CstDecode<crate::bindings::LnUrlAuthRequestData>,
828) {
829    FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
830        flutter_rust_bridge::for_generated::TaskInfo {
831            debug_name: "BindingLiquidSdk_lnurl_auth",
832            port: Some(port_),
833            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
834        },
835        move || {
836            let api_that = that.cst_decode();
837            let api_req_data = req_data.cst_decode();
838            move |context| async move {
839                transform_result_dco::<_, _, crate::bindings::duplicates::LnUrlAuthError>(
840                    (move || async move {
841                        let mut api_that_guard = None;
842                        let decode_indices_ =
843                            flutter_rust_bridge::for_generated::lockable_compute_decode_order(
844                                vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
845                                    &api_that, 0, false,
846                                )],
847                            );
848                        for i in decode_indices_ {
849                            match i {
850                                0 => {
851                                    api_that_guard =
852                                        Some(api_that.lockable_decode_async_ref().await)
853                                }
854                                _ => unreachable!(),
855                            }
856                        }
857                        let api_that_guard = api_that_guard.unwrap();
858                        let output_ok = crate::bindings::BindingLiquidSdk::lnurl_auth(
859                            &*api_that_guard,
860                            api_req_data,
861                        )
862                        .await?;
863                        Ok(output_ok)
864                    })()
865                    .await,
866                )
867            }
868        },
869    )
870}
871fn wire__crate__bindings__BindingLiquidSdk_lnurl_pay_impl(
872    port_: flutter_rust_bridge::for_generated::MessagePort,
873    that: impl CstDecode<
874        RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
875    >,
876    req: impl CstDecode<crate::model::LnUrlPayRequest>,
877) {
878    FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
879        flutter_rust_bridge::for_generated::TaskInfo {
880            debug_name: "BindingLiquidSdk_lnurl_pay",
881            port: Some(port_),
882            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
883        },
884        move || {
885            let api_that = that.cst_decode();
886            let api_req = req.cst_decode();
887            move |context| async move {
888                transform_result_dco::<_, _, crate::bindings::duplicates::LnUrlPayError>(
889                    (move || async move {
890                        let mut api_that_guard = None;
891                        let decode_indices_ =
892                            flutter_rust_bridge::for_generated::lockable_compute_decode_order(
893                                vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
894                                    &api_that, 0, false,
895                                )],
896                            );
897                        for i in decode_indices_ {
898                            match i {
899                                0 => {
900                                    api_that_guard =
901                                        Some(api_that.lockable_decode_async_ref().await)
902                                }
903                                _ => unreachable!(),
904                            }
905                        }
906                        let api_that_guard = api_that_guard.unwrap();
907                        let output_ok =
908                            crate::bindings::BindingLiquidSdk::lnurl_pay(&*api_that_guard, api_req)
909                                .await?;
910                        Ok(output_ok)
911                    })()
912                    .await,
913                )
914            }
915        },
916    )
917}
918fn wire__crate__bindings__BindingLiquidSdk_lnurl_withdraw_impl(
919    port_: flutter_rust_bridge::for_generated::MessagePort,
920    that: impl CstDecode<
921        RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
922    >,
923    req: impl CstDecode<crate::bindings::LnUrlWithdrawRequest>,
924) {
925    FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
926        flutter_rust_bridge::for_generated::TaskInfo {
927            debug_name: "BindingLiquidSdk_lnurl_withdraw",
928            port: Some(port_),
929            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
930        },
931        move || {
932            let api_that = that.cst_decode();
933            let api_req = req.cst_decode();
934            move |context| async move {
935                transform_result_dco::<_, _, crate::bindings::duplicates::LnUrlWithdrawError>(
936                    (move || async move {
937                        let mut api_that_guard = None;
938                        let decode_indices_ =
939                            flutter_rust_bridge::for_generated::lockable_compute_decode_order(
940                                vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
941                                    &api_that, 0, false,
942                                )],
943                            );
944                        for i in decode_indices_ {
945                            match i {
946                                0 => {
947                                    api_that_guard =
948                                        Some(api_that.lockable_decode_async_ref().await)
949                                }
950                                _ => unreachable!(),
951                            }
952                        }
953                        let api_that_guard = api_that_guard.unwrap();
954                        let output_ok = crate::bindings::BindingLiquidSdk::lnurl_withdraw(
955                            &*api_that_guard,
956                            api_req,
957                        )
958                        .await?;
959                        Ok(output_ok)
960                    })()
961                    .await,
962                )
963            }
964        },
965    )
966}
967fn wire__crate__bindings__BindingLiquidSdk_parse_impl(
968    port_: flutter_rust_bridge::for_generated::MessagePort,
969    that: impl CstDecode<
970        RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
971    >,
972    input: impl CstDecode<String>,
973) {
974    FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
975        flutter_rust_bridge::for_generated::TaskInfo {
976            debug_name: "BindingLiquidSdk_parse",
977            port: Some(port_),
978            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
979        },
980        move || {
981            let api_that = that.cst_decode();
982            let api_input = input.cst_decode();
983            move |context| async move {
984                transform_result_dco::<_, _, crate::error::PaymentError>(
985                    (move || async move {
986                        let mut api_that_guard = None;
987                        let decode_indices_ =
988                            flutter_rust_bridge::for_generated::lockable_compute_decode_order(
989                                vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
990                                    &api_that, 0, false,
991                                )],
992                            );
993                        for i in decode_indices_ {
994                            match i {
995                                0 => {
996                                    api_that_guard =
997                                        Some(api_that.lockable_decode_async_ref().await)
998                                }
999                                _ => unreachable!(),
1000                            }
1001                        }
1002                        let api_that_guard = api_that_guard.unwrap();
1003                        let output_ok =
1004                            crate::bindings::BindingLiquidSdk::parse(&*api_that_guard, api_input)
1005                                .await?;
1006                        Ok(output_ok)
1007                    })()
1008                    .await,
1009                )
1010            }
1011        },
1012    )
1013}
1014fn wire__crate__bindings__BindingLiquidSdk_pay_onchain_impl(
1015    port_: flutter_rust_bridge::for_generated::MessagePort,
1016    that: impl CstDecode<
1017        RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
1018    >,
1019    req: impl CstDecode<crate::model::PayOnchainRequest>,
1020) {
1021    FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
1022        flutter_rust_bridge::for_generated::TaskInfo {
1023            debug_name: "BindingLiquidSdk_pay_onchain",
1024            port: Some(port_),
1025            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
1026        },
1027        move || {
1028            let api_that = that.cst_decode();
1029            let api_req = req.cst_decode();
1030            move |context| async move {
1031                transform_result_dco::<_, _, crate::error::PaymentError>(
1032                    (move || async move {
1033                        let mut api_that_guard = None;
1034                        let decode_indices_ =
1035                            flutter_rust_bridge::for_generated::lockable_compute_decode_order(
1036                                vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
1037                                    &api_that, 0, false,
1038                                )],
1039                            );
1040                        for i in decode_indices_ {
1041                            match i {
1042                                0 => {
1043                                    api_that_guard =
1044                                        Some(api_that.lockable_decode_async_ref().await)
1045                                }
1046                                _ => unreachable!(),
1047                            }
1048                        }
1049                        let api_that_guard = api_that_guard.unwrap();
1050                        let output_ok = crate::bindings::BindingLiquidSdk::pay_onchain(
1051                            &*api_that_guard,
1052                            api_req,
1053                        )
1054                        .await?;
1055                        Ok(output_ok)
1056                    })()
1057                    .await,
1058                )
1059            }
1060        },
1061    )
1062}
1063fn wire__crate__bindings__BindingLiquidSdk_prepare_buy_bitcoin_impl(
1064    port_: flutter_rust_bridge::for_generated::MessagePort,
1065    that: impl CstDecode<
1066        RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
1067    >,
1068    req: impl CstDecode<crate::model::PrepareBuyBitcoinRequest>,
1069) {
1070    FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
1071        flutter_rust_bridge::for_generated::TaskInfo {
1072            debug_name: "BindingLiquidSdk_prepare_buy_bitcoin",
1073            port: Some(port_),
1074            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
1075        },
1076        move || {
1077            let api_that = that.cst_decode();
1078            let api_req = req.cst_decode();
1079            move |context| async move {
1080                transform_result_dco::<_, _, crate::error::PaymentError>(
1081                    (move || async move {
1082                        let mut api_that_guard = None;
1083                        let decode_indices_ =
1084                            flutter_rust_bridge::for_generated::lockable_compute_decode_order(
1085                                vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
1086                                    &api_that, 0, false,
1087                                )],
1088                            );
1089                        for i in decode_indices_ {
1090                            match i {
1091                                0 => {
1092                                    api_that_guard =
1093                                        Some(api_that.lockable_decode_async_ref().await)
1094                                }
1095                                _ => unreachable!(),
1096                            }
1097                        }
1098                        let api_that_guard = api_that_guard.unwrap();
1099                        let output_ok = crate::bindings::BindingLiquidSdk::prepare_buy_bitcoin(
1100                            &*api_that_guard,
1101                            api_req,
1102                        )
1103                        .await?;
1104                        Ok(output_ok)
1105                    })()
1106                    .await,
1107                )
1108            }
1109        },
1110    )
1111}
1112fn wire__crate__bindings__BindingLiquidSdk_prepare_lnurl_pay_impl(
1113    port_: flutter_rust_bridge::for_generated::MessagePort,
1114    that: impl CstDecode<
1115        RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
1116    >,
1117    req: impl CstDecode<crate::model::PrepareLnUrlPayRequest>,
1118) {
1119    FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
1120        flutter_rust_bridge::for_generated::TaskInfo {
1121            debug_name: "BindingLiquidSdk_prepare_lnurl_pay",
1122            port: Some(port_),
1123            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
1124        },
1125        move || {
1126            let api_that = that.cst_decode();
1127            let api_req = req.cst_decode();
1128            move |context| async move {
1129                transform_result_dco::<_, _, crate::bindings::duplicates::LnUrlPayError>(
1130                    (move || async move {
1131                        let mut api_that_guard = None;
1132                        let decode_indices_ =
1133                            flutter_rust_bridge::for_generated::lockable_compute_decode_order(
1134                                vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
1135                                    &api_that, 0, false,
1136                                )],
1137                            );
1138                        for i in decode_indices_ {
1139                            match i {
1140                                0 => {
1141                                    api_that_guard =
1142                                        Some(api_that.lockable_decode_async_ref().await)
1143                                }
1144                                _ => unreachable!(),
1145                            }
1146                        }
1147                        let api_that_guard = api_that_guard.unwrap();
1148                        let output_ok = crate::bindings::BindingLiquidSdk::prepare_lnurl_pay(
1149                            &*api_that_guard,
1150                            api_req,
1151                        )
1152                        .await?;
1153                        Ok(output_ok)
1154                    })()
1155                    .await,
1156                )
1157            }
1158        },
1159    )
1160}
1161fn wire__crate__bindings__BindingLiquidSdk_prepare_pay_onchain_impl(
1162    port_: flutter_rust_bridge::for_generated::MessagePort,
1163    that: impl CstDecode<
1164        RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
1165    >,
1166    req: impl CstDecode<crate::model::PreparePayOnchainRequest>,
1167) {
1168    FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
1169        flutter_rust_bridge::for_generated::TaskInfo {
1170            debug_name: "BindingLiquidSdk_prepare_pay_onchain",
1171            port: Some(port_),
1172            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
1173        },
1174        move || {
1175            let api_that = that.cst_decode();
1176            let api_req = req.cst_decode();
1177            move |context| async move {
1178                transform_result_dco::<_, _, crate::error::PaymentError>(
1179                    (move || async move {
1180                        let mut api_that_guard = None;
1181                        let decode_indices_ =
1182                            flutter_rust_bridge::for_generated::lockable_compute_decode_order(
1183                                vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
1184                                    &api_that, 0, false,
1185                                )],
1186                            );
1187                        for i in decode_indices_ {
1188                            match i {
1189                                0 => {
1190                                    api_that_guard =
1191                                        Some(api_that.lockable_decode_async_ref().await)
1192                                }
1193                                _ => unreachable!(),
1194                            }
1195                        }
1196                        let api_that_guard = api_that_guard.unwrap();
1197                        let output_ok = crate::bindings::BindingLiquidSdk::prepare_pay_onchain(
1198                            &*api_that_guard,
1199                            api_req,
1200                        )
1201                        .await?;
1202                        Ok(output_ok)
1203                    })()
1204                    .await,
1205                )
1206            }
1207        },
1208    )
1209}
1210fn wire__crate__bindings__BindingLiquidSdk_prepare_receive_payment_impl(
1211    port_: flutter_rust_bridge::for_generated::MessagePort,
1212    that: impl CstDecode<
1213        RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
1214    >,
1215    req: impl CstDecode<crate::model::PrepareReceiveRequest>,
1216) {
1217    FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
1218        flutter_rust_bridge::for_generated::TaskInfo {
1219            debug_name: "BindingLiquidSdk_prepare_receive_payment",
1220            port: Some(port_),
1221            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
1222        },
1223        move || {
1224            let api_that = that.cst_decode();
1225            let api_req = req.cst_decode();
1226            move |context| async move {
1227                transform_result_dco::<_, _, crate::error::PaymentError>(
1228                    (move || async move {
1229                        let mut api_that_guard = None;
1230                        let decode_indices_ =
1231                            flutter_rust_bridge::for_generated::lockable_compute_decode_order(
1232                                vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
1233                                    &api_that, 0, false,
1234                                )],
1235                            );
1236                        for i in decode_indices_ {
1237                            match i {
1238                                0 => {
1239                                    api_that_guard =
1240                                        Some(api_that.lockable_decode_async_ref().await)
1241                                }
1242                                _ => unreachable!(),
1243                            }
1244                        }
1245                        let api_that_guard = api_that_guard.unwrap();
1246                        let output_ok = crate::bindings::BindingLiquidSdk::prepare_receive_payment(
1247                            &*api_that_guard,
1248                            api_req,
1249                        )
1250                        .await?;
1251                        Ok(output_ok)
1252                    })()
1253                    .await,
1254                )
1255            }
1256        },
1257    )
1258}
1259fn wire__crate__bindings__BindingLiquidSdk_prepare_refund_impl(
1260    port_: flutter_rust_bridge::for_generated::MessagePort,
1261    that: impl CstDecode<
1262        RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
1263    >,
1264    req: impl CstDecode<crate::model::PrepareRefundRequest>,
1265) {
1266    FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
1267        flutter_rust_bridge::for_generated::TaskInfo {
1268            debug_name: "BindingLiquidSdk_prepare_refund",
1269            port: Some(port_),
1270            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
1271        },
1272        move || {
1273            let api_that = that.cst_decode();
1274            let api_req = req.cst_decode();
1275            move |context| async move {
1276                transform_result_dco::<_, _, crate::error::SdkError>(
1277                    (move || async move {
1278                        let mut api_that_guard = None;
1279                        let decode_indices_ =
1280                            flutter_rust_bridge::for_generated::lockable_compute_decode_order(
1281                                vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
1282                                    &api_that, 0, false,
1283                                )],
1284                            );
1285                        for i in decode_indices_ {
1286                            match i {
1287                                0 => {
1288                                    api_that_guard =
1289                                        Some(api_that.lockable_decode_async_ref().await)
1290                                }
1291                                _ => unreachable!(),
1292                            }
1293                        }
1294                        let api_that_guard = api_that_guard.unwrap();
1295                        let output_ok = crate::bindings::BindingLiquidSdk::prepare_refund(
1296                            &*api_that_guard,
1297                            api_req,
1298                        )
1299                        .await?;
1300                        Ok(output_ok)
1301                    })()
1302                    .await,
1303                )
1304            }
1305        },
1306    )
1307}
1308fn wire__crate__bindings__BindingLiquidSdk_prepare_send_payment_impl(
1309    port_: flutter_rust_bridge::for_generated::MessagePort,
1310    that: impl CstDecode<
1311        RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
1312    >,
1313    req: impl CstDecode<crate::model::PrepareSendRequest>,
1314) {
1315    FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
1316        flutter_rust_bridge::for_generated::TaskInfo {
1317            debug_name: "BindingLiquidSdk_prepare_send_payment",
1318            port: Some(port_),
1319            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
1320        },
1321        move || {
1322            let api_that = that.cst_decode();
1323            let api_req = req.cst_decode();
1324            move |context| async move {
1325                transform_result_dco::<_, _, crate::error::PaymentError>(
1326                    (move || async move {
1327                        let mut api_that_guard = None;
1328                        let decode_indices_ =
1329                            flutter_rust_bridge::for_generated::lockable_compute_decode_order(
1330                                vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
1331                                    &api_that, 0, false,
1332                                )],
1333                            );
1334                        for i in decode_indices_ {
1335                            match i {
1336                                0 => {
1337                                    api_that_guard =
1338                                        Some(api_that.lockable_decode_async_ref().await)
1339                                }
1340                                _ => unreachable!(),
1341                            }
1342                        }
1343                        let api_that_guard = api_that_guard.unwrap();
1344                        let output_ok = crate::bindings::BindingLiquidSdk::prepare_send_payment(
1345                            &*api_that_guard,
1346                            api_req,
1347                        )
1348                        .await?;
1349                        Ok(output_ok)
1350                    })()
1351                    .await,
1352                )
1353            }
1354        },
1355    )
1356}
1357fn wire__crate__bindings__BindingLiquidSdk_receive_payment_impl(
1358    port_: flutter_rust_bridge::for_generated::MessagePort,
1359    that: impl CstDecode<
1360        RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
1361    >,
1362    req: impl CstDecode<crate::model::ReceivePaymentRequest>,
1363) {
1364    FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
1365        flutter_rust_bridge::for_generated::TaskInfo {
1366            debug_name: "BindingLiquidSdk_receive_payment",
1367            port: Some(port_),
1368            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
1369        },
1370        move || {
1371            let api_that = that.cst_decode();
1372            let api_req = req.cst_decode();
1373            move |context| async move {
1374                transform_result_dco::<_, _, crate::error::PaymentError>(
1375                    (move || async move {
1376                        let mut api_that_guard = None;
1377                        let decode_indices_ =
1378                            flutter_rust_bridge::for_generated::lockable_compute_decode_order(
1379                                vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
1380                                    &api_that, 0, false,
1381                                )],
1382                            );
1383                        for i in decode_indices_ {
1384                            match i {
1385                                0 => {
1386                                    api_that_guard =
1387                                        Some(api_that.lockable_decode_async_ref().await)
1388                                }
1389                                _ => unreachable!(),
1390                            }
1391                        }
1392                        let api_that_guard = api_that_guard.unwrap();
1393                        let output_ok = crate::bindings::BindingLiquidSdk::receive_payment(
1394                            &*api_that_guard,
1395                            api_req,
1396                        )
1397                        .await?;
1398                        Ok(output_ok)
1399                    })()
1400                    .await,
1401                )
1402            }
1403        },
1404    )
1405}
1406fn wire__crate__bindings__BindingLiquidSdk_recommended_fees_impl(
1407    port_: flutter_rust_bridge::for_generated::MessagePort,
1408    that: impl CstDecode<
1409        RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
1410    >,
1411) {
1412    FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
1413        flutter_rust_bridge::for_generated::TaskInfo {
1414            debug_name: "BindingLiquidSdk_recommended_fees",
1415            port: Some(port_),
1416            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
1417        },
1418        move || {
1419            let api_that = that.cst_decode();
1420            move |context| async move {
1421                transform_result_dco::<_, _, crate::error::SdkError>(
1422                    (move || async move {
1423                        let mut api_that_guard = None;
1424                        let decode_indices_ =
1425                            flutter_rust_bridge::for_generated::lockable_compute_decode_order(
1426                                vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
1427                                    &api_that, 0, false,
1428                                )],
1429                            );
1430                        for i in decode_indices_ {
1431                            match i {
1432                                0 => {
1433                                    api_that_guard =
1434                                        Some(api_that.lockable_decode_async_ref().await)
1435                                }
1436                                _ => unreachable!(),
1437                            }
1438                        }
1439                        let api_that_guard = api_that_guard.unwrap();
1440                        let output_ok =
1441                            crate::bindings::BindingLiquidSdk::recommended_fees(&*api_that_guard)
1442                                .await?;
1443                        Ok(output_ok)
1444                    })()
1445                    .await,
1446                )
1447            }
1448        },
1449    )
1450}
1451fn wire__crate__bindings__BindingLiquidSdk_refund_impl(
1452    port_: flutter_rust_bridge::for_generated::MessagePort,
1453    that: impl CstDecode<
1454        RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
1455    >,
1456    req: impl CstDecode<crate::model::RefundRequest>,
1457) {
1458    FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
1459        flutter_rust_bridge::for_generated::TaskInfo {
1460            debug_name: "BindingLiquidSdk_refund",
1461            port: Some(port_),
1462            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
1463        },
1464        move || {
1465            let api_that = that.cst_decode();
1466            let api_req = req.cst_decode();
1467            move |context| async move {
1468                transform_result_dco::<_, _, crate::error::PaymentError>(
1469                    (move || async move {
1470                        let mut api_that_guard = None;
1471                        let decode_indices_ =
1472                            flutter_rust_bridge::for_generated::lockable_compute_decode_order(
1473                                vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
1474                                    &api_that, 0, false,
1475                                )],
1476                            );
1477                        for i in decode_indices_ {
1478                            match i {
1479                                0 => {
1480                                    api_that_guard =
1481                                        Some(api_that.lockable_decode_async_ref().await)
1482                                }
1483                                _ => unreachable!(),
1484                            }
1485                        }
1486                        let api_that_guard = api_that_guard.unwrap();
1487                        let output_ok =
1488                            crate::bindings::BindingLiquidSdk::refund(&*api_that_guard, api_req)
1489                                .await?;
1490                        Ok(output_ok)
1491                    })()
1492                    .await,
1493                )
1494            }
1495        },
1496    )
1497}
1498fn wire__crate__bindings__BindingLiquidSdk_register_webhook_impl(
1499    port_: flutter_rust_bridge::for_generated::MessagePort,
1500    that: impl CstDecode<
1501        RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
1502    >,
1503    webhook_url: impl CstDecode<String>,
1504) {
1505    FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
1506        flutter_rust_bridge::for_generated::TaskInfo {
1507            debug_name: "BindingLiquidSdk_register_webhook",
1508            port: Some(port_),
1509            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
1510        },
1511        move || {
1512            let api_that = that.cst_decode();
1513            let api_webhook_url = webhook_url.cst_decode();
1514            move |context| async move {
1515                transform_result_dco::<_, _, crate::error::SdkError>(
1516                    (move || async move {
1517                        let mut api_that_guard = None;
1518                        let decode_indices_ =
1519                            flutter_rust_bridge::for_generated::lockable_compute_decode_order(
1520                                vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
1521                                    &api_that, 0, false,
1522                                )],
1523                            );
1524                        for i in decode_indices_ {
1525                            match i {
1526                                0 => {
1527                                    api_that_guard =
1528                                        Some(api_that.lockable_decode_async_ref().await)
1529                                }
1530                                _ => unreachable!(),
1531                            }
1532                        }
1533                        let api_that_guard = api_that_guard.unwrap();
1534                        let output_ok = crate::bindings::BindingLiquidSdk::register_webhook(
1535                            &*api_that_guard,
1536                            api_webhook_url,
1537                        )
1538                        .await?;
1539                        Ok(output_ok)
1540                    })()
1541                    .await,
1542                )
1543            }
1544        },
1545    )
1546}
1547fn wire__crate__bindings__BindingLiquidSdk_rescan_onchain_swaps_impl(
1548    port_: flutter_rust_bridge::for_generated::MessagePort,
1549    that: impl CstDecode<
1550        RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
1551    >,
1552) {
1553    FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
1554        flutter_rust_bridge::for_generated::TaskInfo {
1555            debug_name: "BindingLiquidSdk_rescan_onchain_swaps",
1556            port: Some(port_),
1557            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
1558        },
1559        move || {
1560            let api_that = that.cst_decode();
1561            move |context| async move {
1562                transform_result_dco::<_, _, crate::error::SdkError>(
1563                    (move || async move {
1564                        let mut api_that_guard = None;
1565                        let decode_indices_ =
1566                            flutter_rust_bridge::for_generated::lockable_compute_decode_order(
1567                                vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
1568                                    &api_that, 0, false,
1569                                )],
1570                            );
1571                        for i in decode_indices_ {
1572                            match i {
1573                                0 => {
1574                                    api_that_guard =
1575                                        Some(api_that.lockable_decode_async_ref().await)
1576                                }
1577                                _ => unreachable!(),
1578                            }
1579                        }
1580                        let api_that_guard = api_that_guard.unwrap();
1581                        let output_ok = crate::bindings::BindingLiquidSdk::rescan_onchain_swaps(
1582                            &*api_that_guard,
1583                        )
1584                        .await?;
1585                        Ok(output_ok)
1586                    })()
1587                    .await,
1588                )
1589            }
1590        },
1591    )
1592}
1593fn wire__crate__bindings__BindingLiquidSdk_restore_impl(
1594    that: impl CstDecode<
1595        RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
1596    >,
1597    req: impl CstDecode<crate::model::RestoreRequest>,
1598) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
1599    FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::DcoCodec, _>(
1600        flutter_rust_bridge::for_generated::TaskInfo {
1601            debug_name: "BindingLiquidSdk_restore",
1602            port: None,
1603            mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync,
1604        },
1605        move || {
1606            let api_that = that.cst_decode();
1607            let api_req = req.cst_decode();
1608            transform_result_dco::<_, _, crate::error::SdkError>((move || {
1609                let mut api_that_guard = None;
1610                let decode_indices_ =
1611                    flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![
1612                        flutter_rust_bridge::for_generated::LockableOrderInfo::new(
1613                            &api_that, 0, false,
1614                        ),
1615                    ]);
1616                for i in decode_indices_ {
1617                    match i {
1618                        0 => api_that_guard = Some(api_that.lockable_decode_sync_ref()),
1619                        _ => unreachable!(),
1620                    }
1621                }
1622                let api_that_guard = api_that_guard.unwrap();
1623                let output_ok =
1624                    crate::bindings::BindingLiquidSdk::restore(&*api_that_guard, api_req)?;
1625                Ok(output_ok)
1626            })())
1627        },
1628    )
1629}
1630fn wire__crate__bindings__BindingLiquidSdk_send_payment_impl(
1631    port_: flutter_rust_bridge::for_generated::MessagePort,
1632    that: impl CstDecode<
1633        RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
1634    >,
1635    req: impl CstDecode<crate::model::SendPaymentRequest>,
1636) {
1637    FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
1638        flutter_rust_bridge::for_generated::TaskInfo {
1639            debug_name: "BindingLiquidSdk_send_payment",
1640            port: Some(port_),
1641            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
1642        },
1643        move || {
1644            let api_that = that.cst_decode();
1645            let api_req = req.cst_decode();
1646            move |context| async move {
1647                transform_result_dco::<_, _, crate::error::PaymentError>(
1648                    (move || async move {
1649                        let mut api_that_guard = None;
1650                        let decode_indices_ =
1651                            flutter_rust_bridge::for_generated::lockable_compute_decode_order(
1652                                vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
1653                                    &api_that, 0, false,
1654                                )],
1655                            );
1656                        for i in decode_indices_ {
1657                            match i {
1658                                0 => {
1659                                    api_that_guard =
1660                                        Some(api_that.lockable_decode_async_ref().await)
1661                                }
1662                                _ => unreachable!(),
1663                            }
1664                        }
1665                        let api_that_guard = api_that_guard.unwrap();
1666                        let output_ok = crate::bindings::BindingLiquidSdk::send_payment(
1667                            &*api_that_guard,
1668                            api_req,
1669                        )
1670                        .await?;
1671                        Ok(output_ok)
1672                    })()
1673                    .await,
1674                )
1675            }
1676        },
1677    )
1678}
1679fn wire__crate__bindings__BindingLiquidSdk_sign_message_impl(
1680    that: impl CstDecode<
1681        RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
1682    >,
1683    req: impl CstDecode<crate::model::SignMessageRequest>,
1684) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
1685    FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::DcoCodec, _>(
1686        flutter_rust_bridge::for_generated::TaskInfo {
1687            debug_name: "BindingLiquidSdk_sign_message",
1688            port: None,
1689            mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync,
1690        },
1691        move || {
1692            let api_that = that.cst_decode();
1693            let api_req = req.cst_decode();
1694            transform_result_dco::<_, _, crate::error::SdkError>((move || {
1695                let mut api_that_guard = None;
1696                let decode_indices_ =
1697                    flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![
1698                        flutter_rust_bridge::for_generated::LockableOrderInfo::new(
1699                            &api_that, 0, false,
1700                        ),
1701                    ]);
1702                for i in decode_indices_ {
1703                    match i {
1704                        0 => api_that_guard = Some(api_that.lockable_decode_sync_ref()),
1705                        _ => unreachable!(),
1706                    }
1707                }
1708                let api_that_guard = api_that_guard.unwrap();
1709                let output_ok =
1710                    crate::bindings::BindingLiquidSdk::sign_message(&*api_that_guard, api_req)?;
1711                Ok(output_ok)
1712            })())
1713        },
1714    )
1715}
1716fn wire__crate__bindings__BindingLiquidSdk_sync_impl(
1717    port_: flutter_rust_bridge::for_generated::MessagePort,
1718    that: impl CstDecode<
1719        RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
1720    >,
1721) {
1722    FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
1723        flutter_rust_bridge::for_generated::TaskInfo {
1724            debug_name: "BindingLiquidSdk_sync(dart_style=sync)",
1725            port: Some(port_),
1726            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
1727        },
1728        move || {
1729            let api_that = that.cst_decode();
1730            move |context| async move {
1731                transform_result_dco::<_, _, crate::error::SdkError>(
1732                    (move || async move {
1733                        let mut api_that_guard = None;
1734                        let decode_indices_ =
1735                            flutter_rust_bridge::for_generated::lockable_compute_decode_order(
1736                                vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
1737                                    &api_that, 0, false,
1738                                )],
1739                            );
1740                        for i in decode_indices_ {
1741                            match i {
1742                                0 => {
1743                                    api_that_guard =
1744                                        Some(api_that.lockable_decode_async_ref().await)
1745                                }
1746                                _ => unreachable!(),
1747                            }
1748                        }
1749                        let api_that_guard = api_that_guard.unwrap();
1750                        let output_ok =
1751                            crate::bindings::BindingLiquidSdk::sync(&*api_that_guard).await?;
1752                        Ok(output_ok)
1753                    })()
1754                    .await,
1755                )
1756            }
1757        },
1758    )
1759}
1760fn wire__crate__bindings__BindingLiquidSdk_unregister_webhook_impl(
1761    port_: flutter_rust_bridge::for_generated::MessagePort,
1762    that: impl CstDecode<
1763        RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>,
1764    >,
1765) {
1766    FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
1767        flutter_rust_bridge::for_generated::TaskInfo {
1768            debug_name: "BindingLiquidSdk_unregister_webhook",
1769            port: Some(port_),
1770            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
1771        },
1772        move || {
1773            let api_that = that.cst_decode();
1774            move |context| async move {
1775                transform_result_dco::<_, _, crate::error::SdkError>(
1776                    (move || async move {
1777                        let mut api_that_guard = None;
1778                        let decode_indices_ =
1779                            flutter_rust_bridge::for_generated::lockable_compute_decode_order(
1780                                vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
1781                                    &api_that, 0, false,
1782                                )],
1783                            );
1784                        for i in decode_indices_ {
1785                            match i {
1786                                0 => {
1787                                    api_that_guard =
1788                                        Some(api_that.lockable_decode_async_ref().await)
1789                                }
1790                                _ => unreachable!(),
1791                            }
1792                        }
1793                        let api_that_guard = api_that_guard.unwrap();
1794                        let output_ok =
1795                            crate::bindings::BindingLiquidSdk::unregister_webhook(&*api_that_guard)
1796                                .await?;
1797                        Ok(output_ok)
1798                    })()
1799                    .await,
1800                )
1801            }
1802        },
1803    )
1804}
1805fn wire__crate__bindings__binding_event_listener_on_event_impl(
1806    port_: flutter_rust_bridge::for_generated::MessagePort,
1807    that: impl CstDecode<crate::bindings::BindingEventListener>,
1808    e: impl CstDecode<crate::model::SdkEvent>,
1809) {
1810    FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::<flutter_rust_bridge::for_generated::DcoCodec, _, _>(
1811        flutter_rust_bridge::for_generated::TaskInfo {
1812            debug_name: "binding_event_listener_on_event",
1813            port: Some(port_),
1814            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
1815        },
1816        move || {
1817            let api_that = that.cst_decode();
1818            let api_e = e.cst_decode();
1819            move |context| {
1820                transform_result_dco::<_, _, ()>((move || {
1821                    let output_ok = Result::<_, ()>::Ok({
1822                        crate::bindings::BindingEventListener::on_event(&api_that, api_e);
1823                    })?;
1824                    Ok(output_ok)
1825                })())
1826            }
1827        },
1828    )
1829}
1830fn wire__crate__bindings__breez_log_stream_impl(
1831    port_: flutter_rust_bridge::for_generated::MessagePort,
1832    s: impl CstDecode<StreamSink<crate::model::LogEntry, flutter_rust_bridge::for_generated::DcoCodec>>,
1833) {
1834    FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::<flutter_rust_bridge::for_generated::DcoCodec, _, _>(
1835        flutter_rust_bridge::for_generated::TaskInfo {
1836            debug_name: "breez_log_stream",
1837            port: Some(port_),
1838            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
1839        },
1840        move || {
1841            let api_s = s.cst_decode();
1842            move |context| {
1843                transform_result_dco::<_, _, flutter_rust_bridge::for_generated::anyhow::Error>(
1844                    (move || {
1845                        let output_ok = crate::bindings::breez_log_stream(api_s)?;
1846                        Ok(output_ok)
1847                    })(),
1848                )
1849            }
1850        },
1851    )
1852}
1853fn wire__crate__bindings__connect_impl(
1854    port_: flutter_rust_bridge::for_generated::MessagePort,
1855    req: impl CstDecode<crate::model::ConnectRequest>,
1856) {
1857    FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::DcoCodec, _, _, _>(
1858        flutter_rust_bridge::for_generated::TaskInfo {
1859            debug_name: "connect",
1860            port: Some(port_),
1861            mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
1862        },
1863        move || {
1864            let api_req = req.cst_decode();
1865            move |context| async move {
1866                transform_result_dco::<_, _, crate::error::SdkError>(
1867                    (move || async move {
1868                        let output_ok = crate::bindings::connect(api_req).await?;
1869                        Ok(output_ok)
1870                    })()
1871                    .await,
1872                )
1873            }
1874        },
1875    )
1876}
1877fn wire__crate__bindings__default_config_impl(
1878    network: impl CstDecode<crate::model::LiquidNetwork>,
1879    breez_api_key: impl CstDecode<Option<String>>,
1880) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
1881    FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::DcoCodec, _>(
1882        flutter_rust_bridge::for_generated::TaskInfo {
1883            debug_name: "default_config",
1884            port: None,
1885            mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync,
1886        },
1887        move || {
1888            let api_network = network.cst_decode();
1889            let api_breez_api_key = breez_api_key.cst_decode();
1890            transform_result_dco::<_, _, crate::error::SdkError>((move || {
1891                let output_ok = crate::bindings::default_config(api_network, api_breez_api_key)?;
1892                Ok(output_ok)
1893            })())
1894        },
1895    )
1896}
1897fn wire__crate__bindings__parse_invoice_impl(
1898    input: impl CstDecode<String>,
1899) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
1900    FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::DcoCodec, _>(
1901        flutter_rust_bridge::for_generated::TaskInfo {
1902            debug_name: "parse_invoice",
1903            port: None,
1904            mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync,
1905        },
1906        move || {
1907            let api_input = input.cst_decode();
1908            transform_result_dco::<_, _, crate::error::PaymentError>((move || {
1909                let output_ok = crate::bindings::parse_invoice(api_input)?;
1910                Ok(output_ok)
1911            })())
1912        },
1913    )
1914}
1915
1916// Section: static_checks
1917
1918#[allow(clippy::unnecessary_literal_unwrap)]
1919const _: fn() = || {
1920    {
1921        let AesSuccessActionData = None::<crate::bindings::AesSuccessActionData>.unwrap();
1922        let _: String = AesSuccessActionData.description;
1923        let _: String = AesSuccessActionData.ciphertext;
1924        let _: String = AesSuccessActionData.iv;
1925    }
1926    {
1927        let AesSuccessActionDataDecrypted =
1928            None::<crate::bindings::AesSuccessActionDataDecrypted>.unwrap();
1929        let _: String = AesSuccessActionDataDecrypted.description;
1930        let _: String = AesSuccessActionDataDecrypted.plaintext;
1931    }
1932    match None::<crate::bindings::AesSuccessActionDataResult>.unwrap() {
1933        crate::bindings::AesSuccessActionDataResult::Decrypted { data } => {
1934            let _: crate::bindings::AesSuccessActionDataDecrypted = data;
1935        }
1936        crate::bindings::AesSuccessActionDataResult::ErrorStatus { reason } => {
1937            let _: String = reason;
1938        }
1939    }
1940    match None::<crate::bindings::Amount>.unwrap() {
1941        crate::bindings::Amount::Bitcoin { amount_msat } => {
1942            let _: u64 = amount_msat;
1943        }
1944        crate::bindings::Amount::Currency {
1945            iso4217_code,
1946            fractional_amount,
1947        } => {
1948            let _: String = iso4217_code;
1949            let _: u64 = fractional_amount;
1950        }
1951    }
1952    {
1953        let BitcoinAddressData = None::<crate::bindings::BitcoinAddressData>.unwrap();
1954        let _: String = BitcoinAddressData.address;
1955        let _: crate::bindings::Network = BitcoinAddressData.network;
1956        let _: Option<u64> = BitcoinAddressData.amount_sat;
1957        let _: Option<String> = BitcoinAddressData.label;
1958        let _: Option<String> = BitcoinAddressData.message;
1959    }
1960    {
1961        let CurrencyInfo = None::<crate::bindings::CurrencyInfo>.unwrap();
1962        let _: String = CurrencyInfo.name;
1963        let _: u32 = CurrencyInfo.fraction_size;
1964        let _: Option<u32> = CurrencyInfo.spacing;
1965        let _: Option<crate::bindings::Symbol> = CurrencyInfo.symbol;
1966        let _: Option<crate::bindings::Symbol> = CurrencyInfo.uniq_symbol;
1967        let _: Vec<crate::bindings::LocalizedName> = CurrencyInfo.localized_name;
1968        let _: Vec<crate::bindings::LocaleOverrides> = CurrencyInfo.locale_overrides;
1969    }
1970    {
1971        let ExternalInputParser = None::<crate::bindings::ExternalInputParser>.unwrap();
1972        let _: String = ExternalInputParser.provider_id;
1973        let _: String = ExternalInputParser.input_regex;
1974        let _: String = ExternalInputParser.parser_url;
1975    }
1976    {
1977        let FiatCurrency = None::<crate::bindings::FiatCurrency>.unwrap();
1978        let _: String = FiatCurrency.id;
1979        let _: crate::bindings::CurrencyInfo = FiatCurrency.info;
1980    }
1981    match None::<crate::bindings::InputType>.unwrap() {
1982        crate::bindings::InputType::BitcoinAddress { address } => {
1983            let _: crate::bindings::BitcoinAddressData = address;
1984        }
1985        crate::bindings::InputType::LiquidAddress { address } => {
1986            let _: crate::bindings::LiquidAddressData = address;
1987        }
1988        crate::bindings::InputType::Bolt11 { invoice } => {
1989            let _: crate::bindings::LNInvoice = invoice;
1990        }
1991        crate::bindings::InputType::Bolt12Offer {
1992            offer,
1993            bip353_address,
1994        } => {
1995            let _: crate::bindings::LNOffer = offer;
1996            let _: Option<String> = bip353_address;
1997        }
1998        crate::bindings::InputType::NodeId { node_id } => {
1999            let _: String = node_id;
2000        }
2001        crate::bindings::InputType::Url { url } => {
2002            let _: String = url;
2003        }
2004        crate::bindings::InputType::LnUrlPay {
2005            data,
2006            bip353_address,
2007        } => {
2008            let _: crate::bindings::LnUrlPayRequestData = data;
2009            let _: Option<String> = bip353_address;
2010        }
2011        crate::bindings::InputType::LnUrlWithdraw { data } => {
2012            let _: crate::bindings::LnUrlWithdrawRequestData = data;
2013        }
2014        crate::bindings::InputType::LnUrlAuth { data } => {
2015            let _: crate::bindings::LnUrlAuthRequestData = data;
2016        }
2017        crate::bindings::InputType::LnUrlError { data } => {
2018            let _: crate::bindings::LnUrlErrorData = data;
2019        }
2020    }
2021    {
2022        let LiquidAddressData = None::<crate::bindings::LiquidAddressData>.unwrap();
2023        let _: String = LiquidAddressData.address;
2024        let _: crate::bindings::Network = LiquidAddressData.network;
2025        let _: Option<String> = LiquidAddressData.asset_id;
2026        let _: Option<f64> = LiquidAddressData.amount;
2027        let _: Option<u64> = LiquidAddressData.amount_sat;
2028        let _: Option<String> = LiquidAddressData.label;
2029        let _: Option<String> = LiquidAddressData.message;
2030    }
2031    {
2032        let LNInvoice = None::<crate::bindings::LNInvoice>.unwrap();
2033        let _: String = LNInvoice.bolt11;
2034        let _: crate::bindings::Network = LNInvoice.network;
2035        let _: String = LNInvoice.payee_pubkey;
2036        let _: String = LNInvoice.payment_hash;
2037        let _: Option<String> = LNInvoice.description;
2038        let _: Option<String> = LNInvoice.description_hash;
2039        let _: Option<u64> = LNInvoice.amount_msat;
2040        let _: u64 = LNInvoice.timestamp;
2041        let _: u64 = LNInvoice.expiry;
2042        let _: Vec<crate::bindings::RouteHint> = LNInvoice.routing_hints;
2043        let _: Vec<u8> = LNInvoice.payment_secret;
2044        let _: u64 = LNInvoice.min_final_cltv_expiry_delta;
2045    }
2046    {
2047        let LNOffer = None::<crate::bindings::LNOffer>.unwrap();
2048        let _: String = LNOffer.offer;
2049        let _: Vec<String> = LNOffer.chains;
2050        let _: Option<crate::bindings::Amount> = LNOffer.min_amount;
2051        let _: Option<String> = LNOffer.description;
2052        let _: Option<u64> = LNOffer.absolute_expiry;
2053        let _: Option<String> = LNOffer.issuer;
2054        let _: Option<String> = LNOffer.signing_pubkey;
2055        let _: Vec<crate::bindings::LnOfferBlindedPath> = LNOffer.paths;
2056    }
2057    {
2058        let LnOfferBlindedPath = None::<crate::bindings::LnOfferBlindedPath>.unwrap();
2059        let _: Vec<String> = LnOfferBlindedPath.blinded_hops;
2060    }
2061    {
2062        let LnUrlAuthRequestData = None::<crate::bindings::LnUrlAuthRequestData>.unwrap();
2063        let _: String = LnUrlAuthRequestData.k1;
2064        let _: Option<String> = LnUrlAuthRequestData.action;
2065        let _: String = LnUrlAuthRequestData.domain;
2066        let _: String = LnUrlAuthRequestData.url;
2067    }
2068    {
2069        let LnUrlErrorData = None::<crate::bindings::LnUrlErrorData>.unwrap();
2070        let _: String = LnUrlErrorData.reason;
2071    }
2072    {
2073        let LnUrlPayErrorData = None::<crate::bindings::LnUrlPayErrorData>.unwrap();
2074        let _: String = LnUrlPayErrorData.payment_hash;
2075        let _: String = LnUrlPayErrorData.reason;
2076    }
2077    {
2078        let LnUrlPayRequestData = None::<crate::bindings::LnUrlPayRequestData>.unwrap();
2079        let _: String = LnUrlPayRequestData.callback;
2080        let _: u64 = LnUrlPayRequestData.min_sendable;
2081        let _: u64 = LnUrlPayRequestData.max_sendable;
2082        let _: String = LnUrlPayRequestData.metadata_str;
2083        let _: u16 = LnUrlPayRequestData.comment_allowed;
2084        let _: String = LnUrlPayRequestData.domain;
2085        let _: bool = LnUrlPayRequestData.allows_nostr;
2086        let _: Option<String> = LnUrlPayRequestData.nostr_pubkey;
2087        let _: Option<String> = LnUrlPayRequestData.ln_address;
2088    }
2089    {
2090        let LnUrlWithdrawRequest = None::<crate::bindings::LnUrlWithdrawRequest>.unwrap();
2091        let _: crate::bindings::LnUrlWithdrawRequestData = LnUrlWithdrawRequest.data;
2092        let _: u64 = LnUrlWithdrawRequest.amount_msat;
2093        let _: Option<String> = LnUrlWithdrawRequest.description;
2094    }
2095    {
2096        let LnUrlWithdrawRequestData = None::<crate::bindings::LnUrlWithdrawRequestData>.unwrap();
2097        let _: String = LnUrlWithdrawRequestData.callback;
2098        let _: String = LnUrlWithdrawRequestData.k1;
2099        let _: String = LnUrlWithdrawRequestData.default_description;
2100        let _: u64 = LnUrlWithdrawRequestData.min_withdrawable;
2101        let _: u64 = LnUrlWithdrawRequestData.max_withdrawable;
2102    }
2103    {
2104        let LocaleOverrides = None::<crate::bindings::LocaleOverrides>.unwrap();
2105        let _: String = LocaleOverrides.locale;
2106        let _: Option<u32> = LocaleOverrides.spacing;
2107        let _: crate::bindings::Symbol = LocaleOverrides.symbol;
2108    }
2109    {
2110        let LocalizedName = None::<crate::bindings::LocalizedName>.unwrap();
2111        let _: String = LocalizedName.locale;
2112        let _: String = LocalizedName.name;
2113    }
2114    {
2115        let MessageSuccessActionData = None::<crate::bindings::MessageSuccessActionData>.unwrap();
2116        let _: String = MessageSuccessActionData.message;
2117    }
2118    {
2119        let Rate = None::<crate::bindings::Rate>.unwrap();
2120        let _: String = Rate.coin;
2121        let _: f64 = Rate.value;
2122    }
2123    {
2124        let RouteHint = None::<crate::bindings::RouteHint>.unwrap();
2125        let _: Vec<crate::bindings::RouteHintHop> = RouteHint.hops;
2126    }
2127    {
2128        let RouteHintHop = None::<crate::bindings::RouteHintHop>.unwrap();
2129        let _: String = RouteHintHop.src_node_id;
2130        let _: String = RouteHintHop.short_channel_id;
2131        let _: u32 = RouteHintHop.fees_base_msat;
2132        let _: u32 = RouteHintHop.fees_proportional_millionths;
2133        let _: u64 = RouteHintHop.cltv_expiry_delta;
2134        let _: Option<u64> = RouteHintHop.htlc_minimum_msat;
2135        let _: Option<u64> = RouteHintHop.htlc_maximum_msat;
2136    }
2137    match None::<crate::bindings::SuccessAction>.unwrap() {
2138        crate::bindings::SuccessAction::Aes { data } => {
2139            let _: crate::bindings::AesSuccessActionData = data;
2140        }
2141        crate::bindings::SuccessAction::Message { data } => {
2142            let _: crate::bindings::MessageSuccessActionData = data;
2143        }
2144        crate::bindings::SuccessAction::Url { data } => {
2145            let _: crate::bindings::UrlSuccessActionData = data;
2146        }
2147    }
2148    match None::<crate::bindings::SuccessActionProcessed>.unwrap() {
2149        crate::bindings::SuccessActionProcessed::Aes { result } => {
2150            let _: crate::bindings::AesSuccessActionDataResult = result;
2151        }
2152        crate::bindings::SuccessActionProcessed::Message { data } => {
2153            let _: crate::bindings::MessageSuccessActionData = data;
2154        }
2155        crate::bindings::SuccessActionProcessed::Url { data } => {
2156            let _: crate::bindings::UrlSuccessActionData = data;
2157        }
2158    }
2159    {
2160        let Symbol = None::<crate::bindings::Symbol>.unwrap();
2161        let _: Option<String> = Symbol.grapheme;
2162        let _: Option<String> = Symbol.template;
2163        let _: Option<bool> = Symbol.rtl;
2164        let _: Option<u32> = Symbol.position;
2165    }
2166    {
2167        let UrlSuccessActionData = None::<crate::bindings::UrlSuccessActionData>.unwrap();
2168        let _: String = UrlSuccessActionData.description;
2169        let _: String = UrlSuccessActionData.url;
2170        let _: bool = UrlSuccessActionData.matches_callback_domain;
2171    }
2172};
2173
2174// Section: dart2rust
2175
2176impl CstDecode<bool> for bool {
2177    // Codec=Cst (C-struct based), see doc to use other codecs
2178    fn cst_decode(self) -> bool {
2179        self
2180    }
2181}
2182impl CstDecode<crate::model::BuyBitcoinProvider> for i32 {
2183    // Codec=Cst (C-struct based), see doc to use other codecs
2184    fn cst_decode(self) -> crate::model::BuyBitcoinProvider {
2185        match self {
2186            0 => crate::model::BuyBitcoinProvider::Moonpay,
2187            _ => unreachable!("Invalid variant for BuyBitcoinProvider: {}", self),
2188        }
2189    }
2190}
2191impl CstDecode<f64> for f64 {
2192    // Codec=Cst (C-struct based), see doc to use other codecs
2193    fn cst_decode(self) -> f64 {
2194        self
2195    }
2196}
2197impl CstDecode<i32> for i32 {
2198    // Codec=Cst (C-struct based), see doc to use other codecs
2199    fn cst_decode(self) -> i32 {
2200        self
2201    }
2202}
2203impl CstDecode<i64> for i64 {
2204    // Codec=Cst (C-struct based), see doc to use other codecs
2205    fn cst_decode(self) -> i64 {
2206        self
2207    }
2208}
2209impl CstDecode<crate::model::LiquidNetwork> for i32 {
2210    // Codec=Cst (C-struct based), see doc to use other codecs
2211    fn cst_decode(self) -> crate::model::LiquidNetwork {
2212        match self {
2213            0 => crate::model::LiquidNetwork::Mainnet,
2214            1 => crate::model::LiquidNetwork::Testnet,
2215            2 => crate::model::LiquidNetwork::Regtest,
2216            _ => unreachable!("Invalid variant for LiquidNetwork: {}", self),
2217        }
2218    }
2219}
2220impl CstDecode<crate::bindings::Network> for i32 {
2221    // Codec=Cst (C-struct based), see doc to use other codecs
2222    fn cst_decode(self) -> crate::bindings::Network {
2223        match self {
2224            0 => crate::bindings::Network::Bitcoin,
2225            1 => crate::bindings::Network::Testnet,
2226            2 => crate::bindings::Network::Signet,
2227            3 => crate::bindings::Network::Regtest,
2228            _ => unreachable!("Invalid variant for Network: {}", self),
2229        }
2230    }
2231}
2232impl CstDecode<crate::model::PaymentMethod> for i32 {
2233    // Codec=Cst (C-struct based), see doc to use other codecs
2234    fn cst_decode(self) -> crate::model::PaymentMethod {
2235        match self {
2236            0 => crate::model::PaymentMethod::Lightning,
2237            1 => crate::model::PaymentMethod::Bolt11Invoice,
2238            2 => crate::model::PaymentMethod::Bolt12Offer,
2239            3 => crate::model::PaymentMethod::BitcoinAddress,
2240            4 => crate::model::PaymentMethod::LiquidAddress,
2241            _ => unreachable!("Invalid variant for PaymentMethod: {}", self),
2242        }
2243    }
2244}
2245impl CstDecode<crate::model::PaymentState> for i32 {
2246    // Codec=Cst (C-struct based), see doc to use other codecs
2247    fn cst_decode(self) -> crate::model::PaymentState {
2248        match self {
2249            0 => crate::model::PaymentState::Created,
2250            1 => crate::model::PaymentState::Pending,
2251            2 => crate::model::PaymentState::Complete,
2252            3 => crate::model::PaymentState::Failed,
2253            4 => crate::model::PaymentState::TimedOut,
2254            5 => crate::model::PaymentState::Refundable,
2255            6 => crate::model::PaymentState::RefundPending,
2256            7 => crate::model::PaymentState::WaitingFeeAcceptance,
2257            _ => unreachable!("Invalid variant for PaymentState: {}", self),
2258        }
2259    }
2260}
2261impl CstDecode<crate::model::PaymentType> for i32 {
2262    // Codec=Cst (C-struct based), see doc to use other codecs
2263    fn cst_decode(self) -> crate::model::PaymentType {
2264        match self {
2265            0 => crate::model::PaymentType::Receive,
2266            1 => crate::model::PaymentType::Send,
2267            _ => unreachable!("Invalid variant for PaymentType: {}", self),
2268        }
2269    }
2270}
2271impl CstDecode<u16> for u16 {
2272    // Codec=Cst (C-struct based), see doc to use other codecs
2273    fn cst_decode(self) -> u16 {
2274        self
2275    }
2276}
2277impl CstDecode<u32> for u32 {
2278    // Codec=Cst (C-struct based), see doc to use other codecs
2279    fn cst_decode(self) -> u32 {
2280        self
2281    }
2282}
2283impl CstDecode<u64> for u64 {
2284    // Codec=Cst (C-struct based), see doc to use other codecs
2285    fn cst_decode(self) -> u64 {
2286        self
2287    }
2288}
2289impl CstDecode<u8> for u8 {
2290    // Codec=Cst (C-struct based), see doc to use other codecs
2291    fn cst_decode(self) -> u8 {
2292        self
2293    }
2294}
2295impl CstDecode<usize> for usize {
2296    // Codec=Cst (C-struct based), see doc to use other codecs
2297    fn cst_decode(self) -> usize {
2298        self
2299    }
2300}
2301impl SseDecode for flutter_rust_bridge::for_generated::anyhow::Error {
2302    // Codec=Sse (Serialization based), see doc to use other codecs
2303    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2304        let mut inner = <String>::sse_decode(deserializer);
2305        return flutter_rust_bridge::for_generated::anyhow::anyhow!("{}", inner);
2306    }
2307}
2308
2309impl SseDecode for BindingLiquidSdk {
2310    // Codec=Sse (Serialization based), see doc to use other codecs
2311    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2312        let mut inner = <RustOpaqueNom<
2313            flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>,
2314        >>::sse_decode(deserializer);
2315        return flutter_rust_bridge::for_generated::rust_auto_opaque_decode_owned(inner);
2316    }
2317}
2318
2319impl SseDecode
2320    for RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>
2321{
2322    // Codec=Sse (Serialization based), see doc to use other codecs
2323    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2324        let mut inner = <usize>::sse_decode(deserializer);
2325        return unsafe { decode_rust_opaque_nom(inner) };
2326    }
2327}
2328
2329impl SseDecode
2330    for StreamSink<crate::model::LogEntry, flutter_rust_bridge::for_generated::DcoCodec>
2331{
2332    // Codec=Sse (Serialization based), see doc to use other codecs
2333    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2334        let mut inner = <String>::sse_decode(deserializer);
2335        return StreamSink::deserialize(inner);
2336    }
2337}
2338
2339impl SseDecode
2340    for StreamSink<crate::model::SdkEvent, flutter_rust_bridge::for_generated::DcoCodec>
2341{
2342    // Codec=Sse (Serialization based), see doc to use other codecs
2343    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2344        let mut inner = <String>::sse_decode(deserializer);
2345        return StreamSink::deserialize(inner);
2346    }
2347}
2348
2349impl SseDecode for String {
2350    // Codec=Sse (Serialization based), see doc to use other codecs
2351    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2352        let mut inner = <Vec<u8>>::sse_decode(deserializer);
2353        return String::from_utf8(inner).unwrap();
2354    }
2355}
2356
2357impl SseDecode for crate::model::AcceptPaymentProposedFeesRequest {
2358    // Codec=Sse (Serialization based), see doc to use other codecs
2359    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2360        let mut var_response =
2361            <crate::model::FetchPaymentProposedFeesResponse>::sse_decode(deserializer);
2362        return crate::model::AcceptPaymentProposedFeesRequest {
2363            response: var_response,
2364        };
2365    }
2366}
2367
2368impl SseDecode for crate::bindings::AesSuccessActionData {
2369    // Codec=Sse (Serialization based), see doc to use other codecs
2370    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2371        let mut var_description = <String>::sse_decode(deserializer);
2372        let mut var_ciphertext = <String>::sse_decode(deserializer);
2373        let mut var_iv = <String>::sse_decode(deserializer);
2374        return crate::bindings::AesSuccessActionData {
2375            description: var_description,
2376            ciphertext: var_ciphertext,
2377            iv: var_iv,
2378        };
2379    }
2380}
2381
2382impl SseDecode for crate::bindings::AesSuccessActionDataDecrypted {
2383    // Codec=Sse (Serialization based), see doc to use other codecs
2384    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2385        let mut var_description = <String>::sse_decode(deserializer);
2386        let mut var_plaintext = <String>::sse_decode(deserializer);
2387        return crate::bindings::AesSuccessActionDataDecrypted {
2388            description: var_description,
2389            plaintext: var_plaintext,
2390        };
2391    }
2392}
2393
2394impl SseDecode for crate::bindings::AesSuccessActionDataResult {
2395    // Codec=Sse (Serialization based), see doc to use other codecs
2396    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2397        let mut tag_ = <i32>::sse_decode(deserializer);
2398        match tag_ {
2399            0 => {
2400                let mut var_data =
2401                    <crate::bindings::AesSuccessActionDataDecrypted>::sse_decode(deserializer);
2402                return crate::bindings::AesSuccessActionDataResult::Decrypted { data: var_data };
2403            }
2404            1 => {
2405                let mut var_reason = <String>::sse_decode(deserializer);
2406                return crate::bindings::AesSuccessActionDataResult::ErrorStatus {
2407                    reason: var_reason,
2408                };
2409            }
2410            _ => {
2411                unimplemented!("");
2412            }
2413        }
2414    }
2415}
2416
2417impl SseDecode for crate::bindings::Amount {
2418    // Codec=Sse (Serialization based), see doc to use other codecs
2419    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2420        let mut tag_ = <i32>::sse_decode(deserializer);
2421        match tag_ {
2422            0 => {
2423                let mut var_amountMsat = <u64>::sse_decode(deserializer);
2424                return crate::bindings::Amount::Bitcoin {
2425                    amount_msat: var_amountMsat,
2426                };
2427            }
2428            1 => {
2429                let mut var_iso4217Code = <String>::sse_decode(deserializer);
2430                let mut var_fractionalAmount = <u64>::sse_decode(deserializer);
2431                return crate::bindings::Amount::Currency {
2432                    iso4217_code: var_iso4217Code,
2433                    fractional_amount: var_fractionalAmount,
2434                };
2435            }
2436            _ => {
2437                unimplemented!("");
2438            }
2439        }
2440    }
2441}
2442
2443impl SseDecode for crate::model::AssetBalance {
2444    // Codec=Sse (Serialization based), see doc to use other codecs
2445    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2446        let mut var_assetId = <String>::sse_decode(deserializer);
2447        let mut var_balanceSat = <u64>::sse_decode(deserializer);
2448        let mut var_name = <Option<String>>::sse_decode(deserializer);
2449        let mut var_ticker = <Option<String>>::sse_decode(deserializer);
2450        let mut var_balance = <Option<f64>>::sse_decode(deserializer);
2451        return crate::model::AssetBalance {
2452            asset_id: var_assetId,
2453            balance_sat: var_balanceSat,
2454            name: var_name,
2455            ticker: var_ticker,
2456            balance: var_balance,
2457        };
2458    }
2459}
2460
2461impl SseDecode for crate::model::AssetInfo {
2462    // Codec=Sse (Serialization based), see doc to use other codecs
2463    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2464        let mut var_name = <String>::sse_decode(deserializer);
2465        let mut var_ticker = <String>::sse_decode(deserializer);
2466        let mut var_amount = <f64>::sse_decode(deserializer);
2467        let mut var_fees = <Option<f64>>::sse_decode(deserializer);
2468        return crate::model::AssetInfo {
2469            name: var_name,
2470            ticker: var_ticker,
2471            amount: var_amount,
2472            fees: var_fees,
2473        };
2474    }
2475}
2476
2477impl SseDecode for crate::model::AssetMetadata {
2478    // Codec=Sse (Serialization based), see doc to use other codecs
2479    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2480        let mut var_assetId = <String>::sse_decode(deserializer);
2481        let mut var_name = <String>::sse_decode(deserializer);
2482        let mut var_ticker = <String>::sse_decode(deserializer);
2483        let mut var_precision = <u8>::sse_decode(deserializer);
2484        let mut var_fiatId = <Option<String>>::sse_decode(deserializer);
2485        return crate::model::AssetMetadata {
2486            asset_id: var_assetId,
2487            name: var_name,
2488            ticker: var_ticker,
2489            precision: var_precision,
2490            fiat_id: var_fiatId,
2491        };
2492    }
2493}
2494
2495impl SseDecode for crate::model::BackupRequest {
2496    // Codec=Sse (Serialization based), see doc to use other codecs
2497    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2498        let mut var_backupPath = <Option<String>>::sse_decode(deserializer);
2499        return crate::model::BackupRequest {
2500            backup_path: var_backupPath,
2501        };
2502    }
2503}
2504
2505impl SseDecode for crate::bindings::BindingEventListener {
2506    // Codec=Sse (Serialization based), see doc to use other codecs
2507    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2508        let mut var_stream = <StreamSink<
2509            crate::model::SdkEvent,
2510            flutter_rust_bridge::for_generated::DcoCodec,
2511        >>::sse_decode(deserializer);
2512        return crate::bindings::BindingEventListener { stream: var_stream };
2513    }
2514}
2515
2516impl SseDecode for crate::bindings::BitcoinAddressData {
2517    // Codec=Sse (Serialization based), see doc to use other codecs
2518    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2519        let mut var_address = <String>::sse_decode(deserializer);
2520        let mut var_network = <crate::bindings::Network>::sse_decode(deserializer);
2521        let mut var_amountSat = <Option<u64>>::sse_decode(deserializer);
2522        let mut var_label = <Option<String>>::sse_decode(deserializer);
2523        let mut var_message = <Option<String>>::sse_decode(deserializer);
2524        return crate::bindings::BitcoinAddressData {
2525            address: var_address,
2526            network: var_network,
2527            amount_sat: var_amountSat,
2528            label: var_label,
2529            message: var_message,
2530        };
2531    }
2532}
2533
2534impl SseDecode for crate::model::BlockchainExplorer {
2535    // Codec=Sse (Serialization based), see doc to use other codecs
2536    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2537        let mut tag_ = <i32>::sse_decode(deserializer);
2538        match tag_ {
2539            0 => {
2540                let mut var_url = <String>::sse_decode(deserializer);
2541                return crate::model::BlockchainExplorer::Electrum { url: var_url };
2542            }
2543            1 => {
2544                let mut var_url = <String>::sse_decode(deserializer);
2545                let mut var_useWaterfalls = <bool>::sse_decode(deserializer);
2546                return crate::model::BlockchainExplorer::Esplora {
2547                    url: var_url,
2548                    use_waterfalls: var_useWaterfalls,
2549                };
2550            }
2551            _ => {
2552                unimplemented!("");
2553            }
2554        }
2555    }
2556}
2557
2558impl SseDecode for crate::model::BlockchainInfo {
2559    // Codec=Sse (Serialization based), see doc to use other codecs
2560    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2561        let mut var_liquidTip = <u32>::sse_decode(deserializer);
2562        let mut var_bitcoinTip = <u32>::sse_decode(deserializer);
2563        return crate::model::BlockchainInfo {
2564            liquid_tip: var_liquidTip,
2565            bitcoin_tip: var_bitcoinTip,
2566        };
2567    }
2568}
2569
2570impl SseDecode for bool {
2571    // Codec=Sse (Serialization based), see doc to use other codecs
2572    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2573        deserializer.cursor.read_u8().unwrap() != 0
2574    }
2575}
2576
2577impl SseDecode for crate::model::BuyBitcoinProvider {
2578    // Codec=Sse (Serialization based), see doc to use other codecs
2579    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2580        let mut inner = <i32>::sse_decode(deserializer);
2581        return match inner {
2582            0 => crate::model::BuyBitcoinProvider::Moonpay,
2583            _ => unreachable!("Invalid variant for BuyBitcoinProvider: {}", inner),
2584        };
2585    }
2586}
2587
2588impl SseDecode for crate::model::BuyBitcoinRequest {
2589    // Codec=Sse (Serialization based), see doc to use other codecs
2590    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2591        let mut var_prepareResponse =
2592            <crate::model::PrepareBuyBitcoinResponse>::sse_decode(deserializer);
2593        let mut var_redirectUrl = <Option<String>>::sse_decode(deserializer);
2594        return crate::model::BuyBitcoinRequest {
2595            prepare_response: var_prepareResponse,
2596            redirect_url: var_redirectUrl,
2597        };
2598    }
2599}
2600
2601impl SseDecode for crate::model::CheckMessageRequest {
2602    // Codec=Sse (Serialization based), see doc to use other codecs
2603    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2604        let mut var_message = <String>::sse_decode(deserializer);
2605        let mut var_pubkey = <String>::sse_decode(deserializer);
2606        let mut var_signature = <String>::sse_decode(deserializer);
2607        return crate::model::CheckMessageRequest {
2608            message: var_message,
2609            pubkey: var_pubkey,
2610            signature: var_signature,
2611        };
2612    }
2613}
2614
2615impl SseDecode for crate::model::CheckMessageResponse {
2616    // Codec=Sse (Serialization based), see doc to use other codecs
2617    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2618        let mut var_isValid = <bool>::sse_decode(deserializer);
2619        return crate::model::CheckMessageResponse {
2620            is_valid: var_isValid,
2621        };
2622    }
2623}
2624
2625impl SseDecode for crate::model::Config {
2626    // Codec=Sse (Serialization based), see doc to use other codecs
2627    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2628        let mut var_liquidExplorer = <crate::model::BlockchainExplorer>::sse_decode(deserializer);
2629        let mut var_bitcoinExplorer = <crate::model::BlockchainExplorer>::sse_decode(deserializer);
2630        let mut var_workingDir = <String>::sse_decode(deserializer);
2631        let mut var_network = <crate::model::LiquidNetwork>::sse_decode(deserializer);
2632        let mut var_paymentTimeoutSec = <u64>::sse_decode(deserializer);
2633        let mut var_syncServiceUrl = <Option<String>>::sse_decode(deserializer);
2634        let mut var_zeroConfMaxAmountSat = <Option<u64>>::sse_decode(deserializer);
2635        let mut var_breezApiKey = <Option<String>>::sse_decode(deserializer);
2636        let mut var_externalInputParsers =
2637            <Option<Vec<crate::bindings::ExternalInputParser>>>::sse_decode(deserializer);
2638        let mut var_useDefaultExternalInputParsers = <bool>::sse_decode(deserializer);
2639        let mut var_onchainFeeRateLeewaySatPerVbyte = <Option<u32>>::sse_decode(deserializer);
2640        let mut var_assetMetadata =
2641            <Option<Vec<crate::model::AssetMetadata>>>::sse_decode(deserializer);
2642        let mut var_sideswapApiKey = <Option<String>>::sse_decode(deserializer);
2643        return crate::model::Config {
2644            liquid_explorer: var_liquidExplorer,
2645            bitcoin_explorer: var_bitcoinExplorer,
2646            working_dir: var_workingDir,
2647            network: var_network,
2648            payment_timeout_sec: var_paymentTimeoutSec,
2649            sync_service_url: var_syncServiceUrl,
2650            zero_conf_max_amount_sat: var_zeroConfMaxAmountSat,
2651            breez_api_key: var_breezApiKey,
2652            external_input_parsers: var_externalInputParsers,
2653            use_default_external_input_parsers: var_useDefaultExternalInputParsers,
2654            onchain_fee_rate_leeway_sat_per_vbyte: var_onchainFeeRateLeewaySatPerVbyte,
2655            asset_metadata: var_assetMetadata,
2656            sideswap_api_key: var_sideswapApiKey,
2657        };
2658    }
2659}
2660
2661impl SseDecode for crate::model::ConnectRequest {
2662    // Codec=Sse (Serialization based), see doc to use other codecs
2663    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2664        let mut var_config = <crate::model::Config>::sse_decode(deserializer);
2665        let mut var_mnemonic = <Option<String>>::sse_decode(deserializer);
2666        let mut var_passphrase = <Option<String>>::sse_decode(deserializer);
2667        let mut var_seed = <Option<Vec<u8>>>::sse_decode(deserializer);
2668        return crate::model::ConnectRequest {
2669            config: var_config,
2670            mnemonic: var_mnemonic,
2671            passphrase: var_passphrase,
2672            seed: var_seed,
2673        };
2674    }
2675}
2676
2677impl SseDecode for crate::model::CreateBolt12InvoiceRequest {
2678    // Codec=Sse (Serialization based), see doc to use other codecs
2679    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2680        let mut var_offer = <String>::sse_decode(deserializer);
2681        let mut var_invoiceRequest = <String>::sse_decode(deserializer);
2682        return crate::model::CreateBolt12InvoiceRequest {
2683            offer: var_offer,
2684            invoice_request: var_invoiceRequest,
2685        };
2686    }
2687}
2688
2689impl SseDecode for crate::model::CreateBolt12InvoiceResponse {
2690    // Codec=Sse (Serialization based), see doc to use other codecs
2691    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2692        let mut var_invoice = <String>::sse_decode(deserializer);
2693        return crate::model::CreateBolt12InvoiceResponse {
2694            invoice: var_invoice,
2695        };
2696    }
2697}
2698
2699impl SseDecode for crate::bindings::CurrencyInfo {
2700    // Codec=Sse (Serialization based), see doc to use other codecs
2701    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2702        let mut var_name = <String>::sse_decode(deserializer);
2703        let mut var_fractionSize = <u32>::sse_decode(deserializer);
2704        let mut var_spacing = <Option<u32>>::sse_decode(deserializer);
2705        let mut var_symbol = <Option<crate::bindings::Symbol>>::sse_decode(deserializer);
2706        let mut var_uniqSymbol = <Option<crate::bindings::Symbol>>::sse_decode(deserializer);
2707        let mut var_localizedName = <Vec<crate::bindings::LocalizedName>>::sse_decode(deserializer);
2708        let mut var_localeOverrides =
2709            <Vec<crate::bindings::LocaleOverrides>>::sse_decode(deserializer);
2710        return crate::bindings::CurrencyInfo {
2711            name: var_name,
2712            fraction_size: var_fractionSize,
2713            spacing: var_spacing,
2714            symbol: var_symbol,
2715            uniq_symbol: var_uniqSymbol,
2716            localized_name: var_localizedName,
2717            locale_overrides: var_localeOverrides,
2718        };
2719    }
2720}
2721
2722impl SseDecode for crate::bindings::ExternalInputParser {
2723    // Codec=Sse (Serialization based), see doc to use other codecs
2724    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2725        let mut var_providerId = <String>::sse_decode(deserializer);
2726        let mut var_inputRegex = <String>::sse_decode(deserializer);
2727        let mut var_parserUrl = <String>::sse_decode(deserializer);
2728        return crate::bindings::ExternalInputParser {
2729            provider_id: var_providerId,
2730            input_regex: var_inputRegex,
2731            parser_url: var_parserUrl,
2732        };
2733    }
2734}
2735
2736impl SseDecode for f64 {
2737    // Codec=Sse (Serialization based), see doc to use other codecs
2738    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2739        deserializer.cursor.read_f64::<NativeEndian>().unwrap()
2740    }
2741}
2742
2743impl SseDecode for crate::model::FetchPaymentProposedFeesRequest {
2744    // Codec=Sse (Serialization based), see doc to use other codecs
2745    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2746        let mut var_swapId = <String>::sse_decode(deserializer);
2747        return crate::model::FetchPaymentProposedFeesRequest {
2748            swap_id: var_swapId,
2749        };
2750    }
2751}
2752
2753impl SseDecode for crate::model::FetchPaymentProposedFeesResponse {
2754    // Codec=Sse (Serialization based), see doc to use other codecs
2755    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2756        let mut var_swapId = <String>::sse_decode(deserializer);
2757        let mut var_feesSat = <u64>::sse_decode(deserializer);
2758        let mut var_payerAmountSat = <u64>::sse_decode(deserializer);
2759        let mut var_receiverAmountSat = <u64>::sse_decode(deserializer);
2760        return crate::model::FetchPaymentProposedFeesResponse {
2761            swap_id: var_swapId,
2762            fees_sat: var_feesSat,
2763            payer_amount_sat: var_payerAmountSat,
2764            receiver_amount_sat: var_receiverAmountSat,
2765        };
2766    }
2767}
2768
2769impl SseDecode for crate::bindings::FiatCurrency {
2770    // Codec=Sse (Serialization based), see doc to use other codecs
2771    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2772        let mut var_id = <String>::sse_decode(deserializer);
2773        let mut var_info = <crate::bindings::CurrencyInfo>::sse_decode(deserializer);
2774        return crate::bindings::FiatCurrency {
2775            id: var_id,
2776            info: var_info,
2777        };
2778    }
2779}
2780
2781impl SseDecode for crate::model::GetInfoResponse {
2782    // Codec=Sse (Serialization based), see doc to use other codecs
2783    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2784        let mut var_walletInfo = <crate::model::WalletInfo>::sse_decode(deserializer);
2785        let mut var_blockchainInfo = <crate::model::BlockchainInfo>::sse_decode(deserializer);
2786        return crate::model::GetInfoResponse {
2787            wallet_info: var_walletInfo,
2788            blockchain_info: var_blockchainInfo,
2789        };
2790    }
2791}
2792
2793impl SseDecode for crate::model::GetPaymentRequest {
2794    // Codec=Sse (Serialization based), see doc to use other codecs
2795    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2796        let mut tag_ = <i32>::sse_decode(deserializer);
2797        match tag_ {
2798            0 => {
2799                let mut var_paymentHash = <String>::sse_decode(deserializer);
2800                return crate::model::GetPaymentRequest::PaymentHash {
2801                    payment_hash: var_paymentHash,
2802                };
2803            }
2804            1 => {
2805                let mut var_swapId = <String>::sse_decode(deserializer);
2806                return crate::model::GetPaymentRequest::SwapId {
2807                    swap_id: var_swapId,
2808                };
2809            }
2810            _ => {
2811                unimplemented!("");
2812            }
2813        }
2814    }
2815}
2816
2817impl SseDecode for i32 {
2818    // Codec=Sse (Serialization based), see doc to use other codecs
2819    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2820        deserializer.cursor.read_i32::<NativeEndian>().unwrap()
2821    }
2822}
2823
2824impl SseDecode for i64 {
2825    // Codec=Sse (Serialization based), see doc to use other codecs
2826    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2827        deserializer.cursor.read_i64::<NativeEndian>().unwrap()
2828    }
2829}
2830
2831impl SseDecode for crate::bindings::InputType {
2832    // Codec=Sse (Serialization based), see doc to use other codecs
2833    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2834        let mut tag_ = <i32>::sse_decode(deserializer);
2835        match tag_ {
2836            0 => {
2837                let mut var_address =
2838                    <crate::bindings::BitcoinAddressData>::sse_decode(deserializer);
2839                return crate::bindings::InputType::BitcoinAddress {
2840                    address: var_address,
2841                };
2842            }
2843            1 => {
2844                let mut var_address =
2845                    <crate::bindings::LiquidAddressData>::sse_decode(deserializer);
2846                return crate::bindings::InputType::LiquidAddress {
2847                    address: var_address,
2848                };
2849            }
2850            2 => {
2851                let mut var_invoice = <crate::bindings::LNInvoice>::sse_decode(deserializer);
2852                return crate::bindings::InputType::Bolt11 {
2853                    invoice: var_invoice,
2854                };
2855            }
2856            3 => {
2857                let mut var_offer = <crate::bindings::LNOffer>::sse_decode(deserializer);
2858                let mut var_bip353Address = <Option<String>>::sse_decode(deserializer);
2859                return crate::bindings::InputType::Bolt12Offer {
2860                    offer: var_offer,
2861                    bip353_address: var_bip353Address,
2862                };
2863            }
2864            4 => {
2865                let mut var_nodeId = <String>::sse_decode(deserializer);
2866                return crate::bindings::InputType::NodeId {
2867                    node_id: var_nodeId,
2868                };
2869            }
2870            5 => {
2871                let mut var_url = <String>::sse_decode(deserializer);
2872                return crate::bindings::InputType::Url { url: var_url };
2873            }
2874            6 => {
2875                let mut var_data = <crate::bindings::LnUrlPayRequestData>::sse_decode(deserializer);
2876                let mut var_bip353Address = <Option<String>>::sse_decode(deserializer);
2877                return crate::bindings::InputType::LnUrlPay {
2878                    data: var_data,
2879                    bip353_address: var_bip353Address,
2880                };
2881            }
2882            7 => {
2883                let mut var_data =
2884                    <crate::bindings::LnUrlWithdrawRequestData>::sse_decode(deserializer);
2885                return crate::bindings::InputType::LnUrlWithdraw { data: var_data };
2886            }
2887            8 => {
2888                let mut var_data =
2889                    <crate::bindings::LnUrlAuthRequestData>::sse_decode(deserializer);
2890                return crate::bindings::InputType::LnUrlAuth { data: var_data };
2891            }
2892            9 => {
2893                let mut var_data = <crate::bindings::LnUrlErrorData>::sse_decode(deserializer);
2894                return crate::bindings::InputType::LnUrlError { data: var_data };
2895            }
2896            _ => {
2897                unimplemented!("");
2898            }
2899        }
2900    }
2901}
2902
2903impl SseDecode for crate::model::LightningPaymentLimitsResponse {
2904    // Codec=Sse (Serialization based), see doc to use other codecs
2905    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2906        let mut var_send = <crate::model::Limits>::sse_decode(deserializer);
2907        let mut var_receive = <crate::model::Limits>::sse_decode(deserializer);
2908        return crate::model::LightningPaymentLimitsResponse {
2909            send: var_send,
2910            receive: var_receive,
2911        };
2912    }
2913}
2914
2915impl SseDecode for crate::model::Limits {
2916    // Codec=Sse (Serialization based), see doc to use other codecs
2917    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2918        let mut var_minSat = <u64>::sse_decode(deserializer);
2919        let mut var_maxSat = <u64>::sse_decode(deserializer);
2920        let mut var_maxZeroConfSat = <u64>::sse_decode(deserializer);
2921        return crate::model::Limits {
2922            min_sat: var_minSat,
2923            max_sat: var_maxSat,
2924            max_zero_conf_sat: var_maxZeroConfSat,
2925        };
2926    }
2927}
2928
2929impl SseDecode for crate::bindings::LiquidAddressData {
2930    // Codec=Sse (Serialization based), see doc to use other codecs
2931    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2932        let mut var_address = <String>::sse_decode(deserializer);
2933        let mut var_network = <crate::bindings::Network>::sse_decode(deserializer);
2934        let mut var_assetId = <Option<String>>::sse_decode(deserializer);
2935        let mut var_amount = <Option<f64>>::sse_decode(deserializer);
2936        let mut var_amountSat = <Option<u64>>::sse_decode(deserializer);
2937        let mut var_label = <Option<String>>::sse_decode(deserializer);
2938        let mut var_message = <Option<String>>::sse_decode(deserializer);
2939        return crate::bindings::LiquidAddressData {
2940            address: var_address,
2941            network: var_network,
2942            asset_id: var_assetId,
2943            amount: var_amount,
2944            amount_sat: var_amountSat,
2945            label: var_label,
2946            message: var_message,
2947        };
2948    }
2949}
2950
2951impl SseDecode for crate::model::LiquidNetwork {
2952    // Codec=Sse (Serialization based), see doc to use other codecs
2953    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2954        let mut inner = <i32>::sse_decode(deserializer);
2955        return match inner {
2956            0 => crate::model::LiquidNetwork::Mainnet,
2957            1 => crate::model::LiquidNetwork::Testnet,
2958            2 => crate::model::LiquidNetwork::Regtest,
2959            _ => unreachable!("Invalid variant for LiquidNetwork: {}", inner),
2960        };
2961    }
2962}
2963
2964impl SseDecode for Vec<String> {
2965    // Codec=Sse (Serialization based), see doc to use other codecs
2966    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2967        let mut len_ = <i32>::sse_decode(deserializer);
2968        let mut ans_ = vec![];
2969        for idx_ in 0..len_ {
2970            ans_.push(<String>::sse_decode(deserializer));
2971        }
2972        return ans_;
2973    }
2974}
2975
2976impl SseDecode for Vec<crate::model::AssetBalance> {
2977    // Codec=Sse (Serialization based), see doc to use other codecs
2978    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2979        let mut len_ = <i32>::sse_decode(deserializer);
2980        let mut ans_ = vec![];
2981        for idx_ in 0..len_ {
2982            ans_.push(<crate::model::AssetBalance>::sse_decode(deserializer));
2983        }
2984        return ans_;
2985    }
2986}
2987
2988impl SseDecode for Vec<crate::model::AssetMetadata> {
2989    // Codec=Sse (Serialization based), see doc to use other codecs
2990    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
2991        let mut len_ = <i32>::sse_decode(deserializer);
2992        let mut ans_ = vec![];
2993        for idx_ in 0..len_ {
2994            ans_.push(<crate::model::AssetMetadata>::sse_decode(deserializer));
2995        }
2996        return ans_;
2997    }
2998}
2999
3000impl SseDecode for Vec<crate::bindings::ExternalInputParser> {
3001    // Codec=Sse (Serialization based), see doc to use other codecs
3002    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3003        let mut len_ = <i32>::sse_decode(deserializer);
3004        let mut ans_ = vec![];
3005        for idx_ in 0..len_ {
3006            ans_.push(<crate::bindings::ExternalInputParser>::sse_decode(
3007                deserializer,
3008            ));
3009        }
3010        return ans_;
3011    }
3012}
3013
3014impl SseDecode for Vec<crate::bindings::FiatCurrency> {
3015    // Codec=Sse (Serialization based), see doc to use other codecs
3016    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3017        let mut len_ = <i32>::sse_decode(deserializer);
3018        let mut ans_ = vec![];
3019        for idx_ in 0..len_ {
3020            ans_.push(<crate::bindings::FiatCurrency>::sse_decode(deserializer));
3021        }
3022        return ans_;
3023    }
3024}
3025
3026impl SseDecode for Vec<crate::bindings::LnOfferBlindedPath> {
3027    // Codec=Sse (Serialization based), see doc to use other codecs
3028    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3029        let mut len_ = <i32>::sse_decode(deserializer);
3030        let mut ans_ = vec![];
3031        for idx_ in 0..len_ {
3032            ans_.push(<crate::bindings::LnOfferBlindedPath>::sse_decode(
3033                deserializer,
3034            ));
3035        }
3036        return ans_;
3037    }
3038}
3039
3040impl SseDecode for Vec<crate::bindings::LocaleOverrides> {
3041    // Codec=Sse (Serialization based), see doc to use other codecs
3042    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3043        let mut len_ = <i32>::sse_decode(deserializer);
3044        let mut ans_ = vec![];
3045        for idx_ in 0..len_ {
3046            ans_.push(<crate::bindings::LocaleOverrides>::sse_decode(deserializer));
3047        }
3048        return ans_;
3049    }
3050}
3051
3052impl SseDecode for Vec<crate::bindings::LocalizedName> {
3053    // Codec=Sse (Serialization based), see doc to use other codecs
3054    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3055        let mut len_ = <i32>::sse_decode(deserializer);
3056        let mut ans_ = vec![];
3057        for idx_ in 0..len_ {
3058            ans_.push(<crate::bindings::LocalizedName>::sse_decode(deserializer));
3059        }
3060        return ans_;
3061    }
3062}
3063
3064impl SseDecode for Vec<crate::model::Payment> {
3065    // Codec=Sse (Serialization based), see doc to use other codecs
3066    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3067        let mut len_ = <i32>::sse_decode(deserializer);
3068        let mut ans_ = vec![];
3069        for idx_ in 0..len_ {
3070            ans_.push(<crate::model::Payment>::sse_decode(deserializer));
3071        }
3072        return ans_;
3073    }
3074}
3075
3076impl SseDecode for crate::model::ListPaymentDetails {
3077    // Codec=Sse (Serialization based), see doc to use other codecs
3078    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3079        let mut tag_ = <i32>::sse_decode(deserializer);
3080        match tag_ {
3081            0 => {
3082                let mut var_assetId = <Option<String>>::sse_decode(deserializer);
3083                let mut var_destination = <Option<String>>::sse_decode(deserializer);
3084                return crate::model::ListPaymentDetails::Liquid {
3085                    asset_id: var_assetId,
3086                    destination: var_destination,
3087                };
3088            }
3089            1 => {
3090                let mut var_address = <Option<String>>::sse_decode(deserializer);
3091                return crate::model::ListPaymentDetails::Bitcoin {
3092                    address: var_address,
3093                };
3094            }
3095            _ => {
3096                unimplemented!("");
3097            }
3098        }
3099    }
3100}
3101
3102impl SseDecode for Vec<crate::model::PaymentState> {
3103    // Codec=Sse (Serialization based), see doc to use other codecs
3104    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3105        let mut len_ = <i32>::sse_decode(deserializer);
3106        let mut ans_ = vec![];
3107        for idx_ in 0..len_ {
3108            ans_.push(<crate::model::PaymentState>::sse_decode(deserializer));
3109        }
3110        return ans_;
3111    }
3112}
3113
3114impl SseDecode for Vec<crate::model::PaymentType> {
3115    // Codec=Sse (Serialization based), see doc to use other codecs
3116    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3117        let mut len_ = <i32>::sse_decode(deserializer);
3118        let mut ans_ = vec![];
3119        for idx_ in 0..len_ {
3120            ans_.push(<crate::model::PaymentType>::sse_decode(deserializer));
3121        }
3122        return ans_;
3123    }
3124}
3125
3126impl SseDecode for crate::model::ListPaymentsRequest {
3127    // Codec=Sse (Serialization based), see doc to use other codecs
3128    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3129        let mut var_filters = <Option<Vec<crate::model::PaymentType>>>::sse_decode(deserializer);
3130        let mut var_states = <Option<Vec<crate::model::PaymentState>>>::sse_decode(deserializer);
3131        let mut var_fromTimestamp = <Option<i64>>::sse_decode(deserializer);
3132        let mut var_toTimestamp = <Option<i64>>::sse_decode(deserializer);
3133        let mut var_offset = <Option<u32>>::sse_decode(deserializer);
3134        let mut var_limit = <Option<u32>>::sse_decode(deserializer);
3135        let mut var_details = <Option<crate::model::ListPaymentDetails>>::sse_decode(deserializer);
3136        let mut var_sortAscending = <Option<bool>>::sse_decode(deserializer);
3137        return crate::model::ListPaymentsRequest {
3138            filters: var_filters,
3139            states: var_states,
3140            from_timestamp: var_fromTimestamp,
3141            to_timestamp: var_toTimestamp,
3142            offset: var_offset,
3143            limit: var_limit,
3144            details: var_details,
3145            sort_ascending: var_sortAscending,
3146        };
3147    }
3148}
3149
3150impl SseDecode for Vec<u8> {
3151    // Codec=Sse (Serialization based), see doc to use other codecs
3152    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3153        let mut len_ = <i32>::sse_decode(deserializer);
3154        let mut ans_ = vec![];
3155        for idx_ in 0..len_ {
3156            ans_.push(<u8>::sse_decode(deserializer));
3157        }
3158        return ans_;
3159    }
3160}
3161
3162impl SseDecode for Vec<crate::bindings::Rate> {
3163    // Codec=Sse (Serialization based), see doc to use other codecs
3164    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3165        let mut len_ = <i32>::sse_decode(deserializer);
3166        let mut ans_ = vec![];
3167        for idx_ in 0..len_ {
3168            ans_.push(<crate::bindings::Rate>::sse_decode(deserializer));
3169        }
3170        return ans_;
3171    }
3172}
3173
3174impl SseDecode for Vec<crate::model::RefundableSwap> {
3175    // Codec=Sse (Serialization based), see doc to use other codecs
3176    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3177        let mut len_ = <i32>::sse_decode(deserializer);
3178        let mut ans_ = vec![];
3179        for idx_ in 0..len_ {
3180            ans_.push(<crate::model::RefundableSwap>::sse_decode(deserializer));
3181        }
3182        return ans_;
3183    }
3184}
3185
3186impl SseDecode for Vec<crate::bindings::RouteHint> {
3187    // Codec=Sse (Serialization based), see doc to use other codecs
3188    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3189        let mut len_ = <i32>::sse_decode(deserializer);
3190        let mut ans_ = vec![];
3191        for idx_ in 0..len_ {
3192            ans_.push(<crate::bindings::RouteHint>::sse_decode(deserializer));
3193        }
3194        return ans_;
3195    }
3196}
3197
3198impl SseDecode for Vec<crate::bindings::RouteHintHop> {
3199    // Codec=Sse (Serialization based), see doc to use other codecs
3200    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3201        let mut len_ = <i32>::sse_decode(deserializer);
3202        let mut ans_ = vec![];
3203        for idx_ in 0..len_ {
3204            ans_.push(<crate::bindings::RouteHintHop>::sse_decode(deserializer));
3205        }
3206        return ans_;
3207    }
3208}
3209
3210impl SseDecode for crate::bindings::LNInvoice {
3211    // Codec=Sse (Serialization based), see doc to use other codecs
3212    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3213        let mut var_bolt11 = <String>::sse_decode(deserializer);
3214        let mut var_network = <crate::bindings::Network>::sse_decode(deserializer);
3215        let mut var_payeePubkey = <String>::sse_decode(deserializer);
3216        let mut var_paymentHash = <String>::sse_decode(deserializer);
3217        let mut var_description = <Option<String>>::sse_decode(deserializer);
3218        let mut var_descriptionHash = <Option<String>>::sse_decode(deserializer);
3219        let mut var_amountMsat = <Option<u64>>::sse_decode(deserializer);
3220        let mut var_timestamp = <u64>::sse_decode(deserializer);
3221        let mut var_expiry = <u64>::sse_decode(deserializer);
3222        let mut var_routingHints = <Vec<crate::bindings::RouteHint>>::sse_decode(deserializer);
3223        let mut var_paymentSecret = <Vec<u8>>::sse_decode(deserializer);
3224        let mut var_minFinalCltvExpiryDelta = <u64>::sse_decode(deserializer);
3225        return crate::bindings::LNInvoice {
3226            bolt11: var_bolt11,
3227            network: var_network,
3228            payee_pubkey: var_payeePubkey,
3229            payment_hash: var_paymentHash,
3230            description: var_description,
3231            description_hash: var_descriptionHash,
3232            amount_msat: var_amountMsat,
3233            timestamp: var_timestamp,
3234            expiry: var_expiry,
3235            routing_hints: var_routingHints,
3236            payment_secret: var_paymentSecret,
3237            min_final_cltv_expiry_delta: var_minFinalCltvExpiryDelta,
3238        };
3239    }
3240}
3241
3242impl SseDecode for crate::bindings::LNOffer {
3243    // Codec=Sse (Serialization based), see doc to use other codecs
3244    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3245        let mut var_offer = <String>::sse_decode(deserializer);
3246        let mut var_chains = <Vec<String>>::sse_decode(deserializer);
3247        let mut var_minAmount = <Option<crate::bindings::Amount>>::sse_decode(deserializer);
3248        let mut var_description = <Option<String>>::sse_decode(deserializer);
3249        let mut var_absoluteExpiry = <Option<u64>>::sse_decode(deserializer);
3250        let mut var_issuer = <Option<String>>::sse_decode(deserializer);
3251        let mut var_signingPubkey = <Option<String>>::sse_decode(deserializer);
3252        let mut var_paths = <Vec<crate::bindings::LnOfferBlindedPath>>::sse_decode(deserializer);
3253        return crate::bindings::LNOffer {
3254            offer: var_offer,
3255            chains: var_chains,
3256            min_amount: var_minAmount,
3257            description: var_description,
3258            absolute_expiry: var_absoluteExpiry,
3259            issuer: var_issuer,
3260            signing_pubkey: var_signingPubkey,
3261            paths: var_paths,
3262        };
3263    }
3264}
3265
3266impl SseDecode for crate::bindings::LnOfferBlindedPath {
3267    // Codec=Sse (Serialization based), see doc to use other codecs
3268    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3269        let mut var_blindedHops = <Vec<String>>::sse_decode(deserializer);
3270        return crate::bindings::LnOfferBlindedPath {
3271            blinded_hops: var_blindedHops,
3272        };
3273    }
3274}
3275
3276impl SseDecode for crate::bindings::duplicates::LnUrlAuthError {
3277    // Codec=Sse (Serialization based), see doc to use other codecs
3278    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3279        let mut tag_ = <i32>::sse_decode(deserializer);
3280        match tag_ {
3281            0 => {
3282                let mut var_err = <String>::sse_decode(deserializer);
3283                return crate::bindings::duplicates::LnUrlAuthError::Generic { err: var_err };
3284            }
3285            1 => {
3286                let mut var_err = <String>::sse_decode(deserializer);
3287                return crate::bindings::duplicates::LnUrlAuthError::InvalidUri { err: var_err };
3288            }
3289            2 => {
3290                let mut var_err = <String>::sse_decode(deserializer);
3291                return crate::bindings::duplicates::LnUrlAuthError::ServiceConnectivity {
3292                    err: var_err,
3293                };
3294            }
3295            _ => {
3296                unimplemented!("");
3297            }
3298        }
3299    }
3300}
3301
3302impl SseDecode for crate::bindings::LnUrlAuthRequestData {
3303    // Codec=Sse (Serialization based), see doc to use other codecs
3304    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3305        let mut var_k1 = <String>::sse_decode(deserializer);
3306        let mut var_action = <Option<String>>::sse_decode(deserializer);
3307        let mut var_domain = <String>::sse_decode(deserializer);
3308        let mut var_url = <String>::sse_decode(deserializer);
3309        return crate::bindings::LnUrlAuthRequestData {
3310            k1: var_k1,
3311            action: var_action,
3312            domain: var_domain,
3313            url: var_url,
3314        };
3315    }
3316}
3317
3318impl SseDecode for crate::bindings::duplicates::LnUrlCallbackStatus {
3319    // Codec=Sse (Serialization based), see doc to use other codecs
3320    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3321        let mut tag_ = <i32>::sse_decode(deserializer);
3322        match tag_ {
3323            0 => {
3324                return crate::bindings::duplicates::LnUrlCallbackStatus::Ok;
3325            }
3326            1 => {
3327                let mut var_data = <crate::bindings::LnUrlErrorData>::sse_decode(deserializer);
3328                return crate::bindings::duplicates::LnUrlCallbackStatus::ErrorStatus {
3329                    data: var_data,
3330                };
3331            }
3332            _ => {
3333                unimplemented!("");
3334            }
3335        }
3336    }
3337}
3338
3339impl SseDecode for crate::bindings::LnUrlErrorData {
3340    // Codec=Sse (Serialization based), see doc to use other codecs
3341    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3342        let mut var_reason = <String>::sse_decode(deserializer);
3343        return crate::bindings::LnUrlErrorData { reason: var_reason };
3344    }
3345}
3346
3347impl SseDecode for crate::model::LnUrlInfo {
3348    // Codec=Sse (Serialization based), see doc to use other codecs
3349    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3350        let mut var_lnAddress = <Option<String>>::sse_decode(deserializer);
3351        let mut var_lnurlPayComment = <Option<String>>::sse_decode(deserializer);
3352        let mut var_lnurlPayDomain = <Option<String>>::sse_decode(deserializer);
3353        let mut var_lnurlPayMetadata = <Option<String>>::sse_decode(deserializer);
3354        let mut var_lnurlPaySuccessAction =
3355            <Option<crate::bindings::SuccessActionProcessed>>::sse_decode(deserializer);
3356        let mut var_lnurlPayUnprocessedSuccessAction =
3357            <Option<crate::bindings::SuccessAction>>::sse_decode(deserializer);
3358        let mut var_lnurlWithdrawEndpoint = <Option<String>>::sse_decode(deserializer);
3359        return crate::model::LnUrlInfo {
3360            ln_address: var_lnAddress,
3361            lnurl_pay_comment: var_lnurlPayComment,
3362            lnurl_pay_domain: var_lnurlPayDomain,
3363            lnurl_pay_metadata: var_lnurlPayMetadata,
3364            lnurl_pay_success_action: var_lnurlPaySuccessAction,
3365            lnurl_pay_unprocessed_success_action: var_lnurlPayUnprocessedSuccessAction,
3366            lnurl_withdraw_endpoint: var_lnurlWithdrawEndpoint,
3367        };
3368    }
3369}
3370
3371impl SseDecode for crate::bindings::duplicates::LnUrlPayError {
3372    // Codec=Sse (Serialization based), see doc to use other codecs
3373    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3374        let mut tag_ = <i32>::sse_decode(deserializer);
3375        match tag_ {
3376            0 => {
3377                return crate::bindings::duplicates::LnUrlPayError::AlreadyPaid;
3378            }
3379            1 => {
3380                let mut var_err = <String>::sse_decode(deserializer);
3381                return crate::bindings::duplicates::LnUrlPayError::Generic { err: var_err };
3382            }
3383            2 => {
3384                let mut var_err = <String>::sse_decode(deserializer);
3385                return crate::bindings::duplicates::LnUrlPayError::InsufficientBalance {
3386                    err: var_err,
3387                };
3388            }
3389            3 => {
3390                let mut var_err = <String>::sse_decode(deserializer);
3391                return crate::bindings::duplicates::LnUrlPayError::InvalidAmount { err: var_err };
3392            }
3393            4 => {
3394                let mut var_err = <String>::sse_decode(deserializer);
3395                return crate::bindings::duplicates::LnUrlPayError::InvalidInvoice { err: var_err };
3396            }
3397            5 => {
3398                let mut var_err = <String>::sse_decode(deserializer);
3399                return crate::bindings::duplicates::LnUrlPayError::InvalidNetwork { err: var_err };
3400            }
3401            6 => {
3402                let mut var_err = <String>::sse_decode(deserializer);
3403                return crate::bindings::duplicates::LnUrlPayError::InvalidUri { err: var_err };
3404            }
3405            7 => {
3406                let mut var_err = <String>::sse_decode(deserializer);
3407                return crate::bindings::duplicates::LnUrlPayError::InvoiceExpired { err: var_err };
3408            }
3409            8 => {
3410                let mut var_err = <String>::sse_decode(deserializer);
3411                return crate::bindings::duplicates::LnUrlPayError::PaymentFailed { err: var_err };
3412            }
3413            9 => {
3414                let mut var_err = <String>::sse_decode(deserializer);
3415                return crate::bindings::duplicates::LnUrlPayError::PaymentTimeout { err: var_err };
3416            }
3417            10 => {
3418                let mut var_err = <String>::sse_decode(deserializer);
3419                return crate::bindings::duplicates::LnUrlPayError::RouteNotFound { err: var_err };
3420            }
3421            11 => {
3422                let mut var_err = <String>::sse_decode(deserializer);
3423                return crate::bindings::duplicates::LnUrlPayError::RouteTooExpensive {
3424                    err: var_err,
3425                };
3426            }
3427            12 => {
3428                let mut var_err = <String>::sse_decode(deserializer);
3429                return crate::bindings::duplicates::LnUrlPayError::ServiceConnectivity {
3430                    err: var_err,
3431                };
3432            }
3433            _ => {
3434                unimplemented!("");
3435            }
3436        }
3437    }
3438}
3439
3440impl SseDecode for crate::bindings::LnUrlPayErrorData {
3441    // Codec=Sse (Serialization based), see doc to use other codecs
3442    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3443        let mut var_paymentHash = <String>::sse_decode(deserializer);
3444        let mut var_reason = <String>::sse_decode(deserializer);
3445        return crate::bindings::LnUrlPayErrorData {
3446            payment_hash: var_paymentHash,
3447            reason: var_reason,
3448        };
3449    }
3450}
3451
3452impl SseDecode for crate::model::LnUrlPayRequest {
3453    // Codec=Sse (Serialization based), see doc to use other codecs
3454    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3455        let mut var_prepareResponse =
3456            <crate::model::PrepareLnUrlPayResponse>::sse_decode(deserializer);
3457        return crate::model::LnUrlPayRequest {
3458            prepare_response: var_prepareResponse,
3459        };
3460    }
3461}
3462
3463impl SseDecode for crate::bindings::LnUrlPayRequestData {
3464    // Codec=Sse (Serialization based), see doc to use other codecs
3465    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3466        let mut var_callback = <String>::sse_decode(deserializer);
3467        let mut var_minSendable = <u64>::sse_decode(deserializer);
3468        let mut var_maxSendable = <u64>::sse_decode(deserializer);
3469        let mut var_metadataStr = <String>::sse_decode(deserializer);
3470        let mut var_commentAllowed = <u16>::sse_decode(deserializer);
3471        let mut var_domain = <String>::sse_decode(deserializer);
3472        let mut var_allowsNostr = <bool>::sse_decode(deserializer);
3473        let mut var_nostrPubkey = <Option<String>>::sse_decode(deserializer);
3474        let mut var_lnAddress = <Option<String>>::sse_decode(deserializer);
3475        return crate::bindings::LnUrlPayRequestData {
3476            callback: var_callback,
3477            min_sendable: var_minSendable,
3478            max_sendable: var_maxSendable,
3479            metadata_str: var_metadataStr,
3480            comment_allowed: var_commentAllowed,
3481            domain: var_domain,
3482            allows_nostr: var_allowsNostr,
3483            nostr_pubkey: var_nostrPubkey,
3484            ln_address: var_lnAddress,
3485        };
3486    }
3487}
3488
3489impl SseDecode for crate::model::LnUrlPayResult {
3490    // Codec=Sse (Serialization based), see doc to use other codecs
3491    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3492        let mut tag_ = <i32>::sse_decode(deserializer);
3493        match tag_ {
3494            0 => {
3495                let mut var_data = <crate::model::LnUrlPaySuccessData>::sse_decode(deserializer);
3496                return crate::model::LnUrlPayResult::EndpointSuccess { data: var_data };
3497            }
3498            1 => {
3499                let mut var_data = <crate::bindings::LnUrlErrorData>::sse_decode(deserializer);
3500                return crate::model::LnUrlPayResult::EndpointError { data: var_data };
3501            }
3502            2 => {
3503                let mut var_data = <crate::bindings::LnUrlPayErrorData>::sse_decode(deserializer);
3504                return crate::model::LnUrlPayResult::PayError { data: var_data };
3505            }
3506            _ => {
3507                unimplemented!("");
3508            }
3509        }
3510    }
3511}
3512
3513impl SseDecode for crate::model::LnUrlPaySuccessData {
3514    // Codec=Sse (Serialization based), see doc to use other codecs
3515    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3516        let mut var_payment = <crate::model::Payment>::sse_decode(deserializer);
3517        let mut var_successAction =
3518            <Option<crate::bindings::SuccessActionProcessed>>::sse_decode(deserializer);
3519        return crate::model::LnUrlPaySuccessData {
3520            payment: var_payment,
3521            success_action: var_successAction,
3522        };
3523    }
3524}
3525
3526impl SseDecode for crate::bindings::duplicates::LnUrlWithdrawError {
3527    // Codec=Sse (Serialization based), see doc to use other codecs
3528    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3529        let mut tag_ = <i32>::sse_decode(deserializer);
3530        match tag_ {
3531            0 => {
3532                let mut var_err = <String>::sse_decode(deserializer);
3533                return crate::bindings::duplicates::LnUrlWithdrawError::Generic { err: var_err };
3534            }
3535            1 => {
3536                let mut var_err = <String>::sse_decode(deserializer);
3537                return crate::bindings::duplicates::LnUrlWithdrawError::InvalidAmount {
3538                    err: var_err,
3539                };
3540            }
3541            2 => {
3542                let mut var_err = <String>::sse_decode(deserializer);
3543                return crate::bindings::duplicates::LnUrlWithdrawError::InvalidInvoice {
3544                    err: var_err,
3545                };
3546            }
3547            3 => {
3548                let mut var_err = <String>::sse_decode(deserializer);
3549                return crate::bindings::duplicates::LnUrlWithdrawError::InvalidUri {
3550                    err: var_err,
3551                };
3552            }
3553            4 => {
3554                let mut var_err = <String>::sse_decode(deserializer);
3555                return crate::bindings::duplicates::LnUrlWithdrawError::InvoiceNoRoutingHints {
3556                    err: var_err,
3557                };
3558            }
3559            5 => {
3560                let mut var_err = <String>::sse_decode(deserializer);
3561                return crate::bindings::duplicates::LnUrlWithdrawError::ServiceConnectivity {
3562                    err: var_err,
3563                };
3564            }
3565            _ => {
3566                unimplemented!("");
3567            }
3568        }
3569    }
3570}
3571
3572impl SseDecode for crate::bindings::LnUrlWithdrawRequest {
3573    // Codec=Sse (Serialization based), see doc to use other codecs
3574    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3575        let mut var_data = <crate::bindings::LnUrlWithdrawRequestData>::sse_decode(deserializer);
3576        let mut var_amountMsat = <u64>::sse_decode(deserializer);
3577        let mut var_description = <Option<String>>::sse_decode(deserializer);
3578        return crate::bindings::LnUrlWithdrawRequest {
3579            data: var_data,
3580            amount_msat: var_amountMsat,
3581            description: var_description,
3582        };
3583    }
3584}
3585
3586impl SseDecode for crate::bindings::LnUrlWithdrawRequestData {
3587    // Codec=Sse (Serialization based), see doc to use other codecs
3588    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3589        let mut var_callback = <String>::sse_decode(deserializer);
3590        let mut var_k1 = <String>::sse_decode(deserializer);
3591        let mut var_defaultDescription = <String>::sse_decode(deserializer);
3592        let mut var_minWithdrawable = <u64>::sse_decode(deserializer);
3593        let mut var_maxWithdrawable = <u64>::sse_decode(deserializer);
3594        return crate::bindings::LnUrlWithdrawRequestData {
3595            callback: var_callback,
3596            k1: var_k1,
3597            default_description: var_defaultDescription,
3598            min_withdrawable: var_minWithdrawable,
3599            max_withdrawable: var_maxWithdrawable,
3600        };
3601    }
3602}
3603
3604impl SseDecode for crate::bindings::duplicates::LnUrlWithdrawResult {
3605    // Codec=Sse (Serialization based), see doc to use other codecs
3606    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3607        let mut tag_ = <i32>::sse_decode(deserializer);
3608        match tag_ {
3609            0 => {
3610                let mut var_data =
3611                    <crate::bindings::duplicates::LnUrlWithdrawSuccessData>::sse_decode(
3612                        deserializer,
3613                    );
3614                return crate::bindings::duplicates::LnUrlWithdrawResult::Ok { data: var_data };
3615            }
3616            1 => {
3617                let mut var_data =
3618                    <crate::bindings::duplicates::LnUrlWithdrawSuccessData>::sse_decode(
3619                        deserializer,
3620                    );
3621                return crate::bindings::duplicates::LnUrlWithdrawResult::Timeout {
3622                    data: var_data,
3623                };
3624            }
3625            2 => {
3626                let mut var_data = <crate::bindings::LnUrlErrorData>::sse_decode(deserializer);
3627                return crate::bindings::duplicates::LnUrlWithdrawResult::ErrorStatus {
3628                    data: var_data,
3629                };
3630            }
3631            _ => {
3632                unimplemented!("");
3633            }
3634        }
3635    }
3636}
3637
3638impl SseDecode for crate::bindings::duplicates::LnUrlWithdrawSuccessData {
3639    // Codec=Sse (Serialization based), see doc to use other codecs
3640    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3641        let mut var_invoice = <crate::bindings::LNInvoice>::sse_decode(deserializer);
3642        return crate::bindings::duplicates::LnUrlWithdrawSuccessData {
3643            invoice: var_invoice,
3644        };
3645    }
3646}
3647
3648impl SseDecode for crate::bindings::LocaleOverrides {
3649    // Codec=Sse (Serialization based), see doc to use other codecs
3650    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3651        let mut var_locale = <String>::sse_decode(deserializer);
3652        let mut var_spacing = <Option<u32>>::sse_decode(deserializer);
3653        let mut var_symbol = <crate::bindings::Symbol>::sse_decode(deserializer);
3654        return crate::bindings::LocaleOverrides {
3655            locale: var_locale,
3656            spacing: var_spacing,
3657            symbol: var_symbol,
3658        };
3659    }
3660}
3661
3662impl SseDecode for crate::bindings::LocalizedName {
3663    // Codec=Sse (Serialization based), see doc to use other codecs
3664    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3665        let mut var_locale = <String>::sse_decode(deserializer);
3666        let mut var_name = <String>::sse_decode(deserializer);
3667        return crate::bindings::LocalizedName {
3668            locale: var_locale,
3669            name: var_name,
3670        };
3671    }
3672}
3673
3674impl SseDecode for crate::model::LogEntry {
3675    // Codec=Sse (Serialization based), see doc to use other codecs
3676    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3677        let mut var_line = <String>::sse_decode(deserializer);
3678        let mut var_level = <String>::sse_decode(deserializer);
3679        return crate::model::LogEntry {
3680            line: var_line,
3681            level: var_level,
3682        };
3683    }
3684}
3685
3686impl SseDecode for crate::bindings::MessageSuccessActionData {
3687    // Codec=Sse (Serialization based), see doc to use other codecs
3688    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3689        let mut var_message = <String>::sse_decode(deserializer);
3690        return crate::bindings::MessageSuccessActionData {
3691            message: var_message,
3692        };
3693    }
3694}
3695
3696impl SseDecode for crate::bindings::Network {
3697    // Codec=Sse (Serialization based), see doc to use other codecs
3698    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3699        let mut inner = <i32>::sse_decode(deserializer);
3700        return match inner {
3701            0 => crate::bindings::Network::Bitcoin,
3702            1 => crate::bindings::Network::Testnet,
3703            2 => crate::bindings::Network::Signet,
3704            3 => crate::bindings::Network::Regtest,
3705            _ => unreachable!("Invalid variant for Network: {}", inner),
3706        };
3707    }
3708}
3709
3710impl SseDecode for crate::model::OnchainPaymentLimitsResponse {
3711    // Codec=Sse (Serialization based), see doc to use other codecs
3712    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3713        let mut var_send = <crate::model::Limits>::sse_decode(deserializer);
3714        let mut var_receive = <crate::model::Limits>::sse_decode(deserializer);
3715        return crate::model::OnchainPaymentLimitsResponse {
3716            send: var_send,
3717            receive: var_receive,
3718        };
3719    }
3720}
3721
3722impl SseDecode for Option<String> {
3723    // Codec=Sse (Serialization based), see doc to use other codecs
3724    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3725        if (<bool>::sse_decode(deserializer)) {
3726            return Some(<String>::sse_decode(deserializer));
3727        } else {
3728            return None;
3729        }
3730    }
3731}
3732
3733impl SseDecode for Option<crate::bindings::Amount> {
3734    // Codec=Sse (Serialization based), see doc to use other codecs
3735    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3736        if (<bool>::sse_decode(deserializer)) {
3737            return Some(<crate::bindings::Amount>::sse_decode(deserializer));
3738        } else {
3739            return None;
3740        }
3741    }
3742}
3743
3744impl SseDecode for Option<crate::model::AssetInfo> {
3745    // Codec=Sse (Serialization based), see doc to use other codecs
3746    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3747        if (<bool>::sse_decode(deserializer)) {
3748            return Some(<crate::model::AssetInfo>::sse_decode(deserializer));
3749        } else {
3750            return None;
3751        }
3752    }
3753}
3754
3755impl SseDecode for Option<bool> {
3756    // Codec=Sse (Serialization based), see doc to use other codecs
3757    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3758        if (<bool>::sse_decode(deserializer)) {
3759            return Some(<bool>::sse_decode(deserializer));
3760        } else {
3761            return None;
3762        }
3763    }
3764}
3765
3766impl SseDecode for Option<f64> {
3767    // Codec=Sse (Serialization based), see doc to use other codecs
3768    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3769        if (<bool>::sse_decode(deserializer)) {
3770            return Some(<f64>::sse_decode(deserializer));
3771        } else {
3772            return None;
3773        }
3774    }
3775}
3776
3777impl SseDecode for Option<i64> {
3778    // Codec=Sse (Serialization based), see doc to use other codecs
3779    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3780        if (<bool>::sse_decode(deserializer)) {
3781            return Some(<i64>::sse_decode(deserializer));
3782        } else {
3783            return None;
3784        }
3785    }
3786}
3787
3788impl SseDecode for Option<crate::model::ListPaymentDetails> {
3789    // Codec=Sse (Serialization based), see doc to use other codecs
3790    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3791        if (<bool>::sse_decode(deserializer)) {
3792            return Some(<crate::model::ListPaymentDetails>::sse_decode(deserializer));
3793        } else {
3794            return None;
3795        }
3796    }
3797}
3798
3799impl SseDecode for Option<crate::model::LnUrlInfo> {
3800    // Codec=Sse (Serialization based), see doc to use other codecs
3801    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3802        if (<bool>::sse_decode(deserializer)) {
3803            return Some(<crate::model::LnUrlInfo>::sse_decode(deserializer));
3804        } else {
3805            return None;
3806        }
3807    }
3808}
3809
3810impl SseDecode for Option<crate::model::PayAmount> {
3811    // Codec=Sse (Serialization based), see doc to use other codecs
3812    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3813        if (<bool>::sse_decode(deserializer)) {
3814            return Some(<crate::model::PayAmount>::sse_decode(deserializer));
3815        } else {
3816            return None;
3817        }
3818    }
3819}
3820
3821impl SseDecode for Option<crate::model::Payment> {
3822    // Codec=Sse (Serialization based), see doc to use other codecs
3823    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3824        if (<bool>::sse_decode(deserializer)) {
3825            return Some(<crate::model::Payment>::sse_decode(deserializer));
3826        } else {
3827            return None;
3828        }
3829    }
3830}
3831
3832impl SseDecode for Option<crate::model::ReceiveAmount> {
3833    // Codec=Sse (Serialization based), see doc to use other codecs
3834    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3835        if (<bool>::sse_decode(deserializer)) {
3836            return Some(<crate::model::ReceiveAmount>::sse_decode(deserializer));
3837        } else {
3838            return None;
3839        }
3840    }
3841}
3842
3843impl SseDecode for Option<crate::bindings::SuccessAction> {
3844    // Codec=Sse (Serialization based), see doc to use other codecs
3845    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3846        if (<bool>::sse_decode(deserializer)) {
3847            return Some(<crate::bindings::SuccessAction>::sse_decode(deserializer));
3848        } else {
3849            return None;
3850        }
3851    }
3852}
3853
3854impl SseDecode for Option<crate::bindings::SuccessActionProcessed> {
3855    // Codec=Sse (Serialization based), see doc to use other codecs
3856    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3857        if (<bool>::sse_decode(deserializer)) {
3858            return Some(<crate::bindings::SuccessActionProcessed>::sse_decode(
3859                deserializer,
3860            ));
3861        } else {
3862            return None;
3863        }
3864    }
3865}
3866
3867impl SseDecode for Option<crate::bindings::Symbol> {
3868    // Codec=Sse (Serialization based), see doc to use other codecs
3869    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3870        if (<bool>::sse_decode(deserializer)) {
3871            return Some(<crate::bindings::Symbol>::sse_decode(deserializer));
3872        } else {
3873            return None;
3874        }
3875    }
3876}
3877
3878impl SseDecode for Option<u32> {
3879    // Codec=Sse (Serialization based), see doc to use other codecs
3880    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3881        if (<bool>::sse_decode(deserializer)) {
3882            return Some(<u32>::sse_decode(deserializer));
3883        } else {
3884            return None;
3885        }
3886    }
3887}
3888
3889impl SseDecode for Option<u64> {
3890    // Codec=Sse (Serialization based), see doc to use other codecs
3891    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3892        if (<bool>::sse_decode(deserializer)) {
3893            return Some(<u64>::sse_decode(deserializer));
3894        } else {
3895            return None;
3896        }
3897    }
3898}
3899
3900impl SseDecode for Option<Vec<crate::model::AssetMetadata>> {
3901    // Codec=Sse (Serialization based), see doc to use other codecs
3902    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3903        if (<bool>::sse_decode(deserializer)) {
3904            return Some(<Vec<crate::model::AssetMetadata>>::sse_decode(deserializer));
3905        } else {
3906            return None;
3907        }
3908    }
3909}
3910
3911impl SseDecode for Option<Vec<crate::bindings::ExternalInputParser>> {
3912    // Codec=Sse (Serialization based), see doc to use other codecs
3913    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3914        if (<bool>::sse_decode(deserializer)) {
3915            return Some(<Vec<crate::bindings::ExternalInputParser>>::sse_decode(
3916                deserializer,
3917            ));
3918        } else {
3919            return None;
3920        }
3921    }
3922}
3923
3924impl SseDecode for Option<Vec<crate::model::PaymentState>> {
3925    // Codec=Sse (Serialization based), see doc to use other codecs
3926    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3927        if (<bool>::sse_decode(deserializer)) {
3928            return Some(<Vec<crate::model::PaymentState>>::sse_decode(deserializer));
3929        } else {
3930            return None;
3931        }
3932    }
3933}
3934
3935impl SseDecode for Option<Vec<crate::model::PaymentType>> {
3936    // Codec=Sse (Serialization based), see doc to use other codecs
3937    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3938        if (<bool>::sse_decode(deserializer)) {
3939            return Some(<Vec<crate::model::PaymentType>>::sse_decode(deserializer));
3940        } else {
3941            return None;
3942        }
3943    }
3944}
3945
3946impl SseDecode for Option<Vec<u8>> {
3947    // Codec=Sse (Serialization based), see doc to use other codecs
3948    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3949        if (<bool>::sse_decode(deserializer)) {
3950            return Some(<Vec<u8>>::sse_decode(deserializer));
3951        } else {
3952            return None;
3953        }
3954    }
3955}
3956
3957impl SseDecode for crate::model::PayAmount {
3958    // Codec=Sse (Serialization based), see doc to use other codecs
3959    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3960        let mut tag_ = <i32>::sse_decode(deserializer);
3961        match tag_ {
3962            0 => {
3963                let mut var_receiverAmountSat = <u64>::sse_decode(deserializer);
3964                return crate::model::PayAmount::Bitcoin {
3965                    receiver_amount_sat: var_receiverAmountSat,
3966                };
3967            }
3968            1 => {
3969                let mut var_assetId = <String>::sse_decode(deserializer);
3970                let mut var_receiverAmount = <f64>::sse_decode(deserializer);
3971                let mut var_estimateAssetFees = <Option<bool>>::sse_decode(deserializer);
3972                return crate::model::PayAmount::Asset {
3973                    asset_id: var_assetId,
3974                    receiver_amount: var_receiverAmount,
3975                    estimate_asset_fees: var_estimateAssetFees,
3976                };
3977            }
3978            2 => {
3979                return crate::model::PayAmount::Drain;
3980            }
3981            _ => {
3982                unimplemented!("");
3983            }
3984        }
3985    }
3986}
3987
3988impl SseDecode for crate::model::PayOnchainRequest {
3989    // Codec=Sse (Serialization based), see doc to use other codecs
3990    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
3991        let mut var_address = <String>::sse_decode(deserializer);
3992        let mut var_prepareResponse =
3993            <crate::model::PreparePayOnchainResponse>::sse_decode(deserializer);
3994        return crate::model::PayOnchainRequest {
3995            address: var_address,
3996            prepare_response: var_prepareResponse,
3997        };
3998    }
3999}
4000
4001impl SseDecode for crate::model::Payment {
4002    // Codec=Sse (Serialization based), see doc to use other codecs
4003    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4004        let mut var_destination = <Option<String>>::sse_decode(deserializer);
4005        let mut var_txId = <Option<String>>::sse_decode(deserializer);
4006        let mut var_unblindingData = <Option<String>>::sse_decode(deserializer);
4007        let mut var_timestamp = <u32>::sse_decode(deserializer);
4008        let mut var_amountSat = <u64>::sse_decode(deserializer);
4009        let mut var_feesSat = <u64>::sse_decode(deserializer);
4010        let mut var_swapperFeesSat = <Option<u64>>::sse_decode(deserializer);
4011        let mut var_paymentType = <crate::model::PaymentType>::sse_decode(deserializer);
4012        let mut var_status = <crate::model::PaymentState>::sse_decode(deserializer);
4013        let mut var_details = <crate::model::PaymentDetails>::sse_decode(deserializer);
4014        return crate::model::Payment {
4015            destination: var_destination,
4016            tx_id: var_txId,
4017            unblinding_data: var_unblindingData,
4018            timestamp: var_timestamp,
4019            amount_sat: var_amountSat,
4020            fees_sat: var_feesSat,
4021            swapper_fees_sat: var_swapperFeesSat,
4022            payment_type: var_paymentType,
4023            status: var_status,
4024            details: var_details,
4025        };
4026    }
4027}
4028
4029impl SseDecode for crate::model::PaymentDetails {
4030    // Codec=Sse (Serialization based), see doc to use other codecs
4031    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4032        let mut tag_ = <i32>::sse_decode(deserializer);
4033        match tag_ {
4034            0 => {
4035                let mut var_swapId = <String>::sse_decode(deserializer);
4036                let mut var_description = <String>::sse_decode(deserializer);
4037                let mut var_liquidExpirationBlockheight = <u32>::sse_decode(deserializer);
4038                let mut var_preimage = <Option<String>>::sse_decode(deserializer);
4039                let mut var_invoice = <Option<String>>::sse_decode(deserializer);
4040                let mut var_bolt12Offer = <Option<String>>::sse_decode(deserializer);
4041                let mut var_paymentHash = <Option<String>>::sse_decode(deserializer);
4042                let mut var_destinationPubkey = <Option<String>>::sse_decode(deserializer);
4043                let mut var_lnurlInfo = <Option<crate::model::LnUrlInfo>>::sse_decode(deserializer);
4044                let mut var_bip353Address = <Option<String>>::sse_decode(deserializer);
4045                let mut var_claimTxId = <Option<String>>::sse_decode(deserializer);
4046                let mut var_refundTxId = <Option<String>>::sse_decode(deserializer);
4047                let mut var_refundTxAmountSat = <Option<u64>>::sse_decode(deserializer);
4048                return crate::model::PaymentDetails::Lightning {
4049                    swap_id: var_swapId,
4050                    description: var_description,
4051                    liquid_expiration_blockheight: var_liquidExpirationBlockheight,
4052                    preimage: var_preimage,
4053                    invoice: var_invoice,
4054                    bolt12_offer: var_bolt12Offer,
4055                    payment_hash: var_paymentHash,
4056                    destination_pubkey: var_destinationPubkey,
4057                    lnurl_info: var_lnurlInfo,
4058                    bip353_address: var_bip353Address,
4059                    claim_tx_id: var_claimTxId,
4060                    refund_tx_id: var_refundTxId,
4061                    refund_tx_amount_sat: var_refundTxAmountSat,
4062                };
4063            }
4064            1 => {
4065                let mut var_destination = <String>::sse_decode(deserializer);
4066                let mut var_description = <String>::sse_decode(deserializer);
4067                let mut var_assetId = <String>::sse_decode(deserializer);
4068                let mut var_assetInfo = <Option<crate::model::AssetInfo>>::sse_decode(deserializer);
4069                let mut var_lnurlInfo = <Option<crate::model::LnUrlInfo>>::sse_decode(deserializer);
4070                let mut var_bip353Address = <Option<String>>::sse_decode(deserializer);
4071                return crate::model::PaymentDetails::Liquid {
4072                    destination: var_destination,
4073                    description: var_description,
4074                    asset_id: var_assetId,
4075                    asset_info: var_assetInfo,
4076                    lnurl_info: var_lnurlInfo,
4077                    bip353_address: var_bip353Address,
4078                };
4079            }
4080            2 => {
4081                let mut var_swapId = <String>::sse_decode(deserializer);
4082                let mut var_bitcoinAddress = <String>::sse_decode(deserializer);
4083                let mut var_description = <String>::sse_decode(deserializer);
4084                let mut var_autoAcceptedFees = <bool>::sse_decode(deserializer);
4085                let mut var_liquidExpirationBlockheight = <Option<u32>>::sse_decode(deserializer);
4086                let mut var_bitcoinExpirationBlockheight = <Option<u32>>::sse_decode(deserializer);
4087                let mut var_lockupTxId = <Option<String>>::sse_decode(deserializer);
4088                let mut var_claimTxId = <Option<String>>::sse_decode(deserializer);
4089                let mut var_refundTxId = <Option<String>>::sse_decode(deserializer);
4090                let mut var_refundTxAmountSat = <Option<u64>>::sse_decode(deserializer);
4091                return crate::model::PaymentDetails::Bitcoin {
4092                    swap_id: var_swapId,
4093                    bitcoin_address: var_bitcoinAddress,
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        let mut var_comment = <Option<String>>::sse_decode(deserializer);
4407        return crate::model::PrepareSendRequest {
4408            destination: var_destination,
4409            amount: var_amount,
4410            comment: var_comment,
4411        };
4412    }
4413}
4414
4415impl SseDecode for crate::model::PrepareSendResponse {
4416    // Codec=Sse (Serialization based), see doc to use other codecs
4417    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4418        let mut var_destination = <crate::model::SendDestination>::sse_decode(deserializer);
4419        let mut var_amount = <Option<crate::model::PayAmount>>::sse_decode(deserializer);
4420        let mut var_feesSat = <Option<u64>>::sse_decode(deserializer);
4421        let mut var_estimatedAssetFees = <Option<f64>>::sse_decode(deserializer);
4422        return crate::model::PrepareSendResponse {
4423            destination: var_destination,
4424            amount: var_amount,
4425            fees_sat: var_feesSat,
4426            estimated_asset_fees: var_estimatedAssetFees,
4427        };
4428    }
4429}
4430
4431impl SseDecode for crate::bindings::Rate {
4432    // Codec=Sse (Serialization based), see doc to use other codecs
4433    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4434        let mut var_coin = <String>::sse_decode(deserializer);
4435        let mut var_value = <f64>::sse_decode(deserializer);
4436        return crate::bindings::Rate {
4437            coin: var_coin,
4438            value: var_value,
4439        };
4440    }
4441}
4442
4443impl SseDecode for crate::model::ReceiveAmount {
4444    // Codec=Sse (Serialization based), see doc to use other codecs
4445    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4446        let mut tag_ = <i32>::sse_decode(deserializer);
4447        match tag_ {
4448            0 => {
4449                let mut var_payerAmountSat = <u64>::sse_decode(deserializer);
4450                return crate::model::ReceiveAmount::Bitcoin {
4451                    payer_amount_sat: var_payerAmountSat,
4452                };
4453            }
4454            1 => {
4455                let mut var_assetId = <String>::sse_decode(deserializer);
4456                let mut var_payerAmount = <Option<f64>>::sse_decode(deserializer);
4457                return crate::model::ReceiveAmount::Asset {
4458                    asset_id: var_assetId,
4459                    payer_amount: var_payerAmount,
4460                };
4461            }
4462            _ => {
4463                unimplemented!("");
4464            }
4465        }
4466    }
4467}
4468
4469impl SseDecode for crate::model::ReceivePaymentRequest {
4470    // Codec=Sse (Serialization based), see doc to use other codecs
4471    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4472        let mut var_prepareResponse =
4473            <crate::model::PrepareReceiveResponse>::sse_decode(deserializer);
4474        let mut var_description = <Option<String>>::sse_decode(deserializer);
4475        let mut var_useDescriptionHash = <Option<bool>>::sse_decode(deserializer);
4476        return crate::model::ReceivePaymentRequest {
4477            prepare_response: var_prepareResponse,
4478            description: var_description,
4479            use_description_hash: var_useDescriptionHash,
4480        };
4481    }
4482}
4483
4484impl SseDecode for crate::model::ReceivePaymentResponse {
4485    // Codec=Sse (Serialization based), see doc to use other codecs
4486    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4487        let mut var_destination = <String>::sse_decode(deserializer);
4488        return crate::model::ReceivePaymentResponse {
4489            destination: var_destination,
4490        };
4491    }
4492}
4493
4494impl SseDecode for crate::model::RecommendedFees {
4495    // Codec=Sse (Serialization based), see doc to use other codecs
4496    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4497        let mut var_fastestFee = <u64>::sse_decode(deserializer);
4498        let mut var_halfHourFee = <u64>::sse_decode(deserializer);
4499        let mut var_hourFee = <u64>::sse_decode(deserializer);
4500        let mut var_economyFee = <u64>::sse_decode(deserializer);
4501        let mut var_minimumFee = <u64>::sse_decode(deserializer);
4502        return crate::model::RecommendedFees {
4503            fastest_fee: var_fastestFee,
4504            half_hour_fee: var_halfHourFee,
4505            hour_fee: var_hourFee,
4506            economy_fee: var_economyFee,
4507            minimum_fee: var_minimumFee,
4508        };
4509    }
4510}
4511
4512impl SseDecode for crate::model::RefundRequest {
4513    // Codec=Sse (Serialization based), see doc to use other codecs
4514    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4515        let mut var_swapAddress = <String>::sse_decode(deserializer);
4516        let mut var_refundAddress = <String>::sse_decode(deserializer);
4517        let mut var_feeRateSatPerVbyte = <u32>::sse_decode(deserializer);
4518        return crate::model::RefundRequest {
4519            swap_address: var_swapAddress,
4520            refund_address: var_refundAddress,
4521            fee_rate_sat_per_vbyte: var_feeRateSatPerVbyte,
4522        };
4523    }
4524}
4525
4526impl SseDecode for crate::model::RefundResponse {
4527    // Codec=Sse (Serialization based), see doc to use other codecs
4528    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4529        let mut var_refundTxId = <String>::sse_decode(deserializer);
4530        return crate::model::RefundResponse {
4531            refund_tx_id: var_refundTxId,
4532        };
4533    }
4534}
4535
4536impl SseDecode for crate::model::RefundableSwap {
4537    // Codec=Sse (Serialization based), see doc to use other codecs
4538    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4539        let mut var_swapAddress = <String>::sse_decode(deserializer);
4540        let mut var_timestamp = <u32>::sse_decode(deserializer);
4541        let mut var_amountSat = <u64>::sse_decode(deserializer);
4542        let mut var_lastRefundTxId = <Option<String>>::sse_decode(deserializer);
4543        return crate::model::RefundableSwap {
4544            swap_address: var_swapAddress,
4545            timestamp: var_timestamp,
4546            amount_sat: var_amountSat,
4547            last_refund_tx_id: var_lastRefundTxId,
4548        };
4549    }
4550}
4551
4552impl SseDecode for crate::model::RestoreRequest {
4553    // Codec=Sse (Serialization based), see doc to use other codecs
4554    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4555        let mut var_backupPath = <Option<String>>::sse_decode(deserializer);
4556        return crate::model::RestoreRequest {
4557            backup_path: var_backupPath,
4558        };
4559    }
4560}
4561
4562impl SseDecode for crate::bindings::RouteHint {
4563    // Codec=Sse (Serialization based), see doc to use other codecs
4564    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4565        let mut var_hops = <Vec<crate::bindings::RouteHintHop>>::sse_decode(deserializer);
4566        return crate::bindings::RouteHint { hops: var_hops };
4567    }
4568}
4569
4570impl SseDecode for crate::bindings::RouteHintHop {
4571    // Codec=Sse (Serialization based), see doc to use other codecs
4572    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4573        let mut var_srcNodeId = <String>::sse_decode(deserializer);
4574        let mut var_shortChannelId = <String>::sse_decode(deserializer);
4575        let mut var_feesBaseMsat = <u32>::sse_decode(deserializer);
4576        let mut var_feesProportionalMillionths = <u32>::sse_decode(deserializer);
4577        let mut var_cltvExpiryDelta = <u64>::sse_decode(deserializer);
4578        let mut var_htlcMinimumMsat = <Option<u64>>::sse_decode(deserializer);
4579        let mut var_htlcMaximumMsat = <Option<u64>>::sse_decode(deserializer);
4580        return crate::bindings::RouteHintHop {
4581            src_node_id: var_srcNodeId,
4582            short_channel_id: var_shortChannelId,
4583            fees_base_msat: var_feesBaseMsat,
4584            fees_proportional_millionths: var_feesProportionalMillionths,
4585            cltv_expiry_delta: var_cltvExpiryDelta,
4586            htlc_minimum_msat: var_htlcMinimumMsat,
4587            htlc_maximum_msat: var_htlcMaximumMsat,
4588        };
4589    }
4590}
4591
4592impl SseDecode for crate::error::SdkError {
4593    // Codec=Sse (Serialization based), see doc to use other codecs
4594    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4595        let mut tag_ = <i32>::sse_decode(deserializer);
4596        match tag_ {
4597            0 => {
4598                return crate::error::SdkError::AlreadyStarted;
4599            }
4600            1 => {
4601                let mut var_err = <String>::sse_decode(deserializer);
4602                return crate::error::SdkError::Generic { err: var_err };
4603            }
4604            2 => {
4605                return crate::error::SdkError::NotStarted;
4606            }
4607            3 => {
4608                let mut var_err = <String>::sse_decode(deserializer);
4609                return crate::error::SdkError::ServiceConnectivity { err: var_err };
4610            }
4611            _ => {
4612                unimplemented!("");
4613            }
4614        }
4615    }
4616}
4617
4618impl SseDecode for crate::model::SdkEvent {
4619    // Codec=Sse (Serialization based), see doc to use other codecs
4620    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4621        let mut tag_ = <i32>::sse_decode(deserializer);
4622        match tag_ {
4623            0 => {
4624                let mut var_details = <crate::model::Payment>::sse_decode(deserializer);
4625                return crate::model::SdkEvent::PaymentFailed {
4626                    details: var_details,
4627                };
4628            }
4629            1 => {
4630                let mut var_details = <crate::model::Payment>::sse_decode(deserializer);
4631                return crate::model::SdkEvent::PaymentPending {
4632                    details: var_details,
4633                };
4634            }
4635            2 => {
4636                let mut var_details = <crate::model::Payment>::sse_decode(deserializer);
4637                return crate::model::SdkEvent::PaymentRefundable {
4638                    details: var_details,
4639                };
4640            }
4641            3 => {
4642                let mut var_details = <crate::model::Payment>::sse_decode(deserializer);
4643                return crate::model::SdkEvent::PaymentRefunded {
4644                    details: var_details,
4645                };
4646            }
4647            4 => {
4648                let mut var_details = <crate::model::Payment>::sse_decode(deserializer);
4649                return crate::model::SdkEvent::PaymentRefundPending {
4650                    details: var_details,
4651                };
4652            }
4653            5 => {
4654                let mut var_details = <crate::model::Payment>::sse_decode(deserializer);
4655                return crate::model::SdkEvent::PaymentSucceeded {
4656                    details: var_details,
4657                };
4658            }
4659            6 => {
4660                let mut var_details = <crate::model::Payment>::sse_decode(deserializer);
4661                return crate::model::SdkEvent::PaymentWaitingConfirmation {
4662                    details: var_details,
4663                };
4664            }
4665            7 => {
4666                let mut var_details = <crate::model::Payment>::sse_decode(deserializer);
4667                return crate::model::SdkEvent::PaymentWaitingFeeAcceptance {
4668                    details: var_details,
4669                };
4670            }
4671            8 => {
4672                return crate::model::SdkEvent::Synced;
4673            }
4674            9 => {
4675                let mut var_didPullNewRecords = <bool>::sse_decode(deserializer);
4676                return crate::model::SdkEvent::DataSynced {
4677                    did_pull_new_records: var_didPullNewRecords,
4678                };
4679            }
4680            _ => {
4681                unimplemented!("");
4682            }
4683        }
4684    }
4685}
4686
4687impl SseDecode for crate::model::SendDestination {
4688    // Codec=Sse (Serialization based), see doc to use other codecs
4689    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4690        let mut tag_ = <i32>::sse_decode(deserializer);
4691        match tag_ {
4692            0 => {
4693                let mut var_addressData =
4694                    <crate::bindings::LiquidAddressData>::sse_decode(deserializer);
4695                let mut var_bip353Address = <Option<String>>::sse_decode(deserializer);
4696                return crate::model::SendDestination::LiquidAddress {
4697                    address_data: var_addressData,
4698                    bip353_address: var_bip353Address,
4699                };
4700            }
4701            1 => {
4702                let mut var_invoice = <crate::bindings::LNInvoice>::sse_decode(deserializer);
4703                let mut var_bip353Address = <Option<String>>::sse_decode(deserializer);
4704                return crate::model::SendDestination::Bolt11 {
4705                    invoice: var_invoice,
4706                    bip353_address: var_bip353Address,
4707                };
4708            }
4709            2 => {
4710                let mut var_offer = <crate::bindings::LNOffer>::sse_decode(deserializer);
4711                let mut var_receiverAmountSat = <u64>::sse_decode(deserializer);
4712                let mut var_bip353Address = <Option<String>>::sse_decode(deserializer);
4713                let mut var_payerNote = <Option<String>>::sse_decode(deserializer);
4714                return crate::model::SendDestination::Bolt12 {
4715                    offer: var_offer,
4716                    receiver_amount_sat: var_receiverAmountSat,
4717                    bip353_address: var_bip353Address,
4718                    payer_note: var_payerNote,
4719                };
4720            }
4721            _ => {
4722                unimplemented!("");
4723            }
4724        }
4725    }
4726}
4727
4728impl SseDecode for crate::model::SendPaymentRequest {
4729    // Codec=Sse (Serialization based), see doc to use other codecs
4730    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4731        let mut var_prepareResponse = <crate::model::PrepareSendResponse>::sse_decode(deserializer);
4732        let mut var_useAssetFees = <Option<bool>>::sse_decode(deserializer);
4733        return crate::model::SendPaymentRequest {
4734            prepare_response: var_prepareResponse,
4735            use_asset_fees: var_useAssetFees,
4736        };
4737    }
4738}
4739
4740impl SseDecode for crate::model::SendPaymentResponse {
4741    // Codec=Sse (Serialization based), see doc to use other codecs
4742    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4743        let mut var_payment = <crate::model::Payment>::sse_decode(deserializer);
4744        return crate::model::SendPaymentResponse {
4745            payment: var_payment,
4746        };
4747    }
4748}
4749
4750impl SseDecode for crate::model::SignMessageRequest {
4751    // Codec=Sse (Serialization based), see doc to use other codecs
4752    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4753        let mut var_message = <String>::sse_decode(deserializer);
4754        return crate::model::SignMessageRequest {
4755            message: var_message,
4756        };
4757    }
4758}
4759
4760impl SseDecode for crate::model::SignMessageResponse {
4761    // Codec=Sse (Serialization based), see doc to use other codecs
4762    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4763        let mut var_signature = <String>::sse_decode(deserializer);
4764        return crate::model::SignMessageResponse {
4765            signature: var_signature,
4766        };
4767    }
4768}
4769
4770impl SseDecode for crate::bindings::SuccessAction {
4771    // Codec=Sse (Serialization based), see doc to use other codecs
4772    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4773        let mut tag_ = <i32>::sse_decode(deserializer);
4774        match tag_ {
4775            0 => {
4776                let mut var_data =
4777                    <crate::bindings::AesSuccessActionData>::sse_decode(deserializer);
4778                return crate::bindings::SuccessAction::Aes { data: var_data };
4779            }
4780            1 => {
4781                let mut var_data =
4782                    <crate::bindings::MessageSuccessActionData>::sse_decode(deserializer);
4783                return crate::bindings::SuccessAction::Message { data: var_data };
4784            }
4785            2 => {
4786                let mut var_data =
4787                    <crate::bindings::UrlSuccessActionData>::sse_decode(deserializer);
4788                return crate::bindings::SuccessAction::Url { data: var_data };
4789            }
4790            _ => {
4791                unimplemented!("");
4792            }
4793        }
4794    }
4795}
4796
4797impl SseDecode for crate::bindings::SuccessActionProcessed {
4798    // Codec=Sse (Serialization based), see doc to use other codecs
4799    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4800        let mut tag_ = <i32>::sse_decode(deserializer);
4801        match tag_ {
4802            0 => {
4803                let mut var_result =
4804                    <crate::bindings::AesSuccessActionDataResult>::sse_decode(deserializer);
4805                return crate::bindings::SuccessActionProcessed::Aes { result: var_result };
4806            }
4807            1 => {
4808                let mut var_data =
4809                    <crate::bindings::MessageSuccessActionData>::sse_decode(deserializer);
4810                return crate::bindings::SuccessActionProcessed::Message { data: var_data };
4811            }
4812            2 => {
4813                let mut var_data =
4814                    <crate::bindings::UrlSuccessActionData>::sse_decode(deserializer);
4815                return crate::bindings::SuccessActionProcessed::Url { data: var_data };
4816            }
4817            _ => {
4818                unimplemented!("");
4819            }
4820        }
4821    }
4822}
4823
4824impl SseDecode for crate::bindings::Symbol {
4825    // Codec=Sse (Serialization based), see doc to use other codecs
4826    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4827        let mut var_grapheme = <Option<String>>::sse_decode(deserializer);
4828        let mut var_template = <Option<String>>::sse_decode(deserializer);
4829        let mut var_rtl = <Option<bool>>::sse_decode(deserializer);
4830        let mut var_position = <Option<u32>>::sse_decode(deserializer);
4831        return crate::bindings::Symbol {
4832            grapheme: var_grapheme,
4833            template: var_template,
4834            rtl: var_rtl,
4835            position: var_position,
4836        };
4837    }
4838}
4839
4840impl SseDecode for u16 {
4841    // Codec=Sse (Serialization based), see doc to use other codecs
4842    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4843        deserializer.cursor.read_u16::<NativeEndian>().unwrap()
4844    }
4845}
4846
4847impl SseDecode for u32 {
4848    // Codec=Sse (Serialization based), see doc to use other codecs
4849    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4850        deserializer.cursor.read_u32::<NativeEndian>().unwrap()
4851    }
4852}
4853
4854impl SseDecode for u64 {
4855    // Codec=Sse (Serialization based), see doc to use other codecs
4856    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4857        deserializer.cursor.read_u64::<NativeEndian>().unwrap()
4858    }
4859}
4860
4861impl SseDecode for u8 {
4862    // Codec=Sse (Serialization based), see doc to use other codecs
4863    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4864        deserializer.cursor.read_u8().unwrap()
4865    }
4866}
4867
4868impl SseDecode for () {
4869    // Codec=Sse (Serialization based), see doc to use other codecs
4870    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {}
4871}
4872
4873impl SseDecode for crate::bindings::UrlSuccessActionData {
4874    // Codec=Sse (Serialization based), see doc to use other codecs
4875    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4876        let mut var_description = <String>::sse_decode(deserializer);
4877        let mut var_url = <String>::sse_decode(deserializer);
4878        let mut var_matchesCallbackDomain = <bool>::sse_decode(deserializer);
4879        return crate::bindings::UrlSuccessActionData {
4880            description: var_description,
4881            url: var_url,
4882            matches_callback_domain: var_matchesCallbackDomain,
4883        };
4884    }
4885}
4886
4887impl SseDecode for usize {
4888    // Codec=Sse (Serialization based), see doc to use other codecs
4889    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4890        deserializer.cursor.read_u64::<NativeEndian>().unwrap() as _
4891    }
4892}
4893
4894impl SseDecode for crate::model::WalletInfo {
4895    // Codec=Sse (Serialization based), see doc to use other codecs
4896    fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
4897        let mut var_balanceSat = <u64>::sse_decode(deserializer);
4898        let mut var_pendingSendSat = <u64>::sse_decode(deserializer);
4899        let mut var_pendingReceiveSat = <u64>::sse_decode(deserializer);
4900        let mut var_fingerprint = <String>::sse_decode(deserializer);
4901        let mut var_pubkey = <String>::sse_decode(deserializer);
4902        let mut var_assetBalances = <Vec<crate::model::AssetBalance>>::sse_decode(deserializer);
4903        return crate::model::WalletInfo {
4904            balance_sat: var_balanceSat,
4905            pending_send_sat: var_pendingSendSat,
4906            pending_receive_sat: var_pendingReceiveSat,
4907            fingerprint: var_fingerprint,
4908            pubkey: var_pubkey,
4909            asset_balances: var_assetBalances,
4910        };
4911    }
4912}
4913
4914fn pde_ffi_dispatcher_primary_impl(
4915    func_id: i32,
4916    port: flutter_rust_bridge::for_generated::MessagePort,
4917    ptr: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
4918    rust_vec_len: i32,
4919    data_len: i32,
4920) {
4921    // Codec=Pde (Serialization + dispatch), see doc to use other codecs
4922    match func_id {
4923        _ => unreachable!(),
4924    }
4925}
4926
4927fn pde_ffi_dispatcher_sync_impl(
4928    func_id: i32,
4929    ptr: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
4930    rust_vec_len: i32,
4931    data_len: i32,
4932) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
4933    // Codec=Pde (Serialization + dispatch), see doc to use other codecs
4934    match func_id {
4935        _ => unreachable!(),
4936    }
4937}
4938
4939// Section: rust2dart
4940
4941// Codec=Dco (DartCObject based), see doc to use other codecs
4942impl flutter_rust_bridge::IntoDart for FrbWrapper<BindingLiquidSdk> {
4943    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
4944        flutter_rust_bridge::for_generated::rust_auto_opaque_encode::<_, StdArc<_>>(self.0)
4945            .into_dart()
4946    }
4947}
4948impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for FrbWrapper<BindingLiquidSdk> {}
4949
4950impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<BindingLiquidSdk>> for BindingLiquidSdk {
4951    fn into_into_dart(self) -> FrbWrapper<BindingLiquidSdk> {
4952        self.into()
4953    }
4954}
4955
4956// Codec=Dco (DartCObject based), see doc to use other codecs
4957impl flutter_rust_bridge::IntoDart for crate::model::AcceptPaymentProposedFeesRequest {
4958    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
4959        [self.response.into_into_dart().into_dart()].into_dart()
4960    }
4961}
4962impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
4963    for crate::model::AcceptPaymentProposedFeesRequest
4964{
4965}
4966impl flutter_rust_bridge::IntoIntoDart<crate::model::AcceptPaymentProposedFeesRequest>
4967    for crate::model::AcceptPaymentProposedFeesRequest
4968{
4969    fn into_into_dart(self) -> crate::model::AcceptPaymentProposedFeesRequest {
4970        self
4971    }
4972}
4973// Codec=Dco (DartCObject based), see doc to use other codecs
4974impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::AesSuccessActionData> {
4975    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
4976        [
4977            self.0.description.into_into_dart().into_dart(),
4978            self.0.ciphertext.into_into_dart().into_dart(),
4979            self.0.iv.into_into_dart().into_dart(),
4980        ]
4981        .into_dart()
4982    }
4983}
4984impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
4985    for FrbWrapper<crate::bindings::AesSuccessActionData>
4986{
4987}
4988impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::AesSuccessActionData>>
4989    for crate::bindings::AesSuccessActionData
4990{
4991    fn into_into_dart(self) -> FrbWrapper<crate::bindings::AesSuccessActionData> {
4992        self.into()
4993    }
4994}
4995// Codec=Dco (DartCObject based), see doc to use other codecs
4996impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::AesSuccessActionDataDecrypted> {
4997    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
4998        [
4999            self.0.description.into_into_dart().into_dart(),
5000            self.0.plaintext.into_into_dart().into_dart(),
5001        ]
5002        .into_dart()
5003    }
5004}
5005impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5006    for FrbWrapper<crate::bindings::AesSuccessActionDataDecrypted>
5007{
5008}
5009impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::AesSuccessActionDataDecrypted>>
5010    for crate::bindings::AesSuccessActionDataDecrypted
5011{
5012    fn into_into_dart(self) -> FrbWrapper<crate::bindings::AesSuccessActionDataDecrypted> {
5013        self.into()
5014    }
5015}
5016// Codec=Dco (DartCObject based), see doc to use other codecs
5017impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::AesSuccessActionDataResult> {
5018    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5019        match self.0 {
5020            crate::bindings::AesSuccessActionDataResult::Decrypted { data } => {
5021                [0.into_dart(), data.into_into_dart().into_dart()].into_dart()
5022            }
5023            crate::bindings::AesSuccessActionDataResult::ErrorStatus { reason } => {
5024                [1.into_dart(), reason.into_into_dart().into_dart()].into_dart()
5025            }
5026            _ => {
5027                unimplemented!("");
5028            }
5029        }
5030    }
5031}
5032impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5033    for FrbWrapper<crate::bindings::AesSuccessActionDataResult>
5034{
5035}
5036impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::AesSuccessActionDataResult>>
5037    for crate::bindings::AesSuccessActionDataResult
5038{
5039    fn into_into_dart(self) -> FrbWrapper<crate::bindings::AesSuccessActionDataResult> {
5040        self.into()
5041    }
5042}
5043// Codec=Dco (DartCObject based), see doc to use other codecs
5044impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::Amount> {
5045    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5046        match self.0 {
5047            crate::bindings::Amount::Bitcoin { amount_msat } => {
5048                [0.into_dart(), amount_msat.into_into_dart().into_dart()].into_dart()
5049            }
5050            crate::bindings::Amount::Currency {
5051                iso4217_code,
5052                fractional_amount,
5053            } => [
5054                1.into_dart(),
5055                iso4217_code.into_into_dart().into_dart(),
5056                fractional_amount.into_into_dart().into_dart(),
5057            ]
5058            .into_dart(),
5059            _ => {
5060                unimplemented!("");
5061            }
5062        }
5063    }
5064}
5065impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5066    for FrbWrapper<crate::bindings::Amount>
5067{
5068}
5069impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::Amount>>
5070    for crate::bindings::Amount
5071{
5072    fn into_into_dart(self) -> FrbWrapper<crate::bindings::Amount> {
5073        self.into()
5074    }
5075}
5076// Codec=Dco (DartCObject based), see doc to use other codecs
5077impl flutter_rust_bridge::IntoDart for crate::model::AssetBalance {
5078    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5079        [
5080            self.asset_id.into_into_dart().into_dart(),
5081            self.balance_sat.into_into_dart().into_dart(),
5082            self.name.into_into_dart().into_dart(),
5083            self.ticker.into_into_dart().into_dart(),
5084            self.balance.into_into_dart().into_dart(),
5085        ]
5086        .into_dart()
5087    }
5088}
5089impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::AssetBalance {}
5090impl flutter_rust_bridge::IntoIntoDart<crate::model::AssetBalance> for crate::model::AssetBalance {
5091    fn into_into_dart(self) -> crate::model::AssetBalance {
5092        self
5093    }
5094}
5095// Codec=Dco (DartCObject based), see doc to use other codecs
5096impl flutter_rust_bridge::IntoDart for crate::model::AssetInfo {
5097    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5098        [
5099            self.name.into_into_dart().into_dart(),
5100            self.ticker.into_into_dart().into_dart(),
5101            self.amount.into_into_dart().into_dart(),
5102            self.fees.into_into_dart().into_dart(),
5103        ]
5104        .into_dart()
5105    }
5106}
5107impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::AssetInfo {}
5108impl flutter_rust_bridge::IntoIntoDart<crate::model::AssetInfo> for crate::model::AssetInfo {
5109    fn into_into_dart(self) -> crate::model::AssetInfo {
5110        self
5111    }
5112}
5113// Codec=Dco (DartCObject based), see doc to use other codecs
5114impl flutter_rust_bridge::IntoDart for crate::model::AssetMetadata {
5115    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5116        [
5117            self.asset_id.into_into_dart().into_dart(),
5118            self.name.into_into_dart().into_dart(),
5119            self.ticker.into_into_dart().into_dart(),
5120            self.precision.into_into_dart().into_dart(),
5121            self.fiat_id.into_into_dart().into_dart(),
5122        ]
5123        .into_dart()
5124    }
5125}
5126impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::AssetMetadata {}
5127impl flutter_rust_bridge::IntoIntoDart<crate::model::AssetMetadata>
5128    for crate::model::AssetMetadata
5129{
5130    fn into_into_dart(self) -> crate::model::AssetMetadata {
5131        self
5132    }
5133}
5134// Codec=Dco (DartCObject based), see doc to use other codecs
5135impl flutter_rust_bridge::IntoDart for crate::model::BackupRequest {
5136    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5137        [self.backup_path.into_into_dart().into_dart()].into_dart()
5138    }
5139}
5140impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::BackupRequest {}
5141impl flutter_rust_bridge::IntoIntoDart<crate::model::BackupRequest>
5142    for crate::model::BackupRequest
5143{
5144    fn into_into_dart(self) -> crate::model::BackupRequest {
5145        self
5146    }
5147}
5148// Codec=Dco (DartCObject based), see doc to use other codecs
5149impl flutter_rust_bridge::IntoDart for crate::bindings::BindingEventListener {
5150    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5151        [self.stream.into_into_dart().into_dart()].into_dart()
5152    }
5153}
5154impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5155    for crate::bindings::BindingEventListener
5156{
5157}
5158impl flutter_rust_bridge::IntoIntoDart<crate::bindings::BindingEventListener>
5159    for crate::bindings::BindingEventListener
5160{
5161    fn into_into_dart(self) -> crate::bindings::BindingEventListener {
5162        self
5163    }
5164}
5165// Codec=Dco (DartCObject based), see doc to use other codecs
5166impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::BitcoinAddressData> {
5167    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5168        [
5169            self.0.address.into_into_dart().into_dart(),
5170            self.0.network.into_into_dart().into_dart(),
5171            self.0.amount_sat.into_into_dart().into_dart(),
5172            self.0.label.into_into_dart().into_dart(),
5173            self.0.message.into_into_dart().into_dart(),
5174        ]
5175        .into_dart()
5176    }
5177}
5178impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5179    for FrbWrapper<crate::bindings::BitcoinAddressData>
5180{
5181}
5182impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::BitcoinAddressData>>
5183    for crate::bindings::BitcoinAddressData
5184{
5185    fn into_into_dart(self) -> FrbWrapper<crate::bindings::BitcoinAddressData> {
5186        self.into()
5187    }
5188}
5189// Codec=Dco (DartCObject based), see doc to use other codecs
5190impl flutter_rust_bridge::IntoDart for crate::model::BlockchainExplorer {
5191    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5192        match self {
5193            crate::model::BlockchainExplorer::Electrum { url } => {
5194                [0.into_dart(), url.into_into_dart().into_dart()].into_dart()
5195            }
5196            crate::model::BlockchainExplorer::Esplora {
5197                url,
5198                use_waterfalls,
5199            } => [
5200                1.into_dart(),
5201                url.into_into_dart().into_dart(),
5202                use_waterfalls.into_into_dart().into_dart(),
5203            ]
5204            .into_dart(),
5205            _ => {
5206                unimplemented!("");
5207            }
5208        }
5209    }
5210}
5211impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5212    for crate::model::BlockchainExplorer
5213{
5214}
5215impl flutter_rust_bridge::IntoIntoDart<crate::model::BlockchainExplorer>
5216    for crate::model::BlockchainExplorer
5217{
5218    fn into_into_dart(self) -> crate::model::BlockchainExplorer {
5219        self
5220    }
5221}
5222// Codec=Dco (DartCObject based), see doc to use other codecs
5223impl flutter_rust_bridge::IntoDart for crate::model::BlockchainInfo {
5224    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5225        [
5226            self.liquid_tip.into_into_dart().into_dart(),
5227            self.bitcoin_tip.into_into_dart().into_dart(),
5228        ]
5229        .into_dart()
5230    }
5231}
5232impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::BlockchainInfo {}
5233impl flutter_rust_bridge::IntoIntoDart<crate::model::BlockchainInfo>
5234    for crate::model::BlockchainInfo
5235{
5236    fn into_into_dart(self) -> crate::model::BlockchainInfo {
5237        self
5238    }
5239}
5240// Codec=Dco (DartCObject based), see doc to use other codecs
5241impl flutter_rust_bridge::IntoDart for crate::model::BuyBitcoinProvider {
5242    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5243        match self {
5244            Self::Moonpay => 0.into_dart(),
5245            _ => unreachable!(),
5246        }
5247    }
5248}
5249impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5250    for crate::model::BuyBitcoinProvider
5251{
5252}
5253impl flutter_rust_bridge::IntoIntoDart<crate::model::BuyBitcoinProvider>
5254    for crate::model::BuyBitcoinProvider
5255{
5256    fn into_into_dart(self) -> crate::model::BuyBitcoinProvider {
5257        self
5258    }
5259}
5260// Codec=Dco (DartCObject based), see doc to use other codecs
5261impl flutter_rust_bridge::IntoDart for crate::model::BuyBitcoinRequest {
5262    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5263        [
5264            self.prepare_response.into_into_dart().into_dart(),
5265            self.redirect_url.into_into_dart().into_dart(),
5266        ]
5267        .into_dart()
5268    }
5269}
5270impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5271    for crate::model::BuyBitcoinRequest
5272{
5273}
5274impl flutter_rust_bridge::IntoIntoDart<crate::model::BuyBitcoinRequest>
5275    for crate::model::BuyBitcoinRequest
5276{
5277    fn into_into_dart(self) -> crate::model::BuyBitcoinRequest {
5278        self
5279    }
5280}
5281// Codec=Dco (DartCObject based), see doc to use other codecs
5282impl flutter_rust_bridge::IntoDart for crate::model::CheckMessageRequest {
5283    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5284        [
5285            self.message.into_into_dart().into_dart(),
5286            self.pubkey.into_into_dart().into_dart(),
5287            self.signature.into_into_dart().into_dart(),
5288        ]
5289        .into_dart()
5290    }
5291}
5292impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5293    for crate::model::CheckMessageRequest
5294{
5295}
5296impl flutter_rust_bridge::IntoIntoDart<crate::model::CheckMessageRequest>
5297    for crate::model::CheckMessageRequest
5298{
5299    fn into_into_dart(self) -> crate::model::CheckMessageRequest {
5300        self
5301    }
5302}
5303// Codec=Dco (DartCObject based), see doc to use other codecs
5304impl flutter_rust_bridge::IntoDart for crate::model::CheckMessageResponse {
5305    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5306        [self.is_valid.into_into_dart().into_dart()].into_dart()
5307    }
5308}
5309impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5310    for crate::model::CheckMessageResponse
5311{
5312}
5313impl flutter_rust_bridge::IntoIntoDart<crate::model::CheckMessageResponse>
5314    for crate::model::CheckMessageResponse
5315{
5316    fn into_into_dart(self) -> crate::model::CheckMessageResponse {
5317        self
5318    }
5319}
5320// Codec=Dco (DartCObject based), see doc to use other codecs
5321impl flutter_rust_bridge::IntoDart for crate::model::Config {
5322    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5323        [
5324            self.liquid_explorer.into_into_dart().into_dart(),
5325            self.bitcoin_explorer.into_into_dart().into_dart(),
5326            self.working_dir.into_into_dart().into_dart(),
5327            self.network.into_into_dart().into_dart(),
5328            self.payment_timeout_sec.into_into_dart().into_dart(),
5329            self.sync_service_url.into_into_dart().into_dart(),
5330            self.zero_conf_max_amount_sat.into_into_dart().into_dart(),
5331            self.breez_api_key.into_into_dart().into_dart(),
5332            self.external_input_parsers.into_into_dart().into_dart(),
5333            self.use_default_external_input_parsers
5334                .into_into_dart()
5335                .into_dart(),
5336            self.onchain_fee_rate_leeway_sat_per_vbyte
5337                .into_into_dart()
5338                .into_dart(),
5339            self.asset_metadata.into_into_dart().into_dart(),
5340            self.sideswap_api_key.into_into_dart().into_dart(),
5341        ]
5342        .into_dart()
5343    }
5344}
5345impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::Config {}
5346impl flutter_rust_bridge::IntoIntoDart<crate::model::Config> for crate::model::Config {
5347    fn into_into_dart(self) -> crate::model::Config {
5348        self
5349    }
5350}
5351// Codec=Dco (DartCObject based), see doc to use other codecs
5352impl flutter_rust_bridge::IntoDart for crate::model::ConnectRequest {
5353    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5354        [
5355            self.config.into_into_dart().into_dart(),
5356            self.mnemonic.into_into_dart().into_dart(),
5357            self.passphrase.into_into_dart().into_dart(),
5358            self.seed.into_into_dart().into_dart(),
5359        ]
5360        .into_dart()
5361    }
5362}
5363impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::ConnectRequest {}
5364impl flutter_rust_bridge::IntoIntoDart<crate::model::ConnectRequest>
5365    for crate::model::ConnectRequest
5366{
5367    fn into_into_dart(self) -> crate::model::ConnectRequest {
5368        self
5369    }
5370}
5371// Codec=Dco (DartCObject based), see doc to use other codecs
5372impl flutter_rust_bridge::IntoDart for crate::model::CreateBolt12InvoiceRequest {
5373    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5374        [
5375            self.offer.into_into_dart().into_dart(),
5376            self.invoice_request.into_into_dart().into_dart(),
5377        ]
5378        .into_dart()
5379    }
5380}
5381impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5382    for crate::model::CreateBolt12InvoiceRequest
5383{
5384}
5385impl flutter_rust_bridge::IntoIntoDart<crate::model::CreateBolt12InvoiceRequest>
5386    for crate::model::CreateBolt12InvoiceRequest
5387{
5388    fn into_into_dart(self) -> crate::model::CreateBolt12InvoiceRequest {
5389        self
5390    }
5391}
5392// Codec=Dco (DartCObject based), see doc to use other codecs
5393impl flutter_rust_bridge::IntoDart for crate::model::CreateBolt12InvoiceResponse {
5394    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5395        [self.invoice.into_into_dart().into_dart()].into_dart()
5396    }
5397}
5398impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5399    for crate::model::CreateBolt12InvoiceResponse
5400{
5401}
5402impl flutter_rust_bridge::IntoIntoDart<crate::model::CreateBolt12InvoiceResponse>
5403    for crate::model::CreateBolt12InvoiceResponse
5404{
5405    fn into_into_dart(self) -> crate::model::CreateBolt12InvoiceResponse {
5406        self
5407    }
5408}
5409// Codec=Dco (DartCObject based), see doc to use other codecs
5410impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::CurrencyInfo> {
5411    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5412        [
5413            self.0.name.into_into_dart().into_dart(),
5414            self.0.fraction_size.into_into_dart().into_dart(),
5415            self.0.spacing.into_into_dart().into_dart(),
5416            self.0.symbol.into_into_dart().into_dart(),
5417            self.0.uniq_symbol.into_into_dart().into_dart(),
5418            self.0.localized_name.into_into_dart().into_dart(),
5419            self.0.locale_overrides.into_into_dart().into_dart(),
5420        ]
5421        .into_dart()
5422    }
5423}
5424impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5425    for FrbWrapper<crate::bindings::CurrencyInfo>
5426{
5427}
5428impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::CurrencyInfo>>
5429    for crate::bindings::CurrencyInfo
5430{
5431    fn into_into_dart(self) -> FrbWrapper<crate::bindings::CurrencyInfo> {
5432        self.into()
5433    }
5434}
5435// Codec=Dco (DartCObject based), see doc to use other codecs
5436impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::ExternalInputParser> {
5437    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5438        [
5439            self.0.provider_id.into_into_dart().into_dart(),
5440            self.0.input_regex.into_into_dart().into_dart(),
5441            self.0.parser_url.into_into_dart().into_dart(),
5442        ]
5443        .into_dart()
5444    }
5445}
5446impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5447    for FrbWrapper<crate::bindings::ExternalInputParser>
5448{
5449}
5450impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::ExternalInputParser>>
5451    for crate::bindings::ExternalInputParser
5452{
5453    fn into_into_dart(self) -> FrbWrapper<crate::bindings::ExternalInputParser> {
5454        self.into()
5455    }
5456}
5457// Codec=Dco (DartCObject based), see doc to use other codecs
5458impl flutter_rust_bridge::IntoDart for crate::model::FetchPaymentProposedFeesRequest {
5459    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5460        [self.swap_id.into_into_dart().into_dart()].into_dart()
5461    }
5462}
5463impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5464    for crate::model::FetchPaymentProposedFeesRequest
5465{
5466}
5467impl flutter_rust_bridge::IntoIntoDart<crate::model::FetchPaymentProposedFeesRequest>
5468    for crate::model::FetchPaymentProposedFeesRequest
5469{
5470    fn into_into_dart(self) -> crate::model::FetchPaymentProposedFeesRequest {
5471        self
5472    }
5473}
5474// Codec=Dco (DartCObject based), see doc to use other codecs
5475impl flutter_rust_bridge::IntoDart for crate::model::FetchPaymentProposedFeesResponse {
5476    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5477        [
5478            self.swap_id.into_into_dart().into_dart(),
5479            self.fees_sat.into_into_dart().into_dart(),
5480            self.payer_amount_sat.into_into_dart().into_dart(),
5481            self.receiver_amount_sat.into_into_dart().into_dart(),
5482        ]
5483        .into_dart()
5484    }
5485}
5486impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5487    for crate::model::FetchPaymentProposedFeesResponse
5488{
5489}
5490impl flutter_rust_bridge::IntoIntoDart<crate::model::FetchPaymentProposedFeesResponse>
5491    for crate::model::FetchPaymentProposedFeesResponse
5492{
5493    fn into_into_dart(self) -> crate::model::FetchPaymentProposedFeesResponse {
5494        self
5495    }
5496}
5497// Codec=Dco (DartCObject based), see doc to use other codecs
5498impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::FiatCurrency> {
5499    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5500        [
5501            self.0.id.into_into_dart().into_dart(),
5502            self.0.info.into_into_dart().into_dart(),
5503        ]
5504        .into_dart()
5505    }
5506}
5507impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5508    for FrbWrapper<crate::bindings::FiatCurrency>
5509{
5510}
5511impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::FiatCurrency>>
5512    for crate::bindings::FiatCurrency
5513{
5514    fn into_into_dart(self) -> FrbWrapper<crate::bindings::FiatCurrency> {
5515        self.into()
5516    }
5517}
5518// Codec=Dco (DartCObject based), see doc to use other codecs
5519impl flutter_rust_bridge::IntoDart for crate::model::GetInfoResponse {
5520    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5521        [
5522            self.wallet_info.into_into_dart().into_dart(),
5523            self.blockchain_info.into_into_dart().into_dart(),
5524        ]
5525        .into_dart()
5526    }
5527}
5528impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::GetInfoResponse {}
5529impl flutter_rust_bridge::IntoIntoDart<crate::model::GetInfoResponse>
5530    for crate::model::GetInfoResponse
5531{
5532    fn into_into_dart(self) -> crate::model::GetInfoResponse {
5533        self
5534    }
5535}
5536// Codec=Dco (DartCObject based), see doc to use other codecs
5537impl flutter_rust_bridge::IntoDart for crate::model::GetPaymentRequest {
5538    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5539        match self {
5540            crate::model::GetPaymentRequest::PaymentHash { payment_hash } => {
5541                [0.into_dart(), payment_hash.into_into_dart().into_dart()].into_dart()
5542            }
5543            crate::model::GetPaymentRequest::SwapId { swap_id } => {
5544                [1.into_dart(), swap_id.into_into_dart().into_dart()].into_dart()
5545            }
5546            _ => {
5547                unimplemented!("");
5548            }
5549        }
5550    }
5551}
5552impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5553    for crate::model::GetPaymentRequest
5554{
5555}
5556impl flutter_rust_bridge::IntoIntoDart<crate::model::GetPaymentRequest>
5557    for crate::model::GetPaymentRequest
5558{
5559    fn into_into_dart(self) -> crate::model::GetPaymentRequest {
5560        self
5561    }
5562}
5563// Codec=Dco (DartCObject based), see doc to use other codecs
5564impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::InputType> {
5565    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5566        match self.0 {
5567            crate::bindings::InputType::BitcoinAddress { address } => {
5568                [0.into_dart(), address.into_into_dart().into_dart()].into_dart()
5569            }
5570            crate::bindings::InputType::LiquidAddress { address } => {
5571                [1.into_dart(), address.into_into_dart().into_dart()].into_dart()
5572            }
5573            crate::bindings::InputType::Bolt11 { invoice } => {
5574                [2.into_dart(), invoice.into_into_dart().into_dart()].into_dart()
5575            }
5576            crate::bindings::InputType::Bolt12Offer {
5577                offer,
5578                bip353_address,
5579            } => [
5580                3.into_dart(),
5581                offer.into_into_dart().into_dart(),
5582                bip353_address.into_into_dart().into_dart(),
5583            ]
5584            .into_dart(),
5585            crate::bindings::InputType::NodeId { node_id } => {
5586                [4.into_dart(), node_id.into_into_dart().into_dart()].into_dart()
5587            }
5588            crate::bindings::InputType::Url { url } => {
5589                [5.into_dart(), url.into_into_dart().into_dart()].into_dart()
5590            }
5591            crate::bindings::InputType::LnUrlPay {
5592                data,
5593                bip353_address,
5594            } => [
5595                6.into_dart(),
5596                data.into_into_dart().into_dart(),
5597                bip353_address.into_into_dart().into_dart(),
5598            ]
5599            .into_dart(),
5600            crate::bindings::InputType::LnUrlWithdraw { data } => {
5601                [7.into_dart(), data.into_into_dart().into_dart()].into_dart()
5602            }
5603            crate::bindings::InputType::LnUrlAuth { data } => {
5604                [8.into_dart(), data.into_into_dart().into_dart()].into_dart()
5605            }
5606            crate::bindings::InputType::LnUrlError { data } => {
5607                [9.into_dart(), data.into_into_dart().into_dart()].into_dart()
5608            }
5609            _ => {
5610                unimplemented!("");
5611            }
5612        }
5613    }
5614}
5615impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5616    for FrbWrapper<crate::bindings::InputType>
5617{
5618}
5619impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::InputType>>
5620    for crate::bindings::InputType
5621{
5622    fn into_into_dart(self) -> FrbWrapper<crate::bindings::InputType> {
5623        self.into()
5624    }
5625}
5626// Codec=Dco (DartCObject based), see doc to use other codecs
5627impl flutter_rust_bridge::IntoDart for crate::model::LightningPaymentLimitsResponse {
5628    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5629        [
5630            self.send.into_into_dart().into_dart(),
5631            self.receive.into_into_dart().into_dart(),
5632        ]
5633        .into_dart()
5634    }
5635}
5636impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5637    for crate::model::LightningPaymentLimitsResponse
5638{
5639}
5640impl flutter_rust_bridge::IntoIntoDart<crate::model::LightningPaymentLimitsResponse>
5641    for crate::model::LightningPaymentLimitsResponse
5642{
5643    fn into_into_dart(self) -> crate::model::LightningPaymentLimitsResponse {
5644        self
5645    }
5646}
5647// Codec=Dco (DartCObject based), see doc to use other codecs
5648impl flutter_rust_bridge::IntoDart for crate::model::Limits {
5649    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5650        [
5651            self.min_sat.into_into_dart().into_dart(),
5652            self.max_sat.into_into_dart().into_dart(),
5653            self.max_zero_conf_sat.into_into_dart().into_dart(),
5654        ]
5655        .into_dart()
5656    }
5657}
5658impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::Limits {}
5659impl flutter_rust_bridge::IntoIntoDart<crate::model::Limits> for crate::model::Limits {
5660    fn into_into_dart(self) -> crate::model::Limits {
5661        self
5662    }
5663}
5664// Codec=Dco (DartCObject based), see doc to use other codecs
5665impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LiquidAddressData> {
5666    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5667        [
5668            self.0.address.into_into_dart().into_dart(),
5669            self.0.network.into_into_dart().into_dart(),
5670            self.0.asset_id.into_into_dart().into_dart(),
5671            self.0.amount.into_into_dart().into_dart(),
5672            self.0.amount_sat.into_into_dart().into_dart(),
5673            self.0.label.into_into_dart().into_dart(),
5674            self.0.message.into_into_dart().into_dart(),
5675        ]
5676        .into_dart()
5677    }
5678}
5679impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5680    for FrbWrapper<crate::bindings::LiquidAddressData>
5681{
5682}
5683impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LiquidAddressData>>
5684    for crate::bindings::LiquidAddressData
5685{
5686    fn into_into_dart(self) -> FrbWrapper<crate::bindings::LiquidAddressData> {
5687        self.into()
5688    }
5689}
5690// Codec=Dco (DartCObject based), see doc to use other codecs
5691impl flutter_rust_bridge::IntoDart for crate::model::LiquidNetwork {
5692    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5693        match self {
5694            Self::Mainnet => 0.into_dart(),
5695            Self::Testnet => 1.into_dart(),
5696            Self::Regtest => 2.into_dart(),
5697            _ => unreachable!(),
5698        }
5699    }
5700}
5701impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::LiquidNetwork {}
5702impl flutter_rust_bridge::IntoIntoDart<crate::model::LiquidNetwork>
5703    for crate::model::LiquidNetwork
5704{
5705    fn into_into_dart(self) -> crate::model::LiquidNetwork {
5706        self
5707    }
5708}
5709// Codec=Dco (DartCObject based), see doc to use other codecs
5710impl flutter_rust_bridge::IntoDart for crate::model::ListPaymentDetails {
5711    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5712        match self {
5713            crate::model::ListPaymentDetails::Liquid {
5714                asset_id,
5715                destination,
5716            } => [
5717                0.into_dart(),
5718                asset_id.into_into_dart().into_dart(),
5719                destination.into_into_dart().into_dart(),
5720            ]
5721            .into_dart(),
5722            crate::model::ListPaymentDetails::Bitcoin { address } => {
5723                [1.into_dart(), address.into_into_dart().into_dart()].into_dart()
5724            }
5725            _ => {
5726                unimplemented!("");
5727            }
5728        }
5729    }
5730}
5731impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5732    for crate::model::ListPaymentDetails
5733{
5734}
5735impl flutter_rust_bridge::IntoIntoDart<crate::model::ListPaymentDetails>
5736    for crate::model::ListPaymentDetails
5737{
5738    fn into_into_dart(self) -> crate::model::ListPaymentDetails {
5739        self
5740    }
5741}
5742// Codec=Dco (DartCObject based), see doc to use other codecs
5743impl flutter_rust_bridge::IntoDart for crate::model::ListPaymentsRequest {
5744    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5745        [
5746            self.filters.into_into_dart().into_dart(),
5747            self.states.into_into_dart().into_dart(),
5748            self.from_timestamp.into_into_dart().into_dart(),
5749            self.to_timestamp.into_into_dart().into_dart(),
5750            self.offset.into_into_dart().into_dart(),
5751            self.limit.into_into_dart().into_dart(),
5752            self.details.into_into_dart().into_dart(),
5753            self.sort_ascending.into_into_dart().into_dart(),
5754        ]
5755        .into_dart()
5756    }
5757}
5758impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5759    for crate::model::ListPaymentsRequest
5760{
5761}
5762impl flutter_rust_bridge::IntoIntoDart<crate::model::ListPaymentsRequest>
5763    for crate::model::ListPaymentsRequest
5764{
5765    fn into_into_dart(self) -> crate::model::ListPaymentsRequest {
5766        self
5767    }
5768}
5769// Codec=Dco (DartCObject based), see doc to use other codecs
5770impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LNInvoice> {
5771    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5772        [
5773            self.0.bolt11.into_into_dart().into_dart(),
5774            self.0.network.into_into_dart().into_dart(),
5775            self.0.payee_pubkey.into_into_dart().into_dart(),
5776            self.0.payment_hash.into_into_dart().into_dart(),
5777            self.0.description.into_into_dart().into_dart(),
5778            self.0.description_hash.into_into_dart().into_dart(),
5779            self.0.amount_msat.into_into_dart().into_dart(),
5780            self.0.timestamp.into_into_dart().into_dart(),
5781            self.0.expiry.into_into_dart().into_dart(),
5782            self.0.routing_hints.into_into_dart().into_dart(),
5783            self.0.payment_secret.into_into_dart().into_dart(),
5784            self.0
5785                .min_final_cltv_expiry_delta
5786                .into_into_dart()
5787                .into_dart(),
5788        ]
5789        .into_dart()
5790    }
5791}
5792impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5793    for FrbWrapper<crate::bindings::LNInvoice>
5794{
5795}
5796impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LNInvoice>>
5797    for crate::bindings::LNInvoice
5798{
5799    fn into_into_dart(self) -> FrbWrapper<crate::bindings::LNInvoice> {
5800        self.into()
5801    }
5802}
5803// Codec=Dco (DartCObject based), see doc to use other codecs
5804impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LNOffer> {
5805    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5806        [
5807            self.0.offer.into_into_dart().into_dart(),
5808            self.0.chains.into_into_dart().into_dart(),
5809            self.0.min_amount.into_into_dart().into_dart(),
5810            self.0.description.into_into_dart().into_dart(),
5811            self.0.absolute_expiry.into_into_dart().into_dart(),
5812            self.0.issuer.into_into_dart().into_dart(),
5813            self.0.signing_pubkey.into_into_dart().into_dart(),
5814            self.0.paths.into_into_dart().into_dart(),
5815        ]
5816        .into_dart()
5817    }
5818}
5819impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5820    for FrbWrapper<crate::bindings::LNOffer>
5821{
5822}
5823impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LNOffer>>
5824    for crate::bindings::LNOffer
5825{
5826    fn into_into_dart(self) -> FrbWrapper<crate::bindings::LNOffer> {
5827        self.into()
5828    }
5829}
5830// Codec=Dco (DartCObject based), see doc to use other codecs
5831impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LnOfferBlindedPath> {
5832    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5833        [self.0.blinded_hops.into_into_dart().into_dart()].into_dart()
5834    }
5835}
5836impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5837    for FrbWrapper<crate::bindings::LnOfferBlindedPath>
5838{
5839}
5840impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LnOfferBlindedPath>>
5841    for crate::bindings::LnOfferBlindedPath
5842{
5843    fn into_into_dart(self) -> FrbWrapper<crate::bindings::LnOfferBlindedPath> {
5844        self.into()
5845    }
5846}
5847// Codec=Dco (DartCObject based), see doc to use other codecs
5848impl flutter_rust_bridge::IntoDart for crate::bindings::duplicates::LnUrlAuthError {
5849    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5850        match self {
5851            crate::bindings::duplicates::LnUrlAuthError::Generic { err } => {
5852                [0.into_dart(), err.into_into_dart().into_dart()].into_dart()
5853            }
5854            crate::bindings::duplicates::LnUrlAuthError::InvalidUri { err } => {
5855                [1.into_dart(), err.into_into_dart().into_dart()].into_dart()
5856            }
5857            crate::bindings::duplicates::LnUrlAuthError::ServiceConnectivity { err } => {
5858                [2.into_dart(), err.into_into_dart().into_dart()].into_dart()
5859            }
5860            _ => {
5861                unimplemented!("");
5862            }
5863        }
5864    }
5865}
5866impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5867    for crate::bindings::duplicates::LnUrlAuthError
5868{
5869}
5870impl flutter_rust_bridge::IntoIntoDart<crate::bindings::duplicates::LnUrlAuthError>
5871    for crate::bindings::duplicates::LnUrlAuthError
5872{
5873    fn into_into_dart(self) -> crate::bindings::duplicates::LnUrlAuthError {
5874        self
5875    }
5876}
5877// Codec=Dco (DartCObject based), see doc to use other codecs
5878impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LnUrlAuthRequestData> {
5879    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5880        [
5881            self.0.k1.into_into_dart().into_dart(),
5882            self.0.action.into_into_dart().into_dart(),
5883            self.0.domain.into_into_dart().into_dart(),
5884            self.0.url.into_into_dart().into_dart(),
5885        ]
5886        .into_dart()
5887    }
5888}
5889impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5890    for FrbWrapper<crate::bindings::LnUrlAuthRequestData>
5891{
5892}
5893impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LnUrlAuthRequestData>>
5894    for crate::bindings::LnUrlAuthRequestData
5895{
5896    fn into_into_dart(self) -> FrbWrapper<crate::bindings::LnUrlAuthRequestData> {
5897        self.into()
5898    }
5899}
5900// Codec=Dco (DartCObject based), see doc to use other codecs
5901impl flutter_rust_bridge::IntoDart for crate::bindings::duplicates::LnUrlCallbackStatus {
5902    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5903        match self {
5904            crate::bindings::duplicates::LnUrlCallbackStatus::Ok => [0.into_dart()].into_dart(),
5905            crate::bindings::duplicates::LnUrlCallbackStatus::ErrorStatus { data } => {
5906                [1.into_dart(), data.into_into_dart().into_dart()].into_dart()
5907            }
5908            _ => {
5909                unimplemented!("");
5910            }
5911        }
5912    }
5913}
5914impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5915    for crate::bindings::duplicates::LnUrlCallbackStatus
5916{
5917}
5918impl flutter_rust_bridge::IntoIntoDart<crate::bindings::duplicates::LnUrlCallbackStatus>
5919    for crate::bindings::duplicates::LnUrlCallbackStatus
5920{
5921    fn into_into_dart(self) -> crate::bindings::duplicates::LnUrlCallbackStatus {
5922        self
5923    }
5924}
5925// Codec=Dco (DartCObject based), see doc to use other codecs
5926impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LnUrlErrorData> {
5927    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5928        [self.0.reason.into_into_dart().into_dart()].into_dart()
5929    }
5930}
5931impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
5932    for FrbWrapper<crate::bindings::LnUrlErrorData>
5933{
5934}
5935impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LnUrlErrorData>>
5936    for crate::bindings::LnUrlErrorData
5937{
5938    fn into_into_dart(self) -> FrbWrapper<crate::bindings::LnUrlErrorData> {
5939        self.into()
5940    }
5941}
5942// Codec=Dco (DartCObject based), see doc to use other codecs
5943impl flutter_rust_bridge::IntoDart for crate::model::LnUrlInfo {
5944    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5945        [
5946            self.ln_address.into_into_dart().into_dart(),
5947            self.lnurl_pay_comment.into_into_dart().into_dart(),
5948            self.lnurl_pay_domain.into_into_dart().into_dart(),
5949            self.lnurl_pay_metadata.into_into_dart().into_dart(),
5950            self.lnurl_pay_success_action.into_into_dart().into_dart(),
5951            self.lnurl_pay_unprocessed_success_action
5952                .into_into_dart()
5953                .into_dart(),
5954            self.lnurl_withdraw_endpoint.into_into_dart().into_dart(),
5955        ]
5956        .into_dart()
5957    }
5958}
5959impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::LnUrlInfo {}
5960impl flutter_rust_bridge::IntoIntoDart<crate::model::LnUrlInfo> for crate::model::LnUrlInfo {
5961    fn into_into_dart(self) -> crate::model::LnUrlInfo {
5962        self
5963    }
5964}
5965// Codec=Dco (DartCObject based), see doc to use other codecs
5966impl flutter_rust_bridge::IntoDart for crate::bindings::duplicates::LnUrlPayError {
5967    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
5968        match self {
5969            crate::bindings::duplicates::LnUrlPayError::AlreadyPaid => [0.into_dart()].into_dart(),
5970            crate::bindings::duplicates::LnUrlPayError::Generic { err } => {
5971                [1.into_dart(), err.into_into_dart().into_dart()].into_dart()
5972            }
5973            crate::bindings::duplicates::LnUrlPayError::InsufficientBalance { err } => {
5974                [2.into_dart(), err.into_into_dart().into_dart()].into_dart()
5975            }
5976            crate::bindings::duplicates::LnUrlPayError::InvalidAmount { err } => {
5977                [3.into_dart(), err.into_into_dart().into_dart()].into_dart()
5978            }
5979            crate::bindings::duplicates::LnUrlPayError::InvalidInvoice { err } => {
5980                [4.into_dart(), err.into_into_dart().into_dart()].into_dart()
5981            }
5982            crate::bindings::duplicates::LnUrlPayError::InvalidNetwork { err } => {
5983                [5.into_dart(), err.into_into_dart().into_dart()].into_dart()
5984            }
5985            crate::bindings::duplicates::LnUrlPayError::InvalidUri { err } => {
5986                [6.into_dart(), err.into_into_dart().into_dart()].into_dart()
5987            }
5988            crate::bindings::duplicates::LnUrlPayError::InvoiceExpired { err } => {
5989                [7.into_dart(), err.into_into_dart().into_dart()].into_dart()
5990            }
5991            crate::bindings::duplicates::LnUrlPayError::PaymentFailed { err } => {
5992                [8.into_dart(), err.into_into_dart().into_dart()].into_dart()
5993            }
5994            crate::bindings::duplicates::LnUrlPayError::PaymentTimeout { err } => {
5995                [9.into_dart(), err.into_into_dart().into_dart()].into_dart()
5996            }
5997            crate::bindings::duplicates::LnUrlPayError::RouteNotFound { err } => {
5998                [10.into_dart(), err.into_into_dart().into_dart()].into_dart()
5999            }
6000            crate::bindings::duplicates::LnUrlPayError::RouteTooExpensive { err } => {
6001                [11.into_dart(), err.into_into_dart().into_dart()].into_dart()
6002            }
6003            crate::bindings::duplicates::LnUrlPayError::ServiceConnectivity { err } => {
6004                [12.into_dart(), err.into_into_dart().into_dart()].into_dart()
6005            }
6006            _ => {
6007                unimplemented!("");
6008            }
6009        }
6010    }
6011}
6012impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6013    for crate::bindings::duplicates::LnUrlPayError
6014{
6015}
6016impl flutter_rust_bridge::IntoIntoDart<crate::bindings::duplicates::LnUrlPayError>
6017    for crate::bindings::duplicates::LnUrlPayError
6018{
6019    fn into_into_dart(self) -> crate::bindings::duplicates::LnUrlPayError {
6020        self
6021    }
6022}
6023// Codec=Dco (DartCObject based), see doc to use other codecs
6024impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LnUrlPayErrorData> {
6025    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6026        [
6027            self.0.payment_hash.into_into_dart().into_dart(),
6028            self.0.reason.into_into_dart().into_dart(),
6029        ]
6030        .into_dart()
6031    }
6032}
6033impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6034    for FrbWrapper<crate::bindings::LnUrlPayErrorData>
6035{
6036}
6037impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LnUrlPayErrorData>>
6038    for crate::bindings::LnUrlPayErrorData
6039{
6040    fn into_into_dart(self) -> FrbWrapper<crate::bindings::LnUrlPayErrorData> {
6041        self.into()
6042    }
6043}
6044// Codec=Dco (DartCObject based), see doc to use other codecs
6045impl flutter_rust_bridge::IntoDart for crate::model::LnUrlPayRequest {
6046    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6047        [self.prepare_response.into_into_dart().into_dart()].into_dart()
6048    }
6049}
6050impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::LnUrlPayRequest {}
6051impl flutter_rust_bridge::IntoIntoDart<crate::model::LnUrlPayRequest>
6052    for crate::model::LnUrlPayRequest
6053{
6054    fn into_into_dart(self) -> crate::model::LnUrlPayRequest {
6055        self
6056    }
6057}
6058// Codec=Dco (DartCObject based), see doc to use other codecs
6059impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LnUrlPayRequestData> {
6060    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6061        [
6062            self.0.callback.into_into_dart().into_dart(),
6063            self.0.min_sendable.into_into_dart().into_dart(),
6064            self.0.max_sendable.into_into_dart().into_dart(),
6065            self.0.metadata_str.into_into_dart().into_dart(),
6066            self.0.comment_allowed.into_into_dart().into_dart(),
6067            self.0.domain.into_into_dart().into_dart(),
6068            self.0.allows_nostr.into_into_dart().into_dart(),
6069            self.0.nostr_pubkey.into_into_dart().into_dart(),
6070            self.0.ln_address.into_into_dart().into_dart(),
6071        ]
6072        .into_dart()
6073    }
6074}
6075impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6076    for FrbWrapper<crate::bindings::LnUrlPayRequestData>
6077{
6078}
6079impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LnUrlPayRequestData>>
6080    for crate::bindings::LnUrlPayRequestData
6081{
6082    fn into_into_dart(self) -> FrbWrapper<crate::bindings::LnUrlPayRequestData> {
6083        self.into()
6084    }
6085}
6086// Codec=Dco (DartCObject based), see doc to use other codecs
6087impl flutter_rust_bridge::IntoDart for crate::model::LnUrlPayResult {
6088    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6089        match self {
6090            crate::model::LnUrlPayResult::EndpointSuccess { data } => {
6091                [0.into_dart(), data.into_into_dart().into_dart()].into_dart()
6092            }
6093            crate::model::LnUrlPayResult::EndpointError { data } => {
6094                [1.into_dart(), data.into_into_dart().into_dart()].into_dart()
6095            }
6096            crate::model::LnUrlPayResult::PayError { data } => {
6097                [2.into_dart(), data.into_into_dart().into_dart()].into_dart()
6098            }
6099            _ => {
6100                unimplemented!("");
6101            }
6102        }
6103    }
6104}
6105impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::LnUrlPayResult {}
6106impl flutter_rust_bridge::IntoIntoDart<crate::model::LnUrlPayResult>
6107    for crate::model::LnUrlPayResult
6108{
6109    fn into_into_dart(self) -> crate::model::LnUrlPayResult {
6110        self
6111    }
6112}
6113// Codec=Dco (DartCObject based), see doc to use other codecs
6114impl flutter_rust_bridge::IntoDart for crate::model::LnUrlPaySuccessData {
6115    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6116        [
6117            self.payment.into_into_dart().into_dart(),
6118            self.success_action.into_into_dart().into_dart(),
6119        ]
6120        .into_dart()
6121    }
6122}
6123impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6124    for crate::model::LnUrlPaySuccessData
6125{
6126}
6127impl flutter_rust_bridge::IntoIntoDart<crate::model::LnUrlPaySuccessData>
6128    for crate::model::LnUrlPaySuccessData
6129{
6130    fn into_into_dart(self) -> crate::model::LnUrlPaySuccessData {
6131        self
6132    }
6133}
6134// Codec=Dco (DartCObject based), see doc to use other codecs
6135impl flutter_rust_bridge::IntoDart for crate::bindings::duplicates::LnUrlWithdrawError {
6136    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6137        match self {
6138            crate::bindings::duplicates::LnUrlWithdrawError::Generic { err } => {
6139                [0.into_dart(), err.into_into_dart().into_dart()].into_dart()
6140            }
6141            crate::bindings::duplicates::LnUrlWithdrawError::InvalidAmount { err } => {
6142                [1.into_dart(), err.into_into_dart().into_dart()].into_dart()
6143            }
6144            crate::bindings::duplicates::LnUrlWithdrawError::InvalidInvoice { err } => {
6145                [2.into_dart(), err.into_into_dart().into_dart()].into_dart()
6146            }
6147            crate::bindings::duplicates::LnUrlWithdrawError::InvalidUri { err } => {
6148                [3.into_dart(), err.into_into_dart().into_dart()].into_dart()
6149            }
6150            crate::bindings::duplicates::LnUrlWithdrawError::InvoiceNoRoutingHints { err } => {
6151                [4.into_dart(), err.into_into_dart().into_dart()].into_dart()
6152            }
6153            crate::bindings::duplicates::LnUrlWithdrawError::ServiceConnectivity { err } => {
6154                [5.into_dart(), err.into_into_dart().into_dart()].into_dart()
6155            }
6156            _ => {
6157                unimplemented!("");
6158            }
6159        }
6160    }
6161}
6162impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6163    for crate::bindings::duplicates::LnUrlWithdrawError
6164{
6165}
6166impl flutter_rust_bridge::IntoIntoDart<crate::bindings::duplicates::LnUrlWithdrawError>
6167    for crate::bindings::duplicates::LnUrlWithdrawError
6168{
6169    fn into_into_dart(self) -> crate::bindings::duplicates::LnUrlWithdrawError {
6170        self
6171    }
6172}
6173// Codec=Dco (DartCObject based), see doc to use other codecs
6174impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LnUrlWithdrawRequest> {
6175    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6176        [
6177            self.0.data.into_into_dart().into_dart(),
6178            self.0.amount_msat.into_into_dart().into_dart(),
6179            self.0.description.into_into_dart().into_dart(),
6180        ]
6181        .into_dart()
6182    }
6183}
6184impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6185    for FrbWrapper<crate::bindings::LnUrlWithdrawRequest>
6186{
6187}
6188impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LnUrlWithdrawRequest>>
6189    for crate::bindings::LnUrlWithdrawRequest
6190{
6191    fn into_into_dart(self) -> FrbWrapper<crate::bindings::LnUrlWithdrawRequest> {
6192        self.into()
6193    }
6194}
6195// Codec=Dco (DartCObject based), see doc to use other codecs
6196impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LnUrlWithdrawRequestData> {
6197    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6198        [
6199            self.0.callback.into_into_dart().into_dart(),
6200            self.0.k1.into_into_dart().into_dart(),
6201            self.0.default_description.into_into_dart().into_dart(),
6202            self.0.min_withdrawable.into_into_dart().into_dart(),
6203            self.0.max_withdrawable.into_into_dart().into_dart(),
6204        ]
6205        .into_dart()
6206    }
6207}
6208impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6209    for FrbWrapper<crate::bindings::LnUrlWithdrawRequestData>
6210{
6211}
6212impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LnUrlWithdrawRequestData>>
6213    for crate::bindings::LnUrlWithdrawRequestData
6214{
6215    fn into_into_dart(self) -> FrbWrapper<crate::bindings::LnUrlWithdrawRequestData> {
6216        self.into()
6217    }
6218}
6219// Codec=Dco (DartCObject based), see doc to use other codecs
6220impl flutter_rust_bridge::IntoDart for crate::bindings::duplicates::LnUrlWithdrawResult {
6221    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6222        match self {
6223            crate::bindings::duplicates::LnUrlWithdrawResult::Ok { data } => {
6224                [0.into_dart(), data.into_into_dart().into_dart()].into_dart()
6225            }
6226            crate::bindings::duplicates::LnUrlWithdrawResult::Timeout { data } => {
6227                [1.into_dart(), data.into_into_dart().into_dart()].into_dart()
6228            }
6229            crate::bindings::duplicates::LnUrlWithdrawResult::ErrorStatus { data } => {
6230                [2.into_dart(), data.into_into_dart().into_dart()].into_dart()
6231            }
6232            _ => {
6233                unimplemented!("");
6234            }
6235        }
6236    }
6237}
6238impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6239    for crate::bindings::duplicates::LnUrlWithdrawResult
6240{
6241}
6242impl flutter_rust_bridge::IntoIntoDart<crate::bindings::duplicates::LnUrlWithdrawResult>
6243    for crate::bindings::duplicates::LnUrlWithdrawResult
6244{
6245    fn into_into_dart(self) -> crate::bindings::duplicates::LnUrlWithdrawResult {
6246        self
6247    }
6248}
6249// Codec=Dco (DartCObject based), see doc to use other codecs
6250impl flutter_rust_bridge::IntoDart for crate::bindings::duplicates::LnUrlWithdrawSuccessData {
6251    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6252        [self.invoice.into_into_dart().into_dart()].into_dart()
6253    }
6254}
6255impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6256    for crate::bindings::duplicates::LnUrlWithdrawSuccessData
6257{
6258}
6259impl flutter_rust_bridge::IntoIntoDart<crate::bindings::duplicates::LnUrlWithdrawSuccessData>
6260    for crate::bindings::duplicates::LnUrlWithdrawSuccessData
6261{
6262    fn into_into_dart(self) -> crate::bindings::duplicates::LnUrlWithdrawSuccessData {
6263        self
6264    }
6265}
6266// Codec=Dco (DartCObject based), see doc to use other codecs
6267impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LocaleOverrides> {
6268    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6269        [
6270            self.0.locale.into_into_dart().into_dart(),
6271            self.0.spacing.into_into_dart().into_dart(),
6272            self.0.symbol.into_into_dart().into_dart(),
6273        ]
6274        .into_dart()
6275    }
6276}
6277impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6278    for FrbWrapper<crate::bindings::LocaleOverrides>
6279{
6280}
6281impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LocaleOverrides>>
6282    for crate::bindings::LocaleOverrides
6283{
6284    fn into_into_dart(self) -> FrbWrapper<crate::bindings::LocaleOverrides> {
6285        self.into()
6286    }
6287}
6288// Codec=Dco (DartCObject based), see doc to use other codecs
6289impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::LocalizedName> {
6290    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6291        [
6292            self.0.locale.into_into_dart().into_dart(),
6293            self.0.name.into_into_dart().into_dart(),
6294        ]
6295        .into_dart()
6296    }
6297}
6298impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6299    for FrbWrapper<crate::bindings::LocalizedName>
6300{
6301}
6302impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::LocalizedName>>
6303    for crate::bindings::LocalizedName
6304{
6305    fn into_into_dart(self) -> FrbWrapper<crate::bindings::LocalizedName> {
6306        self.into()
6307    }
6308}
6309// Codec=Dco (DartCObject based), see doc to use other codecs
6310impl flutter_rust_bridge::IntoDart for crate::model::LogEntry {
6311    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6312        [
6313            self.line.into_into_dart().into_dart(),
6314            self.level.into_into_dart().into_dart(),
6315        ]
6316        .into_dart()
6317    }
6318}
6319impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::LogEntry {}
6320impl flutter_rust_bridge::IntoIntoDart<crate::model::LogEntry> for crate::model::LogEntry {
6321    fn into_into_dart(self) -> crate::model::LogEntry {
6322        self
6323    }
6324}
6325// Codec=Dco (DartCObject based), see doc to use other codecs
6326impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::MessageSuccessActionData> {
6327    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6328        [self.0.message.into_into_dart().into_dart()].into_dart()
6329    }
6330}
6331impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6332    for FrbWrapper<crate::bindings::MessageSuccessActionData>
6333{
6334}
6335impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::MessageSuccessActionData>>
6336    for crate::bindings::MessageSuccessActionData
6337{
6338    fn into_into_dart(self) -> FrbWrapper<crate::bindings::MessageSuccessActionData> {
6339        self.into()
6340    }
6341}
6342// Codec=Dco (DartCObject based), see doc to use other codecs
6343impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::Network> {
6344    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6345        match self.0 {
6346            crate::bindings::Network::Bitcoin => 0.into_dart(),
6347            crate::bindings::Network::Testnet => 1.into_dart(),
6348            crate::bindings::Network::Signet => 2.into_dart(),
6349            crate::bindings::Network::Regtest => 3.into_dart(),
6350            _ => unreachable!(),
6351        }
6352    }
6353}
6354impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6355    for FrbWrapper<crate::bindings::Network>
6356{
6357}
6358impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::Network>>
6359    for crate::bindings::Network
6360{
6361    fn into_into_dart(self) -> FrbWrapper<crate::bindings::Network> {
6362        self.into()
6363    }
6364}
6365// Codec=Dco (DartCObject based), see doc to use other codecs
6366impl flutter_rust_bridge::IntoDart for crate::model::OnchainPaymentLimitsResponse {
6367    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6368        [
6369            self.send.into_into_dart().into_dart(),
6370            self.receive.into_into_dart().into_dart(),
6371        ]
6372        .into_dart()
6373    }
6374}
6375impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6376    for crate::model::OnchainPaymentLimitsResponse
6377{
6378}
6379impl flutter_rust_bridge::IntoIntoDart<crate::model::OnchainPaymentLimitsResponse>
6380    for crate::model::OnchainPaymentLimitsResponse
6381{
6382    fn into_into_dart(self) -> crate::model::OnchainPaymentLimitsResponse {
6383        self
6384    }
6385}
6386// Codec=Dco (DartCObject based), see doc to use other codecs
6387impl flutter_rust_bridge::IntoDart for crate::model::PayAmount {
6388    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6389        match self {
6390            crate::model::PayAmount::Bitcoin {
6391                receiver_amount_sat,
6392            } => [
6393                0.into_dart(),
6394                receiver_amount_sat.into_into_dart().into_dart(),
6395            ]
6396            .into_dart(),
6397            crate::model::PayAmount::Asset {
6398                asset_id,
6399                receiver_amount,
6400                estimate_asset_fees,
6401            } => [
6402                1.into_dart(),
6403                asset_id.into_into_dart().into_dart(),
6404                receiver_amount.into_into_dart().into_dart(),
6405                estimate_asset_fees.into_into_dart().into_dart(),
6406            ]
6407            .into_dart(),
6408            crate::model::PayAmount::Drain => [2.into_dart()].into_dart(),
6409            _ => {
6410                unimplemented!("");
6411            }
6412        }
6413    }
6414}
6415impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::PayAmount {}
6416impl flutter_rust_bridge::IntoIntoDart<crate::model::PayAmount> for crate::model::PayAmount {
6417    fn into_into_dart(self) -> crate::model::PayAmount {
6418        self
6419    }
6420}
6421// Codec=Dco (DartCObject based), see doc to use other codecs
6422impl flutter_rust_bridge::IntoDart for crate::model::PayOnchainRequest {
6423    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6424        [
6425            self.address.into_into_dart().into_dart(),
6426            self.prepare_response.into_into_dart().into_dart(),
6427        ]
6428        .into_dart()
6429    }
6430}
6431impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6432    for crate::model::PayOnchainRequest
6433{
6434}
6435impl flutter_rust_bridge::IntoIntoDart<crate::model::PayOnchainRequest>
6436    for crate::model::PayOnchainRequest
6437{
6438    fn into_into_dart(self) -> crate::model::PayOnchainRequest {
6439        self
6440    }
6441}
6442// Codec=Dco (DartCObject based), see doc to use other codecs
6443impl flutter_rust_bridge::IntoDart for crate::model::Payment {
6444    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6445        [
6446            self.destination.into_into_dart().into_dart(),
6447            self.tx_id.into_into_dart().into_dart(),
6448            self.unblinding_data.into_into_dart().into_dart(),
6449            self.timestamp.into_into_dart().into_dart(),
6450            self.amount_sat.into_into_dart().into_dart(),
6451            self.fees_sat.into_into_dart().into_dart(),
6452            self.swapper_fees_sat.into_into_dart().into_dart(),
6453            self.payment_type.into_into_dart().into_dart(),
6454            self.status.into_into_dart().into_dart(),
6455            self.details.into_into_dart().into_dart(),
6456        ]
6457        .into_dart()
6458    }
6459}
6460impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::Payment {}
6461impl flutter_rust_bridge::IntoIntoDart<crate::model::Payment> for crate::model::Payment {
6462    fn into_into_dart(self) -> crate::model::Payment {
6463        self
6464    }
6465}
6466// Codec=Dco (DartCObject based), see doc to use other codecs
6467impl flutter_rust_bridge::IntoDart for crate::model::PaymentDetails {
6468    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6469        match self {
6470            crate::model::PaymentDetails::Lightning {
6471                swap_id,
6472                description,
6473                liquid_expiration_blockheight,
6474                preimage,
6475                invoice,
6476                bolt12_offer,
6477                payment_hash,
6478                destination_pubkey,
6479                lnurl_info,
6480                bip353_address,
6481                claim_tx_id,
6482                refund_tx_id,
6483                refund_tx_amount_sat,
6484            } => [
6485                0.into_dart(),
6486                swap_id.into_into_dart().into_dart(),
6487                description.into_into_dart().into_dart(),
6488                liquid_expiration_blockheight.into_into_dart().into_dart(),
6489                preimage.into_into_dart().into_dart(),
6490                invoice.into_into_dart().into_dart(),
6491                bolt12_offer.into_into_dart().into_dart(),
6492                payment_hash.into_into_dart().into_dart(),
6493                destination_pubkey.into_into_dart().into_dart(),
6494                lnurl_info.into_into_dart().into_dart(),
6495                bip353_address.into_into_dart().into_dart(),
6496                claim_tx_id.into_into_dart().into_dart(),
6497                refund_tx_id.into_into_dart().into_dart(),
6498                refund_tx_amount_sat.into_into_dart().into_dart(),
6499            ]
6500            .into_dart(),
6501            crate::model::PaymentDetails::Liquid {
6502                destination,
6503                description,
6504                asset_id,
6505                asset_info,
6506                lnurl_info,
6507                bip353_address,
6508            } => [
6509                1.into_dart(),
6510                destination.into_into_dart().into_dart(),
6511                description.into_into_dart().into_dart(),
6512                asset_id.into_into_dart().into_dart(),
6513                asset_info.into_into_dart().into_dart(),
6514                lnurl_info.into_into_dart().into_dart(),
6515                bip353_address.into_into_dart().into_dart(),
6516            ]
6517            .into_dart(),
6518            crate::model::PaymentDetails::Bitcoin {
6519                swap_id,
6520                bitcoin_address,
6521                description,
6522                auto_accepted_fees,
6523                liquid_expiration_blockheight,
6524                bitcoin_expiration_blockheight,
6525                lockup_tx_id,
6526                claim_tx_id,
6527                refund_tx_id,
6528                refund_tx_amount_sat,
6529            } => [
6530                2.into_dart(),
6531                swap_id.into_into_dart().into_dart(),
6532                bitcoin_address.into_into_dart().into_dart(),
6533                description.into_into_dart().into_dart(),
6534                auto_accepted_fees.into_into_dart().into_dart(),
6535                liquid_expiration_blockheight.into_into_dart().into_dart(),
6536                bitcoin_expiration_blockheight.into_into_dart().into_dart(),
6537                lockup_tx_id.into_into_dart().into_dart(),
6538                claim_tx_id.into_into_dart().into_dart(),
6539                refund_tx_id.into_into_dart().into_dart(),
6540                refund_tx_amount_sat.into_into_dart().into_dart(),
6541            ]
6542            .into_dart(),
6543            _ => {
6544                unimplemented!("");
6545            }
6546        }
6547    }
6548}
6549impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::PaymentDetails {}
6550impl flutter_rust_bridge::IntoIntoDart<crate::model::PaymentDetails>
6551    for crate::model::PaymentDetails
6552{
6553    fn into_into_dart(self) -> crate::model::PaymentDetails {
6554        self
6555    }
6556}
6557// Codec=Dco (DartCObject based), see doc to use other codecs
6558impl flutter_rust_bridge::IntoDart for crate::error::PaymentError {
6559    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6560        match self {
6561            crate::error::PaymentError::AlreadyClaimed => [0.into_dart()].into_dart(),
6562            crate::error::PaymentError::AlreadyPaid => [1.into_dart()].into_dart(),
6563            crate::error::PaymentError::PaymentInProgress => [2.into_dart()].into_dart(),
6564            crate::error::PaymentError::AmountOutOfRange { min, max } => [
6565                3.into_dart(),
6566                min.into_into_dart().into_dart(),
6567                max.into_into_dart().into_dart(),
6568            ]
6569            .into_dart(),
6570            crate::error::PaymentError::AmountMissing { err } => {
6571                [4.into_dart(), err.into_into_dart().into_dart()].into_dart()
6572            }
6573            crate::error::PaymentError::AssetError { err } => {
6574                [5.into_dart(), err.into_into_dart().into_dart()].into_dart()
6575            }
6576            crate::error::PaymentError::InvalidNetwork { err } => {
6577                [6.into_dart(), err.into_into_dart().into_dart()].into_dart()
6578            }
6579            crate::error::PaymentError::Generic { err } => {
6580                [7.into_dart(), err.into_into_dart().into_dart()].into_dart()
6581            }
6582            crate::error::PaymentError::InvalidOrExpiredFees => [8.into_dart()].into_dart(),
6583            crate::error::PaymentError::InsufficientFunds => [9.into_dart()].into_dart(),
6584            crate::error::PaymentError::InvalidDescription { err } => {
6585                [10.into_dart(), err.into_into_dart().into_dart()].into_dart()
6586            }
6587            crate::error::PaymentError::InvalidInvoice { err } => {
6588                [11.into_dart(), err.into_into_dart().into_dart()].into_dart()
6589            }
6590            crate::error::PaymentError::InvalidPreimage => [12.into_dart()].into_dart(),
6591            crate::error::PaymentError::PairsNotFound => [13.into_dart()].into_dart(),
6592            crate::error::PaymentError::PaymentTimeout => [14.into_dart()].into_dart(),
6593            crate::error::PaymentError::PersistError => [15.into_dart()].into_dart(),
6594            crate::error::PaymentError::ReceiveError { err } => {
6595                [16.into_dart(), err.into_into_dart().into_dart()].into_dart()
6596            }
6597            crate::error::PaymentError::Refunded { err, refund_tx_id } => [
6598                17.into_dart(),
6599                err.into_into_dart().into_dart(),
6600                refund_tx_id.into_into_dart().into_dart(),
6601            ]
6602            .into_dart(),
6603            crate::error::PaymentError::SelfTransferNotSupported => [18.into_dart()].into_dart(),
6604            crate::error::PaymentError::SendError { err } => {
6605                [19.into_dart(), err.into_into_dart().into_dart()].into_dart()
6606            }
6607            crate::error::PaymentError::SignerError { err } => {
6608                [20.into_dart(), err.into_into_dart().into_dart()].into_dart()
6609            }
6610            _ => {
6611                unimplemented!("");
6612            }
6613        }
6614    }
6615}
6616impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::error::PaymentError {}
6617impl flutter_rust_bridge::IntoIntoDart<crate::error::PaymentError> for crate::error::PaymentError {
6618    fn into_into_dart(self) -> crate::error::PaymentError {
6619        self
6620    }
6621}
6622// Codec=Dco (DartCObject based), see doc to use other codecs
6623impl flutter_rust_bridge::IntoDart for crate::model::PaymentMethod {
6624    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6625        match self {
6626            Self::Lightning => 0.into_dart(),
6627            Self::Bolt11Invoice => 1.into_dart(),
6628            Self::Bolt12Offer => 2.into_dart(),
6629            Self::BitcoinAddress => 3.into_dart(),
6630            Self::LiquidAddress => 4.into_dart(),
6631            _ => unreachable!(),
6632        }
6633    }
6634}
6635impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::PaymentMethod {}
6636impl flutter_rust_bridge::IntoIntoDart<crate::model::PaymentMethod>
6637    for crate::model::PaymentMethod
6638{
6639    fn into_into_dart(self) -> crate::model::PaymentMethod {
6640        self
6641    }
6642}
6643// Codec=Dco (DartCObject based), see doc to use other codecs
6644impl flutter_rust_bridge::IntoDart for crate::model::PaymentState {
6645    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6646        match self {
6647            Self::Created => 0.into_dart(),
6648            Self::Pending => 1.into_dart(),
6649            Self::Complete => 2.into_dart(),
6650            Self::Failed => 3.into_dart(),
6651            Self::TimedOut => 4.into_dart(),
6652            Self::Refundable => 5.into_dart(),
6653            Self::RefundPending => 6.into_dart(),
6654            Self::WaitingFeeAcceptance => 7.into_dart(),
6655            _ => unreachable!(),
6656        }
6657    }
6658}
6659impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::PaymentState {}
6660impl flutter_rust_bridge::IntoIntoDart<crate::model::PaymentState> for crate::model::PaymentState {
6661    fn into_into_dart(self) -> crate::model::PaymentState {
6662        self
6663    }
6664}
6665// Codec=Dco (DartCObject based), see doc to use other codecs
6666impl flutter_rust_bridge::IntoDart for crate::model::PaymentType {
6667    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6668        match self {
6669            Self::Receive => 0.into_dart(),
6670            Self::Send => 1.into_dart(),
6671            _ => unreachable!(),
6672        }
6673    }
6674}
6675impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::PaymentType {}
6676impl flutter_rust_bridge::IntoIntoDart<crate::model::PaymentType> for crate::model::PaymentType {
6677    fn into_into_dart(self) -> crate::model::PaymentType {
6678        self
6679    }
6680}
6681// Codec=Dco (DartCObject based), see doc to use other codecs
6682impl flutter_rust_bridge::IntoDart for crate::model::PrepareBuyBitcoinRequest {
6683    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6684        [
6685            self.provider.into_into_dart().into_dart(),
6686            self.amount_sat.into_into_dart().into_dart(),
6687        ]
6688        .into_dart()
6689    }
6690}
6691impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6692    for crate::model::PrepareBuyBitcoinRequest
6693{
6694}
6695impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareBuyBitcoinRequest>
6696    for crate::model::PrepareBuyBitcoinRequest
6697{
6698    fn into_into_dart(self) -> crate::model::PrepareBuyBitcoinRequest {
6699        self
6700    }
6701}
6702// Codec=Dco (DartCObject based), see doc to use other codecs
6703impl flutter_rust_bridge::IntoDart for crate::model::PrepareBuyBitcoinResponse {
6704    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6705        [
6706            self.provider.into_into_dart().into_dart(),
6707            self.amount_sat.into_into_dart().into_dart(),
6708            self.fees_sat.into_into_dart().into_dart(),
6709        ]
6710        .into_dart()
6711    }
6712}
6713impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6714    for crate::model::PrepareBuyBitcoinResponse
6715{
6716}
6717impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareBuyBitcoinResponse>
6718    for crate::model::PrepareBuyBitcoinResponse
6719{
6720    fn into_into_dart(self) -> crate::model::PrepareBuyBitcoinResponse {
6721        self
6722    }
6723}
6724// Codec=Dco (DartCObject based), see doc to use other codecs
6725impl flutter_rust_bridge::IntoDart for crate::model::PrepareLnUrlPayRequest {
6726    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6727        [
6728            self.data.into_into_dart().into_dart(),
6729            self.amount.into_into_dart().into_dart(),
6730            self.bip353_address.into_into_dart().into_dart(),
6731            self.comment.into_into_dart().into_dart(),
6732            self.validate_success_action_url
6733                .into_into_dart()
6734                .into_dart(),
6735        ]
6736        .into_dart()
6737    }
6738}
6739impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6740    for crate::model::PrepareLnUrlPayRequest
6741{
6742}
6743impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareLnUrlPayRequest>
6744    for crate::model::PrepareLnUrlPayRequest
6745{
6746    fn into_into_dart(self) -> crate::model::PrepareLnUrlPayRequest {
6747        self
6748    }
6749}
6750// Codec=Dco (DartCObject based), see doc to use other codecs
6751impl flutter_rust_bridge::IntoDart for crate::model::PrepareLnUrlPayResponse {
6752    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6753        [
6754            self.destination.into_into_dart().into_dart(),
6755            self.fees_sat.into_into_dart().into_dart(),
6756            self.data.into_into_dart().into_dart(),
6757            self.amount.into_into_dart().into_dart(),
6758            self.comment.into_into_dart().into_dart(),
6759            self.success_action.into_into_dart().into_dart(),
6760        ]
6761        .into_dart()
6762    }
6763}
6764impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6765    for crate::model::PrepareLnUrlPayResponse
6766{
6767}
6768impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareLnUrlPayResponse>
6769    for crate::model::PrepareLnUrlPayResponse
6770{
6771    fn into_into_dart(self) -> crate::model::PrepareLnUrlPayResponse {
6772        self
6773    }
6774}
6775// Codec=Dco (DartCObject based), see doc to use other codecs
6776impl flutter_rust_bridge::IntoDart for crate::model::PreparePayOnchainRequest {
6777    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6778        [
6779            self.amount.into_into_dart().into_dart(),
6780            self.fee_rate_sat_per_vbyte.into_into_dart().into_dart(),
6781        ]
6782        .into_dart()
6783    }
6784}
6785impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6786    for crate::model::PreparePayOnchainRequest
6787{
6788}
6789impl flutter_rust_bridge::IntoIntoDart<crate::model::PreparePayOnchainRequest>
6790    for crate::model::PreparePayOnchainRequest
6791{
6792    fn into_into_dart(self) -> crate::model::PreparePayOnchainRequest {
6793        self
6794    }
6795}
6796// Codec=Dco (DartCObject based), see doc to use other codecs
6797impl flutter_rust_bridge::IntoDart for crate::model::PreparePayOnchainResponse {
6798    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6799        [
6800            self.receiver_amount_sat.into_into_dart().into_dart(),
6801            self.claim_fees_sat.into_into_dart().into_dart(),
6802            self.total_fees_sat.into_into_dart().into_dart(),
6803        ]
6804        .into_dart()
6805    }
6806}
6807impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6808    for crate::model::PreparePayOnchainResponse
6809{
6810}
6811impl flutter_rust_bridge::IntoIntoDart<crate::model::PreparePayOnchainResponse>
6812    for crate::model::PreparePayOnchainResponse
6813{
6814    fn into_into_dart(self) -> crate::model::PreparePayOnchainResponse {
6815        self
6816    }
6817}
6818// Codec=Dco (DartCObject based), see doc to use other codecs
6819impl flutter_rust_bridge::IntoDart for crate::model::PrepareReceiveRequest {
6820    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6821        [
6822            self.payment_method.into_into_dart().into_dart(),
6823            self.amount.into_into_dart().into_dart(),
6824        ]
6825        .into_dart()
6826    }
6827}
6828impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6829    for crate::model::PrepareReceiveRequest
6830{
6831}
6832impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareReceiveRequest>
6833    for crate::model::PrepareReceiveRequest
6834{
6835    fn into_into_dart(self) -> crate::model::PrepareReceiveRequest {
6836        self
6837    }
6838}
6839// Codec=Dco (DartCObject based), see doc to use other codecs
6840impl flutter_rust_bridge::IntoDart for crate::model::PrepareReceiveResponse {
6841    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6842        [
6843            self.payment_method.into_into_dart().into_dart(),
6844            self.fees_sat.into_into_dart().into_dart(),
6845            self.amount.into_into_dart().into_dart(),
6846            self.min_payer_amount_sat.into_into_dart().into_dart(),
6847            self.max_payer_amount_sat.into_into_dart().into_dart(),
6848            self.swapper_feerate.into_into_dart().into_dart(),
6849        ]
6850        .into_dart()
6851    }
6852}
6853impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6854    for crate::model::PrepareReceiveResponse
6855{
6856}
6857impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareReceiveResponse>
6858    for crate::model::PrepareReceiveResponse
6859{
6860    fn into_into_dart(self) -> crate::model::PrepareReceiveResponse {
6861        self
6862    }
6863}
6864// Codec=Dco (DartCObject based), see doc to use other codecs
6865impl flutter_rust_bridge::IntoDart for crate::model::PrepareRefundRequest {
6866    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6867        [
6868            self.swap_address.into_into_dart().into_dart(),
6869            self.refund_address.into_into_dart().into_dart(),
6870            self.fee_rate_sat_per_vbyte.into_into_dart().into_dart(),
6871        ]
6872        .into_dart()
6873    }
6874}
6875impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6876    for crate::model::PrepareRefundRequest
6877{
6878}
6879impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareRefundRequest>
6880    for crate::model::PrepareRefundRequest
6881{
6882    fn into_into_dart(self) -> crate::model::PrepareRefundRequest {
6883        self
6884    }
6885}
6886// Codec=Dco (DartCObject based), see doc to use other codecs
6887impl flutter_rust_bridge::IntoDart for crate::model::PrepareRefundResponse {
6888    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6889        [
6890            self.tx_vsize.into_into_dart().into_dart(),
6891            self.tx_fee_sat.into_into_dart().into_dart(),
6892            self.last_refund_tx_id.into_into_dart().into_dart(),
6893        ]
6894        .into_dart()
6895    }
6896}
6897impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6898    for crate::model::PrepareRefundResponse
6899{
6900}
6901impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareRefundResponse>
6902    for crate::model::PrepareRefundResponse
6903{
6904    fn into_into_dart(self) -> crate::model::PrepareRefundResponse {
6905        self
6906    }
6907}
6908// Codec=Dco (DartCObject based), see doc to use other codecs
6909impl flutter_rust_bridge::IntoDart for crate::model::PrepareSendRequest {
6910    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6911        [
6912            self.destination.into_into_dart().into_dart(),
6913            self.amount.into_into_dart().into_dart(),
6914            self.comment.into_into_dart().into_dart(),
6915        ]
6916        .into_dart()
6917    }
6918}
6919impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6920    for crate::model::PrepareSendRequest
6921{
6922}
6923impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareSendRequest>
6924    for crate::model::PrepareSendRequest
6925{
6926    fn into_into_dart(self) -> crate::model::PrepareSendRequest {
6927        self
6928    }
6929}
6930// Codec=Dco (DartCObject based), see doc to use other codecs
6931impl flutter_rust_bridge::IntoDart for crate::model::PrepareSendResponse {
6932    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6933        [
6934            self.destination.into_into_dart().into_dart(),
6935            self.amount.into_into_dart().into_dart(),
6936            self.fees_sat.into_into_dart().into_dart(),
6937            self.estimated_asset_fees.into_into_dart().into_dart(),
6938        ]
6939        .into_dart()
6940    }
6941}
6942impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6943    for crate::model::PrepareSendResponse
6944{
6945}
6946impl flutter_rust_bridge::IntoIntoDart<crate::model::PrepareSendResponse>
6947    for crate::model::PrepareSendResponse
6948{
6949    fn into_into_dart(self) -> crate::model::PrepareSendResponse {
6950        self
6951    }
6952}
6953// Codec=Dco (DartCObject based), see doc to use other codecs
6954impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::Rate> {
6955    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6956        [
6957            self.0.coin.into_into_dart().into_dart(),
6958            self.0.value.into_into_dart().into_dart(),
6959        ]
6960        .into_dart()
6961    }
6962}
6963impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
6964    for FrbWrapper<crate::bindings::Rate>
6965{
6966}
6967impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::Rate>>
6968    for crate::bindings::Rate
6969{
6970    fn into_into_dart(self) -> FrbWrapper<crate::bindings::Rate> {
6971        self.into()
6972    }
6973}
6974// Codec=Dco (DartCObject based), see doc to use other codecs
6975impl flutter_rust_bridge::IntoDart for crate::model::ReceiveAmount {
6976    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
6977        match self {
6978            crate::model::ReceiveAmount::Bitcoin { payer_amount_sat } => {
6979                [0.into_dart(), payer_amount_sat.into_into_dart().into_dart()].into_dart()
6980            }
6981            crate::model::ReceiveAmount::Asset {
6982                asset_id,
6983                payer_amount,
6984            } => [
6985                1.into_dart(),
6986                asset_id.into_into_dart().into_dart(),
6987                payer_amount.into_into_dart().into_dart(),
6988            ]
6989            .into_dart(),
6990            _ => {
6991                unimplemented!("");
6992            }
6993        }
6994    }
6995}
6996impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::ReceiveAmount {}
6997impl flutter_rust_bridge::IntoIntoDart<crate::model::ReceiveAmount>
6998    for crate::model::ReceiveAmount
6999{
7000    fn into_into_dart(self) -> crate::model::ReceiveAmount {
7001        self
7002    }
7003}
7004// Codec=Dco (DartCObject based), see doc to use other codecs
7005impl flutter_rust_bridge::IntoDart for crate::model::ReceivePaymentRequest {
7006    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7007        [
7008            self.prepare_response.into_into_dart().into_dart(),
7009            self.description.into_into_dart().into_dart(),
7010            self.use_description_hash.into_into_dart().into_dart(),
7011        ]
7012        .into_dart()
7013    }
7014}
7015impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7016    for crate::model::ReceivePaymentRequest
7017{
7018}
7019impl flutter_rust_bridge::IntoIntoDart<crate::model::ReceivePaymentRequest>
7020    for crate::model::ReceivePaymentRequest
7021{
7022    fn into_into_dart(self) -> crate::model::ReceivePaymentRequest {
7023        self
7024    }
7025}
7026// Codec=Dco (DartCObject based), see doc to use other codecs
7027impl flutter_rust_bridge::IntoDart for crate::model::ReceivePaymentResponse {
7028    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7029        [self.destination.into_into_dart().into_dart()].into_dart()
7030    }
7031}
7032impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7033    for crate::model::ReceivePaymentResponse
7034{
7035}
7036impl flutter_rust_bridge::IntoIntoDart<crate::model::ReceivePaymentResponse>
7037    for crate::model::ReceivePaymentResponse
7038{
7039    fn into_into_dart(self) -> crate::model::ReceivePaymentResponse {
7040        self
7041    }
7042}
7043// Codec=Dco (DartCObject based), see doc to use other codecs
7044impl flutter_rust_bridge::IntoDart for crate::model::RecommendedFees {
7045    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7046        [
7047            self.fastest_fee.into_into_dart().into_dart(),
7048            self.half_hour_fee.into_into_dart().into_dart(),
7049            self.hour_fee.into_into_dart().into_dart(),
7050            self.economy_fee.into_into_dart().into_dart(),
7051            self.minimum_fee.into_into_dart().into_dart(),
7052        ]
7053        .into_dart()
7054    }
7055}
7056impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::RecommendedFees {}
7057impl flutter_rust_bridge::IntoIntoDart<crate::model::RecommendedFees>
7058    for crate::model::RecommendedFees
7059{
7060    fn into_into_dart(self) -> crate::model::RecommendedFees {
7061        self
7062    }
7063}
7064// Codec=Dco (DartCObject based), see doc to use other codecs
7065impl flutter_rust_bridge::IntoDart for crate::model::RefundRequest {
7066    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7067        [
7068            self.swap_address.into_into_dart().into_dart(),
7069            self.refund_address.into_into_dart().into_dart(),
7070            self.fee_rate_sat_per_vbyte.into_into_dart().into_dart(),
7071        ]
7072        .into_dart()
7073    }
7074}
7075impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::RefundRequest {}
7076impl flutter_rust_bridge::IntoIntoDart<crate::model::RefundRequest>
7077    for crate::model::RefundRequest
7078{
7079    fn into_into_dart(self) -> crate::model::RefundRequest {
7080        self
7081    }
7082}
7083// Codec=Dco (DartCObject based), see doc to use other codecs
7084impl flutter_rust_bridge::IntoDart for crate::model::RefundResponse {
7085    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7086        [self.refund_tx_id.into_into_dart().into_dart()].into_dart()
7087    }
7088}
7089impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::RefundResponse {}
7090impl flutter_rust_bridge::IntoIntoDart<crate::model::RefundResponse>
7091    for crate::model::RefundResponse
7092{
7093    fn into_into_dart(self) -> crate::model::RefundResponse {
7094        self
7095    }
7096}
7097// Codec=Dco (DartCObject based), see doc to use other codecs
7098impl flutter_rust_bridge::IntoDart for crate::model::RefundableSwap {
7099    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7100        [
7101            self.swap_address.into_into_dart().into_dart(),
7102            self.timestamp.into_into_dart().into_dart(),
7103            self.amount_sat.into_into_dart().into_dart(),
7104            self.last_refund_tx_id.into_into_dart().into_dart(),
7105        ]
7106        .into_dart()
7107    }
7108}
7109impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::RefundableSwap {}
7110impl flutter_rust_bridge::IntoIntoDart<crate::model::RefundableSwap>
7111    for crate::model::RefundableSwap
7112{
7113    fn into_into_dart(self) -> crate::model::RefundableSwap {
7114        self
7115    }
7116}
7117// Codec=Dco (DartCObject based), see doc to use other codecs
7118impl flutter_rust_bridge::IntoDart for crate::model::RestoreRequest {
7119    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7120        [self.backup_path.into_into_dart().into_dart()].into_dart()
7121    }
7122}
7123impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::RestoreRequest {}
7124impl flutter_rust_bridge::IntoIntoDart<crate::model::RestoreRequest>
7125    for crate::model::RestoreRequest
7126{
7127    fn into_into_dart(self) -> crate::model::RestoreRequest {
7128        self
7129    }
7130}
7131// Codec=Dco (DartCObject based), see doc to use other codecs
7132impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::RouteHint> {
7133    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7134        [self.0.hops.into_into_dart().into_dart()].into_dart()
7135    }
7136}
7137impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7138    for FrbWrapper<crate::bindings::RouteHint>
7139{
7140}
7141impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::RouteHint>>
7142    for crate::bindings::RouteHint
7143{
7144    fn into_into_dart(self) -> FrbWrapper<crate::bindings::RouteHint> {
7145        self.into()
7146    }
7147}
7148// Codec=Dco (DartCObject based), see doc to use other codecs
7149impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::RouteHintHop> {
7150    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7151        [
7152            self.0.src_node_id.into_into_dart().into_dart(),
7153            self.0.short_channel_id.into_into_dart().into_dart(),
7154            self.0.fees_base_msat.into_into_dart().into_dart(),
7155            self.0
7156                .fees_proportional_millionths
7157                .into_into_dart()
7158                .into_dart(),
7159            self.0.cltv_expiry_delta.into_into_dart().into_dart(),
7160            self.0.htlc_minimum_msat.into_into_dart().into_dart(),
7161            self.0.htlc_maximum_msat.into_into_dart().into_dart(),
7162        ]
7163        .into_dart()
7164    }
7165}
7166impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7167    for FrbWrapper<crate::bindings::RouteHintHop>
7168{
7169}
7170impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::RouteHintHop>>
7171    for crate::bindings::RouteHintHop
7172{
7173    fn into_into_dart(self) -> FrbWrapper<crate::bindings::RouteHintHop> {
7174        self.into()
7175    }
7176}
7177// Codec=Dco (DartCObject based), see doc to use other codecs
7178impl flutter_rust_bridge::IntoDart for crate::error::SdkError {
7179    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7180        match self {
7181            crate::error::SdkError::AlreadyStarted => [0.into_dart()].into_dart(),
7182            crate::error::SdkError::Generic { err } => {
7183                [1.into_dart(), err.into_into_dart().into_dart()].into_dart()
7184            }
7185            crate::error::SdkError::NotStarted => [2.into_dart()].into_dart(),
7186            crate::error::SdkError::ServiceConnectivity { err } => {
7187                [3.into_dart(), err.into_into_dart().into_dart()].into_dart()
7188            }
7189            _ => {
7190                unimplemented!("");
7191            }
7192        }
7193    }
7194}
7195impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::error::SdkError {}
7196impl flutter_rust_bridge::IntoIntoDart<crate::error::SdkError> for crate::error::SdkError {
7197    fn into_into_dart(self) -> crate::error::SdkError {
7198        self
7199    }
7200}
7201// Codec=Dco (DartCObject based), see doc to use other codecs
7202impl flutter_rust_bridge::IntoDart for crate::model::SdkEvent {
7203    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7204        match self {
7205            crate::model::SdkEvent::PaymentFailed { details } => {
7206                [0.into_dart(), details.into_into_dart().into_dart()].into_dart()
7207            }
7208            crate::model::SdkEvent::PaymentPending { details } => {
7209                [1.into_dart(), details.into_into_dart().into_dart()].into_dart()
7210            }
7211            crate::model::SdkEvent::PaymentRefundable { details } => {
7212                [2.into_dart(), details.into_into_dart().into_dart()].into_dart()
7213            }
7214            crate::model::SdkEvent::PaymentRefunded { details } => {
7215                [3.into_dart(), details.into_into_dart().into_dart()].into_dart()
7216            }
7217            crate::model::SdkEvent::PaymentRefundPending { details } => {
7218                [4.into_dart(), details.into_into_dart().into_dart()].into_dart()
7219            }
7220            crate::model::SdkEvent::PaymentSucceeded { details } => {
7221                [5.into_dart(), details.into_into_dart().into_dart()].into_dart()
7222            }
7223            crate::model::SdkEvent::PaymentWaitingConfirmation { details } => {
7224                [6.into_dart(), details.into_into_dart().into_dart()].into_dart()
7225            }
7226            crate::model::SdkEvent::PaymentWaitingFeeAcceptance { details } => {
7227                [7.into_dart(), details.into_into_dart().into_dart()].into_dart()
7228            }
7229            crate::model::SdkEvent::Synced => [8.into_dart()].into_dart(),
7230            crate::model::SdkEvent::DataSynced {
7231                did_pull_new_records,
7232            } => [
7233                9.into_dart(),
7234                did_pull_new_records.into_into_dart().into_dart(),
7235            ]
7236            .into_dart(),
7237            _ => {
7238                unimplemented!("");
7239            }
7240        }
7241    }
7242}
7243impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::SdkEvent {}
7244impl flutter_rust_bridge::IntoIntoDart<crate::model::SdkEvent> for crate::model::SdkEvent {
7245    fn into_into_dart(self) -> crate::model::SdkEvent {
7246        self
7247    }
7248}
7249// Codec=Dco (DartCObject based), see doc to use other codecs
7250impl flutter_rust_bridge::IntoDart for crate::model::SendDestination {
7251    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7252        match self {
7253            crate::model::SendDestination::LiquidAddress {
7254                address_data,
7255                bip353_address,
7256            } => [
7257                0.into_dart(),
7258                address_data.into_into_dart().into_dart(),
7259                bip353_address.into_into_dart().into_dart(),
7260            ]
7261            .into_dart(),
7262            crate::model::SendDestination::Bolt11 {
7263                invoice,
7264                bip353_address,
7265            } => [
7266                1.into_dart(),
7267                invoice.into_into_dart().into_dart(),
7268                bip353_address.into_into_dart().into_dart(),
7269            ]
7270            .into_dart(),
7271            crate::model::SendDestination::Bolt12 {
7272                offer,
7273                receiver_amount_sat,
7274                bip353_address,
7275                payer_note,
7276            } => [
7277                2.into_dart(),
7278                offer.into_into_dart().into_dart(),
7279                receiver_amount_sat.into_into_dart().into_dart(),
7280                bip353_address.into_into_dart().into_dart(),
7281                payer_note.into_into_dart().into_dart(),
7282            ]
7283            .into_dart(),
7284            _ => {
7285                unimplemented!("");
7286            }
7287        }
7288    }
7289}
7290impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::SendDestination {}
7291impl flutter_rust_bridge::IntoIntoDart<crate::model::SendDestination>
7292    for crate::model::SendDestination
7293{
7294    fn into_into_dart(self) -> crate::model::SendDestination {
7295        self
7296    }
7297}
7298// Codec=Dco (DartCObject based), see doc to use other codecs
7299impl flutter_rust_bridge::IntoDart for crate::model::SendPaymentRequest {
7300    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7301        [
7302            self.prepare_response.into_into_dart().into_dart(),
7303            self.use_asset_fees.into_into_dart().into_dart(),
7304        ]
7305        .into_dart()
7306    }
7307}
7308impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7309    for crate::model::SendPaymentRequest
7310{
7311}
7312impl flutter_rust_bridge::IntoIntoDart<crate::model::SendPaymentRequest>
7313    for crate::model::SendPaymentRequest
7314{
7315    fn into_into_dart(self) -> crate::model::SendPaymentRequest {
7316        self
7317    }
7318}
7319// Codec=Dco (DartCObject based), see doc to use other codecs
7320impl flutter_rust_bridge::IntoDart for crate::model::SendPaymentResponse {
7321    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7322        [self.payment.into_into_dart().into_dart()].into_dart()
7323    }
7324}
7325impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7326    for crate::model::SendPaymentResponse
7327{
7328}
7329impl flutter_rust_bridge::IntoIntoDart<crate::model::SendPaymentResponse>
7330    for crate::model::SendPaymentResponse
7331{
7332    fn into_into_dart(self) -> crate::model::SendPaymentResponse {
7333        self
7334    }
7335}
7336// Codec=Dco (DartCObject based), see doc to use other codecs
7337impl flutter_rust_bridge::IntoDart for crate::model::SignMessageRequest {
7338    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7339        [self.message.into_into_dart().into_dart()].into_dart()
7340    }
7341}
7342impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7343    for crate::model::SignMessageRequest
7344{
7345}
7346impl flutter_rust_bridge::IntoIntoDart<crate::model::SignMessageRequest>
7347    for crate::model::SignMessageRequest
7348{
7349    fn into_into_dart(self) -> crate::model::SignMessageRequest {
7350        self
7351    }
7352}
7353// Codec=Dco (DartCObject based), see doc to use other codecs
7354impl flutter_rust_bridge::IntoDart for crate::model::SignMessageResponse {
7355    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7356        [self.signature.into_into_dart().into_dart()].into_dart()
7357    }
7358}
7359impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7360    for crate::model::SignMessageResponse
7361{
7362}
7363impl flutter_rust_bridge::IntoIntoDart<crate::model::SignMessageResponse>
7364    for crate::model::SignMessageResponse
7365{
7366    fn into_into_dart(self) -> crate::model::SignMessageResponse {
7367        self
7368    }
7369}
7370// Codec=Dco (DartCObject based), see doc to use other codecs
7371impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::SuccessAction> {
7372    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7373        match self.0 {
7374            crate::bindings::SuccessAction::Aes { data } => {
7375                [0.into_dart(), data.into_into_dart().into_dart()].into_dart()
7376            }
7377            crate::bindings::SuccessAction::Message { data } => {
7378                [1.into_dart(), data.into_into_dart().into_dart()].into_dart()
7379            }
7380            crate::bindings::SuccessAction::Url { data } => {
7381                [2.into_dart(), data.into_into_dart().into_dart()].into_dart()
7382            }
7383            _ => {
7384                unimplemented!("");
7385            }
7386        }
7387    }
7388}
7389impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7390    for FrbWrapper<crate::bindings::SuccessAction>
7391{
7392}
7393impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::SuccessAction>>
7394    for crate::bindings::SuccessAction
7395{
7396    fn into_into_dart(self) -> FrbWrapper<crate::bindings::SuccessAction> {
7397        self.into()
7398    }
7399}
7400// Codec=Dco (DartCObject based), see doc to use other codecs
7401impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::SuccessActionProcessed> {
7402    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7403        match self.0 {
7404            crate::bindings::SuccessActionProcessed::Aes { result } => {
7405                [0.into_dart(), result.into_into_dart().into_dart()].into_dart()
7406            }
7407            crate::bindings::SuccessActionProcessed::Message { data } => {
7408                [1.into_dart(), data.into_into_dart().into_dart()].into_dart()
7409            }
7410            crate::bindings::SuccessActionProcessed::Url { data } => {
7411                [2.into_dart(), data.into_into_dart().into_dart()].into_dart()
7412            }
7413            _ => {
7414                unimplemented!("");
7415            }
7416        }
7417    }
7418}
7419impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7420    for FrbWrapper<crate::bindings::SuccessActionProcessed>
7421{
7422}
7423impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::SuccessActionProcessed>>
7424    for crate::bindings::SuccessActionProcessed
7425{
7426    fn into_into_dart(self) -> FrbWrapper<crate::bindings::SuccessActionProcessed> {
7427        self.into()
7428    }
7429}
7430// Codec=Dco (DartCObject based), see doc to use other codecs
7431impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::Symbol> {
7432    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7433        [
7434            self.0.grapheme.into_into_dart().into_dart(),
7435            self.0.template.into_into_dart().into_dart(),
7436            self.0.rtl.into_into_dart().into_dart(),
7437            self.0.position.into_into_dart().into_dart(),
7438        ]
7439        .into_dart()
7440    }
7441}
7442impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7443    for FrbWrapper<crate::bindings::Symbol>
7444{
7445}
7446impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::Symbol>>
7447    for crate::bindings::Symbol
7448{
7449    fn into_into_dart(self) -> FrbWrapper<crate::bindings::Symbol> {
7450        self.into()
7451    }
7452}
7453// Codec=Dco (DartCObject based), see doc to use other codecs
7454impl flutter_rust_bridge::IntoDart for FrbWrapper<crate::bindings::UrlSuccessActionData> {
7455    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7456        [
7457            self.0.description.into_into_dart().into_dart(),
7458            self.0.url.into_into_dart().into_dart(),
7459            self.0.matches_callback_domain.into_into_dart().into_dart(),
7460        ]
7461        .into_dart()
7462    }
7463}
7464impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
7465    for FrbWrapper<crate::bindings::UrlSuccessActionData>
7466{
7467}
7468impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<crate::bindings::UrlSuccessActionData>>
7469    for crate::bindings::UrlSuccessActionData
7470{
7471    fn into_into_dart(self) -> FrbWrapper<crate::bindings::UrlSuccessActionData> {
7472        self.into()
7473    }
7474}
7475// Codec=Dco (DartCObject based), see doc to use other codecs
7476impl flutter_rust_bridge::IntoDart for crate::model::WalletInfo {
7477    fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
7478        [
7479            self.balance_sat.into_into_dart().into_dart(),
7480            self.pending_send_sat.into_into_dart().into_dart(),
7481            self.pending_receive_sat.into_into_dart().into_dart(),
7482            self.fingerprint.into_into_dart().into_dart(),
7483            self.pubkey.into_into_dart().into_dart(),
7484            self.asset_balances.into_into_dart().into_dart(),
7485        ]
7486        .into_dart()
7487    }
7488}
7489impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::model::WalletInfo {}
7490impl flutter_rust_bridge::IntoIntoDart<crate::model::WalletInfo> for crate::model::WalletInfo {
7491    fn into_into_dart(self) -> crate::model::WalletInfo {
7492        self
7493    }
7494}
7495
7496impl SseEncode for flutter_rust_bridge::for_generated::anyhow::Error {
7497    // Codec=Sse (Serialization based), see doc to use other codecs
7498    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7499        <String>::sse_encode(format!("{:?}", self), serializer);
7500    }
7501}
7502
7503impl SseEncode for BindingLiquidSdk {
7504    // Codec=Sse (Serialization based), see doc to use other codecs
7505    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7506        <RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>>::sse_encode(flutter_rust_bridge::for_generated::rust_auto_opaque_encode::<_, StdArc<_>>(self), serializer);
7507    }
7508}
7509
7510impl SseEncode
7511    for RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>
7512{
7513    // Codec=Sse (Serialization based), see doc to use other codecs
7514    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7515        let (ptr, size) = self.sse_encode_raw();
7516        <usize>::sse_encode(ptr, serializer);
7517        <i32>::sse_encode(size, serializer);
7518    }
7519}
7520
7521impl SseEncode
7522    for StreamSink<crate::model::LogEntry, flutter_rust_bridge::for_generated::DcoCodec>
7523{
7524    // Codec=Sse (Serialization based), see doc to use other codecs
7525    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7526        unimplemented!("")
7527    }
7528}
7529
7530impl SseEncode
7531    for StreamSink<crate::model::SdkEvent, flutter_rust_bridge::for_generated::DcoCodec>
7532{
7533    // Codec=Sse (Serialization based), see doc to use other codecs
7534    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7535        unimplemented!("")
7536    }
7537}
7538
7539impl SseEncode for String {
7540    // Codec=Sse (Serialization based), see doc to use other codecs
7541    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7542        <Vec<u8>>::sse_encode(self.into_bytes(), serializer);
7543    }
7544}
7545
7546impl SseEncode for crate::model::AcceptPaymentProposedFeesRequest {
7547    // Codec=Sse (Serialization based), see doc to use other codecs
7548    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7549        <crate::model::FetchPaymentProposedFeesResponse>::sse_encode(self.response, serializer);
7550    }
7551}
7552
7553impl SseEncode for crate::bindings::AesSuccessActionData {
7554    // Codec=Sse (Serialization based), see doc to use other codecs
7555    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7556        <String>::sse_encode(self.description, serializer);
7557        <String>::sse_encode(self.ciphertext, serializer);
7558        <String>::sse_encode(self.iv, serializer);
7559    }
7560}
7561
7562impl SseEncode for crate::bindings::AesSuccessActionDataDecrypted {
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        <String>::sse_encode(self.description, serializer);
7566        <String>::sse_encode(self.plaintext, serializer);
7567    }
7568}
7569
7570impl SseEncode for crate::bindings::AesSuccessActionDataResult {
7571    // Codec=Sse (Serialization based), see doc to use other codecs
7572    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7573        match self {
7574            crate::bindings::AesSuccessActionDataResult::Decrypted { data } => {
7575                <i32>::sse_encode(0, serializer);
7576                <crate::bindings::AesSuccessActionDataDecrypted>::sse_encode(data, serializer);
7577            }
7578            crate::bindings::AesSuccessActionDataResult::ErrorStatus { reason } => {
7579                <i32>::sse_encode(1, serializer);
7580                <String>::sse_encode(reason, serializer);
7581            }
7582            _ => {
7583                unimplemented!("");
7584            }
7585        }
7586    }
7587}
7588
7589impl SseEncode for crate::bindings::Amount {
7590    // Codec=Sse (Serialization based), see doc to use other codecs
7591    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7592        match self {
7593            crate::bindings::Amount::Bitcoin { amount_msat } => {
7594                <i32>::sse_encode(0, serializer);
7595                <u64>::sse_encode(amount_msat, serializer);
7596            }
7597            crate::bindings::Amount::Currency {
7598                iso4217_code,
7599                fractional_amount,
7600            } => {
7601                <i32>::sse_encode(1, serializer);
7602                <String>::sse_encode(iso4217_code, serializer);
7603                <u64>::sse_encode(fractional_amount, serializer);
7604            }
7605            _ => {
7606                unimplemented!("");
7607            }
7608        }
7609    }
7610}
7611
7612impl SseEncode for crate::model::AssetBalance {
7613    // Codec=Sse (Serialization based), see doc to use other codecs
7614    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7615        <String>::sse_encode(self.asset_id, serializer);
7616        <u64>::sse_encode(self.balance_sat, serializer);
7617        <Option<String>>::sse_encode(self.name, serializer);
7618        <Option<String>>::sse_encode(self.ticker, serializer);
7619        <Option<f64>>::sse_encode(self.balance, serializer);
7620    }
7621}
7622
7623impl SseEncode for crate::model::AssetInfo {
7624    // Codec=Sse (Serialization based), see doc to use other codecs
7625    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7626        <String>::sse_encode(self.name, serializer);
7627        <String>::sse_encode(self.ticker, serializer);
7628        <f64>::sse_encode(self.amount, serializer);
7629        <Option<f64>>::sse_encode(self.fees, serializer);
7630    }
7631}
7632
7633impl SseEncode for crate::model::AssetMetadata {
7634    // Codec=Sse (Serialization based), see doc to use other codecs
7635    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7636        <String>::sse_encode(self.asset_id, serializer);
7637        <String>::sse_encode(self.name, serializer);
7638        <String>::sse_encode(self.ticker, serializer);
7639        <u8>::sse_encode(self.precision, serializer);
7640        <Option<String>>::sse_encode(self.fiat_id, serializer);
7641    }
7642}
7643
7644impl SseEncode for crate::model::BackupRequest {
7645    // Codec=Sse (Serialization based), see doc to use other codecs
7646    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7647        <Option<String>>::sse_encode(self.backup_path, serializer);
7648    }
7649}
7650
7651impl SseEncode for crate::bindings::BindingEventListener {
7652    // Codec=Sse (Serialization based), see doc to use other codecs
7653    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7654        <StreamSink<crate::model::SdkEvent,flutter_rust_bridge::for_generated::DcoCodec>>::sse_encode(self.stream, serializer);
7655    }
7656}
7657
7658impl SseEncode for crate::bindings::BitcoinAddressData {
7659    // Codec=Sse (Serialization based), see doc to use other codecs
7660    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7661        <String>::sse_encode(self.address, serializer);
7662        <crate::bindings::Network>::sse_encode(self.network, serializer);
7663        <Option<u64>>::sse_encode(self.amount_sat, serializer);
7664        <Option<String>>::sse_encode(self.label, serializer);
7665        <Option<String>>::sse_encode(self.message, serializer);
7666    }
7667}
7668
7669impl SseEncode for crate::model::BlockchainExplorer {
7670    // Codec=Sse (Serialization based), see doc to use other codecs
7671    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7672        match self {
7673            crate::model::BlockchainExplorer::Electrum { url } => {
7674                <i32>::sse_encode(0, serializer);
7675                <String>::sse_encode(url, serializer);
7676            }
7677            crate::model::BlockchainExplorer::Esplora {
7678                url,
7679                use_waterfalls,
7680            } => {
7681                <i32>::sse_encode(1, serializer);
7682                <String>::sse_encode(url, serializer);
7683                <bool>::sse_encode(use_waterfalls, serializer);
7684            }
7685            _ => {
7686                unimplemented!("");
7687            }
7688        }
7689    }
7690}
7691
7692impl SseEncode for crate::model::BlockchainInfo {
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        <u32>::sse_encode(self.liquid_tip, serializer);
7696        <u32>::sse_encode(self.bitcoin_tip, serializer);
7697    }
7698}
7699
7700impl SseEncode for bool {
7701    // Codec=Sse (Serialization based), see doc to use other codecs
7702    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7703        serializer.cursor.write_u8(self as _).unwrap();
7704    }
7705}
7706
7707impl SseEncode for crate::model::BuyBitcoinProvider {
7708    // Codec=Sse (Serialization based), see doc to use other codecs
7709    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7710        <i32>::sse_encode(
7711            match self {
7712                crate::model::BuyBitcoinProvider::Moonpay => 0,
7713                _ => {
7714                    unimplemented!("");
7715                }
7716            },
7717            serializer,
7718        );
7719    }
7720}
7721
7722impl SseEncode for crate::model::BuyBitcoinRequest {
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        <crate::model::PrepareBuyBitcoinResponse>::sse_encode(self.prepare_response, serializer);
7726        <Option<String>>::sse_encode(self.redirect_url, serializer);
7727    }
7728}
7729
7730impl SseEncode for crate::model::CheckMessageRequest {
7731    // Codec=Sse (Serialization based), see doc to use other codecs
7732    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7733        <String>::sse_encode(self.message, serializer);
7734        <String>::sse_encode(self.pubkey, serializer);
7735        <String>::sse_encode(self.signature, serializer);
7736    }
7737}
7738
7739impl SseEncode for crate::model::CheckMessageResponse {
7740    // Codec=Sse (Serialization based), see doc to use other codecs
7741    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7742        <bool>::sse_encode(self.is_valid, serializer);
7743    }
7744}
7745
7746impl SseEncode for crate::model::Config {
7747    // Codec=Sse (Serialization based), see doc to use other codecs
7748    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7749        <crate::model::BlockchainExplorer>::sse_encode(self.liquid_explorer, serializer);
7750        <crate::model::BlockchainExplorer>::sse_encode(self.bitcoin_explorer, serializer);
7751        <String>::sse_encode(self.working_dir, serializer);
7752        <crate::model::LiquidNetwork>::sse_encode(self.network, serializer);
7753        <u64>::sse_encode(self.payment_timeout_sec, serializer);
7754        <Option<String>>::sse_encode(self.sync_service_url, serializer);
7755        <Option<u64>>::sse_encode(self.zero_conf_max_amount_sat, serializer);
7756        <Option<String>>::sse_encode(self.breez_api_key, serializer);
7757        <Option<Vec<crate::bindings::ExternalInputParser>>>::sse_encode(
7758            self.external_input_parsers,
7759            serializer,
7760        );
7761        <bool>::sse_encode(self.use_default_external_input_parsers, serializer);
7762        <Option<u32>>::sse_encode(self.onchain_fee_rate_leeway_sat_per_vbyte, serializer);
7763        <Option<Vec<crate::model::AssetMetadata>>>::sse_encode(self.asset_metadata, serializer);
7764        <Option<String>>::sse_encode(self.sideswap_api_key, serializer);
7765    }
7766}
7767
7768impl SseEncode for crate::model::ConnectRequest {
7769    // Codec=Sse (Serialization based), see doc to use other codecs
7770    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7771        <crate::model::Config>::sse_encode(self.config, serializer);
7772        <Option<String>>::sse_encode(self.mnemonic, serializer);
7773        <Option<String>>::sse_encode(self.passphrase, serializer);
7774        <Option<Vec<u8>>>::sse_encode(self.seed, serializer);
7775    }
7776}
7777
7778impl SseEncode for crate::model::CreateBolt12InvoiceRequest {
7779    // Codec=Sse (Serialization based), see doc to use other codecs
7780    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7781        <String>::sse_encode(self.offer, serializer);
7782        <String>::sse_encode(self.invoice_request, serializer);
7783    }
7784}
7785
7786impl SseEncode for crate::model::CreateBolt12InvoiceResponse {
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.invoice, serializer);
7790    }
7791}
7792
7793impl SseEncode for crate::bindings::CurrencyInfo {
7794    // Codec=Sse (Serialization based), see doc to use other codecs
7795    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7796        <String>::sse_encode(self.name, serializer);
7797        <u32>::sse_encode(self.fraction_size, serializer);
7798        <Option<u32>>::sse_encode(self.spacing, serializer);
7799        <Option<crate::bindings::Symbol>>::sse_encode(self.symbol, serializer);
7800        <Option<crate::bindings::Symbol>>::sse_encode(self.uniq_symbol, serializer);
7801        <Vec<crate::bindings::LocalizedName>>::sse_encode(self.localized_name, serializer);
7802        <Vec<crate::bindings::LocaleOverrides>>::sse_encode(self.locale_overrides, serializer);
7803    }
7804}
7805
7806impl SseEncode for crate::bindings::ExternalInputParser {
7807    // Codec=Sse (Serialization based), see doc to use other codecs
7808    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7809        <String>::sse_encode(self.provider_id, serializer);
7810        <String>::sse_encode(self.input_regex, serializer);
7811        <String>::sse_encode(self.parser_url, serializer);
7812    }
7813}
7814
7815impl SseEncode for f64 {
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        serializer.cursor.write_f64::<NativeEndian>(self).unwrap();
7819    }
7820}
7821
7822impl SseEncode for crate::model::FetchPaymentProposedFeesRequest {
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    }
7827}
7828
7829impl SseEncode for crate::model::FetchPaymentProposedFeesResponse {
7830    // Codec=Sse (Serialization based), see doc to use other codecs
7831    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7832        <String>::sse_encode(self.swap_id, serializer);
7833        <u64>::sse_encode(self.fees_sat, serializer);
7834        <u64>::sse_encode(self.payer_amount_sat, serializer);
7835        <u64>::sse_encode(self.receiver_amount_sat, serializer);
7836    }
7837}
7838
7839impl SseEncode for crate::bindings::FiatCurrency {
7840    // Codec=Sse (Serialization based), see doc to use other codecs
7841    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7842        <String>::sse_encode(self.id, serializer);
7843        <crate::bindings::CurrencyInfo>::sse_encode(self.info, serializer);
7844    }
7845}
7846
7847impl SseEncode for crate::model::GetInfoResponse {
7848    // Codec=Sse (Serialization based), see doc to use other codecs
7849    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7850        <crate::model::WalletInfo>::sse_encode(self.wallet_info, serializer);
7851        <crate::model::BlockchainInfo>::sse_encode(self.blockchain_info, serializer);
7852    }
7853}
7854
7855impl SseEncode for crate::model::GetPaymentRequest {
7856    // Codec=Sse (Serialization based), see doc to use other codecs
7857    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7858        match self {
7859            crate::model::GetPaymentRequest::PaymentHash { payment_hash } => {
7860                <i32>::sse_encode(0, serializer);
7861                <String>::sse_encode(payment_hash, serializer);
7862            }
7863            crate::model::GetPaymentRequest::SwapId { swap_id } => {
7864                <i32>::sse_encode(1, serializer);
7865                <String>::sse_encode(swap_id, serializer);
7866            }
7867            _ => {
7868                unimplemented!("");
7869            }
7870        }
7871    }
7872}
7873
7874impl SseEncode for i32 {
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_i32::<NativeEndian>(self).unwrap();
7878    }
7879}
7880
7881impl SseEncode for i64 {
7882    // Codec=Sse (Serialization based), see doc to use other codecs
7883    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7884        serializer.cursor.write_i64::<NativeEndian>(self).unwrap();
7885    }
7886}
7887
7888impl SseEncode for crate::bindings::InputType {
7889    // Codec=Sse (Serialization based), see doc to use other codecs
7890    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7891        match self {
7892            crate::bindings::InputType::BitcoinAddress { address } => {
7893                <i32>::sse_encode(0, serializer);
7894                <crate::bindings::BitcoinAddressData>::sse_encode(address, serializer);
7895            }
7896            crate::bindings::InputType::LiquidAddress { address } => {
7897                <i32>::sse_encode(1, serializer);
7898                <crate::bindings::LiquidAddressData>::sse_encode(address, serializer);
7899            }
7900            crate::bindings::InputType::Bolt11 { invoice } => {
7901                <i32>::sse_encode(2, serializer);
7902                <crate::bindings::LNInvoice>::sse_encode(invoice, serializer);
7903            }
7904            crate::bindings::InputType::Bolt12Offer {
7905                offer,
7906                bip353_address,
7907            } => {
7908                <i32>::sse_encode(3, serializer);
7909                <crate::bindings::LNOffer>::sse_encode(offer, serializer);
7910                <Option<String>>::sse_encode(bip353_address, serializer);
7911            }
7912            crate::bindings::InputType::NodeId { node_id } => {
7913                <i32>::sse_encode(4, serializer);
7914                <String>::sse_encode(node_id, serializer);
7915            }
7916            crate::bindings::InputType::Url { url } => {
7917                <i32>::sse_encode(5, serializer);
7918                <String>::sse_encode(url, serializer);
7919            }
7920            crate::bindings::InputType::LnUrlPay {
7921                data,
7922                bip353_address,
7923            } => {
7924                <i32>::sse_encode(6, serializer);
7925                <crate::bindings::LnUrlPayRequestData>::sse_encode(data, serializer);
7926                <Option<String>>::sse_encode(bip353_address, serializer);
7927            }
7928            crate::bindings::InputType::LnUrlWithdraw { data } => {
7929                <i32>::sse_encode(7, serializer);
7930                <crate::bindings::LnUrlWithdrawRequestData>::sse_encode(data, serializer);
7931            }
7932            crate::bindings::InputType::LnUrlAuth { data } => {
7933                <i32>::sse_encode(8, serializer);
7934                <crate::bindings::LnUrlAuthRequestData>::sse_encode(data, serializer);
7935            }
7936            crate::bindings::InputType::LnUrlError { data } => {
7937                <i32>::sse_encode(9, serializer);
7938                <crate::bindings::LnUrlErrorData>::sse_encode(data, serializer);
7939            }
7940            _ => {
7941                unimplemented!("");
7942            }
7943        }
7944    }
7945}
7946
7947impl SseEncode for crate::model::LightningPaymentLimitsResponse {
7948    // Codec=Sse (Serialization based), see doc to use other codecs
7949    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7950        <crate::model::Limits>::sse_encode(self.send, serializer);
7951        <crate::model::Limits>::sse_encode(self.receive, serializer);
7952    }
7953}
7954
7955impl SseEncode for crate::model::Limits {
7956    // Codec=Sse (Serialization based), see doc to use other codecs
7957    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7958        <u64>::sse_encode(self.min_sat, serializer);
7959        <u64>::sse_encode(self.max_sat, serializer);
7960        <u64>::sse_encode(self.max_zero_conf_sat, serializer);
7961    }
7962}
7963
7964impl SseEncode for crate::bindings::LiquidAddressData {
7965    // Codec=Sse (Serialization based), see doc to use other codecs
7966    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7967        <String>::sse_encode(self.address, serializer);
7968        <crate::bindings::Network>::sse_encode(self.network, serializer);
7969        <Option<String>>::sse_encode(self.asset_id, serializer);
7970        <Option<f64>>::sse_encode(self.amount, serializer);
7971        <Option<u64>>::sse_encode(self.amount_sat, serializer);
7972        <Option<String>>::sse_encode(self.label, serializer);
7973        <Option<String>>::sse_encode(self.message, serializer);
7974    }
7975}
7976
7977impl SseEncode for crate::model::LiquidNetwork {
7978    // Codec=Sse (Serialization based), see doc to use other codecs
7979    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7980        <i32>::sse_encode(
7981            match self {
7982                crate::model::LiquidNetwork::Mainnet => 0,
7983                crate::model::LiquidNetwork::Testnet => 1,
7984                crate::model::LiquidNetwork::Regtest => 2,
7985                _ => {
7986                    unimplemented!("");
7987                }
7988            },
7989            serializer,
7990        );
7991    }
7992}
7993
7994impl SseEncode for Vec<String> {
7995    // Codec=Sse (Serialization based), see doc to use other codecs
7996    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
7997        <i32>::sse_encode(self.len() as _, serializer);
7998        for item in self {
7999            <String>::sse_encode(item, serializer);
8000        }
8001    }
8002}
8003
8004impl SseEncode for Vec<crate::model::AssetBalance> {
8005    // Codec=Sse (Serialization based), see doc to use other codecs
8006    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8007        <i32>::sse_encode(self.len() as _, serializer);
8008        for item in self {
8009            <crate::model::AssetBalance>::sse_encode(item, serializer);
8010        }
8011    }
8012}
8013
8014impl SseEncode for Vec<crate::model::AssetMetadata> {
8015    // Codec=Sse (Serialization based), see doc to use other codecs
8016    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8017        <i32>::sse_encode(self.len() as _, serializer);
8018        for item in self {
8019            <crate::model::AssetMetadata>::sse_encode(item, serializer);
8020        }
8021    }
8022}
8023
8024impl SseEncode for Vec<crate::bindings::ExternalInputParser> {
8025    // Codec=Sse (Serialization based), see doc to use other codecs
8026    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8027        <i32>::sse_encode(self.len() as _, serializer);
8028        for item in self {
8029            <crate::bindings::ExternalInputParser>::sse_encode(item, serializer);
8030        }
8031    }
8032}
8033
8034impl SseEncode for Vec<crate::bindings::FiatCurrency> {
8035    // Codec=Sse (Serialization based), see doc to use other codecs
8036    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8037        <i32>::sse_encode(self.len() as _, serializer);
8038        for item in self {
8039            <crate::bindings::FiatCurrency>::sse_encode(item, serializer);
8040        }
8041    }
8042}
8043
8044impl SseEncode for Vec<crate::bindings::LnOfferBlindedPath> {
8045    // Codec=Sse (Serialization based), see doc to use other codecs
8046    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8047        <i32>::sse_encode(self.len() as _, serializer);
8048        for item in self {
8049            <crate::bindings::LnOfferBlindedPath>::sse_encode(item, serializer);
8050        }
8051    }
8052}
8053
8054impl SseEncode for Vec<crate::bindings::LocaleOverrides> {
8055    // Codec=Sse (Serialization based), see doc to use other codecs
8056    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8057        <i32>::sse_encode(self.len() as _, serializer);
8058        for item in self {
8059            <crate::bindings::LocaleOverrides>::sse_encode(item, serializer);
8060        }
8061    }
8062}
8063
8064impl SseEncode for Vec<crate::bindings::LocalizedName> {
8065    // Codec=Sse (Serialization based), see doc to use other codecs
8066    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8067        <i32>::sse_encode(self.len() as _, serializer);
8068        for item in self {
8069            <crate::bindings::LocalizedName>::sse_encode(item, serializer);
8070        }
8071    }
8072}
8073
8074impl SseEncode for Vec<crate::model::Payment> {
8075    // Codec=Sse (Serialization based), see doc to use other codecs
8076    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8077        <i32>::sse_encode(self.len() as _, serializer);
8078        for item in self {
8079            <crate::model::Payment>::sse_encode(item, serializer);
8080        }
8081    }
8082}
8083
8084impl SseEncode for crate::model::ListPaymentDetails {
8085    // Codec=Sse (Serialization based), see doc to use other codecs
8086    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8087        match self {
8088            crate::model::ListPaymentDetails::Liquid {
8089                asset_id,
8090                destination,
8091            } => {
8092                <i32>::sse_encode(0, serializer);
8093                <Option<String>>::sse_encode(asset_id, serializer);
8094                <Option<String>>::sse_encode(destination, serializer);
8095            }
8096            crate::model::ListPaymentDetails::Bitcoin { address } => {
8097                <i32>::sse_encode(1, serializer);
8098                <Option<String>>::sse_encode(address, serializer);
8099            }
8100            _ => {
8101                unimplemented!("");
8102            }
8103        }
8104    }
8105}
8106
8107impl SseEncode for Vec<crate::model::PaymentState> {
8108    // Codec=Sse (Serialization based), see doc to use other codecs
8109    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8110        <i32>::sse_encode(self.len() as _, serializer);
8111        for item in self {
8112            <crate::model::PaymentState>::sse_encode(item, serializer);
8113        }
8114    }
8115}
8116
8117impl SseEncode for Vec<crate::model::PaymentType> {
8118    // Codec=Sse (Serialization based), see doc to use other codecs
8119    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8120        <i32>::sse_encode(self.len() as _, serializer);
8121        for item in self {
8122            <crate::model::PaymentType>::sse_encode(item, serializer);
8123        }
8124    }
8125}
8126
8127impl SseEncode for crate::model::ListPaymentsRequest {
8128    // Codec=Sse (Serialization based), see doc to use other codecs
8129    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8130        <Option<Vec<crate::model::PaymentType>>>::sse_encode(self.filters, serializer);
8131        <Option<Vec<crate::model::PaymentState>>>::sse_encode(self.states, serializer);
8132        <Option<i64>>::sse_encode(self.from_timestamp, serializer);
8133        <Option<i64>>::sse_encode(self.to_timestamp, serializer);
8134        <Option<u32>>::sse_encode(self.offset, serializer);
8135        <Option<u32>>::sse_encode(self.limit, serializer);
8136        <Option<crate::model::ListPaymentDetails>>::sse_encode(self.details, serializer);
8137        <Option<bool>>::sse_encode(self.sort_ascending, serializer);
8138    }
8139}
8140
8141impl SseEncode for Vec<u8> {
8142    // Codec=Sse (Serialization based), see doc to use other codecs
8143    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8144        <i32>::sse_encode(self.len() as _, serializer);
8145        for item in self {
8146            <u8>::sse_encode(item, serializer);
8147        }
8148    }
8149}
8150
8151impl SseEncode for Vec<crate::bindings::Rate> {
8152    // Codec=Sse (Serialization based), see doc to use other codecs
8153    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8154        <i32>::sse_encode(self.len() as _, serializer);
8155        for item in self {
8156            <crate::bindings::Rate>::sse_encode(item, serializer);
8157        }
8158    }
8159}
8160
8161impl SseEncode for Vec<crate::model::RefundableSwap> {
8162    // Codec=Sse (Serialization based), see doc to use other codecs
8163    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8164        <i32>::sse_encode(self.len() as _, serializer);
8165        for item in self {
8166            <crate::model::RefundableSwap>::sse_encode(item, serializer);
8167        }
8168    }
8169}
8170
8171impl SseEncode for Vec<crate::bindings::RouteHint> {
8172    // Codec=Sse (Serialization based), see doc to use other codecs
8173    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8174        <i32>::sse_encode(self.len() as _, serializer);
8175        for item in self {
8176            <crate::bindings::RouteHint>::sse_encode(item, serializer);
8177        }
8178    }
8179}
8180
8181impl SseEncode for Vec<crate::bindings::RouteHintHop> {
8182    // Codec=Sse (Serialization based), see doc to use other codecs
8183    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8184        <i32>::sse_encode(self.len() as _, serializer);
8185        for item in self {
8186            <crate::bindings::RouteHintHop>::sse_encode(item, serializer);
8187        }
8188    }
8189}
8190
8191impl SseEncode for crate::bindings::LNInvoice {
8192    // Codec=Sse (Serialization based), see doc to use other codecs
8193    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8194        <String>::sse_encode(self.bolt11, serializer);
8195        <crate::bindings::Network>::sse_encode(self.network, serializer);
8196        <String>::sse_encode(self.payee_pubkey, serializer);
8197        <String>::sse_encode(self.payment_hash, serializer);
8198        <Option<String>>::sse_encode(self.description, serializer);
8199        <Option<String>>::sse_encode(self.description_hash, serializer);
8200        <Option<u64>>::sse_encode(self.amount_msat, serializer);
8201        <u64>::sse_encode(self.timestamp, serializer);
8202        <u64>::sse_encode(self.expiry, serializer);
8203        <Vec<crate::bindings::RouteHint>>::sse_encode(self.routing_hints, serializer);
8204        <Vec<u8>>::sse_encode(self.payment_secret, serializer);
8205        <u64>::sse_encode(self.min_final_cltv_expiry_delta, serializer);
8206    }
8207}
8208
8209impl SseEncode for crate::bindings::LNOffer {
8210    // Codec=Sse (Serialization based), see doc to use other codecs
8211    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8212        <String>::sse_encode(self.offer, serializer);
8213        <Vec<String>>::sse_encode(self.chains, serializer);
8214        <Option<crate::bindings::Amount>>::sse_encode(self.min_amount, serializer);
8215        <Option<String>>::sse_encode(self.description, serializer);
8216        <Option<u64>>::sse_encode(self.absolute_expiry, serializer);
8217        <Option<String>>::sse_encode(self.issuer, serializer);
8218        <Option<String>>::sse_encode(self.signing_pubkey, serializer);
8219        <Vec<crate::bindings::LnOfferBlindedPath>>::sse_encode(self.paths, serializer);
8220    }
8221}
8222
8223impl SseEncode for crate::bindings::LnOfferBlindedPath {
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        <Vec<String>>::sse_encode(self.blinded_hops, serializer);
8227    }
8228}
8229
8230impl SseEncode for crate::bindings::duplicates::LnUrlAuthError {
8231    // Codec=Sse (Serialization based), see doc to use other codecs
8232    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8233        match self {
8234            crate::bindings::duplicates::LnUrlAuthError::Generic { err } => {
8235                <i32>::sse_encode(0, serializer);
8236                <String>::sse_encode(err, serializer);
8237            }
8238            crate::bindings::duplicates::LnUrlAuthError::InvalidUri { err } => {
8239                <i32>::sse_encode(1, serializer);
8240                <String>::sse_encode(err, serializer);
8241            }
8242            crate::bindings::duplicates::LnUrlAuthError::ServiceConnectivity { err } => {
8243                <i32>::sse_encode(2, serializer);
8244                <String>::sse_encode(err, serializer);
8245            }
8246            _ => {
8247                unimplemented!("");
8248            }
8249        }
8250    }
8251}
8252
8253impl SseEncode for crate::bindings::LnUrlAuthRequestData {
8254    // Codec=Sse (Serialization based), see doc to use other codecs
8255    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8256        <String>::sse_encode(self.k1, serializer);
8257        <Option<String>>::sse_encode(self.action, serializer);
8258        <String>::sse_encode(self.domain, serializer);
8259        <String>::sse_encode(self.url, serializer);
8260    }
8261}
8262
8263impl SseEncode for crate::bindings::duplicates::LnUrlCallbackStatus {
8264    // Codec=Sse (Serialization based), see doc to use other codecs
8265    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8266        match self {
8267            crate::bindings::duplicates::LnUrlCallbackStatus::Ok => {
8268                <i32>::sse_encode(0, serializer);
8269            }
8270            crate::bindings::duplicates::LnUrlCallbackStatus::ErrorStatus { data } => {
8271                <i32>::sse_encode(1, serializer);
8272                <crate::bindings::LnUrlErrorData>::sse_encode(data, serializer);
8273            }
8274            _ => {
8275                unimplemented!("");
8276            }
8277        }
8278    }
8279}
8280
8281impl SseEncode for crate::bindings::LnUrlErrorData {
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        <String>::sse_encode(self.reason, serializer);
8285    }
8286}
8287
8288impl SseEncode for crate::model::LnUrlInfo {
8289    // Codec=Sse (Serialization based), see doc to use other codecs
8290    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8291        <Option<String>>::sse_encode(self.ln_address, serializer);
8292        <Option<String>>::sse_encode(self.lnurl_pay_comment, serializer);
8293        <Option<String>>::sse_encode(self.lnurl_pay_domain, serializer);
8294        <Option<String>>::sse_encode(self.lnurl_pay_metadata, serializer);
8295        <Option<crate::bindings::SuccessActionProcessed>>::sse_encode(
8296            self.lnurl_pay_success_action,
8297            serializer,
8298        );
8299        <Option<crate::bindings::SuccessAction>>::sse_encode(
8300            self.lnurl_pay_unprocessed_success_action,
8301            serializer,
8302        );
8303        <Option<String>>::sse_encode(self.lnurl_withdraw_endpoint, serializer);
8304    }
8305}
8306
8307impl SseEncode for crate::bindings::duplicates::LnUrlPayError {
8308    // Codec=Sse (Serialization based), see doc to use other codecs
8309    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8310        match self {
8311            crate::bindings::duplicates::LnUrlPayError::AlreadyPaid => {
8312                <i32>::sse_encode(0, serializer);
8313            }
8314            crate::bindings::duplicates::LnUrlPayError::Generic { err } => {
8315                <i32>::sse_encode(1, serializer);
8316                <String>::sse_encode(err, serializer);
8317            }
8318            crate::bindings::duplicates::LnUrlPayError::InsufficientBalance { err } => {
8319                <i32>::sse_encode(2, serializer);
8320                <String>::sse_encode(err, serializer);
8321            }
8322            crate::bindings::duplicates::LnUrlPayError::InvalidAmount { err } => {
8323                <i32>::sse_encode(3, serializer);
8324                <String>::sse_encode(err, serializer);
8325            }
8326            crate::bindings::duplicates::LnUrlPayError::InvalidInvoice { err } => {
8327                <i32>::sse_encode(4, serializer);
8328                <String>::sse_encode(err, serializer);
8329            }
8330            crate::bindings::duplicates::LnUrlPayError::InvalidNetwork { err } => {
8331                <i32>::sse_encode(5, serializer);
8332                <String>::sse_encode(err, serializer);
8333            }
8334            crate::bindings::duplicates::LnUrlPayError::InvalidUri { err } => {
8335                <i32>::sse_encode(6, serializer);
8336                <String>::sse_encode(err, serializer);
8337            }
8338            crate::bindings::duplicates::LnUrlPayError::InvoiceExpired { err } => {
8339                <i32>::sse_encode(7, serializer);
8340                <String>::sse_encode(err, serializer);
8341            }
8342            crate::bindings::duplicates::LnUrlPayError::PaymentFailed { err } => {
8343                <i32>::sse_encode(8, serializer);
8344                <String>::sse_encode(err, serializer);
8345            }
8346            crate::bindings::duplicates::LnUrlPayError::PaymentTimeout { err } => {
8347                <i32>::sse_encode(9, serializer);
8348                <String>::sse_encode(err, serializer);
8349            }
8350            crate::bindings::duplicates::LnUrlPayError::RouteNotFound { err } => {
8351                <i32>::sse_encode(10, serializer);
8352                <String>::sse_encode(err, serializer);
8353            }
8354            crate::bindings::duplicates::LnUrlPayError::RouteTooExpensive { err } => {
8355                <i32>::sse_encode(11, serializer);
8356                <String>::sse_encode(err, serializer);
8357            }
8358            crate::bindings::duplicates::LnUrlPayError::ServiceConnectivity { err } => {
8359                <i32>::sse_encode(12, serializer);
8360                <String>::sse_encode(err, serializer);
8361            }
8362            _ => {
8363                unimplemented!("");
8364            }
8365        }
8366    }
8367}
8368
8369impl SseEncode for crate::bindings::LnUrlPayErrorData {
8370    // Codec=Sse (Serialization based), see doc to use other codecs
8371    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8372        <String>::sse_encode(self.payment_hash, serializer);
8373        <String>::sse_encode(self.reason, serializer);
8374    }
8375}
8376
8377impl SseEncode for crate::model::LnUrlPayRequest {
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        <crate::model::PrepareLnUrlPayResponse>::sse_encode(self.prepare_response, serializer);
8381    }
8382}
8383
8384impl SseEncode for crate::bindings::LnUrlPayRequestData {
8385    // Codec=Sse (Serialization based), see doc to use other codecs
8386    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8387        <String>::sse_encode(self.callback, serializer);
8388        <u64>::sse_encode(self.min_sendable, serializer);
8389        <u64>::sse_encode(self.max_sendable, serializer);
8390        <String>::sse_encode(self.metadata_str, serializer);
8391        <u16>::sse_encode(self.comment_allowed, serializer);
8392        <String>::sse_encode(self.domain, serializer);
8393        <bool>::sse_encode(self.allows_nostr, serializer);
8394        <Option<String>>::sse_encode(self.nostr_pubkey, serializer);
8395        <Option<String>>::sse_encode(self.ln_address, serializer);
8396    }
8397}
8398
8399impl SseEncode for crate::model::LnUrlPayResult {
8400    // Codec=Sse (Serialization based), see doc to use other codecs
8401    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8402        match self {
8403            crate::model::LnUrlPayResult::EndpointSuccess { data } => {
8404                <i32>::sse_encode(0, serializer);
8405                <crate::model::LnUrlPaySuccessData>::sse_encode(data, serializer);
8406            }
8407            crate::model::LnUrlPayResult::EndpointError { data } => {
8408                <i32>::sse_encode(1, serializer);
8409                <crate::bindings::LnUrlErrorData>::sse_encode(data, serializer);
8410            }
8411            crate::model::LnUrlPayResult::PayError { data } => {
8412                <i32>::sse_encode(2, serializer);
8413                <crate::bindings::LnUrlPayErrorData>::sse_encode(data, serializer);
8414            }
8415            _ => {
8416                unimplemented!("");
8417            }
8418        }
8419    }
8420}
8421
8422impl SseEncode for crate::model::LnUrlPaySuccessData {
8423    // Codec=Sse (Serialization based), see doc to use other codecs
8424    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8425        <crate::model::Payment>::sse_encode(self.payment, serializer);
8426        <Option<crate::bindings::SuccessActionProcessed>>::sse_encode(
8427            self.success_action,
8428            serializer,
8429        );
8430    }
8431}
8432
8433impl SseEncode for crate::bindings::duplicates::LnUrlWithdrawError {
8434    // Codec=Sse (Serialization based), see doc to use other codecs
8435    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8436        match self {
8437            crate::bindings::duplicates::LnUrlWithdrawError::Generic { err } => {
8438                <i32>::sse_encode(0, serializer);
8439                <String>::sse_encode(err, serializer);
8440            }
8441            crate::bindings::duplicates::LnUrlWithdrawError::InvalidAmount { err } => {
8442                <i32>::sse_encode(1, serializer);
8443                <String>::sse_encode(err, serializer);
8444            }
8445            crate::bindings::duplicates::LnUrlWithdrawError::InvalidInvoice { err } => {
8446                <i32>::sse_encode(2, serializer);
8447                <String>::sse_encode(err, serializer);
8448            }
8449            crate::bindings::duplicates::LnUrlWithdrawError::InvalidUri { err } => {
8450                <i32>::sse_encode(3, serializer);
8451                <String>::sse_encode(err, serializer);
8452            }
8453            crate::bindings::duplicates::LnUrlWithdrawError::InvoiceNoRoutingHints { err } => {
8454                <i32>::sse_encode(4, serializer);
8455                <String>::sse_encode(err, serializer);
8456            }
8457            crate::bindings::duplicates::LnUrlWithdrawError::ServiceConnectivity { err } => {
8458                <i32>::sse_encode(5, serializer);
8459                <String>::sse_encode(err, serializer);
8460            }
8461            _ => {
8462                unimplemented!("");
8463            }
8464        }
8465    }
8466}
8467
8468impl SseEncode for crate::bindings::LnUrlWithdrawRequest {
8469    // Codec=Sse (Serialization based), see doc to use other codecs
8470    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8471        <crate::bindings::LnUrlWithdrawRequestData>::sse_encode(self.data, serializer);
8472        <u64>::sse_encode(self.amount_msat, serializer);
8473        <Option<String>>::sse_encode(self.description, serializer);
8474    }
8475}
8476
8477impl SseEncode for crate::bindings::LnUrlWithdrawRequestData {
8478    // Codec=Sse (Serialization based), see doc to use other codecs
8479    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8480        <String>::sse_encode(self.callback, serializer);
8481        <String>::sse_encode(self.k1, serializer);
8482        <String>::sse_encode(self.default_description, serializer);
8483        <u64>::sse_encode(self.min_withdrawable, serializer);
8484        <u64>::sse_encode(self.max_withdrawable, serializer);
8485    }
8486}
8487
8488impl SseEncode for crate::bindings::duplicates::LnUrlWithdrawResult {
8489    // Codec=Sse (Serialization based), see doc to use other codecs
8490    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8491        match self {
8492            crate::bindings::duplicates::LnUrlWithdrawResult::Ok { data } => {
8493                <i32>::sse_encode(0, serializer);
8494                <crate::bindings::duplicates::LnUrlWithdrawSuccessData>::sse_encode(
8495                    data, serializer,
8496                );
8497            }
8498            crate::bindings::duplicates::LnUrlWithdrawResult::Timeout { data } => {
8499                <i32>::sse_encode(1, serializer);
8500                <crate::bindings::duplicates::LnUrlWithdrawSuccessData>::sse_encode(
8501                    data, serializer,
8502                );
8503            }
8504            crate::bindings::duplicates::LnUrlWithdrawResult::ErrorStatus { data } => {
8505                <i32>::sse_encode(2, serializer);
8506                <crate::bindings::LnUrlErrorData>::sse_encode(data, serializer);
8507            }
8508            _ => {
8509                unimplemented!("");
8510            }
8511        }
8512    }
8513}
8514
8515impl SseEncode for crate::bindings::duplicates::LnUrlWithdrawSuccessData {
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        <crate::bindings::LNInvoice>::sse_encode(self.invoice, serializer);
8519    }
8520}
8521
8522impl SseEncode for crate::bindings::LocaleOverrides {
8523    // Codec=Sse (Serialization based), see doc to use other codecs
8524    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8525        <String>::sse_encode(self.locale, serializer);
8526        <Option<u32>>::sse_encode(self.spacing, serializer);
8527        <crate::bindings::Symbol>::sse_encode(self.symbol, serializer);
8528    }
8529}
8530
8531impl SseEncode for crate::bindings::LocalizedName {
8532    // Codec=Sse (Serialization based), see doc to use other codecs
8533    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8534        <String>::sse_encode(self.locale, serializer);
8535        <String>::sse_encode(self.name, serializer);
8536    }
8537}
8538
8539impl SseEncode for crate::model::LogEntry {
8540    // Codec=Sse (Serialization based), see doc to use other codecs
8541    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8542        <String>::sse_encode(self.line, serializer);
8543        <String>::sse_encode(self.level, serializer);
8544    }
8545}
8546
8547impl SseEncode for crate::bindings::MessageSuccessActionData {
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        <String>::sse_encode(self.message, serializer);
8551    }
8552}
8553
8554impl SseEncode for crate::bindings::Network {
8555    // Codec=Sse (Serialization based), see doc to use other codecs
8556    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8557        <i32>::sse_encode(
8558            match self {
8559                crate::bindings::Network::Bitcoin => 0,
8560                crate::bindings::Network::Testnet => 1,
8561                crate::bindings::Network::Signet => 2,
8562                crate::bindings::Network::Regtest => 3,
8563                _ => {
8564                    unimplemented!("");
8565                }
8566            },
8567            serializer,
8568        );
8569    }
8570}
8571
8572impl SseEncode for crate::model::OnchainPaymentLimitsResponse {
8573    // Codec=Sse (Serialization based), see doc to use other codecs
8574    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8575        <crate::model::Limits>::sse_encode(self.send, serializer);
8576        <crate::model::Limits>::sse_encode(self.receive, serializer);
8577    }
8578}
8579
8580impl SseEncode for Option<String> {
8581    // Codec=Sse (Serialization based), see doc to use other codecs
8582    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8583        <bool>::sse_encode(self.is_some(), serializer);
8584        if let Some(value) = self {
8585            <String>::sse_encode(value, serializer);
8586        }
8587    }
8588}
8589
8590impl SseEncode for Option<crate::bindings::Amount> {
8591    // Codec=Sse (Serialization based), see doc to use other codecs
8592    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8593        <bool>::sse_encode(self.is_some(), serializer);
8594        if let Some(value) = self {
8595            <crate::bindings::Amount>::sse_encode(value, serializer);
8596        }
8597    }
8598}
8599
8600impl SseEncode for Option<crate::model::AssetInfo> {
8601    // Codec=Sse (Serialization based), see doc to use other codecs
8602    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8603        <bool>::sse_encode(self.is_some(), serializer);
8604        if let Some(value) = self {
8605            <crate::model::AssetInfo>::sse_encode(value, serializer);
8606        }
8607    }
8608}
8609
8610impl SseEncode for Option<bool> {
8611    // Codec=Sse (Serialization based), see doc to use other codecs
8612    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8613        <bool>::sse_encode(self.is_some(), serializer);
8614        if let Some(value) = self {
8615            <bool>::sse_encode(value, serializer);
8616        }
8617    }
8618}
8619
8620impl SseEncode for Option<f64> {
8621    // Codec=Sse (Serialization based), see doc to use other codecs
8622    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8623        <bool>::sse_encode(self.is_some(), serializer);
8624        if let Some(value) = self {
8625            <f64>::sse_encode(value, serializer);
8626        }
8627    }
8628}
8629
8630impl SseEncode for Option<i64> {
8631    // Codec=Sse (Serialization based), see doc to use other codecs
8632    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8633        <bool>::sse_encode(self.is_some(), serializer);
8634        if let Some(value) = self {
8635            <i64>::sse_encode(value, serializer);
8636        }
8637    }
8638}
8639
8640impl SseEncode for Option<crate::model::ListPaymentDetails> {
8641    // Codec=Sse (Serialization based), see doc to use other codecs
8642    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8643        <bool>::sse_encode(self.is_some(), serializer);
8644        if let Some(value) = self {
8645            <crate::model::ListPaymentDetails>::sse_encode(value, serializer);
8646        }
8647    }
8648}
8649
8650impl SseEncode for Option<crate::model::LnUrlInfo> {
8651    // Codec=Sse (Serialization based), see doc to use other codecs
8652    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8653        <bool>::sse_encode(self.is_some(), serializer);
8654        if let Some(value) = self {
8655            <crate::model::LnUrlInfo>::sse_encode(value, serializer);
8656        }
8657    }
8658}
8659
8660impl SseEncode for Option<crate::model::PayAmount> {
8661    // Codec=Sse (Serialization based), see doc to use other codecs
8662    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8663        <bool>::sse_encode(self.is_some(), serializer);
8664        if let Some(value) = self {
8665            <crate::model::PayAmount>::sse_encode(value, serializer);
8666        }
8667    }
8668}
8669
8670impl SseEncode for Option<crate::model::Payment> {
8671    // Codec=Sse (Serialization based), see doc to use other codecs
8672    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8673        <bool>::sse_encode(self.is_some(), serializer);
8674        if let Some(value) = self {
8675            <crate::model::Payment>::sse_encode(value, serializer);
8676        }
8677    }
8678}
8679
8680impl SseEncode for Option<crate::model::ReceiveAmount> {
8681    // Codec=Sse (Serialization based), see doc to use other codecs
8682    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8683        <bool>::sse_encode(self.is_some(), serializer);
8684        if let Some(value) = self {
8685            <crate::model::ReceiveAmount>::sse_encode(value, serializer);
8686        }
8687    }
8688}
8689
8690impl SseEncode for Option<crate::bindings::SuccessAction> {
8691    // Codec=Sse (Serialization based), see doc to use other codecs
8692    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8693        <bool>::sse_encode(self.is_some(), serializer);
8694        if let Some(value) = self {
8695            <crate::bindings::SuccessAction>::sse_encode(value, serializer);
8696        }
8697    }
8698}
8699
8700impl SseEncode for Option<crate::bindings::SuccessActionProcessed> {
8701    // Codec=Sse (Serialization based), see doc to use other codecs
8702    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8703        <bool>::sse_encode(self.is_some(), serializer);
8704        if let Some(value) = self {
8705            <crate::bindings::SuccessActionProcessed>::sse_encode(value, serializer);
8706        }
8707    }
8708}
8709
8710impl SseEncode for Option<crate::bindings::Symbol> {
8711    // Codec=Sse (Serialization based), see doc to use other codecs
8712    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8713        <bool>::sse_encode(self.is_some(), serializer);
8714        if let Some(value) = self {
8715            <crate::bindings::Symbol>::sse_encode(value, serializer);
8716        }
8717    }
8718}
8719
8720impl SseEncode for Option<u32> {
8721    // Codec=Sse (Serialization based), see doc to use other codecs
8722    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8723        <bool>::sse_encode(self.is_some(), serializer);
8724        if let Some(value) = self {
8725            <u32>::sse_encode(value, serializer);
8726        }
8727    }
8728}
8729
8730impl SseEncode for Option<u64> {
8731    // Codec=Sse (Serialization based), see doc to use other codecs
8732    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8733        <bool>::sse_encode(self.is_some(), serializer);
8734        if let Some(value) = self {
8735            <u64>::sse_encode(value, serializer);
8736        }
8737    }
8738}
8739
8740impl SseEncode for Option<Vec<crate::model::AssetMetadata>> {
8741    // Codec=Sse (Serialization based), see doc to use other codecs
8742    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8743        <bool>::sse_encode(self.is_some(), serializer);
8744        if let Some(value) = self {
8745            <Vec<crate::model::AssetMetadata>>::sse_encode(value, serializer);
8746        }
8747    }
8748}
8749
8750impl SseEncode for Option<Vec<crate::bindings::ExternalInputParser>> {
8751    // Codec=Sse (Serialization based), see doc to use other codecs
8752    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8753        <bool>::sse_encode(self.is_some(), serializer);
8754        if let Some(value) = self {
8755            <Vec<crate::bindings::ExternalInputParser>>::sse_encode(value, serializer);
8756        }
8757    }
8758}
8759
8760impl SseEncode for Option<Vec<crate::model::PaymentState>> {
8761    // Codec=Sse (Serialization based), see doc to use other codecs
8762    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8763        <bool>::sse_encode(self.is_some(), serializer);
8764        if let Some(value) = self {
8765            <Vec<crate::model::PaymentState>>::sse_encode(value, serializer);
8766        }
8767    }
8768}
8769
8770impl SseEncode for Option<Vec<crate::model::PaymentType>> {
8771    // Codec=Sse (Serialization based), see doc to use other codecs
8772    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8773        <bool>::sse_encode(self.is_some(), serializer);
8774        if let Some(value) = self {
8775            <Vec<crate::model::PaymentType>>::sse_encode(value, serializer);
8776        }
8777    }
8778}
8779
8780impl SseEncode for Option<Vec<u8>> {
8781    // Codec=Sse (Serialization based), see doc to use other codecs
8782    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8783        <bool>::sse_encode(self.is_some(), serializer);
8784        if let Some(value) = self {
8785            <Vec<u8>>::sse_encode(value, serializer);
8786        }
8787    }
8788}
8789
8790impl SseEncode for crate::model::PayAmount {
8791    // Codec=Sse (Serialization based), see doc to use other codecs
8792    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8793        match self {
8794            crate::model::PayAmount::Bitcoin {
8795                receiver_amount_sat,
8796            } => {
8797                <i32>::sse_encode(0, serializer);
8798                <u64>::sse_encode(receiver_amount_sat, serializer);
8799            }
8800            crate::model::PayAmount::Asset {
8801                asset_id,
8802                receiver_amount,
8803                estimate_asset_fees,
8804            } => {
8805                <i32>::sse_encode(1, serializer);
8806                <String>::sse_encode(asset_id, serializer);
8807                <f64>::sse_encode(receiver_amount, serializer);
8808                <Option<bool>>::sse_encode(estimate_asset_fees, serializer);
8809            }
8810            crate::model::PayAmount::Drain => {
8811                <i32>::sse_encode(2, serializer);
8812            }
8813            _ => {
8814                unimplemented!("");
8815            }
8816        }
8817    }
8818}
8819
8820impl SseEncode for crate::model::PayOnchainRequest {
8821    // Codec=Sse (Serialization based), see doc to use other codecs
8822    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8823        <String>::sse_encode(self.address, serializer);
8824        <crate::model::PreparePayOnchainResponse>::sse_encode(self.prepare_response, serializer);
8825    }
8826}
8827
8828impl SseEncode for crate::model::Payment {
8829    // Codec=Sse (Serialization based), see doc to use other codecs
8830    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8831        <Option<String>>::sse_encode(self.destination, serializer);
8832        <Option<String>>::sse_encode(self.tx_id, serializer);
8833        <Option<String>>::sse_encode(self.unblinding_data, serializer);
8834        <u32>::sse_encode(self.timestamp, serializer);
8835        <u64>::sse_encode(self.amount_sat, serializer);
8836        <u64>::sse_encode(self.fees_sat, serializer);
8837        <Option<u64>>::sse_encode(self.swapper_fees_sat, serializer);
8838        <crate::model::PaymentType>::sse_encode(self.payment_type, serializer);
8839        <crate::model::PaymentState>::sse_encode(self.status, serializer);
8840        <crate::model::PaymentDetails>::sse_encode(self.details, serializer);
8841    }
8842}
8843
8844impl SseEncode for crate::model::PaymentDetails {
8845    // Codec=Sse (Serialization based), see doc to use other codecs
8846    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8847        match self {
8848            crate::model::PaymentDetails::Lightning {
8849                swap_id,
8850                description,
8851                liquid_expiration_blockheight,
8852                preimage,
8853                invoice,
8854                bolt12_offer,
8855                payment_hash,
8856                destination_pubkey,
8857                lnurl_info,
8858                bip353_address,
8859                claim_tx_id,
8860                refund_tx_id,
8861                refund_tx_amount_sat,
8862            } => {
8863                <i32>::sse_encode(0, serializer);
8864                <String>::sse_encode(swap_id, serializer);
8865                <String>::sse_encode(description, serializer);
8866                <u32>::sse_encode(liquid_expiration_blockheight, serializer);
8867                <Option<String>>::sse_encode(preimage, serializer);
8868                <Option<String>>::sse_encode(invoice, serializer);
8869                <Option<String>>::sse_encode(bolt12_offer, serializer);
8870                <Option<String>>::sse_encode(payment_hash, serializer);
8871                <Option<String>>::sse_encode(destination_pubkey, serializer);
8872                <Option<crate::model::LnUrlInfo>>::sse_encode(lnurl_info, serializer);
8873                <Option<String>>::sse_encode(bip353_address, serializer);
8874                <Option<String>>::sse_encode(claim_tx_id, serializer);
8875                <Option<String>>::sse_encode(refund_tx_id, serializer);
8876                <Option<u64>>::sse_encode(refund_tx_amount_sat, serializer);
8877            }
8878            crate::model::PaymentDetails::Liquid {
8879                destination,
8880                description,
8881                asset_id,
8882                asset_info,
8883                lnurl_info,
8884                bip353_address,
8885            } => {
8886                <i32>::sse_encode(1, serializer);
8887                <String>::sse_encode(destination, serializer);
8888                <String>::sse_encode(description, serializer);
8889                <String>::sse_encode(asset_id, serializer);
8890                <Option<crate::model::AssetInfo>>::sse_encode(asset_info, serializer);
8891                <Option<crate::model::LnUrlInfo>>::sse_encode(lnurl_info, serializer);
8892                <Option<String>>::sse_encode(bip353_address, serializer);
8893            }
8894            crate::model::PaymentDetails::Bitcoin {
8895                swap_id,
8896                bitcoin_address,
8897                description,
8898                auto_accepted_fees,
8899                liquid_expiration_blockheight,
8900                bitcoin_expiration_blockheight,
8901                lockup_tx_id,
8902                claim_tx_id,
8903                refund_tx_id,
8904                refund_tx_amount_sat,
8905            } => {
8906                <i32>::sse_encode(2, serializer);
8907                <String>::sse_encode(swap_id, serializer);
8908                <String>::sse_encode(bitcoin_address, serializer);
8909                <String>::sse_encode(description, serializer);
8910                <bool>::sse_encode(auto_accepted_fees, serializer);
8911                <Option<u32>>::sse_encode(liquid_expiration_blockheight, serializer);
8912                <Option<u32>>::sse_encode(bitcoin_expiration_blockheight, serializer);
8913                <Option<String>>::sse_encode(lockup_tx_id, serializer);
8914                <Option<String>>::sse_encode(claim_tx_id, serializer);
8915                <Option<String>>::sse_encode(refund_tx_id, serializer);
8916                <Option<u64>>::sse_encode(refund_tx_amount_sat, serializer);
8917            }
8918            _ => {
8919                unimplemented!("");
8920            }
8921        }
8922    }
8923}
8924
8925impl SseEncode for crate::error::PaymentError {
8926    // Codec=Sse (Serialization based), see doc to use other codecs
8927    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
8928        match self {
8929            crate::error::PaymentError::AlreadyClaimed => {
8930                <i32>::sse_encode(0, serializer);
8931            }
8932            crate::error::PaymentError::AlreadyPaid => {
8933                <i32>::sse_encode(1, serializer);
8934            }
8935            crate::error::PaymentError::PaymentInProgress => {
8936                <i32>::sse_encode(2, serializer);
8937            }
8938            crate::error::PaymentError::AmountOutOfRange { min, max } => {
8939                <i32>::sse_encode(3, serializer);
8940                <u64>::sse_encode(min, serializer);
8941                <u64>::sse_encode(max, serializer);
8942            }
8943            crate::error::PaymentError::AmountMissing { err } => {
8944                <i32>::sse_encode(4, serializer);
8945                <String>::sse_encode(err, serializer);
8946            }
8947            crate::error::PaymentError::AssetError { err } => {
8948                <i32>::sse_encode(5, serializer);
8949                <String>::sse_encode(err, serializer);
8950            }
8951            crate::error::PaymentError::InvalidNetwork { err } => {
8952                <i32>::sse_encode(6, serializer);
8953                <String>::sse_encode(err, serializer);
8954            }
8955            crate::error::PaymentError::Generic { err } => {
8956                <i32>::sse_encode(7, serializer);
8957                <String>::sse_encode(err, serializer);
8958            }
8959            crate::error::PaymentError::InvalidOrExpiredFees => {
8960                <i32>::sse_encode(8, serializer);
8961            }
8962            crate::error::PaymentError::InsufficientFunds => {
8963                <i32>::sse_encode(9, serializer);
8964            }
8965            crate::error::PaymentError::InvalidDescription { err } => {
8966                <i32>::sse_encode(10, serializer);
8967                <String>::sse_encode(err, serializer);
8968            }
8969            crate::error::PaymentError::InvalidInvoice { err } => {
8970                <i32>::sse_encode(11, serializer);
8971                <String>::sse_encode(err, serializer);
8972            }
8973            crate::error::PaymentError::InvalidPreimage => {
8974                <i32>::sse_encode(12, serializer);
8975            }
8976            crate::error::PaymentError::PairsNotFound => {
8977                <i32>::sse_encode(13, serializer);
8978            }
8979            crate::error::PaymentError::PaymentTimeout => {
8980                <i32>::sse_encode(14, serializer);
8981            }
8982            crate::error::PaymentError::PersistError => {
8983                <i32>::sse_encode(15, serializer);
8984            }
8985            crate::error::PaymentError::ReceiveError { err } => {
8986                <i32>::sse_encode(16, serializer);
8987                <String>::sse_encode(err, serializer);
8988            }
8989            crate::error::PaymentError::Refunded { err, refund_tx_id } => {
8990                <i32>::sse_encode(17, serializer);
8991                <String>::sse_encode(err, serializer);
8992                <String>::sse_encode(refund_tx_id, serializer);
8993            }
8994            crate::error::PaymentError::SelfTransferNotSupported => {
8995                <i32>::sse_encode(18, serializer);
8996            }
8997            crate::error::PaymentError::SendError { err } => {
8998                <i32>::sse_encode(19, serializer);
8999                <String>::sse_encode(err, serializer);
9000            }
9001            crate::error::PaymentError::SignerError { err } => {
9002                <i32>::sse_encode(20, serializer);
9003                <String>::sse_encode(err, serializer);
9004            }
9005            _ => {
9006                unimplemented!("");
9007            }
9008        }
9009    }
9010}
9011
9012impl SseEncode for crate::model::PaymentMethod {
9013    // Codec=Sse (Serialization based), see doc to use other codecs
9014    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9015        <i32>::sse_encode(
9016            match self {
9017                crate::model::PaymentMethod::Lightning => 0,
9018                crate::model::PaymentMethod::Bolt11Invoice => 1,
9019                crate::model::PaymentMethod::Bolt12Offer => 2,
9020                crate::model::PaymentMethod::BitcoinAddress => 3,
9021                crate::model::PaymentMethod::LiquidAddress => 4,
9022                _ => {
9023                    unimplemented!("");
9024                }
9025            },
9026            serializer,
9027        );
9028    }
9029}
9030
9031impl SseEncode for crate::model::PaymentState {
9032    // Codec=Sse (Serialization based), see doc to use other codecs
9033    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9034        <i32>::sse_encode(
9035            match self {
9036                crate::model::PaymentState::Created => 0,
9037                crate::model::PaymentState::Pending => 1,
9038                crate::model::PaymentState::Complete => 2,
9039                crate::model::PaymentState::Failed => 3,
9040                crate::model::PaymentState::TimedOut => 4,
9041                crate::model::PaymentState::Refundable => 5,
9042                crate::model::PaymentState::RefundPending => 6,
9043                crate::model::PaymentState::WaitingFeeAcceptance => 7,
9044                _ => {
9045                    unimplemented!("");
9046                }
9047            },
9048            serializer,
9049        );
9050    }
9051}
9052
9053impl SseEncode for crate::model::PaymentType {
9054    // Codec=Sse (Serialization based), see doc to use other codecs
9055    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9056        <i32>::sse_encode(
9057            match self {
9058                crate::model::PaymentType::Receive => 0,
9059                crate::model::PaymentType::Send => 1,
9060                _ => {
9061                    unimplemented!("");
9062                }
9063            },
9064            serializer,
9065        );
9066    }
9067}
9068
9069impl SseEncode for crate::model::PrepareBuyBitcoinRequest {
9070    // Codec=Sse (Serialization based), see doc to use other codecs
9071    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9072        <crate::model::BuyBitcoinProvider>::sse_encode(self.provider, serializer);
9073        <u64>::sse_encode(self.amount_sat, serializer);
9074    }
9075}
9076
9077impl SseEncode for crate::model::PrepareBuyBitcoinResponse {
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::model::BuyBitcoinProvider>::sse_encode(self.provider, serializer);
9081        <u64>::sse_encode(self.amount_sat, serializer);
9082        <u64>::sse_encode(self.fees_sat, serializer);
9083    }
9084}
9085
9086impl SseEncode for crate::model::PrepareLnUrlPayRequest {
9087    // Codec=Sse (Serialization based), see doc to use other codecs
9088    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9089        <crate::bindings::LnUrlPayRequestData>::sse_encode(self.data, serializer);
9090        <crate::model::PayAmount>::sse_encode(self.amount, serializer);
9091        <Option<String>>::sse_encode(self.bip353_address, serializer);
9092        <Option<String>>::sse_encode(self.comment, serializer);
9093        <Option<bool>>::sse_encode(self.validate_success_action_url, serializer);
9094    }
9095}
9096
9097impl SseEncode for crate::model::PrepareLnUrlPayResponse {
9098    // Codec=Sse (Serialization based), see doc to use other codecs
9099    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9100        <crate::model::SendDestination>::sse_encode(self.destination, serializer);
9101        <u64>::sse_encode(self.fees_sat, serializer);
9102        <crate::bindings::LnUrlPayRequestData>::sse_encode(self.data, serializer);
9103        <crate::model::PayAmount>::sse_encode(self.amount, serializer);
9104        <Option<String>>::sse_encode(self.comment, serializer);
9105        <Option<crate::bindings::SuccessAction>>::sse_encode(self.success_action, serializer);
9106    }
9107}
9108
9109impl SseEncode for crate::model::PreparePayOnchainRequest {
9110    // Codec=Sse (Serialization based), see doc to use other codecs
9111    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9112        <crate::model::PayAmount>::sse_encode(self.amount, serializer);
9113        <Option<u32>>::sse_encode(self.fee_rate_sat_per_vbyte, serializer);
9114    }
9115}
9116
9117impl SseEncode for crate::model::PreparePayOnchainResponse {
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        <u64>::sse_encode(self.receiver_amount_sat, serializer);
9121        <u64>::sse_encode(self.claim_fees_sat, serializer);
9122        <u64>::sse_encode(self.total_fees_sat, serializer);
9123    }
9124}
9125
9126impl SseEncode for crate::model::PrepareReceiveRequest {
9127    // Codec=Sse (Serialization based), see doc to use other codecs
9128    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9129        <crate::model::PaymentMethod>::sse_encode(self.payment_method, serializer);
9130        <Option<crate::model::ReceiveAmount>>::sse_encode(self.amount, serializer);
9131    }
9132}
9133
9134impl SseEncode for crate::model::PrepareReceiveResponse {
9135    // Codec=Sse (Serialization based), see doc to use other codecs
9136    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9137        <crate::model::PaymentMethod>::sse_encode(self.payment_method, serializer);
9138        <u64>::sse_encode(self.fees_sat, serializer);
9139        <Option<crate::model::ReceiveAmount>>::sse_encode(self.amount, serializer);
9140        <Option<u64>>::sse_encode(self.min_payer_amount_sat, serializer);
9141        <Option<u64>>::sse_encode(self.max_payer_amount_sat, serializer);
9142        <Option<f64>>::sse_encode(self.swapper_feerate, serializer);
9143    }
9144}
9145
9146impl SseEncode for crate::model::PrepareRefundRequest {
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        <String>::sse_encode(self.swap_address, serializer);
9150        <String>::sse_encode(self.refund_address, serializer);
9151        <u32>::sse_encode(self.fee_rate_sat_per_vbyte, serializer);
9152    }
9153}
9154
9155impl SseEncode for crate::model::PrepareRefundResponse {
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        <u32>::sse_encode(self.tx_vsize, serializer);
9159        <u64>::sse_encode(self.tx_fee_sat, serializer);
9160        <Option<String>>::sse_encode(self.last_refund_tx_id, serializer);
9161    }
9162}
9163
9164impl SseEncode for crate::model::PrepareSendRequest {
9165    // Codec=Sse (Serialization based), see doc to use other codecs
9166    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9167        <String>::sse_encode(self.destination, serializer);
9168        <Option<crate::model::PayAmount>>::sse_encode(self.amount, serializer);
9169        <Option<String>>::sse_encode(self.comment, serializer);
9170    }
9171}
9172
9173impl SseEncode for crate::model::PrepareSendResponse {
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        <crate::model::SendDestination>::sse_encode(self.destination, serializer);
9177        <Option<crate::model::PayAmount>>::sse_encode(self.amount, serializer);
9178        <Option<u64>>::sse_encode(self.fees_sat, serializer);
9179        <Option<f64>>::sse_encode(self.estimated_asset_fees, serializer);
9180    }
9181}
9182
9183impl SseEncode for crate::bindings::Rate {
9184    // Codec=Sse (Serialization based), see doc to use other codecs
9185    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9186        <String>::sse_encode(self.coin, serializer);
9187        <f64>::sse_encode(self.value, serializer);
9188    }
9189}
9190
9191impl SseEncode for crate::model::ReceiveAmount {
9192    // Codec=Sse (Serialization based), see doc to use other codecs
9193    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9194        match self {
9195            crate::model::ReceiveAmount::Bitcoin { payer_amount_sat } => {
9196                <i32>::sse_encode(0, serializer);
9197                <u64>::sse_encode(payer_amount_sat, serializer);
9198            }
9199            crate::model::ReceiveAmount::Asset {
9200                asset_id,
9201                payer_amount,
9202            } => {
9203                <i32>::sse_encode(1, serializer);
9204                <String>::sse_encode(asset_id, serializer);
9205                <Option<f64>>::sse_encode(payer_amount, serializer);
9206            }
9207            _ => {
9208                unimplemented!("");
9209            }
9210        }
9211    }
9212}
9213
9214impl SseEncode for crate::model::ReceivePaymentRequest {
9215    // Codec=Sse (Serialization based), see doc to use other codecs
9216    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9217        <crate::model::PrepareReceiveResponse>::sse_encode(self.prepare_response, serializer);
9218        <Option<String>>::sse_encode(self.description, serializer);
9219        <Option<bool>>::sse_encode(self.use_description_hash, serializer);
9220    }
9221}
9222
9223impl SseEncode for crate::model::ReceivePaymentResponse {
9224    // Codec=Sse (Serialization based), see doc to use other codecs
9225    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9226        <String>::sse_encode(self.destination, serializer);
9227    }
9228}
9229
9230impl SseEncode for crate::model::RecommendedFees {
9231    // Codec=Sse (Serialization based), see doc to use other codecs
9232    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9233        <u64>::sse_encode(self.fastest_fee, serializer);
9234        <u64>::sse_encode(self.half_hour_fee, serializer);
9235        <u64>::sse_encode(self.hour_fee, serializer);
9236        <u64>::sse_encode(self.economy_fee, serializer);
9237        <u64>::sse_encode(self.minimum_fee, serializer);
9238    }
9239}
9240
9241impl SseEncode for crate::model::RefundRequest {
9242    // Codec=Sse (Serialization based), see doc to use other codecs
9243    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9244        <String>::sse_encode(self.swap_address, serializer);
9245        <String>::sse_encode(self.refund_address, serializer);
9246        <u32>::sse_encode(self.fee_rate_sat_per_vbyte, serializer);
9247    }
9248}
9249
9250impl SseEncode for crate::model::RefundResponse {
9251    // Codec=Sse (Serialization based), see doc to use other codecs
9252    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9253        <String>::sse_encode(self.refund_tx_id, serializer);
9254    }
9255}
9256
9257impl SseEncode for crate::model::RefundableSwap {
9258    // Codec=Sse (Serialization based), see doc to use other codecs
9259    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9260        <String>::sse_encode(self.swap_address, serializer);
9261        <u32>::sse_encode(self.timestamp, serializer);
9262        <u64>::sse_encode(self.amount_sat, serializer);
9263        <Option<String>>::sse_encode(self.last_refund_tx_id, serializer);
9264    }
9265}
9266
9267impl SseEncode for crate::model::RestoreRequest {
9268    // Codec=Sse (Serialization based), see doc to use other codecs
9269    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9270        <Option<String>>::sse_encode(self.backup_path, serializer);
9271    }
9272}
9273
9274impl SseEncode for crate::bindings::RouteHint {
9275    // Codec=Sse (Serialization based), see doc to use other codecs
9276    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9277        <Vec<crate::bindings::RouteHintHop>>::sse_encode(self.hops, serializer);
9278    }
9279}
9280
9281impl SseEncode for crate::bindings::RouteHintHop {
9282    // Codec=Sse (Serialization based), see doc to use other codecs
9283    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9284        <String>::sse_encode(self.src_node_id, serializer);
9285        <String>::sse_encode(self.short_channel_id, serializer);
9286        <u32>::sse_encode(self.fees_base_msat, serializer);
9287        <u32>::sse_encode(self.fees_proportional_millionths, serializer);
9288        <u64>::sse_encode(self.cltv_expiry_delta, serializer);
9289        <Option<u64>>::sse_encode(self.htlc_minimum_msat, serializer);
9290        <Option<u64>>::sse_encode(self.htlc_maximum_msat, serializer);
9291    }
9292}
9293
9294impl SseEncode for crate::error::SdkError {
9295    // Codec=Sse (Serialization based), see doc to use other codecs
9296    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9297        match self {
9298            crate::error::SdkError::AlreadyStarted => {
9299                <i32>::sse_encode(0, serializer);
9300            }
9301            crate::error::SdkError::Generic { err } => {
9302                <i32>::sse_encode(1, serializer);
9303                <String>::sse_encode(err, serializer);
9304            }
9305            crate::error::SdkError::NotStarted => {
9306                <i32>::sse_encode(2, serializer);
9307            }
9308            crate::error::SdkError::ServiceConnectivity { err } => {
9309                <i32>::sse_encode(3, serializer);
9310                <String>::sse_encode(err, serializer);
9311            }
9312            _ => {
9313                unimplemented!("");
9314            }
9315        }
9316    }
9317}
9318
9319impl SseEncode for crate::model::SdkEvent {
9320    // Codec=Sse (Serialization based), see doc to use other codecs
9321    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9322        match self {
9323            crate::model::SdkEvent::PaymentFailed { details } => {
9324                <i32>::sse_encode(0, serializer);
9325                <crate::model::Payment>::sse_encode(details, serializer);
9326            }
9327            crate::model::SdkEvent::PaymentPending { details } => {
9328                <i32>::sse_encode(1, serializer);
9329                <crate::model::Payment>::sse_encode(details, serializer);
9330            }
9331            crate::model::SdkEvent::PaymentRefundable { details } => {
9332                <i32>::sse_encode(2, serializer);
9333                <crate::model::Payment>::sse_encode(details, serializer);
9334            }
9335            crate::model::SdkEvent::PaymentRefunded { details } => {
9336                <i32>::sse_encode(3, serializer);
9337                <crate::model::Payment>::sse_encode(details, serializer);
9338            }
9339            crate::model::SdkEvent::PaymentRefundPending { details } => {
9340                <i32>::sse_encode(4, serializer);
9341                <crate::model::Payment>::sse_encode(details, serializer);
9342            }
9343            crate::model::SdkEvent::PaymentSucceeded { details } => {
9344                <i32>::sse_encode(5, serializer);
9345                <crate::model::Payment>::sse_encode(details, serializer);
9346            }
9347            crate::model::SdkEvent::PaymentWaitingConfirmation { details } => {
9348                <i32>::sse_encode(6, serializer);
9349                <crate::model::Payment>::sse_encode(details, serializer);
9350            }
9351            crate::model::SdkEvent::PaymentWaitingFeeAcceptance { details } => {
9352                <i32>::sse_encode(7, serializer);
9353                <crate::model::Payment>::sse_encode(details, serializer);
9354            }
9355            crate::model::SdkEvent::Synced => {
9356                <i32>::sse_encode(8, serializer);
9357            }
9358            crate::model::SdkEvent::DataSynced {
9359                did_pull_new_records,
9360            } => {
9361                <i32>::sse_encode(9, serializer);
9362                <bool>::sse_encode(did_pull_new_records, serializer);
9363            }
9364            _ => {
9365                unimplemented!("");
9366            }
9367        }
9368    }
9369}
9370
9371impl SseEncode for crate::model::SendDestination {
9372    // Codec=Sse (Serialization based), see doc to use other codecs
9373    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9374        match self {
9375            crate::model::SendDestination::LiquidAddress {
9376                address_data,
9377                bip353_address,
9378            } => {
9379                <i32>::sse_encode(0, serializer);
9380                <crate::bindings::LiquidAddressData>::sse_encode(address_data, serializer);
9381                <Option<String>>::sse_encode(bip353_address, serializer);
9382            }
9383            crate::model::SendDestination::Bolt11 {
9384                invoice,
9385                bip353_address,
9386            } => {
9387                <i32>::sse_encode(1, serializer);
9388                <crate::bindings::LNInvoice>::sse_encode(invoice, serializer);
9389                <Option<String>>::sse_encode(bip353_address, serializer);
9390            }
9391            crate::model::SendDestination::Bolt12 {
9392                offer,
9393                receiver_amount_sat,
9394                bip353_address,
9395                payer_note,
9396            } => {
9397                <i32>::sse_encode(2, serializer);
9398                <crate::bindings::LNOffer>::sse_encode(offer, serializer);
9399                <u64>::sse_encode(receiver_amount_sat, serializer);
9400                <Option<String>>::sse_encode(bip353_address, serializer);
9401                <Option<String>>::sse_encode(payer_note, serializer);
9402            }
9403            _ => {
9404                unimplemented!("");
9405            }
9406        }
9407    }
9408}
9409
9410impl SseEncode for crate::model::SendPaymentRequest {
9411    // Codec=Sse (Serialization based), see doc to use other codecs
9412    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9413        <crate::model::PrepareSendResponse>::sse_encode(self.prepare_response, serializer);
9414        <Option<bool>>::sse_encode(self.use_asset_fees, serializer);
9415    }
9416}
9417
9418impl SseEncode for crate::model::SendPaymentResponse {
9419    // Codec=Sse (Serialization based), see doc to use other codecs
9420    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9421        <crate::model::Payment>::sse_encode(self.payment, serializer);
9422    }
9423}
9424
9425impl SseEncode for crate::model::SignMessageRequest {
9426    // Codec=Sse (Serialization based), see doc to use other codecs
9427    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9428        <String>::sse_encode(self.message, serializer);
9429    }
9430}
9431
9432impl SseEncode for crate::model::SignMessageResponse {
9433    // Codec=Sse (Serialization based), see doc to use other codecs
9434    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9435        <String>::sse_encode(self.signature, serializer);
9436    }
9437}
9438
9439impl SseEncode for crate::bindings::SuccessAction {
9440    // Codec=Sse (Serialization based), see doc to use other codecs
9441    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9442        match self {
9443            crate::bindings::SuccessAction::Aes { data } => {
9444                <i32>::sse_encode(0, serializer);
9445                <crate::bindings::AesSuccessActionData>::sse_encode(data, serializer);
9446            }
9447            crate::bindings::SuccessAction::Message { data } => {
9448                <i32>::sse_encode(1, serializer);
9449                <crate::bindings::MessageSuccessActionData>::sse_encode(data, serializer);
9450            }
9451            crate::bindings::SuccessAction::Url { data } => {
9452                <i32>::sse_encode(2, serializer);
9453                <crate::bindings::UrlSuccessActionData>::sse_encode(data, serializer);
9454            }
9455            _ => {
9456                unimplemented!("");
9457            }
9458        }
9459    }
9460}
9461
9462impl SseEncode for crate::bindings::SuccessActionProcessed {
9463    // Codec=Sse (Serialization based), see doc to use other codecs
9464    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9465        match self {
9466            crate::bindings::SuccessActionProcessed::Aes { result } => {
9467                <i32>::sse_encode(0, serializer);
9468                <crate::bindings::AesSuccessActionDataResult>::sse_encode(result, serializer);
9469            }
9470            crate::bindings::SuccessActionProcessed::Message { data } => {
9471                <i32>::sse_encode(1, serializer);
9472                <crate::bindings::MessageSuccessActionData>::sse_encode(data, serializer);
9473            }
9474            crate::bindings::SuccessActionProcessed::Url { data } => {
9475                <i32>::sse_encode(2, serializer);
9476                <crate::bindings::UrlSuccessActionData>::sse_encode(data, serializer);
9477            }
9478            _ => {
9479                unimplemented!("");
9480            }
9481        }
9482    }
9483}
9484
9485impl SseEncode for crate::bindings::Symbol {
9486    // Codec=Sse (Serialization based), see doc to use other codecs
9487    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9488        <Option<String>>::sse_encode(self.grapheme, serializer);
9489        <Option<String>>::sse_encode(self.template, serializer);
9490        <Option<bool>>::sse_encode(self.rtl, serializer);
9491        <Option<u32>>::sse_encode(self.position, serializer);
9492    }
9493}
9494
9495impl SseEncode for u16 {
9496    // Codec=Sse (Serialization based), see doc to use other codecs
9497    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9498        serializer.cursor.write_u16::<NativeEndian>(self).unwrap();
9499    }
9500}
9501
9502impl SseEncode for u32 {
9503    // Codec=Sse (Serialization based), see doc to use other codecs
9504    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9505        serializer.cursor.write_u32::<NativeEndian>(self).unwrap();
9506    }
9507}
9508
9509impl SseEncode for u64 {
9510    // Codec=Sse (Serialization based), see doc to use other codecs
9511    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9512        serializer.cursor.write_u64::<NativeEndian>(self).unwrap();
9513    }
9514}
9515
9516impl SseEncode for u8 {
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        serializer.cursor.write_u8(self).unwrap();
9520    }
9521}
9522
9523impl SseEncode for () {
9524    // Codec=Sse (Serialization based), see doc to use other codecs
9525    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {}
9526}
9527
9528impl SseEncode for crate::bindings::UrlSuccessActionData {
9529    // Codec=Sse (Serialization based), see doc to use other codecs
9530    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9531        <String>::sse_encode(self.description, serializer);
9532        <String>::sse_encode(self.url, serializer);
9533        <bool>::sse_encode(self.matches_callback_domain, serializer);
9534    }
9535}
9536
9537impl SseEncode for usize {
9538    // Codec=Sse (Serialization based), see doc to use other codecs
9539    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9540        serializer
9541            .cursor
9542            .write_u64::<NativeEndian>(self as _)
9543            .unwrap();
9544    }
9545}
9546
9547impl SseEncode for crate::model::WalletInfo {
9548    // Codec=Sse (Serialization based), see doc to use other codecs
9549    fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
9550        <u64>::sse_encode(self.balance_sat, serializer);
9551        <u64>::sse_encode(self.pending_send_sat, serializer);
9552        <u64>::sse_encode(self.pending_receive_sat, serializer);
9553        <String>::sse_encode(self.fingerprint, serializer);
9554        <String>::sse_encode(self.pubkey, serializer);
9555        <Vec<crate::model::AssetBalance>>::sse_encode(self.asset_balances, serializer);
9556    }
9557}
9558
9559#[cfg(not(target_family = "wasm"))]
9560mod io {
9561    // This file is automatically generated, so please do not edit it.
9562    // @generated by `flutter_rust_bridge`@ 2.9.0.
9563
9564    // Section: imports
9565
9566    use super::*;
9567    use crate::bindings::*;
9568    use crate::model::EventListener;
9569    use flutter_rust_bridge::for_generated::byteorder::{
9570        NativeEndian, ReadBytesExt, WriteBytesExt,
9571    };
9572    use flutter_rust_bridge::for_generated::{transform_result_dco, Lifetimeable, Lockable};
9573    use flutter_rust_bridge::{Handler, IntoIntoDart};
9574
9575    // Section: boilerplate
9576
9577    flutter_rust_bridge::frb_generated_boilerplate_io!();
9578
9579    // Section: dart2rust
9580
9581    impl CstDecode<flutter_rust_bridge::for_generated::anyhow::Error>
9582        for *mut wire_cst_list_prim_u_8_strict
9583    {
9584        // Codec=Cst (C-struct based), see doc to use other codecs
9585        fn cst_decode(self) -> flutter_rust_bridge::for_generated::anyhow::Error {
9586            unimplemented!()
9587        }
9588    }
9589    impl CstDecode<BindingLiquidSdk> for usize {
9590        // Codec=Cst (C-struct based), see doc to use other codecs
9591        fn cst_decode(self) -> BindingLiquidSdk {
9592            flutter_rust_bridge::for_generated::rust_auto_opaque_decode_owned(CstDecode::<
9593                RustOpaqueNom<
9594                    flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>,
9595                >,
9596            >::cst_decode(
9597                self
9598            ))
9599        }
9600    }
9601    impl
9602        CstDecode<
9603            RustOpaqueNom<
9604                flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>,
9605            >,
9606        > for usize
9607    {
9608        // Codec=Cst (C-struct based), see doc to use other codecs
9609        fn cst_decode(
9610            self,
9611        ) -> RustOpaqueNom<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>
9612        {
9613            unsafe { decode_rust_opaque_nom(self as _) }
9614        }
9615    }
9616    impl CstDecode<StreamSink<crate::model::LogEntry, 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::LogEntry, flutter_rust_bridge::for_generated::DcoCodec>
9623        {
9624            let raw: String = self.cst_decode();
9625            StreamSink::deserialize(raw)
9626        }
9627    }
9628    impl CstDecode<StreamSink<crate::model::SdkEvent, flutter_rust_bridge::for_generated::DcoCodec>>
9629        for *mut wire_cst_list_prim_u_8_strict
9630    {
9631        // Codec=Cst (C-struct based), see doc to use other codecs
9632        fn cst_decode(
9633            self,
9634        ) -> StreamSink<crate::model::SdkEvent, flutter_rust_bridge::for_generated::DcoCodec>
9635        {
9636            let raw: String = self.cst_decode();
9637            StreamSink::deserialize(raw)
9638        }
9639    }
9640    impl CstDecode<String> for *mut wire_cst_list_prim_u_8_strict {
9641        // Codec=Cst (C-struct based), see doc to use other codecs
9642        fn cst_decode(self) -> String {
9643            let vec: Vec<u8> = self.cst_decode();
9644            String::from_utf8(vec).unwrap()
9645        }
9646    }
9647    impl CstDecode<crate::model::AcceptPaymentProposedFeesRequest>
9648        for wire_cst_accept_payment_proposed_fees_request
9649    {
9650        // Codec=Cst (C-struct based), see doc to use other codecs
9651        fn cst_decode(self) -> crate::model::AcceptPaymentProposedFeesRequest {
9652            crate::model::AcceptPaymentProposedFeesRequest {
9653                response: self.response.cst_decode(),
9654            }
9655        }
9656    }
9657    impl CstDecode<crate::bindings::AesSuccessActionData> for wire_cst_aes_success_action_data {
9658        // Codec=Cst (C-struct based), see doc to use other codecs
9659        fn cst_decode(self) -> crate::bindings::AesSuccessActionData {
9660            crate::bindings::AesSuccessActionData {
9661                description: self.description.cst_decode(),
9662                ciphertext: self.ciphertext.cst_decode(),
9663                iv: self.iv.cst_decode(),
9664            }
9665        }
9666    }
9667    impl CstDecode<crate::bindings::AesSuccessActionDataDecrypted>
9668        for wire_cst_aes_success_action_data_decrypted
9669    {
9670        // Codec=Cst (C-struct based), see doc to use other codecs
9671        fn cst_decode(self) -> crate::bindings::AesSuccessActionDataDecrypted {
9672            crate::bindings::AesSuccessActionDataDecrypted {
9673                description: self.description.cst_decode(),
9674                plaintext: self.plaintext.cst_decode(),
9675            }
9676        }
9677    }
9678    impl CstDecode<crate::bindings::AesSuccessActionDataResult>
9679        for wire_cst_aes_success_action_data_result
9680    {
9681        // Codec=Cst (C-struct based), see doc to use other codecs
9682        fn cst_decode(self) -> crate::bindings::AesSuccessActionDataResult {
9683            match self.tag {
9684                0 => {
9685                    let ans = unsafe { self.kind.Decrypted };
9686                    crate::bindings::AesSuccessActionDataResult::Decrypted {
9687                        data: ans.data.cst_decode(),
9688                    }
9689                }
9690                1 => {
9691                    let ans = unsafe { self.kind.ErrorStatus };
9692                    crate::bindings::AesSuccessActionDataResult::ErrorStatus {
9693                        reason: ans.reason.cst_decode(),
9694                    }
9695                }
9696                _ => unreachable!(),
9697            }
9698        }
9699    }
9700    impl CstDecode<crate::bindings::Amount> for wire_cst_amount {
9701        // Codec=Cst (C-struct based), see doc to use other codecs
9702        fn cst_decode(self) -> crate::bindings::Amount {
9703            match self.tag {
9704                0 => {
9705                    let ans = unsafe { self.kind.Bitcoin };
9706                    crate::bindings::Amount::Bitcoin {
9707                        amount_msat: ans.amount_msat.cst_decode(),
9708                    }
9709                }
9710                1 => {
9711                    let ans = unsafe { self.kind.Currency };
9712                    crate::bindings::Amount::Currency {
9713                        iso4217_code: ans.iso4217_code.cst_decode(),
9714                        fractional_amount: ans.fractional_amount.cst_decode(),
9715                    }
9716                }
9717                _ => unreachable!(),
9718            }
9719        }
9720    }
9721    impl CstDecode<crate::model::AssetBalance> for wire_cst_asset_balance {
9722        // Codec=Cst (C-struct based), see doc to use other codecs
9723        fn cst_decode(self) -> crate::model::AssetBalance {
9724            crate::model::AssetBalance {
9725                asset_id: self.asset_id.cst_decode(),
9726                balance_sat: self.balance_sat.cst_decode(),
9727                name: self.name.cst_decode(),
9728                ticker: self.ticker.cst_decode(),
9729                balance: self.balance.cst_decode(),
9730            }
9731        }
9732    }
9733    impl CstDecode<crate::model::AssetInfo> for wire_cst_asset_info {
9734        // Codec=Cst (C-struct based), see doc to use other codecs
9735        fn cst_decode(self) -> crate::model::AssetInfo {
9736            crate::model::AssetInfo {
9737                name: self.name.cst_decode(),
9738                ticker: self.ticker.cst_decode(),
9739                amount: self.amount.cst_decode(),
9740                fees: self.fees.cst_decode(),
9741            }
9742        }
9743    }
9744    impl CstDecode<crate::model::AssetMetadata> for wire_cst_asset_metadata {
9745        // Codec=Cst (C-struct based), see doc to use other codecs
9746        fn cst_decode(self) -> crate::model::AssetMetadata {
9747            crate::model::AssetMetadata {
9748                asset_id: self.asset_id.cst_decode(),
9749                name: self.name.cst_decode(),
9750                ticker: self.ticker.cst_decode(),
9751                precision: self.precision.cst_decode(),
9752                fiat_id: self.fiat_id.cst_decode(),
9753            }
9754        }
9755    }
9756    impl CstDecode<crate::model::BackupRequest> for wire_cst_backup_request {
9757        // Codec=Cst (C-struct based), see doc to use other codecs
9758        fn cst_decode(self) -> crate::model::BackupRequest {
9759            crate::model::BackupRequest {
9760                backup_path: self.backup_path.cst_decode(),
9761            }
9762        }
9763    }
9764    impl CstDecode<crate::bindings::BindingEventListener> for wire_cst_binding_event_listener {
9765        // Codec=Cst (C-struct based), see doc to use other codecs
9766        fn cst_decode(self) -> crate::bindings::BindingEventListener {
9767            crate::bindings::BindingEventListener {
9768                stream: self.stream.cst_decode(),
9769            }
9770        }
9771    }
9772    impl CstDecode<crate::bindings::BitcoinAddressData> for wire_cst_bitcoin_address_data {
9773        // Codec=Cst (C-struct based), see doc to use other codecs
9774        fn cst_decode(self) -> crate::bindings::BitcoinAddressData {
9775            crate::bindings::BitcoinAddressData {
9776                address: self.address.cst_decode(),
9777                network: self.network.cst_decode(),
9778                amount_sat: self.amount_sat.cst_decode(),
9779                label: self.label.cst_decode(),
9780                message: self.message.cst_decode(),
9781            }
9782        }
9783    }
9784    impl CstDecode<crate::model::BlockchainExplorer> for wire_cst_blockchain_explorer {
9785        // Codec=Cst (C-struct based), see doc to use other codecs
9786        fn cst_decode(self) -> crate::model::BlockchainExplorer {
9787            match self.tag {
9788                0 => {
9789                    let ans = unsafe { self.kind.Electrum };
9790                    crate::model::BlockchainExplorer::Electrum {
9791                        url: ans.url.cst_decode(),
9792                    }
9793                }
9794                1 => {
9795                    let ans = unsafe { self.kind.Esplora };
9796                    crate::model::BlockchainExplorer::Esplora {
9797                        url: ans.url.cst_decode(),
9798                        use_waterfalls: ans.use_waterfalls.cst_decode(),
9799                    }
9800                }
9801                _ => unreachable!(),
9802            }
9803        }
9804    }
9805    impl CstDecode<crate::model::BlockchainInfo> for wire_cst_blockchain_info {
9806        // Codec=Cst (C-struct based), see doc to use other codecs
9807        fn cst_decode(self) -> crate::model::BlockchainInfo {
9808            crate::model::BlockchainInfo {
9809                liquid_tip: self.liquid_tip.cst_decode(),
9810                bitcoin_tip: self.bitcoin_tip.cst_decode(),
9811            }
9812        }
9813    }
9814    impl CstDecode<crate::model::AcceptPaymentProposedFeesRequest>
9815        for *mut wire_cst_accept_payment_proposed_fees_request
9816    {
9817        // Codec=Cst (C-struct based), see doc to use other codecs
9818        fn cst_decode(self) -> crate::model::AcceptPaymentProposedFeesRequest {
9819            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9820            CstDecode::<crate::model::AcceptPaymentProposedFeesRequest>::cst_decode(*wrap).into()
9821        }
9822    }
9823    impl CstDecode<crate::bindings::AesSuccessActionData> for *mut wire_cst_aes_success_action_data {
9824        // Codec=Cst (C-struct based), see doc to use other codecs
9825        fn cst_decode(self) -> crate::bindings::AesSuccessActionData {
9826            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9827            CstDecode::<crate::bindings::AesSuccessActionData>::cst_decode(*wrap).into()
9828        }
9829    }
9830    impl CstDecode<crate::bindings::AesSuccessActionDataDecrypted>
9831        for *mut wire_cst_aes_success_action_data_decrypted
9832    {
9833        // Codec=Cst (C-struct based), see doc to use other codecs
9834        fn cst_decode(self) -> crate::bindings::AesSuccessActionDataDecrypted {
9835            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9836            CstDecode::<crate::bindings::AesSuccessActionDataDecrypted>::cst_decode(*wrap).into()
9837        }
9838    }
9839    impl CstDecode<crate::bindings::AesSuccessActionDataResult>
9840        for *mut wire_cst_aes_success_action_data_result
9841    {
9842        // Codec=Cst (C-struct based), see doc to use other codecs
9843        fn cst_decode(self) -> crate::bindings::AesSuccessActionDataResult {
9844            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9845            CstDecode::<crate::bindings::AesSuccessActionDataResult>::cst_decode(*wrap).into()
9846        }
9847    }
9848    impl CstDecode<crate::bindings::Amount> for *mut wire_cst_amount {
9849        // Codec=Cst (C-struct based), see doc to use other codecs
9850        fn cst_decode(self) -> crate::bindings::Amount {
9851            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9852            CstDecode::<crate::bindings::Amount>::cst_decode(*wrap).into()
9853        }
9854    }
9855    impl CstDecode<crate::model::AssetInfo> for *mut wire_cst_asset_info {
9856        // Codec=Cst (C-struct based), see doc to use other codecs
9857        fn cst_decode(self) -> crate::model::AssetInfo {
9858            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9859            CstDecode::<crate::model::AssetInfo>::cst_decode(*wrap).into()
9860        }
9861    }
9862    impl CstDecode<crate::model::BackupRequest> for *mut wire_cst_backup_request {
9863        // Codec=Cst (C-struct based), see doc to use other codecs
9864        fn cst_decode(self) -> crate::model::BackupRequest {
9865            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9866            CstDecode::<crate::model::BackupRequest>::cst_decode(*wrap).into()
9867        }
9868    }
9869    impl CstDecode<crate::bindings::BindingEventListener> for *mut wire_cst_binding_event_listener {
9870        // Codec=Cst (C-struct based), see doc to use other codecs
9871        fn cst_decode(self) -> crate::bindings::BindingEventListener {
9872            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9873            CstDecode::<crate::bindings::BindingEventListener>::cst_decode(*wrap).into()
9874        }
9875    }
9876    impl CstDecode<crate::bindings::BitcoinAddressData> for *mut wire_cst_bitcoin_address_data {
9877        // Codec=Cst (C-struct based), see doc to use other codecs
9878        fn cst_decode(self) -> crate::bindings::BitcoinAddressData {
9879            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9880            CstDecode::<crate::bindings::BitcoinAddressData>::cst_decode(*wrap).into()
9881        }
9882    }
9883    impl CstDecode<bool> for *mut bool {
9884        // Codec=Cst (C-struct based), see doc to use other codecs
9885        fn cst_decode(self) -> bool {
9886            unsafe { *flutter_rust_bridge::for_generated::box_from_leak_ptr(self) }
9887        }
9888    }
9889    impl CstDecode<crate::model::BuyBitcoinRequest> for *mut wire_cst_buy_bitcoin_request {
9890        // Codec=Cst (C-struct based), see doc to use other codecs
9891        fn cst_decode(self) -> crate::model::BuyBitcoinRequest {
9892            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9893            CstDecode::<crate::model::BuyBitcoinRequest>::cst_decode(*wrap).into()
9894        }
9895    }
9896    impl CstDecode<crate::model::CheckMessageRequest> for *mut wire_cst_check_message_request {
9897        // Codec=Cst (C-struct based), see doc to use other codecs
9898        fn cst_decode(self) -> crate::model::CheckMessageRequest {
9899            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9900            CstDecode::<crate::model::CheckMessageRequest>::cst_decode(*wrap).into()
9901        }
9902    }
9903    impl CstDecode<crate::model::ConnectRequest> for *mut wire_cst_connect_request {
9904        // Codec=Cst (C-struct based), see doc to use other codecs
9905        fn cst_decode(self) -> crate::model::ConnectRequest {
9906            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9907            CstDecode::<crate::model::ConnectRequest>::cst_decode(*wrap).into()
9908        }
9909    }
9910    impl CstDecode<crate::model::CreateBolt12InvoiceRequest>
9911        for *mut wire_cst_create_bolt_12_invoice_request
9912    {
9913        // Codec=Cst (C-struct based), see doc to use other codecs
9914        fn cst_decode(self) -> crate::model::CreateBolt12InvoiceRequest {
9915            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9916            CstDecode::<crate::model::CreateBolt12InvoiceRequest>::cst_decode(*wrap).into()
9917        }
9918    }
9919    impl CstDecode<f64> for *mut f64 {
9920        // Codec=Cst (C-struct based), see doc to use other codecs
9921        fn cst_decode(self) -> f64 {
9922            unsafe { *flutter_rust_bridge::for_generated::box_from_leak_ptr(self) }
9923        }
9924    }
9925    impl CstDecode<crate::model::FetchPaymentProposedFeesRequest>
9926        for *mut wire_cst_fetch_payment_proposed_fees_request
9927    {
9928        // Codec=Cst (C-struct based), see doc to use other codecs
9929        fn cst_decode(self) -> crate::model::FetchPaymentProposedFeesRequest {
9930            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9931            CstDecode::<crate::model::FetchPaymentProposedFeesRequest>::cst_decode(*wrap).into()
9932        }
9933    }
9934    impl CstDecode<crate::model::GetPaymentRequest> for *mut wire_cst_get_payment_request {
9935        // Codec=Cst (C-struct based), see doc to use other codecs
9936        fn cst_decode(self) -> crate::model::GetPaymentRequest {
9937            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9938            CstDecode::<crate::model::GetPaymentRequest>::cst_decode(*wrap).into()
9939        }
9940    }
9941    impl CstDecode<i64> for *mut i64 {
9942        // Codec=Cst (C-struct based), see doc to use other codecs
9943        fn cst_decode(self) -> i64 {
9944            unsafe { *flutter_rust_bridge::for_generated::box_from_leak_ptr(self) }
9945        }
9946    }
9947    impl CstDecode<crate::bindings::LiquidAddressData> for *mut wire_cst_liquid_address_data {
9948        // Codec=Cst (C-struct based), see doc to use other codecs
9949        fn cst_decode(self) -> crate::bindings::LiquidAddressData {
9950            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9951            CstDecode::<crate::bindings::LiquidAddressData>::cst_decode(*wrap).into()
9952        }
9953    }
9954    impl CstDecode<crate::model::ListPaymentDetails> for *mut wire_cst_list_payment_details {
9955        // Codec=Cst (C-struct based), see doc to use other codecs
9956        fn cst_decode(self) -> crate::model::ListPaymentDetails {
9957            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9958            CstDecode::<crate::model::ListPaymentDetails>::cst_decode(*wrap).into()
9959        }
9960    }
9961    impl CstDecode<crate::model::ListPaymentsRequest> for *mut wire_cst_list_payments_request {
9962        // Codec=Cst (C-struct based), see doc to use other codecs
9963        fn cst_decode(self) -> crate::model::ListPaymentsRequest {
9964            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9965            CstDecode::<crate::model::ListPaymentsRequest>::cst_decode(*wrap).into()
9966        }
9967    }
9968    impl CstDecode<crate::bindings::LNInvoice> for *mut wire_cst_ln_invoice {
9969        // Codec=Cst (C-struct based), see doc to use other codecs
9970        fn cst_decode(self) -> crate::bindings::LNInvoice {
9971            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9972            CstDecode::<crate::bindings::LNInvoice>::cst_decode(*wrap).into()
9973        }
9974    }
9975    impl CstDecode<crate::bindings::LNOffer> for *mut wire_cst_ln_offer {
9976        // Codec=Cst (C-struct based), see doc to use other codecs
9977        fn cst_decode(self) -> crate::bindings::LNOffer {
9978            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9979            CstDecode::<crate::bindings::LNOffer>::cst_decode(*wrap).into()
9980        }
9981    }
9982    impl CstDecode<crate::bindings::LnUrlAuthRequestData> for *mut wire_cst_ln_url_auth_request_data {
9983        // Codec=Cst (C-struct based), see doc to use other codecs
9984        fn cst_decode(self) -> crate::bindings::LnUrlAuthRequestData {
9985            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9986            CstDecode::<crate::bindings::LnUrlAuthRequestData>::cst_decode(*wrap).into()
9987        }
9988    }
9989    impl CstDecode<crate::bindings::LnUrlErrorData> for *mut wire_cst_ln_url_error_data {
9990        // Codec=Cst (C-struct based), see doc to use other codecs
9991        fn cst_decode(self) -> crate::bindings::LnUrlErrorData {
9992            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
9993            CstDecode::<crate::bindings::LnUrlErrorData>::cst_decode(*wrap).into()
9994        }
9995    }
9996    impl CstDecode<crate::model::LnUrlInfo> for *mut wire_cst_ln_url_info {
9997        // Codec=Cst (C-struct based), see doc to use other codecs
9998        fn cst_decode(self) -> crate::model::LnUrlInfo {
9999            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10000            CstDecode::<crate::model::LnUrlInfo>::cst_decode(*wrap).into()
10001        }
10002    }
10003    impl CstDecode<crate::bindings::LnUrlPayErrorData> for *mut wire_cst_ln_url_pay_error_data {
10004        // Codec=Cst (C-struct based), see doc to use other codecs
10005        fn cst_decode(self) -> crate::bindings::LnUrlPayErrorData {
10006            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10007            CstDecode::<crate::bindings::LnUrlPayErrorData>::cst_decode(*wrap).into()
10008        }
10009    }
10010    impl CstDecode<crate::model::LnUrlPayRequest> for *mut wire_cst_ln_url_pay_request {
10011        // Codec=Cst (C-struct based), see doc to use other codecs
10012        fn cst_decode(self) -> crate::model::LnUrlPayRequest {
10013            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10014            CstDecode::<crate::model::LnUrlPayRequest>::cst_decode(*wrap).into()
10015        }
10016    }
10017    impl CstDecode<crate::bindings::LnUrlPayRequestData> for *mut wire_cst_ln_url_pay_request_data {
10018        // Codec=Cst (C-struct based), see doc to use other codecs
10019        fn cst_decode(self) -> crate::bindings::LnUrlPayRequestData {
10020            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10021            CstDecode::<crate::bindings::LnUrlPayRequestData>::cst_decode(*wrap).into()
10022        }
10023    }
10024    impl CstDecode<crate::model::LnUrlPaySuccessData> for *mut wire_cst_ln_url_pay_success_data {
10025        // Codec=Cst (C-struct based), see doc to use other codecs
10026        fn cst_decode(self) -> crate::model::LnUrlPaySuccessData {
10027            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10028            CstDecode::<crate::model::LnUrlPaySuccessData>::cst_decode(*wrap).into()
10029        }
10030    }
10031    impl CstDecode<crate::bindings::LnUrlWithdrawRequest> for *mut wire_cst_ln_url_withdraw_request {
10032        // Codec=Cst (C-struct based), see doc to use other codecs
10033        fn cst_decode(self) -> crate::bindings::LnUrlWithdrawRequest {
10034            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10035            CstDecode::<crate::bindings::LnUrlWithdrawRequest>::cst_decode(*wrap).into()
10036        }
10037    }
10038    impl CstDecode<crate::bindings::LnUrlWithdrawRequestData>
10039        for *mut wire_cst_ln_url_withdraw_request_data
10040    {
10041        // Codec=Cst (C-struct based), see doc to use other codecs
10042        fn cst_decode(self) -> crate::bindings::LnUrlWithdrawRequestData {
10043            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10044            CstDecode::<crate::bindings::LnUrlWithdrawRequestData>::cst_decode(*wrap).into()
10045        }
10046    }
10047    impl CstDecode<crate::bindings::duplicates::LnUrlWithdrawSuccessData>
10048        for *mut wire_cst_ln_url_withdraw_success_data
10049    {
10050        // Codec=Cst (C-struct based), see doc to use other codecs
10051        fn cst_decode(self) -> crate::bindings::duplicates::LnUrlWithdrawSuccessData {
10052            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10053            CstDecode::<crate::bindings::duplicates::LnUrlWithdrawSuccessData>::cst_decode(*wrap)
10054                .into()
10055        }
10056    }
10057    impl CstDecode<crate::bindings::MessageSuccessActionData>
10058        for *mut wire_cst_message_success_action_data
10059    {
10060        // Codec=Cst (C-struct based), see doc to use other codecs
10061        fn cst_decode(self) -> crate::bindings::MessageSuccessActionData {
10062            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10063            CstDecode::<crate::bindings::MessageSuccessActionData>::cst_decode(*wrap).into()
10064        }
10065    }
10066    impl CstDecode<crate::model::PayAmount> for *mut wire_cst_pay_amount {
10067        // Codec=Cst (C-struct based), see doc to use other codecs
10068        fn cst_decode(self) -> crate::model::PayAmount {
10069            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10070            CstDecode::<crate::model::PayAmount>::cst_decode(*wrap).into()
10071        }
10072    }
10073    impl CstDecode<crate::model::PayOnchainRequest> for *mut wire_cst_pay_onchain_request {
10074        // Codec=Cst (C-struct based), see doc to use other codecs
10075        fn cst_decode(self) -> crate::model::PayOnchainRequest {
10076            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10077            CstDecode::<crate::model::PayOnchainRequest>::cst_decode(*wrap).into()
10078        }
10079    }
10080    impl CstDecode<crate::model::Payment> for *mut wire_cst_payment {
10081        // Codec=Cst (C-struct based), see doc to use other codecs
10082        fn cst_decode(self) -> crate::model::Payment {
10083            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10084            CstDecode::<crate::model::Payment>::cst_decode(*wrap).into()
10085        }
10086    }
10087    impl CstDecode<crate::model::PrepareBuyBitcoinRequest>
10088        for *mut wire_cst_prepare_buy_bitcoin_request
10089    {
10090        // Codec=Cst (C-struct based), see doc to use other codecs
10091        fn cst_decode(self) -> crate::model::PrepareBuyBitcoinRequest {
10092            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10093            CstDecode::<crate::model::PrepareBuyBitcoinRequest>::cst_decode(*wrap).into()
10094        }
10095    }
10096    impl CstDecode<crate::model::PrepareLnUrlPayRequest> for *mut wire_cst_prepare_ln_url_pay_request {
10097        // Codec=Cst (C-struct based), see doc to use other codecs
10098        fn cst_decode(self) -> crate::model::PrepareLnUrlPayRequest {
10099            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10100            CstDecode::<crate::model::PrepareLnUrlPayRequest>::cst_decode(*wrap).into()
10101        }
10102    }
10103    impl CstDecode<crate::model::PreparePayOnchainRequest>
10104        for *mut wire_cst_prepare_pay_onchain_request
10105    {
10106        // Codec=Cst (C-struct based), see doc to use other codecs
10107        fn cst_decode(self) -> crate::model::PreparePayOnchainRequest {
10108            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10109            CstDecode::<crate::model::PreparePayOnchainRequest>::cst_decode(*wrap).into()
10110        }
10111    }
10112    impl CstDecode<crate::model::PrepareReceiveRequest> for *mut wire_cst_prepare_receive_request {
10113        // Codec=Cst (C-struct based), see doc to use other codecs
10114        fn cst_decode(self) -> crate::model::PrepareReceiveRequest {
10115            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10116            CstDecode::<crate::model::PrepareReceiveRequest>::cst_decode(*wrap).into()
10117        }
10118    }
10119    impl CstDecode<crate::model::PrepareRefundRequest> for *mut wire_cst_prepare_refund_request {
10120        // Codec=Cst (C-struct based), see doc to use other codecs
10121        fn cst_decode(self) -> crate::model::PrepareRefundRequest {
10122            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10123            CstDecode::<crate::model::PrepareRefundRequest>::cst_decode(*wrap).into()
10124        }
10125    }
10126    impl CstDecode<crate::model::PrepareSendRequest> for *mut wire_cst_prepare_send_request {
10127        // Codec=Cst (C-struct based), see doc to use other codecs
10128        fn cst_decode(self) -> crate::model::PrepareSendRequest {
10129            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10130            CstDecode::<crate::model::PrepareSendRequest>::cst_decode(*wrap).into()
10131        }
10132    }
10133    impl CstDecode<crate::model::ReceiveAmount> for *mut wire_cst_receive_amount {
10134        // Codec=Cst (C-struct based), see doc to use other codecs
10135        fn cst_decode(self) -> crate::model::ReceiveAmount {
10136            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10137            CstDecode::<crate::model::ReceiveAmount>::cst_decode(*wrap).into()
10138        }
10139    }
10140    impl CstDecode<crate::model::ReceivePaymentRequest> for *mut wire_cst_receive_payment_request {
10141        // Codec=Cst (C-struct based), see doc to use other codecs
10142        fn cst_decode(self) -> crate::model::ReceivePaymentRequest {
10143            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10144            CstDecode::<crate::model::ReceivePaymentRequest>::cst_decode(*wrap).into()
10145        }
10146    }
10147    impl CstDecode<crate::model::RefundRequest> for *mut wire_cst_refund_request {
10148        // Codec=Cst (C-struct based), see doc to use other codecs
10149        fn cst_decode(self) -> crate::model::RefundRequest {
10150            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10151            CstDecode::<crate::model::RefundRequest>::cst_decode(*wrap).into()
10152        }
10153    }
10154    impl CstDecode<crate::model::RestoreRequest> for *mut wire_cst_restore_request {
10155        // Codec=Cst (C-struct based), see doc to use other codecs
10156        fn cst_decode(self) -> crate::model::RestoreRequest {
10157            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10158            CstDecode::<crate::model::RestoreRequest>::cst_decode(*wrap).into()
10159        }
10160    }
10161    impl CstDecode<crate::model::SdkEvent> for *mut wire_cst_sdk_event {
10162        // Codec=Cst (C-struct based), see doc to use other codecs
10163        fn cst_decode(self) -> crate::model::SdkEvent {
10164            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10165            CstDecode::<crate::model::SdkEvent>::cst_decode(*wrap).into()
10166        }
10167    }
10168    impl CstDecode<crate::model::SendPaymentRequest> for *mut wire_cst_send_payment_request {
10169        // Codec=Cst (C-struct based), see doc to use other codecs
10170        fn cst_decode(self) -> crate::model::SendPaymentRequest {
10171            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10172            CstDecode::<crate::model::SendPaymentRequest>::cst_decode(*wrap).into()
10173        }
10174    }
10175    impl CstDecode<crate::model::SignMessageRequest> for *mut wire_cst_sign_message_request {
10176        // Codec=Cst (C-struct based), see doc to use other codecs
10177        fn cst_decode(self) -> crate::model::SignMessageRequest {
10178            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10179            CstDecode::<crate::model::SignMessageRequest>::cst_decode(*wrap).into()
10180        }
10181    }
10182    impl CstDecode<crate::bindings::SuccessAction> for *mut wire_cst_success_action {
10183        // Codec=Cst (C-struct based), see doc to use other codecs
10184        fn cst_decode(self) -> crate::bindings::SuccessAction {
10185            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10186            CstDecode::<crate::bindings::SuccessAction>::cst_decode(*wrap).into()
10187        }
10188    }
10189    impl CstDecode<crate::bindings::SuccessActionProcessed> for *mut wire_cst_success_action_processed {
10190        // Codec=Cst (C-struct based), see doc to use other codecs
10191        fn cst_decode(self) -> crate::bindings::SuccessActionProcessed {
10192            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10193            CstDecode::<crate::bindings::SuccessActionProcessed>::cst_decode(*wrap).into()
10194        }
10195    }
10196    impl CstDecode<crate::bindings::Symbol> for *mut wire_cst_symbol {
10197        // Codec=Cst (C-struct based), see doc to use other codecs
10198        fn cst_decode(self) -> crate::bindings::Symbol {
10199            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10200            CstDecode::<crate::bindings::Symbol>::cst_decode(*wrap).into()
10201        }
10202    }
10203    impl CstDecode<u32> for *mut u32 {
10204        // Codec=Cst (C-struct based), see doc to use other codecs
10205        fn cst_decode(self) -> u32 {
10206            unsafe { *flutter_rust_bridge::for_generated::box_from_leak_ptr(self) }
10207        }
10208    }
10209    impl CstDecode<u64> for *mut u64 {
10210        // Codec=Cst (C-struct based), see doc to use other codecs
10211        fn cst_decode(self) -> u64 {
10212            unsafe { *flutter_rust_bridge::for_generated::box_from_leak_ptr(self) }
10213        }
10214    }
10215    impl CstDecode<crate::bindings::UrlSuccessActionData> for *mut wire_cst_url_success_action_data {
10216        // Codec=Cst (C-struct based), see doc to use other codecs
10217        fn cst_decode(self) -> crate::bindings::UrlSuccessActionData {
10218            let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) };
10219            CstDecode::<crate::bindings::UrlSuccessActionData>::cst_decode(*wrap).into()
10220        }
10221    }
10222    impl CstDecode<crate::model::BuyBitcoinRequest> for wire_cst_buy_bitcoin_request {
10223        // Codec=Cst (C-struct based), see doc to use other codecs
10224        fn cst_decode(self) -> crate::model::BuyBitcoinRequest {
10225            crate::model::BuyBitcoinRequest {
10226                prepare_response: self.prepare_response.cst_decode(),
10227                redirect_url: self.redirect_url.cst_decode(),
10228            }
10229        }
10230    }
10231    impl CstDecode<crate::model::CheckMessageRequest> for wire_cst_check_message_request {
10232        // Codec=Cst (C-struct based), see doc to use other codecs
10233        fn cst_decode(self) -> crate::model::CheckMessageRequest {
10234            crate::model::CheckMessageRequest {
10235                message: self.message.cst_decode(),
10236                pubkey: self.pubkey.cst_decode(),
10237                signature: self.signature.cst_decode(),
10238            }
10239        }
10240    }
10241    impl CstDecode<crate::model::CheckMessageResponse> for wire_cst_check_message_response {
10242        // Codec=Cst (C-struct based), see doc to use other codecs
10243        fn cst_decode(self) -> crate::model::CheckMessageResponse {
10244            crate::model::CheckMessageResponse {
10245                is_valid: self.is_valid.cst_decode(),
10246            }
10247        }
10248    }
10249    impl CstDecode<crate::model::Config> for wire_cst_config {
10250        // Codec=Cst (C-struct based), see doc to use other codecs
10251        fn cst_decode(self) -> crate::model::Config {
10252            crate::model::Config {
10253                liquid_explorer: self.liquid_explorer.cst_decode(),
10254                bitcoin_explorer: self.bitcoin_explorer.cst_decode(),
10255                working_dir: self.working_dir.cst_decode(),
10256                network: self.network.cst_decode(),
10257                payment_timeout_sec: self.payment_timeout_sec.cst_decode(),
10258                sync_service_url: self.sync_service_url.cst_decode(),
10259                zero_conf_max_amount_sat: self.zero_conf_max_amount_sat.cst_decode(),
10260                breez_api_key: self.breez_api_key.cst_decode(),
10261                external_input_parsers: self.external_input_parsers.cst_decode(),
10262                use_default_external_input_parsers: self
10263                    .use_default_external_input_parsers
10264                    .cst_decode(),
10265                onchain_fee_rate_leeway_sat_per_vbyte: self
10266                    .onchain_fee_rate_leeway_sat_per_vbyte
10267                    .cst_decode(),
10268                asset_metadata: self.asset_metadata.cst_decode(),
10269                sideswap_api_key: self.sideswap_api_key.cst_decode(),
10270            }
10271        }
10272    }
10273    impl CstDecode<crate::model::ConnectRequest> for wire_cst_connect_request {
10274        // Codec=Cst (C-struct based), see doc to use other codecs
10275        fn cst_decode(self) -> crate::model::ConnectRequest {
10276            crate::model::ConnectRequest {
10277                config: self.config.cst_decode(),
10278                mnemonic: self.mnemonic.cst_decode(),
10279                passphrase: self.passphrase.cst_decode(),
10280                seed: self.seed.cst_decode(),
10281            }
10282        }
10283    }
10284    impl CstDecode<crate::model::CreateBolt12InvoiceRequest>
10285        for wire_cst_create_bolt_12_invoice_request
10286    {
10287        // Codec=Cst (C-struct based), see doc to use other codecs
10288        fn cst_decode(self) -> crate::model::CreateBolt12InvoiceRequest {
10289            crate::model::CreateBolt12InvoiceRequest {
10290                offer: self.offer.cst_decode(),
10291                invoice_request: self.invoice_request.cst_decode(),
10292            }
10293        }
10294    }
10295    impl CstDecode<crate::model::CreateBolt12InvoiceResponse>
10296        for wire_cst_create_bolt_12_invoice_response
10297    {
10298        // Codec=Cst (C-struct based), see doc to use other codecs
10299        fn cst_decode(self) -> crate::model::CreateBolt12InvoiceResponse {
10300            crate::model::CreateBolt12InvoiceResponse {
10301                invoice: self.invoice.cst_decode(),
10302            }
10303        }
10304    }
10305    impl CstDecode<crate::bindings::CurrencyInfo> for wire_cst_currency_info {
10306        // Codec=Cst (C-struct based), see doc to use other codecs
10307        fn cst_decode(self) -> crate::bindings::CurrencyInfo {
10308            crate::bindings::CurrencyInfo {
10309                name: self.name.cst_decode(),
10310                fraction_size: self.fraction_size.cst_decode(),
10311                spacing: self.spacing.cst_decode(),
10312                symbol: self.symbol.cst_decode(),
10313                uniq_symbol: self.uniq_symbol.cst_decode(),
10314                localized_name: self.localized_name.cst_decode(),
10315                locale_overrides: self.locale_overrides.cst_decode(),
10316            }
10317        }
10318    }
10319    impl CstDecode<crate::bindings::ExternalInputParser> for wire_cst_external_input_parser {
10320        // Codec=Cst (C-struct based), see doc to use other codecs
10321        fn cst_decode(self) -> crate::bindings::ExternalInputParser {
10322            crate::bindings::ExternalInputParser {
10323                provider_id: self.provider_id.cst_decode(),
10324                input_regex: self.input_regex.cst_decode(),
10325                parser_url: self.parser_url.cst_decode(),
10326            }
10327        }
10328    }
10329    impl CstDecode<crate::model::FetchPaymentProposedFeesRequest>
10330        for wire_cst_fetch_payment_proposed_fees_request
10331    {
10332        // Codec=Cst (C-struct based), see doc to use other codecs
10333        fn cst_decode(self) -> crate::model::FetchPaymentProposedFeesRequest {
10334            crate::model::FetchPaymentProposedFeesRequest {
10335                swap_id: self.swap_id.cst_decode(),
10336            }
10337        }
10338    }
10339    impl CstDecode<crate::model::FetchPaymentProposedFeesResponse>
10340        for wire_cst_fetch_payment_proposed_fees_response
10341    {
10342        // Codec=Cst (C-struct based), see doc to use other codecs
10343        fn cst_decode(self) -> crate::model::FetchPaymentProposedFeesResponse {
10344            crate::model::FetchPaymentProposedFeesResponse {
10345                swap_id: self.swap_id.cst_decode(),
10346                fees_sat: self.fees_sat.cst_decode(),
10347                payer_amount_sat: self.payer_amount_sat.cst_decode(),
10348                receiver_amount_sat: self.receiver_amount_sat.cst_decode(),
10349            }
10350        }
10351    }
10352    impl CstDecode<crate::bindings::FiatCurrency> for wire_cst_fiat_currency {
10353        // Codec=Cst (C-struct based), see doc to use other codecs
10354        fn cst_decode(self) -> crate::bindings::FiatCurrency {
10355            crate::bindings::FiatCurrency {
10356                id: self.id.cst_decode(),
10357                info: self.info.cst_decode(),
10358            }
10359        }
10360    }
10361    impl CstDecode<crate::model::GetInfoResponse> for wire_cst_get_info_response {
10362        // Codec=Cst (C-struct based), see doc to use other codecs
10363        fn cst_decode(self) -> crate::model::GetInfoResponse {
10364            crate::model::GetInfoResponse {
10365                wallet_info: self.wallet_info.cst_decode(),
10366                blockchain_info: self.blockchain_info.cst_decode(),
10367            }
10368        }
10369    }
10370    impl CstDecode<crate::model::GetPaymentRequest> for wire_cst_get_payment_request {
10371        // Codec=Cst (C-struct based), see doc to use other codecs
10372        fn cst_decode(self) -> crate::model::GetPaymentRequest {
10373            match self.tag {
10374                0 => {
10375                    let ans = unsafe { self.kind.PaymentHash };
10376                    crate::model::GetPaymentRequest::PaymentHash {
10377                        payment_hash: ans.payment_hash.cst_decode(),
10378                    }
10379                }
10380                1 => {
10381                    let ans = unsafe { self.kind.SwapId };
10382                    crate::model::GetPaymentRequest::SwapId {
10383                        swap_id: ans.swap_id.cst_decode(),
10384                    }
10385                }
10386                _ => unreachable!(),
10387            }
10388        }
10389    }
10390    impl CstDecode<crate::bindings::InputType> for wire_cst_input_type {
10391        // Codec=Cst (C-struct based), see doc to use other codecs
10392        fn cst_decode(self) -> crate::bindings::InputType {
10393            match self.tag {
10394                0 => {
10395                    let ans = unsafe { self.kind.BitcoinAddress };
10396                    crate::bindings::InputType::BitcoinAddress {
10397                        address: ans.address.cst_decode(),
10398                    }
10399                }
10400                1 => {
10401                    let ans = unsafe { self.kind.LiquidAddress };
10402                    crate::bindings::InputType::LiquidAddress {
10403                        address: ans.address.cst_decode(),
10404                    }
10405                }
10406                2 => {
10407                    let ans = unsafe { self.kind.Bolt11 };
10408                    crate::bindings::InputType::Bolt11 {
10409                        invoice: ans.invoice.cst_decode(),
10410                    }
10411                }
10412                3 => {
10413                    let ans = unsafe { self.kind.Bolt12Offer };
10414                    crate::bindings::InputType::Bolt12Offer {
10415                        offer: ans.offer.cst_decode(),
10416                        bip353_address: ans.bip353_address.cst_decode(),
10417                    }
10418                }
10419                4 => {
10420                    let ans = unsafe { self.kind.NodeId };
10421                    crate::bindings::InputType::NodeId {
10422                        node_id: ans.node_id.cst_decode(),
10423                    }
10424                }
10425                5 => {
10426                    let ans = unsafe { self.kind.Url };
10427                    crate::bindings::InputType::Url {
10428                        url: ans.url.cst_decode(),
10429                    }
10430                }
10431                6 => {
10432                    let ans = unsafe { self.kind.LnUrlPay };
10433                    crate::bindings::InputType::LnUrlPay {
10434                        data: ans.data.cst_decode(),
10435                        bip353_address: ans.bip353_address.cst_decode(),
10436                    }
10437                }
10438                7 => {
10439                    let ans = unsafe { self.kind.LnUrlWithdraw };
10440                    crate::bindings::InputType::LnUrlWithdraw {
10441                        data: ans.data.cst_decode(),
10442                    }
10443                }
10444                8 => {
10445                    let ans = unsafe { self.kind.LnUrlAuth };
10446                    crate::bindings::InputType::LnUrlAuth {
10447                        data: ans.data.cst_decode(),
10448                    }
10449                }
10450                9 => {
10451                    let ans = unsafe { self.kind.LnUrlError };
10452                    crate::bindings::InputType::LnUrlError {
10453                        data: ans.data.cst_decode(),
10454                    }
10455                }
10456                _ => unreachable!(),
10457            }
10458        }
10459    }
10460    impl CstDecode<crate::model::LightningPaymentLimitsResponse>
10461        for wire_cst_lightning_payment_limits_response
10462    {
10463        // Codec=Cst (C-struct based), see doc to use other codecs
10464        fn cst_decode(self) -> crate::model::LightningPaymentLimitsResponse {
10465            crate::model::LightningPaymentLimitsResponse {
10466                send: self.send.cst_decode(),
10467                receive: self.receive.cst_decode(),
10468            }
10469        }
10470    }
10471    impl CstDecode<crate::model::Limits> for wire_cst_limits {
10472        // Codec=Cst (C-struct based), see doc to use other codecs
10473        fn cst_decode(self) -> crate::model::Limits {
10474            crate::model::Limits {
10475                min_sat: self.min_sat.cst_decode(),
10476                max_sat: self.max_sat.cst_decode(),
10477                max_zero_conf_sat: self.max_zero_conf_sat.cst_decode(),
10478            }
10479        }
10480    }
10481    impl CstDecode<crate::bindings::LiquidAddressData> for wire_cst_liquid_address_data {
10482        // Codec=Cst (C-struct based), see doc to use other codecs
10483        fn cst_decode(self) -> crate::bindings::LiquidAddressData {
10484            crate::bindings::LiquidAddressData {
10485                address: self.address.cst_decode(),
10486                network: self.network.cst_decode(),
10487                asset_id: self.asset_id.cst_decode(),
10488                amount: self.amount.cst_decode(),
10489                amount_sat: self.amount_sat.cst_decode(),
10490                label: self.label.cst_decode(),
10491                message: self.message.cst_decode(),
10492            }
10493        }
10494    }
10495    impl CstDecode<Vec<String>> for *mut wire_cst_list_String {
10496        // Codec=Cst (C-struct based), see doc to use other codecs
10497        fn cst_decode(self) -> Vec<String> {
10498            let vec = unsafe {
10499                let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10500                flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10501            };
10502            vec.into_iter().map(CstDecode::cst_decode).collect()
10503        }
10504    }
10505    impl CstDecode<Vec<crate::model::AssetBalance>> for *mut wire_cst_list_asset_balance {
10506        // Codec=Cst (C-struct based), see doc to use other codecs
10507        fn cst_decode(self) -> Vec<crate::model::AssetBalance> {
10508            let vec = unsafe {
10509                let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10510                flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10511            };
10512            vec.into_iter().map(CstDecode::cst_decode).collect()
10513        }
10514    }
10515    impl CstDecode<Vec<crate::model::AssetMetadata>> for *mut wire_cst_list_asset_metadata {
10516        // Codec=Cst (C-struct based), see doc to use other codecs
10517        fn cst_decode(self) -> Vec<crate::model::AssetMetadata> {
10518            let vec = unsafe {
10519                let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10520                flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10521            };
10522            vec.into_iter().map(CstDecode::cst_decode).collect()
10523        }
10524    }
10525    impl CstDecode<Vec<crate::bindings::ExternalInputParser>>
10526        for *mut wire_cst_list_external_input_parser
10527    {
10528        // Codec=Cst (C-struct based), see doc to use other codecs
10529        fn cst_decode(self) -> Vec<crate::bindings::ExternalInputParser> {
10530            let vec = unsafe {
10531                let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10532                flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10533            };
10534            vec.into_iter().map(CstDecode::cst_decode).collect()
10535        }
10536    }
10537    impl CstDecode<Vec<crate::bindings::FiatCurrency>> for *mut wire_cst_list_fiat_currency {
10538        // Codec=Cst (C-struct based), see doc to use other codecs
10539        fn cst_decode(self) -> Vec<crate::bindings::FiatCurrency> {
10540            let vec = unsafe {
10541                let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10542                flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10543            };
10544            vec.into_iter().map(CstDecode::cst_decode).collect()
10545        }
10546    }
10547    impl CstDecode<Vec<crate::bindings::LnOfferBlindedPath>>
10548        for *mut wire_cst_list_ln_offer_blinded_path
10549    {
10550        // Codec=Cst (C-struct based), see doc to use other codecs
10551        fn cst_decode(self) -> Vec<crate::bindings::LnOfferBlindedPath> {
10552            let vec = unsafe {
10553                let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10554                flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10555            };
10556            vec.into_iter().map(CstDecode::cst_decode).collect()
10557        }
10558    }
10559    impl CstDecode<Vec<crate::bindings::LocaleOverrides>> for *mut wire_cst_list_locale_overrides {
10560        // Codec=Cst (C-struct based), see doc to use other codecs
10561        fn cst_decode(self) -> Vec<crate::bindings::LocaleOverrides> {
10562            let vec = unsafe {
10563                let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10564                flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10565            };
10566            vec.into_iter().map(CstDecode::cst_decode).collect()
10567        }
10568    }
10569    impl CstDecode<Vec<crate::bindings::LocalizedName>> for *mut wire_cst_list_localized_name {
10570        // Codec=Cst (C-struct based), see doc to use other codecs
10571        fn cst_decode(self) -> Vec<crate::bindings::LocalizedName> {
10572            let vec = unsafe {
10573                let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10574                flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10575            };
10576            vec.into_iter().map(CstDecode::cst_decode).collect()
10577        }
10578    }
10579    impl CstDecode<Vec<crate::model::Payment>> for *mut wire_cst_list_payment {
10580        // Codec=Cst (C-struct based), see doc to use other codecs
10581        fn cst_decode(self) -> Vec<crate::model::Payment> {
10582            let vec = unsafe {
10583                let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10584                flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10585            };
10586            vec.into_iter().map(CstDecode::cst_decode).collect()
10587        }
10588    }
10589    impl CstDecode<crate::model::ListPaymentDetails> for wire_cst_list_payment_details {
10590        // Codec=Cst (C-struct based), see doc to use other codecs
10591        fn cst_decode(self) -> crate::model::ListPaymentDetails {
10592            match self.tag {
10593                0 => {
10594                    let ans = unsafe { self.kind.Liquid };
10595                    crate::model::ListPaymentDetails::Liquid {
10596                        asset_id: ans.asset_id.cst_decode(),
10597                        destination: ans.destination.cst_decode(),
10598                    }
10599                }
10600                1 => {
10601                    let ans = unsafe { self.kind.Bitcoin };
10602                    crate::model::ListPaymentDetails::Bitcoin {
10603                        address: ans.address.cst_decode(),
10604                    }
10605                }
10606                _ => unreachable!(),
10607            }
10608        }
10609    }
10610    impl CstDecode<Vec<crate::model::PaymentState>> for *mut wire_cst_list_payment_state {
10611        // Codec=Cst (C-struct based), see doc to use other codecs
10612        fn cst_decode(self) -> Vec<crate::model::PaymentState> {
10613            let vec = unsafe {
10614                let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10615                flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10616            };
10617            vec.into_iter().map(CstDecode::cst_decode).collect()
10618        }
10619    }
10620    impl CstDecode<Vec<crate::model::PaymentType>> for *mut wire_cst_list_payment_type {
10621        // Codec=Cst (C-struct based), see doc to use other codecs
10622        fn cst_decode(self) -> Vec<crate::model::PaymentType> {
10623            let vec = unsafe {
10624                let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10625                flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10626            };
10627            vec.into_iter().map(CstDecode::cst_decode).collect()
10628        }
10629    }
10630    impl CstDecode<crate::model::ListPaymentsRequest> for wire_cst_list_payments_request {
10631        // Codec=Cst (C-struct based), see doc to use other codecs
10632        fn cst_decode(self) -> crate::model::ListPaymentsRequest {
10633            crate::model::ListPaymentsRequest {
10634                filters: self.filters.cst_decode(),
10635                states: self.states.cst_decode(),
10636                from_timestamp: self.from_timestamp.cst_decode(),
10637                to_timestamp: self.to_timestamp.cst_decode(),
10638                offset: self.offset.cst_decode(),
10639                limit: self.limit.cst_decode(),
10640                details: self.details.cst_decode(),
10641                sort_ascending: self.sort_ascending.cst_decode(),
10642            }
10643        }
10644    }
10645    impl CstDecode<Vec<u8>> for *mut wire_cst_list_prim_u_8_strict {
10646        // Codec=Cst (C-struct based), see doc to use other codecs
10647        fn cst_decode(self) -> Vec<u8> {
10648            unsafe {
10649                let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10650                flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10651            }
10652        }
10653    }
10654    impl CstDecode<Vec<crate::bindings::Rate>> for *mut wire_cst_list_rate {
10655        // Codec=Cst (C-struct based), see doc to use other codecs
10656        fn cst_decode(self) -> Vec<crate::bindings::Rate> {
10657            let vec = unsafe {
10658                let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10659                flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10660            };
10661            vec.into_iter().map(CstDecode::cst_decode).collect()
10662        }
10663    }
10664    impl CstDecode<Vec<crate::model::RefundableSwap>> for *mut wire_cst_list_refundable_swap {
10665        // Codec=Cst (C-struct based), see doc to use other codecs
10666        fn cst_decode(self) -> Vec<crate::model::RefundableSwap> {
10667            let vec = unsafe {
10668                let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10669                flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10670            };
10671            vec.into_iter().map(CstDecode::cst_decode).collect()
10672        }
10673    }
10674    impl CstDecode<Vec<crate::bindings::RouteHint>> for *mut wire_cst_list_route_hint {
10675        // Codec=Cst (C-struct based), see doc to use other codecs
10676        fn cst_decode(self) -> Vec<crate::bindings::RouteHint> {
10677            let vec = unsafe {
10678                let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10679                flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10680            };
10681            vec.into_iter().map(CstDecode::cst_decode).collect()
10682        }
10683    }
10684    impl CstDecode<Vec<crate::bindings::RouteHintHop>> for *mut wire_cst_list_route_hint_hop {
10685        // Codec=Cst (C-struct based), see doc to use other codecs
10686        fn cst_decode(self) -> Vec<crate::bindings::RouteHintHop> {
10687            let vec = unsafe {
10688                let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self);
10689                flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len)
10690            };
10691            vec.into_iter().map(CstDecode::cst_decode).collect()
10692        }
10693    }
10694    impl CstDecode<crate::bindings::LNInvoice> for wire_cst_ln_invoice {
10695        // Codec=Cst (C-struct based), see doc to use other codecs
10696        fn cst_decode(self) -> crate::bindings::LNInvoice {
10697            crate::bindings::LNInvoice {
10698                bolt11: self.bolt11.cst_decode(),
10699                network: self.network.cst_decode(),
10700                payee_pubkey: self.payee_pubkey.cst_decode(),
10701                payment_hash: self.payment_hash.cst_decode(),
10702                description: self.description.cst_decode(),
10703                description_hash: self.description_hash.cst_decode(),
10704                amount_msat: self.amount_msat.cst_decode(),
10705                timestamp: self.timestamp.cst_decode(),
10706                expiry: self.expiry.cst_decode(),
10707                routing_hints: self.routing_hints.cst_decode(),
10708                payment_secret: self.payment_secret.cst_decode(),
10709                min_final_cltv_expiry_delta: self.min_final_cltv_expiry_delta.cst_decode(),
10710            }
10711        }
10712    }
10713    impl CstDecode<crate::bindings::LNOffer> for wire_cst_ln_offer {
10714        // Codec=Cst (C-struct based), see doc to use other codecs
10715        fn cst_decode(self) -> crate::bindings::LNOffer {
10716            crate::bindings::LNOffer {
10717                offer: self.offer.cst_decode(),
10718                chains: self.chains.cst_decode(),
10719                min_amount: self.min_amount.cst_decode(),
10720                description: self.description.cst_decode(),
10721                absolute_expiry: self.absolute_expiry.cst_decode(),
10722                issuer: self.issuer.cst_decode(),
10723                signing_pubkey: self.signing_pubkey.cst_decode(),
10724                paths: self.paths.cst_decode(),
10725            }
10726        }
10727    }
10728    impl CstDecode<crate::bindings::LnOfferBlindedPath> for wire_cst_ln_offer_blinded_path {
10729        // Codec=Cst (C-struct based), see doc to use other codecs
10730        fn cst_decode(self) -> crate::bindings::LnOfferBlindedPath {
10731            crate::bindings::LnOfferBlindedPath {
10732                blinded_hops: self.blinded_hops.cst_decode(),
10733            }
10734        }
10735    }
10736    impl CstDecode<crate::bindings::duplicates::LnUrlAuthError> for wire_cst_ln_url_auth_error {
10737        // Codec=Cst (C-struct based), see doc to use other codecs
10738        fn cst_decode(self) -> crate::bindings::duplicates::LnUrlAuthError {
10739            match self.tag {
10740                0 => {
10741                    let ans = unsafe { self.kind.Generic };
10742                    crate::bindings::duplicates::LnUrlAuthError::Generic {
10743                        err: ans.err.cst_decode(),
10744                    }
10745                }
10746                1 => {
10747                    let ans = unsafe { self.kind.InvalidUri };
10748                    crate::bindings::duplicates::LnUrlAuthError::InvalidUri {
10749                        err: ans.err.cst_decode(),
10750                    }
10751                }
10752                2 => {
10753                    let ans = unsafe { self.kind.ServiceConnectivity };
10754                    crate::bindings::duplicates::LnUrlAuthError::ServiceConnectivity {
10755                        err: ans.err.cst_decode(),
10756                    }
10757                }
10758                _ => unreachable!(),
10759            }
10760        }
10761    }
10762    impl CstDecode<crate::bindings::LnUrlAuthRequestData> for wire_cst_ln_url_auth_request_data {
10763        // Codec=Cst (C-struct based), see doc to use other codecs
10764        fn cst_decode(self) -> crate::bindings::LnUrlAuthRequestData {
10765            crate::bindings::LnUrlAuthRequestData {
10766                k1: self.k1.cst_decode(),
10767                action: self.action.cst_decode(),
10768                domain: self.domain.cst_decode(),
10769                url: self.url.cst_decode(),
10770            }
10771        }
10772    }
10773    impl CstDecode<crate::bindings::duplicates::LnUrlCallbackStatus>
10774        for wire_cst_ln_url_callback_status
10775    {
10776        // Codec=Cst (C-struct based), see doc to use other codecs
10777        fn cst_decode(self) -> crate::bindings::duplicates::LnUrlCallbackStatus {
10778            match self.tag {
10779                0 => crate::bindings::duplicates::LnUrlCallbackStatus::Ok,
10780                1 => {
10781                    let ans = unsafe { self.kind.ErrorStatus };
10782                    crate::bindings::duplicates::LnUrlCallbackStatus::ErrorStatus {
10783                        data: ans.data.cst_decode(),
10784                    }
10785                }
10786                _ => unreachable!(),
10787            }
10788        }
10789    }
10790    impl CstDecode<crate::bindings::LnUrlErrorData> for wire_cst_ln_url_error_data {
10791        // Codec=Cst (C-struct based), see doc to use other codecs
10792        fn cst_decode(self) -> crate::bindings::LnUrlErrorData {
10793            crate::bindings::LnUrlErrorData {
10794                reason: self.reason.cst_decode(),
10795            }
10796        }
10797    }
10798    impl CstDecode<crate::model::LnUrlInfo> for wire_cst_ln_url_info {
10799        // Codec=Cst (C-struct based), see doc to use other codecs
10800        fn cst_decode(self) -> crate::model::LnUrlInfo {
10801            crate::model::LnUrlInfo {
10802                ln_address: self.ln_address.cst_decode(),
10803                lnurl_pay_comment: self.lnurl_pay_comment.cst_decode(),
10804                lnurl_pay_domain: self.lnurl_pay_domain.cst_decode(),
10805                lnurl_pay_metadata: self.lnurl_pay_metadata.cst_decode(),
10806                lnurl_pay_success_action: self.lnurl_pay_success_action.cst_decode(),
10807                lnurl_pay_unprocessed_success_action: self
10808                    .lnurl_pay_unprocessed_success_action
10809                    .cst_decode(),
10810                lnurl_withdraw_endpoint: self.lnurl_withdraw_endpoint.cst_decode(),
10811            }
10812        }
10813    }
10814    impl CstDecode<crate::bindings::duplicates::LnUrlPayError> for wire_cst_ln_url_pay_error {
10815        // Codec=Cst (C-struct based), see doc to use other codecs
10816        fn cst_decode(self) -> crate::bindings::duplicates::LnUrlPayError {
10817            match self.tag {
10818                0 => crate::bindings::duplicates::LnUrlPayError::AlreadyPaid,
10819                1 => {
10820                    let ans = unsafe { self.kind.Generic };
10821                    crate::bindings::duplicates::LnUrlPayError::Generic {
10822                        err: ans.err.cst_decode(),
10823                    }
10824                }
10825                2 => {
10826                    let ans = unsafe { self.kind.InsufficientBalance };
10827                    crate::bindings::duplicates::LnUrlPayError::InsufficientBalance {
10828                        err: ans.err.cst_decode(),
10829                    }
10830                }
10831                3 => {
10832                    let ans = unsafe { self.kind.InvalidAmount };
10833                    crate::bindings::duplicates::LnUrlPayError::InvalidAmount {
10834                        err: ans.err.cst_decode(),
10835                    }
10836                }
10837                4 => {
10838                    let ans = unsafe { self.kind.InvalidInvoice };
10839                    crate::bindings::duplicates::LnUrlPayError::InvalidInvoice {
10840                        err: ans.err.cst_decode(),
10841                    }
10842                }
10843                5 => {
10844                    let ans = unsafe { self.kind.InvalidNetwork };
10845                    crate::bindings::duplicates::LnUrlPayError::InvalidNetwork {
10846                        err: ans.err.cst_decode(),
10847                    }
10848                }
10849                6 => {
10850                    let ans = unsafe { self.kind.InvalidUri };
10851                    crate::bindings::duplicates::LnUrlPayError::InvalidUri {
10852                        err: ans.err.cst_decode(),
10853                    }
10854                }
10855                7 => {
10856                    let ans = unsafe { self.kind.InvoiceExpired };
10857                    crate::bindings::duplicates::LnUrlPayError::InvoiceExpired {
10858                        err: ans.err.cst_decode(),
10859                    }
10860                }
10861                8 => {
10862                    let ans = unsafe { self.kind.PaymentFailed };
10863                    crate::bindings::duplicates::LnUrlPayError::PaymentFailed {
10864                        err: ans.err.cst_decode(),
10865                    }
10866                }
10867                9 => {
10868                    let ans = unsafe { self.kind.PaymentTimeout };
10869                    crate::bindings::duplicates::LnUrlPayError::PaymentTimeout {
10870                        err: ans.err.cst_decode(),
10871                    }
10872                }
10873                10 => {
10874                    let ans = unsafe { self.kind.RouteNotFound };
10875                    crate::bindings::duplicates::LnUrlPayError::RouteNotFound {
10876                        err: ans.err.cst_decode(),
10877                    }
10878                }
10879                11 => {
10880                    let ans = unsafe { self.kind.RouteTooExpensive };
10881                    crate::bindings::duplicates::LnUrlPayError::RouteTooExpensive {
10882                        err: ans.err.cst_decode(),
10883                    }
10884                }
10885                12 => {
10886                    let ans = unsafe { self.kind.ServiceConnectivity };
10887                    crate::bindings::duplicates::LnUrlPayError::ServiceConnectivity {
10888                        err: ans.err.cst_decode(),
10889                    }
10890                }
10891                _ => unreachable!(),
10892            }
10893        }
10894    }
10895    impl CstDecode<crate::bindings::LnUrlPayErrorData> for wire_cst_ln_url_pay_error_data {
10896        // Codec=Cst (C-struct based), see doc to use other codecs
10897        fn cst_decode(self) -> crate::bindings::LnUrlPayErrorData {
10898            crate::bindings::LnUrlPayErrorData {
10899                payment_hash: self.payment_hash.cst_decode(),
10900                reason: self.reason.cst_decode(),
10901            }
10902        }
10903    }
10904    impl CstDecode<crate::model::LnUrlPayRequest> for wire_cst_ln_url_pay_request {
10905        // Codec=Cst (C-struct based), see doc to use other codecs
10906        fn cst_decode(self) -> crate::model::LnUrlPayRequest {
10907            crate::model::LnUrlPayRequest {
10908                prepare_response: self.prepare_response.cst_decode(),
10909            }
10910        }
10911    }
10912    impl CstDecode<crate::bindings::LnUrlPayRequestData> for wire_cst_ln_url_pay_request_data {
10913        // Codec=Cst (C-struct based), see doc to use other codecs
10914        fn cst_decode(self) -> crate::bindings::LnUrlPayRequestData {
10915            crate::bindings::LnUrlPayRequestData {
10916                callback: self.callback.cst_decode(),
10917                min_sendable: self.min_sendable.cst_decode(),
10918                max_sendable: self.max_sendable.cst_decode(),
10919                metadata_str: self.metadata_str.cst_decode(),
10920                comment_allowed: self.comment_allowed.cst_decode(),
10921                domain: self.domain.cst_decode(),
10922                allows_nostr: self.allows_nostr.cst_decode(),
10923                nostr_pubkey: self.nostr_pubkey.cst_decode(),
10924                ln_address: self.ln_address.cst_decode(),
10925            }
10926        }
10927    }
10928    impl CstDecode<crate::model::LnUrlPayResult> for wire_cst_ln_url_pay_result {
10929        // Codec=Cst (C-struct based), see doc to use other codecs
10930        fn cst_decode(self) -> crate::model::LnUrlPayResult {
10931            match self.tag {
10932                0 => {
10933                    let ans = unsafe { self.kind.EndpointSuccess };
10934                    crate::model::LnUrlPayResult::EndpointSuccess {
10935                        data: ans.data.cst_decode(),
10936                    }
10937                }
10938                1 => {
10939                    let ans = unsafe { self.kind.EndpointError };
10940                    crate::model::LnUrlPayResult::EndpointError {
10941                        data: ans.data.cst_decode(),
10942                    }
10943                }
10944                2 => {
10945                    let ans = unsafe { self.kind.PayError };
10946                    crate::model::LnUrlPayResult::PayError {
10947                        data: ans.data.cst_decode(),
10948                    }
10949                }
10950                _ => unreachable!(),
10951            }
10952        }
10953    }
10954    impl CstDecode<crate::model::LnUrlPaySuccessData> for wire_cst_ln_url_pay_success_data {
10955        // Codec=Cst (C-struct based), see doc to use other codecs
10956        fn cst_decode(self) -> crate::model::LnUrlPaySuccessData {
10957            crate::model::LnUrlPaySuccessData {
10958                payment: self.payment.cst_decode(),
10959                success_action: self.success_action.cst_decode(),
10960            }
10961        }
10962    }
10963    impl CstDecode<crate::bindings::duplicates::LnUrlWithdrawError> for wire_cst_ln_url_withdraw_error {
10964        // Codec=Cst (C-struct based), see doc to use other codecs
10965        fn cst_decode(self) -> crate::bindings::duplicates::LnUrlWithdrawError {
10966            match self.tag {
10967                0 => {
10968                    let ans = unsafe { self.kind.Generic };
10969                    crate::bindings::duplicates::LnUrlWithdrawError::Generic {
10970                        err: ans.err.cst_decode(),
10971                    }
10972                }
10973                1 => {
10974                    let ans = unsafe { self.kind.InvalidAmount };
10975                    crate::bindings::duplicates::LnUrlWithdrawError::InvalidAmount {
10976                        err: ans.err.cst_decode(),
10977                    }
10978                }
10979                2 => {
10980                    let ans = unsafe { self.kind.InvalidInvoice };
10981                    crate::bindings::duplicates::LnUrlWithdrawError::InvalidInvoice {
10982                        err: ans.err.cst_decode(),
10983                    }
10984                }
10985                3 => {
10986                    let ans = unsafe { self.kind.InvalidUri };
10987                    crate::bindings::duplicates::LnUrlWithdrawError::InvalidUri {
10988                        err: ans.err.cst_decode(),
10989                    }
10990                }
10991                4 => {
10992                    let ans = unsafe { self.kind.InvoiceNoRoutingHints };
10993                    crate::bindings::duplicates::LnUrlWithdrawError::InvoiceNoRoutingHints {
10994                        err: ans.err.cst_decode(),
10995                    }
10996                }
10997                5 => {
10998                    let ans = unsafe { self.kind.ServiceConnectivity };
10999                    crate::bindings::duplicates::LnUrlWithdrawError::ServiceConnectivity {
11000                        err: ans.err.cst_decode(),
11001                    }
11002                }
11003                _ => unreachable!(),
11004            }
11005        }
11006    }
11007    impl CstDecode<crate::bindings::LnUrlWithdrawRequest> for wire_cst_ln_url_withdraw_request {
11008        // Codec=Cst (C-struct based), see doc to use other codecs
11009        fn cst_decode(self) -> crate::bindings::LnUrlWithdrawRequest {
11010            crate::bindings::LnUrlWithdrawRequest {
11011                data: self.data.cst_decode(),
11012                amount_msat: self.amount_msat.cst_decode(),
11013                description: self.description.cst_decode(),
11014            }
11015        }
11016    }
11017    impl CstDecode<crate::bindings::LnUrlWithdrawRequestData>
11018        for wire_cst_ln_url_withdraw_request_data
11019    {
11020        // Codec=Cst (C-struct based), see doc to use other codecs
11021        fn cst_decode(self) -> crate::bindings::LnUrlWithdrawRequestData {
11022            crate::bindings::LnUrlWithdrawRequestData {
11023                callback: self.callback.cst_decode(),
11024                k1: self.k1.cst_decode(),
11025                default_description: self.default_description.cst_decode(),
11026                min_withdrawable: self.min_withdrawable.cst_decode(),
11027                max_withdrawable: self.max_withdrawable.cst_decode(),
11028            }
11029        }
11030    }
11031    impl CstDecode<crate::bindings::duplicates::LnUrlWithdrawResult>
11032        for wire_cst_ln_url_withdraw_result
11033    {
11034        // Codec=Cst (C-struct based), see doc to use other codecs
11035        fn cst_decode(self) -> crate::bindings::duplicates::LnUrlWithdrawResult {
11036            match self.tag {
11037                0 => {
11038                    let ans = unsafe { self.kind.Ok };
11039                    crate::bindings::duplicates::LnUrlWithdrawResult::Ok {
11040                        data: ans.data.cst_decode(),
11041                    }
11042                }
11043                1 => {
11044                    let ans = unsafe { self.kind.Timeout };
11045                    crate::bindings::duplicates::LnUrlWithdrawResult::Timeout {
11046                        data: ans.data.cst_decode(),
11047                    }
11048                }
11049                2 => {
11050                    let ans = unsafe { self.kind.ErrorStatus };
11051                    crate::bindings::duplicates::LnUrlWithdrawResult::ErrorStatus {
11052                        data: ans.data.cst_decode(),
11053                    }
11054                }
11055                _ => unreachable!(),
11056            }
11057        }
11058    }
11059    impl CstDecode<crate::bindings::duplicates::LnUrlWithdrawSuccessData>
11060        for wire_cst_ln_url_withdraw_success_data
11061    {
11062        // Codec=Cst (C-struct based), see doc to use other codecs
11063        fn cst_decode(self) -> crate::bindings::duplicates::LnUrlWithdrawSuccessData {
11064            crate::bindings::duplicates::LnUrlWithdrawSuccessData {
11065                invoice: self.invoice.cst_decode(),
11066            }
11067        }
11068    }
11069    impl CstDecode<crate::bindings::LocaleOverrides> for wire_cst_locale_overrides {
11070        // Codec=Cst (C-struct based), see doc to use other codecs
11071        fn cst_decode(self) -> crate::bindings::LocaleOverrides {
11072            crate::bindings::LocaleOverrides {
11073                locale: self.locale.cst_decode(),
11074                spacing: self.spacing.cst_decode(),
11075                symbol: self.symbol.cst_decode(),
11076            }
11077        }
11078    }
11079    impl CstDecode<crate::bindings::LocalizedName> for wire_cst_localized_name {
11080        // Codec=Cst (C-struct based), see doc to use other codecs
11081        fn cst_decode(self) -> crate::bindings::LocalizedName {
11082            crate::bindings::LocalizedName {
11083                locale: self.locale.cst_decode(),
11084                name: self.name.cst_decode(),
11085            }
11086        }
11087    }
11088    impl CstDecode<crate::model::LogEntry> for wire_cst_log_entry {
11089        // Codec=Cst (C-struct based), see doc to use other codecs
11090        fn cst_decode(self) -> crate::model::LogEntry {
11091            crate::model::LogEntry {
11092                line: self.line.cst_decode(),
11093                level: self.level.cst_decode(),
11094            }
11095        }
11096    }
11097    impl CstDecode<crate::bindings::MessageSuccessActionData> for wire_cst_message_success_action_data {
11098        // Codec=Cst (C-struct based), see doc to use other codecs
11099        fn cst_decode(self) -> crate::bindings::MessageSuccessActionData {
11100            crate::bindings::MessageSuccessActionData {
11101                message: self.message.cst_decode(),
11102            }
11103        }
11104    }
11105    impl CstDecode<crate::model::OnchainPaymentLimitsResponse>
11106        for wire_cst_onchain_payment_limits_response
11107    {
11108        // Codec=Cst (C-struct based), see doc to use other codecs
11109        fn cst_decode(self) -> crate::model::OnchainPaymentLimitsResponse {
11110            crate::model::OnchainPaymentLimitsResponse {
11111                send: self.send.cst_decode(),
11112                receive: self.receive.cst_decode(),
11113            }
11114        }
11115    }
11116    impl CstDecode<crate::model::PayAmount> for wire_cst_pay_amount {
11117        // Codec=Cst (C-struct based), see doc to use other codecs
11118        fn cst_decode(self) -> crate::model::PayAmount {
11119            match self.tag {
11120                0 => {
11121                    let ans = unsafe { self.kind.Bitcoin };
11122                    crate::model::PayAmount::Bitcoin {
11123                        receiver_amount_sat: ans.receiver_amount_sat.cst_decode(),
11124                    }
11125                }
11126                1 => {
11127                    let ans = unsafe { self.kind.Asset };
11128                    crate::model::PayAmount::Asset {
11129                        asset_id: ans.asset_id.cst_decode(),
11130                        receiver_amount: ans.receiver_amount.cst_decode(),
11131                        estimate_asset_fees: ans.estimate_asset_fees.cst_decode(),
11132                    }
11133                }
11134                2 => crate::model::PayAmount::Drain,
11135                _ => unreachable!(),
11136            }
11137        }
11138    }
11139    impl CstDecode<crate::model::PayOnchainRequest> for wire_cst_pay_onchain_request {
11140        // Codec=Cst (C-struct based), see doc to use other codecs
11141        fn cst_decode(self) -> crate::model::PayOnchainRequest {
11142            crate::model::PayOnchainRequest {
11143                address: self.address.cst_decode(),
11144                prepare_response: self.prepare_response.cst_decode(),
11145            }
11146        }
11147    }
11148    impl CstDecode<crate::model::Payment> for wire_cst_payment {
11149        // Codec=Cst (C-struct based), see doc to use other codecs
11150        fn cst_decode(self) -> crate::model::Payment {
11151            crate::model::Payment {
11152                destination: self.destination.cst_decode(),
11153                tx_id: self.tx_id.cst_decode(),
11154                unblinding_data: self.unblinding_data.cst_decode(),
11155                timestamp: self.timestamp.cst_decode(),
11156                amount_sat: self.amount_sat.cst_decode(),
11157                fees_sat: self.fees_sat.cst_decode(),
11158                swapper_fees_sat: self.swapper_fees_sat.cst_decode(),
11159                payment_type: self.payment_type.cst_decode(),
11160                status: self.status.cst_decode(),
11161                details: self.details.cst_decode(),
11162            }
11163        }
11164    }
11165    impl CstDecode<crate::model::PaymentDetails> for wire_cst_payment_details {
11166        // Codec=Cst (C-struct based), see doc to use other codecs
11167        fn cst_decode(self) -> crate::model::PaymentDetails {
11168            match self.tag {
11169                0 => {
11170                    let ans = unsafe { self.kind.Lightning };
11171                    crate::model::PaymentDetails::Lightning {
11172                        swap_id: ans.swap_id.cst_decode(),
11173                        description: ans.description.cst_decode(),
11174                        liquid_expiration_blockheight: ans
11175                            .liquid_expiration_blockheight
11176                            .cst_decode(),
11177                        preimage: ans.preimage.cst_decode(),
11178                        invoice: ans.invoice.cst_decode(),
11179                        bolt12_offer: ans.bolt12_offer.cst_decode(),
11180                        payment_hash: ans.payment_hash.cst_decode(),
11181                        destination_pubkey: ans.destination_pubkey.cst_decode(),
11182                        lnurl_info: ans.lnurl_info.cst_decode(),
11183                        bip353_address: ans.bip353_address.cst_decode(),
11184                        claim_tx_id: ans.claim_tx_id.cst_decode(),
11185                        refund_tx_id: ans.refund_tx_id.cst_decode(),
11186                        refund_tx_amount_sat: ans.refund_tx_amount_sat.cst_decode(),
11187                    }
11188                }
11189                1 => {
11190                    let ans = unsafe { self.kind.Liquid };
11191                    crate::model::PaymentDetails::Liquid {
11192                        destination: ans.destination.cst_decode(),
11193                        description: ans.description.cst_decode(),
11194                        asset_id: ans.asset_id.cst_decode(),
11195                        asset_info: ans.asset_info.cst_decode(),
11196                        lnurl_info: ans.lnurl_info.cst_decode(),
11197                        bip353_address: ans.bip353_address.cst_decode(),
11198                    }
11199                }
11200                2 => {
11201                    let ans = unsafe { self.kind.Bitcoin };
11202                    crate::model::PaymentDetails::Bitcoin {
11203                        swap_id: ans.swap_id.cst_decode(),
11204                        bitcoin_address: ans.bitcoin_address.cst_decode(),
11205                        description: ans.description.cst_decode(),
11206                        auto_accepted_fees: ans.auto_accepted_fees.cst_decode(),
11207                        liquid_expiration_blockheight: ans
11208                            .liquid_expiration_blockheight
11209                            .cst_decode(),
11210                        bitcoin_expiration_blockheight: ans
11211                            .bitcoin_expiration_blockheight
11212                            .cst_decode(),
11213                        lockup_tx_id: ans.lockup_tx_id.cst_decode(),
11214                        claim_tx_id: ans.claim_tx_id.cst_decode(),
11215                        refund_tx_id: ans.refund_tx_id.cst_decode(),
11216                        refund_tx_amount_sat: ans.refund_tx_amount_sat.cst_decode(),
11217                    }
11218                }
11219                _ => unreachable!(),
11220            }
11221        }
11222    }
11223    impl CstDecode<crate::error::PaymentError> for wire_cst_payment_error {
11224        // Codec=Cst (C-struct based), see doc to use other codecs
11225        fn cst_decode(self) -> crate::error::PaymentError {
11226            match self.tag {
11227                0 => crate::error::PaymentError::AlreadyClaimed,
11228                1 => crate::error::PaymentError::AlreadyPaid,
11229                2 => crate::error::PaymentError::PaymentInProgress,
11230                3 => {
11231                    let ans = unsafe { self.kind.AmountOutOfRange };
11232                    crate::error::PaymentError::AmountOutOfRange {
11233                        min: ans.min.cst_decode(),
11234                        max: ans.max.cst_decode(),
11235                    }
11236                }
11237                4 => {
11238                    let ans = unsafe { self.kind.AmountMissing };
11239                    crate::error::PaymentError::AmountMissing {
11240                        err: ans.err.cst_decode(),
11241                    }
11242                }
11243                5 => {
11244                    let ans = unsafe { self.kind.AssetError };
11245                    crate::error::PaymentError::AssetError {
11246                        err: ans.err.cst_decode(),
11247                    }
11248                }
11249                6 => {
11250                    let ans = unsafe { self.kind.InvalidNetwork };
11251                    crate::error::PaymentError::InvalidNetwork {
11252                        err: ans.err.cst_decode(),
11253                    }
11254                }
11255                7 => {
11256                    let ans = unsafe { self.kind.Generic };
11257                    crate::error::PaymentError::Generic {
11258                        err: ans.err.cst_decode(),
11259                    }
11260                }
11261                8 => crate::error::PaymentError::InvalidOrExpiredFees,
11262                9 => crate::error::PaymentError::InsufficientFunds,
11263                10 => {
11264                    let ans = unsafe { self.kind.InvalidDescription };
11265                    crate::error::PaymentError::InvalidDescription {
11266                        err: ans.err.cst_decode(),
11267                    }
11268                }
11269                11 => {
11270                    let ans = unsafe { self.kind.InvalidInvoice };
11271                    crate::error::PaymentError::InvalidInvoice {
11272                        err: ans.err.cst_decode(),
11273                    }
11274                }
11275                12 => crate::error::PaymentError::InvalidPreimage,
11276                13 => crate::error::PaymentError::PairsNotFound,
11277                14 => crate::error::PaymentError::PaymentTimeout,
11278                15 => crate::error::PaymentError::PersistError,
11279                16 => {
11280                    let ans = unsafe { self.kind.ReceiveError };
11281                    crate::error::PaymentError::ReceiveError {
11282                        err: ans.err.cst_decode(),
11283                    }
11284                }
11285                17 => {
11286                    let ans = unsafe { self.kind.Refunded };
11287                    crate::error::PaymentError::Refunded {
11288                        err: ans.err.cst_decode(),
11289                        refund_tx_id: ans.refund_tx_id.cst_decode(),
11290                    }
11291                }
11292                18 => crate::error::PaymentError::SelfTransferNotSupported,
11293                19 => {
11294                    let ans = unsafe { self.kind.SendError };
11295                    crate::error::PaymentError::SendError {
11296                        err: ans.err.cst_decode(),
11297                    }
11298                }
11299                20 => {
11300                    let ans = unsafe { self.kind.SignerError };
11301                    crate::error::PaymentError::SignerError {
11302                        err: ans.err.cst_decode(),
11303                    }
11304                }
11305                _ => unreachable!(),
11306            }
11307        }
11308    }
11309    impl CstDecode<crate::model::PrepareBuyBitcoinRequest> for wire_cst_prepare_buy_bitcoin_request {
11310        // Codec=Cst (C-struct based), see doc to use other codecs
11311        fn cst_decode(self) -> crate::model::PrepareBuyBitcoinRequest {
11312            crate::model::PrepareBuyBitcoinRequest {
11313                provider: self.provider.cst_decode(),
11314                amount_sat: self.amount_sat.cst_decode(),
11315            }
11316        }
11317    }
11318    impl CstDecode<crate::model::PrepareBuyBitcoinResponse> for wire_cst_prepare_buy_bitcoin_response {
11319        // Codec=Cst (C-struct based), see doc to use other codecs
11320        fn cst_decode(self) -> crate::model::PrepareBuyBitcoinResponse {
11321            crate::model::PrepareBuyBitcoinResponse {
11322                provider: self.provider.cst_decode(),
11323                amount_sat: self.amount_sat.cst_decode(),
11324                fees_sat: self.fees_sat.cst_decode(),
11325            }
11326        }
11327    }
11328    impl CstDecode<crate::model::PrepareLnUrlPayRequest> for wire_cst_prepare_ln_url_pay_request {
11329        // Codec=Cst (C-struct based), see doc to use other codecs
11330        fn cst_decode(self) -> crate::model::PrepareLnUrlPayRequest {
11331            crate::model::PrepareLnUrlPayRequest {
11332                data: self.data.cst_decode(),
11333                amount: self.amount.cst_decode(),
11334                bip353_address: self.bip353_address.cst_decode(),
11335                comment: self.comment.cst_decode(),
11336                validate_success_action_url: self.validate_success_action_url.cst_decode(),
11337            }
11338        }
11339    }
11340    impl CstDecode<crate::model::PrepareLnUrlPayResponse> for wire_cst_prepare_ln_url_pay_response {
11341        // Codec=Cst (C-struct based), see doc to use other codecs
11342        fn cst_decode(self) -> crate::model::PrepareLnUrlPayResponse {
11343            crate::model::PrepareLnUrlPayResponse {
11344                destination: self.destination.cst_decode(),
11345                fees_sat: self.fees_sat.cst_decode(),
11346                data: self.data.cst_decode(),
11347                amount: self.amount.cst_decode(),
11348                comment: self.comment.cst_decode(),
11349                success_action: self.success_action.cst_decode(),
11350            }
11351        }
11352    }
11353    impl CstDecode<crate::model::PreparePayOnchainRequest> for wire_cst_prepare_pay_onchain_request {
11354        // Codec=Cst (C-struct based), see doc to use other codecs
11355        fn cst_decode(self) -> crate::model::PreparePayOnchainRequest {
11356            crate::model::PreparePayOnchainRequest {
11357                amount: self.amount.cst_decode(),
11358                fee_rate_sat_per_vbyte: self.fee_rate_sat_per_vbyte.cst_decode(),
11359            }
11360        }
11361    }
11362    impl CstDecode<crate::model::PreparePayOnchainResponse> for wire_cst_prepare_pay_onchain_response {
11363        // Codec=Cst (C-struct based), see doc to use other codecs
11364        fn cst_decode(self) -> crate::model::PreparePayOnchainResponse {
11365            crate::model::PreparePayOnchainResponse {
11366                receiver_amount_sat: self.receiver_amount_sat.cst_decode(),
11367                claim_fees_sat: self.claim_fees_sat.cst_decode(),
11368                total_fees_sat: self.total_fees_sat.cst_decode(),
11369            }
11370        }
11371    }
11372    impl CstDecode<crate::model::PrepareReceiveRequest> for wire_cst_prepare_receive_request {
11373        // Codec=Cst (C-struct based), see doc to use other codecs
11374        fn cst_decode(self) -> crate::model::PrepareReceiveRequest {
11375            crate::model::PrepareReceiveRequest {
11376                payment_method: self.payment_method.cst_decode(),
11377                amount: self.amount.cst_decode(),
11378            }
11379        }
11380    }
11381    impl CstDecode<crate::model::PrepareReceiveResponse> for wire_cst_prepare_receive_response {
11382        // Codec=Cst (C-struct based), see doc to use other codecs
11383        fn cst_decode(self) -> crate::model::PrepareReceiveResponse {
11384            crate::model::PrepareReceiveResponse {
11385                payment_method: self.payment_method.cst_decode(),
11386                fees_sat: self.fees_sat.cst_decode(),
11387                amount: self.amount.cst_decode(),
11388                min_payer_amount_sat: self.min_payer_amount_sat.cst_decode(),
11389                max_payer_amount_sat: self.max_payer_amount_sat.cst_decode(),
11390                swapper_feerate: self.swapper_feerate.cst_decode(),
11391            }
11392        }
11393    }
11394    impl CstDecode<crate::model::PrepareRefundRequest> for wire_cst_prepare_refund_request {
11395        // Codec=Cst (C-struct based), see doc to use other codecs
11396        fn cst_decode(self) -> crate::model::PrepareRefundRequest {
11397            crate::model::PrepareRefundRequest {
11398                swap_address: self.swap_address.cst_decode(),
11399                refund_address: self.refund_address.cst_decode(),
11400                fee_rate_sat_per_vbyte: self.fee_rate_sat_per_vbyte.cst_decode(),
11401            }
11402        }
11403    }
11404    impl CstDecode<crate::model::PrepareRefundResponse> for wire_cst_prepare_refund_response {
11405        // Codec=Cst (C-struct based), see doc to use other codecs
11406        fn cst_decode(self) -> crate::model::PrepareRefundResponse {
11407            crate::model::PrepareRefundResponse {
11408                tx_vsize: self.tx_vsize.cst_decode(),
11409                tx_fee_sat: self.tx_fee_sat.cst_decode(),
11410                last_refund_tx_id: self.last_refund_tx_id.cst_decode(),
11411            }
11412        }
11413    }
11414    impl CstDecode<crate::model::PrepareSendRequest> for wire_cst_prepare_send_request {
11415        // Codec=Cst (C-struct based), see doc to use other codecs
11416        fn cst_decode(self) -> crate::model::PrepareSendRequest {
11417            crate::model::PrepareSendRequest {
11418                destination: self.destination.cst_decode(),
11419                amount: self.amount.cst_decode(),
11420                comment: self.comment.cst_decode(),
11421            }
11422        }
11423    }
11424    impl CstDecode<crate::model::PrepareSendResponse> for wire_cst_prepare_send_response {
11425        // Codec=Cst (C-struct based), see doc to use other codecs
11426        fn cst_decode(self) -> crate::model::PrepareSendResponse {
11427            crate::model::PrepareSendResponse {
11428                destination: self.destination.cst_decode(),
11429                amount: self.amount.cst_decode(),
11430                fees_sat: self.fees_sat.cst_decode(),
11431                estimated_asset_fees: self.estimated_asset_fees.cst_decode(),
11432            }
11433        }
11434    }
11435    impl CstDecode<crate::bindings::Rate> for wire_cst_rate {
11436        // Codec=Cst (C-struct based), see doc to use other codecs
11437        fn cst_decode(self) -> crate::bindings::Rate {
11438            crate::bindings::Rate {
11439                coin: self.coin.cst_decode(),
11440                value: self.value.cst_decode(),
11441            }
11442        }
11443    }
11444    impl CstDecode<crate::model::ReceiveAmount> for wire_cst_receive_amount {
11445        // Codec=Cst (C-struct based), see doc to use other codecs
11446        fn cst_decode(self) -> crate::model::ReceiveAmount {
11447            match self.tag {
11448                0 => {
11449                    let ans = unsafe { self.kind.Bitcoin };
11450                    crate::model::ReceiveAmount::Bitcoin {
11451                        payer_amount_sat: ans.payer_amount_sat.cst_decode(),
11452                    }
11453                }
11454                1 => {
11455                    let ans = unsafe { self.kind.Asset };
11456                    crate::model::ReceiveAmount::Asset {
11457                        asset_id: ans.asset_id.cst_decode(),
11458                        payer_amount: ans.payer_amount.cst_decode(),
11459                    }
11460                }
11461                _ => unreachable!(),
11462            }
11463        }
11464    }
11465    impl CstDecode<crate::model::ReceivePaymentRequest> for wire_cst_receive_payment_request {
11466        // Codec=Cst (C-struct based), see doc to use other codecs
11467        fn cst_decode(self) -> crate::model::ReceivePaymentRequest {
11468            crate::model::ReceivePaymentRequest {
11469                prepare_response: self.prepare_response.cst_decode(),
11470                description: self.description.cst_decode(),
11471                use_description_hash: self.use_description_hash.cst_decode(),
11472            }
11473        }
11474    }
11475    impl CstDecode<crate::model::ReceivePaymentResponse> for wire_cst_receive_payment_response {
11476        // Codec=Cst (C-struct based), see doc to use other codecs
11477        fn cst_decode(self) -> crate::model::ReceivePaymentResponse {
11478            crate::model::ReceivePaymentResponse {
11479                destination: self.destination.cst_decode(),
11480            }
11481        }
11482    }
11483    impl CstDecode<crate::model::RecommendedFees> for wire_cst_recommended_fees {
11484        // Codec=Cst (C-struct based), see doc to use other codecs
11485        fn cst_decode(self) -> crate::model::RecommendedFees {
11486            crate::model::RecommendedFees {
11487                fastest_fee: self.fastest_fee.cst_decode(),
11488                half_hour_fee: self.half_hour_fee.cst_decode(),
11489                hour_fee: self.hour_fee.cst_decode(),
11490                economy_fee: self.economy_fee.cst_decode(),
11491                minimum_fee: self.minimum_fee.cst_decode(),
11492            }
11493        }
11494    }
11495    impl CstDecode<crate::model::RefundRequest> for wire_cst_refund_request {
11496        // Codec=Cst (C-struct based), see doc to use other codecs
11497        fn cst_decode(self) -> crate::model::RefundRequest {
11498            crate::model::RefundRequest {
11499                swap_address: self.swap_address.cst_decode(),
11500                refund_address: self.refund_address.cst_decode(),
11501                fee_rate_sat_per_vbyte: self.fee_rate_sat_per_vbyte.cst_decode(),
11502            }
11503        }
11504    }
11505    impl CstDecode<crate::model::RefundResponse> for wire_cst_refund_response {
11506        // Codec=Cst (C-struct based), see doc to use other codecs
11507        fn cst_decode(self) -> crate::model::RefundResponse {
11508            crate::model::RefundResponse {
11509                refund_tx_id: self.refund_tx_id.cst_decode(),
11510            }
11511        }
11512    }
11513    impl CstDecode<crate::model::RefundableSwap> for wire_cst_refundable_swap {
11514        // Codec=Cst (C-struct based), see doc to use other codecs
11515        fn cst_decode(self) -> crate::model::RefundableSwap {
11516            crate::model::RefundableSwap {
11517                swap_address: self.swap_address.cst_decode(),
11518                timestamp: self.timestamp.cst_decode(),
11519                amount_sat: self.amount_sat.cst_decode(),
11520                last_refund_tx_id: self.last_refund_tx_id.cst_decode(),
11521            }
11522        }
11523    }
11524    impl CstDecode<crate::model::RestoreRequest> for wire_cst_restore_request {
11525        // Codec=Cst (C-struct based), see doc to use other codecs
11526        fn cst_decode(self) -> crate::model::RestoreRequest {
11527            crate::model::RestoreRequest {
11528                backup_path: self.backup_path.cst_decode(),
11529            }
11530        }
11531    }
11532    impl CstDecode<crate::bindings::RouteHint> for wire_cst_route_hint {
11533        // Codec=Cst (C-struct based), see doc to use other codecs
11534        fn cst_decode(self) -> crate::bindings::RouteHint {
11535            crate::bindings::RouteHint {
11536                hops: self.hops.cst_decode(),
11537            }
11538        }
11539    }
11540    impl CstDecode<crate::bindings::RouteHintHop> for wire_cst_route_hint_hop {
11541        // Codec=Cst (C-struct based), see doc to use other codecs
11542        fn cst_decode(self) -> crate::bindings::RouteHintHop {
11543            crate::bindings::RouteHintHop {
11544                src_node_id: self.src_node_id.cst_decode(),
11545                short_channel_id: self.short_channel_id.cst_decode(),
11546                fees_base_msat: self.fees_base_msat.cst_decode(),
11547                fees_proportional_millionths: self.fees_proportional_millionths.cst_decode(),
11548                cltv_expiry_delta: self.cltv_expiry_delta.cst_decode(),
11549                htlc_minimum_msat: self.htlc_minimum_msat.cst_decode(),
11550                htlc_maximum_msat: self.htlc_maximum_msat.cst_decode(),
11551            }
11552        }
11553    }
11554    impl CstDecode<crate::error::SdkError> for wire_cst_sdk_error {
11555        // Codec=Cst (C-struct based), see doc to use other codecs
11556        fn cst_decode(self) -> crate::error::SdkError {
11557            match self.tag {
11558                0 => crate::error::SdkError::AlreadyStarted,
11559                1 => {
11560                    let ans = unsafe { self.kind.Generic };
11561                    crate::error::SdkError::Generic {
11562                        err: ans.err.cst_decode(),
11563                    }
11564                }
11565                2 => crate::error::SdkError::NotStarted,
11566                3 => {
11567                    let ans = unsafe { self.kind.ServiceConnectivity };
11568                    crate::error::SdkError::ServiceConnectivity {
11569                        err: ans.err.cst_decode(),
11570                    }
11571                }
11572                _ => unreachable!(),
11573            }
11574        }
11575    }
11576    impl CstDecode<crate::model::SdkEvent> for wire_cst_sdk_event {
11577        // Codec=Cst (C-struct based), see doc to use other codecs
11578        fn cst_decode(self) -> crate::model::SdkEvent {
11579            match self.tag {
11580                0 => {
11581                    let ans = unsafe { self.kind.PaymentFailed };
11582                    crate::model::SdkEvent::PaymentFailed {
11583                        details: ans.details.cst_decode(),
11584                    }
11585                }
11586                1 => {
11587                    let ans = unsafe { self.kind.PaymentPending };
11588                    crate::model::SdkEvent::PaymentPending {
11589                        details: ans.details.cst_decode(),
11590                    }
11591                }
11592                2 => {
11593                    let ans = unsafe { self.kind.PaymentRefundable };
11594                    crate::model::SdkEvent::PaymentRefundable {
11595                        details: ans.details.cst_decode(),
11596                    }
11597                }
11598                3 => {
11599                    let ans = unsafe { self.kind.PaymentRefunded };
11600                    crate::model::SdkEvent::PaymentRefunded {
11601                        details: ans.details.cst_decode(),
11602                    }
11603                }
11604                4 => {
11605                    let ans = unsafe { self.kind.PaymentRefundPending };
11606                    crate::model::SdkEvent::PaymentRefundPending {
11607                        details: ans.details.cst_decode(),
11608                    }
11609                }
11610                5 => {
11611                    let ans = unsafe { self.kind.PaymentSucceeded };
11612                    crate::model::SdkEvent::PaymentSucceeded {
11613                        details: ans.details.cst_decode(),
11614                    }
11615                }
11616                6 => {
11617                    let ans = unsafe { self.kind.PaymentWaitingConfirmation };
11618                    crate::model::SdkEvent::PaymentWaitingConfirmation {
11619                        details: ans.details.cst_decode(),
11620                    }
11621                }
11622                7 => {
11623                    let ans = unsafe { self.kind.PaymentWaitingFeeAcceptance };
11624                    crate::model::SdkEvent::PaymentWaitingFeeAcceptance {
11625                        details: ans.details.cst_decode(),
11626                    }
11627                }
11628                8 => crate::model::SdkEvent::Synced,
11629                9 => {
11630                    let ans = unsafe { self.kind.DataSynced };
11631                    crate::model::SdkEvent::DataSynced {
11632                        did_pull_new_records: ans.did_pull_new_records.cst_decode(),
11633                    }
11634                }
11635                _ => unreachable!(),
11636            }
11637        }
11638    }
11639    impl CstDecode<crate::model::SendDestination> for wire_cst_send_destination {
11640        // Codec=Cst (C-struct based), see doc to use other codecs
11641        fn cst_decode(self) -> crate::model::SendDestination {
11642            match self.tag {
11643                0 => {
11644                    let ans = unsafe { self.kind.LiquidAddress };
11645                    crate::model::SendDestination::LiquidAddress {
11646                        address_data: ans.address_data.cst_decode(),
11647                        bip353_address: ans.bip353_address.cst_decode(),
11648                    }
11649                }
11650                1 => {
11651                    let ans = unsafe { self.kind.Bolt11 };
11652                    crate::model::SendDestination::Bolt11 {
11653                        invoice: ans.invoice.cst_decode(),
11654                        bip353_address: ans.bip353_address.cst_decode(),
11655                    }
11656                }
11657                2 => {
11658                    let ans = unsafe { self.kind.Bolt12 };
11659                    crate::model::SendDestination::Bolt12 {
11660                        offer: ans.offer.cst_decode(),
11661                        receiver_amount_sat: ans.receiver_amount_sat.cst_decode(),
11662                        bip353_address: ans.bip353_address.cst_decode(),
11663                        payer_note: ans.payer_note.cst_decode(),
11664                    }
11665                }
11666                _ => unreachable!(),
11667            }
11668        }
11669    }
11670    impl CstDecode<crate::model::SendPaymentRequest> for wire_cst_send_payment_request {
11671        // Codec=Cst (C-struct based), see doc to use other codecs
11672        fn cst_decode(self) -> crate::model::SendPaymentRequest {
11673            crate::model::SendPaymentRequest {
11674                prepare_response: self.prepare_response.cst_decode(),
11675                use_asset_fees: self.use_asset_fees.cst_decode(),
11676            }
11677        }
11678    }
11679    impl CstDecode<crate::model::SendPaymentResponse> for wire_cst_send_payment_response {
11680        // Codec=Cst (C-struct based), see doc to use other codecs
11681        fn cst_decode(self) -> crate::model::SendPaymentResponse {
11682            crate::model::SendPaymentResponse {
11683                payment: self.payment.cst_decode(),
11684            }
11685        }
11686    }
11687    impl CstDecode<crate::model::SignMessageRequest> for wire_cst_sign_message_request {
11688        // Codec=Cst (C-struct based), see doc to use other codecs
11689        fn cst_decode(self) -> crate::model::SignMessageRequest {
11690            crate::model::SignMessageRequest {
11691                message: self.message.cst_decode(),
11692            }
11693        }
11694    }
11695    impl CstDecode<crate::model::SignMessageResponse> for wire_cst_sign_message_response {
11696        // Codec=Cst (C-struct based), see doc to use other codecs
11697        fn cst_decode(self) -> crate::model::SignMessageResponse {
11698            crate::model::SignMessageResponse {
11699                signature: self.signature.cst_decode(),
11700            }
11701        }
11702    }
11703    impl CstDecode<crate::bindings::SuccessAction> for wire_cst_success_action {
11704        // Codec=Cst (C-struct based), see doc to use other codecs
11705        fn cst_decode(self) -> crate::bindings::SuccessAction {
11706            match self.tag {
11707                0 => {
11708                    let ans = unsafe { self.kind.Aes };
11709                    crate::bindings::SuccessAction::Aes {
11710                        data: ans.data.cst_decode(),
11711                    }
11712                }
11713                1 => {
11714                    let ans = unsafe { self.kind.Message };
11715                    crate::bindings::SuccessAction::Message {
11716                        data: ans.data.cst_decode(),
11717                    }
11718                }
11719                2 => {
11720                    let ans = unsafe { self.kind.Url };
11721                    crate::bindings::SuccessAction::Url {
11722                        data: ans.data.cst_decode(),
11723                    }
11724                }
11725                _ => unreachable!(),
11726            }
11727        }
11728    }
11729    impl CstDecode<crate::bindings::SuccessActionProcessed> for wire_cst_success_action_processed {
11730        // Codec=Cst (C-struct based), see doc to use other codecs
11731        fn cst_decode(self) -> crate::bindings::SuccessActionProcessed {
11732            match self.tag {
11733                0 => {
11734                    let ans = unsafe { self.kind.Aes };
11735                    crate::bindings::SuccessActionProcessed::Aes {
11736                        result: ans.result.cst_decode(),
11737                    }
11738                }
11739                1 => {
11740                    let ans = unsafe { self.kind.Message };
11741                    crate::bindings::SuccessActionProcessed::Message {
11742                        data: ans.data.cst_decode(),
11743                    }
11744                }
11745                2 => {
11746                    let ans = unsafe { self.kind.Url };
11747                    crate::bindings::SuccessActionProcessed::Url {
11748                        data: ans.data.cst_decode(),
11749                    }
11750                }
11751                _ => unreachable!(),
11752            }
11753        }
11754    }
11755    impl CstDecode<crate::bindings::Symbol> for wire_cst_symbol {
11756        // Codec=Cst (C-struct based), see doc to use other codecs
11757        fn cst_decode(self) -> crate::bindings::Symbol {
11758            crate::bindings::Symbol {
11759                grapheme: self.grapheme.cst_decode(),
11760                template: self.template.cst_decode(),
11761                rtl: self.rtl.cst_decode(),
11762                position: self.position.cst_decode(),
11763            }
11764        }
11765    }
11766    impl CstDecode<crate::bindings::UrlSuccessActionData> for wire_cst_url_success_action_data {
11767        // Codec=Cst (C-struct based), see doc to use other codecs
11768        fn cst_decode(self) -> crate::bindings::UrlSuccessActionData {
11769            crate::bindings::UrlSuccessActionData {
11770                description: self.description.cst_decode(),
11771                url: self.url.cst_decode(),
11772                matches_callback_domain: self.matches_callback_domain.cst_decode(),
11773            }
11774        }
11775    }
11776    impl CstDecode<crate::model::WalletInfo> for wire_cst_wallet_info {
11777        // Codec=Cst (C-struct based), see doc to use other codecs
11778        fn cst_decode(self) -> crate::model::WalletInfo {
11779            crate::model::WalletInfo {
11780                balance_sat: self.balance_sat.cst_decode(),
11781                pending_send_sat: self.pending_send_sat.cst_decode(),
11782                pending_receive_sat: self.pending_receive_sat.cst_decode(),
11783                fingerprint: self.fingerprint.cst_decode(),
11784                pubkey: self.pubkey.cst_decode(),
11785                asset_balances: self.asset_balances.cst_decode(),
11786            }
11787        }
11788    }
11789    impl NewWithNullPtr for wire_cst_accept_payment_proposed_fees_request {
11790        fn new_with_null_ptr() -> Self {
11791            Self {
11792                response: Default::default(),
11793            }
11794        }
11795    }
11796    impl Default for wire_cst_accept_payment_proposed_fees_request {
11797        fn default() -> Self {
11798            Self::new_with_null_ptr()
11799        }
11800    }
11801    impl NewWithNullPtr for wire_cst_aes_success_action_data {
11802        fn new_with_null_ptr() -> Self {
11803            Self {
11804                description: core::ptr::null_mut(),
11805                ciphertext: core::ptr::null_mut(),
11806                iv: core::ptr::null_mut(),
11807            }
11808        }
11809    }
11810    impl Default for wire_cst_aes_success_action_data {
11811        fn default() -> Self {
11812            Self::new_with_null_ptr()
11813        }
11814    }
11815    impl NewWithNullPtr for wire_cst_aes_success_action_data_decrypted {
11816        fn new_with_null_ptr() -> Self {
11817            Self {
11818                description: core::ptr::null_mut(),
11819                plaintext: core::ptr::null_mut(),
11820            }
11821        }
11822    }
11823    impl Default for wire_cst_aes_success_action_data_decrypted {
11824        fn default() -> Self {
11825            Self::new_with_null_ptr()
11826        }
11827    }
11828    impl NewWithNullPtr for wire_cst_aes_success_action_data_result {
11829        fn new_with_null_ptr() -> Self {
11830            Self {
11831                tag: -1,
11832                kind: AesSuccessActionDataResultKind { nil__: () },
11833            }
11834        }
11835    }
11836    impl Default for wire_cst_aes_success_action_data_result {
11837        fn default() -> Self {
11838            Self::new_with_null_ptr()
11839        }
11840    }
11841    impl NewWithNullPtr for wire_cst_amount {
11842        fn new_with_null_ptr() -> Self {
11843            Self {
11844                tag: -1,
11845                kind: AmountKind { nil__: () },
11846            }
11847        }
11848    }
11849    impl Default for wire_cst_amount {
11850        fn default() -> Self {
11851            Self::new_with_null_ptr()
11852        }
11853    }
11854    impl NewWithNullPtr for wire_cst_asset_balance {
11855        fn new_with_null_ptr() -> Self {
11856            Self {
11857                asset_id: core::ptr::null_mut(),
11858                balance_sat: Default::default(),
11859                name: core::ptr::null_mut(),
11860                ticker: core::ptr::null_mut(),
11861                balance: core::ptr::null_mut(),
11862            }
11863        }
11864    }
11865    impl Default for wire_cst_asset_balance {
11866        fn default() -> Self {
11867            Self::new_with_null_ptr()
11868        }
11869    }
11870    impl NewWithNullPtr for wire_cst_asset_info {
11871        fn new_with_null_ptr() -> Self {
11872            Self {
11873                name: core::ptr::null_mut(),
11874                ticker: core::ptr::null_mut(),
11875                amount: Default::default(),
11876                fees: core::ptr::null_mut(),
11877            }
11878        }
11879    }
11880    impl Default for wire_cst_asset_info {
11881        fn default() -> Self {
11882            Self::new_with_null_ptr()
11883        }
11884    }
11885    impl NewWithNullPtr for wire_cst_asset_metadata {
11886        fn new_with_null_ptr() -> Self {
11887            Self {
11888                asset_id: core::ptr::null_mut(),
11889                name: core::ptr::null_mut(),
11890                ticker: core::ptr::null_mut(),
11891                precision: Default::default(),
11892                fiat_id: core::ptr::null_mut(),
11893            }
11894        }
11895    }
11896    impl Default for wire_cst_asset_metadata {
11897        fn default() -> Self {
11898            Self::new_with_null_ptr()
11899        }
11900    }
11901    impl NewWithNullPtr for wire_cst_backup_request {
11902        fn new_with_null_ptr() -> Self {
11903            Self {
11904                backup_path: core::ptr::null_mut(),
11905            }
11906        }
11907    }
11908    impl Default for wire_cst_backup_request {
11909        fn default() -> Self {
11910            Self::new_with_null_ptr()
11911        }
11912    }
11913    impl NewWithNullPtr for wire_cst_binding_event_listener {
11914        fn new_with_null_ptr() -> Self {
11915            Self {
11916                stream: core::ptr::null_mut(),
11917            }
11918        }
11919    }
11920    impl Default for wire_cst_binding_event_listener {
11921        fn default() -> Self {
11922            Self::new_with_null_ptr()
11923        }
11924    }
11925    impl NewWithNullPtr for wire_cst_bitcoin_address_data {
11926        fn new_with_null_ptr() -> Self {
11927            Self {
11928                address: core::ptr::null_mut(),
11929                network: Default::default(),
11930                amount_sat: core::ptr::null_mut(),
11931                label: core::ptr::null_mut(),
11932                message: core::ptr::null_mut(),
11933            }
11934        }
11935    }
11936    impl Default for wire_cst_bitcoin_address_data {
11937        fn default() -> Self {
11938            Self::new_with_null_ptr()
11939        }
11940    }
11941    impl NewWithNullPtr for wire_cst_blockchain_explorer {
11942        fn new_with_null_ptr() -> Self {
11943            Self {
11944                tag: -1,
11945                kind: BlockchainExplorerKind { nil__: () },
11946            }
11947        }
11948    }
11949    impl Default for wire_cst_blockchain_explorer {
11950        fn default() -> Self {
11951            Self::new_with_null_ptr()
11952        }
11953    }
11954    impl NewWithNullPtr for wire_cst_blockchain_info {
11955        fn new_with_null_ptr() -> Self {
11956            Self {
11957                liquid_tip: Default::default(),
11958                bitcoin_tip: Default::default(),
11959            }
11960        }
11961    }
11962    impl Default for wire_cst_blockchain_info {
11963        fn default() -> Self {
11964            Self::new_with_null_ptr()
11965        }
11966    }
11967    impl NewWithNullPtr for wire_cst_buy_bitcoin_request {
11968        fn new_with_null_ptr() -> Self {
11969            Self {
11970                prepare_response: Default::default(),
11971                redirect_url: core::ptr::null_mut(),
11972            }
11973        }
11974    }
11975    impl Default for wire_cst_buy_bitcoin_request {
11976        fn default() -> Self {
11977            Self::new_with_null_ptr()
11978        }
11979    }
11980    impl NewWithNullPtr for wire_cst_check_message_request {
11981        fn new_with_null_ptr() -> Self {
11982            Self {
11983                message: core::ptr::null_mut(),
11984                pubkey: core::ptr::null_mut(),
11985                signature: core::ptr::null_mut(),
11986            }
11987        }
11988    }
11989    impl Default for wire_cst_check_message_request {
11990        fn default() -> Self {
11991            Self::new_with_null_ptr()
11992        }
11993    }
11994    impl NewWithNullPtr for wire_cst_check_message_response {
11995        fn new_with_null_ptr() -> Self {
11996            Self {
11997                is_valid: Default::default(),
11998            }
11999        }
12000    }
12001    impl Default for wire_cst_check_message_response {
12002        fn default() -> Self {
12003            Self::new_with_null_ptr()
12004        }
12005    }
12006    impl NewWithNullPtr for wire_cst_config {
12007        fn new_with_null_ptr() -> Self {
12008            Self {
12009                liquid_explorer: Default::default(),
12010                bitcoin_explorer: Default::default(),
12011                working_dir: core::ptr::null_mut(),
12012                network: Default::default(),
12013                payment_timeout_sec: Default::default(),
12014                sync_service_url: core::ptr::null_mut(),
12015                zero_conf_max_amount_sat: core::ptr::null_mut(),
12016                breez_api_key: core::ptr::null_mut(),
12017                external_input_parsers: core::ptr::null_mut(),
12018                use_default_external_input_parsers: Default::default(),
12019                onchain_fee_rate_leeway_sat_per_vbyte: core::ptr::null_mut(),
12020                asset_metadata: core::ptr::null_mut(),
12021                sideswap_api_key: core::ptr::null_mut(),
12022            }
12023        }
12024    }
12025    impl Default for wire_cst_config {
12026        fn default() -> Self {
12027            Self::new_with_null_ptr()
12028        }
12029    }
12030    impl NewWithNullPtr for wire_cst_connect_request {
12031        fn new_with_null_ptr() -> Self {
12032            Self {
12033                config: Default::default(),
12034                mnemonic: core::ptr::null_mut(),
12035                passphrase: core::ptr::null_mut(),
12036                seed: core::ptr::null_mut(),
12037            }
12038        }
12039    }
12040    impl Default for wire_cst_connect_request {
12041        fn default() -> Self {
12042            Self::new_with_null_ptr()
12043        }
12044    }
12045    impl NewWithNullPtr for wire_cst_create_bolt_12_invoice_request {
12046        fn new_with_null_ptr() -> Self {
12047            Self {
12048                offer: core::ptr::null_mut(),
12049                invoice_request: core::ptr::null_mut(),
12050            }
12051        }
12052    }
12053    impl Default for wire_cst_create_bolt_12_invoice_request {
12054        fn default() -> Self {
12055            Self::new_with_null_ptr()
12056        }
12057    }
12058    impl NewWithNullPtr for wire_cst_create_bolt_12_invoice_response {
12059        fn new_with_null_ptr() -> Self {
12060            Self {
12061                invoice: core::ptr::null_mut(),
12062            }
12063        }
12064    }
12065    impl Default for wire_cst_create_bolt_12_invoice_response {
12066        fn default() -> Self {
12067            Self::new_with_null_ptr()
12068        }
12069    }
12070    impl NewWithNullPtr for wire_cst_currency_info {
12071        fn new_with_null_ptr() -> Self {
12072            Self {
12073                name: core::ptr::null_mut(),
12074                fraction_size: Default::default(),
12075                spacing: core::ptr::null_mut(),
12076                symbol: core::ptr::null_mut(),
12077                uniq_symbol: core::ptr::null_mut(),
12078                localized_name: core::ptr::null_mut(),
12079                locale_overrides: core::ptr::null_mut(),
12080            }
12081        }
12082    }
12083    impl Default for wire_cst_currency_info {
12084        fn default() -> Self {
12085            Self::new_with_null_ptr()
12086        }
12087    }
12088    impl NewWithNullPtr for wire_cst_external_input_parser {
12089        fn new_with_null_ptr() -> Self {
12090            Self {
12091                provider_id: core::ptr::null_mut(),
12092                input_regex: core::ptr::null_mut(),
12093                parser_url: core::ptr::null_mut(),
12094            }
12095        }
12096    }
12097    impl Default for wire_cst_external_input_parser {
12098        fn default() -> Self {
12099            Self::new_with_null_ptr()
12100        }
12101    }
12102    impl NewWithNullPtr for wire_cst_fetch_payment_proposed_fees_request {
12103        fn new_with_null_ptr() -> Self {
12104            Self {
12105                swap_id: core::ptr::null_mut(),
12106            }
12107        }
12108    }
12109    impl Default for wire_cst_fetch_payment_proposed_fees_request {
12110        fn default() -> Self {
12111            Self::new_with_null_ptr()
12112        }
12113    }
12114    impl NewWithNullPtr for wire_cst_fetch_payment_proposed_fees_response {
12115        fn new_with_null_ptr() -> Self {
12116            Self {
12117                swap_id: core::ptr::null_mut(),
12118                fees_sat: Default::default(),
12119                payer_amount_sat: Default::default(),
12120                receiver_amount_sat: Default::default(),
12121            }
12122        }
12123    }
12124    impl Default for wire_cst_fetch_payment_proposed_fees_response {
12125        fn default() -> Self {
12126            Self::new_with_null_ptr()
12127        }
12128    }
12129    impl NewWithNullPtr for wire_cst_fiat_currency {
12130        fn new_with_null_ptr() -> Self {
12131            Self {
12132                id: core::ptr::null_mut(),
12133                info: Default::default(),
12134            }
12135        }
12136    }
12137    impl Default for wire_cst_fiat_currency {
12138        fn default() -> Self {
12139            Self::new_with_null_ptr()
12140        }
12141    }
12142    impl NewWithNullPtr for wire_cst_get_info_response {
12143        fn new_with_null_ptr() -> Self {
12144            Self {
12145                wallet_info: Default::default(),
12146                blockchain_info: Default::default(),
12147            }
12148        }
12149    }
12150    impl Default for wire_cst_get_info_response {
12151        fn default() -> Self {
12152            Self::new_with_null_ptr()
12153        }
12154    }
12155    impl NewWithNullPtr for wire_cst_get_payment_request {
12156        fn new_with_null_ptr() -> Self {
12157            Self {
12158                tag: -1,
12159                kind: GetPaymentRequestKind { nil__: () },
12160            }
12161        }
12162    }
12163    impl Default for wire_cst_get_payment_request {
12164        fn default() -> Self {
12165            Self::new_with_null_ptr()
12166        }
12167    }
12168    impl NewWithNullPtr for wire_cst_input_type {
12169        fn new_with_null_ptr() -> Self {
12170            Self {
12171                tag: -1,
12172                kind: InputTypeKind { nil__: () },
12173            }
12174        }
12175    }
12176    impl Default for wire_cst_input_type {
12177        fn default() -> Self {
12178            Self::new_with_null_ptr()
12179        }
12180    }
12181    impl NewWithNullPtr for wire_cst_lightning_payment_limits_response {
12182        fn new_with_null_ptr() -> Self {
12183            Self {
12184                send: Default::default(),
12185                receive: Default::default(),
12186            }
12187        }
12188    }
12189    impl Default for wire_cst_lightning_payment_limits_response {
12190        fn default() -> Self {
12191            Self::new_with_null_ptr()
12192        }
12193    }
12194    impl NewWithNullPtr for wire_cst_limits {
12195        fn new_with_null_ptr() -> Self {
12196            Self {
12197                min_sat: Default::default(),
12198                max_sat: Default::default(),
12199                max_zero_conf_sat: Default::default(),
12200            }
12201        }
12202    }
12203    impl Default for wire_cst_limits {
12204        fn default() -> Self {
12205            Self::new_with_null_ptr()
12206        }
12207    }
12208    impl NewWithNullPtr for wire_cst_liquid_address_data {
12209        fn new_with_null_ptr() -> Self {
12210            Self {
12211                address: core::ptr::null_mut(),
12212                network: Default::default(),
12213                asset_id: core::ptr::null_mut(),
12214                amount: core::ptr::null_mut(),
12215                amount_sat: core::ptr::null_mut(),
12216                label: core::ptr::null_mut(),
12217                message: core::ptr::null_mut(),
12218            }
12219        }
12220    }
12221    impl Default for wire_cst_liquid_address_data {
12222        fn default() -> Self {
12223            Self::new_with_null_ptr()
12224        }
12225    }
12226    impl NewWithNullPtr for wire_cst_list_payment_details {
12227        fn new_with_null_ptr() -> Self {
12228            Self {
12229                tag: -1,
12230                kind: ListPaymentDetailsKind { nil__: () },
12231            }
12232        }
12233    }
12234    impl Default for wire_cst_list_payment_details {
12235        fn default() -> Self {
12236            Self::new_with_null_ptr()
12237        }
12238    }
12239    impl NewWithNullPtr for wire_cst_list_payments_request {
12240        fn new_with_null_ptr() -> Self {
12241            Self {
12242                filters: core::ptr::null_mut(),
12243                states: core::ptr::null_mut(),
12244                from_timestamp: core::ptr::null_mut(),
12245                to_timestamp: core::ptr::null_mut(),
12246                offset: core::ptr::null_mut(),
12247                limit: core::ptr::null_mut(),
12248                details: core::ptr::null_mut(),
12249                sort_ascending: core::ptr::null_mut(),
12250            }
12251        }
12252    }
12253    impl Default for wire_cst_list_payments_request {
12254        fn default() -> Self {
12255            Self::new_with_null_ptr()
12256        }
12257    }
12258    impl NewWithNullPtr for wire_cst_ln_invoice {
12259        fn new_with_null_ptr() -> Self {
12260            Self {
12261                bolt11: core::ptr::null_mut(),
12262                network: Default::default(),
12263                payee_pubkey: core::ptr::null_mut(),
12264                payment_hash: core::ptr::null_mut(),
12265                description: core::ptr::null_mut(),
12266                description_hash: core::ptr::null_mut(),
12267                amount_msat: core::ptr::null_mut(),
12268                timestamp: Default::default(),
12269                expiry: Default::default(),
12270                routing_hints: core::ptr::null_mut(),
12271                payment_secret: core::ptr::null_mut(),
12272                min_final_cltv_expiry_delta: Default::default(),
12273            }
12274        }
12275    }
12276    impl Default for wire_cst_ln_invoice {
12277        fn default() -> Self {
12278            Self::new_with_null_ptr()
12279        }
12280    }
12281    impl NewWithNullPtr for wire_cst_ln_offer {
12282        fn new_with_null_ptr() -> Self {
12283            Self {
12284                offer: core::ptr::null_mut(),
12285                chains: core::ptr::null_mut(),
12286                min_amount: core::ptr::null_mut(),
12287                description: core::ptr::null_mut(),
12288                absolute_expiry: core::ptr::null_mut(),
12289                issuer: core::ptr::null_mut(),
12290                signing_pubkey: core::ptr::null_mut(),
12291                paths: core::ptr::null_mut(),
12292            }
12293        }
12294    }
12295    impl Default for wire_cst_ln_offer {
12296        fn default() -> Self {
12297            Self::new_with_null_ptr()
12298        }
12299    }
12300    impl NewWithNullPtr for wire_cst_ln_offer_blinded_path {
12301        fn new_with_null_ptr() -> Self {
12302            Self {
12303                blinded_hops: core::ptr::null_mut(),
12304            }
12305        }
12306    }
12307    impl Default for wire_cst_ln_offer_blinded_path {
12308        fn default() -> Self {
12309            Self::new_with_null_ptr()
12310        }
12311    }
12312    impl NewWithNullPtr for wire_cst_ln_url_auth_error {
12313        fn new_with_null_ptr() -> Self {
12314            Self {
12315                tag: -1,
12316                kind: LnUrlAuthErrorKind { nil__: () },
12317            }
12318        }
12319    }
12320    impl Default for wire_cst_ln_url_auth_error {
12321        fn default() -> Self {
12322            Self::new_with_null_ptr()
12323        }
12324    }
12325    impl NewWithNullPtr for wire_cst_ln_url_auth_request_data {
12326        fn new_with_null_ptr() -> Self {
12327            Self {
12328                k1: core::ptr::null_mut(),
12329                action: core::ptr::null_mut(),
12330                domain: core::ptr::null_mut(),
12331                url: core::ptr::null_mut(),
12332            }
12333        }
12334    }
12335    impl Default for wire_cst_ln_url_auth_request_data {
12336        fn default() -> Self {
12337            Self::new_with_null_ptr()
12338        }
12339    }
12340    impl NewWithNullPtr for wire_cst_ln_url_callback_status {
12341        fn new_with_null_ptr() -> Self {
12342            Self {
12343                tag: -1,
12344                kind: LnUrlCallbackStatusKind { nil__: () },
12345            }
12346        }
12347    }
12348    impl Default for wire_cst_ln_url_callback_status {
12349        fn default() -> Self {
12350            Self::new_with_null_ptr()
12351        }
12352    }
12353    impl NewWithNullPtr for wire_cst_ln_url_error_data {
12354        fn new_with_null_ptr() -> Self {
12355            Self {
12356                reason: core::ptr::null_mut(),
12357            }
12358        }
12359    }
12360    impl Default for wire_cst_ln_url_error_data {
12361        fn default() -> Self {
12362            Self::new_with_null_ptr()
12363        }
12364    }
12365    impl NewWithNullPtr for wire_cst_ln_url_info {
12366        fn new_with_null_ptr() -> Self {
12367            Self {
12368                ln_address: core::ptr::null_mut(),
12369                lnurl_pay_comment: core::ptr::null_mut(),
12370                lnurl_pay_domain: core::ptr::null_mut(),
12371                lnurl_pay_metadata: core::ptr::null_mut(),
12372                lnurl_pay_success_action: core::ptr::null_mut(),
12373                lnurl_pay_unprocessed_success_action: core::ptr::null_mut(),
12374                lnurl_withdraw_endpoint: core::ptr::null_mut(),
12375            }
12376        }
12377    }
12378    impl Default for wire_cst_ln_url_info {
12379        fn default() -> Self {
12380            Self::new_with_null_ptr()
12381        }
12382    }
12383    impl NewWithNullPtr for wire_cst_ln_url_pay_error {
12384        fn new_with_null_ptr() -> Self {
12385            Self {
12386                tag: -1,
12387                kind: LnUrlPayErrorKind { nil__: () },
12388            }
12389        }
12390    }
12391    impl Default for wire_cst_ln_url_pay_error {
12392        fn default() -> Self {
12393            Self::new_with_null_ptr()
12394        }
12395    }
12396    impl NewWithNullPtr for wire_cst_ln_url_pay_error_data {
12397        fn new_with_null_ptr() -> Self {
12398            Self {
12399                payment_hash: core::ptr::null_mut(),
12400                reason: core::ptr::null_mut(),
12401            }
12402        }
12403    }
12404    impl Default for wire_cst_ln_url_pay_error_data {
12405        fn default() -> Self {
12406            Self::new_with_null_ptr()
12407        }
12408    }
12409    impl NewWithNullPtr for wire_cst_ln_url_pay_request {
12410        fn new_with_null_ptr() -> Self {
12411            Self {
12412                prepare_response: Default::default(),
12413            }
12414        }
12415    }
12416    impl Default for wire_cst_ln_url_pay_request {
12417        fn default() -> Self {
12418            Self::new_with_null_ptr()
12419        }
12420    }
12421    impl NewWithNullPtr for wire_cst_ln_url_pay_request_data {
12422        fn new_with_null_ptr() -> Self {
12423            Self {
12424                callback: core::ptr::null_mut(),
12425                min_sendable: Default::default(),
12426                max_sendable: Default::default(),
12427                metadata_str: core::ptr::null_mut(),
12428                comment_allowed: Default::default(),
12429                domain: core::ptr::null_mut(),
12430                allows_nostr: Default::default(),
12431                nostr_pubkey: core::ptr::null_mut(),
12432                ln_address: core::ptr::null_mut(),
12433            }
12434        }
12435    }
12436    impl Default for wire_cst_ln_url_pay_request_data {
12437        fn default() -> Self {
12438            Self::new_with_null_ptr()
12439        }
12440    }
12441    impl NewWithNullPtr for wire_cst_ln_url_pay_result {
12442        fn new_with_null_ptr() -> Self {
12443            Self {
12444                tag: -1,
12445                kind: LnUrlPayResultKind { nil__: () },
12446            }
12447        }
12448    }
12449    impl Default for wire_cst_ln_url_pay_result {
12450        fn default() -> Self {
12451            Self::new_with_null_ptr()
12452        }
12453    }
12454    impl NewWithNullPtr for wire_cst_ln_url_pay_success_data {
12455        fn new_with_null_ptr() -> Self {
12456            Self {
12457                payment: Default::default(),
12458                success_action: core::ptr::null_mut(),
12459            }
12460        }
12461    }
12462    impl Default for wire_cst_ln_url_pay_success_data {
12463        fn default() -> Self {
12464            Self::new_with_null_ptr()
12465        }
12466    }
12467    impl NewWithNullPtr for wire_cst_ln_url_withdraw_error {
12468        fn new_with_null_ptr() -> Self {
12469            Self {
12470                tag: -1,
12471                kind: LnUrlWithdrawErrorKind { nil__: () },
12472            }
12473        }
12474    }
12475    impl Default for wire_cst_ln_url_withdraw_error {
12476        fn default() -> Self {
12477            Self::new_with_null_ptr()
12478        }
12479    }
12480    impl NewWithNullPtr for wire_cst_ln_url_withdraw_request {
12481        fn new_with_null_ptr() -> Self {
12482            Self {
12483                data: Default::default(),
12484                amount_msat: Default::default(),
12485                description: core::ptr::null_mut(),
12486            }
12487        }
12488    }
12489    impl Default for wire_cst_ln_url_withdraw_request {
12490        fn default() -> Self {
12491            Self::new_with_null_ptr()
12492        }
12493    }
12494    impl NewWithNullPtr for wire_cst_ln_url_withdraw_request_data {
12495        fn new_with_null_ptr() -> Self {
12496            Self {
12497                callback: core::ptr::null_mut(),
12498                k1: core::ptr::null_mut(),
12499                default_description: core::ptr::null_mut(),
12500                min_withdrawable: Default::default(),
12501                max_withdrawable: Default::default(),
12502            }
12503        }
12504    }
12505    impl Default for wire_cst_ln_url_withdraw_request_data {
12506        fn default() -> Self {
12507            Self::new_with_null_ptr()
12508        }
12509    }
12510    impl NewWithNullPtr for wire_cst_ln_url_withdraw_result {
12511        fn new_with_null_ptr() -> Self {
12512            Self {
12513                tag: -1,
12514                kind: LnUrlWithdrawResultKind { nil__: () },
12515            }
12516        }
12517    }
12518    impl Default for wire_cst_ln_url_withdraw_result {
12519        fn default() -> Self {
12520            Self::new_with_null_ptr()
12521        }
12522    }
12523    impl NewWithNullPtr for wire_cst_ln_url_withdraw_success_data {
12524        fn new_with_null_ptr() -> Self {
12525            Self {
12526                invoice: Default::default(),
12527            }
12528        }
12529    }
12530    impl Default for wire_cst_ln_url_withdraw_success_data {
12531        fn default() -> Self {
12532            Self::new_with_null_ptr()
12533        }
12534    }
12535    impl NewWithNullPtr for wire_cst_locale_overrides {
12536        fn new_with_null_ptr() -> Self {
12537            Self {
12538                locale: core::ptr::null_mut(),
12539                spacing: core::ptr::null_mut(),
12540                symbol: Default::default(),
12541            }
12542        }
12543    }
12544    impl Default for wire_cst_locale_overrides {
12545        fn default() -> Self {
12546            Self::new_with_null_ptr()
12547        }
12548    }
12549    impl NewWithNullPtr for wire_cst_localized_name {
12550        fn new_with_null_ptr() -> Self {
12551            Self {
12552                locale: core::ptr::null_mut(),
12553                name: core::ptr::null_mut(),
12554            }
12555        }
12556    }
12557    impl Default for wire_cst_localized_name {
12558        fn default() -> Self {
12559            Self::new_with_null_ptr()
12560        }
12561    }
12562    impl NewWithNullPtr for wire_cst_log_entry {
12563        fn new_with_null_ptr() -> Self {
12564            Self {
12565                line: core::ptr::null_mut(),
12566                level: core::ptr::null_mut(),
12567            }
12568        }
12569    }
12570    impl Default for wire_cst_log_entry {
12571        fn default() -> Self {
12572            Self::new_with_null_ptr()
12573        }
12574    }
12575    impl NewWithNullPtr for wire_cst_message_success_action_data {
12576        fn new_with_null_ptr() -> Self {
12577            Self {
12578                message: core::ptr::null_mut(),
12579            }
12580        }
12581    }
12582    impl Default for wire_cst_message_success_action_data {
12583        fn default() -> Self {
12584            Self::new_with_null_ptr()
12585        }
12586    }
12587    impl NewWithNullPtr for wire_cst_onchain_payment_limits_response {
12588        fn new_with_null_ptr() -> Self {
12589            Self {
12590                send: Default::default(),
12591                receive: Default::default(),
12592            }
12593        }
12594    }
12595    impl Default for wire_cst_onchain_payment_limits_response {
12596        fn default() -> Self {
12597            Self::new_with_null_ptr()
12598        }
12599    }
12600    impl NewWithNullPtr for wire_cst_pay_amount {
12601        fn new_with_null_ptr() -> Self {
12602            Self {
12603                tag: -1,
12604                kind: PayAmountKind { nil__: () },
12605            }
12606        }
12607    }
12608    impl Default for wire_cst_pay_amount {
12609        fn default() -> Self {
12610            Self::new_with_null_ptr()
12611        }
12612    }
12613    impl NewWithNullPtr for wire_cst_pay_onchain_request {
12614        fn new_with_null_ptr() -> Self {
12615            Self {
12616                address: core::ptr::null_mut(),
12617                prepare_response: Default::default(),
12618            }
12619        }
12620    }
12621    impl Default for wire_cst_pay_onchain_request {
12622        fn default() -> Self {
12623            Self::new_with_null_ptr()
12624        }
12625    }
12626    impl NewWithNullPtr for wire_cst_payment {
12627        fn new_with_null_ptr() -> Self {
12628            Self {
12629                destination: core::ptr::null_mut(),
12630                tx_id: core::ptr::null_mut(),
12631                unblinding_data: core::ptr::null_mut(),
12632                timestamp: Default::default(),
12633                amount_sat: Default::default(),
12634                fees_sat: Default::default(),
12635                swapper_fees_sat: core::ptr::null_mut(),
12636                payment_type: Default::default(),
12637                status: Default::default(),
12638                details: Default::default(),
12639            }
12640        }
12641    }
12642    impl Default for wire_cst_payment {
12643        fn default() -> Self {
12644            Self::new_with_null_ptr()
12645        }
12646    }
12647    impl NewWithNullPtr for wire_cst_payment_details {
12648        fn new_with_null_ptr() -> Self {
12649            Self {
12650                tag: -1,
12651                kind: PaymentDetailsKind { nil__: () },
12652            }
12653        }
12654    }
12655    impl Default for wire_cst_payment_details {
12656        fn default() -> Self {
12657            Self::new_with_null_ptr()
12658        }
12659    }
12660    impl NewWithNullPtr for wire_cst_payment_error {
12661        fn new_with_null_ptr() -> Self {
12662            Self {
12663                tag: -1,
12664                kind: PaymentErrorKind { nil__: () },
12665            }
12666        }
12667    }
12668    impl Default for wire_cst_payment_error {
12669        fn default() -> Self {
12670            Self::new_with_null_ptr()
12671        }
12672    }
12673    impl NewWithNullPtr for wire_cst_prepare_buy_bitcoin_request {
12674        fn new_with_null_ptr() -> Self {
12675            Self {
12676                provider: Default::default(),
12677                amount_sat: Default::default(),
12678            }
12679        }
12680    }
12681    impl Default for wire_cst_prepare_buy_bitcoin_request {
12682        fn default() -> Self {
12683            Self::new_with_null_ptr()
12684        }
12685    }
12686    impl NewWithNullPtr for wire_cst_prepare_buy_bitcoin_response {
12687        fn new_with_null_ptr() -> Self {
12688            Self {
12689                provider: Default::default(),
12690                amount_sat: Default::default(),
12691                fees_sat: Default::default(),
12692            }
12693        }
12694    }
12695    impl Default for wire_cst_prepare_buy_bitcoin_response {
12696        fn default() -> Self {
12697            Self::new_with_null_ptr()
12698        }
12699    }
12700    impl NewWithNullPtr for wire_cst_prepare_ln_url_pay_request {
12701        fn new_with_null_ptr() -> Self {
12702            Self {
12703                data: Default::default(),
12704                amount: Default::default(),
12705                bip353_address: core::ptr::null_mut(),
12706                comment: core::ptr::null_mut(),
12707                validate_success_action_url: core::ptr::null_mut(),
12708            }
12709        }
12710    }
12711    impl Default for wire_cst_prepare_ln_url_pay_request {
12712        fn default() -> Self {
12713            Self::new_with_null_ptr()
12714        }
12715    }
12716    impl NewWithNullPtr for wire_cst_prepare_ln_url_pay_response {
12717        fn new_with_null_ptr() -> Self {
12718            Self {
12719                destination: Default::default(),
12720                fees_sat: Default::default(),
12721                data: Default::default(),
12722                amount: Default::default(),
12723                comment: core::ptr::null_mut(),
12724                success_action: core::ptr::null_mut(),
12725            }
12726        }
12727    }
12728    impl Default for wire_cst_prepare_ln_url_pay_response {
12729        fn default() -> Self {
12730            Self::new_with_null_ptr()
12731        }
12732    }
12733    impl NewWithNullPtr for wire_cst_prepare_pay_onchain_request {
12734        fn new_with_null_ptr() -> Self {
12735            Self {
12736                amount: Default::default(),
12737                fee_rate_sat_per_vbyte: core::ptr::null_mut(),
12738            }
12739        }
12740    }
12741    impl Default for wire_cst_prepare_pay_onchain_request {
12742        fn default() -> Self {
12743            Self::new_with_null_ptr()
12744        }
12745    }
12746    impl NewWithNullPtr for wire_cst_prepare_pay_onchain_response {
12747        fn new_with_null_ptr() -> Self {
12748            Self {
12749                receiver_amount_sat: Default::default(),
12750                claim_fees_sat: Default::default(),
12751                total_fees_sat: Default::default(),
12752            }
12753        }
12754    }
12755    impl Default for wire_cst_prepare_pay_onchain_response {
12756        fn default() -> Self {
12757            Self::new_with_null_ptr()
12758        }
12759    }
12760    impl NewWithNullPtr for wire_cst_prepare_receive_request {
12761        fn new_with_null_ptr() -> Self {
12762            Self {
12763                payment_method: Default::default(),
12764                amount: core::ptr::null_mut(),
12765            }
12766        }
12767    }
12768    impl Default for wire_cst_prepare_receive_request {
12769        fn default() -> Self {
12770            Self::new_with_null_ptr()
12771        }
12772    }
12773    impl NewWithNullPtr for wire_cst_prepare_receive_response {
12774        fn new_with_null_ptr() -> Self {
12775            Self {
12776                payment_method: Default::default(),
12777                fees_sat: Default::default(),
12778                amount: core::ptr::null_mut(),
12779                min_payer_amount_sat: core::ptr::null_mut(),
12780                max_payer_amount_sat: core::ptr::null_mut(),
12781                swapper_feerate: core::ptr::null_mut(),
12782            }
12783        }
12784    }
12785    impl Default for wire_cst_prepare_receive_response {
12786        fn default() -> Self {
12787            Self::new_with_null_ptr()
12788        }
12789    }
12790    impl NewWithNullPtr for wire_cst_prepare_refund_request {
12791        fn new_with_null_ptr() -> Self {
12792            Self {
12793                swap_address: core::ptr::null_mut(),
12794                refund_address: core::ptr::null_mut(),
12795                fee_rate_sat_per_vbyte: Default::default(),
12796            }
12797        }
12798    }
12799    impl Default for wire_cst_prepare_refund_request {
12800        fn default() -> Self {
12801            Self::new_with_null_ptr()
12802        }
12803    }
12804    impl NewWithNullPtr for wire_cst_prepare_refund_response {
12805        fn new_with_null_ptr() -> Self {
12806            Self {
12807                tx_vsize: Default::default(),
12808                tx_fee_sat: Default::default(),
12809                last_refund_tx_id: core::ptr::null_mut(),
12810            }
12811        }
12812    }
12813    impl Default for wire_cst_prepare_refund_response {
12814        fn default() -> Self {
12815            Self::new_with_null_ptr()
12816        }
12817    }
12818    impl NewWithNullPtr for wire_cst_prepare_send_request {
12819        fn new_with_null_ptr() -> Self {
12820            Self {
12821                destination: core::ptr::null_mut(),
12822                amount: core::ptr::null_mut(),
12823                comment: core::ptr::null_mut(),
12824            }
12825        }
12826    }
12827    impl Default for wire_cst_prepare_send_request {
12828        fn default() -> Self {
12829            Self::new_with_null_ptr()
12830        }
12831    }
12832    impl NewWithNullPtr for wire_cst_prepare_send_response {
12833        fn new_with_null_ptr() -> Self {
12834            Self {
12835                destination: Default::default(),
12836                amount: core::ptr::null_mut(),
12837                fees_sat: core::ptr::null_mut(),
12838                estimated_asset_fees: core::ptr::null_mut(),
12839            }
12840        }
12841    }
12842    impl Default for wire_cst_prepare_send_response {
12843        fn default() -> Self {
12844            Self::new_with_null_ptr()
12845        }
12846    }
12847    impl NewWithNullPtr for wire_cst_rate {
12848        fn new_with_null_ptr() -> Self {
12849            Self {
12850                coin: core::ptr::null_mut(),
12851                value: Default::default(),
12852            }
12853        }
12854    }
12855    impl Default for wire_cst_rate {
12856        fn default() -> Self {
12857            Self::new_with_null_ptr()
12858        }
12859    }
12860    impl NewWithNullPtr for wire_cst_receive_amount {
12861        fn new_with_null_ptr() -> Self {
12862            Self {
12863                tag: -1,
12864                kind: ReceiveAmountKind { nil__: () },
12865            }
12866        }
12867    }
12868    impl Default for wire_cst_receive_amount {
12869        fn default() -> Self {
12870            Self::new_with_null_ptr()
12871        }
12872    }
12873    impl NewWithNullPtr for wire_cst_receive_payment_request {
12874        fn new_with_null_ptr() -> Self {
12875            Self {
12876                prepare_response: Default::default(),
12877                description: core::ptr::null_mut(),
12878                use_description_hash: core::ptr::null_mut(),
12879            }
12880        }
12881    }
12882    impl Default for wire_cst_receive_payment_request {
12883        fn default() -> Self {
12884            Self::new_with_null_ptr()
12885        }
12886    }
12887    impl NewWithNullPtr for wire_cst_receive_payment_response {
12888        fn new_with_null_ptr() -> Self {
12889            Self {
12890                destination: core::ptr::null_mut(),
12891            }
12892        }
12893    }
12894    impl Default for wire_cst_receive_payment_response {
12895        fn default() -> Self {
12896            Self::new_with_null_ptr()
12897        }
12898    }
12899    impl NewWithNullPtr for wire_cst_recommended_fees {
12900        fn new_with_null_ptr() -> Self {
12901            Self {
12902                fastest_fee: Default::default(),
12903                half_hour_fee: Default::default(),
12904                hour_fee: Default::default(),
12905                economy_fee: Default::default(),
12906                minimum_fee: Default::default(),
12907            }
12908        }
12909    }
12910    impl Default for wire_cst_recommended_fees {
12911        fn default() -> Self {
12912            Self::new_with_null_ptr()
12913        }
12914    }
12915    impl NewWithNullPtr for wire_cst_refund_request {
12916        fn new_with_null_ptr() -> Self {
12917            Self {
12918                swap_address: core::ptr::null_mut(),
12919                refund_address: core::ptr::null_mut(),
12920                fee_rate_sat_per_vbyte: Default::default(),
12921            }
12922        }
12923    }
12924    impl Default for wire_cst_refund_request {
12925        fn default() -> Self {
12926            Self::new_with_null_ptr()
12927        }
12928    }
12929    impl NewWithNullPtr for wire_cst_refund_response {
12930        fn new_with_null_ptr() -> Self {
12931            Self {
12932                refund_tx_id: core::ptr::null_mut(),
12933            }
12934        }
12935    }
12936    impl Default for wire_cst_refund_response {
12937        fn default() -> Self {
12938            Self::new_with_null_ptr()
12939        }
12940    }
12941    impl NewWithNullPtr for wire_cst_refundable_swap {
12942        fn new_with_null_ptr() -> Self {
12943            Self {
12944                swap_address: core::ptr::null_mut(),
12945                timestamp: Default::default(),
12946                amount_sat: Default::default(),
12947                last_refund_tx_id: core::ptr::null_mut(),
12948            }
12949        }
12950    }
12951    impl Default for wire_cst_refundable_swap {
12952        fn default() -> Self {
12953            Self::new_with_null_ptr()
12954        }
12955    }
12956    impl NewWithNullPtr for wire_cst_restore_request {
12957        fn new_with_null_ptr() -> Self {
12958            Self {
12959                backup_path: core::ptr::null_mut(),
12960            }
12961        }
12962    }
12963    impl Default for wire_cst_restore_request {
12964        fn default() -> Self {
12965            Self::new_with_null_ptr()
12966        }
12967    }
12968    impl NewWithNullPtr for wire_cst_route_hint {
12969        fn new_with_null_ptr() -> Self {
12970            Self {
12971                hops: core::ptr::null_mut(),
12972            }
12973        }
12974    }
12975    impl Default for wire_cst_route_hint {
12976        fn default() -> Self {
12977            Self::new_with_null_ptr()
12978        }
12979    }
12980    impl NewWithNullPtr for wire_cst_route_hint_hop {
12981        fn new_with_null_ptr() -> Self {
12982            Self {
12983                src_node_id: core::ptr::null_mut(),
12984                short_channel_id: core::ptr::null_mut(),
12985                fees_base_msat: Default::default(),
12986                fees_proportional_millionths: Default::default(),
12987                cltv_expiry_delta: Default::default(),
12988                htlc_minimum_msat: core::ptr::null_mut(),
12989                htlc_maximum_msat: core::ptr::null_mut(),
12990            }
12991        }
12992    }
12993    impl Default for wire_cst_route_hint_hop {
12994        fn default() -> Self {
12995            Self::new_with_null_ptr()
12996        }
12997    }
12998    impl NewWithNullPtr for wire_cst_sdk_error {
12999        fn new_with_null_ptr() -> Self {
13000            Self {
13001                tag: -1,
13002                kind: SdkErrorKind { nil__: () },
13003            }
13004        }
13005    }
13006    impl Default for wire_cst_sdk_error {
13007        fn default() -> Self {
13008            Self::new_with_null_ptr()
13009        }
13010    }
13011    impl NewWithNullPtr for wire_cst_sdk_event {
13012        fn new_with_null_ptr() -> Self {
13013            Self {
13014                tag: -1,
13015                kind: SdkEventKind { nil__: () },
13016            }
13017        }
13018    }
13019    impl Default for wire_cst_sdk_event {
13020        fn default() -> Self {
13021            Self::new_with_null_ptr()
13022        }
13023    }
13024    impl NewWithNullPtr for wire_cst_send_destination {
13025        fn new_with_null_ptr() -> Self {
13026            Self {
13027                tag: -1,
13028                kind: SendDestinationKind { nil__: () },
13029            }
13030        }
13031    }
13032    impl Default for wire_cst_send_destination {
13033        fn default() -> Self {
13034            Self::new_with_null_ptr()
13035        }
13036    }
13037    impl NewWithNullPtr for wire_cst_send_payment_request {
13038        fn new_with_null_ptr() -> Self {
13039            Self {
13040                prepare_response: Default::default(),
13041                use_asset_fees: core::ptr::null_mut(),
13042            }
13043        }
13044    }
13045    impl Default for wire_cst_send_payment_request {
13046        fn default() -> Self {
13047            Self::new_with_null_ptr()
13048        }
13049    }
13050    impl NewWithNullPtr for wire_cst_send_payment_response {
13051        fn new_with_null_ptr() -> Self {
13052            Self {
13053                payment: Default::default(),
13054            }
13055        }
13056    }
13057    impl Default for wire_cst_send_payment_response {
13058        fn default() -> Self {
13059            Self::new_with_null_ptr()
13060        }
13061    }
13062    impl NewWithNullPtr for wire_cst_sign_message_request {
13063        fn new_with_null_ptr() -> Self {
13064            Self {
13065                message: core::ptr::null_mut(),
13066            }
13067        }
13068    }
13069    impl Default for wire_cst_sign_message_request {
13070        fn default() -> Self {
13071            Self::new_with_null_ptr()
13072        }
13073    }
13074    impl NewWithNullPtr for wire_cst_sign_message_response {
13075        fn new_with_null_ptr() -> Self {
13076            Self {
13077                signature: core::ptr::null_mut(),
13078            }
13079        }
13080    }
13081    impl Default for wire_cst_sign_message_response {
13082        fn default() -> Self {
13083            Self::new_with_null_ptr()
13084        }
13085    }
13086    impl NewWithNullPtr for wire_cst_success_action {
13087        fn new_with_null_ptr() -> Self {
13088            Self {
13089                tag: -1,
13090                kind: SuccessActionKind { nil__: () },
13091            }
13092        }
13093    }
13094    impl Default for wire_cst_success_action {
13095        fn default() -> Self {
13096            Self::new_with_null_ptr()
13097        }
13098    }
13099    impl NewWithNullPtr for wire_cst_success_action_processed {
13100        fn new_with_null_ptr() -> Self {
13101            Self {
13102                tag: -1,
13103                kind: SuccessActionProcessedKind { nil__: () },
13104            }
13105        }
13106    }
13107    impl Default for wire_cst_success_action_processed {
13108        fn default() -> Self {
13109            Self::new_with_null_ptr()
13110        }
13111    }
13112    impl NewWithNullPtr for wire_cst_symbol {
13113        fn new_with_null_ptr() -> Self {
13114            Self {
13115                grapheme: core::ptr::null_mut(),
13116                template: core::ptr::null_mut(),
13117                rtl: core::ptr::null_mut(),
13118                position: core::ptr::null_mut(),
13119            }
13120        }
13121    }
13122    impl Default for wire_cst_symbol {
13123        fn default() -> Self {
13124            Self::new_with_null_ptr()
13125        }
13126    }
13127    impl NewWithNullPtr for wire_cst_url_success_action_data {
13128        fn new_with_null_ptr() -> Self {
13129            Self {
13130                description: core::ptr::null_mut(),
13131                url: core::ptr::null_mut(),
13132                matches_callback_domain: Default::default(),
13133            }
13134        }
13135    }
13136    impl Default for wire_cst_url_success_action_data {
13137        fn default() -> Self {
13138            Self::new_with_null_ptr()
13139        }
13140    }
13141    impl NewWithNullPtr for wire_cst_wallet_info {
13142        fn new_with_null_ptr() -> Self {
13143            Self {
13144                balance_sat: Default::default(),
13145                pending_send_sat: Default::default(),
13146                pending_receive_sat: Default::default(),
13147                fingerprint: core::ptr::null_mut(),
13148                pubkey: core::ptr::null_mut(),
13149                asset_balances: core::ptr::null_mut(),
13150            }
13151        }
13152    }
13153    impl Default for wire_cst_wallet_info {
13154        fn default() -> Self {
13155            Self::new_with_null_ptr()
13156        }
13157    }
13158
13159    #[unsafe(no_mangle)]
13160    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_accept_payment_proposed_fees(
13161        port_: i64,
13162        that: usize,
13163        req: *mut wire_cst_accept_payment_proposed_fees_request,
13164    ) {
13165        wire__crate__bindings__BindingLiquidSdk_accept_payment_proposed_fees_impl(port_, that, req)
13166    }
13167
13168    #[unsafe(no_mangle)]
13169    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_add_event_listener(
13170        port_: i64,
13171        that: usize,
13172        listener: *mut wire_cst_list_prim_u_8_strict,
13173    ) {
13174        wire__crate__bindings__BindingLiquidSdk_add_event_listener_impl(port_, that, listener)
13175    }
13176
13177    #[unsafe(no_mangle)]
13178    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_backup(
13179        that: usize,
13180        req: *mut wire_cst_backup_request,
13181    ) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
13182        wire__crate__bindings__BindingLiquidSdk_backup_impl(that, req)
13183    }
13184
13185    #[unsafe(no_mangle)]
13186    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_buy_bitcoin(
13187        port_: i64,
13188        that: usize,
13189        req: *mut wire_cst_buy_bitcoin_request,
13190    ) {
13191        wire__crate__bindings__BindingLiquidSdk_buy_bitcoin_impl(port_, that, req)
13192    }
13193
13194    #[unsafe(no_mangle)]
13195    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_check_message(
13196        that: usize,
13197        req: *mut wire_cst_check_message_request,
13198    ) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
13199        wire__crate__bindings__BindingLiquidSdk_check_message_impl(that, req)
13200    }
13201
13202    #[unsafe(no_mangle)]
13203    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_create_bolt12_invoice(
13204        port_: i64,
13205        that: usize,
13206        req: *mut wire_cst_create_bolt_12_invoice_request,
13207    ) {
13208        wire__crate__bindings__BindingLiquidSdk_create_bolt12_invoice_impl(port_, that, req)
13209    }
13210
13211    #[unsafe(no_mangle)]
13212    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_disconnect(
13213        port_: i64,
13214        that: usize,
13215    ) {
13216        wire__crate__bindings__BindingLiquidSdk_disconnect_impl(port_, that)
13217    }
13218
13219    #[unsafe(no_mangle)]
13220    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_empty_wallet_cache(
13221        that: usize,
13222    ) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
13223        wire__crate__bindings__BindingLiquidSdk_empty_wallet_cache_impl(that)
13224    }
13225
13226    #[unsafe(no_mangle)]
13227    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_fetch_fiat_rates(
13228        port_: i64,
13229        that: usize,
13230    ) {
13231        wire__crate__bindings__BindingLiquidSdk_fetch_fiat_rates_impl(port_, that)
13232    }
13233
13234    #[unsafe(no_mangle)]
13235    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_fetch_lightning_limits(
13236        port_: i64,
13237        that: usize,
13238    ) {
13239        wire__crate__bindings__BindingLiquidSdk_fetch_lightning_limits_impl(port_, that)
13240    }
13241
13242    #[unsafe(no_mangle)]
13243    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_fetch_onchain_limits(
13244        port_: i64,
13245        that: usize,
13246    ) {
13247        wire__crate__bindings__BindingLiquidSdk_fetch_onchain_limits_impl(port_, that)
13248    }
13249
13250    #[unsafe(no_mangle)]
13251    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_fetch_payment_proposed_fees(
13252        port_: i64,
13253        that: usize,
13254        req: *mut wire_cst_fetch_payment_proposed_fees_request,
13255    ) {
13256        wire__crate__bindings__BindingLiquidSdk_fetch_payment_proposed_fees_impl(port_, that, req)
13257    }
13258
13259    #[unsafe(no_mangle)]
13260    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_get_info(
13261        port_: i64,
13262        that: usize,
13263    ) {
13264        wire__crate__bindings__BindingLiquidSdk_get_info_impl(port_, that)
13265    }
13266
13267    #[unsafe(no_mangle)]
13268    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_get_payment(
13269        port_: i64,
13270        that: usize,
13271        req: *mut wire_cst_get_payment_request,
13272    ) {
13273        wire__crate__bindings__BindingLiquidSdk_get_payment_impl(port_, that, req)
13274    }
13275
13276    #[unsafe(no_mangle)]
13277    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_list_fiat_currencies(
13278        port_: i64,
13279        that: usize,
13280    ) {
13281        wire__crate__bindings__BindingLiquidSdk_list_fiat_currencies_impl(port_, that)
13282    }
13283
13284    #[unsafe(no_mangle)]
13285    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_list_payments(
13286        port_: i64,
13287        that: usize,
13288        req: *mut wire_cst_list_payments_request,
13289    ) {
13290        wire__crate__bindings__BindingLiquidSdk_list_payments_impl(port_, that, req)
13291    }
13292
13293    #[unsafe(no_mangle)]
13294    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_list_refundables(
13295        port_: i64,
13296        that: usize,
13297    ) {
13298        wire__crate__bindings__BindingLiquidSdk_list_refundables_impl(port_, that)
13299    }
13300
13301    #[unsafe(no_mangle)]
13302    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_lnurl_auth(
13303        port_: i64,
13304        that: usize,
13305        req_data: *mut wire_cst_ln_url_auth_request_data,
13306    ) {
13307        wire__crate__bindings__BindingLiquidSdk_lnurl_auth_impl(port_, that, req_data)
13308    }
13309
13310    #[unsafe(no_mangle)]
13311    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_lnurl_pay(
13312        port_: i64,
13313        that: usize,
13314        req: *mut wire_cst_ln_url_pay_request,
13315    ) {
13316        wire__crate__bindings__BindingLiquidSdk_lnurl_pay_impl(port_, that, req)
13317    }
13318
13319    #[unsafe(no_mangle)]
13320    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_lnurl_withdraw(
13321        port_: i64,
13322        that: usize,
13323        req: *mut wire_cst_ln_url_withdraw_request,
13324    ) {
13325        wire__crate__bindings__BindingLiquidSdk_lnurl_withdraw_impl(port_, that, req)
13326    }
13327
13328    #[unsafe(no_mangle)]
13329    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_parse(
13330        port_: i64,
13331        that: usize,
13332        input: *mut wire_cst_list_prim_u_8_strict,
13333    ) {
13334        wire__crate__bindings__BindingLiquidSdk_parse_impl(port_, that, input)
13335    }
13336
13337    #[unsafe(no_mangle)]
13338    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_pay_onchain(
13339        port_: i64,
13340        that: usize,
13341        req: *mut wire_cst_pay_onchain_request,
13342    ) {
13343        wire__crate__bindings__BindingLiquidSdk_pay_onchain_impl(port_, that, req)
13344    }
13345
13346    #[unsafe(no_mangle)]
13347    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_prepare_buy_bitcoin(
13348        port_: i64,
13349        that: usize,
13350        req: *mut wire_cst_prepare_buy_bitcoin_request,
13351    ) {
13352        wire__crate__bindings__BindingLiquidSdk_prepare_buy_bitcoin_impl(port_, that, req)
13353    }
13354
13355    #[unsafe(no_mangle)]
13356    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_prepare_lnurl_pay(
13357        port_: i64,
13358        that: usize,
13359        req: *mut wire_cst_prepare_ln_url_pay_request,
13360    ) {
13361        wire__crate__bindings__BindingLiquidSdk_prepare_lnurl_pay_impl(port_, that, req)
13362    }
13363
13364    #[unsafe(no_mangle)]
13365    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_prepare_pay_onchain(
13366        port_: i64,
13367        that: usize,
13368        req: *mut wire_cst_prepare_pay_onchain_request,
13369    ) {
13370        wire__crate__bindings__BindingLiquidSdk_prepare_pay_onchain_impl(port_, that, req)
13371    }
13372
13373    #[unsafe(no_mangle)]
13374    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_prepare_receive_payment(
13375        port_: i64,
13376        that: usize,
13377        req: *mut wire_cst_prepare_receive_request,
13378    ) {
13379        wire__crate__bindings__BindingLiquidSdk_prepare_receive_payment_impl(port_, that, req)
13380    }
13381
13382    #[unsafe(no_mangle)]
13383    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_prepare_refund(
13384        port_: i64,
13385        that: usize,
13386        req: *mut wire_cst_prepare_refund_request,
13387    ) {
13388        wire__crate__bindings__BindingLiquidSdk_prepare_refund_impl(port_, that, req)
13389    }
13390
13391    #[unsafe(no_mangle)]
13392    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_prepare_send_payment(
13393        port_: i64,
13394        that: usize,
13395        req: *mut wire_cst_prepare_send_request,
13396    ) {
13397        wire__crate__bindings__BindingLiquidSdk_prepare_send_payment_impl(port_, that, req)
13398    }
13399
13400    #[unsafe(no_mangle)]
13401    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_receive_payment(
13402        port_: i64,
13403        that: usize,
13404        req: *mut wire_cst_receive_payment_request,
13405    ) {
13406        wire__crate__bindings__BindingLiquidSdk_receive_payment_impl(port_, that, req)
13407    }
13408
13409    #[unsafe(no_mangle)]
13410    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_recommended_fees(
13411        port_: i64,
13412        that: usize,
13413    ) {
13414        wire__crate__bindings__BindingLiquidSdk_recommended_fees_impl(port_, that)
13415    }
13416
13417    #[unsafe(no_mangle)]
13418    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_refund(
13419        port_: i64,
13420        that: usize,
13421        req: *mut wire_cst_refund_request,
13422    ) {
13423        wire__crate__bindings__BindingLiquidSdk_refund_impl(port_, that, req)
13424    }
13425
13426    #[unsafe(no_mangle)]
13427    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_register_webhook(
13428        port_: i64,
13429        that: usize,
13430        webhook_url: *mut wire_cst_list_prim_u_8_strict,
13431    ) {
13432        wire__crate__bindings__BindingLiquidSdk_register_webhook_impl(port_, that, webhook_url)
13433    }
13434
13435    #[unsafe(no_mangle)]
13436    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_rescan_onchain_swaps(
13437        port_: i64,
13438        that: usize,
13439    ) {
13440        wire__crate__bindings__BindingLiquidSdk_rescan_onchain_swaps_impl(port_, that)
13441    }
13442
13443    #[unsafe(no_mangle)]
13444    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_restore(
13445        that: usize,
13446        req: *mut wire_cst_restore_request,
13447    ) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
13448        wire__crate__bindings__BindingLiquidSdk_restore_impl(that, req)
13449    }
13450
13451    #[unsafe(no_mangle)]
13452    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_send_payment(
13453        port_: i64,
13454        that: usize,
13455        req: *mut wire_cst_send_payment_request,
13456    ) {
13457        wire__crate__bindings__BindingLiquidSdk_send_payment_impl(port_, that, req)
13458    }
13459
13460    #[unsafe(no_mangle)]
13461    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_sign_message(
13462        that: usize,
13463        req: *mut wire_cst_sign_message_request,
13464    ) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
13465        wire__crate__bindings__BindingLiquidSdk_sign_message_impl(that, req)
13466    }
13467
13468    #[unsafe(no_mangle)]
13469    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_sync(
13470        port_: i64,
13471        that: usize,
13472    ) {
13473        wire__crate__bindings__BindingLiquidSdk_sync_impl(port_, that)
13474    }
13475
13476    #[unsafe(no_mangle)]
13477    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_unregister_webhook(
13478        port_: i64,
13479        that: usize,
13480    ) {
13481        wire__crate__bindings__BindingLiquidSdk_unregister_webhook_impl(port_, that)
13482    }
13483
13484    #[unsafe(no_mangle)]
13485    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__binding_event_listener_on_event(
13486        port_: i64,
13487        that: *mut wire_cst_binding_event_listener,
13488        e: *mut wire_cst_sdk_event,
13489    ) {
13490        wire__crate__bindings__binding_event_listener_on_event_impl(port_, that, e)
13491    }
13492
13493    #[unsafe(no_mangle)]
13494    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__breez_log_stream(
13495        port_: i64,
13496        s: *mut wire_cst_list_prim_u_8_strict,
13497    ) {
13498        wire__crate__bindings__breez_log_stream_impl(port_, s)
13499    }
13500
13501    #[unsafe(no_mangle)]
13502    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__connect(
13503        port_: i64,
13504        req: *mut wire_cst_connect_request,
13505    ) {
13506        wire__crate__bindings__connect_impl(port_, req)
13507    }
13508
13509    #[unsafe(no_mangle)]
13510    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__default_config(
13511        network: i32,
13512        breez_api_key: *mut wire_cst_list_prim_u_8_strict,
13513    ) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
13514        wire__crate__bindings__default_config_impl(network, breez_api_key)
13515    }
13516
13517    #[unsafe(no_mangle)]
13518    pub extern "C" fn frbgen_breez_liquid_wire__crate__bindings__parse_invoice(
13519        input: *mut wire_cst_list_prim_u_8_strict,
13520    ) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco {
13521        wire__crate__bindings__parse_invoice_impl(input)
13522    }
13523
13524    #[unsafe(no_mangle)]
13525    pub extern "C" fn frbgen_breez_liquid_rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerBindingLiquidSdk(
13526        ptr: *const std::ffi::c_void,
13527    ) {
13528        unsafe {
13529            StdArc::<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>::increment_strong_count(ptr as _);
13530        }
13531    }
13532
13533    #[unsafe(no_mangle)]
13534    pub extern "C" fn frbgen_breez_liquid_rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerBindingLiquidSdk(
13535        ptr: *const std::ffi::c_void,
13536    ) {
13537        unsafe {
13538            StdArc::<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<BindingLiquidSdk>>::decrement_strong_count(ptr as _);
13539        }
13540    }
13541
13542    #[unsafe(no_mangle)]
13543    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_accept_payment_proposed_fees_request(
13544    ) -> *mut wire_cst_accept_payment_proposed_fees_request {
13545        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13546            wire_cst_accept_payment_proposed_fees_request::new_with_null_ptr(),
13547        )
13548    }
13549
13550    #[unsafe(no_mangle)]
13551    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_aes_success_action_data(
13552    ) -> *mut wire_cst_aes_success_action_data {
13553        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13554            wire_cst_aes_success_action_data::new_with_null_ptr(),
13555        )
13556    }
13557
13558    #[unsafe(no_mangle)]
13559    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_aes_success_action_data_decrypted(
13560    ) -> *mut wire_cst_aes_success_action_data_decrypted {
13561        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13562            wire_cst_aes_success_action_data_decrypted::new_with_null_ptr(),
13563        )
13564    }
13565
13566    #[unsafe(no_mangle)]
13567    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_aes_success_action_data_result(
13568    ) -> *mut wire_cst_aes_success_action_data_result {
13569        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13570            wire_cst_aes_success_action_data_result::new_with_null_ptr(),
13571        )
13572    }
13573
13574    #[unsafe(no_mangle)]
13575    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_amount() -> *mut wire_cst_amount {
13576        flutter_rust_bridge::for_generated::new_leak_box_ptr(wire_cst_amount::new_with_null_ptr())
13577    }
13578
13579    #[unsafe(no_mangle)]
13580    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_asset_info(
13581    ) -> *mut wire_cst_asset_info {
13582        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13583            wire_cst_asset_info::new_with_null_ptr(),
13584        )
13585    }
13586
13587    #[unsafe(no_mangle)]
13588    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_backup_request(
13589    ) -> *mut wire_cst_backup_request {
13590        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13591            wire_cst_backup_request::new_with_null_ptr(),
13592        )
13593    }
13594
13595    #[unsafe(no_mangle)]
13596    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_binding_event_listener(
13597    ) -> *mut wire_cst_binding_event_listener {
13598        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13599            wire_cst_binding_event_listener::new_with_null_ptr(),
13600        )
13601    }
13602
13603    #[unsafe(no_mangle)]
13604    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_bitcoin_address_data(
13605    ) -> *mut wire_cst_bitcoin_address_data {
13606        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13607            wire_cst_bitcoin_address_data::new_with_null_ptr(),
13608        )
13609    }
13610
13611    #[unsafe(no_mangle)]
13612    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_bool(value: bool) -> *mut bool {
13613        flutter_rust_bridge::for_generated::new_leak_box_ptr(value)
13614    }
13615
13616    #[unsafe(no_mangle)]
13617    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_buy_bitcoin_request(
13618    ) -> *mut wire_cst_buy_bitcoin_request {
13619        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13620            wire_cst_buy_bitcoin_request::new_with_null_ptr(),
13621        )
13622    }
13623
13624    #[unsafe(no_mangle)]
13625    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_check_message_request(
13626    ) -> *mut wire_cst_check_message_request {
13627        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13628            wire_cst_check_message_request::new_with_null_ptr(),
13629        )
13630    }
13631
13632    #[unsafe(no_mangle)]
13633    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_connect_request(
13634    ) -> *mut wire_cst_connect_request {
13635        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13636            wire_cst_connect_request::new_with_null_ptr(),
13637        )
13638    }
13639
13640    #[unsafe(no_mangle)]
13641    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_create_bolt_12_invoice_request(
13642    ) -> *mut wire_cst_create_bolt_12_invoice_request {
13643        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13644            wire_cst_create_bolt_12_invoice_request::new_with_null_ptr(),
13645        )
13646    }
13647
13648    #[unsafe(no_mangle)]
13649    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_f_64(value: f64) -> *mut f64 {
13650        flutter_rust_bridge::for_generated::new_leak_box_ptr(value)
13651    }
13652
13653    #[unsafe(no_mangle)]
13654    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_fetch_payment_proposed_fees_request(
13655    ) -> *mut wire_cst_fetch_payment_proposed_fees_request {
13656        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13657            wire_cst_fetch_payment_proposed_fees_request::new_with_null_ptr(),
13658        )
13659    }
13660
13661    #[unsafe(no_mangle)]
13662    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_get_payment_request(
13663    ) -> *mut wire_cst_get_payment_request {
13664        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13665            wire_cst_get_payment_request::new_with_null_ptr(),
13666        )
13667    }
13668
13669    #[unsafe(no_mangle)]
13670    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_i_64(value: i64) -> *mut i64 {
13671        flutter_rust_bridge::for_generated::new_leak_box_ptr(value)
13672    }
13673
13674    #[unsafe(no_mangle)]
13675    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_liquid_address_data(
13676    ) -> *mut wire_cst_liquid_address_data {
13677        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13678            wire_cst_liquid_address_data::new_with_null_ptr(),
13679        )
13680    }
13681
13682    #[unsafe(no_mangle)]
13683    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_list_payment_details(
13684    ) -> *mut wire_cst_list_payment_details {
13685        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13686            wire_cst_list_payment_details::new_with_null_ptr(),
13687        )
13688    }
13689
13690    #[unsafe(no_mangle)]
13691    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_list_payments_request(
13692    ) -> *mut wire_cst_list_payments_request {
13693        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13694            wire_cst_list_payments_request::new_with_null_ptr(),
13695        )
13696    }
13697
13698    #[unsafe(no_mangle)]
13699    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_invoice(
13700    ) -> *mut wire_cst_ln_invoice {
13701        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13702            wire_cst_ln_invoice::new_with_null_ptr(),
13703        )
13704    }
13705
13706    #[unsafe(no_mangle)]
13707    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_offer() -> *mut wire_cst_ln_offer {
13708        flutter_rust_bridge::for_generated::new_leak_box_ptr(wire_cst_ln_offer::new_with_null_ptr())
13709    }
13710
13711    #[unsafe(no_mangle)]
13712    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_url_auth_request_data(
13713    ) -> *mut wire_cst_ln_url_auth_request_data {
13714        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13715            wire_cst_ln_url_auth_request_data::new_with_null_ptr(),
13716        )
13717    }
13718
13719    #[unsafe(no_mangle)]
13720    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_url_error_data(
13721    ) -> *mut wire_cst_ln_url_error_data {
13722        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13723            wire_cst_ln_url_error_data::new_with_null_ptr(),
13724        )
13725    }
13726
13727    #[unsafe(no_mangle)]
13728    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_url_info(
13729    ) -> *mut wire_cst_ln_url_info {
13730        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13731            wire_cst_ln_url_info::new_with_null_ptr(),
13732        )
13733    }
13734
13735    #[unsafe(no_mangle)]
13736    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_url_pay_error_data(
13737    ) -> *mut wire_cst_ln_url_pay_error_data {
13738        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13739            wire_cst_ln_url_pay_error_data::new_with_null_ptr(),
13740        )
13741    }
13742
13743    #[unsafe(no_mangle)]
13744    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_url_pay_request(
13745    ) -> *mut wire_cst_ln_url_pay_request {
13746        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13747            wire_cst_ln_url_pay_request::new_with_null_ptr(),
13748        )
13749    }
13750
13751    #[unsafe(no_mangle)]
13752    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_url_pay_request_data(
13753    ) -> *mut wire_cst_ln_url_pay_request_data {
13754        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13755            wire_cst_ln_url_pay_request_data::new_with_null_ptr(),
13756        )
13757    }
13758
13759    #[unsafe(no_mangle)]
13760    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_url_pay_success_data(
13761    ) -> *mut wire_cst_ln_url_pay_success_data {
13762        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13763            wire_cst_ln_url_pay_success_data::new_with_null_ptr(),
13764        )
13765    }
13766
13767    #[unsafe(no_mangle)]
13768    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_url_withdraw_request(
13769    ) -> *mut wire_cst_ln_url_withdraw_request {
13770        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13771            wire_cst_ln_url_withdraw_request::new_with_null_ptr(),
13772        )
13773    }
13774
13775    #[unsafe(no_mangle)]
13776    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_url_withdraw_request_data(
13777    ) -> *mut wire_cst_ln_url_withdraw_request_data {
13778        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13779            wire_cst_ln_url_withdraw_request_data::new_with_null_ptr(),
13780        )
13781    }
13782
13783    #[unsafe(no_mangle)]
13784    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_ln_url_withdraw_success_data(
13785    ) -> *mut wire_cst_ln_url_withdraw_success_data {
13786        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13787            wire_cst_ln_url_withdraw_success_data::new_with_null_ptr(),
13788        )
13789    }
13790
13791    #[unsafe(no_mangle)]
13792    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_message_success_action_data(
13793    ) -> *mut wire_cst_message_success_action_data {
13794        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13795            wire_cst_message_success_action_data::new_with_null_ptr(),
13796        )
13797    }
13798
13799    #[unsafe(no_mangle)]
13800    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_pay_amount(
13801    ) -> *mut wire_cst_pay_amount {
13802        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13803            wire_cst_pay_amount::new_with_null_ptr(),
13804        )
13805    }
13806
13807    #[unsafe(no_mangle)]
13808    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_pay_onchain_request(
13809    ) -> *mut wire_cst_pay_onchain_request {
13810        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13811            wire_cst_pay_onchain_request::new_with_null_ptr(),
13812        )
13813    }
13814
13815    #[unsafe(no_mangle)]
13816    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_payment() -> *mut wire_cst_payment {
13817        flutter_rust_bridge::for_generated::new_leak_box_ptr(wire_cst_payment::new_with_null_ptr())
13818    }
13819
13820    #[unsafe(no_mangle)]
13821    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_prepare_buy_bitcoin_request(
13822    ) -> *mut wire_cst_prepare_buy_bitcoin_request {
13823        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13824            wire_cst_prepare_buy_bitcoin_request::new_with_null_ptr(),
13825        )
13826    }
13827
13828    #[unsafe(no_mangle)]
13829    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_prepare_ln_url_pay_request(
13830    ) -> *mut wire_cst_prepare_ln_url_pay_request {
13831        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13832            wire_cst_prepare_ln_url_pay_request::new_with_null_ptr(),
13833        )
13834    }
13835
13836    #[unsafe(no_mangle)]
13837    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_prepare_pay_onchain_request(
13838    ) -> *mut wire_cst_prepare_pay_onchain_request {
13839        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13840            wire_cst_prepare_pay_onchain_request::new_with_null_ptr(),
13841        )
13842    }
13843
13844    #[unsafe(no_mangle)]
13845    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_prepare_receive_request(
13846    ) -> *mut wire_cst_prepare_receive_request {
13847        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13848            wire_cst_prepare_receive_request::new_with_null_ptr(),
13849        )
13850    }
13851
13852    #[unsafe(no_mangle)]
13853    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_prepare_refund_request(
13854    ) -> *mut wire_cst_prepare_refund_request {
13855        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13856            wire_cst_prepare_refund_request::new_with_null_ptr(),
13857        )
13858    }
13859
13860    #[unsafe(no_mangle)]
13861    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_prepare_send_request(
13862    ) -> *mut wire_cst_prepare_send_request {
13863        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13864            wire_cst_prepare_send_request::new_with_null_ptr(),
13865        )
13866    }
13867
13868    #[unsafe(no_mangle)]
13869    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_receive_amount(
13870    ) -> *mut wire_cst_receive_amount {
13871        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13872            wire_cst_receive_amount::new_with_null_ptr(),
13873        )
13874    }
13875
13876    #[unsafe(no_mangle)]
13877    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_receive_payment_request(
13878    ) -> *mut wire_cst_receive_payment_request {
13879        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13880            wire_cst_receive_payment_request::new_with_null_ptr(),
13881        )
13882    }
13883
13884    #[unsafe(no_mangle)]
13885    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_refund_request(
13886    ) -> *mut wire_cst_refund_request {
13887        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13888            wire_cst_refund_request::new_with_null_ptr(),
13889        )
13890    }
13891
13892    #[unsafe(no_mangle)]
13893    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_restore_request(
13894    ) -> *mut wire_cst_restore_request {
13895        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13896            wire_cst_restore_request::new_with_null_ptr(),
13897        )
13898    }
13899
13900    #[unsafe(no_mangle)]
13901    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_sdk_event() -> *mut wire_cst_sdk_event
13902    {
13903        flutter_rust_bridge::for_generated::new_leak_box_ptr(wire_cst_sdk_event::new_with_null_ptr())
13904    }
13905
13906    #[unsafe(no_mangle)]
13907    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_send_payment_request(
13908    ) -> *mut wire_cst_send_payment_request {
13909        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13910            wire_cst_send_payment_request::new_with_null_ptr(),
13911        )
13912    }
13913
13914    #[unsafe(no_mangle)]
13915    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_sign_message_request(
13916    ) -> *mut wire_cst_sign_message_request {
13917        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13918            wire_cst_sign_message_request::new_with_null_ptr(),
13919        )
13920    }
13921
13922    #[unsafe(no_mangle)]
13923    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_success_action(
13924    ) -> *mut wire_cst_success_action {
13925        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13926            wire_cst_success_action::new_with_null_ptr(),
13927        )
13928    }
13929
13930    #[unsafe(no_mangle)]
13931    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_success_action_processed(
13932    ) -> *mut wire_cst_success_action_processed {
13933        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13934            wire_cst_success_action_processed::new_with_null_ptr(),
13935        )
13936    }
13937
13938    #[unsafe(no_mangle)]
13939    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_symbol() -> *mut wire_cst_symbol {
13940        flutter_rust_bridge::for_generated::new_leak_box_ptr(wire_cst_symbol::new_with_null_ptr())
13941    }
13942
13943    #[unsafe(no_mangle)]
13944    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_u_32(value: u32) -> *mut u32 {
13945        flutter_rust_bridge::for_generated::new_leak_box_ptr(value)
13946    }
13947
13948    #[unsafe(no_mangle)]
13949    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_u_64(value: u64) -> *mut u64 {
13950        flutter_rust_bridge::for_generated::new_leak_box_ptr(value)
13951    }
13952
13953    #[unsafe(no_mangle)]
13954    pub extern "C" fn frbgen_breez_liquid_cst_new_box_autoadd_url_success_action_data(
13955    ) -> *mut wire_cst_url_success_action_data {
13956        flutter_rust_bridge::for_generated::new_leak_box_ptr(
13957            wire_cst_url_success_action_data::new_with_null_ptr(),
13958        )
13959    }
13960
13961    #[unsafe(no_mangle)]
13962    pub extern "C" fn frbgen_breez_liquid_cst_new_list_String(
13963        len: i32,
13964    ) -> *mut wire_cst_list_String {
13965        let wrap = wire_cst_list_String {
13966            ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
13967                <*mut wire_cst_list_prim_u_8_strict>::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_balance(
13977        len: i32,
13978    ) -> *mut wire_cst_list_asset_balance {
13979        let wrap = wire_cst_list_asset_balance {
13980            ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
13981                <wire_cst_asset_balance>::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_asset_metadata(
13991        len: i32,
13992    ) -> *mut wire_cst_list_asset_metadata {
13993        let wrap = wire_cst_list_asset_metadata {
13994            ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
13995                <wire_cst_asset_metadata>::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_external_input_parser(
14005        len: i32,
14006    ) -> *mut wire_cst_list_external_input_parser {
14007        let wrap = wire_cst_list_external_input_parser {
14008            ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
14009                <wire_cst_external_input_parser>::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_fiat_currency(
14019        len: i32,
14020    ) -> *mut wire_cst_list_fiat_currency {
14021        let wrap = wire_cst_list_fiat_currency {
14022            ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
14023                <wire_cst_fiat_currency>::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_ln_offer_blinded_path(
14033        len: i32,
14034    ) -> *mut wire_cst_list_ln_offer_blinded_path {
14035        let wrap = wire_cst_list_ln_offer_blinded_path {
14036            ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
14037                <wire_cst_ln_offer_blinded_path>::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_locale_overrides(
14047        len: i32,
14048    ) -> *mut wire_cst_list_locale_overrides {
14049        let wrap = wire_cst_list_locale_overrides {
14050            ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
14051                <wire_cst_locale_overrides>::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_localized_name(
14061        len: i32,
14062    ) -> *mut wire_cst_list_localized_name {
14063        let wrap = wire_cst_list_localized_name {
14064            ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
14065                <wire_cst_localized_name>::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(
14075        len: i32,
14076    ) -> *mut wire_cst_list_payment {
14077        let wrap = wire_cst_list_payment {
14078            ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
14079                <wire_cst_payment>::new_with_null_ptr(),
14080                len,
14081            ),
14082            len,
14083        };
14084        flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14085    }
14086
14087    #[unsafe(no_mangle)]
14088    pub extern "C" fn frbgen_breez_liquid_cst_new_list_payment_state(
14089        len: i32,
14090    ) -> *mut wire_cst_list_payment_state {
14091        let wrap = wire_cst_list_payment_state {
14092            ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(Default::default(), len),
14093            len,
14094        };
14095        flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14096    }
14097
14098    #[unsafe(no_mangle)]
14099    pub extern "C" fn frbgen_breez_liquid_cst_new_list_payment_type(
14100        len: i32,
14101    ) -> *mut wire_cst_list_payment_type {
14102        let wrap = wire_cst_list_payment_type {
14103            ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(Default::default(), len),
14104            len,
14105        };
14106        flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14107    }
14108
14109    #[unsafe(no_mangle)]
14110    pub extern "C" fn frbgen_breez_liquid_cst_new_list_prim_u_8_strict(
14111        len: i32,
14112    ) -> *mut wire_cst_list_prim_u_8_strict {
14113        let ans = wire_cst_list_prim_u_8_strict {
14114            ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(Default::default(), len),
14115            len,
14116        };
14117        flutter_rust_bridge::for_generated::new_leak_box_ptr(ans)
14118    }
14119
14120    #[unsafe(no_mangle)]
14121    pub extern "C" fn frbgen_breez_liquid_cst_new_list_rate(len: i32) -> *mut wire_cst_list_rate {
14122        let wrap = wire_cst_list_rate {
14123            ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
14124                <wire_cst_rate>::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_refundable_swap(
14134        len: i32,
14135    ) -> *mut wire_cst_list_refundable_swap {
14136        let wrap = wire_cst_list_refundable_swap {
14137            ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
14138                <wire_cst_refundable_swap>::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(
14148        len: i32,
14149    ) -> *mut wire_cst_list_route_hint {
14150        let wrap = wire_cst_list_route_hint {
14151            ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
14152                <wire_cst_route_hint>::new_with_null_ptr(),
14153                len,
14154            ),
14155            len,
14156        };
14157        flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14158    }
14159
14160    #[unsafe(no_mangle)]
14161    pub extern "C" fn frbgen_breez_liquid_cst_new_list_route_hint_hop(
14162        len: i32,
14163    ) -> *mut wire_cst_list_route_hint_hop {
14164        let wrap = wire_cst_list_route_hint_hop {
14165            ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(
14166                <wire_cst_route_hint_hop>::new_with_null_ptr(),
14167                len,
14168            ),
14169            len,
14170        };
14171        flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap)
14172    }
14173
14174    #[repr(C)]
14175    #[derive(Clone, Copy)]
14176    pub struct wire_cst_accept_payment_proposed_fees_request {
14177        response: wire_cst_fetch_payment_proposed_fees_response,
14178    }
14179    #[repr(C)]
14180    #[derive(Clone, Copy)]
14181    pub struct wire_cst_aes_success_action_data {
14182        description: *mut wire_cst_list_prim_u_8_strict,
14183        ciphertext: *mut wire_cst_list_prim_u_8_strict,
14184        iv: *mut wire_cst_list_prim_u_8_strict,
14185    }
14186    #[repr(C)]
14187    #[derive(Clone, Copy)]
14188    pub struct wire_cst_aes_success_action_data_decrypted {
14189        description: *mut wire_cst_list_prim_u_8_strict,
14190        plaintext: *mut wire_cst_list_prim_u_8_strict,
14191    }
14192    #[repr(C)]
14193    #[derive(Clone, Copy)]
14194    pub struct wire_cst_aes_success_action_data_result {
14195        tag: i32,
14196        kind: AesSuccessActionDataResultKind,
14197    }
14198    #[repr(C)]
14199    #[derive(Clone, Copy)]
14200    pub union AesSuccessActionDataResultKind {
14201        Decrypted: wire_cst_AesSuccessActionDataResult_Decrypted,
14202        ErrorStatus: wire_cst_AesSuccessActionDataResult_ErrorStatus,
14203        nil__: (),
14204    }
14205    #[repr(C)]
14206    #[derive(Clone, Copy)]
14207    pub struct wire_cst_AesSuccessActionDataResult_Decrypted {
14208        data: *mut wire_cst_aes_success_action_data_decrypted,
14209    }
14210    #[repr(C)]
14211    #[derive(Clone, Copy)]
14212    pub struct wire_cst_AesSuccessActionDataResult_ErrorStatus {
14213        reason: *mut wire_cst_list_prim_u_8_strict,
14214    }
14215    #[repr(C)]
14216    #[derive(Clone, Copy)]
14217    pub struct wire_cst_amount {
14218        tag: i32,
14219        kind: AmountKind,
14220    }
14221    #[repr(C)]
14222    #[derive(Clone, Copy)]
14223    pub union AmountKind {
14224        Bitcoin: wire_cst_Amount_Bitcoin,
14225        Currency: wire_cst_Amount_Currency,
14226        nil__: (),
14227    }
14228    #[repr(C)]
14229    #[derive(Clone, Copy)]
14230    pub struct wire_cst_Amount_Bitcoin {
14231        amount_msat: u64,
14232    }
14233    #[repr(C)]
14234    #[derive(Clone, Copy)]
14235    pub struct wire_cst_Amount_Currency {
14236        iso4217_code: *mut wire_cst_list_prim_u_8_strict,
14237        fractional_amount: u64,
14238    }
14239    #[repr(C)]
14240    #[derive(Clone, Copy)]
14241    pub struct wire_cst_asset_balance {
14242        asset_id: *mut wire_cst_list_prim_u_8_strict,
14243        balance_sat: u64,
14244        name: *mut wire_cst_list_prim_u_8_strict,
14245        ticker: *mut wire_cst_list_prim_u_8_strict,
14246        balance: *mut f64,
14247    }
14248    #[repr(C)]
14249    #[derive(Clone, Copy)]
14250    pub struct wire_cst_asset_info {
14251        name: *mut wire_cst_list_prim_u_8_strict,
14252        ticker: *mut wire_cst_list_prim_u_8_strict,
14253        amount: f64,
14254        fees: *mut f64,
14255    }
14256    #[repr(C)]
14257    #[derive(Clone, Copy)]
14258    pub struct wire_cst_asset_metadata {
14259        asset_id: *mut wire_cst_list_prim_u_8_strict,
14260        name: *mut wire_cst_list_prim_u_8_strict,
14261        ticker: *mut wire_cst_list_prim_u_8_strict,
14262        precision: u8,
14263        fiat_id: *mut wire_cst_list_prim_u_8_strict,
14264    }
14265    #[repr(C)]
14266    #[derive(Clone, Copy)]
14267    pub struct wire_cst_backup_request {
14268        backup_path: *mut wire_cst_list_prim_u_8_strict,
14269    }
14270    #[repr(C)]
14271    #[derive(Clone, Copy)]
14272    pub struct wire_cst_binding_event_listener {
14273        stream: *mut wire_cst_list_prim_u_8_strict,
14274    }
14275    #[repr(C)]
14276    #[derive(Clone, Copy)]
14277    pub struct wire_cst_bitcoin_address_data {
14278        address: *mut wire_cst_list_prim_u_8_strict,
14279        network: i32,
14280        amount_sat: *mut u64,
14281        label: *mut wire_cst_list_prim_u_8_strict,
14282        message: *mut wire_cst_list_prim_u_8_strict,
14283    }
14284    #[repr(C)]
14285    #[derive(Clone, Copy)]
14286    pub struct wire_cst_blockchain_explorer {
14287        tag: i32,
14288        kind: BlockchainExplorerKind,
14289    }
14290    #[repr(C)]
14291    #[derive(Clone, Copy)]
14292    pub union BlockchainExplorerKind {
14293        Electrum: wire_cst_BlockchainExplorer_Electrum,
14294        Esplora: wire_cst_BlockchainExplorer_Esplora,
14295        nil__: (),
14296    }
14297    #[repr(C)]
14298    #[derive(Clone, Copy)]
14299    pub struct wire_cst_BlockchainExplorer_Electrum {
14300        url: *mut wire_cst_list_prim_u_8_strict,
14301    }
14302    #[repr(C)]
14303    #[derive(Clone, Copy)]
14304    pub struct wire_cst_BlockchainExplorer_Esplora {
14305        url: *mut wire_cst_list_prim_u_8_strict,
14306        use_waterfalls: bool,
14307    }
14308    #[repr(C)]
14309    #[derive(Clone, Copy)]
14310    pub struct wire_cst_blockchain_info {
14311        liquid_tip: u32,
14312        bitcoin_tip: u32,
14313    }
14314    #[repr(C)]
14315    #[derive(Clone, Copy)]
14316    pub struct wire_cst_buy_bitcoin_request {
14317        prepare_response: wire_cst_prepare_buy_bitcoin_response,
14318        redirect_url: *mut wire_cst_list_prim_u_8_strict,
14319    }
14320    #[repr(C)]
14321    #[derive(Clone, Copy)]
14322    pub struct wire_cst_check_message_request {
14323        message: *mut wire_cst_list_prim_u_8_strict,
14324        pubkey: *mut wire_cst_list_prim_u_8_strict,
14325        signature: *mut wire_cst_list_prim_u_8_strict,
14326    }
14327    #[repr(C)]
14328    #[derive(Clone, Copy)]
14329    pub struct wire_cst_check_message_response {
14330        is_valid: bool,
14331    }
14332    #[repr(C)]
14333    #[derive(Clone, Copy)]
14334    pub struct wire_cst_config {
14335        liquid_explorer: wire_cst_blockchain_explorer,
14336        bitcoin_explorer: wire_cst_blockchain_explorer,
14337        working_dir: *mut wire_cst_list_prim_u_8_strict,
14338        network: i32,
14339        payment_timeout_sec: u64,
14340        sync_service_url: *mut wire_cst_list_prim_u_8_strict,
14341        zero_conf_max_amount_sat: *mut u64,
14342        breez_api_key: *mut wire_cst_list_prim_u_8_strict,
14343        external_input_parsers: *mut wire_cst_list_external_input_parser,
14344        use_default_external_input_parsers: bool,
14345        onchain_fee_rate_leeway_sat_per_vbyte: *mut u32,
14346        asset_metadata: *mut wire_cst_list_asset_metadata,
14347        sideswap_api_key: *mut wire_cst_list_prim_u_8_strict,
14348    }
14349    #[repr(C)]
14350    #[derive(Clone, Copy)]
14351    pub struct wire_cst_connect_request {
14352        config: wire_cst_config,
14353        mnemonic: *mut wire_cst_list_prim_u_8_strict,
14354        passphrase: *mut wire_cst_list_prim_u_8_strict,
14355        seed: *mut wire_cst_list_prim_u_8_strict,
14356    }
14357    #[repr(C)]
14358    #[derive(Clone, Copy)]
14359    pub struct wire_cst_create_bolt_12_invoice_request {
14360        offer: *mut wire_cst_list_prim_u_8_strict,
14361        invoice_request: *mut wire_cst_list_prim_u_8_strict,
14362    }
14363    #[repr(C)]
14364    #[derive(Clone, Copy)]
14365    pub struct wire_cst_create_bolt_12_invoice_response {
14366        invoice: *mut wire_cst_list_prim_u_8_strict,
14367    }
14368    #[repr(C)]
14369    #[derive(Clone, Copy)]
14370    pub struct wire_cst_currency_info {
14371        name: *mut wire_cst_list_prim_u_8_strict,
14372        fraction_size: u32,
14373        spacing: *mut u32,
14374        symbol: *mut wire_cst_symbol,
14375        uniq_symbol: *mut wire_cst_symbol,
14376        localized_name: *mut wire_cst_list_localized_name,
14377        locale_overrides: *mut wire_cst_list_locale_overrides,
14378    }
14379    #[repr(C)]
14380    #[derive(Clone, Copy)]
14381    pub struct wire_cst_external_input_parser {
14382        provider_id: *mut wire_cst_list_prim_u_8_strict,
14383        input_regex: *mut wire_cst_list_prim_u_8_strict,
14384        parser_url: *mut wire_cst_list_prim_u_8_strict,
14385    }
14386    #[repr(C)]
14387    #[derive(Clone, Copy)]
14388    pub struct wire_cst_fetch_payment_proposed_fees_request {
14389        swap_id: *mut wire_cst_list_prim_u_8_strict,
14390    }
14391    #[repr(C)]
14392    #[derive(Clone, Copy)]
14393    pub struct wire_cst_fetch_payment_proposed_fees_response {
14394        swap_id: *mut wire_cst_list_prim_u_8_strict,
14395        fees_sat: u64,
14396        payer_amount_sat: u64,
14397        receiver_amount_sat: u64,
14398    }
14399    #[repr(C)]
14400    #[derive(Clone, Copy)]
14401    pub struct wire_cst_fiat_currency {
14402        id: *mut wire_cst_list_prim_u_8_strict,
14403        info: wire_cst_currency_info,
14404    }
14405    #[repr(C)]
14406    #[derive(Clone, Copy)]
14407    pub struct wire_cst_get_info_response {
14408        wallet_info: wire_cst_wallet_info,
14409        blockchain_info: wire_cst_blockchain_info,
14410    }
14411    #[repr(C)]
14412    #[derive(Clone, Copy)]
14413    pub struct wire_cst_get_payment_request {
14414        tag: i32,
14415        kind: GetPaymentRequestKind,
14416    }
14417    #[repr(C)]
14418    #[derive(Clone, Copy)]
14419    pub union GetPaymentRequestKind {
14420        PaymentHash: wire_cst_GetPaymentRequest_PaymentHash,
14421        SwapId: wire_cst_GetPaymentRequest_SwapId,
14422        nil__: (),
14423    }
14424    #[repr(C)]
14425    #[derive(Clone, Copy)]
14426    pub struct wire_cst_GetPaymentRequest_PaymentHash {
14427        payment_hash: *mut wire_cst_list_prim_u_8_strict,
14428    }
14429    #[repr(C)]
14430    #[derive(Clone, Copy)]
14431    pub struct wire_cst_GetPaymentRequest_SwapId {
14432        swap_id: *mut wire_cst_list_prim_u_8_strict,
14433    }
14434    #[repr(C)]
14435    #[derive(Clone, Copy)]
14436    pub struct wire_cst_input_type {
14437        tag: i32,
14438        kind: InputTypeKind,
14439    }
14440    #[repr(C)]
14441    #[derive(Clone, Copy)]
14442    pub union InputTypeKind {
14443        BitcoinAddress: wire_cst_InputType_BitcoinAddress,
14444        LiquidAddress: wire_cst_InputType_LiquidAddress,
14445        Bolt11: wire_cst_InputType_Bolt11,
14446        Bolt12Offer: wire_cst_InputType_Bolt12Offer,
14447        NodeId: wire_cst_InputType_NodeId,
14448        Url: wire_cst_InputType_Url,
14449        LnUrlPay: wire_cst_InputType_LnUrlPay,
14450        LnUrlWithdraw: wire_cst_InputType_LnUrlWithdraw,
14451        LnUrlAuth: wire_cst_InputType_LnUrlAuth,
14452        LnUrlError: wire_cst_InputType_LnUrlError,
14453        nil__: (),
14454    }
14455    #[repr(C)]
14456    #[derive(Clone, Copy)]
14457    pub struct wire_cst_InputType_BitcoinAddress {
14458        address: *mut wire_cst_bitcoin_address_data,
14459    }
14460    #[repr(C)]
14461    #[derive(Clone, Copy)]
14462    pub struct wire_cst_InputType_LiquidAddress {
14463        address: *mut wire_cst_liquid_address_data,
14464    }
14465    #[repr(C)]
14466    #[derive(Clone, Copy)]
14467    pub struct wire_cst_InputType_Bolt11 {
14468        invoice: *mut wire_cst_ln_invoice,
14469    }
14470    #[repr(C)]
14471    #[derive(Clone, Copy)]
14472    pub struct wire_cst_InputType_Bolt12Offer {
14473        offer: *mut wire_cst_ln_offer,
14474        bip353_address: *mut wire_cst_list_prim_u_8_strict,
14475    }
14476    #[repr(C)]
14477    #[derive(Clone, Copy)]
14478    pub struct wire_cst_InputType_NodeId {
14479        node_id: *mut wire_cst_list_prim_u_8_strict,
14480    }
14481    #[repr(C)]
14482    #[derive(Clone, Copy)]
14483    pub struct wire_cst_InputType_Url {
14484        url: *mut wire_cst_list_prim_u_8_strict,
14485    }
14486    #[repr(C)]
14487    #[derive(Clone, Copy)]
14488    pub struct wire_cst_InputType_LnUrlPay {
14489        data: *mut wire_cst_ln_url_pay_request_data,
14490        bip353_address: *mut wire_cst_list_prim_u_8_strict,
14491    }
14492    #[repr(C)]
14493    #[derive(Clone, Copy)]
14494    pub struct wire_cst_InputType_LnUrlWithdraw {
14495        data: *mut wire_cst_ln_url_withdraw_request_data,
14496    }
14497    #[repr(C)]
14498    #[derive(Clone, Copy)]
14499    pub struct wire_cst_InputType_LnUrlAuth {
14500        data: *mut wire_cst_ln_url_auth_request_data,
14501    }
14502    #[repr(C)]
14503    #[derive(Clone, Copy)]
14504    pub struct wire_cst_InputType_LnUrlError {
14505        data: *mut wire_cst_ln_url_error_data,
14506    }
14507    #[repr(C)]
14508    #[derive(Clone, Copy)]
14509    pub struct wire_cst_lightning_payment_limits_response {
14510        send: wire_cst_limits,
14511        receive: wire_cst_limits,
14512    }
14513    #[repr(C)]
14514    #[derive(Clone, Copy)]
14515    pub struct wire_cst_limits {
14516        min_sat: u64,
14517        max_sat: u64,
14518        max_zero_conf_sat: u64,
14519    }
14520    #[repr(C)]
14521    #[derive(Clone, Copy)]
14522    pub struct wire_cst_liquid_address_data {
14523        address: *mut wire_cst_list_prim_u_8_strict,
14524        network: i32,
14525        asset_id: *mut wire_cst_list_prim_u_8_strict,
14526        amount: *mut f64,
14527        amount_sat: *mut u64,
14528        label: *mut wire_cst_list_prim_u_8_strict,
14529        message: *mut wire_cst_list_prim_u_8_strict,
14530    }
14531    #[repr(C)]
14532    #[derive(Clone, Copy)]
14533    pub struct wire_cst_list_String {
14534        ptr: *mut *mut wire_cst_list_prim_u_8_strict,
14535        len: i32,
14536    }
14537    #[repr(C)]
14538    #[derive(Clone, Copy)]
14539    pub struct wire_cst_list_asset_balance {
14540        ptr: *mut wire_cst_asset_balance,
14541        len: i32,
14542    }
14543    #[repr(C)]
14544    #[derive(Clone, Copy)]
14545    pub struct wire_cst_list_asset_metadata {
14546        ptr: *mut wire_cst_asset_metadata,
14547        len: i32,
14548    }
14549    #[repr(C)]
14550    #[derive(Clone, Copy)]
14551    pub struct wire_cst_list_external_input_parser {
14552        ptr: *mut wire_cst_external_input_parser,
14553        len: i32,
14554    }
14555    #[repr(C)]
14556    #[derive(Clone, Copy)]
14557    pub struct wire_cst_list_fiat_currency {
14558        ptr: *mut wire_cst_fiat_currency,
14559        len: i32,
14560    }
14561    #[repr(C)]
14562    #[derive(Clone, Copy)]
14563    pub struct wire_cst_list_ln_offer_blinded_path {
14564        ptr: *mut wire_cst_ln_offer_blinded_path,
14565        len: i32,
14566    }
14567    #[repr(C)]
14568    #[derive(Clone, Copy)]
14569    pub struct wire_cst_list_locale_overrides {
14570        ptr: *mut wire_cst_locale_overrides,
14571        len: i32,
14572    }
14573    #[repr(C)]
14574    #[derive(Clone, Copy)]
14575    pub struct wire_cst_list_localized_name {
14576        ptr: *mut wire_cst_localized_name,
14577        len: i32,
14578    }
14579    #[repr(C)]
14580    #[derive(Clone, Copy)]
14581    pub struct wire_cst_list_payment {
14582        ptr: *mut wire_cst_payment,
14583        len: i32,
14584    }
14585    #[repr(C)]
14586    #[derive(Clone, Copy)]
14587    pub struct wire_cst_list_payment_details {
14588        tag: i32,
14589        kind: ListPaymentDetailsKind,
14590    }
14591    #[repr(C)]
14592    #[derive(Clone, Copy)]
14593    pub union ListPaymentDetailsKind {
14594        Liquid: wire_cst_ListPaymentDetails_Liquid,
14595        Bitcoin: wire_cst_ListPaymentDetails_Bitcoin,
14596        nil__: (),
14597    }
14598    #[repr(C)]
14599    #[derive(Clone, Copy)]
14600    pub struct wire_cst_ListPaymentDetails_Liquid {
14601        asset_id: *mut wire_cst_list_prim_u_8_strict,
14602        destination: *mut wire_cst_list_prim_u_8_strict,
14603    }
14604    #[repr(C)]
14605    #[derive(Clone, Copy)]
14606    pub struct wire_cst_ListPaymentDetails_Bitcoin {
14607        address: *mut wire_cst_list_prim_u_8_strict,
14608    }
14609    #[repr(C)]
14610    #[derive(Clone, Copy)]
14611    pub struct wire_cst_list_payment_state {
14612        ptr: *mut i32,
14613        len: i32,
14614    }
14615    #[repr(C)]
14616    #[derive(Clone, Copy)]
14617    pub struct wire_cst_list_payment_type {
14618        ptr: *mut i32,
14619        len: i32,
14620    }
14621    #[repr(C)]
14622    #[derive(Clone, Copy)]
14623    pub struct wire_cst_list_payments_request {
14624        filters: *mut wire_cst_list_payment_type,
14625        states: *mut wire_cst_list_payment_state,
14626        from_timestamp: *mut i64,
14627        to_timestamp: *mut i64,
14628        offset: *mut u32,
14629        limit: *mut u32,
14630        details: *mut wire_cst_list_payment_details,
14631        sort_ascending: *mut bool,
14632    }
14633    #[repr(C)]
14634    #[derive(Clone, Copy)]
14635    pub struct wire_cst_list_prim_u_8_strict {
14636        ptr: *mut u8,
14637        len: i32,
14638    }
14639    #[repr(C)]
14640    #[derive(Clone, Copy)]
14641    pub struct wire_cst_list_rate {
14642        ptr: *mut wire_cst_rate,
14643        len: i32,
14644    }
14645    #[repr(C)]
14646    #[derive(Clone, Copy)]
14647    pub struct wire_cst_list_refundable_swap {
14648        ptr: *mut wire_cst_refundable_swap,
14649        len: i32,
14650    }
14651    #[repr(C)]
14652    #[derive(Clone, Copy)]
14653    pub struct wire_cst_list_route_hint {
14654        ptr: *mut wire_cst_route_hint,
14655        len: i32,
14656    }
14657    #[repr(C)]
14658    #[derive(Clone, Copy)]
14659    pub struct wire_cst_list_route_hint_hop {
14660        ptr: *mut wire_cst_route_hint_hop,
14661        len: i32,
14662    }
14663    #[repr(C)]
14664    #[derive(Clone, Copy)]
14665    pub struct wire_cst_ln_invoice {
14666        bolt11: *mut wire_cst_list_prim_u_8_strict,
14667        network: i32,
14668        payee_pubkey: *mut wire_cst_list_prim_u_8_strict,
14669        payment_hash: *mut wire_cst_list_prim_u_8_strict,
14670        description: *mut wire_cst_list_prim_u_8_strict,
14671        description_hash: *mut wire_cst_list_prim_u_8_strict,
14672        amount_msat: *mut u64,
14673        timestamp: u64,
14674        expiry: u64,
14675        routing_hints: *mut wire_cst_list_route_hint,
14676        payment_secret: *mut wire_cst_list_prim_u_8_strict,
14677        min_final_cltv_expiry_delta: u64,
14678    }
14679    #[repr(C)]
14680    #[derive(Clone, Copy)]
14681    pub struct wire_cst_ln_offer {
14682        offer: *mut wire_cst_list_prim_u_8_strict,
14683        chains: *mut wire_cst_list_String,
14684        min_amount: *mut wire_cst_amount,
14685        description: *mut wire_cst_list_prim_u_8_strict,
14686        absolute_expiry: *mut u64,
14687        issuer: *mut wire_cst_list_prim_u_8_strict,
14688        signing_pubkey: *mut wire_cst_list_prim_u_8_strict,
14689        paths: *mut wire_cst_list_ln_offer_blinded_path,
14690    }
14691    #[repr(C)]
14692    #[derive(Clone, Copy)]
14693    pub struct wire_cst_ln_offer_blinded_path {
14694        blinded_hops: *mut wire_cst_list_String,
14695    }
14696    #[repr(C)]
14697    #[derive(Clone, Copy)]
14698    pub struct wire_cst_ln_url_auth_error {
14699        tag: i32,
14700        kind: LnUrlAuthErrorKind,
14701    }
14702    #[repr(C)]
14703    #[derive(Clone, Copy)]
14704    pub union LnUrlAuthErrorKind {
14705        Generic: wire_cst_LnUrlAuthError_Generic,
14706        InvalidUri: wire_cst_LnUrlAuthError_InvalidUri,
14707        ServiceConnectivity: wire_cst_LnUrlAuthError_ServiceConnectivity,
14708        nil__: (),
14709    }
14710    #[repr(C)]
14711    #[derive(Clone, Copy)]
14712    pub struct wire_cst_LnUrlAuthError_Generic {
14713        err: *mut wire_cst_list_prim_u_8_strict,
14714    }
14715    #[repr(C)]
14716    #[derive(Clone, Copy)]
14717    pub struct wire_cst_LnUrlAuthError_InvalidUri {
14718        err: *mut wire_cst_list_prim_u_8_strict,
14719    }
14720    #[repr(C)]
14721    #[derive(Clone, Copy)]
14722    pub struct wire_cst_LnUrlAuthError_ServiceConnectivity {
14723        err: *mut wire_cst_list_prim_u_8_strict,
14724    }
14725    #[repr(C)]
14726    #[derive(Clone, Copy)]
14727    pub struct wire_cst_ln_url_auth_request_data {
14728        k1: *mut wire_cst_list_prim_u_8_strict,
14729        action: *mut wire_cst_list_prim_u_8_strict,
14730        domain: *mut wire_cst_list_prim_u_8_strict,
14731        url: *mut wire_cst_list_prim_u_8_strict,
14732    }
14733    #[repr(C)]
14734    #[derive(Clone, Copy)]
14735    pub struct wire_cst_ln_url_callback_status {
14736        tag: i32,
14737        kind: LnUrlCallbackStatusKind,
14738    }
14739    #[repr(C)]
14740    #[derive(Clone, Copy)]
14741    pub union LnUrlCallbackStatusKind {
14742        ErrorStatus: wire_cst_LnUrlCallbackStatus_ErrorStatus,
14743        nil__: (),
14744    }
14745    #[repr(C)]
14746    #[derive(Clone, Copy)]
14747    pub struct wire_cst_LnUrlCallbackStatus_ErrorStatus {
14748        data: *mut wire_cst_ln_url_error_data,
14749    }
14750    #[repr(C)]
14751    #[derive(Clone, Copy)]
14752    pub struct wire_cst_ln_url_error_data {
14753        reason: *mut wire_cst_list_prim_u_8_strict,
14754    }
14755    #[repr(C)]
14756    #[derive(Clone, Copy)]
14757    pub struct wire_cst_ln_url_info {
14758        ln_address: *mut wire_cst_list_prim_u_8_strict,
14759        lnurl_pay_comment: *mut wire_cst_list_prim_u_8_strict,
14760        lnurl_pay_domain: *mut wire_cst_list_prim_u_8_strict,
14761        lnurl_pay_metadata: *mut wire_cst_list_prim_u_8_strict,
14762        lnurl_pay_success_action: *mut wire_cst_success_action_processed,
14763        lnurl_pay_unprocessed_success_action: *mut wire_cst_success_action,
14764        lnurl_withdraw_endpoint: *mut wire_cst_list_prim_u_8_strict,
14765    }
14766    #[repr(C)]
14767    #[derive(Clone, Copy)]
14768    pub struct wire_cst_ln_url_pay_error {
14769        tag: i32,
14770        kind: LnUrlPayErrorKind,
14771    }
14772    #[repr(C)]
14773    #[derive(Clone, Copy)]
14774    pub union LnUrlPayErrorKind {
14775        Generic: wire_cst_LnUrlPayError_Generic,
14776        InsufficientBalance: wire_cst_LnUrlPayError_InsufficientBalance,
14777        InvalidAmount: wire_cst_LnUrlPayError_InvalidAmount,
14778        InvalidInvoice: wire_cst_LnUrlPayError_InvalidInvoice,
14779        InvalidNetwork: wire_cst_LnUrlPayError_InvalidNetwork,
14780        InvalidUri: wire_cst_LnUrlPayError_InvalidUri,
14781        InvoiceExpired: wire_cst_LnUrlPayError_InvoiceExpired,
14782        PaymentFailed: wire_cst_LnUrlPayError_PaymentFailed,
14783        PaymentTimeout: wire_cst_LnUrlPayError_PaymentTimeout,
14784        RouteNotFound: wire_cst_LnUrlPayError_RouteNotFound,
14785        RouteTooExpensive: wire_cst_LnUrlPayError_RouteTooExpensive,
14786        ServiceConnectivity: wire_cst_LnUrlPayError_ServiceConnectivity,
14787        nil__: (),
14788    }
14789    #[repr(C)]
14790    #[derive(Clone, Copy)]
14791    pub struct wire_cst_LnUrlPayError_Generic {
14792        err: *mut wire_cst_list_prim_u_8_strict,
14793    }
14794    #[repr(C)]
14795    #[derive(Clone, Copy)]
14796    pub struct wire_cst_LnUrlPayError_InsufficientBalance {
14797        err: *mut wire_cst_list_prim_u_8_strict,
14798    }
14799    #[repr(C)]
14800    #[derive(Clone, Copy)]
14801    pub struct wire_cst_LnUrlPayError_InvalidAmount {
14802        err: *mut wire_cst_list_prim_u_8_strict,
14803    }
14804    #[repr(C)]
14805    #[derive(Clone, Copy)]
14806    pub struct wire_cst_LnUrlPayError_InvalidInvoice {
14807        err: *mut wire_cst_list_prim_u_8_strict,
14808    }
14809    #[repr(C)]
14810    #[derive(Clone, Copy)]
14811    pub struct wire_cst_LnUrlPayError_InvalidNetwork {
14812        err: *mut wire_cst_list_prim_u_8_strict,
14813    }
14814    #[repr(C)]
14815    #[derive(Clone, Copy)]
14816    pub struct wire_cst_LnUrlPayError_InvalidUri {
14817        err: *mut wire_cst_list_prim_u_8_strict,
14818    }
14819    #[repr(C)]
14820    #[derive(Clone, Copy)]
14821    pub struct wire_cst_LnUrlPayError_InvoiceExpired {
14822        err: *mut wire_cst_list_prim_u_8_strict,
14823    }
14824    #[repr(C)]
14825    #[derive(Clone, Copy)]
14826    pub struct wire_cst_LnUrlPayError_PaymentFailed {
14827        err: *mut wire_cst_list_prim_u_8_strict,
14828    }
14829    #[repr(C)]
14830    #[derive(Clone, Copy)]
14831    pub struct wire_cst_LnUrlPayError_PaymentTimeout {
14832        err: *mut wire_cst_list_prim_u_8_strict,
14833    }
14834    #[repr(C)]
14835    #[derive(Clone, Copy)]
14836    pub struct wire_cst_LnUrlPayError_RouteNotFound {
14837        err: *mut wire_cst_list_prim_u_8_strict,
14838    }
14839    #[repr(C)]
14840    #[derive(Clone, Copy)]
14841    pub struct wire_cst_LnUrlPayError_RouteTooExpensive {
14842        err: *mut wire_cst_list_prim_u_8_strict,
14843    }
14844    #[repr(C)]
14845    #[derive(Clone, Copy)]
14846    pub struct wire_cst_LnUrlPayError_ServiceConnectivity {
14847        err: *mut wire_cst_list_prim_u_8_strict,
14848    }
14849    #[repr(C)]
14850    #[derive(Clone, Copy)]
14851    pub struct wire_cst_ln_url_pay_error_data {
14852        payment_hash: *mut wire_cst_list_prim_u_8_strict,
14853        reason: *mut wire_cst_list_prim_u_8_strict,
14854    }
14855    #[repr(C)]
14856    #[derive(Clone, Copy)]
14857    pub struct wire_cst_ln_url_pay_request {
14858        prepare_response: wire_cst_prepare_ln_url_pay_response,
14859    }
14860    #[repr(C)]
14861    #[derive(Clone, Copy)]
14862    pub struct wire_cst_ln_url_pay_request_data {
14863        callback: *mut wire_cst_list_prim_u_8_strict,
14864        min_sendable: u64,
14865        max_sendable: u64,
14866        metadata_str: *mut wire_cst_list_prim_u_8_strict,
14867        comment_allowed: u16,
14868        domain: *mut wire_cst_list_prim_u_8_strict,
14869        allows_nostr: bool,
14870        nostr_pubkey: *mut wire_cst_list_prim_u_8_strict,
14871        ln_address: *mut wire_cst_list_prim_u_8_strict,
14872    }
14873    #[repr(C)]
14874    #[derive(Clone, Copy)]
14875    pub struct wire_cst_ln_url_pay_result {
14876        tag: i32,
14877        kind: LnUrlPayResultKind,
14878    }
14879    #[repr(C)]
14880    #[derive(Clone, Copy)]
14881    pub union LnUrlPayResultKind {
14882        EndpointSuccess: wire_cst_LnUrlPayResult_EndpointSuccess,
14883        EndpointError: wire_cst_LnUrlPayResult_EndpointError,
14884        PayError: wire_cst_LnUrlPayResult_PayError,
14885        nil__: (),
14886    }
14887    #[repr(C)]
14888    #[derive(Clone, Copy)]
14889    pub struct wire_cst_LnUrlPayResult_EndpointSuccess {
14890        data: *mut wire_cst_ln_url_pay_success_data,
14891    }
14892    #[repr(C)]
14893    #[derive(Clone, Copy)]
14894    pub struct wire_cst_LnUrlPayResult_EndpointError {
14895        data: *mut wire_cst_ln_url_error_data,
14896    }
14897    #[repr(C)]
14898    #[derive(Clone, Copy)]
14899    pub struct wire_cst_LnUrlPayResult_PayError {
14900        data: *mut wire_cst_ln_url_pay_error_data,
14901    }
14902    #[repr(C)]
14903    #[derive(Clone, Copy)]
14904    pub struct wire_cst_ln_url_pay_success_data {
14905        payment: wire_cst_payment,
14906        success_action: *mut wire_cst_success_action_processed,
14907    }
14908    #[repr(C)]
14909    #[derive(Clone, Copy)]
14910    pub struct wire_cst_ln_url_withdraw_error {
14911        tag: i32,
14912        kind: LnUrlWithdrawErrorKind,
14913    }
14914    #[repr(C)]
14915    #[derive(Clone, Copy)]
14916    pub union LnUrlWithdrawErrorKind {
14917        Generic: wire_cst_LnUrlWithdrawError_Generic,
14918        InvalidAmount: wire_cst_LnUrlWithdrawError_InvalidAmount,
14919        InvalidInvoice: wire_cst_LnUrlWithdrawError_InvalidInvoice,
14920        InvalidUri: wire_cst_LnUrlWithdrawError_InvalidUri,
14921        InvoiceNoRoutingHints: wire_cst_LnUrlWithdrawError_InvoiceNoRoutingHints,
14922        ServiceConnectivity: wire_cst_LnUrlWithdrawError_ServiceConnectivity,
14923        nil__: (),
14924    }
14925    #[repr(C)]
14926    #[derive(Clone, Copy)]
14927    pub struct wire_cst_LnUrlWithdrawError_Generic {
14928        err: *mut wire_cst_list_prim_u_8_strict,
14929    }
14930    #[repr(C)]
14931    #[derive(Clone, Copy)]
14932    pub struct wire_cst_LnUrlWithdrawError_InvalidAmount {
14933        err: *mut wire_cst_list_prim_u_8_strict,
14934    }
14935    #[repr(C)]
14936    #[derive(Clone, Copy)]
14937    pub struct wire_cst_LnUrlWithdrawError_InvalidInvoice {
14938        err: *mut wire_cst_list_prim_u_8_strict,
14939    }
14940    #[repr(C)]
14941    #[derive(Clone, Copy)]
14942    pub struct wire_cst_LnUrlWithdrawError_InvalidUri {
14943        err: *mut wire_cst_list_prim_u_8_strict,
14944    }
14945    #[repr(C)]
14946    #[derive(Clone, Copy)]
14947    pub struct wire_cst_LnUrlWithdrawError_InvoiceNoRoutingHints {
14948        err: *mut wire_cst_list_prim_u_8_strict,
14949    }
14950    #[repr(C)]
14951    #[derive(Clone, Copy)]
14952    pub struct wire_cst_LnUrlWithdrawError_ServiceConnectivity {
14953        err: *mut wire_cst_list_prim_u_8_strict,
14954    }
14955    #[repr(C)]
14956    #[derive(Clone, Copy)]
14957    pub struct wire_cst_ln_url_withdraw_request {
14958        data: wire_cst_ln_url_withdraw_request_data,
14959        amount_msat: u64,
14960        description: *mut wire_cst_list_prim_u_8_strict,
14961    }
14962    #[repr(C)]
14963    #[derive(Clone, Copy)]
14964    pub struct wire_cst_ln_url_withdraw_request_data {
14965        callback: *mut wire_cst_list_prim_u_8_strict,
14966        k1: *mut wire_cst_list_prim_u_8_strict,
14967        default_description: *mut wire_cst_list_prim_u_8_strict,
14968        min_withdrawable: u64,
14969        max_withdrawable: u64,
14970    }
14971    #[repr(C)]
14972    #[derive(Clone, Copy)]
14973    pub struct wire_cst_ln_url_withdraw_result {
14974        tag: i32,
14975        kind: LnUrlWithdrawResultKind,
14976    }
14977    #[repr(C)]
14978    #[derive(Clone, Copy)]
14979    pub union LnUrlWithdrawResultKind {
14980        Ok: wire_cst_LnUrlWithdrawResult_Ok,
14981        Timeout: wire_cst_LnUrlWithdrawResult_Timeout,
14982        ErrorStatus: wire_cst_LnUrlWithdrawResult_ErrorStatus,
14983        nil__: (),
14984    }
14985    #[repr(C)]
14986    #[derive(Clone, Copy)]
14987    pub struct wire_cst_LnUrlWithdrawResult_Ok {
14988        data: *mut wire_cst_ln_url_withdraw_success_data,
14989    }
14990    #[repr(C)]
14991    #[derive(Clone, Copy)]
14992    pub struct wire_cst_LnUrlWithdrawResult_Timeout {
14993        data: *mut wire_cst_ln_url_withdraw_success_data,
14994    }
14995    #[repr(C)]
14996    #[derive(Clone, Copy)]
14997    pub struct wire_cst_LnUrlWithdrawResult_ErrorStatus {
14998        data: *mut wire_cst_ln_url_error_data,
14999    }
15000    #[repr(C)]
15001    #[derive(Clone, Copy)]
15002    pub struct wire_cst_ln_url_withdraw_success_data {
15003        invoice: wire_cst_ln_invoice,
15004    }
15005    #[repr(C)]
15006    #[derive(Clone, Copy)]
15007    pub struct wire_cst_locale_overrides {
15008        locale: *mut wire_cst_list_prim_u_8_strict,
15009        spacing: *mut u32,
15010        symbol: wire_cst_symbol,
15011    }
15012    #[repr(C)]
15013    #[derive(Clone, Copy)]
15014    pub struct wire_cst_localized_name {
15015        locale: *mut wire_cst_list_prim_u_8_strict,
15016        name: *mut wire_cst_list_prim_u_8_strict,
15017    }
15018    #[repr(C)]
15019    #[derive(Clone, Copy)]
15020    pub struct wire_cst_log_entry {
15021        line: *mut wire_cst_list_prim_u_8_strict,
15022        level: *mut wire_cst_list_prim_u_8_strict,
15023    }
15024    #[repr(C)]
15025    #[derive(Clone, Copy)]
15026    pub struct wire_cst_message_success_action_data {
15027        message: *mut wire_cst_list_prim_u_8_strict,
15028    }
15029    #[repr(C)]
15030    #[derive(Clone, Copy)]
15031    pub struct wire_cst_onchain_payment_limits_response {
15032        send: wire_cst_limits,
15033        receive: wire_cst_limits,
15034    }
15035    #[repr(C)]
15036    #[derive(Clone, Copy)]
15037    pub struct wire_cst_pay_amount {
15038        tag: i32,
15039        kind: PayAmountKind,
15040    }
15041    #[repr(C)]
15042    #[derive(Clone, Copy)]
15043    pub union PayAmountKind {
15044        Bitcoin: wire_cst_PayAmount_Bitcoin,
15045        Asset: wire_cst_PayAmount_Asset,
15046        nil__: (),
15047    }
15048    #[repr(C)]
15049    #[derive(Clone, Copy)]
15050    pub struct wire_cst_PayAmount_Bitcoin {
15051        receiver_amount_sat: u64,
15052    }
15053    #[repr(C)]
15054    #[derive(Clone, Copy)]
15055    pub struct wire_cst_PayAmount_Asset {
15056        asset_id: *mut wire_cst_list_prim_u_8_strict,
15057        receiver_amount: f64,
15058        estimate_asset_fees: *mut bool,
15059    }
15060    #[repr(C)]
15061    #[derive(Clone, Copy)]
15062    pub struct wire_cst_pay_onchain_request {
15063        address: *mut wire_cst_list_prim_u_8_strict,
15064        prepare_response: wire_cst_prepare_pay_onchain_response,
15065    }
15066    #[repr(C)]
15067    #[derive(Clone, Copy)]
15068    pub struct wire_cst_payment {
15069        destination: *mut wire_cst_list_prim_u_8_strict,
15070        tx_id: *mut wire_cst_list_prim_u_8_strict,
15071        unblinding_data: *mut wire_cst_list_prim_u_8_strict,
15072        timestamp: u32,
15073        amount_sat: u64,
15074        fees_sat: u64,
15075        swapper_fees_sat: *mut u64,
15076        payment_type: i32,
15077        status: i32,
15078        details: wire_cst_payment_details,
15079    }
15080    #[repr(C)]
15081    #[derive(Clone, Copy)]
15082    pub struct wire_cst_payment_details {
15083        tag: i32,
15084        kind: PaymentDetailsKind,
15085    }
15086    #[repr(C)]
15087    #[derive(Clone, Copy)]
15088    pub union PaymentDetailsKind {
15089        Lightning: wire_cst_PaymentDetails_Lightning,
15090        Liquid: wire_cst_PaymentDetails_Liquid,
15091        Bitcoin: wire_cst_PaymentDetails_Bitcoin,
15092        nil__: (),
15093    }
15094    #[repr(C)]
15095    #[derive(Clone, Copy)]
15096    pub struct wire_cst_PaymentDetails_Lightning {
15097        swap_id: *mut wire_cst_list_prim_u_8_strict,
15098        description: *mut wire_cst_list_prim_u_8_strict,
15099        liquid_expiration_blockheight: u32,
15100        preimage: *mut wire_cst_list_prim_u_8_strict,
15101        invoice: *mut wire_cst_list_prim_u_8_strict,
15102        bolt12_offer: *mut wire_cst_list_prim_u_8_strict,
15103        payment_hash: *mut wire_cst_list_prim_u_8_strict,
15104        destination_pubkey: *mut wire_cst_list_prim_u_8_strict,
15105        lnurl_info: *mut wire_cst_ln_url_info,
15106        bip353_address: *mut wire_cst_list_prim_u_8_strict,
15107        claim_tx_id: *mut wire_cst_list_prim_u_8_strict,
15108        refund_tx_id: *mut wire_cst_list_prim_u_8_strict,
15109        refund_tx_amount_sat: *mut u64,
15110    }
15111    #[repr(C)]
15112    #[derive(Clone, Copy)]
15113    pub struct wire_cst_PaymentDetails_Liquid {
15114        destination: *mut wire_cst_list_prim_u_8_strict,
15115        description: *mut wire_cst_list_prim_u_8_strict,
15116        asset_id: *mut wire_cst_list_prim_u_8_strict,
15117        asset_info: *mut wire_cst_asset_info,
15118        lnurl_info: *mut wire_cst_ln_url_info,
15119        bip353_address: *mut wire_cst_list_prim_u_8_strict,
15120    }
15121    #[repr(C)]
15122    #[derive(Clone, Copy)]
15123    pub struct wire_cst_PaymentDetails_Bitcoin {
15124        swap_id: *mut wire_cst_list_prim_u_8_strict,
15125        bitcoin_address: *mut wire_cst_list_prim_u_8_strict,
15126        description: *mut wire_cst_list_prim_u_8_strict,
15127        auto_accepted_fees: bool,
15128        liquid_expiration_blockheight: *mut u32,
15129        bitcoin_expiration_blockheight: *mut u32,
15130        lockup_tx_id: *mut wire_cst_list_prim_u_8_strict,
15131        claim_tx_id: *mut wire_cst_list_prim_u_8_strict,
15132        refund_tx_id: *mut wire_cst_list_prim_u_8_strict,
15133        refund_tx_amount_sat: *mut u64,
15134    }
15135    #[repr(C)]
15136    #[derive(Clone, Copy)]
15137    pub struct wire_cst_payment_error {
15138        tag: i32,
15139        kind: PaymentErrorKind,
15140    }
15141    #[repr(C)]
15142    #[derive(Clone, Copy)]
15143    pub union PaymentErrorKind {
15144        AmountOutOfRange: wire_cst_PaymentError_AmountOutOfRange,
15145        AmountMissing: wire_cst_PaymentError_AmountMissing,
15146        AssetError: wire_cst_PaymentError_AssetError,
15147        InvalidNetwork: wire_cst_PaymentError_InvalidNetwork,
15148        Generic: wire_cst_PaymentError_Generic,
15149        InvalidDescription: wire_cst_PaymentError_InvalidDescription,
15150        InvalidInvoice: wire_cst_PaymentError_InvalidInvoice,
15151        ReceiveError: wire_cst_PaymentError_ReceiveError,
15152        Refunded: wire_cst_PaymentError_Refunded,
15153        SendError: wire_cst_PaymentError_SendError,
15154        SignerError: wire_cst_PaymentError_SignerError,
15155        nil__: (),
15156    }
15157    #[repr(C)]
15158    #[derive(Clone, Copy)]
15159    pub struct wire_cst_PaymentError_AmountOutOfRange {
15160        min: u64,
15161        max: u64,
15162    }
15163    #[repr(C)]
15164    #[derive(Clone, Copy)]
15165    pub struct wire_cst_PaymentError_AmountMissing {
15166        err: *mut wire_cst_list_prim_u_8_strict,
15167    }
15168    #[repr(C)]
15169    #[derive(Clone, Copy)]
15170    pub struct wire_cst_PaymentError_AssetError {
15171        err: *mut wire_cst_list_prim_u_8_strict,
15172    }
15173    #[repr(C)]
15174    #[derive(Clone, Copy)]
15175    pub struct wire_cst_PaymentError_InvalidNetwork {
15176        err: *mut wire_cst_list_prim_u_8_strict,
15177    }
15178    #[repr(C)]
15179    #[derive(Clone, Copy)]
15180    pub struct wire_cst_PaymentError_Generic {
15181        err: *mut wire_cst_list_prim_u_8_strict,
15182    }
15183    #[repr(C)]
15184    #[derive(Clone, Copy)]
15185    pub struct wire_cst_PaymentError_InvalidDescription {
15186        err: *mut wire_cst_list_prim_u_8_strict,
15187    }
15188    #[repr(C)]
15189    #[derive(Clone, Copy)]
15190    pub struct wire_cst_PaymentError_InvalidInvoice {
15191        err: *mut wire_cst_list_prim_u_8_strict,
15192    }
15193    #[repr(C)]
15194    #[derive(Clone, Copy)]
15195    pub struct wire_cst_PaymentError_ReceiveError {
15196        err: *mut wire_cst_list_prim_u_8_strict,
15197    }
15198    #[repr(C)]
15199    #[derive(Clone, Copy)]
15200    pub struct wire_cst_PaymentError_Refunded {
15201        err: *mut wire_cst_list_prim_u_8_strict,
15202        refund_tx_id: *mut wire_cst_list_prim_u_8_strict,
15203    }
15204    #[repr(C)]
15205    #[derive(Clone, Copy)]
15206    pub struct wire_cst_PaymentError_SendError {
15207        err: *mut wire_cst_list_prim_u_8_strict,
15208    }
15209    #[repr(C)]
15210    #[derive(Clone, Copy)]
15211    pub struct wire_cst_PaymentError_SignerError {
15212        err: *mut wire_cst_list_prim_u_8_strict,
15213    }
15214    #[repr(C)]
15215    #[derive(Clone, Copy)]
15216    pub struct wire_cst_prepare_buy_bitcoin_request {
15217        provider: i32,
15218        amount_sat: u64,
15219    }
15220    #[repr(C)]
15221    #[derive(Clone, Copy)]
15222    pub struct wire_cst_prepare_buy_bitcoin_response {
15223        provider: i32,
15224        amount_sat: u64,
15225        fees_sat: u64,
15226    }
15227    #[repr(C)]
15228    #[derive(Clone, Copy)]
15229    pub struct wire_cst_prepare_ln_url_pay_request {
15230        data: wire_cst_ln_url_pay_request_data,
15231        amount: wire_cst_pay_amount,
15232        bip353_address: *mut wire_cst_list_prim_u_8_strict,
15233        comment: *mut wire_cst_list_prim_u_8_strict,
15234        validate_success_action_url: *mut bool,
15235    }
15236    #[repr(C)]
15237    #[derive(Clone, Copy)]
15238    pub struct wire_cst_prepare_ln_url_pay_response {
15239        destination: wire_cst_send_destination,
15240        fees_sat: u64,
15241        data: wire_cst_ln_url_pay_request_data,
15242        amount: wire_cst_pay_amount,
15243        comment: *mut wire_cst_list_prim_u_8_strict,
15244        success_action: *mut wire_cst_success_action,
15245    }
15246    #[repr(C)]
15247    #[derive(Clone, Copy)]
15248    pub struct wire_cst_prepare_pay_onchain_request {
15249        amount: wire_cst_pay_amount,
15250        fee_rate_sat_per_vbyte: *mut u32,
15251    }
15252    #[repr(C)]
15253    #[derive(Clone, Copy)]
15254    pub struct wire_cst_prepare_pay_onchain_response {
15255        receiver_amount_sat: u64,
15256        claim_fees_sat: u64,
15257        total_fees_sat: u64,
15258    }
15259    #[repr(C)]
15260    #[derive(Clone, Copy)]
15261    pub struct wire_cst_prepare_receive_request {
15262        payment_method: i32,
15263        amount: *mut wire_cst_receive_amount,
15264    }
15265    #[repr(C)]
15266    #[derive(Clone, Copy)]
15267    pub struct wire_cst_prepare_receive_response {
15268        payment_method: i32,
15269        fees_sat: u64,
15270        amount: *mut wire_cst_receive_amount,
15271        min_payer_amount_sat: *mut u64,
15272        max_payer_amount_sat: *mut u64,
15273        swapper_feerate: *mut f64,
15274    }
15275    #[repr(C)]
15276    #[derive(Clone, Copy)]
15277    pub struct wire_cst_prepare_refund_request {
15278        swap_address: *mut wire_cst_list_prim_u_8_strict,
15279        refund_address: *mut wire_cst_list_prim_u_8_strict,
15280        fee_rate_sat_per_vbyte: u32,
15281    }
15282    #[repr(C)]
15283    #[derive(Clone, Copy)]
15284    pub struct wire_cst_prepare_refund_response {
15285        tx_vsize: u32,
15286        tx_fee_sat: u64,
15287        last_refund_tx_id: *mut wire_cst_list_prim_u_8_strict,
15288    }
15289    #[repr(C)]
15290    #[derive(Clone, Copy)]
15291    pub struct wire_cst_prepare_send_request {
15292        destination: *mut wire_cst_list_prim_u_8_strict,
15293        amount: *mut wire_cst_pay_amount,
15294        comment: *mut wire_cst_list_prim_u_8_strict,
15295    }
15296    #[repr(C)]
15297    #[derive(Clone, Copy)]
15298    pub struct wire_cst_prepare_send_response {
15299        destination: wire_cst_send_destination,
15300        amount: *mut wire_cst_pay_amount,
15301        fees_sat: *mut u64,
15302        estimated_asset_fees: *mut f64,
15303    }
15304    #[repr(C)]
15305    #[derive(Clone, Copy)]
15306    pub struct wire_cst_rate {
15307        coin: *mut wire_cst_list_prim_u_8_strict,
15308        value: f64,
15309    }
15310    #[repr(C)]
15311    #[derive(Clone, Copy)]
15312    pub struct wire_cst_receive_amount {
15313        tag: i32,
15314        kind: ReceiveAmountKind,
15315    }
15316    #[repr(C)]
15317    #[derive(Clone, Copy)]
15318    pub union ReceiveAmountKind {
15319        Bitcoin: wire_cst_ReceiveAmount_Bitcoin,
15320        Asset: wire_cst_ReceiveAmount_Asset,
15321        nil__: (),
15322    }
15323    #[repr(C)]
15324    #[derive(Clone, Copy)]
15325    pub struct wire_cst_ReceiveAmount_Bitcoin {
15326        payer_amount_sat: u64,
15327    }
15328    #[repr(C)]
15329    #[derive(Clone, Copy)]
15330    pub struct wire_cst_ReceiveAmount_Asset {
15331        asset_id: *mut wire_cst_list_prim_u_8_strict,
15332        payer_amount: *mut f64,
15333    }
15334    #[repr(C)]
15335    #[derive(Clone, Copy)]
15336    pub struct wire_cst_receive_payment_request {
15337        prepare_response: wire_cst_prepare_receive_response,
15338        description: *mut wire_cst_list_prim_u_8_strict,
15339        use_description_hash: *mut bool,
15340    }
15341    #[repr(C)]
15342    #[derive(Clone, Copy)]
15343    pub struct wire_cst_receive_payment_response {
15344        destination: *mut wire_cst_list_prim_u_8_strict,
15345    }
15346    #[repr(C)]
15347    #[derive(Clone, Copy)]
15348    pub struct wire_cst_recommended_fees {
15349        fastest_fee: u64,
15350        half_hour_fee: u64,
15351        hour_fee: u64,
15352        economy_fee: u64,
15353        minimum_fee: u64,
15354    }
15355    #[repr(C)]
15356    #[derive(Clone, Copy)]
15357    pub struct wire_cst_refund_request {
15358        swap_address: *mut wire_cst_list_prim_u_8_strict,
15359        refund_address: *mut wire_cst_list_prim_u_8_strict,
15360        fee_rate_sat_per_vbyte: u32,
15361    }
15362    #[repr(C)]
15363    #[derive(Clone, Copy)]
15364    pub struct wire_cst_refund_response {
15365        refund_tx_id: *mut wire_cst_list_prim_u_8_strict,
15366    }
15367    #[repr(C)]
15368    #[derive(Clone, Copy)]
15369    pub struct wire_cst_refundable_swap {
15370        swap_address: *mut wire_cst_list_prim_u_8_strict,
15371        timestamp: u32,
15372        amount_sat: u64,
15373        last_refund_tx_id: *mut wire_cst_list_prim_u_8_strict,
15374    }
15375    #[repr(C)]
15376    #[derive(Clone, Copy)]
15377    pub struct wire_cst_restore_request {
15378        backup_path: *mut wire_cst_list_prim_u_8_strict,
15379    }
15380    #[repr(C)]
15381    #[derive(Clone, Copy)]
15382    pub struct wire_cst_route_hint {
15383        hops: *mut wire_cst_list_route_hint_hop,
15384    }
15385    #[repr(C)]
15386    #[derive(Clone, Copy)]
15387    pub struct wire_cst_route_hint_hop {
15388        src_node_id: *mut wire_cst_list_prim_u_8_strict,
15389        short_channel_id: *mut wire_cst_list_prim_u_8_strict,
15390        fees_base_msat: u32,
15391        fees_proportional_millionths: u32,
15392        cltv_expiry_delta: u64,
15393        htlc_minimum_msat: *mut u64,
15394        htlc_maximum_msat: *mut u64,
15395    }
15396    #[repr(C)]
15397    #[derive(Clone, Copy)]
15398    pub struct wire_cst_sdk_error {
15399        tag: i32,
15400        kind: SdkErrorKind,
15401    }
15402    #[repr(C)]
15403    #[derive(Clone, Copy)]
15404    pub union SdkErrorKind {
15405        Generic: wire_cst_SdkError_Generic,
15406        ServiceConnectivity: wire_cst_SdkError_ServiceConnectivity,
15407        nil__: (),
15408    }
15409    #[repr(C)]
15410    #[derive(Clone, Copy)]
15411    pub struct wire_cst_SdkError_Generic {
15412        err: *mut wire_cst_list_prim_u_8_strict,
15413    }
15414    #[repr(C)]
15415    #[derive(Clone, Copy)]
15416    pub struct wire_cst_SdkError_ServiceConnectivity {
15417        err: *mut wire_cst_list_prim_u_8_strict,
15418    }
15419    #[repr(C)]
15420    #[derive(Clone, Copy)]
15421    pub struct wire_cst_sdk_event {
15422        tag: i32,
15423        kind: SdkEventKind,
15424    }
15425    #[repr(C)]
15426    #[derive(Clone, Copy)]
15427    pub union SdkEventKind {
15428        PaymentFailed: wire_cst_SdkEvent_PaymentFailed,
15429        PaymentPending: wire_cst_SdkEvent_PaymentPending,
15430        PaymentRefundable: wire_cst_SdkEvent_PaymentRefundable,
15431        PaymentRefunded: wire_cst_SdkEvent_PaymentRefunded,
15432        PaymentRefundPending: wire_cst_SdkEvent_PaymentRefundPending,
15433        PaymentSucceeded: wire_cst_SdkEvent_PaymentSucceeded,
15434        PaymentWaitingConfirmation: wire_cst_SdkEvent_PaymentWaitingConfirmation,
15435        PaymentWaitingFeeAcceptance: wire_cst_SdkEvent_PaymentWaitingFeeAcceptance,
15436        DataSynced: wire_cst_SdkEvent_DataSynced,
15437        nil__: (),
15438    }
15439    #[repr(C)]
15440    #[derive(Clone, Copy)]
15441    pub struct wire_cst_SdkEvent_PaymentFailed {
15442        details: *mut wire_cst_payment,
15443    }
15444    #[repr(C)]
15445    #[derive(Clone, Copy)]
15446    pub struct wire_cst_SdkEvent_PaymentPending {
15447        details: *mut wire_cst_payment,
15448    }
15449    #[repr(C)]
15450    #[derive(Clone, Copy)]
15451    pub struct wire_cst_SdkEvent_PaymentRefundable {
15452        details: *mut wire_cst_payment,
15453    }
15454    #[repr(C)]
15455    #[derive(Clone, Copy)]
15456    pub struct wire_cst_SdkEvent_PaymentRefunded {
15457        details: *mut wire_cst_payment,
15458    }
15459    #[repr(C)]
15460    #[derive(Clone, Copy)]
15461    pub struct wire_cst_SdkEvent_PaymentRefundPending {
15462        details: *mut wire_cst_payment,
15463    }
15464    #[repr(C)]
15465    #[derive(Clone, Copy)]
15466    pub struct wire_cst_SdkEvent_PaymentSucceeded {
15467        details: *mut wire_cst_payment,
15468    }
15469    #[repr(C)]
15470    #[derive(Clone, Copy)]
15471    pub struct wire_cst_SdkEvent_PaymentWaitingConfirmation {
15472        details: *mut wire_cst_payment,
15473    }
15474    #[repr(C)]
15475    #[derive(Clone, Copy)]
15476    pub struct wire_cst_SdkEvent_PaymentWaitingFeeAcceptance {
15477        details: *mut wire_cst_payment,
15478    }
15479    #[repr(C)]
15480    #[derive(Clone, Copy)]
15481    pub struct wire_cst_SdkEvent_DataSynced {
15482        did_pull_new_records: bool,
15483    }
15484    #[repr(C)]
15485    #[derive(Clone, Copy)]
15486    pub struct wire_cst_send_destination {
15487        tag: i32,
15488        kind: SendDestinationKind,
15489    }
15490    #[repr(C)]
15491    #[derive(Clone, Copy)]
15492    pub union SendDestinationKind {
15493        LiquidAddress: wire_cst_SendDestination_LiquidAddress,
15494        Bolt11: wire_cst_SendDestination_Bolt11,
15495        Bolt12: wire_cst_SendDestination_Bolt12,
15496        nil__: (),
15497    }
15498    #[repr(C)]
15499    #[derive(Clone, Copy)]
15500    pub struct wire_cst_SendDestination_LiquidAddress {
15501        address_data: *mut wire_cst_liquid_address_data,
15502        bip353_address: *mut wire_cst_list_prim_u_8_strict,
15503    }
15504    #[repr(C)]
15505    #[derive(Clone, Copy)]
15506    pub struct wire_cst_SendDestination_Bolt11 {
15507        invoice: *mut wire_cst_ln_invoice,
15508        bip353_address: *mut wire_cst_list_prim_u_8_strict,
15509    }
15510    #[repr(C)]
15511    #[derive(Clone, Copy)]
15512    pub struct wire_cst_SendDestination_Bolt12 {
15513        offer: *mut wire_cst_ln_offer,
15514        receiver_amount_sat: u64,
15515        bip353_address: *mut wire_cst_list_prim_u_8_strict,
15516        payer_note: *mut wire_cst_list_prim_u_8_strict,
15517    }
15518    #[repr(C)]
15519    #[derive(Clone, Copy)]
15520    pub struct wire_cst_send_payment_request {
15521        prepare_response: wire_cst_prepare_send_response,
15522        use_asset_fees: *mut bool,
15523    }
15524    #[repr(C)]
15525    #[derive(Clone, Copy)]
15526    pub struct wire_cst_send_payment_response {
15527        payment: wire_cst_payment,
15528    }
15529    #[repr(C)]
15530    #[derive(Clone, Copy)]
15531    pub struct wire_cst_sign_message_request {
15532        message: *mut wire_cst_list_prim_u_8_strict,
15533    }
15534    #[repr(C)]
15535    #[derive(Clone, Copy)]
15536    pub struct wire_cst_sign_message_response {
15537        signature: *mut wire_cst_list_prim_u_8_strict,
15538    }
15539    #[repr(C)]
15540    #[derive(Clone, Copy)]
15541    pub struct wire_cst_success_action {
15542        tag: i32,
15543        kind: SuccessActionKind,
15544    }
15545    #[repr(C)]
15546    #[derive(Clone, Copy)]
15547    pub union SuccessActionKind {
15548        Aes: wire_cst_SuccessAction_Aes,
15549        Message: wire_cst_SuccessAction_Message,
15550        Url: wire_cst_SuccessAction_Url,
15551        nil__: (),
15552    }
15553    #[repr(C)]
15554    #[derive(Clone, Copy)]
15555    pub struct wire_cst_SuccessAction_Aes {
15556        data: *mut wire_cst_aes_success_action_data,
15557    }
15558    #[repr(C)]
15559    #[derive(Clone, Copy)]
15560    pub struct wire_cst_SuccessAction_Message {
15561        data: *mut wire_cst_message_success_action_data,
15562    }
15563    #[repr(C)]
15564    #[derive(Clone, Copy)]
15565    pub struct wire_cst_SuccessAction_Url {
15566        data: *mut wire_cst_url_success_action_data,
15567    }
15568    #[repr(C)]
15569    #[derive(Clone, Copy)]
15570    pub struct wire_cst_success_action_processed {
15571        tag: i32,
15572        kind: SuccessActionProcessedKind,
15573    }
15574    #[repr(C)]
15575    #[derive(Clone, Copy)]
15576    pub union SuccessActionProcessedKind {
15577        Aes: wire_cst_SuccessActionProcessed_Aes,
15578        Message: wire_cst_SuccessActionProcessed_Message,
15579        Url: wire_cst_SuccessActionProcessed_Url,
15580        nil__: (),
15581    }
15582    #[repr(C)]
15583    #[derive(Clone, Copy)]
15584    pub struct wire_cst_SuccessActionProcessed_Aes {
15585        result: *mut wire_cst_aes_success_action_data_result,
15586    }
15587    #[repr(C)]
15588    #[derive(Clone, Copy)]
15589    pub struct wire_cst_SuccessActionProcessed_Message {
15590        data: *mut wire_cst_message_success_action_data,
15591    }
15592    #[repr(C)]
15593    #[derive(Clone, Copy)]
15594    pub struct wire_cst_SuccessActionProcessed_Url {
15595        data: *mut wire_cst_url_success_action_data,
15596    }
15597    #[repr(C)]
15598    #[derive(Clone, Copy)]
15599    pub struct wire_cst_symbol {
15600        grapheme: *mut wire_cst_list_prim_u_8_strict,
15601        template: *mut wire_cst_list_prim_u_8_strict,
15602        rtl: *mut bool,
15603        position: *mut u32,
15604    }
15605    #[repr(C)]
15606    #[derive(Clone, Copy)]
15607    pub struct wire_cst_url_success_action_data {
15608        description: *mut wire_cst_list_prim_u_8_strict,
15609        url: *mut wire_cst_list_prim_u_8_strict,
15610        matches_callback_domain: bool,
15611    }
15612    #[repr(C)]
15613    #[derive(Clone, Copy)]
15614    pub struct wire_cst_wallet_info {
15615        balance_sat: u64,
15616        pending_send_sat: u64,
15617        pending_receive_sat: u64,
15618        fingerprint: *mut wire_cst_list_prim_u_8_strict,
15619        pubkey: *mut wire_cst_list_prim_u_8_strict,
15620        asset_balances: *mut wire_cst_list_asset_balance,
15621    }
15622}
15623#[cfg(not(target_family = "wasm"))]
15624pub use io::*;