breez-sdk-liquid/packages/dart/lib/src/frb_generated.io.dart

// This file is automatically generated, so please do not edit it.
// @generated by `flutter_rust_bridge`@ 2.4.0.

// ignore_for_file: unused_import, unused_element, unnecessary_import, duplicate_ignore, invalid_use_of_internal_member, annotate_overrides, non_constant_identifier_names, curly_braces_in_flow_control_structures, prefer_const_literals_to_create_immutables, unused_field

import 'bindings.dart';
import 'bindings/duplicates.dart';
import 'dart:async';
import 'dart:convert';
import 'dart:ffi' as ffi;
import 'error.dart';
import 'frb_generated.dart';
import 'model.dart';
import 'package:flutter_rust_bridge/flutter_rust_bridge_for_generated_io.dart';

abstract class RustLibApiImplPlatform extends BaseApiImpl<RustLibWire> {
  RustLibApiImplPlatform({
    required super.handler,
    required super.wire,
    required super.generalizedFrbRustBinding,
    required super.portManager,
  });

  CrossPlatformFinalizerArg get rust_arc_decrement_strong_count_BindingLiquidSdkPtr => wire
      ._rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerBindingLiquidSdkPtr;

  @protected
  AnyhowException dco_decode_AnyhowException(dynamic raw);

  @protected
  BindingLiquidSdk
      dco_decode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerBindingLiquidSdk(
          dynamic raw);

  @protected
  BindingLiquidSdk
      dco_decode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerBindingLiquidSdk(
          dynamic raw);

  @protected
  BindingLiquidSdk dco_decode_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerBindingLiquidSdk(
      dynamic raw);

  @protected
  RustStreamSink<LogEntry> dco_decode_StreamSink_log_entry_Dco(dynamic raw);

  @protected
  RustStreamSink<SdkEvent> dco_decode_StreamSink_sdk_event_Dco(dynamic raw);

  @protected
  String dco_decode_String(dynamic raw);

  @protected
  AesSuccessActionDataDecrypted dco_decode_aes_success_action_data_decrypted(dynamic raw);

  @protected
  AesSuccessActionDataResult dco_decode_aes_success_action_data_result(dynamic raw);

  @protected
  BackupRequest dco_decode_backup_request(dynamic raw);

  @protected
  BindingEventListener dco_decode_binding_event_listener(dynamic raw);

  @protected
  BitcoinAddressData dco_decode_bitcoin_address_data(dynamic raw);

  @protected
  bool dco_decode_bool(dynamic raw);

  @protected
  AesSuccessActionDataDecrypted dco_decode_box_autoadd_aes_success_action_data_decrypted(dynamic raw);

  @protected
  AesSuccessActionDataResult dco_decode_box_autoadd_aes_success_action_data_result(dynamic raw);

  @protected
  BackupRequest dco_decode_box_autoadd_backup_request(dynamic raw);

  @protected
  BindingEventListener dco_decode_box_autoadd_binding_event_listener(dynamic raw);

  @protected
  BitcoinAddressData dco_decode_box_autoadd_bitcoin_address_data(dynamic raw);

  @protected
  bool dco_decode_box_autoadd_bool(dynamic raw);

  @protected
  BuyBitcoinRequest dco_decode_box_autoadd_buy_bitcoin_request(dynamic raw);

  @protected
  CheckMessageRequest dco_decode_box_autoadd_check_message_request(dynamic raw);

  @protected
  ConnectRequest dco_decode_box_autoadd_connect_request(dynamic raw);

  @protected
  PlatformInt64 dco_decode_box_autoadd_i_64(dynamic raw);

  @protected
  LiquidAddressData dco_decode_box_autoadd_liquid_address_data(dynamic raw);

  @protected
  ListPaymentsRequest dco_decode_box_autoadd_list_payments_request(dynamic raw);

  @protected
  LNInvoice dco_decode_box_autoadd_ln_invoice(dynamic raw);

  @protected
  LnUrlAuthRequestData dco_decode_box_autoadd_ln_url_auth_request_data(dynamic raw);

  @protected
  LnUrlErrorData dco_decode_box_autoadd_ln_url_error_data(dynamic raw);

  @protected
  LnUrlPayErrorData dco_decode_box_autoadd_ln_url_pay_error_data(dynamic raw);

  @protected
  LnUrlPayRequest dco_decode_box_autoadd_ln_url_pay_request(dynamic raw);

  @protected
  LnUrlPayRequestData dco_decode_box_autoadd_ln_url_pay_request_data(dynamic raw);

  @protected
  LnUrlPaySuccessData dco_decode_box_autoadd_ln_url_pay_success_data(dynamic raw);

  @protected
  LnUrlWithdrawRequest dco_decode_box_autoadd_ln_url_withdraw_request(dynamic raw);

  @protected
  LnUrlWithdrawRequestData dco_decode_box_autoadd_ln_url_withdraw_request_data(dynamic raw);

  @protected
  LnUrlWithdrawSuccessData dco_decode_box_autoadd_ln_url_withdraw_success_data(dynamic raw);

  @protected
  MessageSuccessActionData dco_decode_box_autoadd_message_success_action_data(dynamic raw);

  @protected
  PayOnchainRequest dco_decode_box_autoadd_pay_onchain_request(dynamic raw);

  @protected
  Payment dco_decode_box_autoadd_payment(dynamic raw);

  @protected
  PrepareBuyBitcoinRequest dco_decode_box_autoadd_prepare_buy_bitcoin_request(dynamic raw);

  @protected
  PreparePayOnchainRequest dco_decode_box_autoadd_prepare_pay_onchain_request(dynamic raw);

  @protected
  PrepareReceiveRequest dco_decode_box_autoadd_prepare_receive_request(dynamic raw);

  @protected
  PrepareRefundRequest dco_decode_box_autoadd_prepare_refund_request(dynamic raw);

  @protected
  PrepareSendRequest dco_decode_box_autoadd_prepare_send_request(dynamic raw);

  @protected
  ReceivePaymentRequest dco_decode_box_autoadd_receive_payment_request(dynamic raw);

  @protected
  RefundRequest dco_decode_box_autoadd_refund_request(dynamic raw);

  @protected
  RestoreRequest dco_decode_box_autoadd_restore_request(dynamic raw);

  @protected
  SdkEvent dco_decode_box_autoadd_sdk_event(dynamic raw);

  @protected
  SendPaymentRequest dco_decode_box_autoadd_send_payment_request(dynamic raw);

  @protected
  SignMessageRequest dco_decode_box_autoadd_sign_message_request(dynamic raw);

  @protected
  SuccessActionProcessed dco_decode_box_autoadd_success_action_processed(dynamic raw);

  @protected
  Symbol dco_decode_box_autoadd_symbol(dynamic raw);

  @protected
  int dco_decode_box_autoadd_u_32(dynamic raw);

  @protected
  BigInt dco_decode_box_autoadd_u_64(dynamic raw);

  @protected
  UrlSuccessActionData dco_decode_box_autoadd_url_success_action_data(dynamic raw);

  @protected
  BuyBitcoinProvider dco_decode_buy_bitcoin_provider(dynamic raw);

  @protected
  BuyBitcoinRequest dco_decode_buy_bitcoin_request(dynamic raw);

  @protected
  CheckMessageRequest dco_decode_check_message_request(dynamic raw);

  @protected
  CheckMessageResponse dco_decode_check_message_response(dynamic raw);

  @protected
  Config dco_decode_config(dynamic raw);

  @protected
  ConnectRequest dco_decode_connect_request(dynamic raw);

  @protected
  CurrencyInfo dco_decode_currency_info(dynamic raw);

  @protected
  double dco_decode_f_64(dynamic raw);

  @protected
  FiatCurrency dco_decode_fiat_currency(dynamic raw);

  @protected
  GetInfoResponse dco_decode_get_info_response(dynamic raw);

  @protected
  int dco_decode_i_32(dynamic raw);

  @protected
  PlatformInt64 dco_decode_i_64(dynamic raw);

  @protected
  InputType dco_decode_input_type(dynamic raw);

  @protected
  LightningPaymentLimitsResponse dco_decode_lightning_payment_limits_response(dynamic raw);

  @protected
  Limits dco_decode_limits(dynamic raw);

  @protected
  LiquidAddressData dco_decode_liquid_address_data(dynamic raw);

  @protected
  LiquidNetwork dco_decode_liquid_network(dynamic raw);

  @protected
  List<FiatCurrency> dco_decode_list_fiat_currency(dynamic raw);

  @protected
  List<LocaleOverrides> dco_decode_list_locale_overrides(dynamic raw);

  @protected
  List<LocalizedName> dco_decode_list_localized_name(dynamic raw);

  @protected
  List<Payment> dco_decode_list_payment(dynamic raw);

  @protected
  List<PaymentType> dco_decode_list_payment_type(dynamic raw);

  @protected
  ListPaymentsRequest dco_decode_list_payments_request(dynamic raw);

  @protected
  Uint8List dco_decode_list_prim_u_8_strict(dynamic raw);

  @protected
  List<Rate> dco_decode_list_rate(dynamic raw);

  @protected
  List<RefundableSwap> dco_decode_list_refundable_swap(dynamic raw);

  @protected
  List<RouteHint> dco_decode_list_route_hint(dynamic raw);

  @protected
  List<RouteHintHop> dco_decode_list_route_hint_hop(dynamic raw);

  @protected
  LNInvoice dco_decode_ln_invoice(dynamic raw);

  @protected
  LnUrlAuthError dco_decode_ln_url_auth_error(dynamic raw);

  @protected
  LnUrlAuthRequestData dco_decode_ln_url_auth_request_data(dynamic raw);

  @protected
  LnUrlCallbackStatus dco_decode_ln_url_callback_status(dynamic raw);

  @protected
  LnUrlErrorData dco_decode_ln_url_error_data(dynamic raw);

  @protected
  LnUrlPayError dco_decode_ln_url_pay_error(dynamic raw);

  @protected
  LnUrlPayErrorData dco_decode_ln_url_pay_error_data(dynamic raw);

  @protected
  LnUrlPayRequest dco_decode_ln_url_pay_request(dynamic raw);

  @protected
  LnUrlPayRequestData dco_decode_ln_url_pay_request_data(dynamic raw);

  @protected
  LnUrlPayResult dco_decode_ln_url_pay_result(dynamic raw);

  @protected
  LnUrlPaySuccessData dco_decode_ln_url_pay_success_data(dynamic raw);

  @protected
  LnUrlWithdrawError dco_decode_ln_url_withdraw_error(dynamic raw);

  @protected
  LnUrlWithdrawRequest dco_decode_ln_url_withdraw_request(dynamic raw);

  @protected
  LnUrlWithdrawRequestData dco_decode_ln_url_withdraw_request_data(dynamic raw);

  @protected
  LnUrlWithdrawResult dco_decode_ln_url_withdraw_result(dynamic raw);

  @protected
  LnUrlWithdrawSuccessData dco_decode_ln_url_withdraw_success_data(dynamic raw);

  @protected
  LocaleOverrides dco_decode_locale_overrides(dynamic raw);

  @protected
  LocalizedName dco_decode_localized_name(dynamic raw);

  @protected
  LogEntry dco_decode_log_entry(dynamic raw);

  @protected
  MessageSuccessActionData dco_decode_message_success_action_data(dynamic raw);

  @protected
  Network dco_decode_network(dynamic raw);

  @protected
  OnchainPaymentLimitsResponse dco_decode_onchain_payment_limits_response(dynamic raw);

  @protected
  String? dco_decode_opt_String(dynamic raw);

  @protected
  bool? dco_decode_opt_box_autoadd_bool(dynamic raw);

  @protected
  PlatformInt64? dco_decode_opt_box_autoadd_i_64(dynamic raw);

  @protected
  SuccessActionProcessed? dco_decode_opt_box_autoadd_success_action_processed(dynamic raw);

  @protected
  Symbol? dco_decode_opt_box_autoadd_symbol(dynamic raw);

  @protected
  int? dco_decode_opt_box_autoadd_u_32(dynamic raw);

  @protected
  BigInt? dco_decode_opt_box_autoadd_u_64(dynamic raw);

  @protected
  List<PaymentType>? dco_decode_opt_list_payment_type(dynamic raw);

  @protected
  PayOnchainAmount dco_decode_pay_onchain_amount(dynamic raw);

  @protected
  PayOnchainRequest dco_decode_pay_onchain_request(dynamic raw);

  @protected
  Payment dco_decode_payment(dynamic raw);

  @protected
  PaymentDetails dco_decode_payment_details(dynamic raw);

  @protected
  PaymentError dco_decode_payment_error(dynamic raw);

  @protected
  PaymentMethod dco_decode_payment_method(dynamic raw);

  @protected
  PaymentState dco_decode_payment_state(dynamic raw);

  @protected
  PaymentType dco_decode_payment_type(dynamic raw);

  @protected
  PrepareBuyBitcoinRequest dco_decode_prepare_buy_bitcoin_request(dynamic raw);

  @protected
  PrepareBuyBitcoinResponse dco_decode_prepare_buy_bitcoin_response(dynamic raw);

  @protected
  PreparePayOnchainRequest dco_decode_prepare_pay_onchain_request(dynamic raw);

  @protected
  PreparePayOnchainResponse dco_decode_prepare_pay_onchain_response(dynamic raw);

  @protected
  PrepareReceiveRequest dco_decode_prepare_receive_request(dynamic raw);

  @protected
  PrepareReceiveResponse dco_decode_prepare_receive_response(dynamic raw);

  @protected
  PrepareRefundRequest dco_decode_prepare_refund_request(dynamic raw);

  @protected
  PrepareRefundResponse dco_decode_prepare_refund_response(dynamic raw);

  @protected
  PrepareSendRequest dco_decode_prepare_send_request(dynamic raw);

  @protected
  PrepareSendResponse dco_decode_prepare_send_response(dynamic raw);

  @protected
  Rate dco_decode_rate(dynamic raw);

  @protected
  ReceivePaymentRequest dco_decode_receive_payment_request(dynamic raw);

  @protected
  ReceivePaymentResponse dco_decode_receive_payment_response(dynamic raw);

  @protected
  RecommendedFees dco_decode_recommended_fees(dynamic raw);

  @protected
  RefundRequest dco_decode_refund_request(dynamic raw);

  @protected
  RefundResponse dco_decode_refund_response(dynamic raw);

  @protected
  RefundableSwap dco_decode_refundable_swap(dynamic raw);

  @protected
  RestoreRequest dco_decode_restore_request(dynamic raw);

  @protected
  RouteHint dco_decode_route_hint(dynamic raw);

  @protected
  RouteHintHop dco_decode_route_hint_hop(dynamic raw);

  @protected
  SdkError dco_decode_sdk_error(dynamic raw);

  @protected
  SdkEvent dco_decode_sdk_event(dynamic raw);

  @protected
  SendDestination dco_decode_send_destination(dynamic raw);

  @protected
  SendPaymentRequest dco_decode_send_payment_request(dynamic raw);

  @protected
  SendPaymentResponse dco_decode_send_payment_response(dynamic raw);

  @protected
  SignMessageRequest dco_decode_sign_message_request(dynamic raw);

  @protected
  SignMessageResponse dco_decode_sign_message_response(dynamic raw);

  @protected
  SuccessActionProcessed dco_decode_success_action_processed(dynamic raw);

  @protected
  Symbol dco_decode_symbol(dynamic raw);

  @protected
  int dco_decode_u_16(dynamic raw);

  @protected
  int dco_decode_u_32(dynamic raw);

  @protected
  BigInt dco_decode_u_64(dynamic raw);

  @protected
  int dco_decode_u_8(dynamic raw);

  @protected
  void dco_decode_unit(dynamic raw);

  @protected
  UrlSuccessActionData dco_decode_url_success_action_data(dynamic raw);

  @protected
  BigInt dco_decode_usize(dynamic raw);

  @protected
  AnyhowException sse_decode_AnyhowException(SseDeserializer deserializer);

  @protected
  BindingLiquidSdk
      sse_decode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerBindingLiquidSdk(
          SseDeserializer deserializer);

  @protected
  BindingLiquidSdk
      sse_decode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerBindingLiquidSdk(
          SseDeserializer deserializer);

  @protected
  BindingLiquidSdk sse_decode_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerBindingLiquidSdk(
      SseDeserializer deserializer);

  @protected
  RustStreamSink<LogEntry> sse_decode_StreamSink_log_entry_Dco(SseDeserializer deserializer);

  @protected
  RustStreamSink<SdkEvent> sse_decode_StreamSink_sdk_event_Dco(SseDeserializer deserializer);

  @protected
  String sse_decode_String(SseDeserializer deserializer);

  @protected
  AesSuccessActionDataDecrypted sse_decode_aes_success_action_data_decrypted(SseDeserializer deserializer);

  @protected
  AesSuccessActionDataResult sse_decode_aes_success_action_data_result(SseDeserializer deserializer);

  @protected
  BackupRequest sse_decode_backup_request(SseDeserializer deserializer);

  @protected
  BindingEventListener sse_decode_binding_event_listener(SseDeserializer deserializer);

  @protected
  BitcoinAddressData sse_decode_bitcoin_address_data(SseDeserializer deserializer);

  @protected
  bool sse_decode_bool(SseDeserializer deserializer);

  @protected
  AesSuccessActionDataDecrypted sse_decode_box_autoadd_aes_success_action_data_decrypted(
      SseDeserializer deserializer);

  @protected
  AesSuccessActionDataResult sse_decode_box_autoadd_aes_success_action_data_result(
      SseDeserializer deserializer);

  @protected
  BackupRequest sse_decode_box_autoadd_backup_request(SseDeserializer deserializer);

  @protected
  BindingEventListener sse_decode_box_autoadd_binding_event_listener(SseDeserializer deserializer);

  @protected
  BitcoinAddressData sse_decode_box_autoadd_bitcoin_address_data(SseDeserializer deserializer);

  @protected
  bool sse_decode_box_autoadd_bool(SseDeserializer deserializer);

  @protected
  BuyBitcoinRequest sse_decode_box_autoadd_buy_bitcoin_request(SseDeserializer deserializer);

  @protected
  CheckMessageRequest sse_decode_box_autoadd_check_message_request(SseDeserializer deserializer);

  @protected
  ConnectRequest sse_decode_box_autoadd_connect_request(SseDeserializer deserializer);

  @protected
  PlatformInt64 sse_decode_box_autoadd_i_64(SseDeserializer deserializer);

  @protected
  LiquidAddressData sse_decode_box_autoadd_liquid_address_data(SseDeserializer deserializer);

  @protected
  ListPaymentsRequest sse_decode_box_autoadd_list_payments_request(SseDeserializer deserializer);

  @protected
  LNInvoice sse_decode_box_autoadd_ln_invoice(SseDeserializer deserializer);

  @protected
  LnUrlAuthRequestData sse_decode_box_autoadd_ln_url_auth_request_data(SseDeserializer deserializer);

  @protected
  LnUrlErrorData sse_decode_box_autoadd_ln_url_error_data(SseDeserializer deserializer);

  @protected
  LnUrlPayErrorData sse_decode_box_autoadd_ln_url_pay_error_data(SseDeserializer deserializer);

  @protected
  LnUrlPayRequest sse_decode_box_autoadd_ln_url_pay_request(SseDeserializer deserializer);

  @protected
  LnUrlPayRequestData sse_decode_box_autoadd_ln_url_pay_request_data(SseDeserializer deserializer);

  @protected
  LnUrlPaySuccessData sse_decode_box_autoadd_ln_url_pay_success_data(SseDeserializer deserializer);

  @protected
  LnUrlWithdrawRequest sse_decode_box_autoadd_ln_url_withdraw_request(SseDeserializer deserializer);

  @protected
  LnUrlWithdrawRequestData sse_decode_box_autoadd_ln_url_withdraw_request_data(SseDeserializer deserializer);

  @protected
  LnUrlWithdrawSuccessData sse_decode_box_autoadd_ln_url_withdraw_success_data(SseDeserializer deserializer);

  @protected
  MessageSuccessActionData sse_decode_box_autoadd_message_success_action_data(SseDeserializer deserializer);

  @protected
  PayOnchainRequest sse_decode_box_autoadd_pay_onchain_request(SseDeserializer deserializer);

  @protected
  Payment sse_decode_box_autoadd_payment(SseDeserializer deserializer);

  @protected
  PrepareBuyBitcoinRequest sse_decode_box_autoadd_prepare_buy_bitcoin_request(SseDeserializer deserializer);

  @protected
  PreparePayOnchainRequest sse_decode_box_autoadd_prepare_pay_onchain_request(SseDeserializer deserializer);

  @protected
  PrepareReceiveRequest sse_decode_box_autoadd_prepare_receive_request(SseDeserializer deserializer);

  @protected
  PrepareRefundRequest sse_decode_box_autoadd_prepare_refund_request(SseDeserializer deserializer);

  @protected
  PrepareSendRequest sse_decode_box_autoadd_prepare_send_request(SseDeserializer deserializer);

  @protected
  ReceivePaymentRequest sse_decode_box_autoadd_receive_payment_request(SseDeserializer deserializer);

  @protected
  RefundRequest sse_decode_box_autoadd_refund_request(SseDeserializer deserializer);

  @protected
  RestoreRequest sse_decode_box_autoadd_restore_request(SseDeserializer deserializer);

  @protected
  SdkEvent sse_decode_box_autoadd_sdk_event(SseDeserializer deserializer);

  @protected
  SendPaymentRequest sse_decode_box_autoadd_send_payment_request(SseDeserializer deserializer);

  @protected
  SignMessageRequest sse_decode_box_autoadd_sign_message_request(SseDeserializer deserializer);

  @protected
  SuccessActionProcessed sse_decode_box_autoadd_success_action_processed(SseDeserializer deserializer);

  @protected
  Symbol sse_decode_box_autoadd_symbol(SseDeserializer deserializer);

  @protected
  int sse_decode_box_autoadd_u_32(SseDeserializer deserializer);

  @protected
  BigInt sse_decode_box_autoadd_u_64(SseDeserializer deserializer);

  @protected
  UrlSuccessActionData sse_decode_box_autoadd_url_success_action_data(SseDeserializer deserializer);

  @protected
  BuyBitcoinProvider sse_decode_buy_bitcoin_provider(SseDeserializer deserializer);

  @protected
  BuyBitcoinRequest sse_decode_buy_bitcoin_request(SseDeserializer deserializer);

  @protected
  CheckMessageRequest sse_decode_check_message_request(SseDeserializer deserializer);

  @protected
  CheckMessageResponse sse_decode_check_message_response(SseDeserializer deserializer);

  @protected
  Config sse_decode_config(SseDeserializer deserializer);

  @protected
  ConnectRequest sse_decode_connect_request(SseDeserializer deserializer);

  @protected
  CurrencyInfo sse_decode_currency_info(SseDeserializer deserializer);

  @protected
  double sse_decode_f_64(SseDeserializer deserializer);

  @protected
  FiatCurrency sse_decode_fiat_currency(SseDeserializer deserializer);

  @protected
  GetInfoResponse sse_decode_get_info_response(SseDeserializer deserializer);

  @protected
  int sse_decode_i_32(SseDeserializer deserializer);

  @protected
  PlatformInt64 sse_decode_i_64(SseDeserializer deserializer);

  @protected
  InputType sse_decode_input_type(SseDeserializer deserializer);

  @protected
  LightningPaymentLimitsResponse sse_decode_lightning_payment_limits_response(SseDeserializer deserializer);

  @protected
  Limits sse_decode_limits(SseDeserializer deserializer);

  @protected
  LiquidAddressData sse_decode_liquid_address_data(SseDeserializer deserializer);

  @protected
  LiquidNetwork sse_decode_liquid_network(SseDeserializer deserializer);

  @protected
  List<FiatCurrency> sse_decode_list_fiat_currency(SseDeserializer deserializer);

  @protected
  List<LocaleOverrides> sse_decode_list_locale_overrides(SseDeserializer deserializer);

  @protected
  List<LocalizedName> sse_decode_list_localized_name(SseDeserializer deserializer);

  @protected
  List<Payment> sse_decode_list_payment(SseDeserializer deserializer);

  @protected
  List<PaymentType> sse_decode_list_payment_type(SseDeserializer deserializer);

  @protected
  ListPaymentsRequest sse_decode_list_payments_request(SseDeserializer deserializer);

  @protected
  Uint8List sse_decode_list_prim_u_8_strict(SseDeserializer deserializer);

  @protected
  List<Rate> sse_decode_list_rate(SseDeserializer deserializer);

  @protected
  List<RefundableSwap> sse_decode_list_refundable_swap(SseDeserializer deserializer);

  @protected
  List<RouteHint> sse_decode_list_route_hint(SseDeserializer deserializer);

  @protected
  List<RouteHintHop> sse_decode_list_route_hint_hop(SseDeserializer deserializer);

  @protected
  LNInvoice sse_decode_ln_invoice(SseDeserializer deserializer);

  @protected
  LnUrlAuthError sse_decode_ln_url_auth_error(SseDeserializer deserializer);

  @protected
  LnUrlAuthRequestData sse_decode_ln_url_auth_request_data(SseDeserializer deserializer);

  @protected
  LnUrlCallbackStatus sse_decode_ln_url_callback_status(SseDeserializer deserializer);

  @protected
  LnUrlErrorData sse_decode_ln_url_error_data(SseDeserializer deserializer);

  @protected
  LnUrlPayError sse_decode_ln_url_pay_error(SseDeserializer deserializer);

  @protected
  LnUrlPayErrorData sse_decode_ln_url_pay_error_data(SseDeserializer deserializer);

  @protected
  LnUrlPayRequest sse_decode_ln_url_pay_request(SseDeserializer deserializer);

  @protected
  LnUrlPayRequestData sse_decode_ln_url_pay_request_data(SseDeserializer deserializer);

  @protected
  LnUrlPayResult sse_decode_ln_url_pay_result(SseDeserializer deserializer);

  @protected
  LnUrlPaySuccessData sse_decode_ln_url_pay_success_data(SseDeserializer deserializer);

  @protected
  LnUrlWithdrawError sse_decode_ln_url_withdraw_error(SseDeserializer deserializer);

  @protected
  LnUrlWithdrawRequest sse_decode_ln_url_withdraw_request(SseDeserializer deserializer);

  @protected
  LnUrlWithdrawRequestData sse_decode_ln_url_withdraw_request_data(SseDeserializer deserializer);

  @protected
  LnUrlWithdrawResult sse_decode_ln_url_withdraw_result(SseDeserializer deserializer);

  @protected
  LnUrlWithdrawSuccessData sse_decode_ln_url_withdraw_success_data(SseDeserializer deserializer);

  @protected
  LocaleOverrides sse_decode_locale_overrides(SseDeserializer deserializer);

  @protected
  LocalizedName sse_decode_localized_name(SseDeserializer deserializer);

  @protected
  LogEntry sse_decode_log_entry(SseDeserializer deserializer);

  @protected
  MessageSuccessActionData sse_decode_message_success_action_data(SseDeserializer deserializer);

  @protected
  Network sse_decode_network(SseDeserializer deserializer);

  @protected
  OnchainPaymentLimitsResponse sse_decode_onchain_payment_limits_response(SseDeserializer deserializer);

  @protected
  String? sse_decode_opt_String(SseDeserializer deserializer);

  @protected
  bool? sse_decode_opt_box_autoadd_bool(SseDeserializer deserializer);

  @protected
  PlatformInt64? sse_decode_opt_box_autoadd_i_64(SseDeserializer deserializer);

  @protected
  SuccessActionProcessed? sse_decode_opt_box_autoadd_success_action_processed(SseDeserializer deserializer);

  @protected
  Symbol? sse_decode_opt_box_autoadd_symbol(SseDeserializer deserializer);

  @protected
  int? sse_decode_opt_box_autoadd_u_32(SseDeserializer deserializer);

  @protected
  BigInt? sse_decode_opt_box_autoadd_u_64(SseDeserializer deserializer);

  @protected
  List<PaymentType>? sse_decode_opt_list_payment_type(SseDeserializer deserializer);

  @protected
  PayOnchainAmount sse_decode_pay_onchain_amount(SseDeserializer deserializer);

  @protected
  PayOnchainRequest sse_decode_pay_onchain_request(SseDeserializer deserializer);

  @protected
  Payment sse_decode_payment(SseDeserializer deserializer);

  @protected
  PaymentDetails sse_decode_payment_details(SseDeserializer deserializer);

  @protected
  PaymentError sse_decode_payment_error(SseDeserializer deserializer);

  @protected
  PaymentMethod sse_decode_payment_method(SseDeserializer deserializer);

  @protected
  PaymentState sse_decode_payment_state(SseDeserializer deserializer);

  @protected
  PaymentType sse_decode_payment_type(SseDeserializer deserializer);

  @protected
  PrepareBuyBitcoinRequest sse_decode_prepare_buy_bitcoin_request(SseDeserializer deserializer);

  @protected
  PrepareBuyBitcoinResponse sse_decode_prepare_buy_bitcoin_response(SseDeserializer deserializer);

  @protected
  PreparePayOnchainRequest sse_decode_prepare_pay_onchain_request(SseDeserializer deserializer);

  @protected
  PreparePayOnchainResponse sse_decode_prepare_pay_onchain_response(SseDeserializer deserializer);

  @protected
  PrepareReceiveRequest sse_decode_prepare_receive_request(SseDeserializer deserializer);

  @protected
  PrepareReceiveResponse sse_decode_prepare_receive_response(SseDeserializer deserializer);

  @protected
  PrepareRefundRequest sse_decode_prepare_refund_request(SseDeserializer deserializer);

  @protected
  PrepareRefundResponse sse_decode_prepare_refund_response(SseDeserializer deserializer);

  @protected
  PrepareSendRequest sse_decode_prepare_send_request(SseDeserializer deserializer);

  @protected
  PrepareSendResponse sse_decode_prepare_send_response(SseDeserializer deserializer);

  @protected
  Rate sse_decode_rate(SseDeserializer deserializer);

  @protected
  ReceivePaymentRequest sse_decode_receive_payment_request(SseDeserializer deserializer);

  @protected
  ReceivePaymentResponse sse_decode_receive_payment_response(SseDeserializer deserializer);

  @protected
  RecommendedFees sse_decode_recommended_fees(SseDeserializer deserializer);

  @protected
  RefundRequest sse_decode_refund_request(SseDeserializer deserializer);

  @protected
  RefundResponse sse_decode_refund_response(SseDeserializer deserializer);

  @protected
  RefundableSwap sse_decode_refundable_swap(SseDeserializer deserializer);

  @protected
  RestoreRequest sse_decode_restore_request(SseDeserializer deserializer);

  @protected
  RouteHint sse_decode_route_hint(SseDeserializer deserializer);

  @protected
  RouteHintHop sse_decode_route_hint_hop(SseDeserializer deserializer);

  @protected
  SdkError sse_decode_sdk_error(SseDeserializer deserializer);

  @protected
  SdkEvent sse_decode_sdk_event(SseDeserializer deserializer);

  @protected
  SendDestination sse_decode_send_destination(SseDeserializer deserializer);

  @protected
  SendPaymentRequest sse_decode_send_payment_request(SseDeserializer deserializer);

  @protected
  SendPaymentResponse sse_decode_send_payment_response(SseDeserializer deserializer);

  @protected
  SignMessageRequest sse_decode_sign_message_request(SseDeserializer deserializer);

  @protected
  SignMessageResponse sse_decode_sign_message_response(SseDeserializer deserializer);

  @protected
  SuccessActionProcessed sse_decode_success_action_processed(SseDeserializer deserializer);

  @protected
  Symbol sse_decode_symbol(SseDeserializer deserializer);

  @protected
  int sse_decode_u_16(SseDeserializer deserializer);

  @protected
  int sse_decode_u_32(SseDeserializer deserializer);

  @protected
  BigInt sse_decode_u_64(SseDeserializer deserializer);

  @protected
  int sse_decode_u_8(SseDeserializer deserializer);

  @protected
  void sse_decode_unit(SseDeserializer deserializer);

  @protected
  UrlSuccessActionData sse_decode_url_success_action_data(SseDeserializer deserializer);

  @protected
  BigInt sse_decode_usize(SseDeserializer deserializer);

  @protected
  ffi.Pointer<wire_cst_list_prim_u_8_strict> cst_encode_AnyhowException(AnyhowException raw) {
    // Codec=Cst (C-struct based), see doc to use other codecs
    throw UnimplementedError();
  }

  @protected
  ffi.Pointer<wire_cst_list_prim_u_8_strict> cst_encode_StreamSink_log_entry_Dco(
      RustStreamSink<LogEntry> raw) {
    // Codec=Cst (C-struct based), see doc to use other codecs
    return cst_encode_String(raw.setupAndSerialize(
        codec: DcoCodec(
      decodeSuccessData: dco_decode_log_entry,
      decodeErrorData: dco_decode_AnyhowException,
    )));
  }

  @protected
  ffi.Pointer<wire_cst_list_prim_u_8_strict> cst_encode_StreamSink_sdk_event_Dco(
      RustStreamSink<SdkEvent> raw) {
    // Codec=Cst (C-struct based), see doc to use other codecs
    return cst_encode_String(raw.setupAndSerialize(
        codec: DcoCodec(
      decodeSuccessData: dco_decode_sdk_event,
      decodeErrorData: dco_decode_AnyhowException,
    )));
  }

  @protected
  ffi.Pointer<wire_cst_list_prim_u_8_strict> cst_encode_String(String raw) {
    // Codec=Cst (C-struct based), see doc to use other codecs
    return cst_encode_list_prim_u_8_strict(utf8.encoder.convert(raw));
  }

  @protected
  ffi.Pointer<wire_cst_aes_success_action_data_decrypted>
      cst_encode_box_autoadd_aes_success_action_data_decrypted(AesSuccessActionDataDecrypted raw) {
    // Codec=Cst (C-struct based), see doc to use other codecs
    final ptr = wire.cst_new_box_autoadd_aes_success_action_data_decrypted();
    cst_api_fill_to_wire_aes_success_action_data_decrypted(raw, ptr.ref);
    return ptr;
  }

  @protected
  ffi.Pointer<wire_cst_aes_success_action_data_result> cst_encode_box_autoadd_aes_success_action_data_result(
      AesSuccessActionDataResult raw) {
    // Codec=Cst (C-struct based), see doc to use other codecs
    final ptr = wire.cst_new_box_autoadd_aes_success_action_data_result();
    cst_api_fill_to_wire_aes_success_action_data_result(raw, ptr.ref);
    return ptr;
  }

  @protected
  ffi.Pointer<wire_cst_backup_request> cst_encode_box_autoadd_backup_request(BackupRequest raw) {
    // Codec=Cst (C-struct based), see doc to use other codecs
    final ptr = wire.cst_new_box_autoadd_backup_request();
    cst_api_fill_to_wire_backup_request(raw, ptr.ref);
    return ptr;
  }

  @protected
  ffi.Pointer<wire_cst_binding_event_listener> cst_encode_box_autoadd_binding_event_listener(
      BindingEventListener raw) {
    // Codec=Cst (C-struct based), see doc to use other codecs
    final ptr = wire.cst_new_box_autoadd_binding_event_listener();
    cst_api_fill_to_wire_binding_event_listener(raw, ptr.ref);
    return ptr;
  }

  @protected
  ffi.Pointer<wire_cst_bitcoin_address_data> cst_encode_box_autoadd_bitcoin_address_data(
      BitcoinAddressData raw) {
    // Codec=Cst (C-struct based), see doc to use other codecs
    final ptr = wire.cst_new_box_autoadd_bitcoin_address_data();
    cst_api_fill_to_wire_bitcoin_address_data(raw, ptr.ref);
    return ptr;
  }

  @protected
  ffi.Pointer<ffi.Bool> cst_encode_box_autoadd_bool(bool raw) {
    // Codec=Cst (C-struct based), see doc to use other codecs
    return wire.cst_new_box_autoadd_bool(cst_encode_bool(raw));
  }

  @protected
  ffi.Pointer<wire_cst_buy_bitcoin_request> cst_encode_box_autoadd_buy_bitcoin_request(
      BuyBitcoinRequest raw) {
    // Codec=Cst (C-struct based), see doc to use other codecs
    final ptr = wire.cst_new_box_autoadd_buy_bitcoin_request();
    cst_api_fill_to_wire_buy_bitcoin_request(raw, ptr.ref);
    return ptr;
  }

  @protected
  ffi.Pointer<wire_cst_check_message_request> cst_encode_box_autoadd_check_message_request(
      CheckMessageRequest raw) {
    // Codec=Cst (C-struct based), see doc to use other codecs
    final ptr = wire.cst_new_box_autoadd_check_message_request();
    cst_api_fill_to_wire_check_message_request(raw, ptr.ref);
    return ptr;
  }

  @protected
  ffi.Pointer<wire_cst_connect_request> cst_encode_box_autoadd_connect_request(ConnectRequest raw) {
    // Codec=Cst (C-struct based), see doc to use other codecs
    final ptr = wire.cst_new_box_autoadd_connect_request();
    cst_api_fill_to_wire_connect_request(raw, ptr.ref);
    return ptr;
  }

  @protected
  ffi.Pointer<ffi.Int64> cst_encode_box_autoadd_i_64(PlatformInt64 raw) {
    // Codec=Cst (C-struct based), see doc to use other codecs
    return wire.cst_new_box_autoadd_i_64(cst_encode_i_64(raw));
  }

  @protected
  ffi.Pointer<wire_cst_liquid_address_data> cst_encode_box_autoadd_liquid_address_data(
      LiquidAddressData raw) {
    // Codec=Cst (C-struct based), see doc to use other codecs
    final ptr = wire.cst_new_box_autoadd_liquid_address_data();
    cst_api_fill_to_wire_liquid_address_data(raw, ptr.ref);
    return ptr;
  }

  @protected
  ffi.Pointer<wire_cst_list_payments_request> cst_encode_box_autoadd_list_payments_request(
      ListPaymentsRequest raw) {
    // Codec=Cst (C-struct based), see doc to use other codecs
    final ptr = wire.cst_new_box_autoadd_list_payments_request();
    cst_api_fill_to_wire_list_payments_request(raw, ptr.ref);
    return ptr;
  }

  @protected
  ffi.Pointer<wire_cst_ln_invoice> cst_encode_box_autoadd_ln_invoice(LNInvoice raw) {
    // Codec=Cst (C-struct based), see doc to use other codecs
    final ptr = wire.cst_new_box_autoadd_ln_invoice();
    cst_api_fill_to_wire_ln_invoice(raw, ptr.ref);
    return ptr;
  }

  @protected
  ffi.Pointer<wire_cst_ln_url_auth_request_data> cst_encode_box_autoadd_ln_url_auth_request_data(
      LnUrlAuthRequestData raw) {
    // Codec=Cst (C-struct based), see doc to use other codecs
    final ptr = wire.cst_new_box_autoadd_ln_url_auth_request_data();
    cst_api_fill_to_wire_ln_url_auth_request_data(raw, ptr.ref);
    return ptr;
  }

  @protected
  ffi.Pointer<wire_cst_ln_url_error_data> cst_encode_box_autoadd_ln_url_error_data(LnUrlErrorData raw) {
    // Codec=Cst (C-struct based), see doc to use other codecs
    final ptr = wire.cst_new_box_autoadd_ln_url_error_data();
    cst_api_fill_to_wire_ln_url_error_data(raw, ptr.ref);
    return ptr;
  }

  @protected
  ffi.Pointer<wire_cst_ln_url_pay_error_data> cst_encode_box_autoadd_ln_url_pay_error_data(
      LnUrlPayErrorData raw) {
    // Codec=Cst (C-struct based), see doc to use other codecs
    final ptr = wire.cst_new_box_autoadd_ln_url_pay_error_data();
    cst_api_fill_to_wire_ln_url_pay_error_data(raw, ptr.ref);
    return ptr;
  }

  @protected
  ffi.Pointer<wire_cst_ln_url_pay_request> cst_encode_box_autoadd_ln_url_pay_request(LnUrlPayRequest raw) {
    // Codec=Cst (C-struct based), see doc to use other codecs
    final ptr = wire.cst_new_box_autoadd_ln_url_pay_request();
    cst_api_fill_to_wire_ln_url_pay_request(raw, ptr.ref);
    return ptr;
  }

  @protected
  ffi.Pointer<wire_cst_ln_url_pay_request_data> cst_encode_box_autoadd_ln_url_pay_request_data(
      LnUrlPayRequestData raw) {
    // Codec=Cst (C-struct based), see doc to use other codecs
    final ptr = wire.cst_new_box_autoadd_ln_url_pay_request_data();
    cst_api_fill_to_wire_ln_url_pay_request_data(raw, ptr.ref);
    return ptr;
  }

  @protected
  ffi.Pointer<wire_cst_ln_url_pay_success_data> cst_encode_box_autoadd_ln_url_pay_success_data(
      LnUrlPaySuccessData raw) {
    // Codec=Cst (C-struct based), see doc to use other codecs
    final ptr = wire.cst_new_box_autoadd_ln_url_pay_success_data();
    cst_api_fill_to_wire_ln_url_pay_success_data(raw, ptr.ref);
    return ptr;
  }

  @protected
  ffi.Pointer<wire_cst_ln_url_withdraw_request> cst_encode_box_autoadd_ln_url_withdraw_request(
      LnUrlWithdrawRequest raw) {
    // Codec=Cst (C-struct based), see doc to use other codecs
    final ptr = wire.cst_new_box_autoadd_ln_url_withdraw_request();
    cst_api_fill_to_wire_ln_url_withdraw_request(raw, ptr.ref);
    return ptr;
  }

  @protected
  ffi.Pointer<wire_cst_ln_url_withdraw_request_data> cst_encode_box_autoadd_ln_url_withdraw_request_data(
      LnUrlWithdrawRequestData raw) {
    // Codec=Cst (C-struct based), see doc to use other codecs
    final ptr = wire.cst_new_box_autoadd_ln_url_withdraw_request_data();
    cst_api_fill_to_wire_ln_url_withdraw_request_data(raw, ptr.ref);
    return ptr;
  }

  @protected
  ffi.Pointer<wire_cst_ln_url_withdraw_success_data> cst_encode_box_autoadd_ln_url_withdraw_success_data(
      LnUrlWithdrawSuccessData raw) {
    // Codec=Cst (C-struct based), see doc to use other codecs
    final ptr = wire.cst_new_box_autoadd_ln_url_withdraw_success_data();
    cst_api_fill_to_wire_ln_url_withdraw_success_data(raw, ptr.ref);
    return ptr;
  }

  @protected
  ffi.Pointer<wire_cst_message_success_action_data> cst_encode_box_autoadd_message_success_action_data(
      MessageSuccessActionData raw) {
    // Codec=Cst (C-struct based), see doc to use other codecs
    final ptr = wire.cst_new_box_autoadd_message_success_action_data();
    cst_api_fill_to_wire_message_success_action_data(raw, ptr.ref);
    return ptr;
  }

  @protected
  ffi.Pointer<wire_cst_pay_onchain_request> cst_encode_box_autoadd_pay_onchain_request(
      PayOnchainRequest raw) {
    // Codec=Cst (C-struct based), see doc to use other codecs
    final ptr = wire.cst_new_box_autoadd_pay_onchain_request();
    cst_api_fill_to_wire_pay_onchain_request(raw, ptr.ref);
    return ptr;
  }

  @protected
  ffi.Pointer<wire_cst_payment> cst_encode_box_autoadd_payment(Payment raw) {
    // Codec=Cst (C-struct based), see doc to use other codecs
    final ptr = wire.cst_new_box_autoadd_payment();
    cst_api_fill_to_wire_payment(raw, ptr.ref);
    return ptr;
  }

  @protected
  ffi.Pointer<wire_cst_prepare_buy_bitcoin_request> cst_encode_box_autoadd_prepare_buy_bitcoin_request(
      PrepareBuyBitcoinRequest raw) {
    // Codec=Cst (C-struct based), see doc to use other codecs
    final ptr = wire.cst_new_box_autoadd_prepare_buy_bitcoin_request();
    cst_api_fill_to_wire_prepare_buy_bitcoin_request(raw, ptr.ref);
    return ptr;
  }

  @protected
  ffi.Pointer<wire_cst_prepare_pay_onchain_request> cst_encode_box_autoadd_prepare_pay_onchain_request(
      PreparePayOnchainRequest raw) {
    // Codec=Cst (C-struct based), see doc to use other codecs
    final ptr = wire.cst_new_box_autoadd_prepare_pay_onchain_request();
    cst_api_fill_to_wire_prepare_pay_onchain_request(raw, ptr.ref);
    return ptr;
  }

  @protected
  ffi.Pointer<wire_cst_prepare_receive_request> cst_encode_box_autoadd_prepare_receive_request(
      PrepareReceiveRequest raw) {
    // Codec=Cst (C-struct based), see doc to use other codecs
    final ptr = wire.cst_new_box_autoadd_prepare_receive_request();
    cst_api_fill_to_wire_prepare_receive_request(raw, ptr.ref);
    return ptr;
  }

  @protected
  ffi.Pointer<wire_cst_prepare_refund_request> cst_encode_box_autoadd_prepare_refund_request(
      PrepareRefundRequest raw) {
    // Codec=Cst (C-struct based), see doc to use other codecs
    final ptr = wire.cst_new_box_autoadd_prepare_refund_request();
    cst_api_fill_to_wire_prepare_refund_request(raw, ptr.ref);
    return ptr;
  }

  @protected
  ffi.Pointer<wire_cst_prepare_send_request> cst_encode_box_autoadd_prepare_send_request(
      PrepareSendRequest raw) {
    // Codec=Cst (C-struct based), see doc to use other codecs
    final ptr = wire.cst_new_box_autoadd_prepare_send_request();
    cst_api_fill_to_wire_prepare_send_request(raw, ptr.ref);
    return ptr;
  }

  @protected
  ffi.Pointer<wire_cst_receive_payment_request> cst_encode_box_autoadd_receive_payment_request(
      ReceivePaymentRequest raw) {
    // Codec=Cst (C-struct based), see doc to use other codecs
    final ptr = wire.cst_new_box_autoadd_receive_payment_request();
    cst_api_fill_to_wire_receive_payment_request(raw, ptr.ref);
    return ptr;
  }

  @protected
  ffi.Pointer<wire_cst_refund_request> cst_encode_box_autoadd_refund_request(RefundRequest raw) {
    // Codec=Cst (C-struct based), see doc to use other codecs
    final ptr = wire.cst_new_box_autoadd_refund_request();
    cst_api_fill_to_wire_refund_request(raw, ptr.ref);
    return ptr;
  }

  @protected
  ffi.Pointer<wire_cst_restore_request> cst_encode_box_autoadd_restore_request(RestoreRequest raw) {
    // Codec=Cst (C-struct based), see doc to use other codecs
    final ptr = wire.cst_new_box_autoadd_restore_request();
    cst_api_fill_to_wire_restore_request(raw, ptr.ref);
    return ptr;
  }

  @protected
  ffi.Pointer<wire_cst_sdk_event> cst_encode_box_autoadd_sdk_event(SdkEvent raw) {
    // Codec=Cst (C-struct based), see doc to use other codecs
    final ptr = wire.cst_new_box_autoadd_sdk_event();
    cst_api_fill_to_wire_sdk_event(raw, ptr.ref);
    return ptr;
  }

  @protected
  ffi.Pointer<wire_cst_send_payment_request> cst_encode_box_autoadd_send_payment_request(
      SendPaymentRequest raw) {
    // Codec=Cst (C-struct based), see doc to use other codecs
    final ptr = wire.cst_new_box_autoadd_send_payment_request();
    cst_api_fill_to_wire_send_payment_request(raw, ptr.ref);
    return ptr;
  }

  @protected
  ffi.Pointer<wire_cst_sign_message_request> cst_encode_box_autoadd_sign_message_request(
      SignMessageRequest raw) {
    // Codec=Cst (C-struct based), see doc to use other codecs
    final ptr = wire.cst_new_box_autoadd_sign_message_request();
    cst_api_fill_to_wire_sign_message_request(raw, ptr.ref);
    return ptr;
  }

  @protected
  ffi.Pointer<wire_cst_success_action_processed> cst_encode_box_autoadd_success_action_processed(
      SuccessActionProcessed raw) {
    // Codec=Cst (C-struct based), see doc to use other codecs
    final ptr = wire.cst_new_box_autoadd_success_action_processed();
    cst_api_fill_to_wire_success_action_processed(raw, ptr.ref);
    return ptr;
  }

  @protected
  ffi.Pointer<wire_cst_symbol> cst_encode_box_autoadd_symbol(Symbol raw) {
    // Codec=Cst (C-struct based), see doc to use other codecs
    final ptr = wire.cst_new_box_autoadd_symbol();
    cst_api_fill_to_wire_symbol(raw, ptr.ref);
    return ptr;
  }

  @protected
  ffi.Pointer<ffi.Uint32> cst_encode_box_autoadd_u_32(int raw) {
    // Codec=Cst (C-struct based), see doc to use other codecs
    return wire.cst_new_box_autoadd_u_32(cst_encode_u_32(raw));
  }

  @protected
  ffi.Pointer<ffi.Uint64> cst_encode_box_autoadd_u_64(BigInt raw) {
    // Codec=Cst (C-struct based), see doc to use other codecs
    return wire.cst_new_box_autoadd_u_64(cst_encode_u_64(raw));
  }

  @protected
  ffi.Pointer<wire_cst_url_success_action_data> cst_encode_box_autoadd_url_success_action_data(
      UrlSuccessActionData raw) {
    // Codec=Cst (C-struct based), see doc to use other codecs
    final ptr = wire.cst_new_box_autoadd_url_success_action_data();
    cst_api_fill_to_wire_url_success_action_data(raw, ptr.ref);
    return ptr;
  }

  @protected
  int cst_encode_i_64(PlatformInt64 raw) {
    // Codec=Cst (C-struct based), see doc to use other codecs
    return raw.toInt();
  }

  @protected
  ffi.Pointer<wire_cst_list_fiat_currency> cst_encode_list_fiat_currency(List<FiatCurrency> raw) {
    // Codec=Cst (C-struct based), see doc to use other codecs
    final ans = wire.cst_new_list_fiat_currency(raw.length);
    for (var i = 0; i < raw.length; ++i) {
      cst_api_fill_to_wire_fiat_currency(raw[i], ans.ref.ptr[i]);
    }
    return ans;
  }

  @protected
  ffi.Pointer<wire_cst_list_locale_overrides> cst_encode_list_locale_overrides(List<LocaleOverrides> raw) {
    // Codec=Cst (C-struct based), see doc to use other codecs
    final ans = wire.cst_new_list_locale_overrides(raw.length);
    for (var i = 0; i < raw.length; ++i) {
      cst_api_fill_to_wire_locale_overrides(raw[i], ans.ref.ptr[i]);
    }
    return ans;
  }

  @protected
  ffi.Pointer<wire_cst_list_localized_name> cst_encode_list_localized_name(List<LocalizedName> raw) {
    // Codec=Cst (C-struct based), see doc to use other codecs
    final ans = wire.cst_new_list_localized_name(raw.length);
    for (var i = 0; i < raw.length; ++i) {
      cst_api_fill_to_wire_localized_name(raw[i], ans.ref.ptr[i]);
    }
    return ans;
  }

  @protected
  ffi.Pointer<wire_cst_list_payment> cst_encode_list_payment(List<Payment> raw) {
    // Codec=Cst (C-struct based), see doc to use other codecs
    final ans = wire.cst_new_list_payment(raw.length);
    for (var i = 0; i < raw.length; ++i) {
      cst_api_fill_to_wire_payment(raw[i], ans.ref.ptr[i]);
    }
    return ans;
  }

  @protected
  ffi.Pointer<wire_cst_list_payment_type> cst_encode_list_payment_type(List<PaymentType> raw) {
    // Codec=Cst (C-struct based), see doc to use other codecs
    final ans = wire.cst_new_list_payment_type(raw.length);
    for (var i = 0; i < raw.length; ++i) {
      ans.ref.ptr[i] = cst_encode_payment_type(raw[i]);
    }
    return ans;
  }

  @protected
  ffi.Pointer<wire_cst_list_prim_u_8_strict> cst_encode_list_prim_u_8_strict(Uint8List raw) {
    // Codec=Cst (C-struct based), see doc to use other codecs
    final ans = wire.cst_new_list_prim_u_8_strict(raw.length);
    ans.ref.ptr.asTypedList(raw.length).setAll(0, raw);
    return ans;
  }

  @protected
  ffi.Pointer<wire_cst_list_rate> cst_encode_list_rate(List<Rate> raw) {
    // Codec=Cst (C-struct based), see doc to use other codecs
    final ans = wire.cst_new_list_rate(raw.length);
    for (var i = 0; i < raw.length; ++i) {
      cst_api_fill_to_wire_rate(raw[i], ans.ref.ptr[i]);
    }
    return ans;
  }

  @protected
  ffi.Pointer<wire_cst_list_refundable_swap> cst_encode_list_refundable_swap(List<RefundableSwap> raw) {
    // Codec=Cst (C-struct based), see doc to use other codecs
    final ans = wire.cst_new_list_refundable_swap(raw.length);
    for (var i = 0; i < raw.length; ++i) {
      cst_api_fill_to_wire_refundable_swap(raw[i], ans.ref.ptr[i]);
    }
    return ans;
  }

  @protected
  ffi.Pointer<wire_cst_list_route_hint> cst_encode_list_route_hint(List<RouteHint> raw) {
    // Codec=Cst (C-struct based), see doc to use other codecs
    final ans = wire.cst_new_list_route_hint(raw.length);
    for (var i = 0; i < raw.length; ++i) {
      cst_api_fill_to_wire_route_hint(raw[i], ans.ref.ptr[i]);
    }
    return ans;
  }

  @protected
  ffi.Pointer<wire_cst_list_route_hint_hop> cst_encode_list_route_hint_hop(List<RouteHintHop> raw) {
    // Codec=Cst (C-struct based), see doc to use other codecs
    final ans = wire.cst_new_list_route_hint_hop(raw.length);
    for (var i = 0; i < raw.length; ++i) {
      cst_api_fill_to_wire_route_hint_hop(raw[i], ans.ref.ptr[i]);
    }
    return ans;
  }

  @protected
  ffi.Pointer<wire_cst_list_prim_u_8_strict> cst_encode_opt_String(String? raw) {
    // Codec=Cst (C-struct based), see doc to use other codecs
    return raw == null ? ffi.nullptr : cst_encode_String(raw);
  }

  @protected
  ffi.Pointer<ffi.Bool> cst_encode_opt_box_autoadd_bool(bool? raw) {
    // Codec=Cst (C-struct based), see doc to use other codecs
    return raw == null ? ffi.nullptr : cst_encode_box_autoadd_bool(raw);
  }

  @protected
  ffi.Pointer<ffi.Int64> cst_encode_opt_box_autoadd_i_64(PlatformInt64? raw) {
    // Codec=Cst (C-struct based), see doc to use other codecs
    return raw == null ? ffi.nullptr : cst_encode_box_autoadd_i_64(raw);
  }

  @protected
  ffi.Pointer<wire_cst_success_action_processed> cst_encode_opt_box_autoadd_success_action_processed(
      SuccessActionProcessed? raw) {
    // Codec=Cst (C-struct based), see doc to use other codecs
    return raw == null ? ffi.nullptr : cst_encode_box_autoadd_success_action_processed(raw);
  }

  @protected
  ffi.Pointer<wire_cst_symbol> cst_encode_opt_box_autoadd_symbol(Symbol? raw) {
    // Codec=Cst (C-struct based), see doc to use other codecs
    return raw == null ? ffi.nullptr : cst_encode_box_autoadd_symbol(raw);
  }

  @protected
  ffi.Pointer<ffi.Uint32> cst_encode_opt_box_autoadd_u_32(int? raw) {
    // Codec=Cst (C-struct based), see doc to use other codecs
    return raw == null ? ffi.nullptr : cst_encode_box_autoadd_u_32(raw);
  }

  @protected
  ffi.Pointer<ffi.Uint64> cst_encode_opt_box_autoadd_u_64(BigInt? raw) {
    // Codec=Cst (C-struct based), see doc to use other codecs
    return raw == null ? ffi.nullptr : cst_encode_box_autoadd_u_64(raw);
  }

  @protected
  ffi.Pointer<wire_cst_list_payment_type> cst_encode_opt_list_payment_type(List<PaymentType>? raw) {
    // Codec=Cst (C-struct based), see doc to use other codecs
    return raw == null ? ffi.nullptr : cst_encode_list_payment_type(raw);
  }

  @protected
  int cst_encode_u_64(BigInt raw) {
    // Codec=Cst (C-struct based), see doc to use other codecs
    return raw.toSigned(64).toInt();
  }

  @protected
  int cst_encode_usize(BigInt raw) {
    // Codec=Cst (C-struct based), see doc to use other codecs
    return raw.toSigned(64).toInt();
  }

  @protected
  void cst_api_fill_to_wire_aes_success_action_data_decrypted(
      AesSuccessActionDataDecrypted apiObj, wire_cst_aes_success_action_data_decrypted wireObj) {
    wireObj.description = cst_encode_String(apiObj.description);
    wireObj.plaintext = cst_encode_String(apiObj.plaintext);
  }

  @protected
  void cst_api_fill_to_wire_aes_success_action_data_result(
      AesSuccessActionDataResult apiObj, wire_cst_aes_success_action_data_result wireObj) {
    if (apiObj is AesSuccessActionDataResult_Decrypted) {
      var pre_data = cst_encode_box_autoadd_aes_success_action_data_decrypted(apiObj.data);
      wireObj.tag = 0;
      wireObj.kind.Decrypted.data = pre_data;
      return;
    }
    if (apiObj is AesSuccessActionDataResult_ErrorStatus) {
      var pre_reason = cst_encode_String(apiObj.reason);
      wireObj.tag = 1;
      wireObj.kind.ErrorStatus.reason = pre_reason;
      return;
    }
  }

  @protected
  void cst_api_fill_to_wire_backup_request(BackupRequest apiObj, wire_cst_backup_request wireObj) {
    wireObj.backup_path = cst_encode_opt_String(apiObj.backupPath);
  }

  @protected
  void cst_api_fill_to_wire_binding_event_listener(
      BindingEventListener apiObj, wire_cst_binding_event_listener wireObj) {
    wireObj.stream = cst_encode_StreamSink_sdk_event_Dco(apiObj.stream);
  }

  @protected
  void cst_api_fill_to_wire_bitcoin_address_data(
      BitcoinAddressData apiObj, wire_cst_bitcoin_address_data wireObj) {
    wireObj.address = cst_encode_String(apiObj.address);
    wireObj.network = cst_encode_network(apiObj.network);
    wireObj.amount_sat = cst_encode_opt_box_autoadd_u_64(apiObj.amountSat);
    wireObj.label = cst_encode_opt_String(apiObj.label);
    wireObj.message = cst_encode_opt_String(apiObj.message);
  }

  @protected
  void cst_api_fill_to_wire_box_autoadd_aes_success_action_data_decrypted(
      AesSuccessActionDataDecrypted apiObj, ffi.Pointer<wire_cst_aes_success_action_data_decrypted> wireObj) {
    cst_api_fill_to_wire_aes_success_action_data_decrypted(apiObj, wireObj.ref);
  }

  @protected
  void cst_api_fill_to_wire_box_autoadd_aes_success_action_data_result(
      AesSuccessActionDataResult apiObj, ffi.Pointer<wire_cst_aes_success_action_data_result> wireObj) {
    cst_api_fill_to_wire_aes_success_action_data_result(apiObj, wireObj.ref);
  }

  @protected
  void cst_api_fill_to_wire_box_autoadd_backup_request(
      BackupRequest apiObj, ffi.Pointer<wire_cst_backup_request> wireObj) {
    cst_api_fill_to_wire_backup_request(apiObj, wireObj.ref);
  }

  @protected
  void cst_api_fill_to_wire_box_autoadd_binding_event_listener(
      BindingEventListener apiObj, ffi.Pointer<wire_cst_binding_event_listener> wireObj) {
    cst_api_fill_to_wire_binding_event_listener(apiObj, wireObj.ref);
  }

  @protected
  void cst_api_fill_to_wire_box_autoadd_bitcoin_address_data(
      BitcoinAddressData apiObj, ffi.Pointer<wire_cst_bitcoin_address_data> wireObj) {
    cst_api_fill_to_wire_bitcoin_address_data(apiObj, wireObj.ref);
  }

  @protected
  void cst_api_fill_to_wire_box_autoadd_buy_bitcoin_request(
      BuyBitcoinRequest apiObj, ffi.Pointer<wire_cst_buy_bitcoin_request> wireObj) {
    cst_api_fill_to_wire_buy_bitcoin_request(apiObj, wireObj.ref);
  }

  @protected
  void cst_api_fill_to_wire_box_autoadd_check_message_request(
      CheckMessageRequest apiObj, ffi.Pointer<wire_cst_check_message_request> wireObj) {
    cst_api_fill_to_wire_check_message_request(apiObj, wireObj.ref);
  }

  @protected
  void cst_api_fill_to_wire_box_autoadd_connect_request(
      ConnectRequest apiObj, ffi.Pointer<wire_cst_connect_request> wireObj) {
    cst_api_fill_to_wire_connect_request(apiObj, wireObj.ref);
  }

  @protected
  void cst_api_fill_to_wire_box_autoadd_liquid_address_data(
      LiquidAddressData apiObj, ffi.Pointer<wire_cst_liquid_address_data> wireObj) {
    cst_api_fill_to_wire_liquid_address_data(apiObj, wireObj.ref);
  }

  @protected
  void cst_api_fill_to_wire_box_autoadd_list_payments_request(
      ListPaymentsRequest apiObj, ffi.Pointer<wire_cst_list_payments_request> wireObj) {
    cst_api_fill_to_wire_list_payments_request(apiObj, wireObj.ref);
  }

  @protected
  void cst_api_fill_to_wire_box_autoadd_ln_invoice(
      LNInvoice apiObj, ffi.Pointer<wire_cst_ln_invoice> wireObj) {
    cst_api_fill_to_wire_ln_invoice(apiObj, wireObj.ref);
  }

  @protected
  void cst_api_fill_to_wire_box_autoadd_ln_url_auth_request_data(
      LnUrlAuthRequestData apiObj, ffi.Pointer<wire_cst_ln_url_auth_request_data> wireObj) {
    cst_api_fill_to_wire_ln_url_auth_request_data(apiObj, wireObj.ref);
  }

  @protected
  void cst_api_fill_to_wire_box_autoadd_ln_url_error_data(
      LnUrlErrorData apiObj, ffi.Pointer<wire_cst_ln_url_error_data> wireObj) {
    cst_api_fill_to_wire_ln_url_error_data(apiObj, wireObj.ref);
  }

  @protected
  void cst_api_fill_to_wire_box_autoadd_ln_url_pay_error_data(
      LnUrlPayErrorData apiObj, ffi.Pointer<wire_cst_ln_url_pay_error_data> wireObj) {
    cst_api_fill_to_wire_ln_url_pay_error_data(apiObj, wireObj.ref);
  }

  @protected
  void cst_api_fill_to_wire_box_autoadd_ln_url_pay_request(
      LnUrlPayRequest apiObj, ffi.Pointer<wire_cst_ln_url_pay_request> wireObj) {
    cst_api_fill_to_wire_ln_url_pay_request(apiObj, wireObj.ref);
  }

  @protected
  void cst_api_fill_to_wire_box_autoadd_ln_url_pay_request_data(
      LnUrlPayRequestData apiObj, ffi.Pointer<wire_cst_ln_url_pay_request_data> wireObj) {
    cst_api_fill_to_wire_ln_url_pay_request_data(apiObj, wireObj.ref);
  }

  @protected
  void cst_api_fill_to_wire_box_autoadd_ln_url_pay_success_data(
      LnUrlPaySuccessData apiObj, ffi.Pointer<wire_cst_ln_url_pay_success_data> wireObj) {
    cst_api_fill_to_wire_ln_url_pay_success_data(apiObj, wireObj.ref);
  }

  @protected
  void cst_api_fill_to_wire_box_autoadd_ln_url_withdraw_request(
      LnUrlWithdrawRequest apiObj, ffi.Pointer<wire_cst_ln_url_withdraw_request> wireObj) {
    cst_api_fill_to_wire_ln_url_withdraw_request(apiObj, wireObj.ref);
  }

  @protected
  void cst_api_fill_to_wire_box_autoadd_ln_url_withdraw_request_data(
      LnUrlWithdrawRequestData apiObj, ffi.Pointer<wire_cst_ln_url_withdraw_request_data> wireObj) {
    cst_api_fill_to_wire_ln_url_withdraw_request_data(apiObj, wireObj.ref);
  }

  @protected
  void cst_api_fill_to_wire_box_autoadd_ln_url_withdraw_success_data(
      LnUrlWithdrawSuccessData apiObj, ffi.Pointer<wire_cst_ln_url_withdraw_success_data> wireObj) {
    cst_api_fill_to_wire_ln_url_withdraw_success_data(apiObj, wireObj.ref);
  }

  @protected
  void cst_api_fill_to_wire_box_autoadd_message_success_action_data(
      MessageSuccessActionData apiObj, ffi.Pointer<wire_cst_message_success_action_data> wireObj) {
    cst_api_fill_to_wire_message_success_action_data(apiObj, wireObj.ref);
  }

  @protected
  void cst_api_fill_to_wire_box_autoadd_pay_onchain_request(
      PayOnchainRequest apiObj, ffi.Pointer<wire_cst_pay_onchain_request> wireObj) {
    cst_api_fill_to_wire_pay_onchain_request(apiObj, wireObj.ref);
  }

  @protected
  void cst_api_fill_to_wire_box_autoadd_payment(Payment apiObj, ffi.Pointer<wire_cst_payment> wireObj) {
    cst_api_fill_to_wire_payment(apiObj, wireObj.ref);
  }

  @protected
  void cst_api_fill_to_wire_box_autoadd_prepare_buy_bitcoin_request(
      PrepareBuyBitcoinRequest apiObj, ffi.Pointer<wire_cst_prepare_buy_bitcoin_request> wireObj) {
    cst_api_fill_to_wire_prepare_buy_bitcoin_request(apiObj, wireObj.ref);
  }

  @protected
  void cst_api_fill_to_wire_box_autoadd_prepare_pay_onchain_request(
      PreparePayOnchainRequest apiObj, ffi.Pointer<wire_cst_prepare_pay_onchain_request> wireObj) {
    cst_api_fill_to_wire_prepare_pay_onchain_request(apiObj, wireObj.ref);
  }

  @protected
  void cst_api_fill_to_wire_box_autoadd_prepare_receive_request(
      PrepareReceiveRequest apiObj, ffi.Pointer<wire_cst_prepare_receive_request> wireObj) {
    cst_api_fill_to_wire_prepare_receive_request(apiObj, wireObj.ref);
  }

  @protected
  void cst_api_fill_to_wire_box_autoadd_prepare_refund_request(
      PrepareRefundRequest apiObj, ffi.Pointer<wire_cst_prepare_refund_request> wireObj) {
    cst_api_fill_to_wire_prepare_refund_request(apiObj, wireObj.ref);
  }

  @protected
  void cst_api_fill_to_wire_box_autoadd_prepare_send_request(
      PrepareSendRequest apiObj, ffi.Pointer<wire_cst_prepare_send_request> wireObj) {
    cst_api_fill_to_wire_prepare_send_request(apiObj, wireObj.ref);
  }

  @protected
  void cst_api_fill_to_wire_box_autoadd_receive_payment_request(
      ReceivePaymentRequest apiObj, ffi.Pointer<wire_cst_receive_payment_request> wireObj) {
    cst_api_fill_to_wire_receive_payment_request(apiObj, wireObj.ref);
  }

  @protected
  void cst_api_fill_to_wire_box_autoadd_refund_request(
      RefundRequest apiObj, ffi.Pointer<wire_cst_refund_request> wireObj) {
    cst_api_fill_to_wire_refund_request(apiObj, wireObj.ref);
  }

  @protected
  void cst_api_fill_to_wire_box_autoadd_restore_request(
      RestoreRequest apiObj, ffi.Pointer<wire_cst_restore_request> wireObj) {
    cst_api_fill_to_wire_restore_request(apiObj, wireObj.ref);
  }

  @protected
  void cst_api_fill_to_wire_box_autoadd_sdk_event(SdkEvent apiObj, ffi.Pointer<wire_cst_sdk_event> wireObj) {
    cst_api_fill_to_wire_sdk_event(apiObj, wireObj.ref);
  }

  @protected
  void cst_api_fill_to_wire_box_autoadd_send_payment_request(
      SendPaymentRequest apiObj, ffi.Pointer<wire_cst_send_payment_request> wireObj) {
    cst_api_fill_to_wire_send_payment_request(apiObj, wireObj.ref);
  }

  @protected
  void cst_api_fill_to_wire_box_autoadd_sign_message_request(
      SignMessageRequest apiObj, ffi.Pointer<wire_cst_sign_message_request> wireObj) {
    cst_api_fill_to_wire_sign_message_request(apiObj, wireObj.ref);
  }

  @protected
  void cst_api_fill_to_wire_box_autoadd_success_action_processed(
      SuccessActionProcessed apiObj, ffi.Pointer<wire_cst_success_action_processed> wireObj) {
    cst_api_fill_to_wire_success_action_processed(apiObj, wireObj.ref);
  }

  @protected
  void cst_api_fill_to_wire_box_autoadd_symbol(Symbol apiObj, ffi.Pointer<wire_cst_symbol> wireObj) {
    cst_api_fill_to_wire_symbol(apiObj, wireObj.ref);
  }

  @protected
  void cst_api_fill_to_wire_box_autoadd_url_success_action_data(
      UrlSuccessActionData apiObj, ffi.Pointer<wire_cst_url_success_action_data> wireObj) {
    cst_api_fill_to_wire_url_success_action_data(apiObj, wireObj.ref);
  }

  @protected
  void cst_api_fill_to_wire_buy_bitcoin_request(
      BuyBitcoinRequest apiObj, wire_cst_buy_bitcoin_request wireObj) {
    cst_api_fill_to_wire_prepare_buy_bitcoin_response(apiObj.prepareResponse, wireObj.prepare_response);
    wireObj.redirect_url = cst_encode_opt_String(apiObj.redirectUrl);
  }

  @protected
  void cst_api_fill_to_wire_check_message_request(
      CheckMessageRequest apiObj, wire_cst_check_message_request wireObj) {
    wireObj.message = cst_encode_String(apiObj.message);
    wireObj.pubkey = cst_encode_String(apiObj.pubkey);
    wireObj.signature = cst_encode_String(apiObj.signature);
  }

  @protected
  void cst_api_fill_to_wire_check_message_response(
      CheckMessageResponse apiObj, wire_cst_check_message_response wireObj) {
    wireObj.is_valid = cst_encode_bool(apiObj.isValid);
  }

  @protected
  void cst_api_fill_to_wire_config(Config apiObj, wire_cst_config wireObj) {
    wireObj.liquid_electrum_url = cst_encode_String(apiObj.liquidElectrumUrl);
    wireObj.bitcoin_electrum_url = cst_encode_String(apiObj.bitcoinElectrumUrl);
    wireObj.mempoolspace_url = cst_encode_String(apiObj.mempoolspaceUrl);
    wireObj.working_dir = cst_encode_String(apiObj.workingDir);
    wireObj.network = cst_encode_liquid_network(apiObj.network);
    wireObj.payment_timeout_sec = cst_encode_u_64(apiObj.paymentTimeoutSec);
    wireObj.zero_conf_min_fee_rate_msat = cst_encode_u_32(apiObj.zeroConfMinFeeRateMsat);
    wireObj.zero_conf_max_amount_sat = cst_encode_opt_box_autoadd_u_64(apiObj.zeroConfMaxAmountSat);
    wireObj.breez_api_key = cst_encode_opt_String(apiObj.breezApiKey);
  }

  @protected
  void cst_api_fill_to_wire_connect_request(ConnectRequest apiObj, wire_cst_connect_request wireObj) {
    wireObj.mnemonic = cst_encode_String(apiObj.mnemonic);
    cst_api_fill_to_wire_config(apiObj.config, wireObj.config);
  }

  @protected
  void cst_api_fill_to_wire_currency_info(CurrencyInfo apiObj, wire_cst_currency_info wireObj) {
    wireObj.name = cst_encode_String(apiObj.name);
    wireObj.fraction_size = cst_encode_u_32(apiObj.fractionSize);
    wireObj.spacing = cst_encode_opt_box_autoadd_u_32(apiObj.spacing);
    wireObj.symbol = cst_encode_opt_box_autoadd_symbol(apiObj.symbol);
    wireObj.uniq_symbol = cst_encode_opt_box_autoadd_symbol(apiObj.uniqSymbol);
    wireObj.localized_name = cst_encode_list_localized_name(apiObj.localizedName);
    wireObj.locale_overrides = cst_encode_list_locale_overrides(apiObj.localeOverrides);
  }

  @protected
  void cst_api_fill_to_wire_fiat_currency(FiatCurrency apiObj, wire_cst_fiat_currency wireObj) {
    wireObj.id = cst_encode_String(apiObj.id);
    cst_api_fill_to_wire_currency_info(apiObj.info, wireObj.info);
  }

  @protected
  void cst_api_fill_to_wire_get_info_response(GetInfoResponse apiObj, wire_cst_get_info_response wireObj) {
    wireObj.balance_sat = cst_encode_u_64(apiObj.balanceSat);
    wireObj.pending_send_sat = cst_encode_u_64(apiObj.pendingSendSat);
    wireObj.pending_receive_sat = cst_encode_u_64(apiObj.pendingReceiveSat);
    wireObj.pubkey = cst_encode_String(apiObj.pubkey);
  }

  @protected
  void cst_api_fill_to_wire_input_type(InputType apiObj, wire_cst_input_type wireObj) {
    if (apiObj is InputType_BitcoinAddress) {
      var pre_address = cst_encode_box_autoadd_bitcoin_address_data(apiObj.address);
      wireObj.tag = 0;
      wireObj.kind.BitcoinAddress.address = pre_address;
      return;
    }
    if (apiObj is InputType_LiquidAddress) {
      var pre_address = cst_encode_box_autoadd_liquid_address_data(apiObj.address);
      wireObj.tag = 1;
      wireObj.kind.LiquidAddress.address = pre_address;
      return;
    }
    if (apiObj is InputType_Bolt11) {
      var pre_invoice = cst_encode_box_autoadd_ln_invoice(apiObj.invoice);
      wireObj.tag = 2;
      wireObj.kind.Bolt11.invoice = pre_invoice;
      return;
    }
    if (apiObj is InputType_NodeId) {
      var pre_node_id = cst_encode_String(apiObj.nodeId);
      wireObj.tag = 3;
      wireObj.kind.NodeId.node_id = pre_node_id;
      return;
    }
    if (apiObj is InputType_Url) {
      var pre_url = cst_encode_String(apiObj.url);
      wireObj.tag = 4;
      wireObj.kind.Url.url = pre_url;
      return;
    }
    if (apiObj is InputType_LnUrlPay) {
      var pre_data = cst_encode_box_autoadd_ln_url_pay_request_data(apiObj.data);
      wireObj.tag = 5;
      wireObj.kind.LnUrlPay.data = pre_data;
      return;
    }
    if (apiObj is InputType_LnUrlWithdraw) {
      var pre_data = cst_encode_box_autoadd_ln_url_withdraw_request_data(apiObj.data);
      wireObj.tag = 6;
      wireObj.kind.LnUrlWithdraw.data = pre_data;
      return;
    }
    if (apiObj is InputType_LnUrlAuth) {
      var pre_data = cst_encode_box_autoadd_ln_url_auth_request_data(apiObj.data);
      wireObj.tag = 7;
      wireObj.kind.LnUrlAuth.data = pre_data;
      return;
    }
    if (apiObj is InputType_LnUrlError) {
      var pre_data = cst_encode_box_autoadd_ln_url_error_data(apiObj.data);
      wireObj.tag = 8;
      wireObj.kind.LnUrlError.data = pre_data;
      return;
    }
  }

  @protected
  void cst_api_fill_to_wire_lightning_payment_limits_response(
      LightningPaymentLimitsResponse apiObj, wire_cst_lightning_payment_limits_response wireObj) {
    cst_api_fill_to_wire_limits(apiObj.send, wireObj.send);
    cst_api_fill_to_wire_limits(apiObj.receive, wireObj.receive);
  }

  @protected
  void cst_api_fill_to_wire_limits(Limits apiObj, wire_cst_limits wireObj) {
    wireObj.min_sat = cst_encode_u_64(apiObj.minSat);
    wireObj.max_sat = cst_encode_u_64(apiObj.maxSat);
    wireObj.max_zero_conf_sat = cst_encode_u_64(apiObj.maxZeroConfSat);
  }

  @protected
  void cst_api_fill_to_wire_liquid_address_data(
      LiquidAddressData apiObj, wire_cst_liquid_address_data wireObj) {
    wireObj.address = cst_encode_String(apiObj.address);
    wireObj.network = cst_encode_network(apiObj.network);
    wireObj.asset_id = cst_encode_opt_String(apiObj.assetId);
    wireObj.amount_sat = cst_encode_opt_box_autoadd_u_64(apiObj.amountSat);
    wireObj.label = cst_encode_opt_String(apiObj.label);
    wireObj.message = cst_encode_opt_String(apiObj.message);
  }

  @protected
  void cst_api_fill_to_wire_list_payments_request(
      ListPaymentsRequest apiObj, wire_cst_list_payments_request wireObj) {
    wireObj.filters = cst_encode_opt_list_payment_type(apiObj.filters);
    wireObj.from_timestamp = cst_encode_opt_box_autoadd_i_64(apiObj.fromTimestamp);
    wireObj.to_timestamp = cst_encode_opt_box_autoadd_i_64(apiObj.toTimestamp);
    wireObj.offset = cst_encode_opt_box_autoadd_u_32(apiObj.offset);
    wireObj.limit = cst_encode_opt_box_autoadd_u_32(apiObj.limit);
  }

  @protected
  void cst_api_fill_to_wire_ln_invoice(LNInvoice apiObj, wire_cst_ln_invoice wireObj) {
    wireObj.bolt11 = cst_encode_String(apiObj.bolt11);
    wireObj.network = cst_encode_network(apiObj.network);
    wireObj.payee_pubkey = cst_encode_String(apiObj.payeePubkey);
    wireObj.payment_hash = cst_encode_String(apiObj.paymentHash);
    wireObj.description = cst_encode_opt_String(apiObj.description);
    wireObj.description_hash = cst_encode_opt_String(apiObj.descriptionHash);
    wireObj.amount_msat = cst_encode_opt_box_autoadd_u_64(apiObj.amountMsat);
    wireObj.timestamp = cst_encode_u_64(apiObj.timestamp);
    wireObj.expiry = cst_encode_u_64(apiObj.expiry);
    wireObj.routing_hints = cst_encode_list_route_hint(apiObj.routingHints);
    wireObj.payment_secret = cst_encode_list_prim_u_8_strict(apiObj.paymentSecret);
    wireObj.min_final_cltv_expiry_delta = cst_encode_u_64(apiObj.minFinalCltvExpiryDelta);
  }

  @protected
  void cst_api_fill_to_wire_ln_url_auth_error(LnUrlAuthError apiObj, wire_cst_ln_url_auth_error wireObj) {
    if (apiObj is LnUrlAuthError_Generic) {
      var pre_err = cst_encode_String(apiObj.err);
      wireObj.tag = 0;
      wireObj.kind.Generic.err = pre_err;
      return;
    }
    if (apiObj is LnUrlAuthError_InvalidUri) {
      var pre_err = cst_encode_String(apiObj.err);
      wireObj.tag = 1;
      wireObj.kind.InvalidUri.err = pre_err;
      return;
    }
    if (apiObj is LnUrlAuthError_ServiceConnectivity) {
      var pre_err = cst_encode_String(apiObj.err);
      wireObj.tag = 2;
      wireObj.kind.ServiceConnectivity.err = pre_err;
      return;
    }
  }

  @protected
  void cst_api_fill_to_wire_ln_url_auth_request_data(
      LnUrlAuthRequestData apiObj, wire_cst_ln_url_auth_request_data wireObj) {
    wireObj.k1 = cst_encode_String(apiObj.k1);
    wireObj.action = cst_encode_opt_String(apiObj.action);
    wireObj.domain = cst_encode_String(apiObj.domain);
    wireObj.url = cst_encode_String(apiObj.url);
  }

  @protected
  void cst_api_fill_to_wire_ln_url_callback_status(
      LnUrlCallbackStatus apiObj, wire_cst_ln_url_callback_status wireObj) {
    if (apiObj is LnUrlCallbackStatus_Ok) {
      wireObj.tag = 0;
      return;
    }
    if (apiObj is LnUrlCallbackStatus_ErrorStatus) {
      var pre_data = cst_encode_box_autoadd_ln_url_error_data(apiObj.data);
      wireObj.tag = 1;
      wireObj.kind.ErrorStatus.data = pre_data;
      return;
    }
  }

  @protected
  void cst_api_fill_to_wire_ln_url_error_data(LnUrlErrorData apiObj, wire_cst_ln_url_error_data wireObj) {
    wireObj.reason = cst_encode_String(apiObj.reason);
  }

  @protected
  void cst_api_fill_to_wire_ln_url_pay_error(LnUrlPayError apiObj, wire_cst_ln_url_pay_error wireObj) {
    if (apiObj is LnUrlPayError_AlreadyPaid) {
      wireObj.tag = 0;
      return;
    }
    if (apiObj is LnUrlPayError_Generic) {
      var pre_err = cst_encode_String(apiObj.err);
      wireObj.tag = 1;
      wireObj.kind.Generic.err = pre_err;
      return;
    }
    if (apiObj is LnUrlPayError_InvalidAmount) {
      var pre_err = cst_encode_String(apiObj.err);
      wireObj.tag = 2;
      wireObj.kind.InvalidAmount.err = pre_err;
      return;
    }
    if (apiObj is LnUrlPayError_InvalidInvoice) {
      var pre_err = cst_encode_String(apiObj.err);
      wireObj.tag = 3;
      wireObj.kind.InvalidInvoice.err = pre_err;
      return;
    }
    if (apiObj is LnUrlPayError_InvalidNetwork) {
      var pre_err = cst_encode_String(apiObj.err);
      wireObj.tag = 4;
      wireObj.kind.InvalidNetwork.err = pre_err;
      return;
    }
    if (apiObj is LnUrlPayError_InvalidUri) {
      var pre_err = cst_encode_String(apiObj.err);
      wireObj.tag = 5;
      wireObj.kind.InvalidUri.err = pre_err;
      return;
    }
    if (apiObj is LnUrlPayError_InvoiceExpired) {
      var pre_err = cst_encode_String(apiObj.err);
      wireObj.tag = 6;
      wireObj.kind.InvoiceExpired.err = pre_err;
      return;
    }
    if (apiObj is LnUrlPayError_PaymentFailed) {
      var pre_err = cst_encode_String(apiObj.err);
      wireObj.tag = 7;
      wireObj.kind.PaymentFailed.err = pre_err;
      return;
    }
    if (apiObj is LnUrlPayError_PaymentTimeout) {
      var pre_err = cst_encode_String(apiObj.err);
      wireObj.tag = 8;
      wireObj.kind.PaymentTimeout.err = pre_err;
      return;
    }
    if (apiObj is LnUrlPayError_RouteNotFound) {
      var pre_err = cst_encode_String(apiObj.err);
      wireObj.tag = 9;
      wireObj.kind.RouteNotFound.err = pre_err;
      return;
    }
    if (apiObj is LnUrlPayError_RouteTooExpensive) {
      var pre_err = cst_encode_String(apiObj.err);
      wireObj.tag = 10;
      wireObj.kind.RouteTooExpensive.err = pre_err;
      return;
    }
    if (apiObj is LnUrlPayError_ServiceConnectivity) {
      var pre_err = cst_encode_String(apiObj.err);
      wireObj.tag = 11;
      wireObj.kind.ServiceConnectivity.err = pre_err;
      return;
    }
  }

  @protected
  void cst_api_fill_to_wire_ln_url_pay_error_data(
      LnUrlPayErrorData apiObj, wire_cst_ln_url_pay_error_data wireObj) {
    wireObj.payment_hash = cst_encode_String(apiObj.paymentHash);
    wireObj.reason = cst_encode_String(apiObj.reason);
  }

  @protected
  void cst_api_fill_to_wire_ln_url_pay_request(LnUrlPayRequest apiObj, wire_cst_ln_url_pay_request wireObj) {
    cst_api_fill_to_wire_ln_url_pay_request_data(apiObj.data, wireObj.data);
    wireObj.amount_msat = cst_encode_u_64(apiObj.amountMsat);
    wireObj.comment = cst_encode_opt_String(apiObj.comment);
    wireObj.payment_label = cst_encode_opt_String(apiObj.paymentLabel);
    wireObj.validate_success_action_url = cst_encode_opt_box_autoadd_bool(apiObj.validateSuccessActionUrl);
  }

  @protected
  void cst_api_fill_to_wire_ln_url_pay_request_data(
      LnUrlPayRequestData apiObj, wire_cst_ln_url_pay_request_data wireObj) {
    wireObj.callback = cst_encode_String(apiObj.callback);
    wireObj.min_sendable = cst_encode_u_64(apiObj.minSendable);
    wireObj.max_sendable = cst_encode_u_64(apiObj.maxSendable);
    wireObj.metadata_str = cst_encode_String(apiObj.metadataStr);
    wireObj.comment_allowed = cst_encode_u_16(apiObj.commentAllowed);
    wireObj.domain = cst_encode_String(apiObj.domain);
    wireObj.allows_nostr = cst_encode_bool(apiObj.allowsNostr);
    wireObj.nostr_pubkey = cst_encode_opt_String(apiObj.nostrPubkey);
    wireObj.ln_address = cst_encode_opt_String(apiObj.lnAddress);
  }

  @protected
  void cst_api_fill_to_wire_ln_url_pay_result(LnUrlPayResult apiObj, wire_cst_ln_url_pay_result wireObj) {
    if (apiObj is LnUrlPayResult_EndpointSuccess) {
      var pre_data = cst_encode_box_autoadd_ln_url_pay_success_data(apiObj.data);
      wireObj.tag = 0;
      wireObj.kind.EndpointSuccess.data = pre_data;
      return;
    }
    if (apiObj is LnUrlPayResult_EndpointError) {
      var pre_data = cst_encode_box_autoadd_ln_url_error_data(apiObj.data);
      wireObj.tag = 1;
      wireObj.kind.EndpointError.data = pre_data;
      return;
    }
    if (apiObj is LnUrlPayResult_PayError) {
      var pre_data = cst_encode_box_autoadd_ln_url_pay_error_data(apiObj.data);
      wireObj.tag = 2;
      wireObj.kind.PayError.data = pre_data;
      return;
    }
  }

  @protected
  void cst_api_fill_to_wire_ln_url_pay_success_data(
      LnUrlPaySuccessData apiObj, wire_cst_ln_url_pay_success_data wireObj) {
    cst_api_fill_to_wire_payment(apiObj.payment, wireObj.payment);
    wireObj.success_action = cst_encode_opt_box_autoadd_success_action_processed(apiObj.successAction);
  }

  @protected
  void cst_api_fill_to_wire_ln_url_withdraw_error(
      LnUrlWithdrawError apiObj, wire_cst_ln_url_withdraw_error wireObj) {
    if (apiObj is LnUrlWithdrawError_Generic) {
      var pre_err = cst_encode_String(apiObj.err);
      wireObj.tag = 0;
      wireObj.kind.Generic.err = pre_err;
      return;
    }
    if (apiObj is LnUrlWithdrawError_InvalidAmount) {
      var pre_err = cst_encode_String(apiObj.err);
      wireObj.tag = 1;
      wireObj.kind.InvalidAmount.err = pre_err;
      return;
    }
    if (apiObj is LnUrlWithdrawError_InvalidInvoice) {
      var pre_err = cst_encode_String(apiObj.err);
      wireObj.tag = 2;
      wireObj.kind.InvalidInvoice.err = pre_err;
      return;
    }
    if (apiObj is LnUrlWithdrawError_InvalidUri) {
      var pre_err = cst_encode_String(apiObj.err);
      wireObj.tag = 3;
      wireObj.kind.InvalidUri.err = pre_err;
      return;
    }
    if (apiObj is LnUrlWithdrawError_InvoiceNoRoutingHints) {
      var pre_err = cst_encode_String(apiObj.err);
      wireObj.tag = 4;
      wireObj.kind.InvoiceNoRoutingHints.err = pre_err;
      return;
    }
    if (apiObj is LnUrlWithdrawError_ServiceConnectivity) {
      var pre_err = cst_encode_String(apiObj.err);
      wireObj.tag = 5;
      wireObj.kind.ServiceConnectivity.err = pre_err;
      return;
    }
  }

  @protected
  void cst_api_fill_to_wire_ln_url_withdraw_request(
      LnUrlWithdrawRequest apiObj, wire_cst_ln_url_withdraw_request wireObj) {
    cst_api_fill_to_wire_ln_url_withdraw_request_data(apiObj.data, wireObj.data);
    wireObj.amount_msat = cst_encode_u_64(apiObj.amountMsat);
    wireObj.description = cst_encode_opt_String(apiObj.description);
  }

  @protected
  void cst_api_fill_to_wire_ln_url_withdraw_request_data(
      LnUrlWithdrawRequestData apiObj, wire_cst_ln_url_withdraw_request_data wireObj) {
    wireObj.callback = cst_encode_String(apiObj.callback);
    wireObj.k1 = cst_encode_String(apiObj.k1);
    wireObj.default_description = cst_encode_String(apiObj.defaultDescription);
    wireObj.min_withdrawable = cst_encode_u_64(apiObj.minWithdrawable);
    wireObj.max_withdrawable = cst_encode_u_64(apiObj.maxWithdrawable);
  }

  @protected
  void cst_api_fill_to_wire_ln_url_withdraw_result(
      LnUrlWithdrawResult apiObj, wire_cst_ln_url_withdraw_result wireObj) {
    if (apiObj is LnUrlWithdrawResult_Ok) {
      var pre_data = cst_encode_box_autoadd_ln_url_withdraw_success_data(apiObj.data);
      wireObj.tag = 0;
      wireObj.kind.Ok.data = pre_data;
      return;
    }
    if (apiObj is LnUrlWithdrawResult_Timeout) {
      var pre_data = cst_encode_box_autoadd_ln_url_withdraw_success_data(apiObj.data);
      wireObj.tag = 1;
      wireObj.kind.Timeout.data = pre_data;
      return;
    }
    if (apiObj is LnUrlWithdrawResult_ErrorStatus) {
      var pre_data = cst_encode_box_autoadd_ln_url_error_data(apiObj.data);
      wireObj.tag = 2;
      wireObj.kind.ErrorStatus.data = pre_data;
      return;
    }
  }

  @protected
  void cst_api_fill_to_wire_ln_url_withdraw_success_data(
      LnUrlWithdrawSuccessData apiObj, wire_cst_ln_url_withdraw_success_data wireObj) {
    cst_api_fill_to_wire_ln_invoice(apiObj.invoice, wireObj.invoice);
  }

  @protected
  void cst_api_fill_to_wire_locale_overrides(LocaleOverrides apiObj, wire_cst_locale_overrides wireObj) {
    wireObj.locale = cst_encode_String(apiObj.locale);
    wireObj.spacing = cst_encode_opt_box_autoadd_u_32(apiObj.spacing);
    cst_api_fill_to_wire_symbol(apiObj.symbol, wireObj.symbol);
  }

  @protected
  void cst_api_fill_to_wire_localized_name(LocalizedName apiObj, wire_cst_localized_name wireObj) {
    wireObj.locale = cst_encode_String(apiObj.locale);
    wireObj.name = cst_encode_String(apiObj.name);
  }

  @protected
  void cst_api_fill_to_wire_log_entry(LogEntry apiObj, wire_cst_log_entry wireObj) {
    wireObj.line = cst_encode_String(apiObj.line);
    wireObj.level = cst_encode_String(apiObj.level);
  }

  @protected
  void cst_api_fill_to_wire_message_success_action_data(
      MessageSuccessActionData apiObj, wire_cst_message_success_action_data wireObj) {
    wireObj.message = cst_encode_String(apiObj.message);
  }

  @protected
  void cst_api_fill_to_wire_onchain_payment_limits_response(
      OnchainPaymentLimitsResponse apiObj, wire_cst_onchain_payment_limits_response wireObj) {
    cst_api_fill_to_wire_limits(apiObj.send, wireObj.send);
    cst_api_fill_to_wire_limits(apiObj.receive, wireObj.receive);
  }

  @protected
  void cst_api_fill_to_wire_pay_onchain_amount(PayOnchainAmount apiObj, wire_cst_pay_onchain_amount wireObj) {
    if (apiObj is PayOnchainAmount_Receiver) {
      var pre_amount_sat = cst_encode_u_64(apiObj.amountSat);
      wireObj.tag = 0;
      wireObj.kind.Receiver.amount_sat = pre_amount_sat;
      return;
    }
    if (apiObj is PayOnchainAmount_Drain) {
      wireObj.tag = 1;
      return;
    }
  }

  @protected
  void cst_api_fill_to_wire_pay_onchain_request(
      PayOnchainRequest apiObj, wire_cst_pay_onchain_request wireObj) {
    wireObj.address = cst_encode_String(apiObj.address);
    cst_api_fill_to_wire_prepare_pay_onchain_response(apiObj.prepareResponse, wireObj.prepare_response);
  }

  @protected
  void cst_api_fill_to_wire_payment(Payment apiObj, wire_cst_payment wireObj) {
    wireObj.destination = cst_encode_opt_String(apiObj.destination);
    wireObj.tx_id = cst_encode_opt_String(apiObj.txId);
    wireObj.timestamp = cst_encode_u_32(apiObj.timestamp);
    wireObj.amount_sat = cst_encode_u_64(apiObj.amountSat);
    wireObj.fees_sat = cst_encode_u_64(apiObj.feesSat);
    wireObj.payment_type = cst_encode_payment_type(apiObj.paymentType);
    wireObj.status = cst_encode_payment_state(apiObj.status);
    cst_api_fill_to_wire_payment_details(apiObj.details, wireObj.details);
  }

  @protected
  void cst_api_fill_to_wire_payment_details(PaymentDetails apiObj, wire_cst_payment_details wireObj) {
    if (apiObj is PaymentDetails_Lightning) {
      var pre_swap_id = cst_encode_String(apiObj.swapId);
      var pre_description = cst_encode_String(apiObj.description);
      var pre_preimage = cst_encode_opt_String(apiObj.preimage);
      var pre_bolt11 = cst_encode_opt_String(apiObj.bolt11);
      var pre_refund_tx_id = cst_encode_opt_String(apiObj.refundTxId);
      var pre_refund_tx_amount_sat = cst_encode_opt_box_autoadd_u_64(apiObj.refundTxAmountSat);
      wireObj.tag = 0;
      wireObj.kind.Lightning.swap_id = pre_swap_id;
      wireObj.kind.Lightning.description = pre_description;
      wireObj.kind.Lightning.preimage = pre_preimage;
      wireObj.kind.Lightning.bolt11 = pre_bolt11;
      wireObj.kind.Lightning.refund_tx_id = pre_refund_tx_id;
      wireObj.kind.Lightning.refund_tx_amount_sat = pre_refund_tx_amount_sat;
      return;
    }
    if (apiObj is PaymentDetails_Liquid) {
      var pre_destination = cst_encode_String(apiObj.destination);
      var pre_description = cst_encode_String(apiObj.description);
      wireObj.tag = 1;
      wireObj.kind.Liquid.destination = pre_destination;
      wireObj.kind.Liquid.description = pre_description;
      return;
    }
    if (apiObj is PaymentDetails_Bitcoin) {
      var pre_swap_id = cst_encode_String(apiObj.swapId);
      var pre_description = cst_encode_String(apiObj.description);
      var pre_refund_tx_id = cst_encode_opt_String(apiObj.refundTxId);
      var pre_refund_tx_amount_sat = cst_encode_opt_box_autoadd_u_64(apiObj.refundTxAmountSat);
      wireObj.tag = 2;
      wireObj.kind.Bitcoin.swap_id = pre_swap_id;
      wireObj.kind.Bitcoin.description = pre_description;
      wireObj.kind.Bitcoin.refund_tx_id = pre_refund_tx_id;
      wireObj.kind.Bitcoin.refund_tx_amount_sat = pre_refund_tx_amount_sat;
      return;
    }
  }

  @protected
  void cst_api_fill_to_wire_payment_error(PaymentError apiObj, wire_cst_payment_error wireObj) {
    if (apiObj is PaymentError_AlreadyClaimed) {
      wireObj.tag = 0;
      return;
    }
    if (apiObj is PaymentError_AlreadyPaid) {
      wireObj.tag = 1;
      return;
    }
    if (apiObj is PaymentError_PaymentInProgress) {
      wireObj.tag = 2;
      return;
    }
    if (apiObj is PaymentError_AmountOutOfRange) {
      wireObj.tag = 3;
      return;
    }
    if (apiObj is PaymentError_AmountMissing) {
      var pre_err = cst_encode_String(apiObj.err);
      wireObj.tag = 4;
      wireObj.kind.AmountMissing.err = pre_err;
      return;
    }
    if (apiObj is PaymentError_InvalidNetwork) {
      var pre_err = cst_encode_String(apiObj.err);
      wireObj.tag = 5;
      wireObj.kind.InvalidNetwork.err = pre_err;
      return;
    }
    if (apiObj is PaymentError_Generic) {
      var pre_err = cst_encode_String(apiObj.err);
      wireObj.tag = 6;
      wireObj.kind.Generic.err = pre_err;
      return;
    }
    if (apiObj is PaymentError_InvalidOrExpiredFees) {
      wireObj.tag = 7;
      return;
    }
    if (apiObj is PaymentError_InsufficientFunds) {
      wireObj.tag = 8;
      return;
    }
    if (apiObj is PaymentError_InvalidDescription) {
      var pre_err = cst_encode_String(apiObj.err);
      wireObj.tag = 9;
      wireObj.kind.InvalidDescription.err = pre_err;
      return;
    }
    if (apiObj is PaymentError_InvalidInvoice) {
      var pre_err = cst_encode_String(apiObj.err);
      wireObj.tag = 10;
      wireObj.kind.InvalidInvoice.err = pre_err;
      return;
    }
    if (apiObj is PaymentError_InvalidPreimage) {
      wireObj.tag = 11;
      return;
    }
    if (apiObj is PaymentError_LwkError) {
      var pre_err = cst_encode_String(apiObj.err);
      wireObj.tag = 12;
      wireObj.kind.LwkError.err = pre_err;
      return;
    }
    if (apiObj is PaymentError_PairsNotFound) {
      wireObj.tag = 13;
      return;
    }
    if (apiObj is PaymentError_PaymentTimeout) {
      wireObj.tag = 14;
      return;
    }
    if (apiObj is PaymentError_PersistError) {
      wireObj.tag = 15;
      return;
    }
    if (apiObj is PaymentError_ReceiveError) {
      var pre_err = cst_encode_String(apiObj.err);
      wireObj.tag = 16;
      wireObj.kind.ReceiveError.err = pre_err;
      return;
    }
    if (apiObj is PaymentError_Refunded) {
      var pre_err = cst_encode_String(apiObj.err);
      var pre_refund_tx_id = cst_encode_String(apiObj.refundTxId);
      wireObj.tag = 17;
      wireObj.kind.Refunded.err = pre_err;
      wireObj.kind.Refunded.refund_tx_id = pre_refund_tx_id;
      return;
    }
    if (apiObj is PaymentError_SelfTransferNotSupported) {
      wireObj.tag = 18;
      return;
    }
    if (apiObj is PaymentError_SendError) {
      var pre_err = cst_encode_String(apiObj.err);
      wireObj.tag = 19;
      wireObj.kind.SendError.err = pre_err;
      return;
    }
    if (apiObj is PaymentError_SignerError) {
      var pre_err = cst_encode_String(apiObj.err);
      wireObj.tag = 20;
      wireObj.kind.SignerError.err = pre_err;
      return;
    }
  }

  @protected
  void cst_api_fill_to_wire_prepare_buy_bitcoin_request(
      PrepareBuyBitcoinRequest apiObj, wire_cst_prepare_buy_bitcoin_request wireObj) {
    wireObj.provider = cst_encode_buy_bitcoin_provider(apiObj.provider);
    wireObj.amount_sat = cst_encode_u_64(apiObj.amountSat);
  }

  @protected
  void cst_api_fill_to_wire_prepare_buy_bitcoin_response(
      PrepareBuyBitcoinResponse apiObj, wire_cst_prepare_buy_bitcoin_response wireObj) {
    wireObj.provider = cst_encode_buy_bitcoin_provider(apiObj.provider);
    wireObj.amount_sat = cst_encode_u_64(apiObj.amountSat);
    wireObj.fees_sat = cst_encode_u_64(apiObj.feesSat);
  }

  @protected
  void cst_api_fill_to_wire_prepare_pay_onchain_request(
      PreparePayOnchainRequest apiObj, wire_cst_prepare_pay_onchain_request wireObj) {
    cst_api_fill_to_wire_pay_onchain_amount(apiObj.amount, wireObj.amount);
    wireObj.fee_rate_sat_per_vbyte = cst_encode_opt_box_autoadd_u_32(apiObj.feeRateSatPerVbyte);
  }

  @protected
  void cst_api_fill_to_wire_prepare_pay_onchain_response(
      PreparePayOnchainResponse apiObj, wire_cst_prepare_pay_onchain_response wireObj) {
    wireObj.receiver_amount_sat = cst_encode_u_64(apiObj.receiverAmountSat);
    wireObj.claim_fees_sat = cst_encode_u_64(apiObj.claimFeesSat);
    wireObj.total_fees_sat = cst_encode_u_64(apiObj.totalFeesSat);
  }

  @protected
  void cst_api_fill_to_wire_prepare_receive_request(
      PrepareReceiveRequest apiObj, wire_cst_prepare_receive_request wireObj) {
    wireObj.payer_amount_sat = cst_encode_opt_box_autoadd_u_64(apiObj.payerAmountSat);
    wireObj.payment_method = cst_encode_payment_method(apiObj.paymentMethod);
  }

  @protected
  void cst_api_fill_to_wire_prepare_receive_response(
      PrepareReceiveResponse apiObj, wire_cst_prepare_receive_response wireObj) {
    wireObj.payment_method = cst_encode_payment_method(apiObj.paymentMethod);
    wireObj.payer_amount_sat = cst_encode_opt_box_autoadd_u_64(apiObj.payerAmountSat);
    wireObj.fees_sat = cst_encode_u_64(apiObj.feesSat);
  }

  @protected
  void cst_api_fill_to_wire_prepare_refund_request(
      PrepareRefundRequest apiObj, wire_cst_prepare_refund_request wireObj) {
    wireObj.swap_address = cst_encode_String(apiObj.swapAddress);
    wireObj.refund_address = cst_encode_String(apiObj.refundAddress);
    wireObj.fee_rate_sat_per_vbyte = cst_encode_u_32(apiObj.feeRateSatPerVbyte);
  }

  @protected
  void cst_api_fill_to_wire_prepare_refund_response(
      PrepareRefundResponse apiObj, wire_cst_prepare_refund_response wireObj) {
    wireObj.tx_vsize = cst_encode_u_32(apiObj.txVsize);
    wireObj.tx_fee_sat = cst_encode_u_64(apiObj.txFeeSat);
    wireObj.refund_tx_id = cst_encode_opt_String(apiObj.refundTxId);
  }

  @protected
  void cst_api_fill_to_wire_prepare_send_request(
      PrepareSendRequest apiObj, wire_cst_prepare_send_request wireObj) {
    wireObj.destination = cst_encode_String(apiObj.destination);
    wireObj.amount_sat = cst_encode_opt_box_autoadd_u_64(apiObj.amountSat);
  }

  @protected
  void cst_api_fill_to_wire_prepare_send_response(
      PrepareSendResponse apiObj, wire_cst_prepare_send_response wireObj) {
    cst_api_fill_to_wire_send_destination(apiObj.destination, wireObj.destination);
    wireObj.fees_sat = cst_encode_u_64(apiObj.feesSat);
  }

  @protected
  void cst_api_fill_to_wire_rate(Rate apiObj, wire_cst_rate wireObj) {
    wireObj.coin = cst_encode_String(apiObj.coin);
    wireObj.value = cst_encode_f_64(apiObj.value);
  }

  @protected
  void cst_api_fill_to_wire_receive_payment_request(
      ReceivePaymentRequest apiObj, wire_cst_receive_payment_request wireObj) {
    cst_api_fill_to_wire_prepare_receive_response(apiObj.prepareResponse, wireObj.prepare_response);
    wireObj.description = cst_encode_opt_String(apiObj.description);
    wireObj.use_description_hash = cst_encode_opt_box_autoadd_bool(apiObj.useDescriptionHash);
  }

  @protected
  void cst_api_fill_to_wire_receive_payment_response(
      ReceivePaymentResponse apiObj, wire_cst_receive_payment_response wireObj) {
    wireObj.destination = cst_encode_String(apiObj.destination);
  }

  @protected
  void cst_api_fill_to_wire_recommended_fees(RecommendedFees apiObj, wire_cst_recommended_fees wireObj) {
    wireObj.fastest_fee = cst_encode_u_64(apiObj.fastestFee);
    wireObj.half_hour_fee = cst_encode_u_64(apiObj.halfHourFee);
    wireObj.hour_fee = cst_encode_u_64(apiObj.hourFee);
    wireObj.economy_fee = cst_encode_u_64(apiObj.economyFee);
    wireObj.minimum_fee = cst_encode_u_64(apiObj.minimumFee);
  }

  @protected
  void cst_api_fill_to_wire_refund_request(RefundRequest apiObj, wire_cst_refund_request wireObj) {
    wireObj.swap_address = cst_encode_String(apiObj.swapAddress);
    wireObj.refund_address = cst_encode_String(apiObj.refundAddress);
    wireObj.fee_rate_sat_per_vbyte = cst_encode_u_32(apiObj.feeRateSatPerVbyte);
  }

  @protected
  void cst_api_fill_to_wire_refund_response(RefundResponse apiObj, wire_cst_refund_response wireObj) {
    wireObj.refund_tx_id = cst_encode_String(apiObj.refundTxId);
  }

  @protected
  void cst_api_fill_to_wire_refundable_swap(RefundableSwap apiObj, wire_cst_refundable_swap wireObj) {
    wireObj.swap_address = cst_encode_String(apiObj.swapAddress);
    wireObj.timestamp = cst_encode_u_32(apiObj.timestamp);
    wireObj.amount_sat = cst_encode_u_64(apiObj.amountSat);
  }

  @protected
  void cst_api_fill_to_wire_restore_request(RestoreRequest apiObj, wire_cst_restore_request wireObj) {
    wireObj.backup_path = cst_encode_opt_String(apiObj.backupPath);
  }

  @protected
  void cst_api_fill_to_wire_route_hint(RouteHint apiObj, wire_cst_route_hint wireObj) {
    wireObj.hops = cst_encode_list_route_hint_hop(apiObj.hops);
  }

  @protected
  void cst_api_fill_to_wire_route_hint_hop(RouteHintHop apiObj, wire_cst_route_hint_hop wireObj) {
    wireObj.src_node_id = cst_encode_String(apiObj.srcNodeId);
    wireObj.short_channel_id = cst_encode_String(apiObj.shortChannelId);
    wireObj.fees_base_msat = cst_encode_u_32(apiObj.feesBaseMsat);
    wireObj.fees_proportional_millionths = cst_encode_u_32(apiObj.feesProportionalMillionths);
    wireObj.cltv_expiry_delta = cst_encode_u_64(apiObj.cltvExpiryDelta);
    wireObj.htlc_minimum_msat = cst_encode_opt_box_autoadd_u_64(apiObj.htlcMinimumMsat);
    wireObj.htlc_maximum_msat = cst_encode_opt_box_autoadd_u_64(apiObj.htlcMaximumMsat);
  }

  @protected
  void cst_api_fill_to_wire_sdk_error(SdkError apiObj, wire_cst_sdk_error wireObj) {
    if (apiObj is SdkError_AlreadyStarted) {
      wireObj.tag = 0;
      return;
    }
    if (apiObj is SdkError_Generic) {
      var pre_err = cst_encode_String(apiObj.err);
      wireObj.tag = 1;
      wireObj.kind.Generic.err = pre_err;
      return;
    }
    if (apiObj is SdkError_NotStarted) {
      wireObj.tag = 2;
      return;
    }
    if (apiObj is SdkError_ServiceConnectivity) {
      var pre_err = cst_encode_String(apiObj.err);
      wireObj.tag = 3;
      wireObj.kind.ServiceConnectivity.err = pre_err;
      return;
    }
  }

  @protected
  void cst_api_fill_to_wire_sdk_event(SdkEvent apiObj, wire_cst_sdk_event wireObj) {
    if (apiObj is SdkEvent_PaymentFailed) {
      var pre_details = cst_encode_box_autoadd_payment(apiObj.details);
      wireObj.tag = 0;
      wireObj.kind.PaymentFailed.details = pre_details;
      return;
    }
    if (apiObj is SdkEvent_PaymentPending) {
      var pre_details = cst_encode_box_autoadd_payment(apiObj.details);
      wireObj.tag = 1;
      wireObj.kind.PaymentPending.details = pre_details;
      return;
    }
    if (apiObj is SdkEvent_PaymentRefunded) {
      var pre_details = cst_encode_box_autoadd_payment(apiObj.details);
      wireObj.tag = 2;
      wireObj.kind.PaymentRefunded.details = pre_details;
      return;
    }
    if (apiObj is SdkEvent_PaymentRefundPending) {
      var pre_details = cst_encode_box_autoadd_payment(apiObj.details);
      wireObj.tag = 3;
      wireObj.kind.PaymentRefundPending.details = pre_details;
      return;
    }
    if (apiObj is SdkEvent_PaymentSucceeded) {
      var pre_details = cst_encode_box_autoadd_payment(apiObj.details);
      wireObj.tag = 4;
      wireObj.kind.PaymentSucceeded.details = pre_details;
      return;
    }
    if (apiObj is SdkEvent_PaymentWaitingConfirmation) {
      var pre_details = cst_encode_box_autoadd_payment(apiObj.details);
      wireObj.tag = 5;
      wireObj.kind.PaymentWaitingConfirmation.details = pre_details;
      return;
    }
    if (apiObj is SdkEvent_Synced) {
      wireObj.tag = 6;
      return;
    }
  }

  @protected
  void cst_api_fill_to_wire_send_destination(SendDestination apiObj, wire_cst_send_destination wireObj) {
    if (apiObj is SendDestination_LiquidAddress) {
      var pre_address_data = cst_encode_box_autoadd_liquid_address_data(apiObj.addressData);
      wireObj.tag = 0;
      wireObj.kind.LiquidAddress.address_data = pre_address_data;
      return;
    }
    if (apiObj is SendDestination_Bolt11) {
      var pre_invoice = cst_encode_box_autoadd_ln_invoice(apiObj.invoice);
      wireObj.tag = 1;
      wireObj.kind.Bolt11.invoice = pre_invoice;
      return;
    }
  }

  @protected
  void cst_api_fill_to_wire_send_payment_request(
      SendPaymentRequest apiObj, wire_cst_send_payment_request wireObj) {
    cst_api_fill_to_wire_prepare_send_response(apiObj.prepareResponse, wireObj.prepare_response);
  }

  @protected
  void cst_api_fill_to_wire_send_payment_response(
      SendPaymentResponse apiObj, wire_cst_send_payment_response wireObj) {
    cst_api_fill_to_wire_payment(apiObj.payment, wireObj.payment);
  }

  @protected
  void cst_api_fill_to_wire_sign_message_request(
      SignMessageRequest apiObj, wire_cst_sign_message_request wireObj) {
    wireObj.message = cst_encode_String(apiObj.message);
  }

  @protected
  void cst_api_fill_to_wire_sign_message_response(
      SignMessageResponse apiObj, wire_cst_sign_message_response wireObj) {
    wireObj.signature = cst_encode_String(apiObj.signature);
  }

  @protected
  void cst_api_fill_to_wire_success_action_processed(
      SuccessActionProcessed apiObj, wire_cst_success_action_processed wireObj) {
    if (apiObj is SuccessActionProcessed_Aes) {
      var pre_result = cst_encode_box_autoadd_aes_success_action_data_result(apiObj.result);
      wireObj.tag = 0;
      wireObj.kind.Aes.result = pre_result;
      return;
    }
    if (apiObj is SuccessActionProcessed_Message) {
      var pre_data = cst_encode_box_autoadd_message_success_action_data(apiObj.data);
      wireObj.tag = 1;
      wireObj.kind.Message.data = pre_data;
      return;
    }
    if (apiObj is SuccessActionProcessed_Url) {
      var pre_data = cst_encode_box_autoadd_url_success_action_data(apiObj.data);
      wireObj.tag = 2;
      wireObj.kind.Url.data = pre_data;
      return;
    }
  }

  @protected
  void cst_api_fill_to_wire_symbol(Symbol apiObj, wire_cst_symbol wireObj) {
    wireObj.grapheme = cst_encode_opt_String(apiObj.grapheme);
    wireObj.template_ = cst_encode_opt_String(apiObj.template);
    wireObj.rtl = cst_encode_opt_box_autoadd_bool(apiObj.rtl);
    wireObj.position = cst_encode_opt_box_autoadd_u_32(apiObj.position);
  }

  @protected
  void cst_api_fill_to_wire_url_success_action_data(
      UrlSuccessActionData apiObj, wire_cst_url_success_action_data wireObj) {
    wireObj.description = cst_encode_String(apiObj.description);
    wireObj.url = cst_encode_String(apiObj.url);
    wireObj.matches_callback_domain = cst_encode_bool(apiObj.matchesCallbackDomain);
  }

  @protected
  int cst_encode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerBindingLiquidSdk(
      BindingLiquidSdk raw);

  @protected
  int cst_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerBindingLiquidSdk(
      BindingLiquidSdk raw);

  @protected
  int cst_encode_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerBindingLiquidSdk(
      BindingLiquidSdk raw);

  @protected
  bool cst_encode_bool(bool raw);

  @protected
  int cst_encode_buy_bitcoin_provider(BuyBitcoinProvider raw);

  @protected
  double cst_encode_f_64(double raw);

  @protected
  int cst_encode_i_32(int raw);

  @protected
  int cst_encode_liquid_network(LiquidNetwork raw);

  @protected
  int cst_encode_network(Network raw);

  @protected
  int cst_encode_payment_method(PaymentMethod raw);

  @protected
  int cst_encode_payment_state(PaymentState raw);

  @protected
  int cst_encode_payment_type(PaymentType raw);

  @protected
  int cst_encode_u_16(int raw);

  @protected
  int cst_encode_u_32(int raw);

  @protected
  int cst_encode_u_8(int raw);

  @protected
  void cst_encode_unit(void raw);

  @protected
  void sse_encode_AnyhowException(AnyhowException self, SseSerializer serializer);

  @protected
  void sse_encode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerBindingLiquidSdk(
      BindingLiquidSdk self, SseSerializer serializer);

  @protected
  void sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerBindingLiquidSdk(
      BindingLiquidSdk self, SseSerializer serializer);

  @protected
  void sse_encode_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerBindingLiquidSdk(
      BindingLiquidSdk self, SseSerializer serializer);

  @protected
  void sse_encode_StreamSink_log_entry_Dco(RustStreamSink<LogEntry> self, SseSerializer serializer);

  @protected
  void sse_encode_StreamSink_sdk_event_Dco(RustStreamSink<SdkEvent> self, SseSerializer serializer);

  @protected
  void sse_encode_String(String self, SseSerializer serializer);

  @protected
  void sse_encode_aes_success_action_data_decrypted(
      AesSuccessActionDataDecrypted self, SseSerializer serializer);

  @protected
  void sse_encode_aes_success_action_data_result(AesSuccessActionDataResult self, SseSerializer serializer);

  @protected
  void sse_encode_backup_request(BackupRequest self, SseSerializer serializer);

  @protected
  void sse_encode_binding_event_listener(BindingEventListener self, SseSerializer serializer);

  @protected
  void sse_encode_bitcoin_address_data(BitcoinAddressData self, SseSerializer serializer);

  @protected
  void sse_encode_bool(bool self, SseSerializer serializer);

  @protected
  void sse_encode_box_autoadd_aes_success_action_data_decrypted(
      AesSuccessActionDataDecrypted self, SseSerializer serializer);

  @protected
  void sse_encode_box_autoadd_aes_success_action_data_result(
      AesSuccessActionDataResult self, SseSerializer serializer);

  @protected
  void sse_encode_box_autoadd_backup_request(BackupRequest self, SseSerializer serializer);

  @protected
  void sse_encode_box_autoadd_binding_event_listener(BindingEventListener self, SseSerializer serializer);

  @protected
  void sse_encode_box_autoadd_bitcoin_address_data(BitcoinAddressData self, SseSerializer serializer);

  @protected
  void sse_encode_box_autoadd_bool(bool self, SseSerializer serializer);

  @protected
  void sse_encode_box_autoadd_buy_bitcoin_request(BuyBitcoinRequest self, SseSerializer serializer);

  @protected
  void sse_encode_box_autoadd_check_message_request(CheckMessageRequest self, SseSerializer serializer);

  @protected
  void sse_encode_box_autoadd_connect_request(ConnectRequest self, SseSerializer serializer);

  @protected
  void sse_encode_box_autoadd_i_64(PlatformInt64 self, SseSerializer serializer);

  @protected
  void sse_encode_box_autoadd_liquid_address_data(LiquidAddressData self, SseSerializer serializer);

  @protected
  void sse_encode_box_autoadd_list_payments_request(ListPaymentsRequest self, SseSerializer serializer);

  @protected
  void sse_encode_box_autoadd_ln_invoice(LNInvoice self, SseSerializer serializer);

  @protected
  void sse_encode_box_autoadd_ln_url_auth_request_data(LnUrlAuthRequestData self, SseSerializer serializer);

  @protected
  void sse_encode_box_autoadd_ln_url_error_data(LnUrlErrorData self, SseSerializer serializer);

  @protected
  void sse_encode_box_autoadd_ln_url_pay_error_data(LnUrlPayErrorData self, SseSerializer serializer);

  @protected
  void sse_encode_box_autoadd_ln_url_pay_request(LnUrlPayRequest self, SseSerializer serializer);

  @protected
  void sse_encode_box_autoadd_ln_url_pay_request_data(LnUrlPayRequestData self, SseSerializer serializer);

  @protected
  void sse_encode_box_autoadd_ln_url_pay_success_data(LnUrlPaySuccessData self, SseSerializer serializer);

  @protected
  void sse_encode_box_autoadd_ln_url_withdraw_request(LnUrlWithdrawRequest self, SseSerializer serializer);

  @protected
  void sse_encode_box_autoadd_ln_url_withdraw_request_data(
      LnUrlWithdrawRequestData self, SseSerializer serializer);

  @protected
  void sse_encode_box_autoadd_ln_url_withdraw_success_data(
      LnUrlWithdrawSuccessData self, SseSerializer serializer);

  @protected
  void sse_encode_box_autoadd_message_success_action_data(
      MessageSuccessActionData self, SseSerializer serializer);

  @protected
  void sse_encode_box_autoadd_pay_onchain_request(PayOnchainRequest self, SseSerializer serializer);

  @protected
  void sse_encode_box_autoadd_payment(Payment self, SseSerializer serializer);

  @protected
  void sse_encode_box_autoadd_prepare_buy_bitcoin_request(
      PrepareBuyBitcoinRequest self, SseSerializer serializer);

  @protected
  void sse_encode_box_autoadd_prepare_pay_onchain_request(
      PreparePayOnchainRequest self, SseSerializer serializer);

  @protected
  void sse_encode_box_autoadd_prepare_receive_request(PrepareReceiveRequest self, SseSerializer serializer);

  @protected
  void sse_encode_box_autoadd_prepare_refund_request(PrepareRefundRequest self, SseSerializer serializer);

  @protected
  void sse_encode_box_autoadd_prepare_send_request(PrepareSendRequest self, SseSerializer serializer);

  @protected
  void sse_encode_box_autoadd_receive_payment_request(ReceivePaymentRequest self, SseSerializer serializer);

  @protected
  void sse_encode_box_autoadd_refund_request(RefundRequest self, SseSerializer serializer);

  @protected
  void sse_encode_box_autoadd_restore_request(RestoreRequest self, SseSerializer serializer);

  @protected
  void sse_encode_box_autoadd_sdk_event(SdkEvent self, SseSerializer serializer);

  @protected
  void sse_encode_box_autoadd_send_payment_request(SendPaymentRequest self, SseSerializer serializer);

  @protected
  void sse_encode_box_autoadd_sign_message_request(SignMessageRequest self, SseSerializer serializer);

  @protected
  void sse_encode_box_autoadd_success_action_processed(SuccessActionProcessed self, SseSerializer serializer);

  @protected
  void sse_encode_box_autoadd_symbol(Symbol self, SseSerializer serializer);

  @protected
  void sse_encode_box_autoadd_u_32(int self, SseSerializer serializer);

  @protected
  void sse_encode_box_autoadd_u_64(BigInt self, SseSerializer serializer);

  @protected
  void sse_encode_box_autoadd_url_success_action_data(UrlSuccessActionData self, SseSerializer serializer);

  @protected
  void sse_encode_buy_bitcoin_provider(BuyBitcoinProvider self, SseSerializer serializer);

  @protected
  void sse_encode_buy_bitcoin_request(BuyBitcoinRequest self, SseSerializer serializer);

  @protected
  void sse_encode_check_message_request(CheckMessageRequest self, SseSerializer serializer);

  @protected
  void sse_encode_check_message_response(CheckMessageResponse self, SseSerializer serializer);

  @protected
  void sse_encode_config(Config self, SseSerializer serializer);

  @protected
  void sse_encode_connect_request(ConnectRequest self, SseSerializer serializer);

  @protected
  void sse_encode_currency_info(CurrencyInfo self, SseSerializer serializer);

  @protected
  void sse_encode_f_64(double self, SseSerializer serializer);

  @protected
  void sse_encode_fiat_currency(FiatCurrency self, SseSerializer serializer);

  @protected
  void sse_encode_get_info_response(GetInfoResponse self, SseSerializer serializer);

  @protected
  void sse_encode_i_32(int self, SseSerializer serializer);

  @protected
  void sse_encode_i_64(PlatformInt64 self, SseSerializer serializer);

  @protected
  void sse_encode_input_type(InputType self, SseSerializer serializer);

  @protected
  void sse_encode_lightning_payment_limits_response(
      LightningPaymentLimitsResponse self, SseSerializer serializer);

  @protected
  void sse_encode_limits(Limits self, SseSerializer serializer);

  @protected
  void sse_encode_liquid_address_data(LiquidAddressData self, SseSerializer serializer);

  @protected
  void sse_encode_liquid_network(LiquidNetwork self, SseSerializer serializer);

  @protected
  void sse_encode_list_fiat_currency(List<FiatCurrency> self, SseSerializer serializer);

  @protected
  void sse_encode_list_locale_overrides(List<LocaleOverrides> self, SseSerializer serializer);

  @protected
  void sse_encode_list_localized_name(List<LocalizedName> self, SseSerializer serializer);

  @protected
  void sse_encode_list_payment(List<Payment> self, SseSerializer serializer);

  @protected
  void sse_encode_list_payment_type(List<PaymentType> self, SseSerializer serializer);

  @protected
  void sse_encode_list_payments_request(ListPaymentsRequest self, SseSerializer serializer);

  @protected
  void sse_encode_list_prim_u_8_strict(Uint8List self, SseSerializer serializer);

  @protected
  void sse_encode_list_rate(List<Rate> self, SseSerializer serializer);

  @protected
  void sse_encode_list_refundable_swap(List<RefundableSwap> self, SseSerializer serializer);

  @protected
  void sse_encode_list_route_hint(List<RouteHint> self, SseSerializer serializer);

  @protected
  void sse_encode_list_route_hint_hop(List<RouteHintHop> self, SseSerializer serializer);

  @protected
  void sse_encode_ln_invoice(LNInvoice self, SseSerializer serializer);

  @protected
  void sse_encode_ln_url_auth_error(LnUrlAuthError self, SseSerializer serializer);

  @protected
  void sse_encode_ln_url_auth_request_data(LnUrlAuthRequestData self, SseSerializer serializer);

  @protected
  void sse_encode_ln_url_callback_status(LnUrlCallbackStatus self, SseSerializer serializer);

  @protected
  void sse_encode_ln_url_error_data(LnUrlErrorData self, SseSerializer serializer);

  @protected
  void sse_encode_ln_url_pay_error(LnUrlPayError self, SseSerializer serializer);

  @protected
  void sse_encode_ln_url_pay_error_data(LnUrlPayErrorData self, SseSerializer serializer);

  @protected
  void sse_encode_ln_url_pay_request(LnUrlPayRequest self, SseSerializer serializer);

  @protected
  void sse_encode_ln_url_pay_request_data(LnUrlPayRequestData self, SseSerializer serializer);

  @protected
  void sse_encode_ln_url_pay_result(LnUrlPayResult self, SseSerializer serializer);

  @protected
  void sse_encode_ln_url_pay_success_data(LnUrlPaySuccessData self, SseSerializer serializer);

  @protected
  void sse_encode_ln_url_withdraw_error(LnUrlWithdrawError self, SseSerializer serializer);

  @protected
  void sse_encode_ln_url_withdraw_request(LnUrlWithdrawRequest self, SseSerializer serializer);

  @protected
  void sse_encode_ln_url_withdraw_request_data(LnUrlWithdrawRequestData self, SseSerializer serializer);

  @protected
  void sse_encode_ln_url_withdraw_result(LnUrlWithdrawResult self, SseSerializer serializer);

  @protected
  void sse_encode_ln_url_withdraw_success_data(LnUrlWithdrawSuccessData self, SseSerializer serializer);

  @protected
  void sse_encode_locale_overrides(LocaleOverrides self, SseSerializer serializer);

  @protected
  void sse_encode_localized_name(LocalizedName self, SseSerializer serializer);

  @protected
  void sse_encode_log_entry(LogEntry self, SseSerializer serializer);

  @protected
  void sse_encode_message_success_action_data(MessageSuccessActionData self, SseSerializer serializer);

  @protected
  void sse_encode_network(Network self, SseSerializer serializer);

  @protected
  void sse_encode_onchain_payment_limits_response(
      OnchainPaymentLimitsResponse self, SseSerializer serializer);

  @protected
  void sse_encode_opt_String(String? self, SseSerializer serializer);

  @protected
  void sse_encode_opt_box_autoadd_bool(bool? self, SseSerializer serializer);

  @protected
  void sse_encode_opt_box_autoadd_i_64(PlatformInt64? self, SseSerializer serializer);

  @protected
  void sse_encode_opt_box_autoadd_success_action_processed(
      SuccessActionProcessed? self, SseSerializer serializer);

  @protected
  void sse_encode_opt_box_autoadd_symbol(Symbol? self, SseSerializer serializer);

  @protected
  void sse_encode_opt_box_autoadd_u_32(int? self, SseSerializer serializer);

  @protected
  void sse_encode_opt_box_autoadd_u_64(BigInt? self, SseSerializer serializer);

  @protected
  void sse_encode_opt_list_payment_type(List<PaymentType>? self, SseSerializer serializer);

  @protected
  void sse_encode_pay_onchain_amount(PayOnchainAmount self, SseSerializer serializer);

  @protected
  void sse_encode_pay_onchain_request(PayOnchainRequest self, SseSerializer serializer);

  @protected
  void sse_encode_payment(Payment self, SseSerializer serializer);

  @protected
  void sse_encode_payment_details(PaymentDetails self, SseSerializer serializer);

  @protected
  void sse_encode_payment_error(PaymentError self, SseSerializer serializer);

  @protected
  void sse_encode_payment_method(PaymentMethod self, SseSerializer serializer);

  @protected
  void sse_encode_payment_state(PaymentState self, SseSerializer serializer);

  @protected
  void sse_encode_payment_type(PaymentType self, SseSerializer serializer);

  @protected
  void sse_encode_prepare_buy_bitcoin_request(PrepareBuyBitcoinRequest self, SseSerializer serializer);

  @protected
  void sse_encode_prepare_buy_bitcoin_response(PrepareBuyBitcoinResponse self, SseSerializer serializer);

  @protected
  void sse_encode_prepare_pay_onchain_request(PreparePayOnchainRequest self, SseSerializer serializer);

  @protected
  void sse_encode_prepare_pay_onchain_response(PreparePayOnchainResponse self, SseSerializer serializer);

  @protected
  void sse_encode_prepare_receive_request(PrepareReceiveRequest self, SseSerializer serializer);

  @protected
  void sse_encode_prepare_receive_response(PrepareReceiveResponse self, SseSerializer serializer);

  @protected
  void sse_encode_prepare_refund_request(PrepareRefundRequest self, SseSerializer serializer);

  @protected
  void sse_encode_prepare_refund_response(PrepareRefundResponse self, SseSerializer serializer);

  @protected
  void sse_encode_prepare_send_request(PrepareSendRequest self, SseSerializer serializer);

  @protected
  void sse_encode_prepare_send_response(PrepareSendResponse self, SseSerializer serializer);

  @protected
  void sse_encode_rate(Rate self, SseSerializer serializer);

  @protected
  void sse_encode_receive_payment_request(ReceivePaymentRequest self, SseSerializer serializer);

  @protected
  void sse_encode_receive_payment_response(ReceivePaymentResponse self, SseSerializer serializer);

  @protected
  void sse_encode_recommended_fees(RecommendedFees self, SseSerializer serializer);

  @protected
  void sse_encode_refund_request(RefundRequest self, SseSerializer serializer);

  @protected
  void sse_encode_refund_response(RefundResponse self, SseSerializer serializer);

  @protected
  void sse_encode_refundable_swap(RefundableSwap self, SseSerializer serializer);

  @protected
  void sse_encode_restore_request(RestoreRequest self, SseSerializer serializer);

  @protected
  void sse_encode_route_hint(RouteHint self, SseSerializer serializer);

  @protected
  void sse_encode_route_hint_hop(RouteHintHop self, SseSerializer serializer);

  @protected
  void sse_encode_sdk_error(SdkError self, SseSerializer serializer);

  @protected
  void sse_encode_sdk_event(SdkEvent self, SseSerializer serializer);

  @protected
  void sse_encode_send_destination(SendDestination self, SseSerializer serializer);

  @protected
  void sse_encode_send_payment_request(SendPaymentRequest self, SseSerializer serializer);

  @protected
  void sse_encode_send_payment_response(SendPaymentResponse self, SseSerializer serializer);

  @protected
  void sse_encode_sign_message_request(SignMessageRequest self, SseSerializer serializer);

  @protected
  void sse_encode_sign_message_response(SignMessageResponse self, SseSerializer serializer);

  @protected
  void sse_encode_success_action_processed(SuccessActionProcessed self, SseSerializer serializer);

  @protected
  void sse_encode_symbol(Symbol self, SseSerializer serializer);

  @protected
  void sse_encode_u_16(int self, SseSerializer serializer);

  @protected
  void sse_encode_u_32(int self, SseSerializer serializer);

  @protected
  void sse_encode_u_64(BigInt self, SseSerializer serializer);

  @protected
  void sse_encode_u_8(int self, SseSerializer serializer);

  @protected
  void sse_encode_unit(void self, SseSerializer serializer);

  @protected
  void sse_encode_url_success_action_data(UrlSuccessActionData self, SseSerializer serializer);

  @protected
  void sse_encode_usize(BigInt self, SseSerializer serializer);
}

// Section: wire_class

// ignore_for_file: camel_case_types, non_constant_identifier_names, avoid_positional_boolean_parameters, annotate_overrides, constant_identifier_names
// AUTO GENERATED FILE, DO NOT EDIT.
//
// Generated by `package:ffigen`.
// ignore_for_file: type=lint

/// generated by flutter_rust_bridge
class RustLibWire implements BaseWire {
  factory RustLibWire.fromExternalLibrary(ExternalLibrary lib) => RustLibWire(lib.ffiDynamicLibrary);

  /// Holds the symbol lookup function.
  final ffi.Pointer<T> Function<T extends ffi.NativeType>(String symbolName) _lookup;

  /// The symbols are looked up in [dynamicLibrary].
  RustLibWire(ffi.DynamicLibrary dynamicLibrary) : _lookup = dynamicLibrary.lookup;

  /// The symbols are looked up with [lookup].
  RustLibWire.fromLookup(ffi.Pointer<T> Function<T extends ffi.NativeType>(String symbolName) lookup)
      : _lookup = lookup;

  void store_dart_post_cobject(
    DartPostCObjectFnType ptr,
  ) {
    return _store_dart_post_cobject(
      ptr,
    );
  }

  late final _store_dart_post_cobjectPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(DartPostCObjectFnType)>>('store_dart_post_cobject');
  late final _store_dart_post_cobject =
      _store_dart_post_cobjectPtr.asFunction<void Function(DartPostCObjectFnType)>();

  void wire__crate__bindings__BindingLiquidSdk_add_event_listener(
    int port_,
    int that,
    ffi.Pointer<wire_cst_list_prim_u_8_strict> listener,
  ) {
    return _wire__crate__bindings__BindingLiquidSdk_add_event_listener(
      port_,
      that,
      listener,
    );
  }

  late final _wire__crate__bindings__BindingLiquidSdk_add_event_listenerPtr = _lookup<
          ffi.NativeFunction<
              ffi.Void Function(ffi.Int64, ffi.UintPtr, ffi.Pointer<wire_cst_list_prim_u_8_strict>)>>(
      'frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_add_event_listener');
  late final _wire__crate__bindings__BindingLiquidSdk_add_event_listener =
      _wire__crate__bindings__BindingLiquidSdk_add_event_listenerPtr
          .asFunction<void Function(int, int, ffi.Pointer<wire_cst_list_prim_u_8_strict>)>();

  WireSyncRust2DartDco wire__crate__bindings__BindingLiquidSdk_backup(
    int that,
    ffi.Pointer<wire_cst_backup_request> req,
  ) {
    return _wire__crate__bindings__BindingLiquidSdk_backup(
      that,
      req,
    );
  }

  late final _wire__crate__bindings__BindingLiquidSdk_backupPtr = _lookup<
          ffi
          .NativeFunction<WireSyncRust2DartDco Function(ffi.UintPtr, ffi.Pointer<wire_cst_backup_request>)>>(
      'frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_backup');
  late final _wire__crate__bindings__BindingLiquidSdk_backup =
      _wire__crate__bindings__BindingLiquidSdk_backupPtr
          .asFunction<WireSyncRust2DartDco Function(int, ffi.Pointer<wire_cst_backup_request>)>();

  void wire__crate__bindings__BindingLiquidSdk_buy_bitcoin(
    int port_,
    int that,
    ffi.Pointer<wire_cst_buy_bitcoin_request> req,
  ) {
    return _wire__crate__bindings__BindingLiquidSdk_buy_bitcoin(
      port_,
      that,
      req,
    );
  }

  late final _wire__crate__bindings__BindingLiquidSdk_buy_bitcoinPtr = _lookup<
          ffi.NativeFunction<
              ffi.Void Function(ffi.Int64, ffi.UintPtr, ffi.Pointer<wire_cst_buy_bitcoin_request>)>>(
      'frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_buy_bitcoin');
  late final _wire__crate__bindings__BindingLiquidSdk_buy_bitcoin =
      _wire__crate__bindings__BindingLiquidSdk_buy_bitcoinPtr
          .asFunction<void Function(int, int, ffi.Pointer<wire_cst_buy_bitcoin_request>)>();

  WireSyncRust2DartDco wire__crate__bindings__BindingLiquidSdk_check_message(
    int that,
    ffi.Pointer<wire_cst_check_message_request> req,
  ) {
    return _wire__crate__bindings__BindingLiquidSdk_check_message(
      that,
      req,
    );
  }

  late final _wire__crate__bindings__BindingLiquidSdk_check_messagePtr = _lookup<
          ffi.NativeFunction<
              WireSyncRust2DartDco Function(ffi.UintPtr, ffi.Pointer<wire_cst_check_message_request>)>>(
      'frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_check_message');
  late final _wire__crate__bindings__BindingLiquidSdk_check_message =
      _wire__crate__bindings__BindingLiquidSdk_check_messagePtr
          .asFunction<WireSyncRust2DartDco Function(int, ffi.Pointer<wire_cst_check_message_request>)>();

  void wire__crate__bindings__BindingLiquidSdk_disconnect(
    int port_,
    int that,
  ) {
    return _wire__crate__bindings__BindingLiquidSdk_disconnect(
      port_,
      that,
    );
  }

  late final _wire__crate__bindings__BindingLiquidSdk_disconnectPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Int64, ffi.UintPtr)>>(
          'frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_disconnect');
  late final _wire__crate__bindings__BindingLiquidSdk_disconnect =
      _wire__crate__bindings__BindingLiquidSdk_disconnectPtr.asFunction<void Function(int, int)>();

  WireSyncRust2DartDco wire__crate__bindings__BindingLiquidSdk_empty_wallet_cache(
    int that,
  ) {
    return _wire__crate__bindings__BindingLiquidSdk_empty_wallet_cache(
      that,
    );
  }

  late final _wire__crate__bindings__BindingLiquidSdk_empty_wallet_cachePtr =
      _lookup<ffi.NativeFunction<WireSyncRust2DartDco Function(ffi.UintPtr)>>(
          'frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_empty_wallet_cache');
  late final _wire__crate__bindings__BindingLiquidSdk_empty_wallet_cache =
      _wire__crate__bindings__BindingLiquidSdk_empty_wallet_cachePtr
          .asFunction<WireSyncRust2DartDco Function(int)>();

  void wire__crate__bindings__BindingLiquidSdk_fetch_fiat_rates(
    int port_,
    int that,
  ) {
    return _wire__crate__bindings__BindingLiquidSdk_fetch_fiat_rates(
      port_,
      that,
    );
  }

  late final _wire__crate__bindings__BindingLiquidSdk_fetch_fiat_ratesPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Int64, ffi.UintPtr)>>(
          'frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_fetch_fiat_rates');
  late final _wire__crate__bindings__BindingLiquidSdk_fetch_fiat_rates =
      _wire__crate__bindings__BindingLiquidSdk_fetch_fiat_ratesPtr.asFunction<void Function(int, int)>();

  void wire__crate__bindings__BindingLiquidSdk_fetch_lightning_limits(
    int port_,
    int that,
  ) {
    return _wire__crate__bindings__BindingLiquidSdk_fetch_lightning_limits(
      port_,
      that,
    );
  }

  late final _wire__crate__bindings__BindingLiquidSdk_fetch_lightning_limitsPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Int64, ffi.UintPtr)>>(
          'frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_fetch_lightning_limits');
  late final _wire__crate__bindings__BindingLiquidSdk_fetch_lightning_limits =
      _wire__crate__bindings__BindingLiquidSdk_fetch_lightning_limitsPtr
          .asFunction<void Function(int, int)>();

  void wire__crate__bindings__BindingLiquidSdk_fetch_onchain_limits(
    int port_,
    int that,
  ) {
    return _wire__crate__bindings__BindingLiquidSdk_fetch_onchain_limits(
      port_,
      that,
    );
  }

  late final _wire__crate__bindings__BindingLiquidSdk_fetch_onchain_limitsPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Int64, ffi.UintPtr)>>(
          'frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_fetch_onchain_limits');
  late final _wire__crate__bindings__BindingLiquidSdk_fetch_onchain_limits =
      _wire__crate__bindings__BindingLiquidSdk_fetch_onchain_limitsPtr.asFunction<void Function(int, int)>();

  void wire__crate__bindings__BindingLiquidSdk_get_info(
    int port_,
    int that,
  ) {
    return _wire__crate__bindings__BindingLiquidSdk_get_info(
      port_,
      that,
    );
  }

  late final _wire__crate__bindings__BindingLiquidSdk_get_infoPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Int64, ffi.UintPtr)>>(
          'frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_get_info');
  late final _wire__crate__bindings__BindingLiquidSdk_get_info =
      _wire__crate__bindings__BindingLiquidSdk_get_infoPtr.asFunction<void Function(int, int)>();

  void wire__crate__bindings__BindingLiquidSdk_list_fiat_currencies(
    int port_,
    int that,
  ) {
    return _wire__crate__bindings__BindingLiquidSdk_list_fiat_currencies(
      port_,
      that,
    );
  }

  late final _wire__crate__bindings__BindingLiquidSdk_list_fiat_currenciesPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Int64, ffi.UintPtr)>>(
          'frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_list_fiat_currencies');
  late final _wire__crate__bindings__BindingLiquidSdk_list_fiat_currencies =
      _wire__crate__bindings__BindingLiquidSdk_list_fiat_currenciesPtr.asFunction<void Function(int, int)>();

  void wire__crate__bindings__BindingLiquidSdk_list_payments(
    int port_,
    int that,
    ffi.Pointer<wire_cst_list_payments_request> req,
  ) {
    return _wire__crate__bindings__BindingLiquidSdk_list_payments(
      port_,
      that,
      req,
    );
  }

  late final _wire__crate__bindings__BindingLiquidSdk_list_paymentsPtr = _lookup<
          ffi.NativeFunction<
              ffi.Void Function(ffi.Int64, ffi.UintPtr, ffi.Pointer<wire_cst_list_payments_request>)>>(
      'frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_list_payments');
  late final _wire__crate__bindings__BindingLiquidSdk_list_payments =
      _wire__crate__bindings__BindingLiquidSdk_list_paymentsPtr
          .asFunction<void Function(int, int, ffi.Pointer<wire_cst_list_payments_request>)>();

  void wire__crate__bindings__BindingLiquidSdk_list_refundables(
    int port_,
    int that,
  ) {
    return _wire__crate__bindings__BindingLiquidSdk_list_refundables(
      port_,
      that,
    );
  }

  late final _wire__crate__bindings__BindingLiquidSdk_list_refundablesPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Int64, ffi.UintPtr)>>(
          'frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_list_refundables');
  late final _wire__crate__bindings__BindingLiquidSdk_list_refundables =
      _wire__crate__bindings__BindingLiquidSdk_list_refundablesPtr.asFunction<void Function(int, int)>();

  void wire__crate__bindings__BindingLiquidSdk_lnurl_auth(
    int port_,
    int that,
    ffi.Pointer<wire_cst_ln_url_auth_request_data> req_data,
  ) {
    return _wire__crate__bindings__BindingLiquidSdk_lnurl_auth(
      port_,
      that,
      req_data,
    );
  }

  late final _wire__crate__bindings__BindingLiquidSdk_lnurl_authPtr = _lookup<
          ffi.NativeFunction<
              ffi.Void Function(ffi.Int64, ffi.UintPtr, ffi.Pointer<wire_cst_ln_url_auth_request_data>)>>(
      'frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_lnurl_auth');
  late final _wire__crate__bindings__BindingLiquidSdk_lnurl_auth =
      _wire__crate__bindings__BindingLiquidSdk_lnurl_authPtr
          .asFunction<void Function(int, int, ffi.Pointer<wire_cst_ln_url_auth_request_data>)>();

  void wire__crate__bindings__BindingLiquidSdk_lnurl_pay(
    int port_,
    int that,
    ffi.Pointer<wire_cst_ln_url_pay_request> req,
  ) {
    return _wire__crate__bindings__BindingLiquidSdk_lnurl_pay(
      port_,
      that,
      req,
    );
  }

  late final _wire__crate__bindings__BindingLiquidSdk_lnurl_payPtr = _lookup<
          ffi.NativeFunction<
              ffi.Void Function(ffi.Int64, ffi.UintPtr, ffi.Pointer<wire_cst_ln_url_pay_request>)>>(
      'frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_lnurl_pay');
  late final _wire__crate__bindings__BindingLiquidSdk_lnurl_pay =
      _wire__crate__bindings__BindingLiquidSdk_lnurl_payPtr
          .asFunction<void Function(int, int, ffi.Pointer<wire_cst_ln_url_pay_request>)>();

  void wire__crate__bindings__BindingLiquidSdk_lnurl_withdraw(
    int port_,
    int that,
    ffi.Pointer<wire_cst_ln_url_withdraw_request> req,
  ) {
    return _wire__crate__bindings__BindingLiquidSdk_lnurl_withdraw(
      port_,
      that,
      req,
    );
  }

  late final _wire__crate__bindings__BindingLiquidSdk_lnurl_withdrawPtr = _lookup<
          ffi.NativeFunction<
              ffi.Void Function(ffi.Int64, ffi.UintPtr, ffi.Pointer<wire_cst_ln_url_withdraw_request>)>>(
      'frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_lnurl_withdraw');
  late final _wire__crate__bindings__BindingLiquidSdk_lnurl_withdraw =
      _wire__crate__bindings__BindingLiquidSdk_lnurl_withdrawPtr
          .asFunction<void Function(int, int, ffi.Pointer<wire_cst_ln_url_withdraw_request>)>();

  void wire__crate__bindings__BindingLiquidSdk_pay_onchain(
    int port_,
    int that,
    ffi.Pointer<wire_cst_pay_onchain_request> req,
  ) {
    return _wire__crate__bindings__BindingLiquidSdk_pay_onchain(
      port_,
      that,
      req,
    );
  }

  late final _wire__crate__bindings__BindingLiquidSdk_pay_onchainPtr = _lookup<
          ffi.NativeFunction<
              ffi.Void Function(ffi.Int64, ffi.UintPtr, ffi.Pointer<wire_cst_pay_onchain_request>)>>(
      'frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_pay_onchain');
  late final _wire__crate__bindings__BindingLiquidSdk_pay_onchain =
      _wire__crate__bindings__BindingLiquidSdk_pay_onchainPtr
          .asFunction<void Function(int, int, ffi.Pointer<wire_cst_pay_onchain_request>)>();

  void wire__crate__bindings__BindingLiquidSdk_prepare_buy_bitcoin(
    int port_,
    int that,
    ffi.Pointer<wire_cst_prepare_buy_bitcoin_request> req,
  ) {
    return _wire__crate__bindings__BindingLiquidSdk_prepare_buy_bitcoin(
      port_,
      that,
      req,
    );
  }

  late final _wire__crate__bindings__BindingLiquidSdk_prepare_buy_bitcoinPtr = _lookup<
          ffi.NativeFunction<
              ffi.Void Function(ffi.Int64, ffi.UintPtr, ffi.Pointer<wire_cst_prepare_buy_bitcoin_request>)>>(
      'frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_prepare_buy_bitcoin');
  late final _wire__crate__bindings__BindingLiquidSdk_prepare_buy_bitcoin =
      _wire__crate__bindings__BindingLiquidSdk_prepare_buy_bitcoinPtr
          .asFunction<void Function(int, int, ffi.Pointer<wire_cst_prepare_buy_bitcoin_request>)>();

  void wire__crate__bindings__BindingLiquidSdk_prepare_pay_onchain(
    int port_,
    int that,
    ffi.Pointer<wire_cst_prepare_pay_onchain_request> req,
  ) {
    return _wire__crate__bindings__BindingLiquidSdk_prepare_pay_onchain(
      port_,
      that,
      req,
    );
  }

  late final _wire__crate__bindings__BindingLiquidSdk_prepare_pay_onchainPtr = _lookup<
          ffi.NativeFunction<
              ffi.Void Function(ffi.Int64, ffi.UintPtr, ffi.Pointer<wire_cst_prepare_pay_onchain_request>)>>(
      'frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_prepare_pay_onchain');
  late final _wire__crate__bindings__BindingLiquidSdk_prepare_pay_onchain =
      _wire__crate__bindings__BindingLiquidSdk_prepare_pay_onchainPtr
          .asFunction<void Function(int, int, ffi.Pointer<wire_cst_prepare_pay_onchain_request>)>();

  void wire__crate__bindings__BindingLiquidSdk_prepare_receive_payment(
    int port_,
    int that,
    ffi.Pointer<wire_cst_prepare_receive_request> req,
  ) {
    return _wire__crate__bindings__BindingLiquidSdk_prepare_receive_payment(
      port_,
      that,
      req,
    );
  }

  late final _wire__crate__bindings__BindingLiquidSdk_prepare_receive_paymentPtr = _lookup<
          ffi.NativeFunction<
              ffi.Void Function(ffi.Int64, ffi.UintPtr, ffi.Pointer<wire_cst_prepare_receive_request>)>>(
      'frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_prepare_receive_payment');
  late final _wire__crate__bindings__BindingLiquidSdk_prepare_receive_payment =
      _wire__crate__bindings__BindingLiquidSdk_prepare_receive_paymentPtr
          .asFunction<void Function(int, int, ffi.Pointer<wire_cst_prepare_receive_request>)>();

  void wire__crate__bindings__BindingLiquidSdk_prepare_refund(
    int port_,
    int that,
    ffi.Pointer<wire_cst_prepare_refund_request> req,
  ) {
    return _wire__crate__bindings__BindingLiquidSdk_prepare_refund(
      port_,
      that,
      req,
    );
  }

  late final _wire__crate__bindings__BindingLiquidSdk_prepare_refundPtr = _lookup<
          ffi.NativeFunction<
              ffi.Void Function(ffi.Int64, ffi.UintPtr, ffi.Pointer<wire_cst_prepare_refund_request>)>>(
      'frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_prepare_refund');
  late final _wire__crate__bindings__BindingLiquidSdk_prepare_refund =
      _wire__crate__bindings__BindingLiquidSdk_prepare_refundPtr
          .asFunction<void Function(int, int, ffi.Pointer<wire_cst_prepare_refund_request>)>();

  void wire__crate__bindings__BindingLiquidSdk_prepare_send_payment(
    int port_,
    int that,
    ffi.Pointer<wire_cst_prepare_send_request> req,
  ) {
    return _wire__crate__bindings__BindingLiquidSdk_prepare_send_payment(
      port_,
      that,
      req,
    );
  }

  late final _wire__crate__bindings__BindingLiquidSdk_prepare_send_paymentPtr = _lookup<
          ffi.NativeFunction<
              ffi.Void Function(ffi.Int64, ffi.UintPtr, ffi.Pointer<wire_cst_prepare_send_request>)>>(
      'frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_prepare_send_payment');
  late final _wire__crate__bindings__BindingLiquidSdk_prepare_send_payment =
      _wire__crate__bindings__BindingLiquidSdk_prepare_send_paymentPtr
          .asFunction<void Function(int, int, ffi.Pointer<wire_cst_prepare_send_request>)>();

  void wire__crate__bindings__BindingLiquidSdk_receive_payment(
    int port_,
    int that,
    ffi.Pointer<wire_cst_receive_payment_request> req,
  ) {
    return _wire__crate__bindings__BindingLiquidSdk_receive_payment(
      port_,
      that,
      req,
    );
  }

  late final _wire__crate__bindings__BindingLiquidSdk_receive_paymentPtr = _lookup<
          ffi.NativeFunction<
              ffi.Void Function(ffi.Int64, ffi.UintPtr, ffi.Pointer<wire_cst_receive_payment_request>)>>(
      'frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_receive_payment');
  late final _wire__crate__bindings__BindingLiquidSdk_receive_payment =
      _wire__crate__bindings__BindingLiquidSdk_receive_paymentPtr
          .asFunction<void Function(int, int, ffi.Pointer<wire_cst_receive_payment_request>)>();

  void wire__crate__bindings__BindingLiquidSdk_recommended_fees(
    int port_,
    int that,
  ) {
    return _wire__crate__bindings__BindingLiquidSdk_recommended_fees(
      port_,
      that,
    );
  }

  late final _wire__crate__bindings__BindingLiquidSdk_recommended_feesPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Int64, ffi.UintPtr)>>(
          'frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_recommended_fees');
  late final _wire__crate__bindings__BindingLiquidSdk_recommended_fees =
      _wire__crate__bindings__BindingLiquidSdk_recommended_feesPtr.asFunction<void Function(int, int)>();

  void wire__crate__bindings__BindingLiquidSdk_refund(
    int port_,
    int that,
    ffi.Pointer<wire_cst_refund_request> req,
  ) {
    return _wire__crate__bindings__BindingLiquidSdk_refund(
      port_,
      that,
      req,
    );
  }

  late final _wire__crate__bindings__BindingLiquidSdk_refundPtr = _lookup<
          ffi
          .NativeFunction<ffi.Void Function(ffi.Int64, ffi.UintPtr, ffi.Pointer<wire_cst_refund_request>)>>(
      'frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_refund');
  late final _wire__crate__bindings__BindingLiquidSdk_refund =
      _wire__crate__bindings__BindingLiquidSdk_refundPtr
          .asFunction<void Function(int, int, ffi.Pointer<wire_cst_refund_request>)>();

  void wire__crate__bindings__BindingLiquidSdk_register_webhook(
    int port_,
    int that,
    ffi.Pointer<wire_cst_list_prim_u_8_strict> webhook_url,
  ) {
    return _wire__crate__bindings__BindingLiquidSdk_register_webhook(
      port_,
      that,
      webhook_url,
    );
  }

  late final _wire__crate__bindings__BindingLiquidSdk_register_webhookPtr = _lookup<
          ffi.NativeFunction<
              ffi.Void Function(ffi.Int64, ffi.UintPtr, ffi.Pointer<wire_cst_list_prim_u_8_strict>)>>(
      'frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_register_webhook');
  late final _wire__crate__bindings__BindingLiquidSdk_register_webhook =
      _wire__crate__bindings__BindingLiquidSdk_register_webhookPtr
          .asFunction<void Function(int, int, ffi.Pointer<wire_cst_list_prim_u_8_strict>)>();

  void wire__crate__bindings__BindingLiquidSdk_rescan_onchain_swaps(
    int port_,
    int that,
  ) {
    return _wire__crate__bindings__BindingLiquidSdk_rescan_onchain_swaps(
      port_,
      that,
    );
  }

  late final _wire__crate__bindings__BindingLiquidSdk_rescan_onchain_swapsPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Int64, ffi.UintPtr)>>(
          'frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_rescan_onchain_swaps');
  late final _wire__crate__bindings__BindingLiquidSdk_rescan_onchain_swaps =
      _wire__crate__bindings__BindingLiquidSdk_rescan_onchain_swapsPtr.asFunction<void Function(int, int)>();

  WireSyncRust2DartDco wire__crate__bindings__BindingLiquidSdk_restore(
    int that,
    ffi.Pointer<wire_cst_restore_request> req,
  ) {
    return _wire__crate__bindings__BindingLiquidSdk_restore(
      that,
      req,
    );
  }

  late final _wire__crate__bindings__BindingLiquidSdk_restorePtr = _lookup<
          ffi
          .NativeFunction<WireSyncRust2DartDco Function(ffi.UintPtr, ffi.Pointer<wire_cst_restore_request>)>>(
      'frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_restore');
  late final _wire__crate__bindings__BindingLiquidSdk_restore =
      _wire__crate__bindings__BindingLiquidSdk_restorePtr
          .asFunction<WireSyncRust2DartDco Function(int, ffi.Pointer<wire_cst_restore_request>)>();

  void wire__crate__bindings__BindingLiquidSdk_send_payment(
    int port_,
    int that,
    ffi.Pointer<wire_cst_send_payment_request> req,
  ) {
    return _wire__crate__bindings__BindingLiquidSdk_send_payment(
      port_,
      that,
      req,
    );
  }

  late final _wire__crate__bindings__BindingLiquidSdk_send_paymentPtr = _lookup<
          ffi.NativeFunction<
              ffi.Void Function(ffi.Int64, ffi.UintPtr, ffi.Pointer<wire_cst_send_payment_request>)>>(
      'frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_send_payment');
  late final _wire__crate__bindings__BindingLiquidSdk_send_payment =
      _wire__crate__bindings__BindingLiquidSdk_send_paymentPtr
          .asFunction<void Function(int, int, ffi.Pointer<wire_cst_send_payment_request>)>();

  WireSyncRust2DartDco wire__crate__bindings__BindingLiquidSdk_sign_message(
    int that,
    ffi.Pointer<wire_cst_sign_message_request> req,
  ) {
    return _wire__crate__bindings__BindingLiquidSdk_sign_message(
      that,
      req,
    );
  }

  late final _wire__crate__bindings__BindingLiquidSdk_sign_messagePtr = _lookup<
          ffi.NativeFunction<
              WireSyncRust2DartDco Function(ffi.UintPtr, ffi.Pointer<wire_cst_sign_message_request>)>>(
      'frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_sign_message');
  late final _wire__crate__bindings__BindingLiquidSdk_sign_message =
      _wire__crate__bindings__BindingLiquidSdk_sign_messagePtr
          .asFunction<WireSyncRust2DartDco Function(int, ffi.Pointer<wire_cst_sign_message_request>)>();

  void wire__crate__bindings__BindingLiquidSdk_sync(
    int port_,
    int that,
  ) {
    return _wire__crate__bindings__BindingLiquidSdk_sync(
      port_,
      that,
    );
  }

  late final _wire__crate__bindings__BindingLiquidSdk_syncPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Int64, ffi.UintPtr)>>(
          'frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_sync');
  late final _wire__crate__bindings__BindingLiquidSdk_sync =
      _wire__crate__bindings__BindingLiquidSdk_syncPtr.asFunction<void Function(int, int)>();

  void wire__crate__bindings__BindingLiquidSdk_unregister_webhook(
    int port_,
    int that,
  ) {
    return _wire__crate__bindings__BindingLiquidSdk_unregister_webhook(
      port_,
      that,
    );
  }

  late final _wire__crate__bindings__BindingLiquidSdk_unregister_webhookPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Int64, ffi.UintPtr)>>(
          'frbgen_breez_liquid_wire__crate__bindings__BindingLiquidSdk_unregister_webhook');
  late final _wire__crate__bindings__BindingLiquidSdk_unregister_webhook =
      _wire__crate__bindings__BindingLiquidSdk_unregister_webhookPtr.asFunction<void Function(int, int)>();

  void wire__crate__bindings__binding_event_listener_on_event(
    int port_,
    ffi.Pointer<wire_cst_binding_event_listener> that,
    ffi.Pointer<wire_cst_sdk_event> e,
  ) {
    return _wire__crate__bindings__binding_event_listener_on_event(
      port_,
      that,
      e,
    );
  }

  late final _wire__crate__bindings__binding_event_listener_on_eventPtr = _lookup<
          ffi.NativeFunction<
              ffi.Void Function(
                  ffi.Int64, ffi.Pointer<wire_cst_binding_event_listener>, ffi.Pointer<wire_cst_sdk_event>)>>(
      'frbgen_breez_liquid_wire__crate__bindings__binding_event_listener_on_event');
  late final _wire__crate__bindings__binding_event_listener_on_event =
      _wire__crate__bindings__binding_event_listener_on_eventPtr.asFunction<
          void Function(
              int, ffi.Pointer<wire_cst_binding_event_listener>, ffi.Pointer<wire_cst_sdk_event>)>();

  void wire__crate__bindings__breez_log_stream(
    int port_,
    ffi.Pointer<wire_cst_list_prim_u_8_strict> s,
  ) {
    return _wire__crate__bindings__breez_log_stream(
      port_,
      s,
    );
  }

  late final _wire__crate__bindings__breez_log_streamPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Int64, ffi.Pointer<wire_cst_list_prim_u_8_strict>)>>(
          'frbgen_breez_liquid_wire__crate__bindings__breez_log_stream');
  late final _wire__crate__bindings__breez_log_stream = _wire__crate__bindings__breez_log_streamPtr
      .asFunction<void Function(int, ffi.Pointer<wire_cst_list_prim_u_8_strict>)>();

  void wire__crate__bindings__connect(
    int port_,
    ffi.Pointer<wire_cst_connect_request> req,
  ) {
    return _wire__crate__bindings__connect(
      port_,
      req,
    );
  }

  late final _wire__crate__bindings__connectPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Int64, ffi.Pointer<wire_cst_connect_request>)>>(
          'frbgen_breez_liquid_wire__crate__bindings__connect');
  late final _wire__crate__bindings__connect = _wire__crate__bindings__connectPtr
      .asFunction<void Function(int, ffi.Pointer<wire_cst_connect_request>)>();

  WireSyncRust2DartDco wire__crate__bindings__default_config(
    int network,
  ) {
    return _wire__crate__bindings__default_config(
      network,
    );
  }

  late final _wire__crate__bindings__default_configPtr =
      _lookup<ffi.NativeFunction<WireSyncRust2DartDco Function(ffi.Int32)>>(
          'frbgen_breez_liquid_wire__crate__bindings__default_config');
  late final _wire__crate__bindings__default_config =
      _wire__crate__bindings__default_configPtr.asFunction<WireSyncRust2DartDco Function(int)>();

  void wire__crate__bindings__parse(
    int port_,
    ffi.Pointer<wire_cst_list_prim_u_8_strict> input,
  ) {
    return _wire__crate__bindings__parse(
      port_,
      input,
    );
  }

  late final _wire__crate__bindings__parsePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Int64, ffi.Pointer<wire_cst_list_prim_u_8_strict>)>>(
          'frbgen_breez_liquid_wire__crate__bindings__parse');
  late final _wire__crate__bindings__parse = _wire__crate__bindings__parsePtr
      .asFunction<void Function(int, ffi.Pointer<wire_cst_list_prim_u_8_strict>)>();

  WireSyncRust2DartDco wire__crate__bindings__parse_invoice(
    ffi.Pointer<wire_cst_list_prim_u_8_strict> input,
  ) {
    return _wire__crate__bindings__parse_invoice(
      input,
    );
  }

  late final _wire__crate__bindings__parse_invoicePtr =
      _lookup<ffi.NativeFunction<WireSyncRust2DartDco Function(ffi.Pointer<wire_cst_list_prim_u_8_strict>)>>(
          'frbgen_breez_liquid_wire__crate__bindings__parse_invoice');
  late final _wire__crate__bindings__parse_invoice = _wire__crate__bindings__parse_invoicePtr
      .asFunction<WireSyncRust2DartDco Function(ffi.Pointer<wire_cst_list_prim_u_8_strict>)>();

  void
      rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerBindingLiquidSdk(
    ffi.Pointer<ffi.Void> ptr,
  ) {
    return _rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerBindingLiquidSdk(
      ptr,
    );
  }

  late final _rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerBindingLiquidSdkPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>)>>(
          'frbgen_breez_liquid_rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerBindingLiquidSdk');
  late final _rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerBindingLiquidSdk =
      _rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerBindingLiquidSdkPtr
          .asFunction<void Function(ffi.Pointer<ffi.Void>)>();

  void
      rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerBindingLiquidSdk(
    ffi.Pointer<ffi.Void> ptr,
  ) {
    return _rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerBindingLiquidSdk(
      ptr,
    );
  }

  late final _rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerBindingLiquidSdkPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>)>>(
          'frbgen_breez_liquid_rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerBindingLiquidSdk');
  late final _rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerBindingLiquidSdk =
      _rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerBindingLiquidSdkPtr
          .asFunction<void Function(ffi.Pointer<ffi.Void>)>();

  ffi.Pointer<wire_cst_aes_success_action_data_decrypted>
      cst_new_box_autoadd_aes_success_action_data_decrypted() {
    return _cst_new_box_autoadd_aes_success_action_data_decrypted();
  }

  late final _cst_new_box_autoadd_aes_success_action_data_decryptedPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<wire_cst_aes_success_action_data_decrypted> Function()>>(
          'frbgen_breez_liquid_cst_new_box_autoadd_aes_success_action_data_decrypted');
  late final _cst_new_box_autoadd_aes_success_action_data_decrypted =
      _cst_new_box_autoadd_aes_success_action_data_decryptedPtr
          .asFunction<ffi.Pointer<wire_cst_aes_success_action_data_decrypted> Function()>();

  ffi.Pointer<wire_cst_aes_success_action_data_result> cst_new_box_autoadd_aes_success_action_data_result() {
    return _cst_new_box_autoadd_aes_success_action_data_result();
  }

  late final _cst_new_box_autoadd_aes_success_action_data_resultPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<wire_cst_aes_success_action_data_result> Function()>>(
          'frbgen_breez_liquid_cst_new_box_autoadd_aes_success_action_data_result');
  late final _cst_new_box_autoadd_aes_success_action_data_result =
      _cst_new_box_autoadd_aes_success_action_data_resultPtr
          .asFunction<ffi.Pointer<wire_cst_aes_success_action_data_result> Function()>();

  ffi.Pointer<wire_cst_backup_request> cst_new_box_autoadd_backup_request() {
    return _cst_new_box_autoadd_backup_request();
  }

  late final _cst_new_box_autoadd_backup_requestPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<wire_cst_backup_request> Function()>>(
          'frbgen_breez_liquid_cst_new_box_autoadd_backup_request');
  late final _cst_new_box_autoadd_backup_request =
      _cst_new_box_autoadd_backup_requestPtr.asFunction<ffi.Pointer<wire_cst_backup_request> Function()>();

  ffi.Pointer<wire_cst_binding_event_listener> cst_new_box_autoadd_binding_event_listener() {
    return _cst_new_box_autoadd_binding_event_listener();
  }

  late final _cst_new_box_autoadd_binding_event_listenerPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<wire_cst_binding_event_listener> Function()>>(
          'frbgen_breez_liquid_cst_new_box_autoadd_binding_event_listener');
  late final _cst_new_box_autoadd_binding_event_listener = _cst_new_box_autoadd_binding_event_listenerPtr
      .asFunction<ffi.Pointer<wire_cst_binding_event_listener> Function()>();

  ffi.Pointer<wire_cst_bitcoin_address_data> cst_new_box_autoadd_bitcoin_address_data() {
    return _cst_new_box_autoadd_bitcoin_address_data();
  }

  late final _cst_new_box_autoadd_bitcoin_address_dataPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<wire_cst_bitcoin_address_data> Function()>>(
          'frbgen_breez_liquid_cst_new_box_autoadd_bitcoin_address_data');
  late final _cst_new_box_autoadd_bitcoin_address_data = _cst_new_box_autoadd_bitcoin_address_dataPtr
      .asFunction<ffi.Pointer<wire_cst_bitcoin_address_data> Function()>();

  ffi.Pointer<ffi.Bool> cst_new_box_autoadd_bool(
    bool value,
  ) {
    return _cst_new_box_autoadd_bool(
      value,
    );
  }

  late final _cst_new_box_autoadd_boolPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Bool> Function(ffi.Bool)>>(
          'frbgen_breez_liquid_cst_new_box_autoadd_bool');
  late final _cst_new_box_autoadd_bool =
      _cst_new_box_autoadd_boolPtr.asFunction<ffi.Pointer<ffi.Bool> Function(bool)>();

  ffi.Pointer<wire_cst_buy_bitcoin_request> cst_new_box_autoadd_buy_bitcoin_request() {
    return _cst_new_box_autoadd_buy_bitcoin_request();
  }

  late final _cst_new_box_autoadd_buy_bitcoin_requestPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<wire_cst_buy_bitcoin_request> Function()>>(
          'frbgen_breez_liquid_cst_new_box_autoadd_buy_bitcoin_request');
  late final _cst_new_box_autoadd_buy_bitcoin_request = _cst_new_box_autoadd_buy_bitcoin_requestPtr
      .asFunction<ffi.Pointer<wire_cst_buy_bitcoin_request> Function()>();

  ffi.Pointer<wire_cst_check_message_request> cst_new_box_autoadd_check_message_request() {
    return _cst_new_box_autoadd_check_message_request();
  }

  late final _cst_new_box_autoadd_check_message_requestPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<wire_cst_check_message_request> Function()>>(
          'frbgen_breez_liquid_cst_new_box_autoadd_check_message_request');
  late final _cst_new_box_autoadd_check_message_request = _cst_new_box_autoadd_check_message_requestPtr
      .asFunction<ffi.Pointer<wire_cst_check_message_request> Function()>();

  ffi.Pointer<wire_cst_connect_request> cst_new_box_autoadd_connect_request() {
    return _cst_new_box_autoadd_connect_request();
  }

  late final _cst_new_box_autoadd_connect_requestPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<wire_cst_connect_request> Function()>>(
          'frbgen_breez_liquid_cst_new_box_autoadd_connect_request');
  late final _cst_new_box_autoadd_connect_request =
      _cst_new_box_autoadd_connect_requestPtr.asFunction<ffi.Pointer<wire_cst_connect_request> Function()>();

  ffi.Pointer<ffi.Int64> cst_new_box_autoadd_i_64(
    int value,
  ) {
    return _cst_new_box_autoadd_i_64(
      value,
    );
  }

  late final _cst_new_box_autoadd_i_64Ptr =
      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Int64> Function(ffi.Int64)>>(
          'frbgen_breez_liquid_cst_new_box_autoadd_i_64');
  late final _cst_new_box_autoadd_i_64 =
      _cst_new_box_autoadd_i_64Ptr.asFunction<ffi.Pointer<ffi.Int64> Function(int)>();

  ffi.Pointer<wire_cst_liquid_address_data> cst_new_box_autoadd_liquid_address_data() {
    return _cst_new_box_autoadd_liquid_address_data();
  }

  late final _cst_new_box_autoadd_liquid_address_dataPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<wire_cst_liquid_address_data> Function()>>(
          'frbgen_breez_liquid_cst_new_box_autoadd_liquid_address_data');
  late final _cst_new_box_autoadd_liquid_address_data = _cst_new_box_autoadd_liquid_address_dataPtr
      .asFunction<ffi.Pointer<wire_cst_liquid_address_data> Function()>();

  ffi.Pointer<wire_cst_list_payments_request> cst_new_box_autoadd_list_payments_request() {
    return _cst_new_box_autoadd_list_payments_request();
  }

  late final _cst_new_box_autoadd_list_payments_requestPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<wire_cst_list_payments_request> Function()>>(
          'frbgen_breez_liquid_cst_new_box_autoadd_list_payments_request');
  late final _cst_new_box_autoadd_list_payments_request = _cst_new_box_autoadd_list_payments_requestPtr
      .asFunction<ffi.Pointer<wire_cst_list_payments_request> Function()>();

  ffi.Pointer<wire_cst_ln_invoice> cst_new_box_autoadd_ln_invoice() {
    return _cst_new_box_autoadd_ln_invoice();
  }

  late final _cst_new_box_autoadd_ln_invoicePtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<wire_cst_ln_invoice> Function()>>(
          'frbgen_breez_liquid_cst_new_box_autoadd_ln_invoice');
  late final _cst_new_box_autoadd_ln_invoice =
      _cst_new_box_autoadd_ln_invoicePtr.asFunction<ffi.Pointer<wire_cst_ln_invoice> Function()>();

  ffi.Pointer<wire_cst_ln_url_auth_request_data> cst_new_box_autoadd_ln_url_auth_request_data() {
    return _cst_new_box_autoadd_ln_url_auth_request_data();
  }

  late final _cst_new_box_autoadd_ln_url_auth_request_dataPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<wire_cst_ln_url_auth_request_data> Function()>>(
          'frbgen_breez_liquid_cst_new_box_autoadd_ln_url_auth_request_data');
  late final _cst_new_box_autoadd_ln_url_auth_request_data = _cst_new_box_autoadd_ln_url_auth_request_dataPtr
      .asFunction<ffi.Pointer<wire_cst_ln_url_auth_request_data> Function()>();

  ffi.Pointer<wire_cst_ln_url_error_data> cst_new_box_autoadd_ln_url_error_data() {
    return _cst_new_box_autoadd_ln_url_error_data();
  }

  late final _cst_new_box_autoadd_ln_url_error_dataPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<wire_cst_ln_url_error_data> Function()>>(
          'frbgen_breez_liquid_cst_new_box_autoadd_ln_url_error_data');
  late final _cst_new_box_autoadd_ln_url_error_data = _cst_new_box_autoadd_ln_url_error_dataPtr
      .asFunction<ffi.Pointer<wire_cst_ln_url_error_data> Function()>();

  ffi.Pointer<wire_cst_ln_url_pay_error_data> cst_new_box_autoadd_ln_url_pay_error_data() {
    return _cst_new_box_autoadd_ln_url_pay_error_data();
  }

  late final _cst_new_box_autoadd_ln_url_pay_error_dataPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<wire_cst_ln_url_pay_error_data> Function()>>(
          'frbgen_breez_liquid_cst_new_box_autoadd_ln_url_pay_error_data');
  late final _cst_new_box_autoadd_ln_url_pay_error_data = _cst_new_box_autoadd_ln_url_pay_error_dataPtr
      .asFunction<ffi.Pointer<wire_cst_ln_url_pay_error_data> Function()>();

  ffi.Pointer<wire_cst_ln_url_pay_request> cst_new_box_autoadd_ln_url_pay_request() {
    return _cst_new_box_autoadd_ln_url_pay_request();
  }

  late final _cst_new_box_autoadd_ln_url_pay_requestPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<wire_cst_ln_url_pay_request> Function()>>(
          'frbgen_breez_liquid_cst_new_box_autoadd_ln_url_pay_request');
  late final _cst_new_box_autoadd_ln_url_pay_request = _cst_new_box_autoadd_ln_url_pay_requestPtr
      .asFunction<ffi.Pointer<wire_cst_ln_url_pay_request> Function()>();

  ffi.Pointer<wire_cst_ln_url_pay_request_data> cst_new_box_autoadd_ln_url_pay_request_data() {
    return _cst_new_box_autoadd_ln_url_pay_request_data();
  }

  late final _cst_new_box_autoadd_ln_url_pay_request_dataPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<wire_cst_ln_url_pay_request_data> Function()>>(
          'frbgen_breez_liquid_cst_new_box_autoadd_ln_url_pay_request_data');
  late final _cst_new_box_autoadd_ln_url_pay_request_data = _cst_new_box_autoadd_ln_url_pay_request_dataPtr
      .asFunction<ffi.Pointer<wire_cst_ln_url_pay_request_data> Function()>();

  ffi.Pointer<wire_cst_ln_url_pay_success_data> cst_new_box_autoadd_ln_url_pay_success_data() {
    return _cst_new_box_autoadd_ln_url_pay_success_data();
  }

  late final _cst_new_box_autoadd_ln_url_pay_success_dataPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<wire_cst_ln_url_pay_success_data> Function()>>(
          'frbgen_breez_liquid_cst_new_box_autoadd_ln_url_pay_success_data');
  late final _cst_new_box_autoadd_ln_url_pay_success_data = _cst_new_box_autoadd_ln_url_pay_success_dataPtr
      .asFunction<ffi.Pointer<wire_cst_ln_url_pay_success_data> Function()>();

  ffi.Pointer<wire_cst_ln_url_withdraw_request> cst_new_box_autoadd_ln_url_withdraw_request() {
    return _cst_new_box_autoadd_ln_url_withdraw_request();
  }

  late final _cst_new_box_autoadd_ln_url_withdraw_requestPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<wire_cst_ln_url_withdraw_request> Function()>>(
          'frbgen_breez_liquid_cst_new_box_autoadd_ln_url_withdraw_request');
  late final _cst_new_box_autoadd_ln_url_withdraw_request = _cst_new_box_autoadd_ln_url_withdraw_requestPtr
      .asFunction<ffi.Pointer<wire_cst_ln_url_withdraw_request> Function()>();

  ffi.Pointer<wire_cst_ln_url_withdraw_request_data> cst_new_box_autoadd_ln_url_withdraw_request_data() {
    return _cst_new_box_autoadd_ln_url_withdraw_request_data();
  }

  late final _cst_new_box_autoadd_ln_url_withdraw_request_dataPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<wire_cst_ln_url_withdraw_request_data> Function()>>(
          'frbgen_breez_liquid_cst_new_box_autoadd_ln_url_withdraw_request_data');
  late final _cst_new_box_autoadd_ln_url_withdraw_request_data =
      _cst_new_box_autoadd_ln_url_withdraw_request_dataPtr
          .asFunction<ffi.Pointer<wire_cst_ln_url_withdraw_request_data> Function()>();

  ffi.Pointer<wire_cst_ln_url_withdraw_success_data> cst_new_box_autoadd_ln_url_withdraw_success_data() {
    return _cst_new_box_autoadd_ln_url_withdraw_success_data();
  }

  late final _cst_new_box_autoadd_ln_url_withdraw_success_dataPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<wire_cst_ln_url_withdraw_success_data> Function()>>(
          'frbgen_breez_liquid_cst_new_box_autoadd_ln_url_withdraw_success_data');
  late final _cst_new_box_autoadd_ln_url_withdraw_success_data =
      _cst_new_box_autoadd_ln_url_withdraw_success_dataPtr
          .asFunction<ffi.Pointer<wire_cst_ln_url_withdraw_success_data> Function()>();

  ffi.Pointer<wire_cst_message_success_action_data> cst_new_box_autoadd_message_success_action_data() {
    return _cst_new_box_autoadd_message_success_action_data();
  }

  late final _cst_new_box_autoadd_message_success_action_dataPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<wire_cst_message_success_action_data> Function()>>(
          'frbgen_breez_liquid_cst_new_box_autoadd_message_success_action_data');
  late final _cst_new_box_autoadd_message_success_action_data =
      _cst_new_box_autoadd_message_success_action_dataPtr
          .asFunction<ffi.Pointer<wire_cst_message_success_action_data> Function()>();

  ffi.Pointer<wire_cst_pay_onchain_request> cst_new_box_autoadd_pay_onchain_request() {
    return _cst_new_box_autoadd_pay_onchain_request();
  }

  late final _cst_new_box_autoadd_pay_onchain_requestPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<wire_cst_pay_onchain_request> Function()>>(
          'frbgen_breez_liquid_cst_new_box_autoadd_pay_onchain_request');
  late final _cst_new_box_autoadd_pay_onchain_request = _cst_new_box_autoadd_pay_onchain_requestPtr
      .asFunction<ffi.Pointer<wire_cst_pay_onchain_request> Function()>();

  ffi.Pointer<wire_cst_payment> cst_new_box_autoadd_payment() {
    return _cst_new_box_autoadd_payment();
  }

  late final _cst_new_box_autoadd_paymentPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<wire_cst_payment> Function()>>(
          'frbgen_breez_liquid_cst_new_box_autoadd_payment');
  late final _cst_new_box_autoadd_payment =
      _cst_new_box_autoadd_paymentPtr.asFunction<ffi.Pointer<wire_cst_payment> Function()>();

  ffi.Pointer<wire_cst_prepare_buy_bitcoin_request> cst_new_box_autoadd_prepare_buy_bitcoin_request() {
    return _cst_new_box_autoadd_prepare_buy_bitcoin_request();
  }

  late final _cst_new_box_autoadd_prepare_buy_bitcoin_requestPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<wire_cst_prepare_buy_bitcoin_request> Function()>>(
          'frbgen_breez_liquid_cst_new_box_autoadd_prepare_buy_bitcoin_request');
  late final _cst_new_box_autoadd_prepare_buy_bitcoin_request =
      _cst_new_box_autoadd_prepare_buy_bitcoin_requestPtr
          .asFunction<ffi.Pointer<wire_cst_prepare_buy_bitcoin_request> Function()>();

  ffi.Pointer<wire_cst_prepare_pay_onchain_request> cst_new_box_autoadd_prepare_pay_onchain_request() {
    return _cst_new_box_autoadd_prepare_pay_onchain_request();
  }

  late final _cst_new_box_autoadd_prepare_pay_onchain_requestPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<wire_cst_prepare_pay_onchain_request> Function()>>(
          'frbgen_breez_liquid_cst_new_box_autoadd_prepare_pay_onchain_request');
  late final _cst_new_box_autoadd_prepare_pay_onchain_request =
      _cst_new_box_autoadd_prepare_pay_onchain_requestPtr
          .asFunction<ffi.Pointer<wire_cst_prepare_pay_onchain_request> Function()>();

  ffi.Pointer<wire_cst_prepare_receive_request> cst_new_box_autoadd_prepare_receive_request() {
    return _cst_new_box_autoadd_prepare_receive_request();
  }

  late final _cst_new_box_autoadd_prepare_receive_requestPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<wire_cst_prepare_receive_request> Function()>>(
          'frbgen_breez_liquid_cst_new_box_autoadd_prepare_receive_request');
  late final _cst_new_box_autoadd_prepare_receive_request = _cst_new_box_autoadd_prepare_receive_requestPtr
      .asFunction<ffi.Pointer<wire_cst_prepare_receive_request> Function()>();

  ffi.Pointer<wire_cst_prepare_refund_request> cst_new_box_autoadd_prepare_refund_request() {
    return _cst_new_box_autoadd_prepare_refund_request();
  }

  late final _cst_new_box_autoadd_prepare_refund_requestPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<wire_cst_prepare_refund_request> Function()>>(
          'frbgen_breez_liquid_cst_new_box_autoadd_prepare_refund_request');
  late final _cst_new_box_autoadd_prepare_refund_request = _cst_new_box_autoadd_prepare_refund_requestPtr
      .asFunction<ffi.Pointer<wire_cst_prepare_refund_request> Function()>();

  ffi.Pointer<wire_cst_prepare_send_request> cst_new_box_autoadd_prepare_send_request() {
    return _cst_new_box_autoadd_prepare_send_request();
  }

  late final _cst_new_box_autoadd_prepare_send_requestPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<wire_cst_prepare_send_request> Function()>>(
          'frbgen_breez_liquid_cst_new_box_autoadd_prepare_send_request');
  late final _cst_new_box_autoadd_prepare_send_request = _cst_new_box_autoadd_prepare_send_requestPtr
      .asFunction<ffi.Pointer<wire_cst_prepare_send_request> Function()>();

  ffi.Pointer<wire_cst_receive_payment_request> cst_new_box_autoadd_receive_payment_request() {
    return _cst_new_box_autoadd_receive_payment_request();
  }

  late final _cst_new_box_autoadd_receive_payment_requestPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<wire_cst_receive_payment_request> Function()>>(
          'frbgen_breez_liquid_cst_new_box_autoadd_receive_payment_request');
  late final _cst_new_box_autoadd_receive_payment_request = _cst_new_box_autoadd_receive_payment_requestPtr
      .asFunction<ffi.Pointer<wire_cst_receive_payment_request> Function()>();

  ffi.Pointer<wire_cst_refund_request> cst_new_box_autoadd_refund_request() {
    return _cst_new_box_autoadd_refund_request();
  }

  late final _cst_new_box_autoadd_refund_requestPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<wire_cst_refund_request> Function()>>(
          'frbgen_breez_liquid_cst_new_box_autoadd_refund_request');
  late final _cst_new_box_autoadd_refund_request =
      _cst_new_box_autoadd_refund_requestPtr.asFunction<ffi.Pointer<wire_cst_refund_request> Function()>();

  ffi.Pointer<wire_cst_restore_request> cst_new_box_autoadd_restore_request() {
    return _cst_new_box_autoadd_restore_request();
  }

  late final _cst_new_box_autoadd_restore_requestPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<wire_cst_restore_request> Function()>>(
          'frbgen_breez_liquid_cst_new_box_autoadd_restore_request');
  late final _cst_new_box_autoadd_restore_request =
      _cst_new_box_autoadd_restore_requestPtr.asFunction<ffi.Pointer<wire_cst_restore_request> Function()>();

  ffi.Pointer<wire_cst_sdk_event> cst_new_box_autoadd_sdk_event() {
    return _cst_new_box_autoadd_sdk_event();
  }

  late final _cst_new_box_autoadd_sdk_eventPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<wire_cst_sdk_event> Function()>>(
          'frbgen_breez_liquid_cst_new_box_autoadd_sdk_event');
  late final _cst_new_box_autoadd_sdk_event =
      _cst_new_box_autoadd_sdk_eventPtr.asFunction<ffi.Pointer<wire_cst_sdk_event> Function()>();

  ffi.Pointer<wire_cst_send_payment_request> cst_new_box_autoadd_send_payment_request() {
    return _cst_new_box_autoadd_send_payment_request();
  }

  late final _cst_new_box_autoadd_send_payment_requestPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<wire_cst_send_payment_request> Function()>>(
          'frbgen_breez_liquid_cst_new_box_autoadd_send_payment_request');
  late final _cst_new_box_autoadd_send_payment_request = _cst_new_box_autoadd_send_payment_requestPtr
      .asFunction<ffi.Pointer<wire_cst_send_payment_request> Function()>();

  ffi.Pointer<wire_cst_sign_message_request> cst_new_box_autoadd_sign_message_request() {
    return _cst_new_box_autoadd_sign_message_request();
  }

  late final _cst_new_box_autoadd_sign_message_requestPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<wire_cst_sign_message_request> Function()>>(
          'frbgen_breez_liquid_cst_new_box_autoadd_sign_message_request');
  late final _cst_new_box_autoadd_sign_message_request = _cst_new_box_autoadd_sign_message_requestPtr
      .asFunction<ffi.Pointer<wire_cst_sign_message_request> Function()>();

  ffi.Pointer<wire_cst_success_action_processed> cst_new_box_autoadd_success_action_processed() {
    return _cst_new_box_autoadd_success_action_processed();
  }

  late final _cst_new_box_autoadd_success_action_processedPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<wire_cst_success_action_processed> Function()>>(
          'frbgen_breez_liquid_cst_new_box_autoadd_success_action_processed');
  late final _cst_new_box_autoadd_success_action_processed = _cst_new_box_autoadd_success_action_processedPtr
      .asFunction<ffi.Pointer<wire_cst_success_action_processed> Function()>();

  ffi.Pointer<wire_cst_symbol> cst_new_box_autoadd_symbol() {
    return _cst_new_box_autoadd_symbol();
  }

  late final _cst_new_box_autoadd_symbolPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<wire_cst_symbol> Function()>>(
          'frbgen_breez_liquid_cst_new_box_autoadd_symbol');
  late final _cst_new_box_autoadd_symbol =
      _cst_new_box_autoadd_symbolPtr.asFunction<ffi.Pointer<wire_cst_symbol> Function()>();

  ffi.Pointer<ffi.Uint32> cst_new_box_autoadd_u_32(
    int value,
  ) {
    return _cst_new_box_autoadd_u_32(
      value,
    );
  }

  late final _cst_new_box_autoadd_u_32Ptr =
      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Uint32> Function(ffi.Uint32)>>(
          'frbgen_breez_liquid_cst_new_box_autoadd_u_32');
  late final _cst_new_box_autoadd_u_32 =
      _cst_new_box_autoadd_u_32Ptr.asFunction<ffi.Pointer<ffi.Uint32> Function(int)>();

  ffi.Pointer<ffi.Uint64> cst_new_box_autoadd_u_64(
    int value,
  ) {
    return _cst_new_box_autoadd_u_64(
      value,
    );
  }

  late final _cst_new_box_autoadd_u_64Ptr =
      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Uint64> Function(ffi.Uint64)>>(
          'frbgen_breez_liquid_cst_new_box_autoadd_u_64');
  late final _cst_new_box_autoadd_u_64 =
      _cst_new_box_autoadd_u_64Ptr.asFunction<ffi.Pointer<ffi.Uint64> Function(int)>();

  ffi.Pointer<wire_cst_url_success_action_data> cst_new_box_autoadd_url_success_action_data() {
    return _cst_new_box_autoadd_url_success_action_data();
  }

  late final _cst_new_box_autoadd_url_success_action_dataPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<wire_cst_url_success_action_data> Function()>>(
          'frbgen_breez_liquid_cst_new_box_autoadd_url_success_action_data');
  late final _cst_new_box_autoadd_url_success_action_data = _cst_new_box_autoadd_url_success_action_dataPtr
      .asFunction<ffi.Pointer<wire_cst_url_success_action_data> Function()>();

  ffi.Pointer<wire_cst_list_fiat_currency> cst_new_list_fiat_currency(
    int len,
  ) {
    return _cst_new_list_fiat_currency(
      len,
    );
  }

  late final _cst_new_list_fiat_currencyPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<wire_cst_list_fiat_currency> Function(ffi.Int32)>>(
          'frbgen_breez_liquid_cst_new_list_fiat_currency');
  late final _cst_new_list_fiat_currency =
      _cst_new_list_fiat_currencyPtr.asFunction<ffi.Pointer<wire_cst_list_fiat_currency> Function(int)>();

  ffi.Pointer<wire_cst_list_locale_overrides> cst_new_list_locale_overrides(
    int len,
  ) {
    return _cst_new_list_locale_overrides(
      len,
    );
  }

  late final _cst_new_list_locale_overridesPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<wire_cst_list_locale_overrides> Function(ffi.Int32)>>(
          'frbgen_breez_liquid_cst_new_list_locale_overrides');
  late final _cst_new_list_locale_overrides = _cst_new_list_locale_overridesPtr
      .asFunction<ffi.Pointer<wire_cst_list_locale_overrides> Function(int)>();

  ffi.Pointer<wire_cst_list_localized_name> cst_new_list_localized_name(
    int len,
  ) {
    return _cst_new_list_localized_name(
      len,
    );
  }

  late final _cst_new_list_localized_namePtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<wire_cst_list_localized_name> Function(ffi.Int32)>>(
          'frbgen_breez_liquid_cst_new_list_localized_name');
  late final _cst_new_list_localized_name =
      _cst_new_list_localized_namePtr.asFunction<ffi.Pointer<wire_cst_list_localized_name> Function(int)>();

  ffi.Pointer<wire_cst_list_payment> cst_new_list_payment(
    int len,
  ) {
    return _cst_new_list_payment(
      len,
    );
  }

  late final _cst_new_list_paymentPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<wire_cst_list_payment> Function(ffi.Int32)>>(
          'frbgen_breez_liquid_cst_new_list_payment');
  late final _cst_new_list_payment =
      _cst_new_list_paymentPtr.asFunction<ffi.Pointer<wire_cst_list_payment> Function(int)>();

  ffi.Pointer<wire_cst_list_payment_type> cst_new_list_payment_type(
    int len,
  ) {
    return _cst_new_list_payment_type(
      len,
    );
  }

  late final _cst_new_list_payment_typePtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<wire_cst_list_payment_type> Function(ffi.Int32)>>(
          'frbgen_breez_liquid_cst_new_list_payment_type');
  late final _cst_new_list_payment_type =
      _cst_new_list_payment_typePtr.asFunction<ffi.Pointer<wire_cst_list_payment_type> Function(int)>();

  ffi.Pointer<wire_cst_list_prim_u_8_strict> cst_new_list_prim_u_8_strict(
    int len,
  ) {
    return _cst_new_list_prim_u_8_strict(
      len,
    );
  }

  late final _cst_new_list_prim_u_8_strictPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<wire_cst_list_prim_u_8_strict> Function(ffi.Int32)>>(
          'frbgen_breez_liquid_cst_new_list_prim_u_8_strict');
  late final _cst_new_list_prim_u_8_strict =
      _cst_new_list_prim_u_8_strictPtr.asFunction<ffi.Pointer<wire_cst_list_prim_u_8_strict> Function(int)>();

  ffi.Pointer<wire_cst_list_rate> cst_new_list_rate(
    int len,
  ) {
    return _cst_new_list_rate(
      len,
    );
  }

  late final _cst_new_list_ratePtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<wire_cst_list_rate> Function(ffi.Int32)>>(
          'frbgen_breez_liquid_cst_new_list_rate');
  late final _cst_new_list_rate =
      _cst_new_list_ratePtr.asFunction<ffi.Pointer<wire_cst_list_rate> Function(int)>();

  ffi.Pointer<wire_cst_list_refundable_swap> cst_new_list_refundable_swap(
    int len,
  ) {
    return _cst_new_list_refundable_swap(
      len,
    );
  }

  late final _cst_new_list_refundable_swapPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<wire_cst_list_refundable_swap> Function(ffi.Int32)>>(
          'frbgen_breez_liquid_cst_new_list_refundable_swap');
  late final _cst_new_list_refundable_swap =
      _cst_new_list_refundable_swapPtr.asFunction<ffi.Pointer<wire_cst_list_refundable_swap> Function(int)>();

  ffi.Pointer<wire_cst_list_route_hint> cst_new_list_route_hint(
    int len,
  ) {
    return _cst_new_list_route_hint(
      len,
    );
  }

  late final _cst_new_list_route_hintPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<wire_cst_list_route_hint> Function(ffi.Int32)>>(
          'frbgen_breez_liquid_cst_new_list_route_hint');
  late final _cst_new_list_route_hint =
      _cst_new_list_route_hintPtr.asFunction<ffi.Pointer<wire_cst_list_route_hint> Function(int)>();

  ffi.Pointer<wire_cst_list_route_hint_hop> cst_new_list_route_hint_hop(
    int len,
  ) {
    return _cst_new_list_route_hint_hop(
      len,
    );
  }

  late final _cst_new_list_route_hint_hopPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<wire_cst_list_route_hint_hop> Function(ffi.Int32)>>(
          'frbgen_breez_liquid_cst_new_list_route_hint_hop');
  late final _cst_new_list_route_hint_hop =
      _cst_new_list_route_hint_hopPtr.asFunction<ffi.Pointer<wire_cst_list_route_hint_hop> Function(int)>();

  int dummy_method_to_enforce_bundling() {
    return _dummy_method_to_enforce_bundling();
  }

  late final _dummy_method_to_enforce_bundlingPtr =
      _lookup<ffi.NativeFunction<ffi.Int64 Function()>>('dummy_method_to_enforce_bundling');
  late final _dummy_method_to_enforce_bundling =
      _dummy_method_to_enforce_bundlingPtr.asFunction<int Function()>();
}

typedef DartPostCObjectFnType = ffi.Pointer<ffi.NativeFunction<DartPostCObjectFnTypeFunction>>;
typedef DartPostCObjectFnTypeFunction = ffi.Bool Function(DartPort port_id, ffi.Pointer<ffi.Void> message);
typedef DartDartPostCObjectFnTypeFunction = bool Function(
    DartDartPort port_id, ffi.Pointer<ffi.Void> message);
typedef DartPort = ffi.Int64;
typedef DartDartPort = int;

final class wire_cst_list_prim_u_8_strict extends ffi.Struct {
  external ffi.Pointer<ffi.Uint8> ptr;

  @ffi.Int32()
  external int len;
}

final class wire_cst_backup_request extends ffi.Struct {
  external ffi.Pointer<wire_cst_list_prim_u_8_strict> backup_path;
}

final class wire_cst_prepare_buy_bitcoin_response extends ffi.Struct {
  @ffi.Int32()
  external int provider;

  @ffi.Uint64()
  external int amount_sat;

  @ffi.Uint64()
  external int fees_sat;
}

final class wire_cst_buy_bitcoin_request extends ffi.Struct {
  external wire_cst_prepare_buy_bitcoin_response prepare_response;

  external ffi.Pointer<wire_cst_list_prim_u_8_strict> redirect_url;
}

final class wire_cst_check_message_request extends ffi.Struct {
  external ffi.Pointer<wire_cst_list_prim_u_8_strict> message;

  external ffi.Pointer<wire_cst_list_prim_u_8_strict> pubkey;

  external ffi.Pointer<wire_cst_list_prim_u_8_strict> signature;
}

final class wire_cst_list_payment_type extends ffi.Struct {
  external ffi.Pointer<ffi.Int32> ptr;

  @ffi.Int32()
  external int len;
}

final class wire_cst_list_payments_request extends ffi.Struct {
  external ffi.Pointer<wire_cst_list_payment_type> filters;

  external ffi.Pointer<ffi.Int64> from_timestamp;

  external ffi.Pointer<ffi.Int64> to_timestamp;

  external ffi.Pointer<ffi.Uint32> offset;

  external ffi.Pointer<ffi.Uint32> limit;
}

final class wire_cst_ln_url_auth_request_data extends ffi.Struct {
  external ffi.Pointer<wire_cst_list_prim_u_8_strict> k1;

  external ffi.Pointer<wire_cst_list_prim_u_8_strict> action;

  external ffi.Pointer<wire_cst_list_prim_u_8_strict> domain;

  external ffi.Pointer<wire_cst_list_prim_u_8_strict> url;
}

final class wire_cst_ln_url_pay_request_data extends ffi.Struct {
  external ffi.Pointer<wire_cst_list_prim_u_8_strict> callback;

  @ffi.Uint64()
  external int min_sendable;

  @ffi.Uint64()
  external int max_sendable;

  external ffi.Pointer<wire_cst_list_prim_u_8_strict> metadata_str;

  @ffi.Uint16()
  external int comment_allowed;

  external ffi.Pointer<wire_cst_list_prim_u_8_strict> domain;

  @ffi.Bool()
  external bool allows_nostr;

  external ffi.Pointer<wire_cst_list_prim_u_8_strict> nostr_pubkey;

  external ffi.Pointer<wire_cst_list_prim_u_8_strict> ln_address;
}

final class wire_cst_ln_url_pay_request extends ffi.Struct {
  external wire_cst_ln_url_pay_request_data data;

  @ffi.Uint64()
  external int amount_msat;

  external ffi.Pointer<wire_cst_list_prim_u_8_strict> comment;

  external ffi.Pointer<wire_cst_list_prim_u_8_strict> payment_label;

  external ffi.Pointer<ffi.Bool> validate_success_action_url;
}

final class wire_cst_ln_url_withdraw_request_data extends ffi.Struct {
  external ffi.Pointer<wire_cst_list_prim_u_8_strict> callback;

  external ffi.Pointer<wire_cst_list_prim_u_8_strict> k1;

  external ffi.Pointer<wire_cst_list_prim_u_8_strict> default_description;

  @ffi.Uint64()
  external int min_withdrawable;

  @ffi.Uint64()
  external int max_withdrawable;
}

final class wire_cst_ln_url_withdraw_request extends ffi.Struct {
  external wire_cst_ln_url_withdraw_request_data data;

  @ffi.Uint64()
  external int amount_msat;

  external ffi.Pointer<wire_cst_list_prim_u_8_strict> description;
}

final class wire_cst_prepare_pay_onchain_response extends ffi.Struct {
  @ffi.Uint64()
  external int receiver_amount_sat;

  @ffi.Uint64()
  external int claim_fees_sat;

  @ffi.Uint64()
  external int total_fees_sat;
}

final class wire_cst_pay_onchain_request extends ffi.Struct {
  external ffi.Pointer<wire_cst_list_prim_u_8_strict> address;

  external wire_cst_prepare_pay_onchain_response prepare_response;
}

final class wire_cst_prepare_buy_bitcoin_request extends ffi.Struct {
  @ffi.Int32()
  external int provider;

  @ffi.Uint64()
  external int amount_sat;
}

final class wire_cst_PayOnchainAmount_Receiver extends ffi.Struct {
  @ffi.Uint64()
  external int amount_sat;
}

final class PayOnchainAmountKind extends ffi.Union {
  external wire_cst_PayOnchainAmount_Receiver Receiver;
}

final class wire_cst_pay_onchain_amount extends ffi.Struct {
  @ffi.Int32()
  external int tag;

  external PayOnchainAmountKind kind;
}

final class wire_cst_prepare_pay_onchain_request extends ffi.Struct {
  external wire_cst_pay_onchain_amount amount;

  external ffi.Pointer<ffi.Uint32> fee_rate_sat_per_vbyte;
}

final class wire_cst_prepare_receive_request extends ffi.Struct {
  external ffi.Pointer<ffi.Uint64> payer_amount_sat;

  @ffi.Int32()
  external int payment_method;
}

final class wire_cst_prepare_refund_request extends ffi.Struct {
  external ffi.Pointer<wire_cst_list_prim_u_8_strict> swap_address;

  external ffi.Pointer<wire_cst_list_prim_u_8_strict> refund_address;

  @ffi.Uint32()
  external int fee_rate_sat_per_vbyte;
}

final class wire_cst_prepare_send_request extends ffi.Struct {
  external ffi.Pointer<wire_cst_list_prim_u_8_strict> destination;

  external ffi.Pointer<ffi.Uint64> amount_sat;
}

final class wire_cst_prepare_receive_response extends ffi.Struct {
  @ffi.Int32()
  external int payment_method;

  external ffi.Pointer<ffi.Uint64> payer_amount_sat;

  @ffi.Uint64()
  external int fees_sat;
}

final class wire_cst_receive_payment_request extends ffi.Struct {
  external wire_cst_prepare_receive_response prepare_response;

  external ffi.Pointer<wire_cst_list_prim_u_8_strict> description;

  external ffi.Pointer<ffi.Bool> use_description_hash;
}

final class wire_cst_refund_request extends ffi.Struct {
  external ffi.Pointer<wire_cst_list_prim_u_8_strict> swap_address;

  external ffi.Pointer<wire_cst_list_prim_u_8_strict> refund_address;

  @ffi.Uint32()
  external int fee_rate_sat_per_vbyte;
}

final class wire_cst_restore_request extends ffi.Struct {
  external ffi.Pointer<wire_cst_list_prim_u_8_strict> backup_path;
}

final class wire_cst_liquid_address_data extends ffi.Struct {
  external ffi.Pointer<wire_cst_list_prim_u_8_strict> address;

  @ffi.Int32()
  external int network;

  external ffi.Pointer<wire_cst_list_prim_u_8_strict> asset_id;

  external ffi.Pointer<ffi.Uint64> amount_sat;

  external ffi.Pointer<wire_cst_list_prim_u_8_strict> label;

  external ffi.Pointer<wire_cst_list_prim_u_8_strict> message;
}

final class wire_cst_SendDestination_LiquidAddress extends ffi.Struct {
  external ffi.Pointer<wire_cst_liquid_address_data> address_data;
}

final class wire_cst_route_hint_hop extends ffi.Struct {
  external ffi.Pointer<wire_cst_list_prim_u_8_strict> src_node_id;

  external ffi.Pointer<wire_cst_list_prim_u_8_strict> short_channel_id;

  @ffi.Uint32()
  external int fees_base_msat;

  @ffi.Uint32()
  external int fees_proportional_millionths;

  @ffi.Uint64()
  external int cltv_expiry_delta;

  external ffi.Pointer<ffi.Uint64> htlc_minimum_msat;

  external ffi.Pointer<ffi.Uint64> htlc_maximum_msat;
}

final class wire_cst_list_route_hint_hop extends ffi.Struct {
  external ffi.Pointer<wire_cst_route_hint_hop> ptr;

  @ffi.Int32()
  external int len;
}

final class wire_cst_route_hint extends ffi.Struct {
  external ffi.Pointer<wire_cst_list_route_hint_hop> hops;
}

final class wire_cst_list_route_hint extends ffi.Struct {
  external ffi.Pointer<wire_cst_route_hint> ptr;

  @ffi.Int32()
  external int len;
}

final class wire_cst_ln_invoice extends ffi.Struct {
  external ffi.Pointer<wire_cst_list_prim_u_8_strict> bolt11;

  @ffi.Int32()
  external int network;

  external ffi.Pointer<wire_cst_list_prim_u_8_strict> payee_pubkey;

  external ffi.Pointer<wire_cst_list_prim_u_8_strict> payment_hash;

  external ffi.Pointer<wire_cst_list_prim_u_8_strict> description;

  external ffi.Pointer<wire_cst_list_prim_u_8_strict> description_hash;

  external ffi.Pointer<ffi.Uint64> amount_msat;

  @ffi.Uint64()
  external int timestamp;

  @ffi.Uint64()
  external int expiry;

  external ffi.Pointer<wire_cst_list_route_hint> routing_hints;

  external ffi.Pointer<wire_cst_list_prim_u_8_strict> payment_secret;

  @ffi.Uint64()
  external int min_final_cltv_expiry_delta;
}

final class wire_cst_SendDestination_Bolt11 extends ffi.Struct {
  external ffi.Pointer<wire_cst_ln_invoice> invoice;
}

final class SendDestinationKind extends ffi.Union {
  external wire_cst_SendDestination_LiquidAddress LiquidAddress;

  external wire_cst_SendDestination_Bolt11 Bolt11;
}

final class wire_cst_send_destination extends ffi.Struct {
  @ffi.Int32()
  external int tag;

  external SendDestinationKind kind;
}

final class wire_cst_prepare_send_response extends ffi.Struct {
  external wire_cst_send_destination destination;

  @ffi.Uint64()
  external int fees_sat;
}

final class wire_cst_send_payment_request extends ffi.Struct {
  external wire_cst_prepare_send_response prepare_response;
}

final class wire_cst_sign_message_request extends ffi.Struct {
  external ffi.Pointer<wire_cst_list_prim_u_8_strict> message;
}

final class wire_cst_binding_event_listener extends ffi.Struct {
  external ffi.Pointer<wire_cst_list_prim_u_8_strict> stream;
}

final class wire_cst_PaymentDetails_Lightning extends ffi.Struct {
  external ffi.Pointer<wire_cst_list_prim_u_8_strict> swap_id;

  external ffi.Pointer<wire_cst_list_prim_u_8_strict> description;

  external ffi.Pointer<wire_cst_list_prim_u_8_strict> preimage;

  external ffi.Pointer<wire_cst_list_prim_u_8_strict> bolt11;

  external ffi.Pointer<wire_cst_list_prim_u_8_strict> refund_tx_id;

  external ffi.Pointer<ffi.Uint64> refund_tx_amount_sat;
}

final class wire_cst_PaymentDetails_Liquid extends ffi.Struct {
  external ffi.Pointer<wire_cst_list_prim_u_8_strict> destination;

  external ffi.Pointer<wire_cst_list_prim_u_8_strict> description;
}

final class wire_cst_PaymentDetails_Bitcoin extends ffi.Struct {
  external ffi.Pointer<wire_cst_list_prim_u_8_strict> swap_id;

  external ffi.Pointer<wire_cst_list_prim_u_8_strict> description;

  external ffi.Pointer<wire_cst_list_prim_u_8_strict> refund_tx_id;

  external ffi.Pointer<ffi.Uint64> refund_tx_amount_sat;
}

final class PaymentDetailsKind extends ffi.Union {
  external wire_cst_PaymentDetails_Lightning Lightning;

  external wire_cst_PaymentDetails_Liquid Liquid;

  external wire_cst_PaymentDetails_Bitcoin Bitcoin;
}

final class wire_cst_payment_details extends ffi.Struct {
  @ffi.Int32()
  external int tag;

  external PaymentDetailsKind kind;
}

final class wire_cst_payment extends ffi.Struct {
  external ffi.Pointer<wire_cst_list_prim_u_8_strict> destination;

  external ffi.Pointer<wire_cst_list_prim_u_8_strict> tx_id;

  @ffi.Uint32()
  external int timestamp;

  @ffi.Uint64()
  external int amount_sat;

  @ffi.Uint64()
  external int fees_sat;

  @ffi.Int32()
  external int payment_type;

  @ffi.Int32()
  external int status;

  external wire_cst_payment_details details;
}

final class wire_cst_SdkEvent_PaymentFailed extends ffi.Struct {
  external ffi.Pointer<wire_cst_payment> details;
}

final class wire_cst_SdkEvent_PaymentPending extends ffi.Struct {
  external ffi.Pointer<wire_cst_payment> details;
}

final class wire_cst_SdkEvent_PaymentRefunded extends ffi.Struct {
  external ffi.Pointer<wire_cst_payment> details;
}

final class wire_cst_SdkEvent_PaymentRefundPending extends ffi.Struct {
  external ffi.Pointer<wire_cst_payment> details;
}

final class wire_cst_SdkEvent_PaymentSucceeded extends ffi.Struct {
  external ffi.Pointer<wire_cst_payment> details;
}

final class wire_cst_SdkEvent_PaymentWaitingConfirmation extends ffi.Struct {
  external ffi.Pointer<wire_cst_payment> details;
}

final class SdkEventKind extends ffi.Union {
  external wire_cst_SdkEvent_PaymentFailed PaymentFailed;

  external wire_cst_SdkEvent_PaymentPending PaymentPending;

  external wire_cst_SdkEvent_PaymentRefunded PaymentRefunded;

  external wire_cst_SdkEvent_PaymentRefundPending PaymentRefundPending;

  external wire_cst_SdkEvent_PaymentSucceeded PaymentSucceeded;

  external wire_cst_SdkEvent_PaymentWaitingConfirmation PaymentWaitingConfirmation;
}

final class wire_cst_sdk_event extends ffi.Struct {
  @ffi.Int32()
  external int tag;

  external SdkEventKind kind;
}

final class wire_cst_config extends ffi.Struct {
  external ffi.Pointer<wire_cst_list_prim_u_8_strict> liquid_electrum_url;

  external ffi.Pointer<wire_cst_list_prim_u_8_strict> bitcoin_electrum_url;

  external ffi.Pointer<wire_cst_list_prim_u_8_strict> mempoolspace_url;

  external ffi.Pointer<wire_cst_list_prim_u_8_strict> working_dir;

  @ffi.Int32()
  external int network;

  @ffi.Uint64()
  external int payment_timeout_sec;

  @ffi.Uint32()
  external int zero_conf_min_fee_rate_msat;

  external ffi.Pointer<ffi.Uint64> zero_conf_max_amount_sat;

  external ffi.Pointer<wire_cst_list_prim_u_8_strict> breez_api_key;
}

final class wire_cst_connect_request extends ffi.Struct {
  external ffi.Pointer<wire_cst_list_prim_u_8_strict> mnemonic;

  external wire_cst_config config;
}

final class wire_cst_aes_success_action_data_decrypted extends ffi.Struct {
  external ffi.Pointer<wire_cst_list_prim_u_8_strict> description;

  external ffi.Pointer<wire_cst_list_prim_u_8_strict> plaintext;
}

final class wire_cst_AesSuccessActionDataResult_Decrypted extends ffi.Struct {
  external ffi.Pointer<wire_cst_aes_success_action_data_decrypted> data;
}

final class wire_cst_AesSuccessActionDataResult_ErrorStatus extends ffi.Struct {
  external ffi.Pointer<wire_cst_list_prim_u_8_strict> reason;
}

final class AesSuccessActionDataResultKind extends ffi.Union {
  external wire_cst_AesSuccessActionDataResult_Decrypted Decrypted;

  external wire_cst_AesSuccessActionDataResult_ErrorStatus ErrorStatus;
}

final class wire_cst_aes_success_action_data_result extends ffi.Struct {
  @ffi.Int32()
  external int tag;

  external AesSuccessActionDataResultKind kind;
}

final class wire_cst_bitcoin_address_data extends ffi.Struct {
  external ffi.Pointer<wire_cst_list_prim_u_8_strict> address;

  @ffi.Int32()
  external int network;

  external ffi.Pointer<ffi.Uint64> amount_sat;

  external ffi.Pointer<wire_cst_list_prim_u_8_strict> label;

  external ffi.Pointer<wire_cst_list_prim_u_8_strict> message;
}

final class wire_cst_ln_url_error_data extends ffi.Struct {
  external ffi.Pointer<wire_cst_list_prim_u_8_strict> reason;
}

final class wire_cst_ln_url_pay_error_data extends ffi.Struct {
  external ffi.Pointer<wire_cst_list_prim_u_8_strict> payment_hash;

  external ffi.Pointer<wire_cst_list_prim_u_8_strict> reason;
}

final class wire_cst_SuccessActionProcessed_Aes extends ffi.Struct {
  external ffi.Pointer<wire_cst_aes_success_action_data_result> result;
}

final class wire_cst_message_success_action_data extends ffi.Struct {
  external ffi.Pointer<wire_cst_list_prim_u_8_strict> message;
}

final class wire_cst_SuccessActionProcessed_Message extends ffi.Struct {
  external ffi.Pointer<wire_cst_message_success_action_data> data;
}

final class wire_cst_url_success_action_data extends ffi.Struct {
  external ffi.Pointer<wire_cst_list_prim_u_8_strict> description;

  external ffi.Pointer<wire_cst_list_prim_u_8_strict> url;

  @ffi.Bool()
  external bool matches_callback_domain;
}

final class wire_cst_SuccessActionProcessed_Url extends ffi.Struct {
  external ffi.Pointer<wire_cst_url_success_action_data> data;
}

final class SuccessActionProcessedKind extends ffi.Union {
  external wire_cst_SuccessActionProcessed_Aes Aes;

  external wire_cst_SuccessActionProcessed_Message Message;

  external wire_cst_SuccessActionProcessed_Url Url;
}

final class wire_cst_success_action_processed extends ffi.Struct {
  @ffi.Int32()
  external int tag;

  external SuccessActionProcessedKind kind;
}

final class wire_cst_ln_url_pay_success_data extends ffi.Struct {
  external wire_cst_payment payment;

  external ffi.Pointer<wire_cst_success_action_processed> success_action;
}

final class wire_cst_ln_url_withdraw_success_data extends ffi.Struct {
  external wire_cst_ln_invoice invoice;
}

final class wire_cst_symbol extends ffi.Struct {
  external ffi.Pointer<wire_cst_list_prim_u_8_strict> grapheme;

  external ffi.Pointer<wire_cst_list_prim_u_8_strict> template_;

  external ffi.Pointer<ffi.Bool> rtl;

  external ffi.Pointer<ffi.Uint32> position;
}

final class wire_cst_localized_name extends ffi.Struct {
  external ffi.Pointer<wire_cst_list_prim_u_8_strict> locale;

  external ffi.Pointer<wire_cst_list_prim_u_8_strict> name;
}

final class wire_cst_list_localized_name extends ffi.Struct {
  external ffi.Pointer<wire_cst_localized_name> ptr;

  @ffi.Int32()
  external int len;
}

final class wire_cst_locale_overrides extends ffi.Struct {
  external ffi.Pointer<wire_cst_list_prim_u_8_strict> locale;

  external ffi.Pointer<ffi.Uint32> spacing;

  external wire_cst_symbol symbol;
}

final class wire_cst_list_locale_overrides extends ffi.Struct {
  external ffi.Pointer<wire_cst_locale_overrides> ptr;

  @ffi.Int32()
  external int len;
}

final class wire_cst_currency_info extends ffi.Struct {
  external ffi.Pointer<wire_cst_list_prim_u_8_strict> name;

  @ffi.Uint32()
  external int fraction_size;

  external ffi.Pointer<ffi.Uint32> spacing;

  external ffi.Pointer<wire_cst_symbol> symbol;

  external ffi.Pointer<wire_cst_symbol> uniq_symbol;

  external ffi.Pointer<wire_cst_list_localized_name> localized_name;

  external ffi.Pointer<wire_cst_list_locale_overrides> locale_overrides;
}

final class wire_cst_fiat_currency extends ffi.Struct {
  external ffi.Pointer<wire_cst_list_prim_u_8_strict> id;

  external wire_cst_currency_info info;
}

final class wire_cst_list_fiat_currency extends ffi.Struct {
  external ffi.Pointer<wire_cst_fiat_currency> ptr;

  @ffi.Int32()
  external int len;
}

final class wire_cst_list_payment extends ffi.Struct {
  external ffi.Pointer<wire_cst_payment> ptr;

  @ffi.Int32()
  external int len;
}

final class wire_cst_rate extends ffi.Struct {
  external ffi.Pointer<wire_cst_list_prim_u_8_strict> coin;

  @ffi.Double()
  external double value;
}

final class wire_cst_list_rate extends ffi.Struct {
  external ffi.Pointer<wire_cst_rate> ptr;

  @ffi.Int32()
  external int len;
}

final class wire_cst_refundable_swap extends ffi.Struct {
  external ffi.Pointer<wire_cst_list_prim_u_8_strict> swap_address;

  @ffi.Uint32()
  external int timestamp;

  @ffi.Uint64()
  external int amount_sat;
}

final class wire_cst_list_refundable_swap extends ffi.Struct {
  external ffi.Pointer<wire_cst_refundable_swap> ptr;

  @ffi.Int32()
  external int len;
}

final class wire_cst_check_message_response extends ffi.Struct {
  @ffi.Bool()
  external bool is_valid;
}

final class wire_cst_get_info_response extends ffi.Struct {
  @ffi.Uint64()
  external int balance_sat;

  @ffi.Uint64()
  external int pending_send_sat;

  @ffi.Uint64()
  external int pending_receive_sat;

  external ffi.Pointer<wire_cst_list_prim_u_8_strict> pubkey;
}

final class wire_cst_InputType_BitcoinAddress extends ffi.Struct {
  external ffi.Pointer<wire_cst_bitcoin_address_data> address;
}

final class wire_cst_InputType_LiquidAddress extends ffi.Struct {
  external ffi.Pointer<wire_cst_liquid_address_data> address;
}

final class wire_cst_InputType_Bolt11 extends ffi.Struct {
  external ffi.Pointer<wire_cst_ln_invoice> invoice;
}

final class wire_cst_InputType_NodeId extends ffi.Struct {
  external ffi.Pointer<wire_cst_list_prim_u_8_strict> node_id;
}

final class wire_cst_InputType_Url extends ffi.Struct {
  external ffi.Pointer<wire_cst_list_prim_u_8_strict> url;
}

final class wire_cst_InputType_LnUrlPay extends ffi.Struct {
  external ffi.Pointer<wire_cst_ln_url_pay_request_data> data;
}

final class wire_cst_InputType_LnUrlWithdraw extends ffi.Struct {
  external ffi.Pointer<wire_cst_ln_url_withdraw_request_data> data;
}

final class wire_cst_InputType_LnUrlAuth extends ffi.Struct {
  external ffi.Pointer<wire_cst_ln_url_auth_request_data> data;
}

final class wire_cst_InputType_LnUrlError extends ffi.Struct {
  external ffi.Pointer<wire_cst_ln_url_error_data> data;
}

final class InputTypeKind extends ffi.Union {
  external wire_cst_InputType_BitcoinAddress BitcoinAddress;

  external wire_cst_InputType_LiquidAddress LiquidAddress;

  external wire_cst_InputType_Bolt11 Bolt11;

  external wire_cst_InputType_NodeId NodeId;

  external wire_cst_InputType_Url Url;

  external wire_cst_InputType_LnUrlPay LnUrlPay;

  external wire_cst_InputType_LnUrlWithdraw LnUrlWithdraw;

  external wire_cst_InputType_LnUrlAuth LnUrlAuth;

  external wire_cst_InputType_LnUrlError LnUrlError;
}

final class wire_cst_input_type extends ffi.Struct {
  @ffi.Int32()
  external int tag;

  external InputTypeKind kind;
}

final class wire_cst_limits extends ffi.Struct {
  @ffi.Uint64()
  external int min_sat;

  @ffi.Uint64()
  external int max_sat;

  @ffi.Uint64()
  external int max_zero_conf_sat;
}

final class wire_cst_lightning_payment_limits_response extends ffi.Struct {
  external wire_cst_limits send;

  external wire_cst_limits receive;
}

final class wire_cst_LnUrlAuthError_Generic extends ffi.Struct {
  external ffi.Pointer<wire_cst_list_prim_u_8_strict> err;
}

final class wire_cst_LnUrlAuthError_InvalidUri extends ffi.Struct {
  external ffi.Pointer<wire_cst_list_prim_u_8_strict> err;
}

final class wire_cst_LnUrlAuthError_ServiceConnectivity extends ffi.Struct {
  external ffi.Pointer<wire_cst_list_prim_u_8_strict> err;
}

final class LnUrlAuthErrorKind extends ffi.Union {
  external wire_cst_LnUrlAuthError_Generic Generic;

  external wire_cst_LnUrlAuthError_InvalidUri InvalidUri;

  external wire_cst_LnUrlAuthError_ServiceConnectivity ServiceConnectivity;
}

final class wire_cst_ln_url_auth_error extends ffi.Struct {
  @ffi.Int32()
  external int tag;

  external LnUrlAuthErrorKind kind;
}

final class wire_cst_LnUrlCallbackStatus_ErrorStatus extends ffi.Struct {
  external ffi.Pointer<wire_cst_ln_url_error_data> data;
}

final class LnUrlCallbackStatusKind extends ffi.Union {
  external wire_cst_LnUrlCallbackStatus_ErrorStatus ErrorStatus;
}

final class wire_cst_ln_url_callback_status extends ffi.Struct {
  @ffi.Int32()
  external int tag;

  external LnUrlCallbackStatusKind kind;
}

final class wire_cst_LnUrlPayError_Generic extends ffi.Struct {
  external ffi.Pointer<wire_cst_list_prim_u_8_strict> err;
}

final class wire_cst_LnUrlPayError_InvalidAmount extends ffi.Struct {
  external ffi.Pointer<wire_cst_list_prim_u_8_strict> err;
}

final class wire_cst_LnUrlPayError_InvalidInvoice extends ffi.Struct {
  external ffi.Pointer<wire_cst_list_prim_u_8_strict> err;
}

final class wire_cst_LnUrlPayError_InvalidNetwork extends ffi.Struct {
  external ffi.Pointer<wire_cst_list_prim_u_8_strict> err;
}

final class wire_cst_LnUrlPayError_InvalidUri extends ffi.Struct {
  external ffi.Pointer<wire_cst_list_prim_u_8_strict> err;
}

final class wire_cst_LnUrlPayError_InvoiceExpired extends ffi.Struct {
  external ffi.Pointer<wire_cst_list_prim_u_8_strict> err;
}

final class wire_cst_LnUrlPayError_PaymentFailed extends ffi.Struct {
  external ffi.Pointer<wire_cst_list_prim_u_8_strict> err;
}

final class wire_cst_LnUrlPayError_PaymentTimeout extends ffi.Struct {
  external ffi.Pointer<wire_cst_list_prim_u_8_strict> err;
}

final class wire_cst_LnUrlPayError_RouteNotFound extends ffi.Struct {
  external ffi.Pointer<wire_cst_list_prim_u_8_strict> err;
}

final class wire_cst_LnUrlPayError_RouteTooExpensive extends ffi.Struct {
  external ffi.Pointer<wire_cst_list_prim_u_8_strict> err;
}

final class wire_cst_LnUrlPayError_ServiceConnectivity extends ffi.Struct {
  external ffi.Pointer<wire_cst_list_prim_u_8_strict> err;
}

final class LnUrlPayErrorKind extends ffi.Union {
  external wire_cst_LnUrlPayError_Generic Generic;

  external wire_cst_LnUrlPayError_InvalidAmount InvalidAmount;

  external wire_cst_LnUrlPayError_InvalidInvoice InvalidInvoice;

  external wire_cst_LnUrlPayError_InvalidNetwork InvalidNetwork;

  external wire_cst_LnUrlPayError_InvalidUri InvalidUri;

  external wire_cst_LnUrlPayError_InvoiceExpired InvoiceExpired;

  external wire_cst_LnUrlPayError_PaymentFailed PaymentFailed;

  external wire_cst_LnUrlPayError_PaymentTimeout PaymentTimeout;

  external wire_cst_LnUrlPayError_RouteNotFound RouteNotFound;

  external wire_cst_LnUrlPayError_RouteTooExpensive RouteTooExpensive;

  external wire_cst_LnUrlPayError_ServiceConnectivity ServiceConnectivity;
}

final class wire_cst_ln_url_pay_error extends ffi.Struct {
  @ffi.Int32()
  external int tag;

  external LnUrlPayErrorKind kind;
}

final class wire_cst_LnUrlPayResult_EndpointSuccess extends ffi.Struct {
  external ffi.Pointer<wire_cst_ln_url_pay_success_data> data;
}

final class wire_cst_LnUrlPayResult_EndpointError extends ffi.Struct {
  external ffi.Pointer<wire_cst_ln_url_error_data> data;
}

final class wire_cst_LnUrlPayResult_PayError extends ffi.Struct {
  external ffi.Pointer<wire_cst_ln_url_pay_error_data> data;
}

final class LnUrlPayResultKind extends ffi.Union {
  external wire_cst_LnUrlPayResult_EndpointSuccess EndpointSuccess;

  external wire_cst_LnUrlPayResult_EndpointError EndpointError;

  external wire_cst_LnUrlPayResult_PayError PayError;
}

final class wire_cst_ln_url_pay_result extends ffi.Struct {
  @ffi.Int32()
  external int tag;

  external LnUrlPayResultKind kind;
}

final class wire_cst_LnUrlWithdrawError_Generic extends ffi.Struct {
  external ffi.Pointer<wire_cst_list_prim_u_8_strict> err;
}

final class wire_cst_LnUrlWithdrawError_InvalidAmount extends ffi.Struct {
  external ffi.Pointer<wire_cst_list_prim_u_8_strict> err;
}

final class wire_cst_LnUrlWithdrawError_InvalidInvoice extends ffi.Struct {
  external ffi.Pointer<wire_cst_list_prim_u_8_strict> err;
}

final class wire_cst_LnUrlWithdrawError_InvalidUri extends ffi.Struct {
  external ffi.Pointer<wire_cst_list_prim_u_8_strict> err;
}

final class wire_cst_LnUrlWithdrawError_InvoiceNoRoutingHints extends ffi.Struct {
  external ffi.Pointer<wire_cst_list_prim_u_8_strict> err;
}

final class wire_cst_LnUrlWithdrawError_ServiceConnectivity extends ffi.Struct {
  external ffi.Pointer<wire_cst_list_prim_u_8_strict> err;
}

final class LnUrlWithdrawErrorKind extends ffi.Union {
  external wire_cst_LnUrlWithdrawError_Generic Generic;

  external wire_cst_LnUrlWithdrawError_InvalidAmount InvalidAmount;

  external wire_cst_LnUrlWithdrawError_InvalidInvoice InvalidInvoice;

  external wire_cst_LnUrlWithdrawError_InvalidUri InvalidUri;

  external wire_cst_LnUrlWithdrawError_InvoiceNoRoutingHints InvoiceNoRoutingHints;

  external wire_cst_LnUrlWithdrawError_ServiceConnectivity ServiceConnectivity;
}

final class wire_cst_ln_url_withdraw_error extends ffi.Struct {
  @ffi.Int32()
  external int tag;

  external LnUrlWithdrawErrorKind kind;
}

final class wire_cst_LnUrlWithdrawResult_Ok extends ffi.Struct {
  external ffi.Pointer<wire_cst_ln_url_withdraw_success_data> data;
}

final class wire_cst_LnUrlWithdrawResult_Timeout extends ffi.Struct {
  external ffi.Pointer<wire_cst_ln_url_withdraw_success_data> data;
}

final class wire_cst_LnUrlWithdrawResult_ErrorStatus extends ffi.Struct {
  external ffi.Pointer<wire_cst_ln_url_error_data> data;
}

final class LnUrlWithdrawResultKind extends ffi.Union {
  external wire_cst_LnUrlWithdrawResult_Ok Ok;

  external wire_cst_LnUrlWithdrawResult_Timeout Timeout;

  external wire_cst_LnUrlWithdrawResult_ErrorStatus ErrorStatus;
}

final class wire_cst_ln_url_withdraw_result extends ffi.Struct {
  @ffi.Int32()
  external int tag;

  external LnUrlWithdrawResultKind kind;
}

final class wire_cst_log_entry extends ffi.Struct {
  external ffi.Pointer<wire_cst_list_prim_u_8_strict> line;

  external ffi.Pointer<wire_cst_list_prim_u_8_strict> level;
}

final class wire_cst_onchain_payment_limits_response extends ffi.Struct {
  external wire_cst_limits send;

  external wire_cst_limits receive;
}

final class wire_cst_PaymentError_AmountMissing extends ffi.Struct {
  external ffi.Pointer<wire_cst_list_prim_u_8_strict> err;
}

final class wire_cst_PaymentError_InvalidNetwork extends ffi.Struct {
  external ffi.Pointer<wire_cst_list_prim_u_8_strict> err;
}

final class wire_cst_PaymentError_Generic extends ffi.Struct {
  external ffi.Pointer<wire_cst_list_prim_u_8_strict> err;
}

final class wire_cst_PaymentError_InvalidDescription extends ffi.Struct {
  external ffi.Pointer<wire_cst_list_prim_u_8_strict> err;
}

final class wire_cst_PaymentError_InvalidInvoice extends ffi.Struct {
  external ffi.Pointer<wire_cst_list_prim_u_8_strict> err;
}

final class wire_cst_PaymentError_LwkError extends ffi.Struct {
  external ffi.Pointer<wire_cst_list_prim_u_8_strict> err;
}

final class wire_cst_PaymentError_ReceiveError extends ffi.Struct {
  external ffi.Pointer<wire_cst_list_prim_u_8_strict> err;
}

final class wire_cst_PaymentError_Refunded extends ffi.Struct {
  external ffi.Pointer<wire_cst_list_prim_u_8_strict> err;

  external ffi.Pointer<wire_cst_list_prim_u_8_strict> refund_tx_id;
}

final class wire_cst_PaymentError_SendError extends ffi.Struct {
  external ffi.Pointer<wire_cst_list_prim_u_8_strict> err;
}

final class wire_cst_PaymentError_SignerError extends ffi.Struct {
  external ffi.Pointer<wire_cst_list_prim_u_8_strict> err;
}

final class PaymentErrorKind extends ffi.Union {
  external wire_cst_PaymentError_AmountMissing AmountMissing;

  external wire_cst_PaymentError_InvalidNetwork InvalidNetwork;

  external wire_cst_PaymentError_Generic Generic;

  external wire_cst_PaymentError_InvalidDescription InvalidDescription;

  external wire_cst_PaymentError_InvalidInvoice InvalidInvoice;

  external wire_cst_PaymentError_LwkError LwkError;

  external wire_cst_PaymentError_ReceiveError ReceiveError;

  external wire_cst_PaymentError_Refunded Refunded;

  external wire_cst_PaymentError_SendError SendError;

  external wire_cst_PaymentError_SignerError SignerError;
}

final class wire_cst_payment_error extends ffi.Struct {
  @ffi.Int32()
  external int tag;

  external PaymentErrorKind kind;
}

final class wire_cst_prepare_refund_response extends ffi.Struct {
  @ffi.Uint32()
  external int tx_vsize;

  @ffi.Uint64()
  external int tx_fee_sat;

  external ffi.Pointer<wire_cst_list_prim_u_8_strict> refund_tx_id;
}

final class wire_cst_receive_payment_response extends ffi.Struct {
  external ffi.Pointer<wire_cst_list_prim_u_8_strict> destination;
}

final class wire_cst_recommended_fees extends ffi.Struct {
  @ffi.Uint64()
  external int fastest_fee;

  @ffi.Uint64()
  external int half_hour_fee;

  @ffi.Uint64()
  external int hour_fee;

  @ffi.Uint64()
  external int economy_fee;

  @ffi.Uint64()
  external int minimum_fee;
}

final class wire_cst_refund_response extends ffi.Struct {
  external ffi.Pointer<wire_cst_list_prim_u_8_strict> refund_tx_id;
}

final class wire_cst_SdkError_Generic extends ffi.Struct {
  external ffi.Pointer<wire_cst_list_prim_u_8_strict> err;
}

final class wire_cst_SdkError_ServiceConnectivity extends ffi.Struct {
  external ffi.Pointer<wire_cst_list_prim_u_8_strict> err;
}

final class SdkErrorKind extends ffi.Union {
  external wire_cst_SdkError_Generic Generic;

  external wire_cst_SdkError_ServiceConnectivity ServiceConnectivity;
}

final class wire_cst_sdk_error extends ffi.Struct {
  @ffi.Int32()
  external int tag;

  external SdkErrorKind kind;
}

final class wire_cst_send_payment_response extends ffi.Struct {
  external wire_cst_payment payment;
}

final class wire_cst_sign_message_response extends ffi.Struct {
  external ffi.Pointer<wire_cst_list_prim_u_8_strict> signature;
}

const int ESTIMATED_BTC_CLAIM_TX_VSIZE = 111;

const double STANDARD_FEE_RATE_SAT_PER_VBYTE = 0.1;

const double LOWBALL_FEE_RATE_SAT_PER_VBYTE = 0.01;

const int DEFAULT_ZERO_CONF_MIN_FEE_RATE_TESTNET = 100;

const int DEFAULT_ZERO_CONF_MIN_FEE_RATE_MAINNET = 10;

const int DEFAULT_ZERO_CONF_MAX_SAT = 100000;

const int CHAIN_SWAP_MONITORING_PERIOD_BITCOIN_BLOCKS = 4320;