frb_generated.dart

// This file is automatically generated, so please do not edit it.
// Generated by `flutter_rust_bridge`@ 2.0.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 'api/bitcoin_ffi.dart';
import 'api/io.dart';
import 'api/receive.dart';
import 'api/send.dart';
import 'api/uri.dart';
import 'dart:async';
import 'dart:convert';
import 'frb_generated.dart';
import 'frb_generated.io.dart'
    if (dart.library.js_interop) 'frb_generated.web.dart';
import 'lib.dart';
import 'package:flutter_rust_bridge/flutter_rust_bridge_for_generated.dart';
import 'utils/error.dart';
import 'utils/types.dart';

/// Main entrypoint of the Rust API
class core extends BaseEntrypoint<coreApi, coreApiImpl, coreWire> {
  @internal
  static final instance = core._();

  core._();

  /// Initialize flutter_rust_bridge
  static Future<void> init({
    coreApi? api,
    BaseHandler? handler,
    ExternalLibrary? externalLibrary,
  }) async {
    await instance.initImpl(
      api: api,
      handler: handler,
      externalLibrary: externalLibrary,
    );
  }

  /// Dispose flutter_rust_bridge
  ///
  /// The call to this function is optional, since flutter_rust_bridge (and everything else)
  /// is automatically disposed when the app stops.
  static void dispose() => instance.disposeImpl();

  @override
  ApiImplConstructor<coreApiImpl, coreWire> get apiImplConstructor =>
      coreApiImpl.new;

  @override
  WireConstructor<coreWire> get wireConstructor => coreWire.fromExternalLibrary;

  @override
  Future<void> executeRustInitializers() async {}

  @override
  ExternalLibraryLoaderConfig get defaultExternalLibraryLoaderConfig =>
      kDefaultExternalLibraryLoaderConfig;

  @override
  String get codegenVersion => '2.0.0';

  @override
  int get rustContentHash => -1997949636;

  static const kDefaultExternalLibraryLoaderConfig =
      ExternalLibraryLoaderConfig(
    stem: 'payjoin_flutter',
    ioDirectory: 'rust/target/release/',
    webPrefix: 'pkg/',
  );
}

abstract class coreApi extends BaseApi {
  Future<FfiScript> crateApiBitcoinFfiFfiScriptNew(
      {required List<int> rawOutputScript});

  Future<Uint8List> crateApiBitcoinFfiFfiScriptToBytes(
      {required FfiScript that});

  Future<FfiOhttpKeys> crateApiIoFetchOhttpKeys(
      {required FfiUrl ohttpRelay, required FfiUrl payjoinDirectory});

  Future<FfiInputPair> crateApiReceiveFfiInputPairNew(
      {required TxIn txin, required PsbtInput psbtin});

  Future<FfiMaybeInputsSeen>
      crateApiReceiveFfiMaybeInputsOwnedCheckInputsNotOwned(
          {required FfiMaybeInputsOwned that,
          required FutureOr<bool> Function(Uint8List) isOwned});

  Future<FfiOutputsUnknown>
      crateApiReceiveFfiMaybeInputsSeenCheckNoInputsSeenBefore(
          {required FfiMaybeInputsSeen that,
          required FutureOr<bool> Function(OutPoint) isKnown});

  Future<FfiWantsOutputs>
      crateApiReceiveFfiOutputsUnknownIdentifyReceiverOutputs(
          {required FfiOutputsUnknown that,
          required FutureOr<bool> Function(Uint8List) isReceiverOutput});

  Future<String> crateApiReceiveFfiPayjoinProposalExtractV1Req(
      {required FfiPayjoinProposal that});

  Future<(Request, ClientResponse)>
      crateApiReceiveFfiPayjoinProposalExtractV2Req(
          {required FfiPayjoinProposal that});

  Future<bool> crateApiReceiveFfiPayjoinProposalIsOutputSubstitutionDisabled(
      {required FfiPayjoinProposal that});

  Future<void> crateApiReceiveFfiPayjoinProposalProcessRes(
      {required FfiPayjoinProposal that,
      required List<int> res,
      required ClientResponse ohttpContext});

  Future<String> crateApiReceiveFfiPayjoinProposalPsbt(
      {required FfiPayjoinProposal that});

  Future<List<OutPoint>> crateApiReceiveFfiPayjoinProposalUtxosToBeLocked(
      {required FfiPayjoinProposal that});

  Future<FfiPayjoinProposal>
      crateApiReceiveFfiProvisionalProposalFinalizeProposal(
          {required FfiProvisionalProposal that,
          required FutureOr<String> Function(String) processPsbt,
          BigInt? minFeeRateSatPerVb,
          required BigInt maxFeeRateSatPerVb});

  Future<FfiReceiver> crateApiReceiveFfiReceiverCreate(
      {required String address,
      required Network network,
      required FfiUrl directory,
      required FfiOhttpKeys ohttpKeys,
      required FfiUrl ohttpRelay,
      BigInt? expireAfter});

  Future<(Request, ClientResponse)> crateApiReceiveFfiReceiverExtractReq(
      {required FfiReceiver that});

  FfiReceiver crateApiReceiveFfiReceiverFromJson({required String json});

  String crateApiReceiveFfiReceiverId({required FfiReceiver that});

  FfiPjUriBuilder crateApiReceiveFfiReceiverPjUriBuilder(
      {required FfiReceiver that});

  Future<FfiUrl> crateApiReceiveFfiReceiverPjUrl({required FfiReceiver that});

  Future<FfiUncheckedProposal?> crateApiReceiveFfiReceiverProcessRes(
      {required FfiReceiver that,
      required List<int> body,
      required ClientResponse ctx});

  String crateApiReceiveFfiReceiverToJson({required FfiReceiver that});

  Future<FfiMaybeInputsOwned>
      crateApiReceiveFfiUncheckedProposalAssumeInteractiveReceiver(
          {required FfiUncheckedProposal that});

  Future<FfiMaybeInputsOwned>
      crateApiReceiveFfiUncheckedProposalCheckBroadcastSuitability(
          {required FfiUncheckedProposal that,
          BigInt? minFeeRate,
          required FutureOr<bool> Function(Uint8List) canBroadcast});

  Future<Uint8List>
      crateApiReceiveFfiUncheckedProposalExtractTxToScheduleBroadcast(
          {required FfiUncheckedProposal that});

  Future<FfiProvisionalProposal> crateApiReceiveFfiWantsInputsCommitInputs(
      {required FfiWantsInputs that});

  Future<FfiWantsInputs> crateApiReceiveFfiWantsInputsContributeInputs(
      {required FfiWantsInputs that,
      required List<FfiInputPair> replacementInputs});

  Future<FfiInputPair> crateApiReceiveFfiWantsInputsTryPreservingPrivacy(
      {required FfiWantsInputs that,
      required List<FfiInputPair> candidateInputs});

  Future<FfiWantsInputs> crateApiReceiveFfiWantsOutputsCommitOutputs(
      {required FfiWantsOutputs that});

  Future<bool> crateApiReceiveFfiWantsOutputsIsOutputSubstitutionDisabled(
      {required FfiWantsOutputs that});

  Future<FfiWantsOutputs> crateApiReceiveFfiWantsOutputsReplaceReceiverOutputs(
      {required FfiWantsOutputs that,
      required List<TxOut> replacementOutputs,
      required FfiScript drainScript});

  Future<FfiWantsOutputs>
      crateApiReceiveFfiWantsOutputsSubstituteReceiverScript(
          {required FfiWantsOutputs that, required FfiScript outputScript});

  Future<FfiSenderBuilder>
      crateApiSendFfiSenderBuilderAlwaysDisableOutputSubstitution(
          {required FfiSenderBuilder that, required bool disable});

  Future<FfiSender> crateApiSendFfiSenderBuilderBuildNonIncentivizing(
      {required FfiSenderBuilder that, required BigInt minFeeRate});

  Future<FfiSender> crateApiSendFfiSenderBuilderBuildRecommended(
      {required FfiSenderBuilder that, required BigInt minFeeRate});

  Future<FfiSender> crateApiSendFfiSenderBuilderBuildWithAdditionalFee(
      {required FfiSenderBuilder that,
      required BigInt maxFeeContribution,
      int? changeIndex,
      required BigInt minFeeRate,
      required bool clampFeeContribution});

  Future<FfiSenderBuilder> crateApiSendFfiSenderBuilderFromPsbtAndUri(
      {required String psbtBase64, required FfiPjUri pjUri});

  Future<(Request, FfiV1Context)> crateApiSendFfiSenderExtractV1(
      {required FfiSender that});

  Future<(Request, FfiV2PostContext)> crateApiSendFfiSenderExtractV2(
      {required FfiSender that, required FfiUrl ohttpProxyUrl});

  FfiSender crateApiSendFfiSenderFromJson({required String json});

  String crateApiSendFfiSenderToJson({required FfiSender that});

  Future<String> crateApiSendFfiV1ContextProcessResponse(
      {required FfiV1Context that, required List<int> response});

  Future<(Request, ClientResponse)> crateApiSendFfiV2GetContextExtractReq(
      {required FfiV2GetContext that, required FfiUrl ohttpRelay});

  Future<String?> crateApiSendFfiV2GetContextProcessResponse(
      {required FfiV2GetContext that,
      required List<int> response,
      required ClientResponse ohttpCtx});

  Future<FfiV2GetContext> crateApiSendFfiV2PostContextProcessResponse(
      {required FfiV2PostContext that, required List<int> response});

  Future<FfiOhttpKeys> crateApiUriFfiOhttpKeysDecode(
      {required List<int> bytes});

  String crateApiUriFfiPjUriAddress({required FfiPjUri that});

  BigInt? crateApiUriFfiPjUriAmountSats({required FfiPjUri that});

  String crateApiUriFfiPjUriAsString({required FfiPjUri that});

  FfiPjUriBuilder crateApiUriFfiPjUriBuilderAmountSats(
      {required FfiPjUriBuilder that, required BigInt amount});

  FfiPjUri crateApiUriFfiPjUriBuilderBuild({required FfiPjUriBuilder that});

  FfiPjUriBuilder crateApiUriFfiPjUriBuilderLabel(
      {required FfiPjUriBuilder that, required String label});

  FfiPjUriBuilder crateApiUriFfiPjUriBuilderMessage(
      {required FfiPjUriBuilder that, required String message});

  FfiPjUriBuilder crateApiUriFfiPjUriBuilderPjos(
      {required FfiPjUriBuilder that, required bool pjos});

  String crateApiUriFfiPjUriPjEndpoint({required FfiPjUri that});

  String crateApiUriFfiUriAddress({required FfiUri that});

  BigInt? crateApiUriFfiUriAmountSats({required FfiUri that});

  String crateApiUriFfiUriAsString({required FfiUri that});

  FfiPjUri crateApiUriFfiUriCheckPjSupported({required FfiUri that});

  String? crateApiUriFfiUriLabel({required FfiUri that});

  String? crateApiUriFfiUriMessage({required FfiUri that});

  FfiUri crateApiUriFfiUriParse({required String uri});

  String crateApiUriFfiUrlAsString({required FfiUrl that});

  FfiUrl crateApiUriFfiUrlParse({required String url});

  String? crateApiUriFfiUrlQuery({required FfiUrl that});

  RustArcIncrementStrongCountFnType get rust_arc_increment_strong_count_Script;

  RustArcDecrementStrongCountFnType get rust_arc_decrement_strong_count_Script;

  CrossPlatformFinalizerArg get rust_arc_decrement_strong_count_ScriptPtr;

  RustArcIncrementStrongCountFnType
      get rust_arc_increment_strong_count_OhttpKeys;

  RustArcDecrementStrongCountFnType
      get rust_arc_decrement_strong_count_OhttpKeys;

  CrossPlatformFinalizerArg get rust_arc_decrement_strong_count_OhttpKeysPtr;

  RustArcIncrementStrongCountFnType get rust_arc_increment_strong_count_Url;

  RustArcDecrementStrongCountFnType get rust_arc_decrement_strong_count_Url;

  CrossPlatformFinalizerArg get rust_arc_decrement_strong_count_UrlPtr;

  RustArcIncrementStrongCountFnType
      get rust_arc_increment_strong_count_InputPair;

  RustArcDecrementStrongCountFnType
      get rust_arc_decrement_strong_count_InputPair;

  CrossPlatformFinalizerArg get rust_arc_decrement_strong_count_InputPairPtr;

  RustArcIncrementStrongCountFnType
      get rust_arc_increment_strong_count_MaybeInputsOwned;

  RustArcDecrementStrongCountFnType
      get rust_arc_decrement_strong_count_MaybeInputsOwned;

  CrossPlatformFinalizerArg
      get rust_arc_decrement_strong_count_MaybeInputsOwnedPtr;

  RustArcIncrementStrongCountFnType
      get rust_arc_increment_strong_count_MaybeInputsSeen;

  RustArcDecrementStrongCountFnType
      get rust_arc_decrement_strong_count_MaybeInputsSeen;

  CrossPlatformFinalizerArg
      get rust_arc_decrement_strong_count_MaybeInputsSeenPtr;

  RustArcIncrementStrongCountFnType
      get rust_arc_increment_strong_count_OutputsUnknown;

  RustArcDecrementStrongCountFnType
      get rust_arc_decrement_strong_count_OutputsUnknown;

  CrossPlatformFinalizerArg
      get rust_arc_decrement_strong_count_OutputsUnknownPtr;

  RustArcIncrementStrongCountFnType
      get rust_arc_increment_strong_count_PayjoinProposal;

  RustArcDecrementStrongCountFnType
      get rust_arc_decrement_strong_count_PayjoinProposal;

  CrossPlatformFinalizerArg
      get rust_arc_decrement_strong_count_PayjoinProposalPtr;

  RustArcIncrementStrongCountFnType
      get rust_arc_increment_strong_count_ProvisionalProposal;

  RustArcDecrementStrongCountFnType
      get rust_arc_decrement_strong_count_ProvisionalProposal;

  CrossPlatformFinalizerArg
      get rust_arc_decrement_strong_count_ProvisionalProposalPtr;

  RustArcIncrementStrongCountFnType
      get rust_arc_increment_strong_count_Receiver;

  RustArcDecrementStrongCountFnType
      get rust_arc_decrement_strong_count_Receiver;

  CrossPlatformFinalizerArg get rust_arc_decrement_strong_count_ReceiverPtr;

  RustArcIncrementStrongCountFnType
      get rust_arc_increment_strong_count_UncheckedProposal;

  RustArcDecrementStrongCountFnType
      get rust_arc_decrement_strong_count_UncheckedProposal;

  CrossPlatformFinalizerArg
      get rust_arc_decrement_strong_count_UncheckedProposalPtr;

  RustArcIncrementStrongCountFnType
      get rust_arc_increment_strong_count_WantsInputs;

  RustArcDecrementStrongCountFnType
      get rust_arc_decrement_strong_count_WantsInputs;

  CrossPlatformFinalizerArg get rust_arc_decrement_strong_count_WantsInputsPtr;

  RustArcIncrementStrongCountFnType
      get rust_arc_increment_strong_count_WantsOutputs;

  RustArcDecrementStrongCountFnType
      get rust_arc_decrement_strong_count_WantsOutputs;

  CrossPlatformFinalizerArg get rust_arc_decrement_strong_count_WantsOutputsPtr;

  RustArcIncrementStrongCountFnType get rust_arc_increment_strong_count_Sender;

  RustArcDecrementStrongCountFnType get rust_arc_decrement_strong_count_Sender;

  CrossPlatformFinalizerArg get rust_arc_decrement_strong_count_SenderPtr;

  RustArcIncrementStrongCountFnType
      get rust_arc_increment_strong_count_SenderBuilder;

  RustArcDecrementStrongCountFnType
      get rust_arc_decrement_strong_count_SenderBuilder;

  CrossPlatformFinalizerArg
      get rust_arc_decrement_strong_count_SenderBuilderPtr;

  RustArcIncrementStrongCountFnType
      get rust_arc_increment_strong_count_V1Context;

  RustArcDecrementStrongCountFnType
      get rust_arc_decrement_strong_count_V1Context;

  CrossPlatformFinalizerArg get rust_arc_decrement_strong_count_V1ContextPtr;

  RustArcIncrementStrongCountFnType
      get rust_arc_increment_strong_count_V2GetContext;

  RustArcDecrementStrongCountFnType
      get rust_arc_decrement_strong_count_V2GetContext;

  CrossPlatformFinalizerArg get rust_arc_decrement_strong_count_V2GetContextPtr;

  RustArcIncrementStrongCountFnType
      get rust_arc_increment_strong_count_V2PostContext;

  RustArcDecrementStrongCountFnType
      get rust_arc_decrement_strong_count_V2PostContext;

  CrossPlatformFinalizerArg
      get rust_arc_decrement_strong_count_V2PostContextPtr;

  RustArcIncrementStrongCountFnType get rust_arc_increment_strong_count_PjUri;

  RustArcDecrementStrongCountFnType get rust_arc_decrement_strong_count_PjUri;

  CrossPlatformFinalizerArg get rust_arc_decrement_strong_count_PjUriPtr;

  RustArcIncrementStrongCountFnType
      get rust_arc_increment_strong_count_PjUriBuilder;

  RustArcDecrementStrongCountFnType
      get rust_arc_decrement_strong_count_PjUriBuilder;

  CrossPlatformFinalizerArg get rust_arc_decrement_strong_count_PjUriBuilderPtr;

  RustArcIncrementStrongCountFnType get rust_arc_increment_strong_count_Uri;

  RustArcDecrementStrongCountFnType get rust_arc_decrement_strong_count_Uri;

  CrossPlatformFinalizerArg get rust_arc_decrement_strong_count_UriPtr;

  RustArcIncrementStrongCountFnType
      get rust_arc_increment_strong_count_MutexOptionClientResponse;

  RustArcDecrementStrongCountFnType
      get rust_arc_decrement_strong_count_MutexOptionClientResponse;

  CrossPlatformFinalizerArg
      get rust_arc_decrement_strong_count_MutexOptionClientResponsePtr;
}

class coreApiImpl extends coreApiImplPlatform implements coreApi {
  coreApiImpl({
    required super.handler,
    required super.wire,
    required super.generalizedFrbRustBinding,
    required super.portManager,
  });

  @override
  Future<FfiScript> crateApiBitcoinFfiFfiScriptNew(
      {required List<int> rawOutputScript}) {
    return handler.executeNormal(NormalTask(
      callFfi: (port_) {
        var arg0 = cst_encode_list_prim_u_8_loose(rawOutputScript);
        return wire.wire__crate__api__bitcoin_ffi__ffi_script_new(port_, arg0);
      },
      codec: DcoCodec(
        decodeSuccessData: dco_decode_ffi_script,
        decodeErrorData: null,
      ),
      constMeta: kCrateApiBitcoinFfiFfiScriptNewConstMeta,
      argValues: [rawOutputScript],
      apiImpl: this,
    ));
  }

  TaskConstMeta get kCrateApiBitcoinFfiFfiScriptNewConstMeta =>
      const TaskConstMeta(
        debugName: "ffi_script_new",
        argNames: ["rawOutputScript"],
      );

  @override
  Future<Uint8List> crateApiBitcoinFfiFfiScriptToBytes(
      {required FfiScript that}) {
    return handler.executeNormal(NormalTask(
      callFfi: (port_) {
        var arg0 = cst_encode_box_autoadd_ffi_script(that);
        return wire.wire__crate__api__bitcoin_ffi__ffi_script_to_bytes(
            port_, arg0);
      },
      codec: DcoCodec(
        decodeSuccessData: dco_decode_list_prim_u_8_strict,
        decodeErrorData: null,
      ),
      constMeta: kCrateApiBitcoinFfiFfiScriptToBytesConstMeta,
      argValues: [that],
      apiImpl: this,
    ));
  }

  TaskConstMeta get kCrateApiBitcoinFfiFfiScriptToBytesConstMeta =>
      const TaskConstMeta(
        debugName: "ffi_script_to_bytes",
        argNames: ["that"],
      );

  @override
  Future<FfiOhttpKeys> crateApiIoFetchOhttpKeys(
      {required FfiUrl ohttpRelay, required FfiUrl payjoinDirectory}) {
    return handler.executeNormal(NormalTask(
      callFfi: (port_) {
        var arg0 = cst_encode_box_autoadd_ffi_url(ohttpRelay);
        var arg1 = cst_encode_box_autoadd_ffi_url(payjoinDirectory);
        return wire.wire__crate__api__io__fetch_ohttp_keys(port_, arg0, arg1);
      },
      codec: DcoCodec(
        decodeSuccessData: dco_decode_ffi_ohttp_keys,
        decodeErrorData: dco_decode_payjoin_error,
      ),
      constMeta: kCrateApiIoFetchOhttpKeysConstMeta,
      argValues: [ohttpRelay, payjoinDirectory],
      apiImpl: this,
    ));
  }

  TaskConstMeta get kCrateApiIoFetchOhttpKeysConstMeta => const TaskConstMeta(
        debugName: "fetch_ohttp_keys",
        argNames: ["ohttpRelay", "payjoinDirectory"],
      );

  @override
  Future<FfiInputPair> crateApiReceiveFfiInputPairNew(
      {required TxIn txin, required PsbtInput psbtin}) {
    return handler.executeNormal(NormalTask(
      callFfi: (port_) {
        var arg0 = cst_encode_box_autoadd_tx_in(txin);
        var arg1 = cst_encode_box_autoadd_psbt_input(psbtin);
        return wire.wire__crate__api__receive__ffi_input_pair_new(
            port_, arg0, arg1);
      },
      codec: DcoCodec(
        decodeSuccessData: dco_decode_ffi_input_pair,
        decodeErrorData: dco_decode_payjoin_error,
      ),
      constMeta: kCrateApiReceiveFfiInputPairNewConstMeta,
      argValues: [txin, psbtin],
      apiImpl: this,
    ));
  }

  TaskConstMeta get kCrateApiReceiveFfiInputPairNewConstMeta =>
      const TaskConstMeta(
        debugName: "ffi_input_pair_new",
        argNames: ["txin", "psbtin"],
      );

  @override
  Future<FfiMaybeInputsSeen>
      crateApiReceiveFfiMaybeInputsOwnedCheckInputsNotOwned(
          {required FfiMaybeInputsOwned that,
          required FutureOr<bool> Function(Uint8List) isOwned}) {
    return handler.executeNormal(NormalTask(
      callFfi: (port_) {
        var arg0 = cst_encode_box_autoadd_ffi_maybe_inputs_owned(that);
        var arg1 =
            cst_encode_DartFn_Inputs_list_prim_u_8_strict_Output_bool_AnyhowException(
                isOwned);
        return wire
            .wire__crate__api__receive__ffi_maybe_inputs_owned_check_inputs_not_owned(
                port_, arg0, arg1);
      },
      codec: DcoCodec(
        decodeSuccessData: dco_decode_ffi_maybe_inputs_seen,
        decodeErrorData: dco_decode_payjoin_error,
      ),
      constMeta:
          kCrateApiReceiveFfiMaybeInputsOwnedCheckInputsNotOwnedConstMeta,
      argValues: [that, isOwned],
      apiImpl: this,
    ));
  }

  TaskConstMeta
      get kCrateApiReceiveFfiMaybeInputsOwnedCheckInputsNotOwnedConstMeta =>
          const TaskConstMeta(
            debugName: "ffi_maybe_inputs_owned_check_inputs_not_owned",
            argNames: ["that", "isOwned"],
          );

  @override
  Future<FfiOutputsUnknown>
      crateApiReceiveFfiMaybeInputsSeenCheckNoInputsSeenBefore(
          {required FfiMaybeInputsSeen that,
          required FutureOr<bool> Function(OutPoint) isKnown}) {
    return handler.executeNormal(NormalTask(
      callFfi: (port_) {
        var arg0 = cst_encode_box_autoadd_ffi_maybe_inputs_seen(that);
        var arg1 =
            cst_encode_DartFn_Inputs_out_point_Output_bool_AnyhowException(
                isKnown);
        return wire
            .wire__crate__api__receive__ffi_maybe_inputs_seen_check_no_inputs_seen_before(
                port_, arg0, arg1);
      },
      codec: DcoCodec(
        decodeSuccessData: dco_decode_ffi_outputs_unknown,
        decodeErrorData: dco_decode_payjoin_error,
      ),
      constMeta:
          kCrateApiReceiveFfiMaybeInputsSeenCheckNoInputsSeenBeforeConstMeta,
      argValues: [that, isKnown],
      apiImpl: this,
    ));
  }

  TaskConstMeta
      get kCrateApiReceiveFfiMaybeInputsSeenCheckNoInputsSeenBeforeConstMeta =>
          const TaskConstMeta(
            debugName: "ffi_maybe_inputs_seen_check_no_inputs_seen_before",
            argNames: ["that", "isKnown"],
          );

  @override
  Future<FfiWantsOutputs>
      crateApiReceiveFfiOutputsUnknownIdentifyReceiverOutputs(
          {required FfiOutputsUnknown that,
          required FutureOr<bool> Function(Uint8List) isReceiverOutput}) {
    return handler.executeNormal(NormalTask(
      callFfi: (port_) {
        var arg0 = cst_encode_box_autoadd_ffi_outputs_unknown(that);
        var arg1 =
            cst_encode_DartFn_Inputs_list_prim_u_8_strict_Output_bool_AnyhowException(
                isReceiverOutput);
        return wire
            .wire__crate__api__receive__ffi_outputs_unknown_identify_receiver_outputs(
                port_, arg0, arg1);
      },
      codec: DcoCodec(
        decodeSuccessData: dco_decode_ffi_wants_outputs,
        decodeErrorData: dco_decode_payjoin_error,
      ),
      constMeta:
          kCrateApiReceiveFfiOutputsUnknownIdentifyReceiverOutputsConstMeta,
      argValues: [that, isReceiverOutput],
      apiImpl: this,
    ));
  }

  TaskConstMeta
      get kCrateApiReceiveFfiOutputsUnknownIdentifyReceiverOutputsConstMeta =>
          const TaskConstMeta(
            debugName: "ffi_outputs_unknown_identify_receiver_outputs",
            argNames: ["that", "isReceiverOutput"],
          );

  @override
  Future<String> crateApiReceiveFfiPayjoinProposalExtractV1Req(
      {required FfiPayjoinProposal that}) {
    return handler.executeNormal(NormalTask(
      callFfi: (port_) {
        var arg0 = cst_encode_box_autoadd_ffi_payjoin_proposal(that);
        return wire
            .wire__crate__api__receive__ffi_payjoin_proposal_extract_v1_req(
                port_, arg0);
      },
      codec: DcoCodec(
        decodeSuccessData: dco_decode_String,
        decodeErrorData: null,
      ),
      constMeta: kCrateApiReceiveFfiPayjoinProposalExtractV1ReqConstMeta,
      argValues: [that],
      apiImpl: this,
    ));
  }

  TaskConstMeta get kCrateApiReceiveFfiPayjoinProposalExtractV1ReqConstMeta =>
      const TaskConstMeta(
        debugName: "ffi_payjoin_proposal_extract_v1_req",
        argNames: ["that"],
      );

  @override
  Future<(Request, ClientResponse)>
      crateApiReceiveFfiPayjoinProposalExtractV2Req(
          {required FfiPayjoinProposal that}) {
    return handler.executeNormal(NormalTask(
      callFfi: (port_) {
        var arg0 = cst_encode_box_autoadd_ffi_payjoin_proposal(that);
        return wire
            .wire__crate__api__receive__ffi_payjoin_proposal_extract_v2_req(
                port_, arg0);
      },
      codec: DcoCodec(
        decodeSuccessData: dco_decode_record_request_client_response,
        decodeErrorData: dco_decode_payjoin_error,
      ),
      constMeta: kCrateApiReceiveFfiPayjoinProposalExtractV2ReqConstMeta,
      argValues: [that],
      apiImpl: this,
    ));
  }

  TaskConstMeta get kCrateApiReceiveFfiPayjoinProposalExtractV2ReqConstMeta =>
      const TaskConstMeta(
        debugName: "ffi_payjoin_proposal_extract_v2_req",
        argNames: ["that"],
      );

  @override
  Future<bool> crateApiReceiveFfiPayjoinProposalIsOutputSubstitutionDisabled(
      {required FfiPayjoinProposal that}) {
    return handler.executeNormal(NormalTask(
      callFfi: (port_) {
        var arg0 = cst_encode_box_autoadd_ffi_payjoin_proposal(that);
        return wire
            .wire__crate__api__receive__ffi_payjoin_proposal_is_output_substitution_disabled(
                port_, arg0);
      },
      codec: DcoCodec(
        decodeSuccessData: dco_decode_bool,
        decodeErrorData: null,
      ),
      constMeta:
          kCrateApiReceiveFfiPayjoinProposalIsOutputSubstitutionDisabledConstMeta,
      argValues: [that],
      apiImpl: this,
    ));
  }

  TaskConstMeta
      get kCrateApiReceiveFfiPayjoinProposalIsOutputSubstitutionDisabledConstMeta =>
          const TaskConstMeta(
            debugName: "ffi_payjoin_proposal_is_output_substitution_disabled",
            argNames: ["that"],
          );

  @override
  Future<void> crateApiReceiveFfiPayjoinProposalProcessRes(
      {required FfiPayjoinProposal that,
      required List<int> res,
      required ClientResponse ohttpContext}) {
    return handler.executeNormal(NormalTask(
      callFfi: (port_) {
        var arg0 = cst_encode_box_autoadd_ffi_payjoin_proposal(that);
        var arg1 = cst_encode_list_prim_u_8_loose(res);
        var arg2 = cst_encode_box_autoadd_client_response(ohttpContext);
        return wire.wire__crate__api__receive__ffi_payjoin_proposal_process_res(
            port_, arg0, arg1, arg2);
      },
      codec: DcoCodec(
        decodeSuccessData: dco_decode_unit,
        decodeErrorData: dco_decode_payjoin_error,
      ),
      constMeta: kCrateApiReceiveFfiPayjoinProposalProcessResConstMeta,
      argValues: [that, res, ohttpContext],
      apiImpl: this,
    ));
  }

  TaskConstMeta get kCrateApiReceiveFfiPayjoinProposalProcessResConstMeta =>
      const TaskConstMeta(
        debugName: "ffi_payjoin_proposal_process_res",
        argNames: ["that", "res", "ohttpContext"],
      );

  @override
  Future<String> crateApiReceiveFfiPayjoinProposalPsbt(
      {required FfiPayjoinProposal that}) {
    return handler.executeNormal(NormalTask(
      callFfi: (port_) {
        var arg0 = cst_encode_box_autoadd_ffi_payjoin_proposal(that);
        return wire.wire__crate__api__receive__ffi_payjoin_proposal_psbt(
            port_, arg0);
      },
      codec: DcoCodec(
        decodeSuccessData: dco_decode_String,
        decodeErrorData: null,
      ),
      constMeta: kCrateApiReceiveFfiPayjoinProposalPsbtConstMeta,
      argValues: [that],
      apiImpl: this,
    ));
  }

  TaskConstMeta get kCrateApiReceiveFfiPayjoinProposalPsbtConstMeta =>
      const TaskConstMeta(
        debugName: "ffi_payjoin_proposal_psbt",
        argNames: ["that"],
      );

  @override
  Future<List<OutPoint>> crateApiReceiveFfiPayjoinProposalUtxosToBeLocked(
      {required FfiPayjoinProposal that}) {
    return handler.executeNormal(NormalTask(
      callFfi: (port_) {
        var arg0 = cst_encode_box_autoadd_ffi_payjoin_proposal(that);
        return wire
            .wire__crate__api__receive__ffi_payjoin_proposal_utxos_to_be_locked(
                port_, arg0);
      },
      codec: DcoCodec(
        decodeSuccessData: dco_decode_list_out_point,
        decodeErrorData: null,
      ),
      constMeta: kCrateApiReceiveFfiPayjoinProposalUtxosToBeLockedConstMeta,
      argValues: [that],
      apiImpl: this,
    ));
  }

  TaskConstMeta
      get kCrateApiReceiveFfiPayjoinProposalUtxosToBeLockedConstMeta =>
          const TaskConstMeta(
            debugName: "ffi_payjoin_proposal_utxos_to_be_locked",
            argNames: ["that"],
          );

  @override
  Future<FfiPayjoinProposal>
      crateApiReceiveFfiProvisionalProposalFinalizeProposal(
          {required FfiProvisionalProposal that,
          required FutureOr<String> Function(String) processPsbt,
          BigInt? minFeeRateSatPerVb,
          required BigInt maxFeeRateSatPerVb}) {
    return handler.executeNormal(NormalTask(
      callFfi: (port_) {
        var arg0 = cst_encode_box_autoadd_ffi_provisional_proposal(that);
        var arg1 =
            cst_encode_DartFn_Inputs_String_Output_String_AnyhowException(
                processPsbt);
        var arg2 = cst_encode_opt_box_autoadd_u_64(minFeeRateSatPerVb);
        var arg3 = cst_encode_u_64(maxFeeRateSatPerVb);
        return wire
            .wire__crate__api__receive__ffi_provisional_proposal_finalize_proposal(
                port_, arg0, arg1, arg2, arg3);
      },
      codec: DcoCodec(
        decodeSuccessData: dco_decode_ffi_payjoin_proposal,
        decodeErrorData: dco_decode_payjoin_error,
      ),
      constMeta:
          kCrateApiReceiveFfiProvisionalProposalFinalizeProposalConstMeta,
      argValues: [that, processPsbt, minFeeRateSatPerVb, maxFeeRateSatPerVb],
      apiImpl: this,
    ));
  }

  TaskConstMeta
      get kCrateApiReceiveFfiProvisionalProposalFinalizeProposalConstMeta =>
          const TaskConstMeta(
            debugName: "ffi_provisional_proposal_finalize_proposal",
            argNames: [
              "that",
              "processPsbt",
              "minFeeRateSatPerVb",
              "maxFeeRateSatPerVb"
            ],
          );

  @override
  Future<FfiReceiver> crateApiReceiveFfiReceiverCreate(
      {required String address,
      required Network network,
      required FfiUrl directory,
      required FfiOhttpKeys ohttpKeys,
      required FfiUrl ohttpRelay,
      BigInt? expireAfter}) {
    return handler.executeNormal(NormalTask(
      callFfi: (port_) {
        var arg0 = cst_encode_String(address);
        var arg1 = cst_encode_network(network);
        var arg2 = cst_encode_box_autoadd_ffi_url(directory);
        var arg3 = cst_encode_box_autoadd_ffi_ohttp_keys(ohttpKeys);
        var arg4 = cst_encode_box_autoadd_ffi_url(ohttpRelay);
        var arg5 = cst_encode_opt_box_autoadd_u_64(expireAfter);
        return wire.wire__crate__api__receive__ffi_receiver_create(
            port_, arg0, arg1, arg2, arg3, arg4, arg5);
      },
      codec: DcoCodec(
        decodeSuccessData: dco_decode_ffi_receiver,
        decodeErrorData: dco_decode_payjoin_error,
      ),
      constMeta: kCrateApiReceiveFfiReceiverCreateConstMeta,
      argValues: [
        address,
        network,
        directory,
        ohttpKeys,
        ohttpRelay,
        expireAfter
      ],
      apiImpl: this,
    ));
  }

  TaskConstMeta get kCrateApiReceiveFfiReceiverCreateConstMeta =>
      const TaskConstMeta(
        debugName: "ffi_receiver_create",
        argNames: [
          "address",
          "network",
          "directory",
          "ohttpKeys",
          "ohttpRelay",
          "expireAfter"
        ],
      );

  @override
  Future<(Request, ClientResponse)> crateApiReceiveFfiReceiverExtractReq(
      {required FfiReceiver that}) {
    return handler.executeNormal(NormalTask(
      callFfi: (port_) {
        var arg0 = cst_encode_box_autoadd_ffi_receiver(that);
        return wire.wire__crate__api__receive__ffi_receiver_extract_req(
            port_, arg0);
      },
      codec: DcoCodec(
        decodeSuccessData: dco_decode_record_request_client_response,
        decodeErrorData: dco_decode_payjoin_error,
      ),
      constMeta: kCrateApiReceiveFfiReceiverExtractReqConstMeta,
      argValues: [that],
      apiImpl: this,
    ));
  }

  TaskConstMeta get kCrateApiReceiveFfiReceiverExtractReqConstMeta =>
      const TaskConstMeta(
        debugName: "ffi_receiver_extract_req",
        argNames: ["that"],
      );

  @override
  FfiReceiver crateApiReceiveFfiReceiverFromJson({required String json}) {
    return handler.executeSync(SyncTask(
      callFfi: () {
        var arg0 = cst_encode_String(json);
        return wire.wire__crate__api__receive__ffi_receiver_from_json(arg0);
      },
      codec: DcoCodec(
        decodeSuccessData: dco_decode_ffi_receiver,
        decodeErrorData: dco_decode_payjoin_error,
      ),
      constMeta: kCrateApiReceiveFfiReceiverFromJsonConstMeta,
      argValues: [json],
      apiImpl: this,
    ));
  }

  TaskConstMeta get kCrateApiReceiveFfiReceiverFromJsonConstMeta =>
      const TaskConstMeta(
        debugName: "ffi_receiver_from_json",
        argNames: ["json"],
      );

  @override
  String crateApiReceiveFfiReceiverId({required FfiReceiver that}) {
    return handler.executeSync(SyncTask(
      callFfi: () {
        var arg0 = cst_encode_box_autoadd_ffi_receiver(that);
        return wire.wire__crate__api__receive__ffi_receiver_id(arg0);
      },
      codec: DcoCodec(
        decodeSuccessData: dco_decode_String,
        decodeErrorData: null,
      ),
      constMeta: kCrateApiReceiveFfiReceiverIdConstMeta,
      argValues: [that],
      apiImpl: this,
    ));
  }

  TaskConstMeta get kCrateApiReceiveFfiReceiverIdConstMeta =>
      const TaskConstMeta(
        debugName: "ffi_receiver_id",
        argNames: ["that"],
      );

  @override
  FfiPjUriBuilder crateApiReceiveFfiReceiverPjUriBuilder(
      {required FfiReceiver that}) {
    return handler.executeSync(SyncTask(
      callFfi: () {
        var arg0 = cst_encode_box_autoadd_ffi_receiver(that);
        return wire
            .wire__crate__api__receive__ffi_receiver_pj_uri_builder(arg0);
      },
      codec: DcoCodec(
        decodeSuccessData: dco_decode_ffi_pj_uri_builder,
        decodeErrorData: null,
      ),
      constMeta: kCrateApiReceiveFfiReceiverPjUriBuilderConstMeta,
      argValues: [that],
      apiImpl: this,
    ));
  }

  TaskConstMeta get kCrateApiReceiveFfiReceiverPjUriBuilderConstMeta =>
      const TaskConstMeta(
        debugName: "ffi_receiver_pj_uri_builder",
        argNames: ["that"],
      );

  @override
  Future<FfiUrl> crateApiReceiveFfiReceiverPjUrl({required FfiReceiver that}) {
    return handler.executeNormal(NormalTask(
      callFfi: (port_) {
        var arg0 = cst_encode_box_autoadd_ffi_receiver(that);
        return wire.wire__crate__api__receive__ffi_receiver_pj_url(port_, arg0);
      },
      codec: DcoCodec(
        decodeSuccessData: dco_decode_ffi_url,
        decodeErrorData: null,
      ),
      constMeta: kCrateApiReceiveFfiReceiverPjUrlConstMeta,
      argValues: [that],
      apiImpl: this,
    ));
  }

  TaskConstMeta get kCrateApiReceiveFfiReceiverPjUrlConstMeta =>
      const TaskConstMeta(
        debugName: "ffi_receiver_pj_url",
        argNames: ["that"],
      );

  @override
  Future<FfiUncheckedProposal?> crateApiReceiveFfiReceiverProcessRes(
      {required FfiReceiver that,
      required List<int> body,
      required ClientResponse ctx}) {
    return handler.executeNormal(NormalTask(
      callFfi: (port_) {
        var arg0 = cst_encode_box_autoadd_ffi_receiver(that);
        var arg1 = cst_encode_list_prim_u_8_loose(body);
        var arg2 = cst_encode_box_autoadd_client_response(ctx);
        return wire.wire__crate__api__receive__ffi_receiver_process_res(
            port_, arg0, arg1, arg2);
      },
      codec: DcoCodec(
        decodeSuccessData: dco_decode_opt_box_autoadd_ffi_unchecked_proposal,
        decodeErrorData: dco_decode_payjoin_error,
      ),
      constMeta: kCrateApiReceiveFfiReceiverProcessResConstMeta,
      argValues: [that, body, ctx],
      apiImpl: this,
    ));
  }

  TaskConstMeta get kCrateApiReceiveFfiReceiverProcessResConstMeta =>
      const TaskConstMeta(
        debugName: "ffi_receiver_process_res",
        argNames: ["that", "body", "ctx"],
      );

  @override
  String crateApiReceiveFfiReceiverToJson({required FfiReceiver that}) {
    return handler.executeSync(SyncTask(
      callFfi: () {
        var arg0 = cst_encode_box_autoadd_ffi_receiver(that);
        return wire.wire__crate__api__receive__ffi_receiver_to_json(arg0);
      },
      codec: DcoCodec(
        decodeSuccessData: dco_decode_String,
        decodeErrorData: dco_decode_payjoin_error,
      ),
      constMeta: kCrateApiReceiveFfiReceiverToJsonConstMeta,
      argValues: [that],
      apiImpl: this,
    ));
  }

  TaskConstMeta get kCrateApiReceiveFfiReceiverToJsonConstMeta =>
      const TaskConstMeta(
        debugName: "ffi_receiver_to_json",
        argNames: ["that"],
      );

  @override
  Future<FfiMaybeInputsOwned>
      crateApiReceiveFfiUncheckedProposalAssumeInteractiveReceiver(
          {required FfiUncheckedProposal that}) {
    return handler.executeNormal(NormalTask(
      callFfi: (port_) {
        var arg0 = cst_encode_box_autoadd_ffi_unchecked_proposal(that);
        return wire
            .wire__crate__api__receive__ffi_unchecked_proposal_assume_interactive_receiver(
                port_, arg0);
      },
      codec: DcoCodec(
        decodeSuccessData: dco_decode_ffi_maybe_inputs_owned,
        decodeErrorData: null,
      ),
      constMeta:
          kCrateApiReceiveFfiUncheckedProposalAssumeInteractiveReceiverConstMeta,
      argValues: [that],
      apiImpl: this,
    ));
  }

  TaskConstMeta
      get kCrateApiReceiveFfiUncheckedProposalAssumeInteractiveReceiverConstMeta =>
          const TaskConstMeta(
            debugName: "ffi_unchecked_proposal_assume_interactive_receiver",
            argNames: ["that"],
          );

  @override
  Future<FfiMaybeInputsOwned>
      crateApiReceiveFfiUncheckedProposalCheckBroadcastSuitability(
          {required FfiUncheckedProposal that,
          BigInt? minFeeRate,
          required FutureOr<bool> Function(Uint8List) canBroadcast}) {
    return handler.executeNormal(NormalTask(
      callFfi: (port_) {
        var arg0 = cst_encode_box_autoadd_ffi_unchecked_proposal(that);
        var arg1 = cst_encode_opt_box_autoadd_u_64(minFeeRate);
        var arg2 =
            cst_encode_DartFn_Inputs_list_prim_u_8_strict_Output_bool_AnyhowException(
                canBroadcast);
        return wire
            .wire__crate__api__receive__ffi_unchecked_proposal_check_broadcast_suitability(
                port_, arg0, arg1, arg2);
      },
      codec: DcoCodec(
        decodeSuccessData: dco_decode_ffi_maybe_inputs_owned,
        decodeErrorData: dco_decode_payjoin_error,
      ),
      constMeta:
          kCrateApiReceiveFfiUncheckedProposalCheckBroadcastSuitabilityConstMeta,
      argValues: [that, minFeeRate, canBroadcast],
      apiImpl: this,
    ));
  }

  TaskConstMeta
      get kCrateApiReceiveFfiUncheckedProposalCheckBroadcastSuitabilityConstMeta =>
          const TaskConstMeta(
            debugName: "ffi_unchecked_proposal_check_broadcast_suitability",
            argNames: ["that", "minFeeRate", "canBroadcast"],
          );

  @override
  Future<Uint8List>
      crateApiReceiveFfiUncheckedProposalExtractTxToScheduleBroadcast(
          {required FfiUncheckedProposal that}) {
    return handler.executeNormal(NormalTask(
      callFfi: (port_) {
        var arg0 = cst_encode_box_autoadd_ffi_unchecked_proposal(that);
        return wire
            .wire__crate__api__receive__ffi_unchecked_proposal_extract_tx_to_schedule_broadcast(
                port_, arg0);
      },
      codec: DcoCodec(
        decodeSuccessData: dco_decode_list_prim_u_8_strict,
        decodeErrorData: null,
      ),
      constMeta:
          kCrateApiReceiveFfiUncheckedProposalExtractTxToScheduleBroadcastConstMeta,
      argValues: [that],
      apiImpl: this,
    ));
  }

  TaskConstMeta
      get kCrateApiReceiveFfiUncheckedProposalExtractTxToScheduleBroadcastConstMeta =>
          const TaskConstMeta(
            debugName:
                "ffi_unchecked_proposal_extract_tx_to_schedule_broadcast",
            argNames: ["that"],
          );

  @override
  Future<FfiProvisionalProposal> crateApiReceiveFfiWantsInputsCommitInputs(
      {required FfiWantsInputs that}) {
    return handler.executeNormal(NormalTask(
      callFfi: (port_) {
        var arg0 = cst_encode_box_autoadd_ffi_wants_inputs(that);
        return wire.wire__crate__api__receive__ffi_wants_inputs_commit_inputs(
            port_, arg0);
      },
      codec: DcoCodec(
        decodeSuccessData: dco_decode_ffi_provisional_proposal,
        decodeErrorData: null,
      ),
      constMeta: kCrateApiReceiveFfiWantsInputsCommitInputsConstMeta,
      argValues: [that],
      apiImpl: this,
    ));
  }

  TaskConstMeta get kCrateApiReceiveFfiWantsInputsCommitInputsConstMeta =>
      const TaskConstMeta(
        debugName: "ffi_wants_inputs_commit_inputs",
        argNames: ["that"],
      );

  @override
  Future<FfiWantsInputs> crateApiReceiveFfiWantsInputsContributeInputs(
      {required FfiWantsInputs that,
      required List<FfiInputPair> replacementInputs}) {
    return handler.executeNormal(NormalTask(
      callFfi: (port_) {
        var arg0 = cst_encode_box_autoadd_ffi_wants_inputs(that);
        var arg1 = cst_encode_list_ffi_input_pair(replacementInputs);
        return wire
            .wire__crate__api__receive__ffi_wants_inputs_contribute_inputs(
                port_, arg0, arg1);
      },
      codec: DcoCodec(
        decodeSuccessData: dco_decode_ffi_wants_inputs,
        decodeErrorData: dco_decode_payjoin_error,
      ),
      constMeta: kCrateApiReceiveFfiWantsInputsContributeInputsConstMeta,
      argValues: [that, replacementInputs],
      apiImpl: this,
    ));
  }

  TaskConstMeta get kCrateApiReceiveFfiWantsInputsContributeInputsConstMeta =>
      const TaskConstMeta(
        debugName: "ffi_wants_inputs_contribute_inputs",
        argNames: ["that", "replacementInputs"],
      );

  @override
  Future<FfiInputPair> crateApiReceiveFfiWantsInputsTryPreservingPrivacy(
      {required FfiWantsInputs that,
      required List<FfiInputPair> candidateInputs}) {
    return handler.executeNormal(NormalTask(
      callFfi: (port_) {
        var arg0 = cst_encode_box_autoadd_ffi_wants_inputs(that);
        var arg1 = cst_encode_list_ffi_input_pair(candidateInputs);
        return wire
            .wire__crate__api__receive__ffi_wants_inputs_try_preserving_privacy(
                port_, arg0, arg1);
      },
      codec: DcoCodec(
        decodeSuccessData: dco_decode_ffi_input_pair,
        decodeErrorData: dco_decode_payjoin_error,
      ),
      constMeta: kCrateApiReceiveFfiWantsInputsTryPreservingPrivacyConstMeta,
      argValues: [that, candidateInputs],
      apiImpl: this,
    ));
  }

  TaskConstMeta
      get kCrateApiReceiveFfiWantsInputsTryPreservingPrivacyConstMeta =>
          const TaskConstMeta(
            debugName: "ffi_wants_inputs_try_preserving_privacy",
            argNames: ["that", "candidateInputs"],
          );

  @override
  Future<FfiWantsInputs> crateApiReceiveFfiWantsOutputsCommitOutputs(
      {required FfiWantsOutputs that}) {
    return handler.executeNormal(NormalTask(
      callFfi: (port_) {
        var arg0 = cst_encode_box_autoadd_ffi_wants_outputs(that);
        return wire.wire__crate__api__receive__ffi_wants_outputs_commit_outputs(
            port_, arg0);
      },
      codec: DcoCodec(
        decodeSuccessData: dco_decode_ffi_wants_inputs,
        decodeErrorData: null,
      ),
      constMeta: kCrateApiReceiveFfiWantsOutputsCommitOutputsConstMeta,
      argValues: [that],
      apiImpl: this,
    ));
  }

  TaskConstMeta get kCrateApiReceiveFfiWantsOutputsCommitOutputsConstMeta =>
      const TaskConstMeta(
        debugName: "ffi_wants_outputs_commit_outputs",
        argNames: ["that"],
      );

  @override
  Future<bool> crateApiReceiveFfiWantsOutputsIsOutputSubstitutionDisabled(
      {required FfiWantsOutputs that}) {
    return handler.executeNormal(NormalTask(
      callFfi: (port_) {
        var arg0 = cst_encode_box_autoadd_ffi_wants_outputs(that);
        return wire
            .wire__crate__api__receive__ffi_wants_outputs_is_output_substitution_disabled(
                port_, arg0);
      },
      codec: DcoCodec(
        decodeSuccessData: dco_decode_bool,
        decodeErrorData: null,
      ),
      constMeta:
          kCrateApiReceiveFfiWantsOutputsIsOutputSubstitutionDisabledConstMeta,
      argValues: [that],
      apiImpl: this,
    ));
  }

  TaskConstMeta
      get kCrateApiReceiveFfiWantsOutputsIsOutputSubstitutionDisabledConstMeta =>
          const TaskConstMeta(
            debugName: "ffi_wants_outputs_is_output_substitution_disabled",
            argNames: ["that"],
          );

  @override
  Future<FfiWantsOutputs> crateApiReceiveFfiWantsOutputsReplaceReceiverOutputs(
      {required FfiWantsOutputs that,
      required List<TxOut> replacementOutputs,
      required FfiScript drainScript}) {
    return handler.executeNormal(NormalTask(
      callFfi: (port_) {
        var arg0 = cst_encode_box_autoadd_ffi_wants_outputs(that);
        var arg1 = cst_encode_list_tx_out(replacementOutputs);
        var arg2 = cst_encode_box_autoadd_ffi_script(drainScript);
        return wire
            .wire__crate__api__receive__ffi_wants_outputs_replace_receiver_outputs(
                port_, arg0, arg1, arg2);
      },
      codec: DcoCodec(
        decodeSuccessData: dco_decode_ffi_wants_outputs,
        decodeErrorData: dco_decode_payjoin_error,
      ),
      constMeta: kCrateApiReceiveFfiWantsOutputsReplaceReceiverOutputsConstMeta,
      argValues: [that, replacementOutputs, drainScript],
      apiImpl: this,
    ));
  }

  TaskConstMeta
      get kCrateApiReceiveFfiWantsOutputsReplaceReceiverOutputsConstMeta =>
          const TaskConstMeta(
            debugName: "ffi_wants_outputs_replace_receiver_outputs",
            argNames: ["that", "replacementOutputs", "drainScript"],
          );

  @override
  Future<FfiWantsOutputs>
      crateApiReceiveFfiWantsOutputsSubstituteReceiverScript(
          {required FfiWantsOutputs that, required FfiScript outputScript}) {
    return handler.executeNormal(NormalTask(
      callFfi: (port_) {
        var arg0 = cst_encode_box_autoadd_ffi_wants_outputs(that);
        var arg1 = cst_encode_box_autoadd_ffi_script(outputScript);
        return wire
            .wire__crate__api__receive__ffi_wants_outputs_substitute_receiver_script(
                port_, arg0, arg1);
      },
      codec: DcoCodec(
        decodeSuccessData: dco_decode_ffi_wants_outputs,
        decodeErrorData: dco_decode_payjoin_error,
      ),
      constMeta:
          kCrateApiReceiveFfiWantsOutputsSubstituteReceiverScriptConstMeta,
      argValues: [that, outputScript],
      apiImpl: this,
    ));
  }

  TaskConstMeta
      get kCrateApiReceiveFfiWantsOutputsSubstituteReceiverScriptConstMeta =>
          const TaskConstMeta(
            debugName: "ffi_wants_outputs_substitute_receiver_script",
            argNames: ["that", "outputScript"],
          );

  @override
  Future<FfiSenderBuilder>
      crateApiSendFfiSenderBuilderAlwaysDisableOutputSubstitution(
          {required FfiSenderBuilder that, required bool disable}) {
    return handler.executeNormal(NormalTask(
      callFfi: (port_) {
        var arg0 = cst_encode_box_autoadd_ffi_sender_builder(that);
        var arg1 = cst_encode_bool(disable);
        return wire
            .wire__crate__api__send__ffi_sender_builder_always_disable_output_substitution(
                port_, arg0, arg1);
      },
      codec: DcoCodec(
        decodeSuccessData: dco_decode_ffi_sender_builder,
        decodeErrorData: null,
      ),
      constMeta:
          kCrateApiSendFfiSenderBuilderAlwaysDisableOutputSubstitutionConstMeta,
      argValues: [that, disable],
      apiImpl: this,
    ));
  }

  TaskConstMeta
      get kCrateApiSendFfiSenderBuilderAlwaysDisableOutputSubstitutionConstMeta =>
          const TaskConstMeta(
            debugName: "ffi_sender_builder_always_disable_output_substitution",
            argNames: ["that", "disable"],
          );

  @override
  Future<FfiSender> crateApiSendFfiSenderBuilderBuildNonIncentivizing(
      {required FfiSenderBuilder that, required BigInt minFeeRate}) {
    return handler.executeNormal(NormalTask(
      callFfi: (port_) {
        var arg0 = cst_encode_box_autoadd_ffi_sender_builder(that);
        var arg1 = cst_encode_u_64(minFeeRate);
        return wire
            .wire__crate__api__send__ffi_sender_builder_build_non_incentivizing(
                port_, arg0, arg1);
      },
      codec: DcoCodec(
        decodeSuccessData: dco_decode_ffi_sender,
        decodeErrorData: dco_decode_payjoin_error,
      ),
      constMeta: kCrateApiSendFfiSenderBuilderBuildNonIncentivizingConstMeta,
      argValues: [that, minFeeRate],
      apiImpl: this,
    ));
  }

  TaskConstMeta
      get kCrateApiSendFfiSenderBuilderBuildNonIncentivizingConstMeta =>
          const TaskConstMeta(
            debugName: "ffi_sender_builder_build_non_incentivizing",
            argNames: ["that", "minFeeRate"],
          );

  @override
  Future<FfiSender> crateApiSendFfiSenderBuilderBuildRecommended(
      {required FfiSenderBuilder that, required BigInt minFeeRate}) {
    return handler.executeNormal(NormalTask(
      callFfi: (port_) {
        var arg0 = cst_encode_box_autoadd_ffi_sender_builder(that);
        var arg1 = cst_encode_u_64(minFeeRate);
        return wire
            .wire__crate__api__send__ffi_sender_builder_build_recommended(
                port_, arg0, arg1);
      },
      codec: DcoCodec(
        decodeSuccessData: dco_decode_ffi_sender,
        decodeErrorData: dco_decode_payjoin_error,
      ),
      constMeta: kCrateApiSendFfiSenderBuilderBuildRecommendedConstMeta,
      argValues: [that, minFeeRate],
      apiImpl: this,
    ));
  }

  TaskConstMeta get kCrateApiSendFfiSenderBuilderBuildRecommendedConstMeta =>
      const TaskConstMeta(
        debugName: "ffi_sender_builder_build_recommended",
        argNames: ["that", "minFeeRate"],
      );

  @override
  Future<FfiSender> crateApiSendFfiSenderBuilderBuildWithAdditionalFee(
      {required FfiSenderBuilder that,
      required BigInt maxFeeContribution,
      int? changeIndex,
      required BigInt minFeeRate,
      required bool clampFeeContribution}) {
    return handler.executeNormal(NormalTask(
      callFfi: (port_) {
        var arg0 = cst_encode_box_autoadd_ffi_sender_builder(that);
        var arg1 = cst_encode_u_64(maxFeeContribution);
        var arg2 = cst_encode_opt_box_autoadd_u_8(changeIndex);
        var arg3 = cst_encode_u_64(minFeeRate);
        var arg4 = cst_encode_bool(clampFeeContribution);
        return wire
            .wire__crate__api__send__ffi_sender_builder_build_with_additional_fee(
                port_, arg0, arg1, arg2, arg3, arg4);
      },
      codec: DcoCodec(
        decodeSuccessData: dco_decode_ffi_sender,
        decodeErrorData: dco_decode_payjoin_error,
      ),
      constMeta: kCrateApiSendFfiSenderBuilderBuildWithAdditionalFeeConstMeta,
      argValues: [
        that,
        maxFeeContribution,
        changeIndex,
        minFeeRate,
        clampFeeContribution
      ],
      apiImpl: this,
    ));
  }

  TaskConstMeta
      get kCrateApiSendFfiSenderBuilderBuildWithAdditionalFeeConstMeta =>
          const TaskConstMeta(
            debugName: "ffi_sender_builder_build_with_additional_fee",
            argNames: [
              "that",
              "maxFeeContribution",
              "changeIndex",
              "minFeeRate",
              "clampFeeContribution"
            ],
          );

  @override
  Future<FfiSenderBuilder> crateApiSendFfiSenderBuilderFromPsbtAndUri(
      {required String psbtBase64, required FfiPjUri pjUri}) {
    return handler.executeNormal(NormalTask(
      callFfi: (port_) {
        var arg0 = cst_encode_String(psbtBase64);
        var arg1 = cst_encode_box_autoadd_ffi_pj_uri(pjUri);
        return wire
            .wire__crate__api__send__ffi_sender_builder_from_psbt_and_uri(
                port_, arg0, arg1);
      },
      codec: DcoCodec(
        decodeSuccessData: dco_decode_ffi_sender_builder,
        decodeErrorData: dco_decode_payjoin_error,
      ),
      constMeta: kCrateApiSendFfiSenderBuilderFromPsbtAndUriConstMeta,
      argValues: [psbtBase64, pjUri],
      apiImpl: this,
    ));
  }

  TaskConstMeta get kCrateApiSendFfiSenderBuilderFromPsbtAndUriConstMeta =>
      const TaskConstMeta(
        debugName: "ffi_sender_builder_from_psbt_and_uri",
        argNames: ["psbtBase64", "pjUri"],
      );

  @override
  Future<(Request, FfiV1Context)> crateApiSendFfiSenderExtractV1(
      {required FfiSender that}) {
    return handler.executeNormal(NormalTask(
      callFfi: (port_) {
        var arg0 = cst_encode_box_autoadd_ffi_sender(that);
        return wire.wire__crate__api__send__ffi_sender_extract_v1(port_, arg0);
      },
      codec: DcoCodec(
        decodeSuccessData: dco_decode_record_request_ffi_v_1_context,
        decodeErrorData: dco_decode_payjoin_error,
      ),
      constMeta: kCrateApiSendFfiSenderExtractV1ConstMeta,
      argValues: [that],
      apiImpl: this,
    ));
  }

  TaskConstMeta get kCrateApiSendFfiSenderExtractV1ConstMeta =>
      const TaskConstMeta(
        debugName: "ffi_sender_extract_v1",
        argNames: ["that"],
      );

  @override
  Future<(Request, FfiV2PostContext)> crateApiSendFfiSenderExtractV2(
      {required FfiSender that, required FfiUrl ohttpProxyUrl}) {
    return handler.executeNormal(NormalTask(
      callFfi: (port_) {
        var arg0 = cst_encode_box_autoadd_ffi_sender(that);
        var arg1 = cst_encode_box_autoadd_ffi_url(ohttpProxyUrl);
        return wire.wire__crate__api__send__ffi_sender_extract_v2(
            port_, arg0, arg1);
      },
      codec: DcoCodec(
        decodeSuccessData: dco_decode_record_request_ffi_v_2_post_context,
        decodeErrorData: dco_decode_payjoin_error,
      ),
      constMeta: kCrateApiSendFfiSenderExtractV2ConstMeta,
      argValues: [that, ohttpProxyUrl],
      apiImpl: this,
    ));
  }

  TaskConstMeta get kCrateApiSendFfiSenderExtractV2ConstMeta =>
      const TaskConstMeta(
        debugName: "ffi_sender_extract_v2",
        argNames: ["that", "ohttpProxyUrl"],
      );

  @override
  FfiSender crateApiSendFfiSenderFromJson({required String json}) {
    return handler.executeSync(SyncTask(
      callFfi: () {
        var arg0 = cst_encode_String(json);
        return wire.wire__crate__api__send__ffi_sender_from_json(arg0);
      },
      codec: DcoCodec(
        decodeSuccessData: dco_decode_ffi_sender,
        decodeErrorData: dco_decode_payjoin_error,
      ),
      constMeta: kCrateApiSendFfiSenderFromJsonConstMeta,
      argValues: [json],
      apiImpl: this,
    ));
  }

  TaskConstMeta get kCrateApiSendFfiSenderFromJsonConstMeta =>
      const TaskConstMeta(
        debugName: "ffi_sender_from_json",
        argNames: ["json"],
      );

  @override
  String crateApiSendFfiSenderToJson({required FfiSender that}) {
    return handler.executeSync(SyncTask(
      callFfi: () {
        var arg0 = cst_encode_box_autoadd_ffi_sender(that);
        return wire.wire__crate__api__send__ffi_sender_to_json(arg0);
      },
      codec: DcoCodec(
        decodeSuccessData: dco_decode_String,
        decodeErrorData: dco_decode_payjoin_error,
      ),
      constMeta: kCrateApiSendFfiSenderToJsonConstMeta,
      argValues: [that],
      apiImpl: this,
    ));
  }

  TaskConstMeta get kCrateApiSendFfiSenderToJsonConstMeta =>
      const TaskConstMeta(
        debugName: "ffi_sender_to_json",
        argNames: ["that"],
      );

  @override
  Future<String> crateApiSendFfiV1ContextProcessResponse(
      {required FfiV1Context that, required List<int> response}) {
    return handler.executeNormal(NormalTask(
      callFfi: (port_) {
        var arg0 = cst_encode_box_autoadd_ffi_v_1_context(that);
        var arg1 = cst_encode_list_prim_u_8_loose(response);
        return wire.wire__crate__api__send__ffi_v_1_context_process_response(
            port_, arg0, arg1);
      },
      codec: DcoCodec(
        decodeSuccessData: dco_decode_String,
        decodeErrorData: dco_decode_payjoin_error,
      ),
      constMeta: kCrateApiSendFfiV1ContextProcessResponseConstMeta,
      argValues: [that, response],
      apiImpl: this,
    ));
  }

  TaskConstMeta get kCrateApiSendFfiV1ContextProcessResponseConstMeta =>
      const TaskConstMeta(
        debugName: "ffi_v_1_context_process_response",
        argNames: ["that", "response"],
      );

  @override
  Future<(Request, ClientResponse)> crateApiSendFfiV2GetContextExtractReq(
      {required FfiV2GetContext that, required FfiUrl ohttpRelay}) {
    return handler.executeNormal(NormalTask(
      callFfi: (port_) {
        var arg0 = cst_encode_box_autoadd_ffi_v_2_get_context(that);
        var arg1 = cst_encode_box_autoadd_ffi_url(ohttpRelay);
        return wire.wire__crate__api__send__ffi_v_2_get_context_extract_req(
            port_, arg0, arg1);
      },
      codec: DcoCodec(
        decodeSuccessData: dco_decode_record_request_client_response,
        decodeErrorData: dco_decode_payjoin_error,
      ),
      constMeta: kCrateApiSendFfiV2GetContextExtractReqConstMeta,
      argValues: [that, ohttpRelay],
      apiImpl: this,
    ));
  }

  TaskConstMeta get kCrateApiSendFfiV2GetContextExtractReqConstMeta =>
      const TaskConstMeta(
        debugName: "ffi_v_2_get_context_extract_req",
        argNames: ["that", "ohttpRelay"],
      );

  @override
  Future<String?> crateApiSendFfiV2GetContextProcessResponse(
      {required FfiV2GetContext that,
      required List<int> response,
      required ClientResponse ohttpCtx}) {
    return handler.executeNormal(NormalTask(
      callFfi: (port_) {
        var arg0 = cst_encode_box_autoadd_ffi_v_2_get_context(that);
        var arg1 = cst_encode_list_prim_u_8_loose(response);
        var arg2 = cst_encode_box_autoadd_client_response(ohttpCtx);
        return wire
            .wire__crate__api__send__ffi_v_2_get_context_process_response(
                port_, arg0, arg1, arg2);
      },
      codec: DcoCodec(
        decodeSuccessData: dco_decode_opt_String,
        decodeErrorData: dco_decode_payjoin_error,
      ),
      constMeta: kCrateApiSendFfiV2GetContextProcessResponseConstMeta,
      argValues: [that, response, ohttpCtx],
      apiImpl: this,
    ));
  }

  TaskConstMeta get kCrateApiSendFfiV2GetContextProcessResponseConstMeta =>
      const TaskConstMeta(
        debugName: "ffi_v_2_get_context_process_response",
        argNames: ["that", "response", "ohttpCtx"],
      );

  @override
  Future<FfiV2GetContext> crateApiSendFfiV2PostContextProcessResponse(
      {required FfiV2PostContext that, required List<int> response}) {
    return handler.executeNormal(NormalTask(
      callFfi: (port_) {
        var arg0 = cst_encode_box_autoadd_ffi_v_2_post_context(that);
        var arg1 = cst_encode_list_prim_u_8_loose(response);
        return wire
            .wire__crate__api__send__ffi_v_2_post_context_process_response(
                port_, arg0, arg1);
      },
      codec: DcoCodec(
        decodeSuccessData: dco_decode_ffi_v_2_get_context,
        decodeErrorData: dco_decode_payjoin_error,
      ),
      constMeta: kCrateApiSendFfiV2PostContextProcessResponseConstMeta,
      argValues: [that, response],
      apiImpl: this,
    ));
  }

  TaskConstMeta get kCrateApiSendFfiV2PostContextProcessResponseConstMeta =>
      const TaskConstMeta(
        debugName: "ffi_v_2_post_context_process_response",
        argNames: ["that", "response"],
      );

  @override
  Future<FfiOhttpKeys> crateApiUriFfiOhttpKeysDecode(
      {required List<int> bytes}) {
    return handler.executeNormal(NormalTask(
      callFfi: (port_) {
        var arg0 = cst_encode_list_prim_u_8_loose(bytes);
        return wire.wire__crate__api__uri__ffi_ohttp_keys_decode(port_, arg0);
      },
      codec: DcoCodec(
        decodeSuccessData: dco_decode_ffi_ohttp_keys,
        decodeErrorData: dco_decode_payjoin_error,
      ),
      constMeta: kCrateApiUriFfiOhttpKeysDecodeConstMeta,
      argValues: [bytes],
      apiImpl: this,
    ));
  }

  TaskConstMeta get kCrateApiUriFfiOhttpKeysDecodeConstMeta =>
      const TaskConstMeta(
        debugName: "ffi_ohttp_keys_decode",
        argNames: ["bytes"],
      );

  @override
  String crateApiUriFfiPjUriAddress({required FfiPjUri that}) {
    return handler.executeSync(SyncTask(
      callFfi: () {
        var arg0 = cst_encode_box_autoadd_ffi_pj_uri(that);
        return wire.wire__crate__api__uri__ffi_pj_uri_address(arg0);
      },
      codec: DcoCodec(
        decodeSuccessData: dco_decode_String,
        decodeErrorData: null,
      ),
      constMeta: kCrateApiUriFfiPjUriAddressConstMeta,
      argValues: [that],
      apiImpl: this,
    ));
  }

  TaskConstMeta get kCrateApiUriFfiPjUriAddressConstMeta => const TaskConstMeta(
        debugName: "ffi_pj_uri_address",
        argNames: ["that"],
      );

  @override
  BigInt? crateApiUriFfiPjUriAmountSats({required FfiPjUri that}) {
    return handler.executeSync(SyncTask(
      callFfi: () {
        var arg0 = cst_encode_box_autoadd_ffi_pj_uri(that);
        return wire.wire__crate__api__uri__ffi_pj_uri_amount_sats(arg0);
      },
      codec: DcoCodec(
        decodeSuccessData: dco_decode_opt_box_autoadd_u_64,
        decodeErrorData: null,
      ),
      constMeta: kCrateApiUriFfiPjUriAmountSatsConstMeta,
      argValues: [that],
      apiImpl: this,
    ));
  }

  TaskConstMeta get kCrateApiUriFfiPjUriAmountSatsConstMeta =>
      const TaskConstMeta(
        debugName: "ffi_pj_uri_amount_sats",
        argNames: ["that"],
      );

  @override
  String crateApiUriFfiPjUriAsString({required FfiPjUri that}) {
    return handler.executeSync(SyncTask(
      callFfi: () {
        var arg0 = cst_encode_box_autoadd_ffi_pj_uri(that);
        return wire.wire__crate__api__uri__ffi_pj_uri_as_string(arg0);
      },
      codec: DcoCodec(
        decodeSuccessData: dco_decode_String,
        decodeErrorData: null,
      ),
      constMeta: kCrateApiUriFfiPjUriAsStringConstMeta,
      argValues: [that],
      apiImpl: this,
    ));
  }

  TaskConstMeta get kCrateApiUriFfiPjUriAsStringConstMeta =>
      const TaskConstMeta(
        debugName: "ffi_pj_uri_as_string",
        argNames: ["that"],
      );

  @override
  FfiPjUriBuilder crateApiUriFfiPjUriBuilderAmountSats(
      {required FfiPjUriBuilder that, required BigInt amount}) {
    return handler.executeSync(SyncTask(
      callFfi: () {
        var arg0 = cst_encode_box_autoadd_ffi_pj_uri_builder(that);
        var arg1 = cst_encode_u_64(amount);
        return wire.wire__crate__api__uri__ffi_pj_uri_builder_amount_sats(
            arg0, arg1);
      },
      codec: DcoCodec(
        decodeSuccessData: dco_decode_ffi_pj_uri_builder,
        decodeErrorData: null,
      ),
      constMeta: kCrateApiUriFfiPjUriBuilderAmountSatsConstMeta,
      argValues: [that, amount],
      apiImpl: this,
    ));
  }

  TaskConstMeta get kCrateApiUriFfiPjUriBuilderAmountSatsConstMeta =>
      const TaskConstMeta(
        debugName: "ffi_pj_uri_builder_amount_sats",
        argNames: ["that", "amount"],
      );

  @override
  FfiPjUri crateApiUriFfiPjUriBuilderBuild({required FfiPjUriBuilder that}) {
    return handler.executeSync(SyncTask(
      callFfi: () {
        var arg0 = cst_encode_box_autoadd_ffi_pj_uri_builder(that);
        return wire.wire__crate__api__uri__ffi_pj_uri_builder_build(arg0);
      },
      codec: DcoCodec(
        decodeSuccessData: dco_decode_ffi_pj_uri,
        decodeErrorData: null,
      ),
      constMeta: kCrateApiUriFfiPjUriBuilderBuildConstMeta,
      argValues: [that],
      apiImpl: this,
    ));
  }

  TaskConstMeta get kCrateApiUriFfiPjUriBuilderBuildConstMeta =>
      const TaskConstMeta(
        debugName: "ffi_pj_uri_builder_build",
        argNames: ["that"],
      );

  @override
  FfiPjUriBuilder crateApiUriFfiPjUriBuilderLabel(
      {required FfiPjUriBuilder that, required String label}) {
    return handler.executeSync(SyncTask(
      callFfi: () {
        var arg0 = cst_encode_box_autoadd_ffi_pj_uri_builder(that);
        var arg1 = cst_encode_String(label);
        return wire.wire__crate__api__uri__ffi_pj_uri_builder_label(arg0, arg1);
      },
      codec: DcoCodec(
        decodeSuccessData: dco_decode_ffi_pj_uri_builder,
        decodeErrorData: null,
      ),
      constMeta: kCrateApiUriFfiPjUriBuilderLabelConstMeta,
      argValues: [that, label],
      apiImpl: this,
    ));
  }

  TaskConstMeta get kCrateApiUriFfiPjUriBuilderLabelConstMeta =>
      const TaskConstMeta(
        debugName: "ffi_pj_uri_builder_label",
        argNames: ["that", "label"],
      );

  @override
  FfiPjUriBuilder crateApiUriFfiPjUriBuilderMessage(
      {required FfiPjUriBuilder that, required String message}) {
    return handler.executeSync(SyncTask(
      callFfi: () {
        var arg0 = cst_encode_box_autoadd_ffi_pj_uri_builder(that);
        var arg1 = cst_encode_String(message);
        return wire.wire__crate__api__uri__ffi_pj_uri_builder_message(
            arg0, arg1);
      },
      codec: DcoCodec(
        decodeSuccessData: dco_decode_ffi_pj_uri_builder,
        decodeErrorData: null,
      ),
      constMeta: kCrateApiUriFfiPjUriBuilderMessageConstMeta,
      argValues: [that, message],
      apiImpl: this,
    ));
  }

  TaskConstMeta get kCrateApiUriFfiPjUriBuilderMessageConstMeta =>
      const TaskConstMeta(
        debugName: "ffi_pj_uri_builder_message",
        argNames: ["that", "message"],
      );

  @override
  FfiPjUriBuilder crateApiUriFfiPjUriBuilderPjos(
      {required FfiPjUriBuilder that, required bool pjos}) {
    return handler.executeSync(SyncTask(
      callFfi: () {
        var arg0 = cst_encode_box_autoadd_ffi_pj_uri_builder(that);
        var arg1 = cst_encode_bool(pjos);
        return wire.wire__crate__api__uri__ffi_pj_uri_builder_pjos(arg0, arg1);
      },
      codec: DcoCodec(
        decodeSuccessData: dco_decode_ffi_pj_uri_builder,
        decodeErrorData: null,
      ),
      constMeta: kCrateApiUriFfiPjUriBuilderPjosConstMeta,
      argValues: [that, pjos],
      apiImpl: this,
    ));
  }

  TaskConstMeta get kCrateApiUriFfiPjUriBuilderPjosConstMeta =>
      const TaskConstMeta(
        debugName: "ffi_pj_uri_builder_pjos",
        argNames: ["that", "pjos"],
      );

  @override
  String crateApiUriFfiPjUriPjEndpoint({required FfiPjUri that}) {
    return handler.executeSync(SyncTask(
      callFfi: () {
        var arg0 = cst_encode_box_autoadd_ffi_pj_uri(that);
        return wire.wire__crate__api__uri__ffi_pj_uri_pj_endpoint(arg0);
      },
      codec: DcoCodec(
        decodeSuccessData: dco_decode_String,
        decodeErrorData: null,
      ),
      constMeta: kCrateApiUriFfiPjUriPjEndpointConstMeta,
      argValues: [that],
      apiImpl: this,
    ));
  }

  TaskConstMeta get kCrateApiUriFfiPjUriPjEndpointConstMeta =>
      const TaskConstMeta(
        debugName: "ffi_pj_uri_pj_endpoint",
        argNames: ["that"],
      );

  @override
  String crateApiUriFfiUriAddress({required FfiUri that}) {
    return handler.executeSync(SyncTask(
      callFfi: () {
        var arg0 = cst_encode_box_autoadd_ffi_uri(that);
        return wire.wire__crate__api__uri__ffi_uri_address(arg0);
      },
      codec: DcoCodec(
        decodeSuccessData: dco_decode_String,
        decodeErrorData: null,
      ),
      constMeta: kCrateApiUriFfiUriAddressConstMeta,
      argValues: [that],
      apiImpl: this,
    ));
  }

  TaskConstMeta get kCrateApiUriFfiUriAddressConstMeta => const TaskConstMeta(
        debugName: "ffi_uri_address",
        argNames: ["that"],
      );

  @override
  BigInt? crateApiUriFfiUriAmountSats({required FfiUri that}) {
    return handler.executeSync(SyncTask(
      callFfi: () {
        var arg0 = cst_encode_box_autoadd_ffi_uri(that);
        return wire.wire__crate__api__uri__ffi_uri_amount_sats(arg0);
      },
      codec: DcoCodec(
        decodeSuccessData: dco_decode_opt_box_autoadd_u_64,
        decodeErrorData: null,
      ),
      constMeta: kCrateApiUriFfiUriAmountSatsConstMeta,
      argValues: [that],
      apiImpl: this,
    ));
  }

  TaskConstMeta get kCrateApiUriFfiUriAmountSatsConstMeta =>
      const TaskConstMeta(
        debugName: "ffi_uri_amount_sats",
        argNames: ["that"],
      );

  @override
  String crateApiUriFfiUriAsString({required FfiUri that}) {
    return handler.executeSync(SyncTask(
      callFfi: () {
        var arg0 = cst_encode_box_autoadd_ffi_uri(that);
        return wire.wire__crate__api__uri__ffi_uri_as_string(arg0);
      },
      codec: DcoCodec(
        decodeSuccessData: dco_decode_String,
        decodeErrorData: null,
      ),
      constMeta: kCrateApiUriFfiUriAsStringConstMeta,
      argValues: [that],
      apiImpl: this,
    ));
  }

  TaskConstMeta get kCrateApiUriFfiUriAsStringConstMeta => const TaskConstMeta(
        debugName: "ffi_uri_as_string",
        argNames: ["that"],
      );

  @override
  FfiPjUri crateApiUriFfiUriCheckPjSupported({required FfiUri that}) {
    return handler.executeSync(SyncTask(
      callFfi: () {
        var arg0 = cst_encode_box_autoadd_ffi_uri(that);
        return wire.wire__crate__api__uri__ffi_uri_check_pj_supported(arg0);
      },
      codec: DcoCodec(
        decodeSuccessData: dco_decode_ffi_pj_uri,
        decodeErrorData: dco_decode_payjoin_error,
      ),
      constMeta: kCrateApiUriFfiUriCheckPjSupportedConstMeta,
      argValues: [that],
      apiImpl: this,
    ));
  }

  TaskConstMeta get kCrateApiUriFfiUriCheckPjSupportedConstMeta =>
      const TaskConstMeta(
        debugName: "ffi_uri_check_pj_supported",
        argNames: ["that"],
      );

  @override
  String? crateApiUriFfiUriLabel({required FfiUri that}) {
    return handler.executeSync(SyncTask(
      callFfi: () {
        var arg0 = cst_encode_box_autoadd_ffi_uri(that);
        return wire.wire__crate__api__uri__ffi_uri_label(arg0);
      },
      codec: DcoCodec(
        decodeSuccessData: dco_decode_opt_String,
        decodeErrorData: null,
      ),
      constMeta: kCrateApiUriFfiUriLabelConstMeta,
      argValues: [that],
      apiImpl: this,
    ));
  }

  TaskConstMeta get kCrateApiUriFfiUriLabelConstMeta => const TaskConstMeta(
        debugName: "ffi_uri_label",
        argNames: ["that"],
      );

  @override
  String? crateApiUriFfiUriMessage({required FfiUri that}) {
    return handler.executeSync(SyncTask(
      callFfi: () {
        var arg0 = cst_encode_box_autoadd_ffi_uri(that);
        return wire.wire__crate__api__uri__ffi_uri_message(arg0);
      },
      codec: DcoCodec(
        decodeSuccessData: dco_decode_opt_String,
        decodeErrorData: null,
      ),
      constMeta: kCrateApiUriFfiUriMessageConstMeta,
      argValues: [that],
      apiImpl: this,
    ));
  }

  TaskConstMeta get kCrateApiUriFfiUriMessageConstMeta => const TaskConstMeta(
        debugName: "ffi_uri_message",
        argNames: ["that"],
      );

  @override
  FfiUri crateApiUriFfiUriParse({required String uri}) {
    return handler.executeSync(SyncTask(
      callFfi: () {
        var arg0 = cst_encode_String(uri);
        return wire.wire__crate__api__uri__ffi_uri_parse(arg0);
      },
      codec: DcoCodec(
        decodeSuccessData: dco_decode_ffi_uri,
        decodeErrorData: dco_decode_payjoin_error,
      ),
      constMeta: kCrateApiUriFfiUriParseConstMeta,
      argValues: [uri],
      apiImpl: this,
    ));
  }

  TaskConstMeta get kCrateApiUriFfiUriParseConstMeta => const TaskConstMeta(
        debugName: "ffi_uri_parse",
        argNames: ["uri"],
      );

  @override
  String crateApiUriFfiUrlAsString({required FfiUrl that}) {
    return handler.executeSync(SyncTask(
      callFfi: () {
        var arg0 = cst_encode_box_autoadd_ffi_url(that);
        return wire.wire__crate__api__uri__ffi_url_as_string(arg0);
      },
      codec: DcoCodec(
        decodeSuccessData: dco_decode_String,
        decodeErrorData: null,
      ),
      constMeta: kCrateApiUriFfiUrlAsStringConstMeta,
      argValues: [that],
      apiImpl: this,
    ));
  }

  TaskConstMeta get kCrateApiUriFfiUrlAsStringConstMeta => const TaskConstMeta(
        debugName: "ffi_url_as_string",
        argNames: ["that"],
      );

  @override
  FfiUrl crateApiUriFfiUrlParse({required String url}) {
    return handler.executeSync(SyncTask(
      callFfi: () {
        var arg0 = cst_encode_String(url);
        return wire.wire__crate__api__uri__ffi_url_parse(arg0);
      },
      codec: DcoCodec(
        decodeSuccessData: dco_decode_ffi_url,
        decodeErrorData: dco_decode_payjoin_error,
      ),
      constMeta: kCrateApiUriFfiUrlParseConstMeta,
      argValues: [url],
      apiImpl: this,
    ));
  }

  TaskConstMeta get kCrateApiUriFfiUrlParseConstMeta => const TaskConstMeta(
        debugName: "ffi_url_parse",
        argNames: ["url"],
      );

  @override
  String? crateApiUriFfiUrlQuery({required FfiUrl that}) {
    return handler.executeSync(SyncTask(
      callFfi: () {
        var arg0 = cst_encode_box_autoadd_ffi_url(that);
        return wire.wire__crate__api__uri__ffi_url_query(arg0);
      },
      codec: DcoCodec(
        decodeSuccessData: dco_decode_opt_String,
        decodeErrorData: null,
      ),
      constMeta: kCrateApiUriFfiUrlQueryConstMeta,
      argValues: [that],
      apiImpl: this,
    ));
  }

  TaskConstMeta get kCrateApiUriFfiUrlQueryConstMeta => const TaskConstMeta(
        debugName: "ffi_url_query",
        argNames: ["that"],
      );

  Future<void> Function(int, dynamic)
      encode_DartFn_Inputs_String_Output_String_AnyhowException(
          FutureOr<String> Function(String) raw) {
    return (callId, rawArg0) async {
      final arg0 = dco_decode_String(rawArg0);

      Box<String>? rawOutput;
      Box<AnyhowException>? rawError;
      try {
        rawOutput = Box(await raw(arg0));
      } catch (e, s) {
        rawError = Box(AnyhowException("$e\n\n$s"));
      }

      final serializer = SseSerializer(generalizedFrbRustBinding);
      assert((rawOutput != null) ^ (rawError != null));
      if (rawOutput != null) {
        serializer.buffer.putUint8(0);
        sse_encode_String(rawOutput.value, serializer);
      } else {
        serializer.buffer.putUint8(1);
        sse_encode_AnyhowException(rawError!.value, serializer);
      }
      final output = serializer.intoRaw();

      generalizedFrbRustBinding.dartFnDeliverOutput(
          callId: callId,
          ptr: output.ptr,
          rustVecLen: output.rustVecLen,
          dataLen: output.dataLen);
    };
  }

  Future<void> Function(int, dynamic)
      encode_DartFn_Inputs_list_prim_u_8_strict_Output_bool_AnyhowException(
          FutureOr<bool> Function(Uint8List) raw) {
    return (callId, rawArg0) async {
      final arg0 = dco_decode_list_prim_u_8_strict(rawArg0);

      Box<bool>? rawOutput;
      Box<AnyhowException>? rawError;
      try {
        rawOutput = Box(await raw(arg0));
      } catch (e, s) {
        rawError = Box(AnyhowException("$e\n\n$s"));
      }

      final serializer = SseSerializer(generalizedFrbRustBinding);
      assert((rawOutput != null) ^ (rawError != null));
      if (rawOutput != null) {
        serializer.buffer.putUint8(0);
        sse_encode_bool(rawOutput.value, serializer);
      } else {
        serializer.buffer.putUint8(1);
        sse_encode_AnyhowException(rawError!.value, serializer);
      }
      final output = serializer.intoRaw();

      generalizedFrbRustBinding.dartFnDeliverOutput(
          callId: callId,
          ptr: output.ptr,
          rustVecLen: output.rustVecLen,
          dataLen: output.dataLen);
    };
  }

  Future<void> Function(int, dynamic)
      encode_DartFn_Inputs_out_point_Output_bool_AnyhowException(
          FutureOr<bool> Function(OutPoint) raw) {
    return (callId, rawArg0) async {
      final arg0 = dco_decode_out_point(rawArg0);

      Box<bool>? rawOutput;
      Box<AnyhowException>? rawError;
      try {
        rawOutput = Box(await raw(arg0));
      } catch (e, s) {
        rawError = Box(AnyhowException("$e\n\n$s"));
      }

      final serializer = SseSerializer(generalizedFrbRustBinding);
      assert((rawOutput != null) ^ (rawError != null));
      if (rawOutput != null) {
        serializer.buffer.putUint8(0);
        sse_encode_bool(rawOutput.value, serializer);
      } else {
        serializer.buffer.putUint8(1);
        sse_encode_AnyhowException(rawError!.value, serializer);
      }
      final output = serializer.intoRaw();

      generalizedFrbRustBinding.dartFnDeliverOutput(
          callId: callId,
          ptr: output.ptr,
          rustVecLen: output.rustVecLen,
          dataLen: output.dataLen);
    };
  }

  RustArcIncrementStrongCountFnType
      get rust_arc_increment_strong_count_Script =>
          wire.rust_arc_increment_strong_count_RustOpaque_bitcoin_ffiScript;

  RustArcDecrementStrongCountFnType
      get rust_arc_decrement_strong_count_Script =>
          wire.rust_arc_decrement_strong_count_RustOpaque_bitcoin_ffiScript;

  RustArcIncrementStrongCountFnType
      get rust_arc_increment_strong_count_OhttpKeys =>
          wire.rust_arc_increment_strong_count_RustOpaque_payjoin_ffiOhttpKeys;

  RustArcDecrementStrongCountFnType
      get rust_arc_decrement_strong_count_OhttpKeys =>
          wire.rust_arc_decrement_strong_count_RustOpaque_payjoin_ffiOhttpKeys;

  RustArcIncrementStrongCountFnType get rust_arc_increment_strong_count_Url =>
      wire.rust_arc_increment_strong_count_RustOpaque_payjoin_ffiUrl;

  RustArcDecrementStrongCountFnType get rust_arc_decrement_strong_count_Url =>
      wire.rust_arc_decrement_strong_count_RustOpaque_payjoin_ffiUrl;

  RustArcIncrementStrongCountFnType
      get rust_arc_increment_strong_count_InputPair => wire
          .rust_arc_increment_strong_count_RustOpaque_payjoin_ffireceiveInputPair;

  RustArcDecrementStrongCountFnType
      get rust_arc_decrement_strong_count_InputPair => wire
          .rust_arc_decrement_strong_count_RustOpaque_payjoin_ffireceiveInputPair;

  RustArcIncrementStrongCountFnType
      get rust_arc_increment_strong_count_MaybeInputsOwned => wire
          .rust_arc_increment_strong_count_RustOpaque_payjoin_ffireceiveMaybeInputsOwned;

  RustArcDecrementStrongCountFnType
      get rust_arc_decrement_strong_count_MaybeInputsOwned => wire
          .rust_arc_decrement_strong_count_RustOpaque_payjoin_ffireceiveMaybeInputsOwned;

  RustArcIncrementStrongCountFnType
      get rust_arc_increment_strong_count_MaybeInputsSeen => wire
          .rust_arc_increment_strong_count_RustOpaque_payjoin_ffireceiveMaybeInputsSeen;

  RustArcDecrementStrongCountFnType
      get rust_arc_decrement_strong_count_MaybeInputsSeen => wire
          .rust_arc_decrement_strong_count_RustOpaque_payjoin_ffireceiveMaybeInputsSeen;

  RustArcIncrementStrongCountFnType
      get rust_arc_increment_strong_count_OutputsUnknown => wire
          .rust_arc_increment_strong_count_RustOpaque_payjoin_ffireceiveOutputsUnknown;

  RustArcDecrementStrongCountFnType
      get rust_arc_decrement_strong_count_OutputsUnknown => wire
          .rust_arc_decrement_strong_count_RustOpaque_payjoin_ffireceiveOutputsUnknown;

  RustArcIncrementStrongCountFnType
      get rust_arc_increment_strong_count_PayjoinProposal => wire
          .rust_arc_increment_strong_count_RustOpaque_payjoin_ffireceivePayjoinProposal;

  RustArcDecrementStrongCountFnType
      get rust_arc_decrement_strong_count_PayjoinProposal => wire
          .rust_arc_decrement_strong_count_RustOpaque_payjoin_ffireceivePayjoinProposal;

  RustArcIncrementStrongCountFnType
      get rust_arc_increment_strong_count_ProvisionalProposal => wire
          .rust_arc_increment_strong_count_RustOpaque_payjoin_ffireceiveProvisionalProposal;

  RustArcDecrementStrongCountFnType
      get rust_arc_decrement_strong_count_ProvisionalProposal => wire
          .rust_arc_decrement_strong_count_RustOpaque_payjoin_ffireceiveProvisionalProposal;

  RustArcIncrementStrongCountFnType
      get rust_arc_increment_strong_count_Receiver => wire
          .rust_arc_increment_strong_count_RustOpaque_payjoin_ffireceiveReceiver;

  RustArcDecrementStrongCountFnType
      get rust_arc_decrement_strong_count_Receiver => wire
          .rust_arc_decrement_strong_count_RustOpaque_payjoin_ffireceiveReceiver;

  RustArcIncrementStrongCountFnType
      get rust_arc_increment_strong_count_UncheckedProposal => wire
          .rust_arc_increment_strong_count_RustOpaque_payjoin_ffireceiveUncheckedProposal;

  RustArcDecrementStrongCountFnType
      get rust_arc_decrement_strong_count_UncheckedProposal => wire
          .rust_arc_decrement_strong_count_RustOpaque_payjoin_ffireceiveUncheckedProposal;

  RustArcIncrementStrongCountFnType
      get rust_arc_increment_strong_count_WantsInputs => wire
          .rust_arc_increment_strong_count_RustOpaque_payjoin_ffireceiveWantsInputs;

  RustArcDecrementStrongCountFnType
      get rust_arc_decrement_strong_count_WantsInputs => wire
          .rust_arc_decrement_strong_count_RustOpaque_payjoin_ffireceiveWantsInputs;

  RustArcIncrementStrongCountFnType
      get rust_arc_increment_strong_count_WantsOutputs => wire
          .rust_arc_increment_strong_count_RustOpaque_payjoin_ffireceiveWantsOutputs;

  RustArcDecrementStrongCountFnType
      get rust_arc_decrement_strong_count_WantsOutputs => wire
          .rust_arc_decrement_strong_count_RustOpaque_payjoin_ffireceiveWantsOutputs;

  RustArcIncrementStrongCountFnType
      get rust_arc_increment_strong_count_Sender =>
          wire.rust_arc_increment_strong_count_RustOpaque_payjoin_ffisendSender;

  RustArcDecrementStrongCountFnType
      get rust_arc_decrement_strong_count_Sender =>
          wire.rust_arc_decrement_strong_count_RustOpaque_payjoin_ffisendSender;

  RustArcIncrementStrongCountFnType
      get rust_arc_increment_strong_count_SenderBuilder => wire
          .rust_arc_increment_strong_count_RustOpaque_payjoin_ffisendSenderBuilder;

  RustArcDecrementStrongCountFnType
      get rust_arc_decrement_strong_count_SenderBuilder => wire
          .rust_arc_decrement_strong_count_RustOpaque_payjoin_ffisendSenderBuilder;

  RustArcIncrementStrongCountFnType
      get rust_arc_increment_strong_count_V1Context => wire
          .rust_arc_increment_strong_count_RustOpaque_payjoin_ffisendV1Context;

  RustArcDecrementStrongCountFnType
      get rust_arc_decrement_strong_count_V1Context => wire
          .rust_arc_decrement_strong_count_RustOpaque_payjoin_ffisendV1Context;

  RustArcIncrementStrongCountFnType
      get rust_arc_increment_strong_count_V2GetContext => wire
          .rust_arc_increment_strong_count_RustOpaque_payjoin_ffisendV2GetContext;

  RustArcDecrementStrongCountFnType
      get rust_arc_decrement_strong_count_V2GetContext => wire
          .rust_arc_decrement_strong_count_RustOpaque_payjoin_ffisendV2GetContext;

  RustArcIncrementStrongCountFnType
      get rust_arc_increment_strong_count_V2PostContext => wire
          .rust_arc_increment_strong_count_RustOpaque_payjoin_ffisendV2PostContext;

  RustArcDecrementStrongCountFnType
      get rust_arc_decrement_strong_count_V2PostContext => wire
          .rust_arc_decrement_strong_count_RustOpaque_payjoin_ffisendV2PostContext;

  RustArcIncrementStrongCountFnType get rust_arc_increment_strong_count_PjUri =>
      wire.rust_arc_increment_strong_count_RustOpaque_payjoin_ffiuriPjUri;

  RustArcDecrementStrongCountFnType get rust_arc_decrement_strong_count_PjUri =>
      wire.rust_arc_decrement_strong_count_RustOpaque_payjoin_ffiuriPjUri;

  RustArcIncrementStrongCountFnType
      get rust_arc_increment_strong_count_PjUriBuilder => wire
          .rust_arc_increment_strong_count_RustOpaque_payjoin_ffiuriPjUriBuilder;

  RustArcDecrementStrongCountFnType
      get rust_arc_decrement_strong_count_PjUriBuilder => wire
          .rust_arc_decrement_strong_count_RustOpaque_payjoin_ffiuriPjUriBuilder;

  RustArcIncrementStrongCountFnType get rust_arc_increment_strong_count_Uri =>
      wire.rust_arc_increment_strong_count_RustOpaque_payjoin_ffiuriUri;

  RustArcDecrementStrongCountFnType get rust_arc_decrement_strong_count_Uri =>
      wire.rust_arc_decrement_strong_count_RustOpaque_payjoin_ffiuriUri;

  RustArcIncrementStrongCountFnType
      get rust_arc_increment_strong_count_MutexOptionClientResponse => wire
          .rust_arc_increment_strong_count_RustOpaque_stdsyncMutexcoreoptionOptionpayjoin_ffiClientResponse;

  RustArcDecrementStrongCountFnType
      get rust_arc_decrement_strong_count_MutexOptionClientResponse => wire
          .rust_arc_decrement_strong_count_RustOpaque_stdsyncMutexcoreoptionOptionpayjoin_ffiClientResponse;

  @protected
  AnyhowException dco_decode_AnyhowException(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    return AnyhowException(raw as String);
  }

  @protected
  FutureOr<String> Function(String)
      dco_decode_DartFn_Inputs_String_Output_String_AnyhowException(
          dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    throw UnimplementedError('');
  }

  @protected
  FutureOr<bool> Function(Uint8List)
      dco_decode_DartFn_Inputs_list_prim_u_8_strict_Output_bool_AnyhowException(
          dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    throw UnimplementedError('');
  }

  @protected
  FutureOr<bool> Function(OutPoint)
      dco_decode_DartFn_Inputs_out_point_Output_bool_AnyhowException(
          dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    throw UnimplementedError('');
  }

  @protected
  Object dco_decode_DartOpaque(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    return decodeDartOpaque(raw, generalizedFrbRustBinding);
  }

  @protected
  Script dco_decode_RustOpaque_bitcoin_ffiScript(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    return ScriptImpl.frbInternalDcoDecode(raw as List<dynamic>);
  }

  @protected
  OhttpKeys dco_decode_RustOpaque_payjoin_ffiOhttpKeys(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    return OhttpKeysImpl.frbInternalDcoDecode(raw as List<dynamic>);
  }

  @protected
  Url dco_decode_RustOpaque_payjoin_ffiUrl(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    return UrlImpl.frbInternalDcoDecode(raw as List<dynamic>);
  }

  @protected
  InputPair dco_decode_RustOpaque_payjoin_ffireceiveInputPair(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    return InputPairImpl.frbInternalDcoDecode(raw as List<dynamic>);
  }

  @protected
  MaybeInputsOwned dco_decode_RustOpaque_payjoin_ffireceiveMaybeInputsOwned(
      dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    return MaybeInputsOwnedImpl.frbInternalDcoDecode(raw as List<dynamic>);
  }

  @protected
  MaybeInputsSeen dco_decode_RustOpaque_payjoin_ffireceiveMaybeInputsSeen(
      dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    return MaybeInputsSeenImpl.frbInternalDcoDecode(raw as List<dynamic>);
  }

  @protected
  OutputsUnknown dco_decode_RustOpaque_payjoin_ffireceiveOutputsUnknown(
      dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    return OutputsUnknownImpl.frbInternalDcoDecode(raw as List<dynamic>);
  }

  @protected
  PayjoinProposal dco_decode_RustOpaque_payjoin_ffireceivePayjoinProposal(
      dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    return PayjoinProposalImpl.frbInternalDcoDecode(raw as List<dynamic>);
  }

  @protected
  ProvisionalProposal
      dco_decode_RustOpaque_payjoin_ffireceiveProvisionalProposal(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    return ProvisionalProposalImpl.frbInternalDcoDecode(raw as List<dynamic>);
  }

  @protected
  Receiver dco_decode_RustOpaque_payjoin_ffireceiveReceiver(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    return ReceiverImpl.frbInternalDcoDecode(raw as List<dynamic>);
  }

  @protected
  UncheckedProposal dco_decode_RustOpaque_payjoin_ffireceiveUncheckedProposal(
      dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    return UncheckedProposalImpl.frbInternalDcoDecode(raw as List<dynamic>);
  }

  @protected
  WantsInputs dco_decode_RustOpaque_payjoin_ffireceiveWantsInputs(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    return WantsInputsImpl.frbInternalDcoDecode(raw as List<dynamic>);
  }

  @protected
  WantsOutputs dco_decode_RustOpaque_payjoin_ffireceiveWantsOutputs(
      dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    return WantsOutputsImpl.frbInternalDcoDecode(raw as List<dynamic>);
  }

  @protected
  Sender dco_decode_RustOpaque_payjoin_ffisendSender(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    return SenderImpl.frbInternalDcoDecode(raw as List<dynamic>);
  }

  @protected
  SenderBuilder dco_decode_RustOpaque_payjoin_ffisendSenderBuilder(
      dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    return SenderBuilderImpl.frbInternalDcoDecode(raw as List<dynamic>);
  }

  @protected
  V1Context dco_decode_RustOpaque_payjoin_ffisendV1Context(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    return V1ContextImpl.frbInternalDcoDecode(raw as List<dynamic>);
  }

  @protected
  V2GetContext dco_decode_RustOpaque_payjoin_ffisendV2GetContext(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    return V2GetContextImpl.frbInternalDcoDecode(raw as List<dynamic>);
  }

  @protected
  V2PostContext dco_decode_RustOpaque_payjoin_ffisendV2PostContext(
      dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    return V2PostContextImpl.frbInternalDcoDecode(raw as List<dynamic>);
  }

  @protected
  PjUri dco_decode_RustOpaque_payjoin_ffiuriPjUri(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    return PjUriImpl.frbInternalDcoDecode(raw as List<dynamic>);
  }

  @protected
  PjUriBuilder dco_decode_RustOpaque_payjoin_ffiuriPjUriBuilder(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    return PjUriBuilderImpl.frbInternalDcoDecode(raw as List<dynamic>);
  }

  @protected
  Uri dco_decode_RustOpaque_payjoin_ffiuriUri(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    return UriImpl.frbInternalDcoDecode(raw as List<dynamic>);
  }

  @protected
  MutexOptionClientResponse
      dco_decode_RustOpaque_stdsyncMutexcoreoptionOptionpayjoin_ffiClientResponse(
          dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    return MutexOptionClientResponseImpl.frbInternalDcoDecode(
        raw as List<dynamic>);
  }

  @protected
  String dco_decode_String(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    return raw as String;
  }

  @protected
  bool dco_decode_bool(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    return raw as bool;
  }

  @protected
  ClientResponse dco_decode_box_autoadd_client_response(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    return dco_decode_client_response(raw);
  }

  @protected
  FfiMaybeInputsOwned dco_decode_box_autoadd_ffi_maybe_inputs_owned(
      dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    return dco_decode_ffi_maybe_inputs_owned(raw);
  }

  @protected
  FfiMaybeInputsSeen dco_decode_box_autoadd_ffi_maybe_inputs_seen(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    return dco_decode_ffi_maybe_inputs_seen(raw);
  }

  @protected
  FfiOhttpKeys dco_decode_box_autoadd_ffi_ohttp_keys(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    return dco_decode_ffi_ohttp_keys(raw);
  }

  @protected
  FfiOutputsUnknown dco_decode_box_autoadd_ffi_outputs_unknown(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    return dco_decode_ffi_outputs_unknown(raw);
  }

  @protected
  FfiPayjoinProposal dco_decode_box_autoadd_ffi_payjoin_proposal(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    return dco_decode_ffi_payjoin_proposal(raw);
  }

  @protected
  FfiPjUri dco_decode_box_autoadd_ffi_pj_uri(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    return dco_decode_ffi_pj_uri(raw);
  }

  @protected
  FfiPjUriBuilder dco_decode_box_autoadd_ffi_pj_uri_builder(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    return dco_decode_ffi_pj_uri_builder(raw);
  }

  @protected
  FfiProvisionalProposal dco_decode_box_autoadd_ffi_provisional_proposal(
      dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    return dco_decode_ffi_provisional_proposal(raw);
  }

  @protected
  FfiReceiver dco_decode_box_autoadd_ffi_receiver(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    return dco_decode_ffi_receiver(raw);
  }

  @protected
  FfiScript dco_decode_box_autoadd_ffi_script(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    return dco_decode_ffi_script(raw);
  }

  @protected
  FfiSender dco_decode_box_autoadd_ffi_sender(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    return dco_decode_ffi_sender(raw);
  }

  @protected
  FfiSenderBuilder dco_decode_box_autoadd_ffi_sender_builder(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    return dco_decode_ffi_sender_builder(raw);
  }

  @protected
  FfiUncheckedProposal dco_decode_box_autoadd_ffi_unchecked_proposal(
      dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    return dco_decode_ffi_unchecked_proposal(raw);
  }

  @protected
  FfiUri dco_decode_box_autoadd_ffi_uri(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    return dco_decode_ffi_uri(raw);
  }

  @protected
  FfiUrl dco_decode_box_autoadd_ffi_url(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    return dco_decode_ffi_url(raw);
  }

  @protected
  FfiV1Context dco_decode_box_autoadd_ffi_v_1_context(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    return dco_decode_ffi_v_1_context(raw);
  }

  @protected
  FfiV2GetContext dco_decode_box_autoadd_ffi_v_2_get_context(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    return dco_decode_ffi_v_2_get_context(raw);
  }

  @protected
  FfiV2PostContext dco_decode_box_autoadd_ffi_v_2_post_context(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    return dco_decode_ffi_v_2_post_context(raw);
  }

  @protected
  FfiWantsInputs dco_decode_box_autoadd_ffi_wants_inputs(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    return dco_decode_ffi_wants_inputs(raw);
  }

  @protected
  FfiWantsOutputs dco_decode_box_autoadd_ffi_wants_outputs(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    return dco_decode_ffi_wants_outputs(raw);
  }

  @protected
  PsbtInput dco_decode_box_autoadd_psbt_input(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    return dco_decode_psbt_input(raw);
  }

  @protected
  TxIn dco_decode_box_autoadd_tx_in(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    return dco_decode_tx_in(raw);
  }

  @protected
  TxOut dco_decode_box_autoadd_tx_out(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    return dco_decode_tx_out(raw);
  }

  @protected
  BigInt dco_decode_box_autoadd_u_64(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    return dco_decode_u_64(raw);
  }

  @protected
  int dco_decode_box_autoadd_u_8(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    return raw as int;
  }

  @protected
  ClientResponse dco_decode_client_response(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    final arr = raw as List<dynamic>;
    if (arr.length != 1)
      throw Exception('unexpected arr length: expect 1 but see ${arr.length}');
    return ClientResponse(
      field0:
          dco_decode_RustOpaque_stdsyncMutexcoreoptionOptionpayjoin_ffiClientResponse(
              arr[0]),
    );
  }

  @protected
  FfiInputPair dco_decode_ffi_input_pair(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    final arr = raw as List<dynamic>;
    if (arr.length != 1)
      throw Exception('unexpected arr length: expect 1 but see ${arr.length}');
    return FfiInputPair(
      field0: dco_decode_RustOpaque_payjoin_ffireceiveInputPair(arr[0]),
    );
  }

  @protected
  FfiMaybeInputsOwned dco_decode_ffi_maybe_inputs_owned(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    final arr = raw as List<dynamic>;
    if (arr.length != 1)
      throw Exception('unexpected arr length: expect 1 but see ${arr.length}');
    return FfiMaybeInputsOwned(
      field0: dco_decode_RustOpaque_payjoin_ffireceiveMaybeInputsOwned(arr[0]),
    );
  }

  @protected
  FfiMaybeInputsSeen dco_decode_ffi_maybe_inputs_seen(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    final arr = raw as List<dynamic>;
    if (arr.length != 1)
      throw Exception('unexpected arr length: expect 1 but see ${arr.length}');
    return FfiMaybeInputsSeen(
      field0: dco_decode_RustOpaque_payjoin_ffireceiveMaybeInputsSeen(arr[0]),
    );
  }

  @protected
  FfiOhttpKeys dco_decode_ffi_ohttp_keys(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    final arr = raw as List<dynamic>;
    if (arr.length != 1)
      throw Exception('unexpected arr length: expect 1 but see ${arr.length}');
    return FfiOhttpKeys(
      field0: dco_decode_RustOpaque_payjoin_ffiOhttpKeys(arr[0]),
    );
  }

  @protected
  FfiOutputsUnknown dco_decode_ffi_outputs_unknown(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    final arr = raw as List<dynamic>;
    if (arr.length != 1)
      throw Exception('unexpected arr length: expect 1 but see ${arr.length}');
    return FfiOutputsUnknown(
      field0: dco_decode_RustOpaque_payjoin_ffireceiveOutputsUnknown(arr[0]),
    );
  }

  @protected
  FfiPayjoinProposal dco_decode_ffi_payjoin_proposal(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    final arr = raw as List<dynamic>;
    if (arr.length != 1)
      throw Exception('unexpected arr length: expect 1 but see ${arr.length}');
    return FfiPayjoinProposal(
      field0: dco_decode_RustOpaque_payjoin_ffireceivePayjoinProposal(arr[0]),
    );
  }

  @protected
  FfiPjUri dco_decode_ffi_pj_uri(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    final arr = raw as List<dynamic>;
    if (arr.length != 1)
      throw Exception('unexpected arr length: expect 1 but see ${arr.length}');
    return FfiPjUri(
      field0: dco_decode_RustOpaque_payjoin_ffiuriPjUri(arr[0]),
    );
  }

  @protected
  FfiPjUriBuilder dco_decode_ffi_pj_uri_builder(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    final arr = raw as List<dynamic>;
    if (arr.length != 1)
      throw Exception('unexpected arr length: expect 1 but see ${arr.length}');
    return FfiPjUriBuilder(
      internal: dco_decode_RustOpaque_payjoin_ffiuriPjUriBuilder(arr[0]),
    );
  }

  @protected
  FfiProvisionalProposal dco_decode_ffi_provisional_proposal(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    final arr = raw as List<dynamic>;
    if (arr.length != 1)
      throw Exception('unexpected arr length: expect 1 but see ${arr.length}');
    return FfiProvisionalProposal(
      field0:
          dco_decode_RustOpaque_payjoin_ffireceiveProvisionalProposal(arr[0]),
    );
  }

  @protected
  FfiReceiver dco_decode_ffi_receiver(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    final arr = raw as List<dynamic>;
    if (arr.length != 1)
      throw Exception('unexpected arr length: expect 1 but see ${arr.length}');
    return FfiReceiver(
      field0: dco_decode_RustOpaque_payjoin_ffireceiveReceiver(arr[0]),
    );
  }

  @protected
  FfiScript dco_decode_ffi_script(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    final arr = raw as List<dynamic>;
    if (arr.length != 1)
      throw Exception('unexpected arr length: expect 1 but see ${arr.length}');
    return FfiScript(
      field0: dco_decode_RustOpaque_bitcoin_ffiScript(arr[0]),
    );
  }

  @protected
  FfiSender dco_decode_ffi_sender(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    final arr = raw as List<dynamic>;
    if (arr.length != 1)
      throw Exception('unexpected arr length: expect 1 but see ${arr.length}');
    return FfiSender(
      field0: dco_decode_RustOpaque_payjoin_ffisendSender(arr[0]),
    );
  }

  @protected
  FfiSenderBuilder dco_decode_ffi_sender_builder(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    final arr = raw as List<dynamic>;
    if (arr.length != 1)
      throw Exception('unexpected arr length: expect 1 but see ${arr.length}');
    return FfiSenderBuilder(
      field0: dco_decode_RustOpaque_payjoin_ffisendSenderBuilder(arr[0]),
    );
  }

  @protected
  FfiUncheckedProposal dco_decode_ffi_unchecked_proposal(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    final arr = raw as List<dynamic>;
    if (arr.length != 1)
      throw Exception('unexpected arr length: expect 1 but see ${arr.length}');
    return FfiUncheckedProposal(
      field0: dco_decode_RustOpaque_payjoin_ffireceiveUncheckedProposal(arr[0]),
    );
  }

  @protected
  FfiUri dco_decode_ffi_uri(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    final arr = raw as List<dynamic>;
    if (arr.length != 1)
      throw Exception('unexpected arr length: expect 1 but see ${arr.length}');
    return FfiUri(
      field0: dco_decode_RustOpaque_payjoin_ffiuriUri(arr[0]),
    );
  }

  @protected
  FfiUrl dco_decode_ffi_url(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    final arr = raw as List<dynamic>;
    if (arr.length != 1)
      throw Exception('unexpected arr length: expect 1 but see ${arr.length}');
    return FfiUrl(
      field0: dco_decode_RustOpaque_payjoin_ffiUrl(arr[0]),
    );
  }

  @protected
  FfiV1Context dco_decode_ffi_v_1_context(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    final arr = raw as List<dynamic>;
    if (arr.length != 1)
      throw Exception('unexpected arr length: expect 1 but see ${arr.length}');
    return FfiV1Context(
      field0: dco_decode_RustOpaque_payjoin_ffisendV1Context(arr[0]),
    );
  }

  @protected
  FfiV2GetContext dco_decode_ffi_v_2_get_context(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    final arr = raw as List<dynamic>;
    if (arr.length != 1)
      throw Exception('unexpected arr length: expect 1 but see ${arr.length}');
    return FfiV2GetContext(
      field0: dco_decode_RustOpaque_payjoin_ffisendV2GetContext(arr[0]),
    );
  }

  @protected
  FfiV2PostContext dco_decode_ffi_v_2_post_context(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    final arr = raw as List<dynamic>;
    if (arr.length != 1)
      throw Exception('unexpected arr length: expect 1 but see ${arr.length}');
    return FfiV2PostContext(
      field0: dco_decode_RustOpaque_payjoin_ffisendV2PostContext(arr[0]),
    );
  }

  @protected
  FfiWantsInputs dco_decode_ffi_wants_inputs(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    final arr = raw as List<dynamic>;
    if (arr.length != 1)
      throw Exception('unexpected arr length: expect 1 but see ${arr.length}');
    return FfiWantsInputs(
      field0: dco_decode_RustOpaque_payjoin_ffireceiveWantsInputs(arr[0]),
    );
  }

  @protected
  FfiWantsOutputs dco_decode_ffi_wants_outputs(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    final arr = raw as List<dynamic>;
    if (arr.length != 1)
      throw Exception('unexpected arr length: expect 1 but see ${arr.length}');
    return FfiWantsOutputs(
      field0: dco_decode_RustOpaque_payjoin_ffireceiveWantsOutputs(arr[0]),
    );
  }

  @protected
  int dco_decode_i_32(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    return raw as int;
  }

  @protected
  List<FfiInputPair> dco_decode_list_ffi_input_pair(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    return (raw as List<dynamic>).map(dco_decode_ffi_input_pair).toList();
  }

  @protected
  List<Uint8List> dco_decode_list_list_prim_u_8_strict(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    return (raw as List<dynamic>).map(dco_decode_list_prim_u_8_strict).toList();
  }

  @protected
  List<OutPoint> dco_decode_list_out_point(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    return (raw as List<dynamic>).map(dco_decode_out_point).toList();
  }

  @protected
  List<int> dco_decode_list_prim_u_8_loose(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    return raw as List<int>;
  }

  @protected
  Uint8List dco_decode_list_prim_u_8_strict(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    return raw as Uint8List;
  }

  @protected
  List<TxOut> dco_decode_list_tx_out(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    return (raw as List<dynamic>).map(dco_decode_tx_out).toList();
  }

  @protected
  Network dco_decode_network(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    return Network.values[raw as int];
  }

  @protected
  String? dco_decode_opt_String(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    return raw == null ? null : dco_decode_String(raw);
  }

  @protected
  FfiScript? dco_decode_opt_box_autoadd_ffi_script(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    return raw == null ? null : dco_decode_box_autoadd_ffi_script(raw);
  }

  @protected
  FfiUncheckedProposal? dco_decode_opt_box_autoadd_ffi_unchecked_proposal(
      dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    return raw == null
        ? null
        : dco_decode_box_autoadd_ffi_unchecked_proposal(raw);
  }

  @protected
  TxOut? dco_decode_opt_box_autoadd_tx_out(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    return raw == null ? null : dco_decode_box_autoadd_tx_out(raw);
  }

  @protected
  BigInt? dco_decode_opt_box_autoadd_u_64(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    return raw == null ? null : dco_decode_box_autoadd_u_64(raw);
  }

  @protected
  int? dco_decode_opt_box_autoadd_u_8(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    return raw == null ? null : dco_decode_box_autoadd_u_8(raw);
  }

  @protected
  OutPoint dco_decode_out_point(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    final arr = raw as List<dynamic>;
    if (arr.length != 2)
      throw Exception('unexpected arr length: expect 2 but see ${arr.length}');
    return OutPoint(
      txid: dco_decode_String(arr[0]),
      vout: dco_decode_u_32(arr[1]),
    );
  }

  @protected
  PayjoinError dco_decode_payjoin_error(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    switch (raw[0]) {
      case 0:
        return PayjoinError_InvalidAddress(
          message: dco_decode_String(raw[1]),
        );
      case 1:
        return PayjoinError_InvalidScript(
          message: dco_decode_String(raw[1]),
        );
      case 2:
        return PayjoinError_NetworkValidation(
          message: dco_decode_String(raw[1]),
        );
      case 3:
        return PayjoinError_PsbtParseError(
          message: dco_decode_String(raw[1]),
        );
      case 4:
        return PayjoinError_ResponseError(
          message: dco_decode_String(raw[1]),
        );
      case 5:
        return PayjoinError_RequestError(
          message: dco_decode_String(raw[1]),
        );
      case 6:
        return PayjoinError_TransactionError(
          message: dco_decode_String(raw[1]),
        );
      case 7:
        return PayjoinError_ServerError(
          message: dco_decode_String(raw[1]),
        );
      case 8:
        return PayjoinError_SelectionError(
          message: dco_decode_String(raw[1]),
        );
      case 9:
        return PayjoinError_CreateRequestError(
          message: dco_decode_String(raw[1]),
        );
      case 10:
        return PayjoinError_PjParseError(
          message: dco_decode_String(raw[1]),
        );
      case 11:
        return PayjoinError_PjNotSupported(
          message: dco_decode_String(raw[1]),
        );
      case 12:
        return PayjoinError_ValidationError(
          message: dco_decode_String(raw[1]),
        );
      case 13:
        return PayjoinError_V2Error(
          message: dco_decode_String(raw[1]),
        );
      case 14:
        return PayjoinError_UnexpectedError(
          message: dco_decode_String(raw[1]),
        );
      case 15:
        return PayjoinError_OhttpError(
          message: dco_decode_String(raw[1]),
        );
      case 16:
        return PayjoinError_UrlError(
          message: dco_decode_String(raw[1]),
        );
      case 17:
        return PayjoinError_IoError(
          message: dco_decode_String(raw[1]),
        );
      case 18:
        return PayjoinError_OutputSubstitutionError(
          message: dco_decode_String(raw[1]),
        );
      case 19:
        return PayjoinError_InputContributionError(
          message: dco_decode_String(raw[1]),
        );
      case 20:
        return PayjoinError_InputPairError(
          message: dco_decode_String(raw[1]),
        );
      case 21:
        return PayjoinError_SerdeJsonError(
          message: dco_decode_String(raw[1]),
        );
      default:
        throw Exception("unreachable");
    }
  }

  @protected
  PsbtInput dco_decode_psbt_input(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    final arr = raw as List<dynamic>;
    if (arr.length != 3)
      throw Exception('unexpected arr length: expect 3 but see ${arr.length}');
    return PsbtInput(
      witnessUtxo: dco_decode_opt_box_autoadd_tx_out(arr[0]),
      redeemScript: dco_decode_opt_box_autoadd_ffi_script(arr[1]),
      witnessScript: dco_decode_opt_box_autoadd_ffi_script(arr[2]),
    );
  }

  @protected
  (Request, ClientResponse) dco_decode_record_request_client_response(
      dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    final arr = raw as List<dynamic>;
    if (arr.length != 2) {
      throw Exception('Expected 2 elements, got ${arr.length}');
    }
    return (
      dco_decode_request(arr[0]),
      dco_decode_client_response(arr[1]),
    );
  }

  @protected
  (Request, FfiV1Context) dco_decode_record_request_ffi_v_1_context(
      dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    final arr = raw as List<dynamic>;
    if (arr.length != 2) {
      throw Exception('Expected 2 elements, got ${arr.length}');
    }
    return (
      dco_decode_request(arr[0]),
      dco_decode_ffi_v_1_context(arr[1]),
    );
  }

  @protected
  (Request, FfiV2PostContext) dco_decode_record_request_ffi_v_2_post_context(
      dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    final arr = raw as List<dynamic>;
    if (arr.length != 2) {
      throw Exception('Expected 2 elements, got ${arr.length}');
    }
    return (
      dco_decode_request(arr[0]),
      dco_decode_ffi_v_2_post_context(arr[1]),
    );
  }

  @protected
  Request dco_decode_request(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    final arr = raw as List<dynamic>;
    if (arr.length != 3)
      throw Exception('unexpected arr length: expect 3 but see ${arr.length}');
    return Request(
      url: dco_decode_ffi_url(arr[0]),
      contentType: dco_decode_String(arr[1]),
      body: dco_decode_list_prim_u_8_strict(arr[2]),
    );
  }

  @protected
  TxIn dco_decode_tx_in(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    final arr = raw as List<dynamic>;
    if (arr.length != 4)
      throw Exception('unexpected arr length: expect 4 but see ${arr.length}');
    return TxIn(
      previousOutput: dco_decode_out_point(arr[0]),
      scriptSig: dco_decode_ffi_script(arr[1]),
      sequence: dco_decode_u_32(arr[2]),
      witness: dco_decode_list_list_prim_u_8_strict(arr[3]),
    );
  }

  @protected
  TxOut dco_decode_tx_out(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    final arr = raw as List<dynamic>;
    if (arr.length != 2)
      throw Exception('unexpected arr length: expect 2 but see ${arr.length}');
    return TxOut(
      value: dco_decode_u_64(arr[0]),
      scriptPubkey: dco_decode_list_prim_u_8_strict(arr[1]),
    );
  }

  @protected
  int dco_decode_u_32(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    return raw as int;
  }

  @protected
  BigInt dco_decode_u_64(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    return dcoDecodeU64(raw);
  }

  @protected
  int dco_decode_u_8(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    return raw as int;
  }

  @protected
  void dco_decode_unit(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    return;
  }

  @protected
  BigInt dco_decode_usize(dynamic raw) {
    // Codec=Dco (DartCObject based), see doc to use other codecs
    return dcoDecodeU64(raw);
  }

  @protected
  AnyhowException sse_decode_AnyhowException(SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    var inner = sse_decode_String(deserializer);
    return AnyhowException(inner);
  }

  @protected
  Object sse_decode_DartOpaque(SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    var inner = sse_decode_usize(deserializer);
    return decodeDartOpaque(inner, generalizedFrbRustBinding);
  }

  @protected
  Script sse_decode_RustOpaque_bitcoin_ffiScript(SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    return ScriptImpl.frbInternalSseDecode(
        sse_decode_usize(deserializer), sse_decode_i_32(deserializer));
  }

  @protected
  OhttpKeys sse_decode_RustOpaque_payjoin_ffiOhttpKeys(
      SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    return OhttpKeysImpl.frbInternalSseDecode(
        sse_decode_usize(deserializer), sse_decode_i_32(deserializer));
  }

  @protected
  Url sse_decode_RustOpaque_payjoin_ffiUrl(SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    return UrlImpl.frbInternalSseDecode(
        sse_decode_usize(deserializer), sse_decode_i_32(deserializer));
  }

  @protected
  InputPair sse_decode_RustOpaque_payjoin_ffireceiveInputPair(
      SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    return InputPairImpl.frbInternalSseDecode(
        sse_decode_usize(deserializer), sse_decode_i_32(deserializer));
  }

  @protected
  MaybeInputsOwned sse_decode_RustOpaque_payjoin_ffireceiveMaybeInputsOwned(
      SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    return MaybeInputsOwnedImpl.frbInternalSseDecode(
        sse_decode_usize(deserializer), sse_decode_i_32(deserializer));
  }

  @protected
  MaybeInputsSeen sse_decode_RustOpaque_payjoin_ffireceiveMaybeInputsSeen(
      SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    return MaybeInputsSeenImpl.frbInternalSseDecode(
        sse_decode_usize(deserializer), sse_decode_i_32(deserializer));
  }

  @protected
  OutputsUnknown sse_decode_RustOpaque_payjoin_ffireceiveOutputsUnknown(
      SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    return OutputsUnknownImpl.frbInternalSseDecode(
        sse_decode_usize(deserializer), sse_decode_i_32(deserializer));
  }

  @protected
  PayjoinProposal sse_decode_RustOpaque_payjoin_ffireceivePayjoinProposal(
      SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    return PayjoinProposalImpl.frbInternalSseDecode(
        sse_decode_usize(deserializer), sse_decode_i_32(deserializer));
  }

  @protected
  ProvisionalProposal
      sse_decode_RustOpaque_payjoin_ffireceiveProvisionalProposal(
          SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    return ProvisionalProposalImpl.frbInternalSseDecode(
        sse_decode_usize(deserializer), sse_decode_i_32(deserializer));
  }

  @protected
  Receiver sse_decode_RustOpaque_payjoin_ffireceiveReceiver(
      SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    return ReceiverImpl.frbInternalSseDecode(
        sse_decode_usize(deserializer), sse_decode_i_32(deserializer));
  }

  @protected
  UncheckedProposal sse_decode_RustOpaque_payjoin_ffireceiveUncheckedProposal(
      SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    return UncheckedProposalImpl.frbInternalSseDecode(
        sse_decode_usize(deserializer), sse_decode_i_32(deserializer));
  }

  @protected
  WantsInputs sse_decode_RustOpaque_payjoin_ffireceiveWantsInputs(
      SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    return WantsInputsImpl.frbInternalSseDecode(
        sse_decode_usize(deserializer), sse_decode_i_32(deserializer));
  }

  @protected
  WantsOutputs sse_decode_RustOpaque_payjoin_ffireceiveWantsOutputs(
      SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    return WantsOutputsImpl.frbInternalSseDecode(
        sse_decode_usize(deserializer), sse_decode_i_32(deserializer));
  }

  @protected
  Sender sse_decode_RustOpaque_payjoin_ffisendSender(
      SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    return SenderImpl.frbInternalSseDecode(
        sse_decode_usize(deserializer), sse_decode_i_32(deserializer));
  }

  @protected
  SenderBuilder sse_decode_RustOpaque_payjoin_ffisendSenderBuilder(
      SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    return SenderBuilderImpl.frbInternalSseDecode(
        sse_decode_usize(deserializer), sse_decode_i_32(deserializer));
  }

  @protected
  V1Context sse_decode_RustOpaque_payjoin_ffisendV1Context(
      SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    return V1ContextImpl.frbInternalSseDecode(
        sse_decode_usize(deserializer), sse_decode_i_32(deserializer));
  }

  @protected
  V2GetContext sse_decode_RustOpaque_payjoin_ffisendV2GetContext(
      SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    return V2GetContextImpl.frbInternalSseDecode(
        sse_decode_usize(deserializer), sse_decode_i_32(deserializer));
  }

  @protected
  V2PostContext sse_decode_RustOpaque_payjoin_ffisendV2PostContext(
      SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    return V2PostContextImpl.frbInternalSseDecode(
        sse_decode_usize(deserializer), sse_decode_i_32(deserializer));
  }

  @protected
  PjUri sse_decode_RustOpaque_payjoin_ffiuriPjUri(
      SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    return PjUriImpl.frbInternalSseDecode(
        sse_decode_usize(deserializer), sse_decode_i_32(deserializer));
  }

  @protected
  PjUriBuilder sse_decode_RustOpaque_payjoin_ffiuriPjUriBuilder(
      SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    return PjUriBuilderImpl.frbInternalSseDecode(
        sse_decode_usize(deserializer), sse_decode_i_32(deserializer));
  }

  @protected
  Uri sse_decode_RustOpaque_payjoin_ffiuriUri(SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    return UriImpl.frbInternalSseDecode(
        sse_decode_usize(deserializer), sse_decode_i_32(deserializer));
  }

  @protected
  MutexOptionClientResponse
      sse_decode_RustOpaque_stdsyncMutexcoreoptionOptionpayjoin_ffiClientResponse(
          SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    return MutexOptionClientResponseImpl.frbInternalSseDecode(
        sse_decode_usize(deserializer), sse_decode_i_32(deserializer));
  }

  @protected
  String sse_decode_String(SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    var inner = sse_decode_list_prim_u_8_strict(deserializer);
    return utf8.decoder.convert(inner);
  }

  @protected
  bool sse_decode_bool(SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    return deserializer.buffer.getUint8() != 0;
  }

  @protected
  ClientResponse sse_decode_box_autoadd_client_response(
      SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    return (sse_decode_client_response(deserializer));
  }

  @protected
  FfiMaybeInputsOwned sse_decode_box_autoadd_ffi_maybe_inputs_owned(
      SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    return (sse_decode_ffi_maybe_inputs_owned(deserializer));
  }

  @protected
  FfiMaybeInputsSeen sse_decode_box_autoadd_ffi_maybe_inputs_seen(
      SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    return (sse_decode_ffi_maybe_inputs_seen(deserializer));
  }

  @protected
  FfiOhttpKeys sse_decode_box_autoadd_ffi_ohttp_keys(
      SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    return (sse_decode_ffi_ohttp_keys(deserializer));
  }

  @protected
  FfiOutputsUnknown sse_decode_box_autoadd_ffi_outputs_unknown(
      SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    return (sse_decode_ffi_outputs_unknown(deserializer));
  }

  @protected
  FfiPayjoinProposal sse_decode_box_autoadd_ffi_payjoin_proposal(
      SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    return (sse_decode_ffi_payjoin_proposal(deserializer));
  }

  @protected
  FfiPjUri sse_decode_box_autoadd_ffi_pj_uri(SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    return (sse_decode_ffi_pj_uri(deserializer));
  }

  @protected
  FfiPjUriBuilder sse_decode_box_autoadd_ffi_pj_uri_builder(
      SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    return (sse_decode_ffi_pj_uri_builder(deserializer));
  }

  @protected
  FfiProvisionalProposal sse_decode_box_autoadd_ffi_provisional_proposal(
      SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    return (sse_decode_ffi_provisional_proposal(deserializer));
  }

  @protected
  FfiReceiver sse_decode_box_autoadd_ffi_receiver(
      SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    return (sse_decode_ffi_receiver(deserializer));
  }

  @protected
  FfiScript sse_decode_box_autoadd_ffi_script(SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    return (sse_decode_ffi_script(deserializer));
  }

  @protected
  FfiSender sse_decode_box_autoadd_ffi_sender(SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    return (sse_decode_ffi_sender(deserializer));
  }

  @protected
  FfiSenderBuilder sse_decode_box_autoadd_ffi_sender_builder(
      SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    return (sse_decode_ffi_sender_builder(deserializer));
  }

  @protected
  FfiUncheckedProposal sse_decode_box_autoadd_ffi_unchecked_proposal(
      SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    return (sse_decode_ffi_unchecked_proposal(deserializer));
  }

  @protected
  FfiUri sse_decode_box_autoadd_ffi_uri(SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    return (sse_decode_ffi_uri(deserializer));
  }

  @protected
  FfiUrl sse_decode_box_autoadd_ffi_url(SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    return (sse_decode_ffi_url(deserializer));
  }

  @protected
  FfiV1Context sse_decode_box_autoadd_ffi_v_1_context(
      SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    return (sse_decode_ffi_v_1_context(deserializer));
  }

  @protected
  FfiV2GetContext sse_decode_box_autoadd_ffi_v_2_get_context(
      SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    return (sse_decode_ffi_v_2_get_context(deserializer));
  }

  @protected
  FfiV2PostContext sse_decode_box_autoadd_ffi_v_2_post_context(
      SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    return (sse_decode_ffi_v_2_post_context(deserializer));
  }

  @protected
  FfiWantsInputs sse_decode_box_autoadd_ffi_wants_inputs(
      SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    return (sse_decode_ffi_wants_inputs(deserializer));
  }

  @protected
  FfiWantsOutputs sse_decode_box_autoadd_ffi_wants_outputs(
      SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    return (sse_decode_ffi_wants_outputs(deserializer));
  }

  @protected
  PsbtInput sse_decode_box_autoadd_psbt_input(SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    return (sse_decode_psbt_input(deserializer));
  }

  @protected
  TxIn sse_decode_box_autoadd_tx_in(SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    return (sse_decode_tx_in(deserializer));
  }

  @protected
  TxOut sse_decode_box_autoadd_tx_out(SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    return (sse_decode_tx_out(deserializer));
  }

  @protected
  BigInt sse_decode_box_autoadd_u_64(SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    return (sse_decode_u_64(deserializer));
  }

  @protected
  int sse_decode_box_autoadd_u_8(SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    return (sse_decode_u_8(deserializer));
  }

  @protected
  ClientResponse sse_decode_client_response(SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    var var_field0 =
        sse_decode_RustOpaque_stdsyncMutexcoreoptionOptionpayjoin_ffiClientResponse(
            deserializer);
    return ClientResponse(field0: var_field0);
  }

  @protected
  FfiInputPair sse_decode_ffi_input_pair(SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    var var_field0 =
        sse_decode_RustOpaque_payjoin_ffireceiveInputPair(deserializer);
    return FfiInputPair(field0: var_field0);
  }

  @protected
  FfiMaybeInputsOwned sse_decode_ffi_maybe_inputs_owned(
      SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    var var_field0 =
        sse_decode_RustOpaque_payjoin_ffireceiveMaybeInputsOwned(deserializer);
    return FfiMaybeInputsOwned(field0: var_field0);
  }

  @protected
  FfiMaybeInputsSeen sse_decode_ffi_maybe_inputs_seen(
      SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    var var_field0 =
        sse_decode_RustOpaque_payjoin_ffireceiveMaybeInputsSeen(deserializer);
    return FfiMaybeInputsSeen(field0: var_field0);
  }

  @protected
  FfiOhttpKeys sse_decode_ffi_ohttp_keys(SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    var var_field0 = sse_decode_RustOpaque_payjoin_ffiOhttpKeys(deserializer);
    return FfiOhttpKeys(field0: var_field0);
  }

  @protected
  FfiOutputsUnknown sse_decode_ffi_outputs_unknown(
      SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    var var_field0 =
        sse_decode_RustOpaque_payjoin_ffireceiveOutputsUnknown(deserializer);
    return FfiOutputsUnknown(field0: var_field0);
  }

  @protected
  FfiPayjoinProposal sse_decode_ffi_payjoin_proposal(
      SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    var var_field0 =
        sse_decode_RustOpaque_payjoin_ffireceivePayjoinProposal(deserializer);
    return FfiPayjoinProposal(field0: var_field0);
  }

  @protected
  FfiPjUri sse_decode_ffi_pj_uri(SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    var var_field0 = sse_decode_RustOpaque_payjoin_ffiuriPjUri(deserializer);
    return FfiPjUri(field0: var_field0);
  }

  @protected
  FfiPjUriBuilder sse_decode_ffi_pj_uri_builder(SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    var var_internal =
        sse_decode_RustOpaque_payjoin_ffiuriPjUriBuilder(deserializer);
    return FfiPjUriBuilder(internal: var_internal);
  }

  @protected
  FfiProvisionalProposal sse_decode_ffi_provisional_proposal(
      SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    var var_field0 =
        sse_decode_RustOpaque_payjoin_ffireceiveProvisionalProposal(
            deserializer);
    return FfiProvisionalProposal(field0: var_field0);
  }

  @protected
  FfiReceiver sse_decode_ffi_receiver(SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    var var_field0 =
        sse_decode_RustOpaque_payjoin_ffireceiveReceiver(deserializer);
    return FfiReceiver(field0: var_field0);
  }

  @protected
  FfiScript sse_decode_ffi_script(SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    var var_field0 = sse_decode_RustOpaque_bitcoin_ffiScript(deserializer);
    return FfiScript(field0: var_field0);
  }

  @protected
  FfiSender sse_decode_ffi_sender(SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    var var_field0 = sse_decode_RustOpaque_payjoin_ffisendSender(deserializer);
    return FfiSender(field0: var_field0);
  }

  @protected
  FfiSenderBuilder sse_decode_ffi_sender_builder(SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    var var_field0 =
        sse_decode_RustOpaque_payjoin_ffisendSenderBuilder(deserializer);
    return FfiSenderBuilder(field0: var_field0);
  }

  @protected
  FfiUncheckedProposal sse_decode_ffi_unchecked_proposal(
      SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    var var_field0 =
        sse_decode_RustOpaque_payjoin_ffireceiveUncheckedProposal(deserializer);
    return FfiUncheckedProposal(field0: var_field0);
  }

  @protected
  FfiUri sse_decode_ffi_uri(SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    var var_field0 = sse_decode_RustOpaque_payjoin_ffiuriUri(deserializer);
    return FfiUri(field0: var_field0);
  }

  @protected
  FfiUrl sse_decode_ffi_url(SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    var var_field0 = sse_decode_RustOpaque_payjoin_ffiUrl(deserializer);
    return FfiUrl(field0: var_field0);
  }

  @protected
  FfiV1Context sse_decode_ffi_v_1_context(SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    var var_field0 =
        sse_decode_RustOpaque_payjoin_ffisendV1Context(deserializer);
    return FfiV1Context(field0: var_field0);
  }

  @protected
  FfiV2GetContext sse_decode_ffi_v_2_get_context(SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    var var_field0 =
        sse_decode_RustOpaque_payjoin_ffisendV2GetContext(deserializer);
    return FfiV2GetContext(field0: var_field0);
  }

  @protected
  FfiV2PostContext sse_decode_ffi_v_2_post_context(
      SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    var var_field0 =
        sse_decode_RustOpaque_payjoin_ffisendV2PostContext(deserializer);
    return FfiV2PostContext(field0: var_field0);
  }

  @protected
  FfiWantsInputs sse_decode_ffi_wants_inputs(SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    var var_field0 =
        sse_decode_RustOpaque_payjoin_ffireceiveWantsInputs(deserializer);
    return FfiWantsInputs(field0: var_field0);
  }

  @protected
  FfiWantsOutputs sse_decode_ffi_wants_outputs(SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    var var_field0 =
        sse_decode_RustOpaque_payjoin_ffireceiveWantsOutputs(deserializer);
    return FfiWantsOutputs(field0: var_field0);
  }

  @protected
  int sse_decode_i_32(SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    return deserializer.buffer.getInt32();
  }

  @protected
  List<FfiInputPair> sse_decode_list_ffi_input_pair(
      SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs

    var len_ = sse_decode_i_32(deserializer);
    var ans_ = <FfiInputPair>[];
    for (var idx_ = 0; idx_ < len_; ++idx_) {
      ans_.add(sse_decode_ffi_input_pair(deserializer));
    }
    return ans_;
  }

  @protected
  List<Uint8List> sse_decode_list_list_prim_u_8_strict(
      SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs

    var len_ = sse_decode_i_32(deserializer);
    var ans_ = <Uint8List>[];
    for (var idx_ = 0; idx_ < len_; ++idx_) {
      ans_.add(sse_decode_list_prim_u_8_strict(deserializer));
    }
    return ans_;
  }

  @protected
  List<OutPoint> sse_decode_list_out_point(SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs

    var len_ = sse_decode_i_32(deserializer);
    var ans_ = <OutPoint>[];
    for (var idx_ = 0; idx_ < len_; ++idx_) {
      ans_.add(sse_decode_out_point(deserializer));
    }
    return ans_;
  }

  @protected
  List<int> sse_decode_list_prim_u_8_loose(SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    var len_ = sse_decode_i_32(deserializer);
    return deserializer.buffer.getUint8List(len_);
  }

  @protected
  Uint8List sse_decode_list_prim_u_8_strict(SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    var len_ = sse_decode_i_32(deserializer);
    return deserializer.buffer.getUint8List(len_);
  }

  @protected
  List<TxOut> sse_decode_list_tx_out(SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs

    var len_ = sse_decode_i_32(deserializer);
    var ans_ = <TxOut>[];
    for (var idx_ = 0; idx_ < len_; ++idx_) {
      ans_.add(sse_decode_tx_out(deserializer));
    }
    return ans_;
  }

  @protected
  Network sse_decode_network(SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    var inner = sse_decode_i_32(deserializer);
    return Network.values[inner];
  }

  @protected
  String? sse_decode_opt_String(SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs

    if (sse_decode_bool(deserializer)) {
      return (sse_decode_String(deserializer));
    } else {
      return null;
    }
  }

  @protected
  FfiScript? sse_decode_opt_box_autoadd_ffi_script(
      SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs

    if (sse_decode_bool(deserializer)) {
      return (sse_decode_box_autoadd_ffi_script(deserializer));
    } else {
      return null;
    }
  }

  @protected
  FfiUncheckedProposal? sse_decode_opt_box_autoadd_ffi_unchecked_proposal(
      SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs

    if (sse_decode_bool(deserializer)) {
      return (sse_decode_box_autoadd_ffi_unchecked_proposal(deserializer));
    } else {
      return null;
    }
  }

  @protected
  TxOut? sse_decode_opt_box_autoadd_tx_out(SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs

    if (sse_decode_bool(deserializer)) {
      return (sse_decode_box_autoadd_tx_out(deserializer));
    } else {
      return null;
    }
  }

  @protected
  BigInt? sse_decode_opt_box_autoadd_u_64(SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs

    if (sse_decode_bool(deserializer)) {
      return (sse_decode_box_autoadd_u_64(deserializer));
    } else {
      return null;
    }
  }

  @protected
  int? sse_decode_opt_box_autoadd_u_8(SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs

    if (sse_decode_bool(deserializer)) {
      return (sse_decode_box_autoadd_u_8(deserializer));
    } else {
      return null;
    }
  }

  @protected
  OutPoint sse_decode_out_point(SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    var var_txid = sse_decode_String(deserializer);
    var var_vout = sse_decode_u_32(deserializer);
    return OutPoint(txid: var_txid, vout: var_vout);
  }

  @protected
  PayjoinError sse_decode_payjoin_error(SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs

    var tag_ = sse_decode_i_32(deserializer);
    switch (tag_) {
      case 0:
        var var_message = sse_decode_String(deserializer);
        return PayjoinError_InvalidAddress(message: var_message);
      case 1:
        var var_message = sse_decode_String(deserializer);
        return PayjoinError_InvalidScript(message: var_message);
      case 2:
        var var_message = sse_decode_String(deserializer);
        return PayjoinError_NetworkValidation(message: var_message);
      case 3:
        var var_message = sse_decode_String(deserializer);
        return PayjoinError_PsbtParseError(message: var_message);
      case 4:
        var var_message = sse_decode_String(deserializer);
        return PayjoinError_ResponseError(message: var_message);
      case 5:
        var var_message = sse_decode_String(deserializer);
        return PayjoinError_RequestError(message: var_message);
      case 6:
        var var_message = sse_decode_String(deserializer);
        return PayjoinError_TransactionError(message: var_message);
      case 7:
        var var_message = sse_decode_String(deserializer);
        return PayjoinError_ServerError(message: var_message);
      case 8:
        var var_message = sse_decode_String(deserializer);
        return PayjoinError_SelectionError(message: var_message);
      case 9:
        var var_message = sse_decode_String(deserializer);
        return PayjoinError_CreateRequestError(message: var_message);
      case 10:
        var var_message = sse_decode_String(deserializer);
        return PayjoinError_PjParseError(message: var_message);
      case 11:
        var var_message = sse_decode_String(deserializer);
        return PayjoinError_PjNotSupported(message: var_message);
      case 12:
        var var_message = sse_decode_String(deserializer);
        return PayjoinError_ValidationError(message: var_message);
      case 13:
        var var_message = sse_decode_String(deserializer);
        return PayjoinError_V2Error(message: var_message);
      case 14:
        var var_message = sse_decode_String(deserializer);
        return PayjoinError_UnexpectedError(message: var_message);
      case 15:
        var var_message = sse_decode_String(deserializer);
        return PayjoinError_OhttpError(message: var_message);
      case 16:
        var var_message = sse_decode_String(deserializer);
        return PayjoinError_UrlError(message: var_message);
      case 17:
        var var_message = sse_decode_String(deserializer);
        return PayjoinError_IoError(message: var_message);
      case 18:
        var var_message = sse_decode_String(deserializer);
        return PayjoinError_OutputSubstitutionError(message: var_message);
      case 19:
        var var_message = sse_decode_String(deserializer);
        return PayjoinError_InputContributionError(message: var_message);
      case 20:
        var var_message = sse_decode_String(deserializer);
        return PayjoinError_InputPairError(message: var_message);
      case 21:
        var var_message = sse_decode_String(deserializer);
        return PayjoinError_SerdeJsonError(message: var_message);
      default:
        throw UnimplementedError('');
    }
  }

  @protected
  PsbtInput sse_decode_psbt_input(SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    var var_witnessUtxo = sse_decode_opt_box_autoadd_tx_out(deserializer);
    var var_redeemScript = sse_decode_opt_box_autoadd_ffi_script(deserializer);
    var var_witnessScript = sse_decode_opt_box_autoadd_ffi_script(deserializer);
    return PsbtInput(
        witnessUtxo: var_witnessUtxo,
        redeemScript: var_redeemScript,
        witnessScript: var_witnessScript);
  }

  @protected
  (Request, ClientResponse) sse_decode_record_request_client_response(
      SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    var var_field0 = sse_decode_request(deserializer);
    var var_field1 = sse_decode_client_response(deserializer);
    return (var_field0, var_field1);
  }

  @protected
  (Request, FfiV1Context) sse_decode_record_request_ffi_v_1_context(
      SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    var var_field0 = sse_decode_request(deserializer);
    var var_field1 = sse_decode_ffi_v_1_context(deserializer);
    return (var_field0, var_field1);
  }

  @protected
  (Request, FfiV2PostContext) sse_decode_record_request_ffi_v_2_post_context(
      SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    var var_field0 = sse_decode_request(deserializer);
    var var_field1 = sse_decode_ffi_v_2_post_context(deserializer);
    return (var_field0, var_field1);
  }

  @protected
  Request sse_decode_request(SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    var var_url = sse_decode_ffi_url(deserializer);
    var var_contentType = sse_decode_String(deserializer);
    var var_body = sse_decode_list_prim_u_8_strict(deserializer);
    return Request(url: var_url, contentType: var_contentType, body: var_body);
  }

  @protected
  TxIn sse_decode_tx_in(SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    var var_previousOutput = sse_decode_out_point(deserializer);
    var var_scriptSig = sse_decode_ffi_script(deserializer);
    var var_sequence = sse_decode_u_32(deserializer);
    var var_witness = sse_decode_list_list_prim_u_8_strict(deserializer);
    return TxIn(
        previousOutput: var_previousOutput,
        scriptSig: var_scriptSig,
        sequence: var_sequence,
        witness: var_witness);
  }

  @protected
  TxOut sse_decode_tx_out(SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    var var_value = sse_decode_u_64(deserializer);
    var var_scriptPubkey = sse_decode_list_prim_u_8_strict(deserializer);
    return TxOut(value: var_value, scriptPubkey: var_scriptPubkey);
  }

  @protected
  int sse_decode_u_32(SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    return deserializer.buffer.getUint32();
  }

  @protected
  BigInt sse_decode_u_64(SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    return deserializer.buffer.getBigUint64();
  }

  @protected
  int sse_decode_u_8(SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    return deserializer.buffer.getUint8();
  }

  @protected
  void sse_decode_unit(SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
  }

  @protected
  BigInt sse_decode_usize(SseDeserializer deserializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    return deserializer.buffer.getBigUint64();
  }

  @protected
  PlatformPointer cst_encode_DartFn_Inputs_String_Output_String_AnyhowException(
      FutureOr<String> Function(String) raw) {
    // Codec=Cst (C-struct based), see doc to use other codecs
    return cst_encode_DartOpaque(
        encode_DartFn_Inputs_String_Output_String_AnyhowException(raw));
  }

  @protected
  PlatformPointer
      cst_encode_DartFn_Inputs_list_prim_u_8_strict_Output_bool_AnyhowException(
          FutureOr<bool> Function(Uint8List) raw) {
    // Codec=Cst (C-struct based), see doc to use other codecs
    return cst_encode_DartOpaque(
        encode_DartFn_Inputs_list_prim_u_8_strict_Output_bool_AnyhowException(
            raw));
  }

  @protected
  PlatformPointer
      cst_encode_DartFn_Inputs_out_point_Output_bool_AnyhowException(
          FutureOr<bool> Function(OutPoint) raw) {
    // Codec=Cst (C-struct based), see doc to use other codecs
    return cst_encode_DartOpaque(
        encode_DartFn_Inputs_out_point_Output_bool_AnyhowException(raw));
  }

  @protected
  PlatformPointer cst_encode_DartOpaque(Object raw) {
    // Codec=Cst (C-struct based), see doc to use other codecs
    return encodeDartOpaque(
        raw, portManager.dartHandlerPort, generalizedFrbRustBinding);
  }

  @protected
  int cst_encode_RustOpaque_bitcoin_ffiScript(Script raw) {
    // Codec=Cst (C-struct based), see doc to use other codecs
// ignore: invalid_use_of_internal_member
    return (raw as ScriptImpl).frbInternalCstEncode();
  }

  @protected
  int cst_encode_RustOpaque_payjoin_ffiOhttpKeys(OhttpKeys raw) {
    // Codec=Cst (C-struct based), see doc to use other codecs
// ignore: invalid_use_of_internal_member
    return (raw as OhttpKeysImpl).frbInternalCstEncode();
  }

  @protected
  int cst_encode_RustOpaque_payjoin_ffiUrl(Url raw) {
    // Codec=Cst (C-struct based), see doc to use other codecs
// ignore: invalid_use_of_internal_member
    return (raw as UrlImpl).frbInternalCstEncode();
  }

  @protected
  int cst_encode_RustOpaque_payjoin_ffireceiveInputPair(InputPair raw) {
    // Codec=Cst (C-struct based), see doc to use other codecs
// ignore: invalid_use_of_internal_member
    return (raw as InputPairImpl).frbInternalCstEncode();
  }

  @protected
  int cst_encode_RustOpaque_payjoin_ffireceiveMaybeInputsOwned(
      MaybeInputsOwned raw) {
    // Codec=Cst (C-struct based), see doc to use other codecs
// ignore: invalid_use_of_internal_member
    return (raw as MaybeInputsOwnedImpl).frbInternalCstEncode();
  }

  @protected
  int cst_encode_RustOpaque_payjoin_ffireceiveMaybeInputsSeen(
      MaybeInputsSeen raw) {
    // Codec=Cst (C-struct based), see doc to use other codecs
// ignore: invalid_use_of_internal_member
    return (raw as MaybeInputsSeenImpl).frbInternalCstEncode();
  }

  @protected
  int cst_encode_RustOpaque_payjoin_ffireceiveOutputsUnknown(
      OutputsUnknown raw) {
    // Codec=Cst (C-struct based), see doc to use other codecs
// ignore: invalid_use_of_internal_member
    return (raw as OutputsUnknownImpl).frbInternalCstEncode();
  }

  @protected
  int cst_encode_RustOpaque_payjoin_ffireceivePayjoinProposal(
      PayjoinProposal raw) {
    // Codec=Cst (C-struct based), see doc to use other codecs
// ignore: invalid_use_of_internal_member
    return (raw as PayjoinProposalImpl).frbInternalCstEncode();
  }

  @protected
  int cst_encode_RustOpaque_payjoin_ffireceiveProvisionalProposal(
      ProvisionalProposal raw) {
    // Codec=Cst (C-struct based), see doc to use other codecs
// ignore: invalid_use_of_internal_member
    return (raw as ProvisionalProposalImpl).frbInternalCstEncode();
  }

  @protected
  int cst_encode_RustOpaque_payjoin_ffireceiveReceiver(Receiver raw) {
    // Codec=Cst (C-struct based), see doc to use other codecs
// ignore: invalid_use_of_internal_member
    return (raw as ReceiverImpl).frbInternalCstEncode();
  }

  @protected
  int cst_encode_RustOpaque_payjoin_ffireceiveUncheckedProposal(
      UncheckedProposal raw) {
    // Codec=Cst (C-struct based), see doc to use other codecs
// ignore: invalid_use_of_internal_member
    return (raw as UncheckedProposalImpl).frbInternalCstEncode();
  }

  @protected
  int cst_encode_RustOpaque_payjoin_ffireceiveWantsInputs(WantsInputs raw) {
    // Codec=Cst (C-struct based), see doc to use other codecs
// ignore: invalid_use_of_internal_member
    return (raw as WantsInputsImpl).frbInternalCstEncode();
  }

  @protected
  int cst_encode_RustOpaque_payjoin_ffireceiveWantsOutputs(WantsOutputs raw) {
    // Codec=Cst (C-struct based), see doc to use other codecs
// ignore: invalid_use_of_internal_member
    return (raw as WantsOutputsImpl).frbInternalCstEncode();
  }

  @protected
  int cst_encode_RustOpaque_payjoin_ffisendSender(Sender raw) {
    // Codec=Cst (C-struct based), see doc to use other codecs
// ignore: invalid_use_of_internal_member
    return (raw as SenderImpl).frbInternalCstEncode();
  }

  @protected
  int cst_encode_RustOpaque_payjoin_ffisendSenderBuilder(SenderBuilder raw) {
    // Codec=Cst (C-struct based), see doc to use other codecs
// ignore: invalid_use_of_internal_member
    return (raw as SenderBuilderImpl).frbInternalCstEncode();
  }

  @protected
  int cst_encode_RustOpaque_payjoin_ffisendV1Context(V1Context raw) {
    // Codec=Cst (C-struct based), see doc to use other codecs
// ignore: invalid_use_of_internal_member
    return (raw as V1ContextImpl).frbInternalCstEncode();
  }

  @protected
  int cst_encode_RustOpaque_payjoin_ffisendV2GetContext(V2GetContext raw) {
    // Codec=Cst (C-struct based), see doc to use other codecs
// ignore: invalid_use_of_internal_member
    return (raw as V2GetContextImpl).frbInternalCstEncode();
  }

  @protected
  int cst_encode_RustOpaque_payjoin_ffisendV2PostContext(V2PostContext raw) {
    // Codec=Cst (C-struct based), see doc to use other codecs
// ignore: invalid_use_of_internal_member
    return (raw as V2PostContextImpl).frbInternalCstEncode();
  }

  @protected
  int cst_encode_RustOpaque_payjoin_ffiuriPjUri(PjUri raw) {
    // Codec=Cst (C-struct based), see doc to use other codecs
// ignore: invalid_use_of_internal_member
    return (raw as PjUriImpl).frbInternalCstEncode();
  }

  @protected
  int cst_encode_RustOpaque_payjoin_ffiuriPjUriBuilder(PjUriBuilder raw) {
    // Codec=Cst (C-struct based), see doc to use other codecs
// ignore: invalid_use_of_internal_member
    return (raw as PjUriBuilderImpl).frbInternalCstEncode();
  }

  @protected
  int cst_encode_RustOpaque_payjoin_ffiuriUri(Uri raw) {
    // Codec=Cst (C-struct based), see doc to use other codecs
// ignore: invalid_use_of_internal_member
    return (raw as UriImpl).frbInternalCstEncode();
  }

  @protected
  int cst_encode_RustOpaque_stdsyncMutexcoreoptionOptionpayjoin_ffiClientResponse(
      MutexOptionClientResponse raw) {
    // Codec=Cst (C-struct based), see doc to use other codecs
// ignore: invalid_use_of_internal_member
    return (raw as MutexOptionClientResponseImpl).frbInternalCstEncode();
  }

  @protected
  bool cst_encode_bool(bool raw) {
    // Codec=Cst (C-struct based), see doc to use other codecs
    return raw;
  }

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

  @protected
  int cst_encode_network(Network raw) {
    // Codec=Cst (C-struct based), see doc to use other codecs
    return cst_encode_i_32(raw.index);
  }

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

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

  @protected
  void cst_encode_unit(void raw) {
    // Codec=Cst (C-struct based), see doc to use other codecs
    return raw;
  }

  @protected
  void sse_encode_AnyhowException(
      AnyhowException self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_String(self.message, serializer);
  }

  @protected
  void sse_encode_DartFn_Inputs_String_Output_String_AnyhowException(
      FutureOr<String> Function(String) self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_DartOpaque(
        encode_DartFn_Inputs_String_Output_String_AnyhowException(self),
        serializer);
  }

  @protected
  void
      sse_encode_DartFn_Inputs_list_prim_u_8_strict_Output_bool_AnyhowException(
          FutureOr<bool> Function(Uint8List) self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_DartOpaque(
        encode_DartFn_Inputs_list_prim_u_8_strict_Output_bool_AnyhowException(
            self),
        serializer);
  }

  @protected
  void sse_encode_DartFn_Inputs_out_point_Output_bool_AnyhowException(
      FutureOr<bool> Function(OutPoint) self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_DartOpaque(
        encode_DartFn_Inputs_out_point_Output_bool_AnyhowException(self),
        serializer);
  }

  @protected
  void sse_encode_DartOpaque(Object self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_usize(
        BigInt.from(PlatformPointerUtil.ptrToInt(encodeDartOpaque(
                self, portManager.dartHandlerPort, generalizedFrbRustBinding)))
            .toUnsigned(64),
        serializer);
  }

  @protected
  void sse_encode_RustOpaque_bitcoin_ffiScript(
      Script self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_usize(
        (self as ScriptImpl).frbInternalSseEncode(move: null), serializer);
  }

  @protected
  void sse_encode_RustOpaque_payjoin_ffiOhttpKeys(
      OhttpKeys self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_usize(
        (self as OhttpKeysImpl).frbInternalSseEncode(move: null), serializer);
  }

  @protected
  void sse_encode_RustOpaque_payjoin_ffiUrl(
      Url self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_usize(
        (self as UrlImpl).frbInternalSseEncode(move: null), serializer);
  }

  @protected
  void sse_encode_RustOpaque_payjoin_ffireceiveInputPair(
      InputPair self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_usize(
        (self as InputPairImpl).frbInternalSseEncode(move: null), serializer);
  }

  @protected
  void sse_encode_RustOpaque_payjoin_ffireceiveMaybeInputsOwned(
      MaybeInputsOwned self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_usize(
        (self as MaybeInputsOwnedImpl).frbInternalSseEncode(move: null),
        serializer);
  }

  @protected
  void sse_encode_RustOpaque_payjoin_ffireceiveMaybeInputsSeen(
      MaybeInputsSeen self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_usize(
        (self as MaybeInputsSeenImpl).frbInternalSseEncode(move: null),
        serializer);
  }

  @protected
  void sse_encode_RustOpaque_payjoin_ffireceiveOutputsUnknown(
      OutputsUnknown self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_usize(
        (self as OutputsUnknownImpl).frbInternalSseEncode(move: null),
        serializer);
  }

  @protected
  void sse_encode_RustOpaque_payjoin_ffireceivePayjoinProposal(
      PayjoinProposal self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_usize(
        (self as PayjoinProposalImpl).frbInternalSseEncode(move: null),
        serializer);
  }

  @protected
  void sse_encode_RustOpaque_payjoin_ffireceiveProvisionalProposal(
      ProvisionalProposal self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_usize(
        (self as ProvisionalProposalImpl).frbInternalSseEncode(move: null),
        serializer);
  }

  @protected
  void sse_encode_RustOpaque_payjoin_ffireceiveReceiver(
      Receiver self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_usize(
        (self as ReceiverImpl).frbInternalSseEncode(move: null), serializer);
  }

  @protected
  void sse_encode_RustOpaque_payjoin_ffireceiveUncheckedProposal(
      UncheckedProposal self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_usize(
        (self as UncheckedProposalImpl).frbInternalSseEncode(move: null),
        serializer);
  }

  @protected
  void sse_encode_RustOpaque_payjoin_ffireceiveWantsInputs(
      WantsInputs self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_usize(
        (self as WantsInputsImpl).frbInternalSseEncode(move: null), serializer);
  }

  @protected
  void sse_encode_RustOpaque_payjoin_ffireceiveWantsOutputs(
      WantsOutputs self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_usize(
        (self as WantsOutputsImpl).frbInternalSseEncode(move: null),
        serializer);
  }

  @protected
  void sse_encode_RustOpaque_payjoin_ffisendSender(
      Sender self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_usize(
        (self as SenderImpl).frbInternalSseEncode(move: null), serializer);
  }

  @protected
  void sse_encode_RustOpaque_payjoin_ffisendSenderBuilder(
      SenderBuilder self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_usize(
        (self as SenderBuilderImpl).frbInternalSseEncode(move: null),
        serializer);
  }

  @protected
  void sse_encode_RustOpaque_payjoin_ffisendV1Context(
      V1Context self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_usize(
        (self as V1ContextImpl).frbInternalSseEncode(move: null), serializer);
  }

  @protected
  void sse_encode_RustOpaque_payjoin_ffisendV2GetContext(
      V2GetContext self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_usize(
        (self as V2GetContextImpl).frbInternalSseEncode(move: null),
        serializer);
  }

  @protected
  void sse_encode_RustOpaque_payjoin_ffisendV2PostContext(
      V2PostContext self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_usize(
        (self as V2PostContextImpl).frbInternalSseEncode(move: null),
        serializer);
  }

  @protected
  void sse_encode_RustOpaque_payjoin_ffiuriPjUri(
      PjUri self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_usize(
        (self as PjUriImpl).frbInternalSseEncode(move: null), serializer);
  }

  @protected
  void sse_encode_RustOpaque_payjoin_ffiuriPjUriBuilder(
      PjUriBuilder self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_usize(
        (self as PjUriBuilderImpl).frbInternalSseEncode(move: null),
        serializer);
  }

  @protected
  void sse_encode_RustOpaque_payjoin_ffiuriUri(
      Uri self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_usize(
        (self as UriImpl).frbInternalSseEncode(move: null), serializer);
  }

  @protected
  void
      sse_encode_RustOpaque_stdsyncMutexcoreoptionOptionpayjoin_ffiClientResponse(
          MutexOptionClientResponse self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_usize(
        (self as MutexOptionClientResponseImpl)
            .frbInternalSseEncode(move: null),
        serializer);
  }

  @protected
  void sse_encode_String(String self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_list_prim_u_8_strict(utf8.encoder.convert(self), serializer);
  }

  @protected
  void sse_encode_bool(bool self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    serializer.buffer.putUint8(self ? 1 : 0);
  }

  @protected
  void sse_encode_box_autoadd_client_response(
      ClientResponse self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_client_response(self, serializer);
  }

  @protected
  void sse_encode_box_autoadd_ffi_maybe_inputs_owned(
      FfiMaybeInputsOwned self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_ffi_maybe_inputs_owned(self, serializer);
  }

  @protected
  void sse_encode_box_autoadd_ffi_maybe_inputs_seen(
      FfiMaybeInputsSeen self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_ffi_maybe_inputs_seen(self, serializer);
  }

  @protected
  void sse_encode_box_autoadd_ffi_ohttp_keys(
      FfiOhttpKeys self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_ffi_ohttp_keys(self, serializer);
  }

  @protected
  void sse_encode_box_autoadd_ffi_outputs_unknown(
      FfiOutputsUnknown self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_ffi_outputs_unknown(self, serializer);
  }

  @protected
  void sse_encode_box_autoadd_ffi_payjoin_proposal(
      FfiPayjoinProposal self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_ffi_payjoin_proposal(self, serializer);
  }

  @protected
  void sse_encode_box_autoadd_ffi_pj_uri(
      FfiPjUri self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_ffi_pj_uri(self, serializer);
  }

  @protected
  void sse_encode_box_autoadd_ffi_pj_uri_builder(
      FfiPjUriBuilder self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_ffi_pj_uri_builder(self, serializer);
  }

  @protected
  void sse_encode_box_autoadd_ffi_provisional_proposal(
      FfiProvisionalProposal self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_ffi_provisional_proposal(self, serializer);
  }

  @protected
  void sse_encode_box_autoadd_ffi_receiver(
      FfiReceiver self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_ffi_receiver(self, serializer);
  }

  @protected
  void sse_encode_box_autoadd_ffi_script(
      FfiScript self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_ffi_script(self, serializer);
  }

  @protected
  void sse_encode_box_autoadd_ffi_sender(
      FfiSender self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_ffi_sender(self, serializer);
  }

  @protected
  void sse_encode_box_autoadd_ffi_sender_builder(
      FfiSenderBuilder self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_ffi_sender_builder(self, serializer);
  }

  @protected
  void sse_encode_box_autoadd_ffi_unchecked_proposal(
      FfiUncheckedProposal self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_ffi_unchecked_proposal(self, serializer);
  }

  @protected
  void sse_encode_box_autoadd_ffi_uri(FfiUri self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_ffi_uri(self, serializer);
  }

  @protected
  void sse_encode_box_autoadd_ffi_url(FfiUrl self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_ffi_url(self, serializer);
  }

  @protected
  void sse_encode_box_autoadd_ffi_v_1_context(
      FfiV1Context self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_ffi_v_1_context(self, serializer);
  }

  @protected
  void sse_encode_box_autoadd_ffi_v_2_get_context(
      FfiV2GetContext self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_ffi_v_2_get_context(self, serializer);
  }

  @protected
  void sse_encode_box_autoadd_ffi_v_2_post_context(
      FfiV2PostContext self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_ffi_v_2_post_context(self, serializer);
  }

  @protected
  void sse_encode_box_autoadd_ffi_wants_inputs(
      FfiWantsInputs self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_ffi_wants_inputs(self, serializer);
  }

  @protected
  void sse_encode_box_autoadd_ffi_wants_outputs(
      FfiWantsOutputs self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_ffi_wants_outputs(self, serializer);
  }

  @protected
  void sse_encode_box_autoadd_psbt_input(
      PsbtInput self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_psbt_input(self, serializer);
  }

  @protected
  void sse_encode_box_autoadd_tx_in(TxIn self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_tx_in(self, serializer);
  }

  @protected
  void sse_encode_box_autoadd_tx_out(TxOut self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_tx_out(self, serializer);
  }

  @protected
  void sse_encode_box_autoadd_u_64(BigInt self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_u_64(self, serializer);
  }

  @protected
  void sse_encode_box_autoadd_u_8(int self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_u_8(self, serializer);
  }

  @protected
  void sse_encode_client_response(
      ClientResponse self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_RustOpaque_stdsyncMutexcoreoptionOptionpayjoin_ffiClientResponse(
        self.field0, serializer);
  }

  @protected
  void sse_encode_ffi_input_pair(FfiInputPair self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_RustOpaque_payjoin_ffireceiveInputPair(self.field0, serializer);
  }

  @protected
  void sse_encode_ffi_maybe_inputs_owned(
      FfiMaybeInputsOwned self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_RustOpaque_payjoin_ffireceiveMaybeInputsOwned(
        self.field0, serializer);
  }

  @protected
  void sse_encode_ffi_maybe_inputs_seen(
      FfiMaybeInputsSeen self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_RustOpaque_payjoin_ffireceiveMaybeInputsSeen(
        self.field0, serializer);
  }

  @protected
  void sse_encode_ffi_ohttp_keys(FfiOhttpKeys self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_RustOpaque_payjoin_ffiOhttpKeys(self.field0, serializer);
  }

  @protected
  void sse_encode_ffi_outputs_unknown(
      FfiOutputsUnknown self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_RustOpaque_payjoin_ffireceiveOutputsUnknown(
        self.field0, serializer);
  }

  @protected
  void sse_encode_ffi_payjoin_proposal(
      FfiPayjoinProposal self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_RustOpaque_payjoin_ffireceivePayjoinProposal(
        self.field0, serializer);
  }

  @protected
  void sse_encode_ffi_pj_uri(FfiPjUri self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_RustOpaque_payjoin_ffiuriPjUri(self.field0, serializer);
  }

  @protected
  void sse_encode_ffi_pj_uri_builder(
      FfiPjUriBuilder self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_RustOpaque_payjoin_ffiuriPjUriBuilder(self.internal, serializer);
  }

  @protected
  void sse_encode_ffi_provisional_proposal(
      FfiProvisionalProposal self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_RustOpaque_payjoin_ffireceiveProvisionalProposal(
        self.field0, serializer);
  }

  @protected
  void sse_encode_ffi_receiver(FfiReceiver self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_RustOpaque_payjoin_ffireceiveReceiver(self.field0, serializer);
  }

  @protected
  void sse_encode_ffi_script(FfiScript self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_RustOpaque_bitcoin_ffiScript(self.field0, serializer);
  }

  @protected
  void sse_encode_ffi_sender(FfiSender self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_RustOpaque_payjoin_ffisendSender(self.field0, serializer);
  }

  @protected
  void sse_encode_ffi_sender_builder(
      FfiSenderBuilder self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_RustOpaque_payjoin_ffisendSenderBuilder(self.field0, serializer);
  }

  @protected
  void sse_encode_ffi_unchecked_proposal(
      FfiUncheckedProposal self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_RustOpaque_payjoin_ffireceiveUncheckedProposal(
        self.field0, serializer);
  }

  @protected
  void sse_encode_ffi_uri(FfiUri self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_RustOpaque_payjoin_ffiuriUri(self.field0, serializer);
  }

  @protected
  void sse_encode_ffi_url(FfiUrl self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_RustOpaque_payjoin_ffiUrl(self.field0, serializer);
  }

  @protected
  void sse_encode_ffi_v_1_context(FfiV1Context self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_RustOpaque_payjoin_ffisendV1Context(self.field0, serializer);
  }

  @protected
  void sse_encode_ffi_v_2_get_context(
      FfiV2GetContext self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_RustOpaque_payjoin_ffisendV2GetContext(self.field0, serializer);
  }

  @protected
  void sse_encode_ffi_v_2_post_context(
      FfiV2PostContext self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_RustOpaque_payjoin_ffisendV2PostContext(self.field0, serializer);
  }

  @protected
  void sse_encode_ffi_wants_inputs(
      FfiWantsInputs self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_RustOpaque_payjoin_ffireceiveWantsInputs(
        self.field0, serializer);
  }

  @protected
  void sse_encode_ffi_wants_outputs(
      FfiWantsOutputs self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_RustOpaque_payjoin_ffireceiveWantsOutputs(
        self.field0, serializer);
  }

  @protected
  void sse_encode_i_32(int self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    serializer.buffer.putInt32(self);
  }

  @protected
  void sse_encode_list_ffi_input_pair(
      List<FfiInputPair> self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_i_32(self.length, serializer);
    for (final item in self) {
      sse_encode_ffi_input_pair(item, serializer);
    }
  }

  @protected
  void sse_encode_list_list_prim_u_8_strict(
      List<Uint8List> self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_i_32(self.length, serializer);
    for (final item in self) {
      sse_encode_list_prim_u_8_strict(item, serializer);
    }
  }

  @protected
  void sse_encode_list_out_point(
      List<OutPoint> self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_i_32(self.length, serializer);
    for (final item in self) {
      sse_encode_out_point(item, serializer);
    }
  }

  @protected
  void sse_encode_list_prim_u_8_loose(
      List<int> self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_i_32(self.length, serializer);
    serializer.buffer
        .putUint8List(self is Uint8List ? self : Uint8List.fromList(self));
  }

  @protected
  void sse_encode_list_prim_u_8_strict(
      Uint8List self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_i_32(self.length, serializer);
    serializer.buffer.putUint8List(self);
  }

  @protected
  void sse_encode_list_tx_out(List<TxOut> self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_i_32(self.length, serializer);
    for (final item in self) {
      sse_encode_tx_out(item, serializer);
    }
  }

  @protected
  void sse_encode_network(Network self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_i_32(self.index, serializer);
  }

  @protected
  void sse_encode_opt_String(String? self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs

    sse_encode_bool(self != null, serializer);
    if (self != null) {
      sse_encode_String(self, serializer);
    }
  }

  @protected
  void sse_encode_opt_box_autoadd_ffi_script(
      FfiScript? self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs

    sse_encode_bool(self != null, serializer);
    if (self != null) {
      sse_encode_box_autoadd_ffi_script(self, serializer);
    }
  }

  @protected
  void sse_encode_opt_box_autoadd_ffi_unchecked_proposal(
      FfiUncheckedProposal? self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs

    sse_encode_bool(self != null, serializer);
    if (self != null) {
      sse_encode_box_autoadd_ffi_unchecked_proposal(self, serializer);
    }
  }

  @protected
  void sse_encode_opt_box_autoadd_tx_out(
      TxOut? self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs

    sse_encode_bool(self != null, serializer);
    if (self != null) {
      sse_encode_box_autoadd_tx_out(self, serializer);
    }
  }

  @protected
  void sse_encode_opt_box_autoadd_u_64(BigInt? self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs

    sse_encode_bool(self != null, serializer);
    if (self != null) {
      sse_encode_box_autoadd_u_64(self, serializer);
    }
  }

  @protected
  void sse_encode_opt_box_autoadd_u_8(int? self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs

    sse_encode_bool(self != null, serializer);
    if (self != null) {
      sse_encode_box_autoadd_u_8(self, serializer);
    }
  }

  @protected
  void sse_encode_out_point(OutPoint self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_String(self.txid, serializer);
    sse_encode_u_32(self.vout, serializer);
  }

  @protected
  void sse_encode_payjoin_error(PayjoinError self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    switch (self) {
      case PayjoinError_InvalidAddress(message: final message):
        sse_encode_i_32(0, serializer);
        sse_encode_String(message, serializer);
      case PayjoinError_InvalidScript(message: final message):
        sse_encode_i_32(1, serializer);
        sse_encode_String(message, serializer);
      case PayjoinError_NetworkValidation(message: final message):
        sse_encode_i_32(2, serializer);
        sse_encode_String(message, serializer);
      case PayjoinError_PsbtParseError(message: final message):
        sse_encode_i_32(3, serializer);
        sse_encode_String(message, serializer);
      case PayjoinError_ResponseError(message: final message):
        sse_encode_i_32(4, serializer);
        sse_encode_String(message, serializer);
      case PayjoinError_RequestError(message: final message):
        sse_encode_i_32(5, serializer);
        sse_encode_String(message, serializer);
      case PayjoinError_TransactionError(message: final message):
        sse_encode_i_32(6, serializer);
        sse_encode_String(message, serializer);
      case PayjoinError_ServerError(message: final message):
        sse_encode_i_32(7, serializer);
        sse_encode_String(message, serializer);
      case PayjoinError_SelectionError(message: final message):
        sse_encode_i_32(8, serializer);
        sse_encode_String(message, serializer);
      case PayjoinError_CreateRequestError(message: final message):
        sse_encode_i_32(9, serializer);
        sse_encode_String(message, serializer);
      case PayjoinError_PjParseError(message: final message):
        sse_encode_i_32(10, serializer);
        sse_encode_String(message, serializer);
      case PayjoinError_PjNotSupported(message: final message):
        sse_encode_i_32(11, serializer);
        sse_encode_String(message, serializer);
      case PayjoinError_ValidationError(message: final message):
        sse_encode_i_32(12, serializer);
        sse_encode_String(message, serializer);
      case PayjoinError_V2Error(message: final message):
        sse_encode_i_32(13, serializer);
        sse_encode_String(message, serializer);
      case PayjoinError_UnexpectedError(message: final message):
        sse_encode_i_32(14, serializer);
        sse_encode_String(message, serializer);
      case PayjoinError_OhttpError(message: final message):
        sse_encode_i_32(15, serializer);
        sse_encode_String(message, serializer);
      case PayjoinError_UrlError(message: final message):
        sse_encode_i_32(16, serializer);
        sse_encode_String(message, serializer);
      case PayjoinError_IoError(message: final message):
        sse_encode_i_32(17, serializer);
        sse_encode_String(message, serializer);
      case PayjoinError_OutputSubstitutionError(message: final message):
        sse_encode_i_32(18, serializer);
        sse_encode_String(message, serializer);
      case PayjoinError_InputContributionError(message: final message):
        sse_encode_i_32(19, serializer);
        sse_encode_String(message, serializer);
      case PayjoinError_InputPairError(message: final message):
        sse_encode_i_32(20, serializer);
        sse_encode_String(message, serializer);
      case PayjoinError_SerdeJsonError(message: final message):
        sse_encode_i_32(21, serializer);
        sse_encode_String(message, serializer);
      default:
        throw UnimplementedError('');
    }
  }

  @protected
  void sse_encode_psbt_input(PsbtInput self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_opt_box_autoadd_tx_out(self.witnessUtxo, serializer);
    sse_encode_opt_box_autoadd_ffi_script(self.redeemScript, serializer);
    sse_encode_opt_box_autoadd_ffi_script(self.witnessScript, serializer);
  }

  @protected
  void sse_encode_record_request_client_response(
      (Request, ClientResponse) self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_request(self.$1, serializer);
    sse_encode_client_response(self.$2, serializer);
  }

  @protected
  void sse_encode_record_request_ffi_v_1_context(
      (Request, FfiV1Context) self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_request(self.$1, serializer);
    sse_encode_ffi_v_1_context(self.$2, serializer);
  }

  @protected
  void sse_encode_record_request_ffi_v_2_post_context(
      (Request, FfiV2PostContext) self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_request(self.$1, serializer);
    sse_encode_ffi_v_2_post_context(self.$2, serializer);
  }

  @protected
  void sse_encode_request(Request self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_ffi_url(self.url, serializer);
    sse_encode_String(self.contentType, serializer);
    sse_encode_list_prim_u_8_strict(self.body, serializer);
  }

  @protected
  void sse_encode_tx_in(TxIn self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_out_point(self.previousOutput, serializer);
    sse_encode_ffi_script(self.scriptSig, serializer);
    sse_encode_u_32(self.sequence, serializer);
    sse_encode_list_list_prim_u_8_strict(self.witness, serializer);
  }

  @protected
  void sse_encode_tx_out(TxOut self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    sse_encode_u_64(self.value, serializer);
    sse_encode_list_prim_u_8_strict(self.scriptPubkey, serializer);
  }

  @protected
  void sse_encode_u_32(int self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    serializer.buffer.putUint32(self);
  }

  @protected
  void sse_encode_u_64(BigInt self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    serializer.buffer.putBigUint64(self);
  }

  @protected
  void sse_encode_u_8(int self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    serializer.buffer.putUint8(self);
  }

  @protected
  void sse_encode_unit(void self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
  }

  @protected
  void sse_encode_usize(BigInt self, SseSerializer serializer) {
    // Codec=Sse (Serialization based), see doc to use other codecs
    serializer.buffer.putBigUint64(self);
  }
}

@sealed
class InputPairImpl extends RustOpaque implements InputPair {
  // Not to be used by end users
  InputPairImpl.frbInternalDcoDecode(List<dynamic> wire)
      : super.frbInternalDcoDecode(wire, _kStaticData);

  // Not to be used by end users
  InputPairImpl.frbInternalSseDecode(BigInt ptr, int externalSizeOnNative)
      : super.frbInternalSseDecode(ptr, externalSizeOnNative, _kStaticData);

  static final _kStaticData = RustArcStaticData(
    rustArcIncrementStrongCount:
        core.instance.api.rust_arc_increment_strong_count_InputPair,
    rustArcDecrementStrongCount:
        core.instance.api.rust_arc_decrement_strong_count_InputPair,
    rustArcDecrementStrongCountPtr:
        core.instance.api.rust_arc_decrement_strong_count_InputPairPtr,
  );
}

@sealed
class MaybeInputsOwnedImpl extends RustOpaque implements MaybeInputsOwned {
  // Not to be used by end users
  MaybeInputsOwnedImpl.frbInternalDcoDecode(List<dynamic> wire)
      : super.frbInternalDcoDecode(wire, _kStaticData);

  // Not to be used by end users
  MaybeInputsOwnedImpl.frbInternalSseDecode(
      BigInt ptr, int externalSizeOnNative)
      : super.frbInternalSseDecode(ptr, externalSizeOnNative, _kStaticData);

  static final _kStaticData = RustArcStaticData(
    rustArcIncrementStrongCount:
        core.instance.api.rust_arc_increment_strong_count_MaybeInputsOwned,
    rustArcDecrementStrongCount:
        core.instance.api.rust_arc_decrement_strong_count_MaybeInputsOwned,
    rustArcDecrementStrongCountPtr:
        core.instance.api.rust_arc_decrement_strong_count_MaybeInputsOwnedPtr,
  );
}

@sealed
class MaybeInputsSeenImpl extends RustOpaque implements MaybeInputsSeen {
  // Not to be used by end users
  MaybeInputsSeenImpl.frbInternalDcoDecode(List<dynamic> wire)
      : super.frbInternalDcoDecode(wire, _kStaticData);

  // Not to be used by end users
  MaybeInputsSeenImpl.frbInternalSseDecode(BigInt ptr, int externalSizeOnNative)
      : super.frbInternalSseDecode(ptr, externalSizeOnNative, _kStaticData);

  static final _kStaticData = RustArcStaticData(
    rustArcIncrementStrongCount:
        core.instance.api.rust_arc_increment_strong_count_MaybeInputsSeen,
    rustArcDecrementStrongCount:
        core.instance.api.rust_arc_decrement_strong_count_MaybeInputsSeen,
    rustArcDecrementStrongCountPtr:
        core.instance.api.rust_arc_decrement_strong_count_MaybeInputsSeenPtr,
  );
}

@sealed
class MutexOptionClientResponseImpl extends RustOpaque
    implements MutexOptionClientResponse {
  // Not to be used by end users
  MutexOptionClientResponseImpl.frbInternalDcoDecode(List<dynamic> wire)
      : super.frbInternalDcoDecode(wire, _kStaticData);

  // Not to be used by end users
  MutexOptionClientResponseImpl.frbInternalSseDecode(
      BigInt ptr, int externalSizeOnNative)
      : super.frbInternalSseDecode(ptr, externalSizeOnNative, _kStaticData);

  static final _kStaticData = RustArcStaticData(
    rustArcIncrementStrongCount: core
        .instance.api.rust_arc_increment_strong_count_MutexOptionClientResponse,
    rustArcDecrementStrongCount: core
        .instance.api.rust_arc_decrement_strong_count_MutexOptionClientResponse,
    rustArcDecrementStrongCountPtr: core.instance.api
        .rust_arc_decrement_strong_count_MutexOptionClientResponsePtr,
  );
}

@sealed
class OhttpKeysImpl extends RustOpaque implements OhttpKeys {
  // Not to be used by end users
  OhttpKeysImpl.frbInternalDcoDecode(List<dynamic> wire)
      : super.frbInternalDcoDecode(wire, _kStaticData);

  // Not to be used by end users
  OhttpKeysImpl.frbInternalSseDecode(BigInt ptr, int externalSizeOnNative)
      : super.frbInternalSseDecode(ptr, externalSizeOnNative, _kStaticData);

  static final _kStaticData = RustArcStaticData(
    rustArcIncrementStrongCount:
        core.instance.api.rust_arc_increment_strong_count_OhttpKeys,
    rustArcDecrementStrongCount:
        core.instance.api.rust_arc_decrement_strong_count_OhttpKeys,
    rustArcDecrementStrongCountPtr:
        core.instance.api.rust_arc_decrement_strong_count_OhttpKeysPtr,
  );
}

@sealed
class OutputsUnknownImpl extends RustOpaque implements OutputsUnknown {
  // Not to be used by end users
  OutputsUnknownImpl.frbInternalDcoDecode(List<dynamic> wire)
      : super.frbInternalDcoDecode(wire, _kStaticData);

  // Not to be used by end users
  OutputsUnknownImpl.frbInternalSseDecode(BigInt ptr, int externalSizeOnNative)
      : super.frbInternalSseDecode(ptr, externalSizeOnNative, _kStaticData);

  static final _kStaticData = RustArcStaticData(
    rustArcIncrementStrongCount:
        core.instance.api.rust_arc_increment_strong_count_OutputsUnknown,
    rustArcDecrementStrongCount:
        core.instance.api.rust_arc_decrement_strong_count_OutputsUnknown,
    rustArcDecrementStrongCountPtr:
        core.instance.api.rust_arc_decrement_strong_count_OutputsUnknownPtr,
  );
}

@sealed
class PayjoinProposalImpl extends RustOpaque implements PayjoinProposal {
  // Not to be used by end users
  PayjoinProposalImpl.frbInternalDcoDecode(List<dynamic> wire)
      : super.frbInternalDcoDecode(wire, _kStaticData);

  // Not to be used by end users
  PayjoinProposalImpl.frbInternalSseDecode(BigInt ptr, int externalSizeOnNative)
      : super.frbInternalSseDecode(ptr, externalSizeOnNative, _kStaticData);

  static final _kStaticData = RustArcStaticData(
    rustArcIncrementStrongCount:
        core.instance.api.rust_arc_increment_strong_count_PayjoinProposal,
    rustArcDecrementStrongCount:
        core.instance.api.rust_arc_decrement_strong_count_PayjoinProposal,
    rustArcDecrementStrongCountPtr:
        core.instance.api.rust_arc_decrement_strong_count_PayjoinProposalPtr,
  );
}

@sealed
class PjUriBuilderImpl extends RustOpaque implements PjUriBuilder {
  // Not to be used by end users
  PjUriBuilderImpl.frbInternalDcoDecode(List<dynamic> wire)
      : super.frbInternalDcoDecode(wire, _kStaticData);

  // Not to be used by end users
  PjUriBuilderImpl.frbInternalSseDecode(BigInt ptr, int externalSizeOnNative)
      : super.frbInternalSseDecode(ptr, externalSizeOnNative, _kStaticData);

  static final _kStaticData = RustArcStaticData(
    rustArcIncrementStrongCount:
        core.instance.api.rust_arc_increment_strong_count_PjUriBuilder,
    rustArcDecrementStrongCount:
        core.instance.api.rust_arc_decrement_strong_count_PjUriBuilder,
    rustArcDecrementStrongCountPtr:
        core.instance.api.rust_arc_decrement_strong_count_PjUriBuilderPtr,
  );
}

@sealed
class PjUriImpl extends RustOpaque implements PjUri {
  // Not to be used by end users
  PjUriImpl.frbInternalDcoDecode(List<dynamic> wire)
      : super.frbInternalDcoDecode(wire, _kStaticData);

  // Not to be used by end users
  PjUriImpl.frbInternalSseDecode(BigInt ptr, int externalSizeOnNative)
      : super.frbInternalSseDecode(ptr, externalSizeOnNative, _kStaticData);

  static final _kStaticData = RustArcStaticData(
    rustArcIncrementStrongCount:
        core.instance.api.rust_arc_increment_strong_count_PjUri,
    rustArcDecrementStrongCount:
        core.instance.api.rust_arc_decrement_strong_count_PjUri,
    rustArcDecrementStrongCountPtr:
        core.instance.api.rust_arc_decrement_strong_count_PjUriPtr,
  );
}

@sealed
class ProvisionalProposalImpl extends RustOpaque
    implements ProvisionalProposal {
  // Not to be used by end users
  ProvisionalProposalImpl.frbInternalDcoDecode(List<dynamic> wire)
      : super.frbInternalDcoDecode(wire, _kStaticData);

  // Not to be used by end users
  ProvisionalProposalImpl.frbInternalSseDecode(
      BigInt ptr, int externalSizeOnNative)
      : super.frbInternalSseDecode(ptr, externalSizeOnNative, _kStaticData);

  static final _kStaticData = RustArcStaticData(
    rustArcIncrementStrongCount:
        core.instance.api.rust_arc_increment_strong_count_ProvisionalProposal,
    rustArcDecrementStrongCount:
        core.instance.api.rust_arc_decrement_strong_count_ProvisionalProposal,
    rustArcDecrementStrongCountPtr: core
        .instance.api.rust_arc_decrement_strong_count_ProvisionalProposalPtr,
  );
}

@sealed
class ReceiverImpl extends RustOpaque implements Receiver {
  // Not to be used by end users
  ReceiverImpl.frbInternalDcoDecode(List<dynamic> wire)
      : super.frbInternalDcoDecode(wire, _kStaticData);

  // Not to be used by end users
  ReceiverImpl.frbInternalSseDecode(BigInt ptr, int externalSizeOnNative)
      : super.frbInternalSseDecode(ptr, externalSizeOnNative, _kStaticData);

  static final _kStaticData = RustArcStaticData(
    rustArcIncrementStrongCount:
        core.instance.api.rust_arc_increment_strong_count_Receiver,
    rustArcDecrementStrongCount:
        core.instance.api.rust_arc_decrement_strong_count_Receiver,
    rustArcDecrementStrongCountPtr:
        core.instance.api.rust_arc_decrement_strong_count_ReceiverPtr,
  );
}

@sealed
class ScriptImpl extends RustOpaque implements Script {
  // Not to be used by end users
  ScriptImpl.frbInternalDcoDecode(List<dynamic> wire)
      : super.frbInternalDcoDecode(wire, _kStaticData);

  // Not to be used by end users
  ScriptImpl.frbInternalSseDecode(BigInt ptr, int externalSizeOnNative)
      : super.frbInternalSseDecode(ptr, externalSizeOnNative, _kStaticData);

  static final _kStaticData = RustArcStaticData(
    rustArcIncrementStrongCount:
        core.instance.api.rust_arc_increment_strong_count_Script,
    rustArcDecrementStrongCount:
        core.instance.api.rust_arc_decrement_strong_count_Script,
    rustArcDecrementStrongCountPtr:
        core.instance.api.rust_arc_decrement_strong_count_ScriptPtr,
  );
}

@sealed
class SenderBuilderImpl extends RustOpaque implements SenderBuilder {
  // Not to be used by end users
  SenderBuilderImpl.frbInternalDcoDecode(List<dynamic> wire)
      : super.frbInternalDcoDecode(wire, _kStaticData);

  // Not to be used by end users
  SenderBuilderImpl.frbInternalSseDecode(BigInt ptr, int externalSizeOnNative)
      : super.frbInternalSseDecode(ptr, externalSizeOnNative, _kStaticData);

  static final _kStaticData = RustArcStaticData(
    rustArcIncrementStrongCount:
        core.instance.api.rust_arc_increment_strong_count_SenderBuilder,
    rustArcDecrementStrongCount:
        core.instance.api.rust_arc_decrement_strong_count_SenderBuilder,
    rustArcDecrementStrongCountPtr:
        core.instance.api.rust_arc_decrement_strong_count_SenderBuilderPtr,
  );
}

@sealed
class SenderImpl extends RustOpaque implements Sender {
  // Not to be used by end users
  SenderImpl.frbInternalDcoDecode(List<dynamic> wire)
      : super.frbInternalDcoDecode(wire, _kStaticData);

  // Not to be used by end users
  SenderImpl.frbInternalSseDecode(BigInt ptr, int externalSizeOnNative)
      : super.frbInternalSseDecode(ptr, externalSizeOnNative, _kStaticData);

  static final _kStaticData = RustArcStaticData(
    rustArcIncrementStrongCount:
        core.instance.api.rust_arc_increment_strong_count_Sender,
    rustArcDecrementStrongCount:
        core.instance.api.rust_arc_decrement_strong_count_Sender,
    rustArcDecrementStrongCountPtr:
        core.instance.api.rust_arc_decrement_strong_count_SenderPtr,
  );
}

@sealed
class UncheckedProposalImpl extends RustOpaque implements UncheckedProposal {
  // Not to be used by end users
  UncheckedProposalImpl.frbInternalDcoDecode(List<dynamic> wire)
      : super.frbInternalDcoDecode(wire, _kStaticData);

  // Not to be used by end users
  UncheckedProposalImpl.frbInternalSseDecode(
      BigInt ptr, int externalSizeOnNative)
      : super.frbInternalSseDecode(ptr, externalSizeOnNative, _kStaticData);

  static final _kStaticData = RustArcStaticData(
    rustArcIncrementStrongCount:
        core.instance.api.rust_arc_increment_strong_count_UncheckedProposal,
    rustArcDecrementStrongCount:
        core.instance.api.rust_arc_decrement_strong_count_UncheckedProposal,
    rustArcDecrementStrongCountPtr:
        core.instance.api.rust_arc_decrement_strong_count_UncheckedProposalPtr,
  );
}

@sealed
class UriImpl extends RustOpaque implements Uri {
  // Not to be used by end users
  UriImpl.frbInternalDcoDecode(List<dynamic> wire)
      : super.frbInternalDcoDecode(wire, _kStaticData);

  // Not to be used by end users
  UriImpl.frbInternalSseDecode(BigInt ptr, int externalSizeOnNative)
      : super.frbInternalSseDecode(ptr, externalSizeOnNative, _kStaticData);

  static final _kStaticData = RustArcStaticData(
    rustArcIncrementStrongCount:
        core.instance.api.rust_arc_increment_strong_count_Uri,
    rustArcDecrementStrongCount:
        core.instance.api.rust_arc_decrement_strong_count_Uri,
    rustArcDecrementStrongCountPtr:
        core.instance.api.rust_arc_decrement_strong_count_UriPtr,
  );
}

@sealed
class UrlImpl extends RustOpaque implements Url {
  // Not to be used by end users
  UrlImpl.frbInternalDcoDecode(List<dynamic> wire)
      : super.frbInternalDcoDecode(wire, _kStaticData);

  // Not to be used by end users
  UrlImpl.frbInternalSseDecode(BigInt ptr, int externalSizeOnNative)
      : super.frbInternalSseDecode(ptr, externalSizeOnNative, _kStaticData);

  static final _kStaticData = RustArcStaticData(
    rustArcIncrementStrongCount:
        core.instance.api.rust_arc_increment_strong_count_Url,
    rustArcDecrementStrongCount:
        core.instance.api.rust_arc_decrement_strong_count_Url,
    rustArcDecrementStrongCountPtr:
        core.instance.api.rust_arc_decrement_strong_count_UrlPtr,
  );
}

@sealed
class V1ContextImpl extends RustOpaque implements V1Context {
  // Not to be used by end users
  V1ContextImpl.frbInternalDcoDecode(List<dynamic> wire)
      : super.frbInternalDcoDecode(wire, _kStaticData);

  // Not to be used by end users
  V1ContextImpl.frbInternalSseDecode(BigInt ptr, int externalSizeOnNative)
      : super.frbInternalSseDecode(ptr, externalSizeOnNative, _kStaticData);

  static final _kStaticData = RustArcStaticData(
    rustArcIncrementStrongCount:
        core.instance.api.rust_arc_increment_strong_count_V1Context,
    rustArcDecrementStrongCount:
        core.instance.api.rust_arc_decrement_strong_count_V1Context,
    rustArcDecrementStrongCountPtr:
        core.instance.api.rust_arc_decrement_strong_count_V1ContextPtr,
  );
}

@sealed
class V2GetContextImpl extends RustOpaque implements V2GetContext {
  // Not to be used by end users
  V2GetContextImpl.frbInternalDcoDecode(List<dynamic> wire)
      : super.frbInternalDcoDecode(wire, _kStaticData);

  // Not to be used by end users
  V2GetContextImpl.frbInternalSseDecode(BigInt ptr, int externalSizeOnNative)
      : super.frbInternalSseDecode(ptr, externalSizeOnNative, _kStaticData);

  static final _kStaticData = RustArcStaticData(
    rustArcIncrementStrongCount:
        core.instance.api.rust_arc_increment_strong_count_V2GetContext,
    rustArcDecrementStrongCount:
        core.instance.api.rust_arc_decrement_strong_count_V2GetContext,
    rustArcDecrementStrongCountPtr:
        core.instance.api.rust_arc_decrement_strong_count_V2GetContextPtr,
  );
}

@sealed
class V2PostContextImpl extends RustOpaque implements V2PostContext {
  // Not to be used by end users
  V2PostContextImpl.frbInternalDcoDecode(List<dynamic> wire)
      : super.frbInternalDcoDecode(wire, _kStaticData);

  // Not to be used by end users
  V2PostContextImpl.frbInternalSseDecode(BigInt ptr, int externalSizeOnNative)
      : super.frbInternalSseDecode(ptr, externalSizeOnNative, _kStaticData);

  static final _kStaticData = RustArcStaticData(
    rustArcIncrementStrongCount:
        core.instance.api.rust_arc_increment_strong_count_V2PostContext,
    rustArcDecrementStrongCount:
        core.instance.api.rust_arc_decrement_strong_count_V2PostContext,
    rustArcDecrementStrongCountPtr:
        core.instance.api.rust_arc_decrement_strong_count_V2PostContextPtr,
  );
}

@sealed
class WantsInputsImpl extends RustOpaque implements WantsInputs {
  // Not to be used by end users
  WantsInputsImpl.frbInternalDcoDecode(List<dynamic> wire)
      : super.frbInternalDcoDecode(wire, _kStaticData);

  // Not to be used by end users
  WantsInputsImpl.frbInternalSseDecode(BigInt ptr, int externalSizeOnNative)
      : super.frbInternalSseDecode(ptr, externalSizeOnNative, _kStaticData);

  static final _kStaticData = RustArcStaticData(
    rustArcIncrementStrongCount:
        core.instance.api.rust_arc_increment_strong_count_WantsInputs,
    rustArcDecrementStrongCount:
        core.instance.api.rust_arc_decrement_strong_count_WantsInputs,
    rustArcDecrementStrongCountPtr:
        core.instance.api.rust_arc_decrement_strong_count_WantsInputsPtr,
  );
}

@sealed
class WantsOutputsImpl extends RustOpaque implements WantsOutputs {
  // Not to be used by end users
  WantsOutputsImpl.frbInternalDcoDecode(List<dynamic> wire)
      : super.frbInternalDcoDecode(wire, _kStaticData);

  // Not to be used by end users
  WantsOutputsImpl.frbInternalSseDecode(BigInt ptr, int externalSizeOnNative)
      : super.frbInternalSseDecode(ptr, externalSizeOnNative, _kStaticData);

  static final _kStaticData = RustArcStaticData(
    rustArcIncrementStrongCount:
        core.instance.api.rust_arc_increment_strong_count_WantsOutputs,
    rustArcDecrementStrongCount:
        core.instance.api.rust_arc_decrement_strong_count_WantsOutputs,
    rustArcDecrementStrongCountPtr:
        core.instance.api.rust_arc_decrement_strong_count_WantsOutputsPtr,
  );
}