// AUTO GENERATED FILE, DO NOT EDIT.
//
// Generated by `package:ffigen`.
// ignore_for_file: type=lint
import 'dart:ffi' as ffi;

/// monero_c wownero bindings
class WowneroC {
  /// Holds the symbol lookup function.
  final ffi.Pointer<T> Function<T extends ffi.NativeType>(String symbolName)
      _lookup;

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

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

  int WOWNERO_PendingTransaction_status(
    ffi.Pointer<ffi.Void> pendingTx_ptr,
  ) {
    return _WOWNERO_PendingTransaction_status(
      pendingTx_ptr,
    );
  }

  late final _WOWNERO_PendingTransaction_statusPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(ffi.Pointer<ffi.Void>)>>(
          'WOWNERO_PendingTransaction_status');
  late final _WOWNERO_PendingTransaction_status =
      _WOWNERO_PendingTransaction_statusPtr.asFunction<
          int Function(ffi.Pointer<ffi.Void>)>();

  ffi.Pointer<ffi.Char> WOWNERO_PendingTransaction_errorString(
    ffi.Pointer<ffi.Void> pendingTx_ptr,
  ) {
    return _WOWNERO_PendingTransaction_errorString(
      pendingTx_ptr,
    );
  }

  late final _WOWNERO_PendingTransaction_errorStringPtr = _lookup<
          ffi.NativeFunction<
              ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>>(
      'WOWNERO_PendingTransaction_errorString');
  late final _WOWNERO_PendingTransaction_errorString =
      _WOWNERO_PendingTransaction_errorStringPtr.asFunction<
          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>();

  bool WOWNERO_PendingTransaction_commit(
    ffi.Pointer<ffi.Void> pendingTx_ptr,
    ffi.Pointer<ffi.Char> filename,
    bool overwrite,
  ) {
    return _WOWNERO_PendingTransaction_commit(
      pendingTx_ptr,
      filename,
      overwrite,
    );
  }

  late final _WOWNERO_PendingTransaction_commitPtr = _lookup<
      ffi.NativeFunction<
          ffi.Bool Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>,
              ffi.Bool)>>('WOWNERO_PendingTransaction_commit');
  late final _WOWNERO_PendingTransaction_commit =
      _WOWNERO_PendingTransaction_commitPtr.asFunction<
          bool Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>, bool)>();

  int WOWNERO_PendingTransaction_amount(
    ffi.Pointer<ffi.Void> pendingTx_ptr,
  ) {
    return _WOWNERO_PendingTransaction_amount(
      pendingTx_ptr,
    );
  }

  late final _WOWNERO_PendingTransaction_amountPtr =
      _lookup<ffi.NativeFunction<ffi.Uint64 Function(ffi.Pointer<ffi.Void>)>>(
          'WOWNERO_PendingTransaction_amount');
  late final _WOWNERO_PendingTransaction_amount =
      _WOWNERO_PendingTransaction_amountPtr.asFunction<
          int Function(ffi.Pointer<ffi.Void>)>();

  int WOWNERO_PendingTransaction_dust(
    ffi.Pointer<ffi.Void> pendingTx_ptr,
  ) {
    return _WOWNERO_PendingTransaction_dust(
      pendingTx_ptr,
    );
  }

  late final _WOWNERO_PendingTransaction_dustPtr =
      _lookup<ffi.NativeFunction<ffi.Uint64 Function(ffi.Pointer<ffi.Void>)>>(
          'WOWNERO_PendingTransaction_dust');
  late final _WOWNERO_PendingTransaction_dust =
      _WOWNERO_PendingTransaction_dustPtr.asFunction<
          int Function(ffi.Pointer<ffi.Void>)>();

  int WOWNERO_PendingTransaction_fee(
    ffi.Pointer<ffi.Void> pendingTx_ptr,
  ) {
    return _WOWNERO_PendingTransaction_fee(
      pendingTx_ptr,
    );
  }

  late final _WOWNERO_PendingTransaction_feePtr =
      _lookup<ffi.NativeFunction<ffi.Uint64 Function(ffi.Pointer<ffi.Void>)>>(
          'WOWNERO_PendingTransaction_fee');
  late final _WOWNERO_PendingTransaction_fee =
      _WOWNERO_PendingTransaction_feePtr.asFunction<
          int Function(ffi.Pointer<ffi.Void>)>();

  ffi.Pointer<ffi.Char> WOWNERO_PendingTransaction_txid(
    ffi.Pointer<ffi.Void> pendingTx_ptr,
    ffi.Pointer<ffi.Char> separator,
  ) {
    return _WOWNERO_PendingTransaction_txid(
      pendingTx_ptr,
      separator,
    );
  }

  late final _WOWNERO_PendingTransaction_txidPtr = _lookup<
      ffi.NativeFunction<
          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>,
              ffi.Pointer<ffi.Char>)>>('WOWNERO_PendingTransaction_txid');
  late final _WOWNERO_PendingTransaction_txid =
      _WOWNERO_PendingTransaction_txidPtr.asFunction<
          ffi.Pointer<ffi.Char> Function(
              ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();

  int WOWNERO_PendingTransaction_txCount(
    ffi.Pointer<ffi.Void> pendingTx_ptr,
  ) {
    return _WOWNERO_PendingTransaction_txCount(
      pendingTx_ptr,
    );
  }

  late final _WOWNERO_PendingTransaction_txCountPtr =
      _lookup<ffi.NativeFunction<ffi.Uint64 Function(ffi.Pointer<ffi.Void>)>>(
          'WOWNERO_PendingTransaction_txCount');
  late final _WOWNERO_PendingTransaction_txCount =
      _WOWNERO_PendingTransaction_txCountPtr.asFunction<
          int Function(ffi.Pointer<ffi.Void>)>();

  ffi.Pointer<ffi.Char> WOWNERO_PendingTransaction_subaddrAccount(
    ffi.Pointer<ffi.Void> pendingTx_ptr,
    ffi.Pointer<ffi.Char> separator,
  ) {
    return _WOWNERO_PendingTransaction_subaddrAccount(
      pendingTx_ptr,
      separator,
    );
  }

  late final _WOWNERO_PendingTransaction_subaddrAccountPtr = _lookup<
          ffi.NativeFunction<
              ffi.Pointer<ffi.Char> Function(
                  ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>>(
      'WOWNERO_PendingTransaction_subaddrAccount');
  late final _WOWNERO_PendingTransaction_subaddrAccount =
      _WOWNERO_PendingTransaction_subaddrAccountPtr.asFunction<
          ffi.Pointer<ffi.Char> Function(
              ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();

  ffi.Pointer<ffi.Char> WOWNERO_PendingTransaction_subaddrIndices(
    ffi.Pointer<ffi.Void> pendingTx_ptr,
    ffi.Pointer<ffi.Char> separator,
  ) {
    return _WOWNERO_PendingTransaction_subaddrIndices(
      pendingTx_ptr,
      separator,
    );
  }

  late final _WOWNERO_PendingTransaction_subaddrIndicesPtr = _lookup<
          ffi.NativeFunction<
              ffi.Pointer<ffi.Char> Function(
                  ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>>(
      'WOWNERO_PendingTransaction_subaddrIndices');
  late final _WOWNERO_PendingTransaction_subaddrIndices =
      _WOWNERO_PendingTransaction_subaddrIndicesPtr.asFunction<
          ffi.Pointer<ffi.Char> Function(
              ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();

  ffi.Pointer<ffi.Char> WOWNERO_PendingTransaction_multisigSignData(
    ffi.Pointer<ffi.Void> pendingTx_ptr,
  ) {
    return _WOWNERO_PendingTransaction_multisigSignData(
      pendingTx_ptr,
    );
  }

  late final _WOWNERO_PendingTransaction_multisigSignDataPtr = _lookup<
          ffi.NativeFunction<
              ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>>(
      'WOWNERO_PendingTransaction_multisigSignData');
  late final _WOWNERO_PendingTransaction_multisigSignData =
      _WOWNERO_PendingTransaction_multisigSignDataPtr.asFunction<
          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>();

  void WOWNERO_PendingTransaction_signMultisigTx(
    ffi.Pointer<ffi.Void> pendingTx_ptr,
  ) {
    return _WOWNERO_PendingTransaction_signMultisigTx(
      pendingTx_ptr,
    );
  }

  late final _WOWNERO_PendingTransaction_signMultisigTxPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>)>>(
          'WOWNERO_PendingTransaction_signMultisigTx');
  late final _WOWNERO_PendingTransaction_signMultisigTx =
      _WOWNERO_PendingTransaction_signMultisigTxPtr.asFunction<
          void Function(ffi.Pointer<ffi.Void>)>();

  ffi.Pointer<ffi.Char> WOWNERO_PendingTransaction_signersKeys(
    ffi.Pointer<ffi.Void> pendingTx_ptr,
    ffi.Pointer<ffi.Char> separator,
  ) {
    return _WOWNERO_PendingTransaction_signersKeys(
      pendingTx_ptr,
      separator,
    );
  }

  late final _WOWNERO_PendingTransaction_signersKeysPtr = _lookup<
          ffi.NativeFunction<
              ffi.Pointer<ffi.Char> Function(
                  ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>>(
      'WOWNERO_PendingTransaction_signersKeys');
  late final _WOWNERO_PendingTransaction_signersKeys =
      _WOWNERO_PendingTransaction_signersKeysPtr.asFunction<
          ffi.Pointer<ffi.Char> Function(
              ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();

  ffi.Pointer<ffi.Char> WOWNERO_PendingTransaction_hex(
    ffi.Pointer<ffi.Void> pendingTx_ptr,
    ffi.Pointer<ffi.Char> separator,
  ) {
    return _WOWNERO_PendingTransaction_hex(
      pendingTx_ptr,
      separator,
    );
  }

  late final _WOWNERO_PendingTransaction_hexPtr = _lookup<
      ffi.NativeFunction<
          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>,
              ffi.Pointer<ffi.Char>)>>('WOWNERO_PendingTransaction_hex');
  late final _WOWNERO_PendingTransaction_hex =
      _WOWNERO_PendingTransaction_hexPtr.asFunction<
          ffi.Pointer<ffi.Char> Function(
              ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();

  int WOWNERO_UnsignedTransaction_status(
    ffi.Pointer<ffi.Void> unsignedTx_ptr,
  ) {
    return _WOWNERO_UnsignedTransaction_status(
      unsignedTx_ptr,
    );
  }

  late final _WOWNERO_UnsignedTransaction_statusPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(ffi.Pointer<ffi.Void>)>>(
          'WOWNERO_UnsignedTransaction_status');
  late final _WOWNERO_UnsignedTransaction_status =
      _WOWNERO_UnsignedTransaction_statusPtr.asFunction<
          int Function(ffi.Pointer<ffi.Void>)>();

  ffi.Pointer<ffi.Char> WOWNERO_UnsignedTransaction_errorString(
    ffi.Pointer<ffi.Void> unsignedTx_ptr,
  ) {
    return _WOWNERO_UnsignedTransaction_errorString(
      unsignedTx_ptr,
    );
  }

  late final _WOWNERO_UnsignedTransaction_errorStringPtr = _lookup<
          ffi.NativeFunction<
              ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>>(
      'WOWNERO_UnsignedTransaction_errorString');
  late final _WOWNERO_UnsignedTransaction_errorString =
      _WOWNERO_UnsignedTransaction_errorStringPtr.asFunction<
          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>();

  ffi.Pointer<ffi.Char> WOWNERO_UnsignedTransaction_amount(
    ffi.Pointer<ffi.Void> unsignedTx_ptr,
    ffi.Pointer<ffi.Char> separator,
  ) {
    return _WOWNERO_UnsignedTransaction_amount(
      unsignedTx_ptr,
      separator,
    );
  }

  late final _WOWNERO_UnsignedTransaction_amountPtr = _lookup<
      ffi.NativeFunction<
          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>,
              ffi.Pointer<ffi.Char>)>>('WOWNERO_UnsignedTransaction_amount');
  late final _WOWNERO_UnsignedTransaction_amount =
      _WOWNERO_UnsignedTransaction_amountPtr.asFunction<
          ffi.Pointer<ffi.Char> Function(
              ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();

  ffi.Pointer<ffi.Char> WOWNERO_UnsignedTransaction_fee(
    ffi.Pointer<ffi.Void> unsignedTx_ptr,
    ffi.Pointer<ffi.Char> separator,
  ) {
    return _WOWNERO_UnsignedTransaction_fee(
      unsignedTx_ptr,
      separator,
    );
  }

  late final _WOWNERO_UnsignedTransaction_feePtr = _lookup<
      ffi.NativeFunction<
          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>,
              ffi.Pointer<ffi.Char>)>>('WOWNERO_UnsignedTransaction_fee');
  late final _WOWNERO_UnsignedTransaction_fee =
      _WOWNERO_UnsignedTransaction_feePtr.asFunction<
          ffi.Pointer<ffi.Char> Function(
              ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();

  ffi.Pointer<ffi.Char> WOWNERO_UnsignedTransaction_mixin(
    ffi.Pointer<ffi.Void> unsignedTx_ptr,
    ffi.Pointer<ffi.Char> separator,
  ) {
    return _WOWNERO_UnsignedTransaction_mixin(
      unsignedTx_ptr,
      separator,
    );
  }

  late final _WOWNERO_UnsignedTransaction_mixinPtr = _lookup<
      ffi.NativeFunction<
          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>,
              ffi.Pointer<ffi.Char>)>>('WOWNERO_UnsignedTransaction_mixin');
  late final _WOWNERO_UnsignedTransaction_mixin =
      _WOWNERO_UnsignedTransaction_mixinPtr.asFunction<
          ffi.Pointer<ffi.Char> Function(
              ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();

  ffi.Pointer<ffi.Char> WOWNERO_UnsignedTransaction_confirmationMessage(
    ffi.Pointer<ffi.Void> unsignedTx_ptr,
  ) {
    return _WOWNERO_UnsignedTransaction_confirmationMessage(
      unsignedTx_ptr,
    );
  }

  late final _WOWNERO_UnsignedTransaction_confirmationMessagePtr = _lookup<
          ffi.NativeFunction<
              ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>>(
      'WOWNERO_UnsignedTransaction_confirmationMessage');
  late final _WOWNERO_UnsignedTransaction_confirmationMessage =
      _WOWNERO_UnsignedTransaction_confirmationMessagePtr.asFunction<
          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>();

  ffi.Pointer<ffi.Char> WOWNERO_UnsignedTransaction_paymentId(
    ffi.Pointer<ffi.Void> unsignedTx_ptr,
    ffi.Pointer<ffi.Char> separator,
  ) {
    return _WOWNERO_UnsignedTransaction_paymentId(
      unsignedTx_ptr,
      separator,
    );
  }

  late final _WOWNERO_UnsignedTransaction_paymentIdPtr = _lookup<
      ffi.NativeFunction<
          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>,
              ffi.Pointer<ffi.Char>)>>('WOWNERO_UnsignedTransaction_paymentId');
  late final _WOWNERO_UnsignedTransaction_paymentId =
      _WOWNERO_UnsignedTransaction_paymentIdPtr.asFunction<
          ffi.Pointer<ffi.Char> Function(
              ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();

  ffi.Pointer<ffi.Char> WOWNERO_UnsignedTransaction_recipientAddress(
    ffi.Pointer<ffi.Void> unsignedTx_ptr,
    ffi.Pointer<ffi.Char> separator,
  ) {
    return _WOWNERO_UnsignedTransaction_recipientAddress(
      unsignedTx_ptr,
      separator,
    );
  }

  late final _WOWNERO_UnsignedTransaction_recipientAddressPtr = _lookup<
          ffi.NativeFunction<
              ffi.Pointer<ffi.Char> Function(
                  ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>>(
      'WOWNERO_UnsignedTransaction_recipientAddress');
  late final _WOWNERO_UnsignedTransaction_recipientAddress =
      _WOWNERO_UnsignedTransaction_recipientAddressPtr.asFunction<
          ffi.Pointer<ffi.Char> Function(
              ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();

  int WOWNERO_UnsignedTransaction_minMixinCount(
    ffi.Pointer<ffi.Void> unsignedTx_ptr,
  ) {
    return _WOWNERO_UnsignedTransaction_minMixinCount(
      unsignedTx_ptr,
    );
  }

  late final _WOWNERO_UnsignedTransaction_minMixinCountPtr =
      _lookup<ffi.NativeFunction<ffi.Uint64 Function(ffi.Pointer<ffi.Void>)>>(
          'WOWNERO_UnsignedTransaction_minMixinCount');
  late final _WOWNERO_UnsignedTransaction_minMixinCount =
      _WOWNERO_UnsignedTransaction_minMixinCountPtr.asFunction<
          int Function(ffi.Pointer<ffi.Void>)>();

  int WOWNERO_UnsignedTransaction_txCount(
    ffi.Pointer<ffi.Void> unsignedTx_ptr,
  ) {
    return _WOWNERO_UnsignedTransaction_txCount(
      unsignedTx_ptr,
    );
  }

  late final _WOWNERO_UnsignedTransaction_txCountPtr =
      _lookup<ffi.NativeFunction<ffi.Uint64 Function(ffi.Pointer<ffi.Void>)>>(
          'WOWNERO_UnsignedTransaction_txCount');
  late final _WOWNERO_UnsignedTransaction_txCount =
      _WOWNERO_UnsignedTransaction_txCountPtr.asFunction<
          int Function(ffi.Pointer<ffi.Void>)>();

  bool WOWNERO_UnsignedTransaction_sign(
    ffi.Pointer<ffi.Void> unsignedTx_ptr,
    ffi.Pointer<ffi.Char> signedFileName,
  ) {
    return _WOWNERO_UnsignedTransaction_sign(
      unsignedTx_ptr,
      signedFileName,
    );
  }

  late final _WOWNERO_UnsignedTransaction_signPtr = _lookup<
      ffi.NativeFunction<
          ffi.Bool Function(ffi.Pointer<ffi.Void>,
              ffi.Pointer<ffi.Char>)>>('WOWNERO_UnsignedTransaction_sign');
  late final _WOWNERO_UnsignedTransaction_sign =
      _WOWNERO_UnsignedTransaction_signPtr.asFunction<
          bool Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();

  int WOWNERO_TransactionInfo_direction(
    ffi.Pointer<ffi.Void> txInfo_ptr,
  ) {
    return _WOWNERO_TransactionInfo_direction(
      txInfo_ptr,
    );
  }

  late final _WOWNERO_TransactionInfo_directionPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(ffi.Pointer<ffi.Void>)>>(
          'WOWNERO_TransactionInfo_direction');
  late final _WOWNERO_TransactionInfo_direction =
      _WOWNERO_TransactionInfo_directionPtr.asFunction<
          int Function(ffi.Pointer<ffi.Void>)>();

  bool WOWNERO_TransactionInfo_isPending(
    ffi.Pointer<ffi.Void> txInfo_ptr,
  ) {
    return _WOWNERO_TransactionInfo_isPending(
      txInfo_ptr,
    );
  }

  late final _WOWNERO_TransactionInfo_isPendingPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(ffi.Pointer<ffi.Void>)>>(
          'WOWNERO_TransactionInfo_isPending');
  late final _WOWNERO_TransactionInfo_isPending =
      _WOWNERO_TransactionInfo_isPendingPtr.asFunction<
          bool Function(ffi.Pointer<ffi.Void>)>();

  bool WOWNERO_TransactionInfo_isFailed(
    ffi.Pointer<ffi.Void> txInfo_ptr,
  ) {
    return _WOWNERO_TransactionInfo_isFailed(
      txInfo_ptr,
    );
  }

  late final _WOWNERO_TransactionInfo_isFailedPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(ffi.Pointer<ffi.Void>)>>(
          'WOWNERO_TransactionInfo_isFailed');
  late final _WOWNERO_TransactionInfo_isFailed =
      _WOWNERO_TransactionInfo_isFailedPtr.asFunction<
          bool Function(ffi.Pointer<ffi.Void>)>();

  bool WOWNERO_TransactionInfo_isCoinbase(
    ffi.Pointer<ffi.Void> txInfo_ptr,
  ) {
    return _WOWNERO_TransactionInfo_isCoinbase(
      txInfo_ptr,
    );
  }

  late final _WOWNERO_TransactionInfo_isCoinbasePtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(ffi.Pointer<ffi.Void>)>>(
          'WOWNERO_TransactionInfo_isCoinbase');
  late final _WOWNERO_TransactionInfo_isCoinbase =
      _WOWNERO_TransactionInfo_isCoinbasePtr.asFunction<
          bool Function(ffi.Pointer<ffi.Void>)>();

  int WOWNERO_TransactionInfo_amount(
    ffi.Pointer<ffi.Void> txInfo_ptr,
  ) {
    return _WOWNERO_TransactionInfo_amount(
      txInfo_ptr,
    );
  }

  late final _WOWNERO_TransactionInfo_amountPtr =
      _lookup<ffi.NativeFunction<ffi.Uint64 Function(ffi.Pointer<ffi.Void>)>>(
          'WOWNERO_TransactionInfo_amount');
  late final _WOWNERO_TransactionInfo_amount =
      _WOWNERO_TransactionInfo_amountPtr.asFunction<
          int Function(ffi.Pointer<ffi.Void>)>();

  int WOWNERO_TransactionInfo_fee(
    ffi.Pointer<ffi.Void> txInfo_ptr,
  ) {
    return _WOWNERO_TransactionInfo_fee(
      txInfo_ptr,
    );
  }

  late final _WOWNERO_TransactionInfo_feePtr =
      _lookup<ffi.NativeFunction<ffi.Uint64 Function(ffi.Pointer<ffi.Void>)>>(
          'WOWNERO_TransactionInfo_fee');
  late final _WOWNERO_TransactionInfo_fee = _WOWNERO_TransactionInfo_feePtr
      .asFunction<int Function(ffi.Pointer<ffi.Void>)>();

  int WOWNERO_TransactionInfo_blockHeight(
    ffi.Pointer<ffi.Void> txInfo_ptr,
  ) {
    return _WOWNERO_TransactionInfo_blockHeight(
      txInfo_ptr,
    );
  }

  late final _WOWNERO_TransactionInfo_blockHeightPtr =
      _lookup<ffi.NativeFunction<ffi.Uint64 Function(ffi.Pointer<ffi.Void>)>>(
          'WOWNERO_TransactionInfo_blockHeight');
  late final _WOWNERO_TransactionInfo_blockHeight =
      _WOWNERO_TransactionInfo_blockHeightPtr.asFunction<
          int Function(ffi.Pointer<ffi.Void>)>();

  ffi.Pointer<ffi.Char> WOWNERO_TransactionInfo_description(
    ffi.Pointer<ffi.Void> txInfo_ptr,
  ) {
    return _WOWNERO_TransactionInfo_description(
      txInfo_ptr,
    );
  }

  late final _WOWNERO_TransactionInfo_descriptionPtr = _lookup<
      ffi.NativeFunction<
          ffi.Pointer<ffi.Char> Function(
              ffi.Pointer<ffi.Void>)>>('WOWNERO_TransactionInfo_description');
  late final _WOWNERO_TransactionInfo_description =
      _WOWNERO_TransactionInfo_descriptionPtr.asFunction<
          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>();

  ffi.Pointer<ffi.Char> WOWNERO_TransactionInfo_subaddrIndex(
    ffi.Pointer<ffi.Void> txInfo_ptr,
    ffi.Pointer<ffi.Char> separator,
  ) {
    return _WOWNERO_TransactionInfo_subaddrIndex(
      txInfo_ptr,
      separator,
    );
  }

  late final _WOWNERO_TransactionInfo_subaddrIndexPtr = _lookup<
      ffi.NativeFunction<
          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>,
              ffi.Pointer<ffi.Char>)>>('WOWNERO_TransactionInfo_subaddrIndex');
  late final _WOWNERO_TransactionInfo_subaddrIndex =
      _WOWNERO_TransactionInfo_subaddrIndexPtr.asFunction<
          ffi.Pointer<ffi.Char> Function(
              ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();

  int WOWNERO_TransactionInfo_subaddrAccount(
    ffi.Pointer<ffi.Void> txInfo_ptr,
  ) {
    return _WOWNERO_TransactionInfo_subaddrAccount(
      txInfo_ptr,
    );
  }

  late final _WOWNERO_TransactionInfo_subaddrAccountPtr =
      _lookup<ffi.NativeFunction<ffi.Uint32 Function(ffi.Pointer<ffi.Void>)>>(
          'WOWNERO_TransactionInfo_subaddrAccount');
  late final _WOWNERO_TransactionInfo_subaddrAccount =
      _WOWNERO_TransactionInfo_subaddrAccountPtr.asFunction<
          int Function(ffi.Pointer<ffi.Void>)>();

  ffi.Pointer<ffi.Char> WOWNERO_TransactionInfo_label(
    ffi.Pointer<ffi.Void> txInfo_ptr,
  ) {
    return _WOWNERO_TransactionInfo_label(
      txInfo_ptr,
    );
  }

  late final _WOWNERO_TransactionInfo_labelPtr = _lookup<
      ffi.NativeFunction<
          ffi.Pointer<ffi.Char> Function(
              ffi.Pointer<ffi.Void>)>>('WOWNERO_TransactionInfo_label');
  late final _WOWNERO_TransactionInfo_label = _WOWNERO_TransactionInfo_labelPtr
      .asFunction<ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>();

  int WOWNERO_TransactionInfo_confirmations(
    ffi.Pointer<ffi.Void> txInfo_ptr,
  ) {
    return _WOWNERO_TransactionInfo_confirmations(
      txInfo_ptr,
    );
  }

  late final _WOWNERO_TransactionInfo_confirmationsPtr =
      _lookup<ffi.NativeFunction<ffi.Uint64 Function(ffi.Pointer<ffi.Void>)>>(
          'WOWNERO_TransactionInfo_confirmations');
  late final _WOWNERO_TransactionInfo_confirmations =
      _WOWNERO_TransactionInfo_confirmationsPtr.asFunction<
          int Function(ffi.Pointer<ffi.Void>)>();

  int WOWNERO_TransactionInfo_unlockTime(
    ffi.Pointer<ffi.Void> txInfo_ptr,
  ) {
    return _WOWNERO_TransactionInfo_unlockTime(
      txInfo_ptr,
    );
  }

  late final _WOWNERO_TransactionInfo_unlockTimePtr =
      _lookup<ffi.NativeFunction<ffi.Uint64 Function(ffi.Pointer<ffi.Void>)>>(
          'WOWNERO_TransactionInfo_unlockTime');
  late final _WOWNERO_TransactionInfo_unlockTime =
      _WOWNERO_TransactionInfo_unlockTimePtr.asFunction<
          int Function(ffi.Pointer<ffi.Void>)>();

  ffi.Pointer<ffi.Char> WOWNERO_TransactionInfo_hash(
    ffi.Pointer<ffi.Void> txInfo_ptr,
  ) {
    return _WOWNERO_TransactionInfo_hash(
      txInfo_ptr,
    );
  }

  late final _WOWNERO_TransactionInfo_hashPtr = _lookup<
      ffi.NativeFunction<
          ffi.Pointer<ffi.Char> Function(
              ffi.Pointer<ffi.Void>)>>('WOWNERO_TransactionInfo_hash');
  late final _WOWNERO_TransactionInfo_hash = _WOWNERO_TransactionInfo_hashPtr
      .asFunction<ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>();

  int WOWNERO_TransactionInfo_timestamp(
    ffi.Pointer<ffi.Void> txInfo_ptr,
  ) {
    return _WOWNERO_TransactionInfo_timestamp(
      txInfo_ptr,
    );
  }

  late final _WOWNERO_TransactionInfo_timestampPtr =
      _lookup<ffi.NativeFunction<ffi.Uint64 Function(ffi.Pointer<ffi.Void>)>>(
          'WOWNERO_TransactionInfo_timestamp');
  late final _WOWNERO_TransactionInfo_timestamp =
      _WOWNERO_TransactionInfo_timestampPtr.asFunction<
          int Function(ffi.Pointer<ffi.Void>)>();

  ffi.Pointer<ffi.Char> WOWNERO_TransactionInfo_paymentId(
    ffi.Pointer<ffi.Void> txInfo_ptr,
  ) {
    return _WOWNERO_TransactionInfo_paymentId(
      txInfo_ptr,
    );
  }

  late final _WOWNERO_TransactionInfo_paymentIdPtr = _lookup<
      ffi.NativeFunction<
          ffi.Pointer<ffi.Char> Function(
              ffi.Pointer<ffi.Void>)>>('WOWNERO_TransactionInfo_paymentId');
  late final _WOWNERO_TransactionInfo_paymentId =
      _WOWNERO_TransactionInfo_paymentIdPtr.asFunction<
          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>();

  int WOWNERO_TransactionInfo_transfers_count(
    ffi.Pointer<ffi.Void> txInfo_ptr,
  ) {
    return _WOWNERO_TransactionInfo_transfers_count(
      txInfo_ptr,
    );
  }

  late final _WOWNERO_TransactionInfo_transfers_countPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(ffi.Pointer<ffi.Void>)>>(
          'WOWNERO_TransactionInfo_transfers_count');
  late final _WOWNERO_TransactionInfo_transfers_count =
      _WOWNERO_TransactionInfo_transfers_countPtr.asFunction<
          int Function(ffi.Pointer<ffi.Void>)>();

  int WOWNERO_TransactionInfo_transfers_amount(
    ffi.Pointer<ffi.Void> txInfo_ptr,
    int index,
  ) {
    return _WOWNERO_TransactionInfo_transfers_amount(
      txInfo_ptr,
      index,
    );
  }

  late final _WOWNERO_TransactionInfo_transfers_amountPtr = _lookup<
          ffi
          .NativeFunction<ffi.Uint64 Function(ffi.Pointer<ffi.Void>, ffi.Int)>>(
      'WOWNERO_TransactionInfo_transfers_amount');
  late final _WOWNERO_TransactionInfo_transfers_amount =
      _WOWNERO_TransactionInfo_transfers_amountPtr.asFunction<
          int Function(ffi.Pointer<ffi.Void>, int)>();

  ffi.Pointer<ffi.Char> WOWNERO_TransactionInfo_transfers_address(
    ffi.Pointer<ffi.Void> txInfo_ptr,
    int address,
  ) {
    return _WOWNERO_TransactionInfo_transfers_address(
      txInfo_ptr,
      address,
    );
  }

  late final _WOWNERO_TransactionInfo_transfers_addressPtr = _lookup<
      ffi.NativeFunction<
          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>,
              ffi.Int)>>('WOWNERO_TransactionInfo_transfers_address');
  late final _WOWNERO_TransactionInfo_transfers_address =
      _WOWNERO_TransactionInfo_transfers_addressPtr.asFunction<
          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>, int)>();

  int WOWNERO_TransactionHistory_count(
    ffi.Pointer<ffi.Void> txHistory_ptr,
  ) {
    return _WOWNERO_TransactionHistory_count(
      txHistory_ptr,
    );
  }

  late final _WOWNERO_TransactionHistory_countPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(ffi.Pointer<ffi.Void>)>>(
          'WOWNERO_TransactionHistory_count');
  late final _WOWNERO_TransactionHistory_count =
      _WOWNERO_TransactionHistory_countPtr.asFunction<
          int Function(ffi.Pointer<ffi.Void>)>();

  ffi.Pointer<ffi.Void> WOWNERO_TransactionHistory_transaction(
    ffi.Pointer<ffi.Void> txHistory_ptr,
    int index,
  ) {
    return _WOWNERO_TransactionHistory_transaction(
      txHistory_ptr,
      index,
    );
  }

  late final _WOWNERO_TransactionHistory_transactionPtr = _lookup<
      ffi.NativeFunction<
          ffi.Pointer<ffi.Void> Function(ffi.Pointer<ffi.Void>,
              ffi.Int)>>('WOWNERO_TransactionHistory_transaction');
  late final _WOWNERO_TransactionHistory_transaction =
      _WOWNERO_TransactionHistory_transactionPtr.asFunction<
          ffi.Pointer<ffi.Void> Function(ffi.Pointer<ffi.Void>, int)>();

  ffi.Pointer<ffi.Void> WOWNERO_TransactionHistory_transactionById(
    ffi.Pointer<ffi.Void> txHistory_ptr,
    ffi.Pointer<ffi.Char> id,
  ) {
    return _WOWNERO_TransactionHistory_transactionById(
      txHistory_ptr,
      id,
    );
  }

  late final _WOWNERO_TransactionHistory_transactionByIdPtr = _lookup<
          ffi.NativeFunction<
              ffi.Pointer<ffi.Void> Function(
                  ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>>(
      'WOWNERO_TransactionHistory_transactionById');
  late final _WOWNERO_TransactionHistory_transactionById =
      _WOWNERO_TransactionHistory_transactionByIdPtr.asFunction<
          ffi.Pointer<ffi.Void> Function(
              ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();

  void WOWNERO_TransactionHistory_refresh(
    ffi.Pointer<ffi.Void> txHistory_ptr,
  ) {
    return _WOWNERO_TransactionHistory_refresh(
      txHistory_ptr,
    );
  }

  late final _WOWNERO_TransactionHistory_refreshPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>)>>(
          'WOWNERO_TransactionHistory_refresh');
  late final _WOWNERO_TransactionHistory_refresh =
      _WOWNERO_TransactionHistory_refreshPtr.asFunction<
          void Function(ffi.Pointer<ffi.Void>)>();

  void WOWNERO_TransactionHistory_setTxNote(
    ffi.Pointer<ffi.Void> txHistory_ptr,
    ffi.Pointer<ffi.Char> txid,
    ffi.Pointer<ffi.Char> note,
  ) {
    return _WOWNERO_TransactionHistory_setTxNote(
      txHistory_ptr,
      txid,
      note,
    );
  }

  late final _WOWNERO_TransactionHistory_setTxNotePtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>,
              ffi.Pointer<ffi.Char>)>>('WOWNERO_TransactionHistory_setTxNote');
  late final _WOWNERO_TransactionHistory_setTxNote =
      _WOWNERO_TransactionHistory_setTxNotePtr.asFunction<
          void Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>,
              ffi.Pointer<ffi.Char>)>();

  ffi.Pointer<ffi.Char> WOWNERO_AddressBookRow_extra(
    ffi.Pointer<ffi.Void> addressBookRow_ptr,
  ) {
    return _WOWNERO_AddressBookRow_extra(
      addressBookRow_ptr,
    );
  }

  late final _WOWNERO_AddressBookRow_extraPtr = _lookup<
      ffi.NativeFunction<
          ffi.Pointer<ffi.Char> Function(
              ffi.Pointer<ffi.Void>)>>('WOWNERO_AddressBookRow_extra');
  late final _WOWNERO_AddressBookRow_extra = _WOWNERO_AddressBookRow_extraPtr
      .asFunction<ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>();

  ffi.Pointer<ffi.Char> WOWNERO_AddressBookRow_getAddress(
    ffi.Pointer<ffi.Void> addressBookRow_ptr,
  ) {
    return _WOWNERO_AddressBookRow_getAddress(
      addressBookRow_ptr,
    );
  }

  late final _WOWNERO_AddressBookRow_getAddressPtr = _lookup<
      ffi.NativeFunction<
          ffi.Pointer<ffi.Char> Function(
              ffi.Pointer<ffi.Void>)>>('WOWNERO_AddressBookRow_getAddress');
  late final _WOWNERO_AddressBookRow_getAddress =
      _WOWNERO_AddressBookRow_getAddressPtr.asFunction<
          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>();

  ffi.Pointer<ffi.Char> WOWNERO_AddressBookRow_getDescription(
    ffi.Pointer<ffi.Void> addressBookRow_ptr,
  ) {
    return _WOWNERO_AddressBookRow_getDescription(
      addressBookRow_ptr,
    );
  }

  late final _WOWNERO_AddressBookRow_getDescriptionPtr = _lookup<
      ffi.NativeFunction<
          ffi.Pointer<ffi.Char> Function(
              ffi.Pointer<ffi.Void>)>>('WOWNERO_AddressBookRow_getDescription');
  late final _WOWNERO_AddressBookRow_getDescription =
      _WOWNERO_AddressBookRow_getDescriptionPtr.asFunction<
          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>();

  ffi.Pointer<ffi.Char> WOWNERO_AddressBookRow_getPaymentId(
    ffi.Pointer<ffi.Void> addressBookRow_ptr,
  ) {
    return _WOWNERO_AddressBookRow_getPaymentId(
      addressBookRow_ptr,
    );
  }

  late final _WOWNERO_AddressBookRow_getPaymentIdPtr = _lookup<
      ffi.NativeFunction<
          ffi.Pointer<ffi.Char> Function(
              ffi.Pointer<ffi.Void>)>>('WOWNERO_AddressBookRow_getPaymentId');
  late final _WOWNERO_AddressBookRow_getPaymentId =
      _WOWNERO_AddressBookRow_getPaymentIdPtr.asFunction<
          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>();

  int WOWNERO_AddressBookRow_getRowId(
    ffi.Pointer<ffi.Void> addressBookRow_ptr,
  ) {
    return _WOWNERO_AddressBookRow_getRowId(
      addressBookRow_ptr,
    );
  }

  late final _WOWNERO_AddressBookRow_getRowIdPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(ffi.Pointer<ffi.Void>)>>(
          'WOWNERO_AddressBookRow_getRowId');
  late final _WOWNERO_AddressBookRow_getRowId =
      _WOWNERO_AddressBookRow_getRowIdPtr.asFunction<
          int Function(ffi.Pointer<ffi.Void>)>();

  int WOWNERO_AddressBook_getAll_size(
    ffi.Pointer<ffi.Void> addressBook_ptr,
  ) {
    return _WOWNERO_AddressBook_getAll_size(
      addressBook_ptr,
    );
  }

  late final _WOWNERO_AddressBook_getAll_sizePtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(ffi.Pointer<ffi.Void>)>>(
          'WOWNERO_AddressBook_getAll_size');
  late final _WOWNERO_AddressBook_getAll_size =
      _WOWNERO_AddressBook_getAll_sizePtr.asFunction<
          int Function(ffi.Pointer<ffi.Void>)>();

  ffi.Pointer<ffi.Void> WOWNERO_AddressBook_getAll_byIndex(
    ffi.Pointer<ffi.Void> addressBook_ptr,
    int index,
  ) {
    return _WOWNERO_AddressBook_getAll_byIndex(
      addressBook_ptr,
      index,
    );
  }

  late final _WOWNERO_AddressBook_getAll_byIndexPtr = _lookup<
      ffi.NativeFunction<
          ffi.Pointer<ffi.Void> Function(ffi.Pointer<ffi.Void>,
              ffi.Int)>>('WOWNERO_AddressBook_getAll_byIndex');
  late final _WOWNERO_AddressBook_getAll_byIndex =
      _WOWNERO_AddressBook_getAll_byIndexPtr.asFunction<
          ffi.Pointer<ffi.Void> Function(ffi.Pointer<ffi.Void>, int)>();

  bool WOWNERO_AddressBook_addRow(
    ffi.Pointer<ffi.Void> addressBook_ptr,
    ffi.Pointer<ffi.Char> dst_addr,
    ffi.Pointer<ffi.Char> payment_id,
    ffi.Pointer<ffi.Char> description,
  ) {
    return _WOWNERO_AddressBook_addRow(
      addressBook_ptr,
      dst_addr,
      payment_id,
      description,
    );
  }

  late final _WOWNERO_AddressBook_addRowPtr = _lookup<
      ffi.NativeFunction<
          ffi.Bool Function(
              ffi.Pointer<ffi.Void>,
              ffi.Pointer<ffi.Char>,
              ffi.Pointer<ffi.Char>,
              ffi.Pointer<ffi.Char>)>>('WOWNERO_AddressBook_addRow');
  late final _WOWNERO_AddressBook_addRow =
      _WOWNERO_AddressBook_addRowPtr.asFunction<
          bool Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>,
              ffi.Pointer<ffi.Char>, ffi.Pointer<ffi.Char>)>();

  bool WOWNERO_AddressBook_deleteRow(
    ffi.Pointer<ffi.Void> addressBook_ptr,
    int rowId,
  ) {
    return _WOWNERO_AddressBook_deleteRow(
      addressBook_ptr,
      rowId,
    );
  }

  late final _WOWNERO_AddressBook_deleteRowPtr = _lookup<
          ffi
          .NativeFunction<ffi.Bool Function(ffi.Pointer<ffi.Void>, ffi.Size)>>(
      'WOWNERO_AddressBook_deleteRow');
  late final _WOWNERO_AddressBook_deleteRow = _WOWNERO_AddressBook_deleteRowPtr
      .asFunction<bool Function(ffi.Pointer<ffi.Void>, int)>();

  bool WOWNERO_AddressBook_setDescription(
    ffi.Pointer<ffi.Void> addressBook_ptr,
    int rowId,
    ffi.Pointer<ffi.Char> description,
  ) {
    return _WOWNERO_AddressBook_setDescription(
      addressBook_ptr,
      rowId,
      description,
    );
  }

  late final _WOWNERO_AddressBook_setDescriptionPtr = _lookup<
      ffi.NativeFunction<
          ffi.Bool Function(ffi.Pointer<ffi.Void>, ffi.Size,
              ffi.Pointer<ffi.Char>)>>('WOWNERO_AddressBook_setDescription');
  late final _WOWNERO_AddressBook_setDescription =
      _WOWNERO_AddressBook_setDescriptionPtr.asFunction<
          bool Function(ffi.Pointer<ffi.Void>, int, ffi.Pointer<ffi.Char>)>();

  void WOWNERO_AddressBook_refresh(
    ffi.Pointer<ffi.Void> addressBook_ptr,
  ) {
    return _WOWNERO_AddressBook_refresh(
      addressBook_ptr,
    );
  }

  late final _WOWNERO_AddressBook_refreshPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>)>>(
          'WOWNERO_AddressBook_refresh');
  late final _WOWNERO_AddressBook_refresh = _WOWNERO_AddressBook_refreshPtr
      .asFunction<void Function(ffi.Pointer<ffi.Void>)>();

  ffi.Pointer<ffi.Char> WOWNERO_AddressBook_errorString(
    ffi.Pointer<ffi.Void> addressBook_ptr,
  ) {
    return _WOWNERO_AddressBook_errorString(
      addressBook_ptr,
    );
  }

  late final _WOWNERO_AddressBook_errorStringPtr = _lookup<
      ffi.NativeFunction<
          ffi.Pointer<ffi.Char> Function(
              ffi.Pointer<ffi.Void>)>>('WOWNERO_AddressBook_errorString');
  late final _WOWNERO_AddressBook_errorString =
      _WOWNERO_AddressBook_errorStringPtr.asFunction<
          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>();

  int WOWNERO_AddressBook_errorCode(
    ffi.Pointer<ffi.Void> addressBook_ptr,
  ) {
    return _WOWNERO_AddressBook_errorCode(
      addressBook_ptr,
    );
  }

  late final _WOWNERO_AddressBook_errorCodePtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(ffi.Pointer<ffi.Void>)>>(
          'WOWNERO_AddressBook_errorCode');
  late final _WOWNERO_AddressBook_errorCode = _WOWNERO_AddressBook_errorCodePtr
      .asFunction<int Function(ffi.Pointer<ffi.Void>)>();

  int WOWNERO_AddressBook_lookupPaymentID(
    ffi.Pointer<ffi.Void> addressBook_ptr,
    ffi.Pointer<ffi.Char> payment_id,
  ) {
    return _WOWNERO_AddressBook_lookupPaymentID(
      addressBook_ptr,
      payment_id,
    );
  }

  late final _WOWNERO_AddressBook_lookupPaymentIDPtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(ffi.Pointer<ffi.Void>,
              ffi.Pointer<ffi.Char>)>>('WOWNERO_AddressBook_lookupPaymentID');
  late final _WOWNERO_AddressBook_lookupPaymentID =
      _WOWNERO_AddressBook_lookupPaymentIDPtr.asFunction<
          int Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();

  int WOWNERO_CoinsInfo_blockHeight(
    ffi.Pointer<ffi.Void> coinsInfo_ptr,
  ) {
    return _WOWNERO_CoinsInfo_blockHeight(
      coinsInfo_ptr,
    );
  }

  late final _WOWNERO_CoinsInfo_blockHeightPtr =
      _lookup<ffi.NativeFunction<ffi.Uint64 Function(ffi.Pointer<ffi.Void>)>>(
          'WOWNERO_CoinsInfo_blockHeight');
  late final _WOWNERO_CoinsInfo_blockHeight = _WOWNERO_CoinsInfo_blockHeightPtr
      .asFunction<int Function(ffi.Pointer<ffi.Void>)>();

  ffi.Pointer<ffi.Char> WOWNERO_CoinsInfo_hash(
    ffi.Pointer<ffi.Void> coinsInfo_ptr,
  ) {
    return _WOWNERO_CoinsInfo_hash(
      coinsInfo_ptr,
    );
  }

  late final _WOWNERO_CoinsInfo_hashPtr = _lookup<
      ffi.NativeFunction<
          ffi.Pointer<ffi.Char> Function(
              ffi.Pointer<ffi.Void>)>>('WOWNERO_CoinsInfo_hash');
  late final _WOWNERO_CoinsInfo_hash = _WOWNERO_CoinsInfo_hashPtr.asFunction<
      ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>();

  int WOWNERO_CoinsInfo_internalOutputIndex(
    ffi.Pointer<ffi.Void> coinsInfo_ptr,
  ) {
    return _WOWNERO_CoinsInfo_internalOutputIndex(
      coinsInfo_ptr,
    );
  }

  late final _WOWNERO_CoinsInfo_internalOutputIndexPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(ffi.Pointer<ffi.Void>)>>(
          'WOWNERO_CoinsInfo_internalOutputIndex');
  late final _WOWNERO_CoinsInfo_internalOutputIndex =
      _WOWNERO_CoinsInfo_internalOutputIndexPtr.asFunction<
          int Function(ffi.Pointer<ffi.Void>)>();

  int WOWNERO_CoinsInfo_globalOutputIndex(
    ffi.Pointer<ffi.Void> coinsInfo_ptr,
  ) {
    return _WOWNERO_CoinsInfo_globalOutputIndex(
      coinsInfo_ptr,
    );
  }

  late final _WOWNERO_CoinsInfo_globalOutputIndexPtr =
      _lookup<ffi.NativeFunction<ffi.Uint64 Function(ffi.Pointer<ffi.Void>)>>(
          'WOWNERO_CoinsInfo_globalOutputIndex');
  late final _WOWNERO_CoinsInfo_globalOutputIndex =
      _WOWNERO_CoinsInfo_globalOutputIndexPtr.asFunction<
          int Function(ffi.Pointer<ffi.Void>)>();

  bool WOWNERO_CoinsInfo_spent(
    ffi.Pointer<ffi.Void> coinsInfo_ptr,
  ) {
    return _WOWNERO_CoinsInfo_spent(
      coinsInfo_ptr,
    );
  }

  late final _WOWNERO_CoinsInfo_spentPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(ffi.Pointer<ffi.Void>)>>(
          'WOWNERO_CoinsInfo_spent');
  late final _WOWNERO_CoinsInfo_spent = _WOWNERO_CoinsInfo_spentPtr.asFunction<
      bool Function(ffi.Pointer<ffi.Void>)>();

  bool WOWNERO_CoinsInfo_frozen(
    ffi.Pointer<ffi.Void> coinsInfo_ptr,
  ) {
    return _WOWNERO_CoinsInfo_frozen(
      coinsInfo_ptr,
    );
  }

  late final _WOWNERO_CoinsInfo_frozenPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(ffi.Pointer<ffi.Void>)>>(
          'WOWNERO_CoinsInfo_frozen');
  late final _WOWNERO_CoinsInfo_frozen = _WOWNERO_CoinsInfo_frozenPtr
      .asFunction<bool Function(ffi.Pointer<ffi.Void>)>();

  int WOWNERO_CoinsInfo_spentHeight(
    ffi.Pointer<ffi.Void> coinsInfo_ptr,
  ) {
    return _WOWNERO_CoinsInfo_spentHeight(
      coinsInfo_ptr,
    );
  }

  late final _WOWNERO_CoinsInfo_spentHeightPtr =
      _lookup<ffi.NativeFunction<ffi.Uint64 Function(ffi.Pointer<ffi.Void>)>>(
          'WOWNERO_CoinsInfo_spentHeight');
  late final _WOWNERO_CoinsInfo_spentHeight = _WOWNERO_CoinsInfo_spentHeightPtr
      .asFunction<int Function(ffi.Pointer<ffi.Void>)>();

  int WOWNERO_CoinsInfo_amount(
    ffi.Pointer<ffi.Void> coinsInfo_ptr,
  ) {
    return _WOWNERO_CoinsInfo_amount(
      coinsInfo_ptr,
    );
  }

  late final _WOWNERO_CoinsInfo_amountPtr =
      _lookup<ffi.NativeFunction<ffi.Uint64 Function(ffi.Pointer<ffi.Void>)>>(
          'WOWNERO_CoinsInfo_amount');
  late final _WOWNERO_CoinsInfo_amount = _WOWNERO_CoinsInfo_amountPtr
      .asFunction<int Function(ffi.Pointer<ffi.Void>)>();

  bool WOWNERO_CoinsInfo_rct(
    ffi.Pointer<ffi.Void> coinsInfo_ptr,
  ) {
    return _WOWNERO_CoinsInfo_rct(
      coinsInfo_ptr,
    );
  }

  late final _WOWNERO_CoinsInfo_rctPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(ffi.Pointer<ffi.Void>)>>(
          'WOWNERO_CoinsInfo_rct');
  late final _WOWNERO_CoinsInfo_rct = _WOWNERO_CoinsInfo_rctPtr.asFunction<
      bool Function(ffi.Pointer<ffi.Void>)>();

  bool WOWNERO_CoinsInfo_keyImageKnown(
    ffi.Pointer<ffi.Void> coinsInfo_ptr,
  ) {
    return _WOWNERO_CoinsInfo_keyImageKnown(
      coinsInfo_ptr,
    );
  }

  late final _WOWNERO_CoinsInfo_keyImageKnownPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(ffi.Pointer<ffi.Void>)>>(
          'WOWNERO_CoinsInfo_keyImageKnown');
  late final _WOWNERO_CoinsInfo_keyImageKnown =
      _WOWNERO_CoinsInfo_keyImageKnownPtr.asFunction<
          bool Function(ffi.Pointer<ffi.Void>)>();

  int WOWNERO_CoinsInfo_pkIndex(
    ffi.Pointer<ffi.Void> coinsInfo_ptr,
  ) {
    return _WOWNERO_CoinsInfo_pkIndex(
      coinsInfo_ptr,
    );
  }

  late final _WOWNERO_CoinsInfo_pkIndexPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(ffi.Pointer<ffi.Void>)>>(
          'WOWNERO_CoinsInfo_pkIndex');
  late final _WOWNERO_CoinsInfo_pkIndex = _WOWNERO_CoinsInfo_pkIndexPtr
      .asFunction<int Function(ffi.Pointer<ffi.Void>)>();

  int WOWNERO_CoinsInfo_subaddrIndex(
    ffi.Pointer<ffi.Void> coinsInfo_ptr,
  ) {
    return _WOWNERO_CoinsInfo_subaddrIndex(
      coinsInfo_ptr,
    );
  }

  late final _WOWNERO_CoinsInfo_subaddrIndexPtr =
      _lookup<ffi.NativeFunction<ffi.Uint32 Function(ffi.Pointer<ffi.Void>)>>(
          'WOWNERO_CoinsInfo_subaddrIndex');
  late final _WOWNERO_CoinsInfo_subaddrIndex =
      _WOWNERO_CoinsInfo_subaddrIndexPtr.asFunction<
          int Function(ffi.Pointer<ffi.Void>)>();

  int WOWNERO_CoinsInfo_subaddrAccount(
    ffi.Pointer<ffi.Void> coinsInfo_ptr,
  ) {
    return _WOWNERO_CoinsInfo_subaddrAccount(
      coinsInfo_ptr,
    );
  }

  late final _WOWNERO_CoinsInfo_subaddrAccountPtr =
      _lookup<ffi.NativeFunction<ffi.Uint32 Function(ffi.Pointer<ffi.Void>)>>(
          'WOWNERO_CoinsInfo_subaddrAccount');
  late final _WOWNERO_CoinsInfo_subaddrAccount =
      _WOWNERO_CoinsInfo_subaddrAccountPtr.asFunction<
          int Function(ffi.Pointer<ffi.Void>)>();

  ffi.Pointer<ffi.Char> WOWNERO_CoinsInfo_address(
    ffi.Pointer<ffi.Void> coinsInfo_ptr,
  ) {
    return _WOWNERO_CoinsInfo_address(
      coinsInfo_ptr,
    );
  }

  late final _WOWNERO_CoinsInfo_addressPtr = _lookup<
      ffi.NativeFunction<
          ffi.Pointer<ffi.Char> Function(
              ffi.Pointer<ffi.Void>)>>('WOWNERO_CoinsInfo_address');
  late final _WOWNERO_CoinsInfo_address = _WOWNERO_CoinsInfo_addressPtr
      .asFunction<ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>();

  ffi.Pointer<ffi.Char> WOWNERO_CoinsInfo_addressLabel(
    ffi.Pointer<ffi.Void> coinsInfo_ptr,
  ) {
    return _WOWNERO_CoinsInfo_addressLabel(
      coinsInfo_ptr,
    );
  }

  late final _WOWNERO_CoinsInfo_addressLabelPtr = _lookup<
      ffi.NativeFunction<
          ffi.Pointer<ffi.Char> Function(
              ffi.Pointer<ffi.Void>)>>('WOWNERO_CoinsInfo_addressLabel');
  late final _WOWNERO_CoinsInfo_addressLabel =
      _WOWNERO_CoinsInfo_addressLabelPtr.asFunction<
          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>();

  ffi.Pointer<ffi.Char> WOWNERO_CoinsInfo_keyImage(
    ffi.Pointer<ffi.Void> coinsInfo_ptr,
  ) {
    return _WOWNERO_CoinsInfo_keyImage(
      coinsInfo_ptr,
    );
  }

  late final _WOWNERO_CoinsInfo_keyImagePtr = _lookup<
      ffi.NativeFunction<
          ffi.Pointer<ffi.Char> Function(
              ffi.Pointer<ffi.Void>)>>('WOWNERO_CoinsInfo_keyImage');
  late final _WOWNERO_CoinsInfo_keyImage = _WOWNERO_CoinsInfo_keyImagePtr
      .asFunction<ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>();

  int WOWNERO_CoinsInfo_unlockTime(
    ffi.Pointer<ffi.Void> coinsInfo_ptr,
  ) {
    return _WOWNERO_CoinsInfo_unlockTime(
      coinsInfo_ptr,
    );
  }

  late final _WOWNERO_CoinsInfo_unlockTimePtr =
      _lookup<ffi.NativeFunction<ffi.Uint64 Function(ffi.Pointer<ffi.Void>)>>(
          'WOWNERO_CoinsInfo_unlockTime');
  late final _WOWNERO_CoinsInfo_unlockTime = _WOWNERO_CoinsInfo_unlockTimePtr
      .asFunction<int Function(ffi.Pointer<ffi.Void>)>();

  bool WOWNERO_CoinsInfo_unlocked(
    ffi.Pointer<ffi.Void> coinsInfo_ptr,
  ) {
    return _WOWNERO_CoinsInfo_unlocked(
      coinsInfo_ptr,
    );
  }

  late final _WOWNERO_CoinsInfo_unlockedPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(ffi.Pointer<ffi.Void>)>>(
          'WOWNERO_CoinsInfo_unlocked');
  late final _WOWNERO_CoinsInfo_unlocked = _WOWNERO_CoinsInfo_unlockedPtr
      .asFunction<bool Function(ffi.Pointer<ffi.Void>)>();

  ffi.Pointer<ffi.Char> WOWNERO_CoinsInfo_pubKey(
    ffi.Pointer<ffi.Void> coinsInfo_ptr,
  ) {
    return _WOWNERO_CoinsInfo_pubKey(
      coinsInfo_ptr,
    );
  }

  late final _WOWNERO_CoinsInfo_pubKeyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Pointer<ffi.Char> Function(
              ffi.Pointer<ffi.Void>)>>('WOWNERO_CoinsInfo_pubKey');
  late final _WOWNERO_CoinsInfo_pubKey = _WOWNERO_CoinsInfo_pubKeyPtr
      .asFunction<ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>();

  bool WOWNERO_CoinsInfo_coinbase(
    ffi.Pointer<ffi.Void> coinsInfo_ptr,
  ) {
    return _WOWNERO_CoinsInfo_coinbase(
      coinsInfo_ptr,
    );
  }

  late final _WOWNERO_CoinsInfo_coinbasePtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(ffi.Pointer<ffi.Void>)>>(
          'WOWNERO_CoinsInfo_coinbase');
  late final _WOWNERO_CoinsInfo_coinbase = _WOWNERO_CoinsInfo_coinbasePtr
      .asFunction<bool Function(ffi.Pointer<ffi.Void>)>();

  ffi.Pointer<ffi.Char> WOWNERO_CoinsInfo_description(
    ffi.Pointer<ffi.Void> coinsInfo_ptr,
  ) {
    return _WOWNERO_CoinsInfo_description(
      coinsInfo_ptr,
    );
  }

  late final _WOWNERO_CoinsInfo_descriptionPtr = _lookup<
      ffi.NativeFunction<
          ffi.Pointer<ffi.Char> Function(
              ffi.Pointer<ffi.Void>)>>('WOWNERO_CoinsInfo_description');
  late final _WOWNERO_CoinsInfo_description = _WOWNERO_CoinsInfo_descriptionPtr
      .asFunction<ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>();

  int WOWNERO_Coins_count(
    ffi.Pointer<ffi.Void> coins_ptr,
  ) {
    return _WOWNERO_Coins_count(
      coins_ptr,
    );
  }

  late final _WOWNERO_Coins_countPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(ffi.Pointer<ffi.Void>)>>(
          'WOWNERO_Coins_count');
  late final _WOWNERO_Coins_count =
      _WOWNERO_Coins_countPtr.asFunction<int Function(ffi.Pointer<ffi.Void>)>();

  ffi.Pointer<ffi.Void> WOWNERO_Coins_coin(
    ffi.Pointer<ffi.Void> coins_ptr,
    int index,
  ) {
    return _WOWNERO_Coins_coin(
      coins_ptr,
      index,
    );
  }

  late final _WOWNERO_Coins_coinPtr = _lookup<
      ffi.NativeFunction<
          ffi.Pointer<ffi.Void> Function(
              ffi.Pointer<ffi.Void>, ffi.Int)>>('WOWNERO_Coins_coin');
  late final _WOWNERO_Coins_coin = _WOWNERO_Coins_coinPtr.asFunction<
      ffi.Pointer<ffi.Void> Function(ffi.Pointer<ffi.Void>, int)>();

  int WOWNERO_Coins_getAll_size(
    ffi.Pointer<ffi.Void> coins_ptr,
  ) {
    return _WOWNERO_Coins_getAll_size(
      coins_ptr,
    );
  }

  late final _WOWNERO_Coins_getAll_sizePtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(ffi.Pointer<ffi.Void>)>>(
          'WOWNERO_Coins_getAll_size');
  late final _WOWNERO_Coins_getAll_size = _WOWNERO_Coins_getAll_sizePtr
      .asFunction<int Function(ffi.Pointer<ffi.Void>)>();

  ffi.Pointer<ffi.Void> WOWNERO_Coins_getAll_byIndex(
    ffi.Pointer<ffi.Void> coins_ptr,
    int index,
  ) {
    return _WOWNERO_Coins_getAll_byIndex(
      coins_ptr,
      index,
    );
  }

  late final _WOWNERO_Coins_getAll_byIndexPtr = _lookup<
      ffi.NativeFunction<
          ffi.Pointer<ffi.Void> Function(
              ffi.Pointer<ffi.Void>, ffi.Int)>>('WOWNERO_Coins_getAll_byIndex');
  late final _WOWNERO_Coins_getAll_byIndex = _WOWNERO_Coins_getAll_byIndexPtr
      .asFunction<ffi.Pointer<ffi.Void> Function(ffi.Pointer<ffi.Void>, int)>();

  void WOWNERO_Coins_refresh(
    ffi.Pointer<ffi.Void> coins_ptr,
  ) {
    return _WOWNERO_Coins_refresh(
      coins_ptr,
    );
  }

  late final _WOWNERO_Coins_refreshPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>)>>(
          'WOWNERO_Coins_refresh');
  late final _WOWNERO_Coins_refresh = _WOWNERO_Coins_refreshPtr.asFunction<
      void Function(ffi.Pointer<ffi.Void>)>();

  void WOWNERO_Coins_setFrozenByPublicKey(
    ffi.Pointer<ffi.Void> coins_ptr,
    ffi.Pointer<ffi.Char> public_key,
  ) {
    return _WOWNERO_Coins_setFrozenByPublicKey(
      coins_ptr,
      public_key,
    );
  }

  late final _WOWNERO_Coins_setFrozenByPublicKeyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(ffi.Pointer<ffi.Void>,
              ffi.Pointer<ffi.Char>)>>('WOWNERO_Coins_setFrozenByPublicKey');
  late final _WOWNERO_Coins_setFrozenByPublicKey =
      _WOWNERO_Coins_setFrozenByPublicKeyPtr.asFunction<
          void Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();

  void WOWNERO_Coins_setFrozen(
    ffi.Pointer<ffi.Void> coins_ptr,
    int index,
  ) {
    return _WOWNERO_Coins_setFrozen(
      coins_ptr,
      index,
    );
  }

  late final _WOWNERO_Coins_setFrozenPtr = _lookup<
          ffi
          .NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>, ffi.Int)>>(
      'WOWNERO_Coins_setFrozen');
  late final _WOWNERO_Coins_setFrozen = _WOWNERO_Coins_setFrozenPtr.asFunction<
      void Function(ffi.Pointer<ffi.Void>, int)>();

  void WOWNERO_Coins_thaw(
    ffi.Pointer<ffi.Void> coins_ptr,
    int index,
  ) {
    return _WOWNERO_Coins_thaw(
      coins_ptr,
      index,
    );
  }

  late final _WOWNERO_Coins_thawPtr = _lookup<
          ffi
          .NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>, ffi.Int)>>(
      'WOWNERO_Coins_thaw');
  late final _WOWNERO_Coins_thaw = _WOWNERO_Coins_thawPtr.asFunction<
      void Function(ffi.Pointer<ffi.Void>, int)>();

  void WOWNERO_Coins_thawByPublicKey(
    ffi.Pointer<ffi.Void> coins_ptr,
    ffi.Pointer<ffi.Char> public_key,
  ) {
    return _WOWNERO_Coins_thawByPublicKey(
      coins_ptr,
      public_key,
    );
  }

  late final _WOWNERO_Coins_thawByPublicKeyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(ffi.Pointer<ffi.Void>,
              ffi.Pointer<ffi.Char>)>>('WOWNERO_Coins_thawByPublicKey');
  late final _WOWNERO_Coins_thawByPublicKey =
      _WOWNERO_Coins_thawByPublicKeyPtr.asFunction<
          void Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();

  bool WOWNERO_Coins_isTransferUnlocked(
    ffi.Pointer<ffi.Void> coins_ptr,
    int unlockTime,
    int blockHeight,
  ) {
    return _WOWNERO_Coins_isTransferUnlocked(
      coins_ptr,
      unlockTime,
      blockHeight,
    );
  }

  late final _WOWNERO_Coins_isTransferUnlockedPtr = _lookup<
      ffi.NativeFunction<
          ffi.Bool Function(ffi.Pointer<ffi.Void>, ffi.Uint64,
              ffi.Uint64)>>('WOWNERO_Coins_isTransferUnlocked');
  late final _WOWNERO_Coins_isTransferUnlocked =
      _WOWNERO_Coins_isTransferUnlockedPtr.asFunction<
          bool Function(ffi.Pointer<ffi.Void>, int, int)>();

  void WOWNERO_Coins_setDescription(
    ffi.Pointer<ffi.Void> coins_ptr,
    ffi.Pointer<ffi.Char> public_key,
    ffi.Pointer<ffi.Char> description,
  ) {
    return _WOWNERO_Coins_setDescription(
      coins_ptr,
      public_key,
      description,
    );
  }

  late final _WOWNERO_Coins_setDescriptionPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>,
              ffi.Pointer<ffi.Char>)>>('WOWNERO_Coins_setDescription');
  late final _WOWNERO_Coins_setDescription =
      _WOWNERO_Coins_setDescriptionPtr.asFunction<
          void Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>,
              ffi.Pointer<ffi.Char>)>();

  ffi.Pointer<ffi.Char> WOWNERO_SubaddressRow_extra(
    ffi.Pointer<ffi.Void> subaddressRow_ptr,
  ) {
    return _WOWNERO_SubaddressRow_extra(
      subaddressRow_ptr,
    );
  }

  late final _WOWNERO_SubaddressRow_extraPtr = _lookup<
      ffi.NativeFunction<
          ffi.Pointer<ffi.Char> Function(
              ffi.Pointer<ffi.Void>)>>('WOWNERO_SubaddressRow_extra');
  late final _WOWNERO_SubaddressRow_extra = _WOWNERO_SubaddressRow_extraPtr
      .asFunction<ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>();

  ffi.Pointer<ffi.Char> WOWNERO_SubaddressRow_getAddress(
    ffi.Pointer<ffi.Void> subaddressRow_ptr,
  ) {
    return _WOWNERO_SubaddressRow_getAddress(
      subaddressRow_ptr,
    );
  }

  late final _WOWNERO_SubaddressRow_getAddressPtr = _lookup<
      ffi.NativeFunction<
          ffi.Pointer<ffi.Char> Function(
              ffi.Pointer<ffi.Void>)>>('WOWNERO_SubaddressRow_getAddress');
  late final _WOWNERO_SubaddressRow_getAddress =
      _WOWNERO_SubaddressRow_getAddressPtr.asFunction<
          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>();

  ffi.Pointer<ffi.Char> WOWNERO_SubaddressRow_getLabel(
    ffi.Pointer<ffi.Void> subaddressRow_ptr,
  ) {
    return _WOWNERO_SubaddressRow_getLabel(
      subaddressRow_ptr,
    );
  }

  late final _WOWNERO_SubaddressRow_getLabelPtr = _lookup<
      ffi.NativeFunction<
          ffi.Pointer<ffi.Char> Function(
              ffi.Pointer<ffi.Void>)>>('WOWNERO_SubaddressRow_getLabel');
  late final _WOWNERO_SubaddressRow_getLabel =
      _WOWNERO_SubaddressRow_getLabelPtr.asFunction<
          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>();

  int WOWNERO_SubaddressRow_getRowId(
    ffi.Pointer<ffi.Void> subaddressRow_ptr,
  ) {
    return _WOWNERO_SubaddressRow_getRowId(
      subaddressRow_ptr,
    );
  }

  late final _WOWNERO_SubaddressRow_getRowIdPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(ffi.Pointer<ffi.Void>)>>(
          'WOWNERO_SubaddressRow_getRowId');
  late final _WOWNERO_SubaddressRow_getRowId =
      _WOWNERO_SubaddressRow_getRowIdPtr.asFunction<
          int Function(ffi.Pointer<ffi.Void>)>();

  int WOWNERO_Subaddress_getAll_size(
    ffi.Pointer<ffi.Void> subaddress_ptr,
  ) {
    return _WOWNERO_Subaddress_getAll_size(
      subaddress_ptr,
    );
  }

  late final _WOWNERO_Subaddress_getAll_sizePtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(ffi.Pointer<ffi.Void>)>>(
          'WOWNERO_Subaddress_getAll_size');
  late final _WOWNERO_Subaddress_getAll_size =
      _WOWNERO_Subaddress_getAll_sizePtr.asFunction<
          int Function(ffi.Pointer<ffi.Void>)>();

  ffi.Pointer<ffi.Void> WOWNERO_Subaddress_getAll_byIndex(
    ffi.Pointer<ffi.Void> subaddress_ptr,
    int index,
  ) {
    return _WOWNERO_Subaddress_getAll_byIndex(
      subaddress_ptr,
      index,
    );
  }

  late final _WOWNERO_Subaddress_getAll_byIndexPtr = _lookup<
      ffi.NativeFunction<
          ffi.Pointer<ffi.Void> Function(ffi.Pointer<ffi.Void>,
              ffi.Int)>>('WOWNERO_Subaddress_getAll_byIndex');
  late final _WOWNERO_Subaddress_getAll_byIndex =
      _WOWNERO_Subaddress_getAll_byIndexPtr.asFunction<
          ffi.Pointer<ffi.Void> Function(ffi.Pointer<ffi.Void>, int)>();

  void WOWNERO_Subaddress_addRow(
    ffi.Pointer<ffi.Void> subaddress_ptr,
    int accountIndex,
    ffi.Pointer<ffi.Char> label,
  ) {
    return _WOWNERO_Subaddress_addRow(
      subaddress_ptr,
      accountIndex,
      label,
    );
  }

  late final _WOWNERO_Subaddress_addRowPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(ffi.Pointer<ffi.Void>, ffi.Uint32,
              ffi.Pointer<ffi.Char>)>>('WOWNERO_Subaddress_addRow');
  late final _WOWNERO_Subaddress_addRow =
      _WOWNERO_Subaddress_addRowPtr.asFunction<
          void Function(ffi.Pointer<ffi.Void>, int, ffi.Pointer<ffi.Char>)>();

  void WOWNERO_Subaddress_setLabel(
    ffi.Pointer<ffi.Void> subaddress_ptr,
    int accountIndex,
    int addressIndex,
    ffi.Pointer<ffi.Char> label,
  ) {
    return _WOWNERO_Subaddress_setLabel(
      subaddress_ptr,
      accountIndex,
      addressIndex,
      label,
    );
  }

  late final _WOWNERO_Subaddress_setLabelPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(ffi.Pointer<ffi.Void>, ffi.Uint32, ffi.Uint32,
              ffi.Pointer<ffi.Char>)>>('WOWNERO_Subaddress_setLabel');
  late final _WOWNERO_Subaddress_setLabel =
      _WOWNERO_Subaddress_setLabelPtr.asFunction<
          void Function(
              ffi.Pointer<ffi.Void>, int, int, ffi.Pointer<ffi.Char>)>();

  void WOWNERO_Subaddress_refresh(
    ffi.Pointer<ffi.Void> subaddress_ptr,
    int accountIndex,
  ) {
    return _WOWNERO_Subaddress_refresh(
      subaddress_ptr,
      accountIndex,
    );
  }

  late final _WOWNERO_Subaddress_refreshPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(ffi.Pointer<ffi.Void>,
              ffi.Uint32)>>('WOWNERO_Subaddress_refresh');
  late final _WOWNERO_Subaddress_refresh = _WOWNERO_Subaddress_refreshPtr
      .asFunction<void Function(ffi.Pointer<ffi.Void>, int)>();

  ffi.Pointer<ffi.Char> WOWNERO_SubaddressAccountRow_extra(
    ffi.Pointer<ffi.Void> subaddressAccountRow_ptr,
  ) {
    return _WOWNERO_SubaddressAccountRow_extra(
      subaddressAccountRow_ptr,
    );
  }

  late final _WOWNERO_SubaddressAccountRow_extraPtr = _lookup<
      ffi.NativeFunction<
          ffi.Pointer<ffi.Char> Function(
              ffi.Pointer<ffi.Void>)>>('WOWNERO_SubaddressAccountRow_extra');
  late final _WOWNERO_SubaddressAccountRow_extra =
      _WOWNERO_SubaddressAccountRow_extraPtr.asFunction<
          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>();

  ffi.Pointer<ffi.Char> WOWNERO_SubaddressAccountRow_getAddress(
    ffi.Pointer<ffi.Void> subaddressAccountRow_ptr,
  ) {
    return _WOWNERO_SubaddressAccountRow_getAddress(
      subaddressAccountRow_ptr,
    );
  }

  late final _WOWNERO_SubaddressAccountRow_getAddressPtr = _lookup<
          ffi.NativeFunction<
              ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>>(
      'WOWNERO_SubaddressAccountRow_getAddress');
  late final _WOWNERO_SubaddressAccountRow_getAddress =
      _WOWNERO_SubaddressAccountRow_getAddressPtr.asFunction<
          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>();

  ffi.Pointer<ffi.Char> WOWNERO_SubaddressAccountRow_getLabel(
    ffi.Pointer<ffi.Void> subaddressAccountRow_ptr,
  ) {
    return _WOWNERO_SubaddressAccountRow_getLabel(
      subaddressAccountRow_ptr,
    );
  }

  late final _WOWNERO_SubaddressAccountRow_getLabelPtr = _lookup<
      ffi.NativeFunction<
          ffi.Pointer<ffi.Char> Function(
              ffi.Pointer<ffi.Void>)>>('WOWNERO_SubaddressAccountRow_getLabel');
  late final _WOWNERO_SubaddressAccountRow_getLabel =
      _WOWNERO_SubaddressAccountRow_getLabelPtr.asFunction<
          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>();

  ffi.Pointer<ffi.Char> WOWNERO_SubaddressAccountRow_getBalance(
    ffi.Pointer<ffi.Void> subaddressAccountRow_ptr,
  ) {
    return _WOWNERO_SubaddressAccountRow_getBalance(
      subaddressAccountRow_ptr,
    );
  }

  late final _WOWNERO_SubaddressAccountRow_getBalancePtr = _lookup<
          ffi.NativeFunction<
              ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>>(
      'WOWNERO_SubaddressAccountRow_getBalance');
  late final _WOWNERO_SubaddressAccountRow_getBalance =
      _WOWNERO_SubaddressAccountRow_getBalancePtr.asFunction<
          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>();

  ffi.Pointer<ffi.Char> WOWNERO_SubaddressAccountRow_getUnlockedBalance(
    ffi.Pointer<ffi.Void> subaddressAccountRow_ptr,
  ) {
    return _WOWNERO_SubaddressAccountRow_getUnlockedBalance(
      subaddressAccountRow_ptr,
    );
  }

  late final _WOWNERO_SubaddressAccountRow_getUnlockedBalancePtr = _lookup<
          ffi.NativeFunction<
              ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>>(
      'WOWNERO_SubaddressAccountRow_getUnlockedBalance');
  late final _WOWNERO_SubaddressAccountRow_getUnlockedBalance =
      _WOWNERO_SubaddressAccountRow_getUnlockedBalancePtr.asFunction<
          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>();

  int WOWNERO_SubaddressAccountRow_getRowId(
    ffi.Pointer<ffi.Void> subaddressAccountRow_ptr,
  ) {
    return _WOWNERO_SubaddressAccountRow_getRowId(
      subaddressAccountRow_ptr,
    );
  }

  late final _WOWNERO_SubaddressAccountRow_getRowIdPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(ffi.Pointer<ffi.Void>)>>(
          'WOWNERO_SubaddressAccountRow_getRowId');
  late final _WOWNERO_SubaddressAccountRow_getRowId =
      _WOWNERO_SubaddressAccountRow_getRowIdPtr.asFunction<
          int Function(ffi.Pointer<ffi.Void>)>();

  int WOWNERO_SubaddressAccount_getAll_size(
    ffi.Pointer<ffi.Void> subaddressAccount_ptr,
  ) {
    return _WOWNERO_SubaddressAccount_getAll_size(
      subaddressAccount_ptr,
    );
  }

  late final _WOWNERO_SubaddressAccount_getAll_sizePtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(ffi.Pointer<ffi.Void>)>>(
          'WOWNERO_SubaddressAccount_getAll_size');
  late final _WOWNERO_SubaddressAccount_getAll_size =
      _WOWNERO_SubaddressAccount_getAll_sizePtr.asFunction<
          int Function(ffi.Pointer<ffi.Void>)>();

  ffi.Pointer<ffi.Void> WOWNERO_SubaddressAccount_getAll_byIndex(
    ffi.Pointer<ffi.Void> subaddressAccount_ptr,
    int index,
  ) {
    return _WOWNERO_SubaddressAccount_getAll_byIndex(
      subaddressAccount_ptr,
      index,
    );
  }

  late final _WOWNERO_SubaddressAccount_getAll_byIndexPtr = _lookup<
      ffi.NativeFunction<
          ffi.Pointer<ffi.Void> Function(ffi.Pointer<ffi.Void>,
              ffi.Int)>>('WOWNERO_SubaddressAccount_getAll_byIndex');
  late final _WOWNERO_SubaddressAccount_getAll_byIndex =
      _WOWNERO_SubaddressAccount_getAll_byIndexPtr.asFunction<
          ffi.Pointer<ffi.Void> Function(ffi.Pointer<ffi.Void>, int)>();

  void WOWNERO_SubaddressAccount_addRow(
    ffi.Pointer<ffi.Void> subaddressAccount_ptr,
    ffi.Pointer<ffi.Char> label,
  ) {
    return _WOWNERO_SubaddressAccount_addRow(
      subaddressAccount_ptr,
      label,
    );
  }

  late final _WOWNERO_SubaddressAccount_addRowPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(ffi.Pointer<ffi.Void>,
              ffi.Pointer<ffi.Char>)>>('WOWNERO_SubaddressAccount_addRow');
  late final _WOWNERO_SubaddressAccount_addRow =
      _WOWNERO_SubaddressAccount_addRowPtr.asFunction<
          void Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();

  void WOWNERO_SubaddressAccount_setLabel(
    ffi.Pointer<ffi.Void> subaddressAccount_ptr,
    int accountIndex,
    ffi.Pointer<ffi.Char> label,
  ) {
    return _WOWNERO_SubaddressAccount_setLabel(
      subaddressAccount_ptr,
      accountIndex,
      label,
    );
  }

  late final _WOWNERO_SubaddressAccount_setLabelPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(ffi.Pointer<ffi.Void>, ffi.Uint32,
              ffi.Pointer<ffi.Char>)>>('WOWNERO_SubaddressAccount_setLabel');
  late final _WOWNERO_SubaddressAccount_setLabel =
      _WOWNERO_SubaddressAccount_setLabelPtr.asFunction<
          void Function(ffi.Pointer<ffi.Void>, int, ffi.Pointer<ffi.Char>)>();

  void WOWNERO_SubaddressAccount_refresh(
    ffi.Pointer<ffi.Void> subaddressAccount_ptr,
  ) {
    return _WOWNERO_SubaddressAccount_refresh(
      subaddressAccount_ptr,
    );
  }

  late final _WOWNERO_SubaddressAccount_refreshPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>)>>(
          'WOWNERO_SubaddressAccount_refresh');
  late final _WOWNERO_SubaddressAccount_refresh =
      _WOWNERO_SubaddressAccount_refreshPtr.asFunction<
          void Function(ffi.Pointer<ffi.Void>)>();

  bool WOWNERO_MultisigState_isMultisig(
    ffi.Pointer<ffi.Void> multisigState_ptr,
  ) {
    return _WOWNERO_MultisigState_isMultisig(
      multisigState_ptr,
    );
  }

  late final _WOWNERO_MultisigState_isMultisigPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(ffi.Pointer<ffi.Void>)>>(
          'WOWNERO_MultisigState_isMultisig');
  late final _WOWNERO_MultisigState_isMultisig =
      _WOWNERO_MultisigState_isMultisigPtr.asFunction<
          bool Function(ffi.Pointer<ffi.Void>)>();

  bool WOWNERO_MultisigState_isReady(
    ffi.Pointer<ffi.Void> multisigState_ptr,
  ) {
    return _WOWNERO_MultisigState_isReady(
      multisigState_ptr,
    );
  }

  late final _WOWNERO_MultisigState_isReadyPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(ffi.Pointer<ffi.Void>)>>(
          'WOWNERO_MultisigState_isReady');
  late final _WOWNERO_MultisigState_isReady = _WOWNERO_MultisigState_isReadyPtr
      .asFunction<bool Function(ffi.Pointer<ffi.Void>)>();

  int WOWNERO_MultisigState_threshold(
    ffi.Pointer<ffi.Void> multisigState_ptr,
  ) {
    return _WOWNERO_MultisigState_threshold(
      multisigState_ptr,
    );
  }

  late final _WOWNERO_MultisigState_thresholdPtr =
      _lookup<ffi.NativeFunction<ffi.Uint32 Function(ffi.Pointer<ffi.Void>)>>(
          'WOWNERO_MultisigState_threshold');
  late final _WOWNERO_MultisigState_threshold =
      _WOWNERO_MultisigState_thresholdPtr.asFunction<
          int Function(ffi.Pointer<ffi.Void>)>();

  int WOWNERO_MultisigState_total(
    ffi.Pointer<ffi.Void> multisigState_ptr,
  ) {
    return _WOWNERO_MultisigState_total(
      multisigState_ptr,
    );
  }

  late final _WOWNERO_MultisigState_totalPtr =
      _lookup<ffi.NativeFunction<ffi.Uint32 Function(ffi.Pointer<ffi.Void>)>>(
          'WOWNERO_MultisigState_total');
  late final _WOWNERO_MultisigState_total = _WOWNERO_MultisigState_totalPtr
      .asFunction<int Function(ffi.Pointer<ffi.Void>)>();

  bool WOWNERO_DeviceProgress_progress(
    ffi.Pointer<ffi.Void> deviceProgress_ptr,
  ) {
    return _WOWNERO_DeviceProgress_progress(
      deviceProgress_ptr,
    );
  }

  late final _WOWNERO_DeviceProgress_progressPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(ffi.Pointer<ffi.Void>)>>(
          'WOWNERO_DeviceProgress_progress');
  late final _WOWNERO_DeviceProgress_progress =
      _WOWNERO_DeviceProgress_progressPtr.asFunction<
          bool Function(ffi.Pointer<ffi.Void>)>();

  bool WOWNERO_DeviceProgress_indeterminate(
    ffi.Pointer<ffi.Void> deviceProgress_ptr,
  ) {
    return _WOWNERO_DeviceProgress_indeterminate(
      deviceProgress_ptr,
    );
  }

  late final _WOWNERO_DeviceProgress_indeterminatePtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(ffi.Pointer<ffi.Void>)>>(
          'WOWNERO_DeviceProgress_indeterminate');
  late final _WOWNERO_DeviceProgress_indeterminate =
      _WOWNERO_DeviceProgress_indeterminatePtr.asFunction<
          bool Function(ffi.Pointer<ffi.Void>)>();

  ffi.Pointer<ffi.Char> WOWNERO_Wallet_seed(
    ffi.Pointer<ffi.Void> wallet_ptr,
    ffi.Pointer<ffi.Char> seed_offset,
  ) {
    return _WOWNERO_Wallet_seed(
      wallet_ptr,
      seed_offset,
    );
  }

  late final _WOWNERO_Wallet_seedPtr = _lookup<
      ffi.NativeFunction<
          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>,
              ffi.Pointer<ffi.Char>)>>('WOWNERO_Wallet_seed');
  late final _WOWNERO_Wallet_seed = _WOWNERO_Wallet_seedPtr.asFunction<
      ffi.Pointer<ffi.Char> Function(
          ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();

  ffi.Pointer<ffi.Char> WOWNERO_Wallet_getSeedLanguage(
    ffi.Pointer<ffi.Void> wallet_ptr,
  ) {
    return _WOWNERO_Wallet_getSeedLanguage(
      wallet_ptr,
    );
  }

  late final _WOWNERO_Wallet_getSeedLanguagePtr = _lookup<
      ffi.NativeFunction<
          ffi.Pointer<ffi.Char> Function(
              ffi.Pointer<ffi.Void>)>>('WOWNERO_Wallet_getSeedLanguage');
  late final _WOWNERO_Wallet_getSeedLanguage =
      _WOWNERO_Wallet_getSeedLanguagePtr.asFunction<
          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>();

  void WOWNERO_Wallet_setSeedLanguage(
    ffi.Pointer<ffi.Void> wallet_ptr,
    ffi.Pointer<ffi.Char> arg,
  ) {
    return _WOWNERO_Wallet_setSeedLanguage(
      wallet_ptr,
      arg,
    );
  }

  late final _WOWNERO_Wallet_setSeedLanguagePtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(ffi.Pointer<ffi.Void>,
              ffi.Pointer<ffi.Char>)>>('WOWNERO_Wallet_setSeedLanguage');
  late final _WOWNERO_Wallet_setSeedLanguage =
      _WOWNERO_Wallet_setSeedLanguagePtr.asFunction<
          void Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();

  int WOWNERO_Wallet_status(
    ffi.Pointer<ffi.Void> wallet_ptr,
  ) {
    return _WOWNERO_Wallet_status(
      wallet_ptr,
    );
  }

  late final _WOWNERO_Wallet_statusPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(ffi.Pointer<ffi.Void>)>>(
          'WOWNERO_Wallet_status');
  late final _WOWNERO_Wallet_status = _WOWNERO_Wallet_statusPtr.asFunction<
      int Function(ffi.Pointer<ffi.Void>)>();

  ffi.Pointer<ffi.Char> WOWNERO_Wallet_errorString(
    ffi.Pointer<ffi.Void> wallet_ptr,
  ) {
    return _WOWNERO_Wallet_errorString(
      wallet_ptr,
    );
  }

  late final _WOWNERO_Wallet_errorStringPtr = _lookup<
      ffi.NativeFunction<
          ffi.Pointer<ffi.Char> Function(
              ffi.Pointer<ffi.Void>)>>('WOWNERO_Wallet_errorString');
  late final _WOWNERO_Wallet_errorString = _WOWNERO_Wallet_errorStringPtr
      .asFunction<ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>();

  bool WOWNERO_Wallet_setPassword(
    ffi.Pointer<ffi.Void> wallet_ptr,
    ffi.Pointer<ffi.Char> password,
  ) {
    return _WOWNERO_Wallet_setPassword(
      wallet_ptr,
      password,
    );
  }

  late final _WOWNERO_Wallet_setPasswordPtr = _lookup<
      ffi.NativeFunction<
          ffi.Bool Function(ffi.Pointer<ffi.Void>,
              ffi.Pointer<ffi.Char>)>>('WOWNERO_Wallet_setPassword');
  late final _WOWNERO_Wallet_setPassword =
      _WOWNERO_Wallet_setPasswordPtr.asFunction<
          bool Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();

  ffi.Pointer<ffi.Char> WOWNERO_Wallet_getPassword(
    ffi.Pointer<ffi.Void> wallet_ptr,
  ) {
    return _WOWNERO_Wallet_getPassword(
      wallet_ptr,
    );
  }

  late final _WOWNERO_Wallet_getPasswordPtr = _lookup<
      ffi.NativeFunction<
          ffi.Pointer<ffi.Char> Function(
              ffi.Pointer<ffi.Void>)>>('WOWNERO_Wallet_getPassword');
  late final _WOWNERO_Wallet_getPassword = _WOWNERO_Wallet_getPasswordPtr
      .asFunction<ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>();

  bool WOWNERO_Wallet_setDevicePin(
    ffi.Pointer<ffi.Void> wallet_ptr,
    ffi.Pointer<ffi.Char> pin,
  ) {
    return _WOWNERO_Wallet_setDevicePin(
      wallet_ptr,
      pin,
    );
  }

  late final _WOWNERO_Wallet_setDevicePinPtr = _lookup<
      ffi.NativeFunction<
          ffi.Bool Function(ffi.Pointer<ffi.Void>,
              ffi.Pointer<ffi.Char>)>>('WOWNERO_Wallet_setDevicePin');
  late final _WOWNERO_Wallet_setDevicePin =
      _WOWNERO_Wallet_setDevicePinPtr.asFunction<
          bool Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();

  bool WOWNERO_Wallet_setDevicePassphrase(
    ffi.Pointer<ffi.Void> wallet_ptr,
    ffi.Pointer<ffi.Char> passphrase,
  ) {
    return _WOWNERO_Wallet_setDevicePassphrase(
      wallet_ptr,
      passphrase,
    );
  }

  late final _WOWNERO_Wallet_setDevicePassphrasePtr = _lookup<
      ffi.NativeFunction<
          ffi.Bool Function(ffi.Pointer<ffi.Void>,
              ffi.Pointer<ffi.Char>)>>('WOWNERO_Wallet_setDevicePassphrase');
  late final _WOWNERO_Wallet_setDevicePassphrase =
      _WOWNERO_Wallet_setDevicePassphrasePtr.asFunction<
          bool Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();

  ffi.Pointer<ffi.Char> WOWNERO_Wallet_address(
    ffi.Pointer<ffi.Void> wallet_ptr,
    int accountIndex,
    int addressIndex,
  ) {
    return _WOWNERO_Wallet_address(
      wallet_ptr,
      accountIndex,
      addressIndex,
    );
  }

  late final _WOWNERO_Wallet_addressPtr = _lookup<
      ffi.NativeFunction<
          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>, ffi.Uint64,
              ffi.Uint64)>>('WOWNERO_Wallet_address');
  late final _WOWNERO_Wallet_address = _WOWNERO_Wallet_addressPtr.asFunction<
      ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>, int, int)>();

  ffi.Pointer<ffi.Char> WOWNERO_Wallet_path(
    ffi.Pointer<ffi.Void> wallet_ptr,
  ) {
    return _WOWNERO_Wallet_path(
      wallet_ptr,
    );
  }

  late final _WOWNERO_Wallet_pathPtr = _lookup<
      ffi.NativeFunction<
          ffi.Pointer<ffi.Char> Function(
              ffi.Pointer<ffi.Void>)>>('WOWNERO_Wallet_path');
  late final _WOWNERO_Wallet_path = _WOWNERO_Wallet_pathPtr.asFunction<
      ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>();

  int WOWNERO_Wallet_nettype(
    ffi.Pointer<ffi.Void> wallet_ptr,
  ) {
    return _WOWNERO_Wallet_nettype(
      wallet_ptr,
    );
  }

  late final _WOWNERO_Wallet_nettypePtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(ffi.Pointer<ffi.Void>)>>(
          'WOWNERO_Wallet_nettype');
  late final _WOWNERO_Wallet_nettype = _WOWNERO_Wallet_nettypePtr.asFunction<
      int Function(ffi.Pointer<ffi.Void>)>();

  int WOWNERO_Wallet_useForkRules(
    ffi.Pointer<ffi.Void> wallet_ptr,
    int version,
    int early_blocks,
  ) {
    return _WOWNERO_Wallet_useForkRules(
      wallet_ptr,
      version,
      early_blocks,
    );
  }

  late final _WOWNERO_Wallet_useForkRulesPtr = _lookup<
      ffi.NativeFunction<
          ffi.Uint8 Function(ffi.Pointer<ffi.Void>, ffi.Uint8,
              ffi.Int64)>>('WOWNERO_Wallet_useForkRules');
  late final _WOWNERO_Wallet_useForkRules = _WOWNERO_Wallet_useForkRulesPtr
      .asFunction<int Function(ffi.Pointer<ffi.Void>, int, int)>();

  ffi.Pointer<ffi.Char> WOWNERO_Wallet_integratedAddress(
    ffi.Pointer<ffi.Void> wallet_ptr,
    ffi.Pointer<ffi.Char> payment_id,
  ) {
    return _WOWNERO_Wallet_integratedAddress(
      wallet_ptr,
      payment_id,
    );
  }

  late final _WOWNERO_Wallet_integratedAddressPtr = _lookup<
      ffi.NativeFunction<
          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>,
              ffi.Pointer<ffi.Char>)>>('WOWNERO_Wallet_integratedAddress');
  late final _WOWNERO_Wallet_integratedAddress =
      _WOWNERO_Wallet_integratedAddressPtr.asFunction<
          ffi.Pointer<ffi.Char> Function(
              ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();

  ffi.Pointer<ffi.Char> WOWNERO_Wallet_secretViewKey(
    ffi.Pointer<ffi.Void> wallet_ptr,
  ) {
    return _WOWNERO_Wallet_secretViewKey(
      wallet_ptr,
    );
  }

  late final _WOWNERO_Wallet_secretViewKeyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Pointer<ffi.Char> Function(
              ffi.Pointer<ffi.Void>)>>('WOWNERO_Wallet_secretViewKey');
  late final _WOWNERO_Wallet_secretViewKey = _WOWNERO_Wallet_secretViewKeyPtr
      .asFunction<ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>();

  ffi.Pointer<ffi.Char> WOWNERO_Wallet_publicViewKey(
    ffi.Pointer<ffi.Void> wallet_ptr,
  ) {
    return _WOWNERO_Wallet_publicViewKey(
      wallet_ptr,
    );
  }

  late final _WOWNERO_Wallet_publicViewKeyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Pointer<ffi.Char> Function(
              ffi.Pointer<ffi.Void>)>>('WOWNERO_Wallet_publicViewKey');
  late final _WOWNERO_Wallet_publicViewKey = _WOWNERO_Wallet_publicViewKeyPtr
      .asFunction<ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>();

  ffi.Pointer<ffi.Char> WOWNERO_Wallet_secretSpendKey(
    ffi.Pointer<ffi.Void> wallet_ptr,
  ) {
    return _WOWNERO_Wallet_secretSpendKey(
      wallet_ptr,
    );
  }

  late final _WOWNERO_Wallet_secretSpendKeyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Pointer<ffi.Char> Function(
              ffi.Pointer<ffi.Void>)>>('WOWNERO_Wallet_secretSpendKey');
  late final _WOWNERO_Wallet_secretSpendKey = _WOWNERO_Wallet_secretSpendKeyPtr
      .asFunction<ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>();

  ffi.Pointer<ffi.Char> WOWNERO_Wallet_publicSpendKey(
    ffi.Pointer<ffi.Void> wallet_ptr,
  ) {
    return _WOWNERO_Wallet_publicSpendKey(
      wallet_ptr,
    );
  }

  late final _WOWNERO_Wallet_publicSpendKeyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Pointer<ffi.Char> Function(
              ffi.Pointer<ffi.Void>)>>('WOWNERO_Wallet_publicSpendKey');
  late final _WOWNERO_Wallet_publicSpendKey = _WOWNERO_Wallet_publicSpendKeyPtr
      .asFunction<ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>();

  ffi.Pointer<ffi.Char> WOWNERO_Wallet_publicMultisigSignerKey(
    ffi.Pointer<ffi.Void> wallet_ptr,
  ) {
    return _WOWNERO_Wallet_publicMultisigSignerKey(
      wallet_ptr,
    );
  }

  late final _WOWNERO_Wallet_publicMultisigSignerKeyPtr = _lookup<
          ffi.NativeFunction<
              ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>>(
      'WOWNERO_Wallet_publicMultisigSignerKey');
  late final _WOWNERO_Wallet_publicMultisigSignerKey =
      _WOWNERO_Wallet_publicMultisigSignerKeyPtr.asFunction<
          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>();

  void WOWNERO_Wallet_stop(
    ffi.Pointer<ffi.Void> wallet_ptr,
  ) {
    return _WOWNERO_Wallet_stop(
      wallet_ptr,
    );
  }

  late final _WOWNERO_Wallet_stopPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>)>>(
          'WOWNERO_Wallet_stop');
  late final _WOWNERO_Wallet_stop = _WOWNERO_Wallet_stopPtr.asFunction<
      void Function(ffi.Pointer<ffi.Void>)>();

  bool WOWNERO_Wallet_store(
    ffi.Pointer<ffi.Void> wallet_ptr,
    ffi.Pointer<ffi.Char> path,
  ) {
    return _WOWNERO_Wallet_store(
      wallet_ptr,
      path,
    );
  }

  late final _WOWNERO_Wallet_storePtr = _lookup<
      ffi.NativeFunction<
          ffi.Bool Function(ffi.Pointer<ffi.Void>,
              ffi.Pointer<ffi.Char>)>>('WOWNERO_Wallet_store');
  late final _WOWNERO_Wallet_store = _WOWNERO_Wallet_storePtr.asFunction<
      bool Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();

  ffi.Pointer<ffi.Char> WOWNERO_Wallet_filename(
    ffi.Pointer<ffi.Void> wallet_ptr,
  ) {
    return _WOWNERO_Wallet_filename(
      wallet_ptr,
    );
  }

  late final _WOWNERO_Wallet_filenamePtr = _lookup<
      ffi.NativeFunction<
          ffi.Pointer<ffi.Char> Function(
              ffi.Pointer<ffi.Void>)>>('WOWNERO_Wallet_filename');
  late final _WOWNERO_Wallet_filename = _WOWNERO_Wallet_filenamePtr.asFunction<
      ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>();

  ffi.Pointer<ffi.Char> WOWNERO_Wallet_keysFilename(
    ffi.Pointer<ffi.Void> wallet_ptr,
  ) {
    return _WOWNERO_Wallet_keysFilename(
      wallet_ptr,
    );
  }

  late final _WOWNERO_Wallet_keysFilenamePtr = _lookup<
      ffi.NativeFunction<
          ffi.Pointer<ffi.Char> Function(
              ffi.Pointer<ffi.Void>)>>('WOWNERO_Wallet_keysFilename');
  late final _WOWNERO_Wallet_keysFilename = _WOWNERO_Wallet_keysFilenamePtr
      .asFunction<ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>();

  bool WOWNERO_Wallet_init(
    ffi.Pointer<ffi.Void> wallet_ptr,
    ffi.Pointer<ffi.Char> daemon_address,
    int upper_transaction_size_limit,
    ffi.Pointer<ffi.Char> daemon_username,
    ffi.Pointer<ffi.Char> daemon_password,
    bool use_ssl,
    bool lightWallet,
    ffi.Pointer<ffi.Char> proxy_address,
  ) {
    return _WOWNERO_Wallet_init(
      wallet_ptr,
      daemon_address,
      upper_transaction_size_limit,
      daemon_username,
      daemon_password,
      use_ssl,
      lightWallet,
      proxy_address,
    );
  }

  late final _WOWNERO_Wallet_initPtr = _lookup<
      ffi.NativeFunction<
          ffi.Bool Function(
              ffi.Pointer<ffi.Void>,
              ffi.Pointer<ffi.Char>,
              ffi.Uint64,
              ffi.Pointer<ffi.Char>,
              ffi.Pointer<ffi.Char>,
              ffi.Bool,
              ffi.Bool,
              ffi.Pointer<ffi.Char>)>>('WOWNERO_Wallet_init');
  late final _WOWNERO_Wallet_init = _WOWNERO_Wallet_initPtr.asFunction<
      bool Function(
          ffi.Pointer<ffi.Void>,
          ffi.Pointer<ffi.Char>,
          int,
          ffi.Pointer<ffi.Char>,
          ffi.Pointer<ffi.Char>,
          bool,
          bool,
          ffi.Pointer<ffi.Char>)>();

  bool WOWNERO_Wallet_createWatchOnly(
    ffi.Pointer<ffi.Void> wallet_ptr,
    ffi.Pointer<ffi.Char> path,
    ffi.Pointer<ffi.Char> password,
    ffi.Pointer<ffi.Char> language,
  ) {
    return _WOWNERO_Wallet_createWatchOnly(
      wallet_ptr,
      path,
      password,
      language,
    );
  }

  late final _WOWNERO_Wallet_createWatchOnlyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Bool Function(
              ffi.Pointer<ffi.Void>,
              ffi.Pointer<ffi.Char>,
              ffi.Pointer<ffi.Char>,
              ffi.Pointer<ffi.Char>)>>('WOWNERO_Wallet_createWatchOnly');
  late final _WOWNERO_Wallet_createWatchOnly =
      _WOWNERO_Wallet_createWatchOnlyPtr.asFunction<
          bool Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>,
              ffi.Pointer<ffi.Char>, ffi.Pointer<ffi.Char>)>();

  void WOWNERO_Wallet_setRefreshFromBlockHeight(
    ffi.Pointer<ffi.Void> wallet_ptr,
    int refresh_from_block_height,
  ) {
    return _WOWNERO_Wallet_setRefreshFromBlockHeight(
      wallet_ptr,
      refresh_from_block_height,
    );
  }

  late final _WOWNERO_Wallet_setRefreshFromBlockHeightPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(ffi.Pointer<ffi.Void>,
              ffi.Uint64)>>('WOWNERO_Wallet_setRefreshFromBlockHeight');
  late final _WOWNERO_Wallet_setRefreshFromBlockHeight =
      _WOWNERO_Wallet_setRefreshFromBlockHeightPtr.asFunction<
          void Function(ffi.Pointer<ffi.Void>, int)>();

  int WOWNERO_Wallet_getRefreshFromBlockHeight(
    ffi.Pointer<ffi.Void> wallet_ptr,
  ) {
    return _WOWNERO_Wallet_getRefreshFromBlockHeight(
      wallet_ptr,
    );
  }

  late final _WOWNERO_Wallet_getRefreshFromBlockHeightPtr =
      _lookup<ffi.NativeFunction<ffi.Uint64 Function(ffi.Pointer<ffi.Void>)>>(
          'WOWNERO_Wallet_getRefreshFromBlockHeight');
  late final _WOWNERO_Wallet_getRefreshFromBlockHeight =
      _WOWNERO_Wallet_getRefreshFromBlockHeightPtr.asFunction<
          int Function(ffi.Pointer<ffi.Void>)>();

  void WOWNERO_Wallet_setRecoveringFromSeed(
    ffi.Pointer<ffi.Void> wallet_ptr,
    bool recoveringFromSeed,
  ) {
    return _WOWNERO_Wallet_setRecoveringFromSeed(
      wallet_ptr,
      recoveringFromSeed,
    );
  }

  late final _WOWNERO_Wallet_setRecoveringFromSeedPtr = _lookup<
          ffi
          .NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>, ffi.Bool)>>(
      'WOWNERO_Wallet_setRecoveringFromSeed');
  late final _WOWNERO_Wallet_setRecoveringFromSeed =
      _WOWNERO_Wallet_setRecoveringFromSeedPtr.asFunction<
          void Function(ffi.Pointer<ffi.Void>, bool)>();

  void WOWNERO_Wallet_setRecoveringFromDevice(
    ffi.Pointer<ffi.Void> wallet_ptr,
    bool recoveringFromDevice,
  ) {
    return _WOWNERO_Wallet_setRecoveringFromDevice(
      wallet_ptr,
      recoveringFromDevice,
    );
  }

  late final _WOWNERO_Wallet_setRecoveringFromDevicePtr = _lookup<
          ffi
          .NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>, ffi.Bool)>>(
      'WOWNERO_Wallet_setRecoveringFromDevice');
  late final _WOWNERO_Wallet_setRecoveringFromDevice =
      _WOWNERO_Wallet_setRecoveringFromDevicePtr.asFunction<
          void Function(ffi.Pointer<ffi.Void>, bool)>();

  void WOWNERO_Wallet_setSubaddressLookahead(
    ffi.Pointer<ffi.Void> wallet_ptr,
    int major,
    int minor,
  ) {
    return _WOWNERO_Wallet_setSubaddressLookahead(
      wallet_ptr,
      major,
      minor,
    );
  }

  late final _WOWNERO_Wallet_setSubaddressLookaheadPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(ffi.Pointer<ffi.Void>, ffi.Uint32,
              ffi.Uint32)>>('WOWNERO_Wallet_setSubaddressLookahead');
  late final _WOWNERO_Wallet_setSubaddressLookahead =
      _WOWNERO_Wallet_setSubaddressLookaheadPtr.asFunction<
          void Function(ffi.Pointer<ffi.Void>, int, int)>();

  bool WOWNERO_Wallet_connectToDaemon(
    ffi.Pointer<ffi.Void> wallet_ptr,
  ) {
    return _WOWNERO_Wallet_connectToDaemon(
      wallet_ptr,
    );
  }

  late final _WOWNERO_Wallet_connectToDaemonPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(ffi.Pointer<ffi.Void>)>>(
          'WOWNERO_Wallet_connectToDaemon');
  late final _WOWNERO_Wallet_connectToDaemon =
      _WOWNERO_Wallet_connectToDaemonPtr.asFunction<
          bool Function(ffi.Pointer<ffi.Void>)>();

  int WOWNERO_Wallet_connected(
    ffi.Pointer<ffi.Void> wallet_ptr,
  ) {
    return _WOWNERO_Wallet_connected(
      wallet_ptr,
    );
  }

  late final _WOWNERO_Wallet_connectedPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(ffi.Pointer<ffi.Void>)>>(
          'WOWNERO_Wallet_connected');
  late final _WOWNERO_Wallet_connected = _WOWNERO_Wallet_connectedPtr
      .asFunction<int Function(ffi.Pointer<ffi.Void>)>();

  void WOWNERO_Wallet_setTrustedDaemon(
    ffi.Pointer<ffi.Void> wallet_ptr,
    bool arg,
  ) {
    return _WOWNERO_Wallet_setTrustedDaemon(
      wallet_ptr,
      arg,
    );
  }

  late final _WOWNERO_Wallet_setTrustedDaemonPtr = _lookup<
          ffi
          .NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>, ffi.Bool)>>(
      'WOWNERO_Wallet_setTrustedDaemon');
  late final _WOWNERO_Wallet_setTrustedDaemon =
      _WOWNERO_Wallet_setTrustedDaemonPtr.asFunction<
          void Function(ffi.Pointer<ffi.Void>, bool)>();

  bool WOWNERO_Wallet_trustedDaemon(
    ffi.Pointer<ffi.Void> wallet_ptr,
  ) {
    return _WOWNERO_Wallet_trustedDaemon(
      wallet_ptr,
    );
  }

  late final _WOWNERO_Wallet_trustedDaemonPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(ffi.Pointer<ffi.Void>)>>(
          'WOWNERO_Wallet_trustedDaemon');
  late final _WOWNERO_Wallet_trustedDaemon = _WOWNERO_Wallet_trustedDaemonPtr
      .asFunction<bool Function(ffi.Pointer<ffi.Void>)>();

  bool WOWNERO_Wallet_setProxy(
    ffi.Pointer<ffi.Void> wallet_ptr,
    ffi.Pointer<ffi.Char> address,
  ) {
    return _WOWNERO_Wallet_setProxy(
      wallet_ptr,
      address,
    );
  }

  late final _WOWNERO_Wallet_setProxyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Bool Function(ffi.Pointer<ffi.Void>,
              ffi.Pointer<ffi.Char>)>>('WOWNERO_Wallet_setProxy');
  late final _WOWNERO_Wallet_setProxy = _WOWNERO_Wallet_setProxyPtr.asFunction<
      bool Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();

  int WOWNERO_Wallet_balance(
    ffi.Pointer<ffi.Void> wallet_ptr,
    int accountIndex,
  ) {
    return _WOWNERO_Wallet_balance(
      wallet_ptr,
      accountIndex,
    );
  }

  late final _WOWNERO_Wallet_balancePtr = _lookup<
      ffi.NativeFunction<
          ffi.Uint64 Function(
              ffi.Pointer<ffi.Void>, ffi.Uint32)>>('WOWNERO_Wallet_balance');
  late final _WOWNERO_Wallet_balance = _WOWNERO_Wallet_balancePtr.asFunction<
      int Function(ffi.Pointer<ffi.Void>, int)>();

  int WOWNERO_Wallet_unlockedBalance(
    ffi.Pointer<ffi.Void> wallet_ptr,
    int accountIndex,
  ) {
    return _WOWNERO_Wallet_unlockedBalance(
      wallet_ptr,
      accountIndex,
    );
  }

  late final _WOWNERO_Wallet_unlockedBalancePtr = _lookup<
      ffi.NativeFunction<
          ffi.Uint64 Function(ffi.Pointer<ffi.Void>,
              ffi.Uint32)>>('WOWNERO_Wallet_unlockedBalance');
  late final _WOWNERO_Wallet_unlockedBalance =
      _WOWNERO_Wallet_unlockedBalancePtr.asFunction<
          int Function(ffi.Pointer<ffi.Void>, int)>();

  int WOWNERO_Wallet_viewOnlyBalance(
    ffi.Pointer<ffi.Void> wallet_ptr,
    int accountIndex,
  ) {
    return _WOWNERO_Wallet_viewOnlyBalance(
      wallet_ptr,
      accountIndex,
    );
  }

  late final _WOWNERO_Wallet_viewOnlyBalancePtr = _lookup<
      ffi.NativeFunction<
          ffi.Uint64 Function(ffi.Pointer<ffi.Void>,
              ffi.Uint32)>>('WOWNERO_Wallet_viewOnlyBalance');
  late final _WOWNERO_Wallet_viewOnlyBalance =
      _WOWNERO_Wallet_viewOnlyBalancePtr.asFunction<
          int Function(ffi.Pointer<ffi.Void>, int)>();

  bool WOWNERO_Wallet_watchOnly(
    ffi.Pointer<ffi.Void> wallet_ptr,
  ) {
    return _WOWNERO_Wallet_watchOnly(
      wallet_ptr,
    );
  }

  late final _WOWNERO_Wallet_watchOnlyPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(ffi.Pointer<ffi.Void>)>>(
          'WOWNERO_Wallet_watchOnly');
  late final _WOWNERO_Wallet_watchOnly = _WOWNERO_Wallet_watchOnlyPtr
      .asFunction<bool Function(ffi.Pointer<ffi.Void>)>();

  bool WOWNERO_Wallet_isDeterministic(
    ffi.Pointer<ffi.Void> wallet_ptr,
  ) {
    return _WOWNERO_Wallet_isDeterministic(
      wallet_ptr,
    );
  }

  late final _WOWNERO_Wallet_isDeterministicPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(ffi.Pointer<ffi.Void>)>>(
          'WOWNERO_Wallet_isDeterministic');
  late final _WOWNERO_Wallet_isDeterministic =
      _WOWNERO_Wallet_isDeterministicPtr.asFunction<
          bool Function(ffi.Pointer<ffi.Void>)>();

  int WOWNERO_Wallet_blockChainHeight(
    ffi.Pointer<ffi.Void> wallet_ptr,
  ) {
    return _WOWNERO_Wallet_blockChainHeight(
      wallet_ptr,
    );
  }

  late final _WOWNERO_Wallet_blockChainHeightPtr =
      _lookup<ffi.NativeFunction<ffi.Uint64 Function(ffi.Pointer<ffi.Void>)>>(
          'WOWNERO_Wallet_blockChainHeight');
  late final _WOWNERO_Wallet_blockChainHeight =
      _WOWNERO_Wallet_blockChainHeightPtr.asFunction<
          int Function(ffi.Pointer<ffi.Void>)>();

  int WOWNERO_Wallet_approximateBlockChainHeight(
    ffi.Pointer<ffi.Void> wallet_ptr,
  ) {
    return _WOWNERO_Wallet_approximateBlockChainHeight(
      wallet_ptr,
    );
  }

  late final _WOWNERO_Wallet_approximateBlockChainHeightPtr =
      _lookup<ffi.NativeFunction<ffi.Uint64 Function(ffi.Pointer<ffi.Void>)>>(
          'WOWNERO_Wallet_approximateBlockChainHeight');
  late final _WOWNERO_Wallet_approximateBlockChainHeight =
      _WOWNERO_Wallet_approximateBlockChainHeightPtr.asFunction<
          int Function(ffi.Pointer<ffi.Void>)>();

  int WOWNERO_Wallet_estimateBlockChainHeight(
    ffi.Pointer<ffi.Void> wallet_ptr,
  ) {
    return _WOWNERO_Wallet_estimateBlockChainHeight(
      wallet_ptr,
    );
  }

  late final _WOWNERO_Wallet_estimateBlockChainHeightPtr =
      _lookup<ffi.NativeFunction<ffi.Uint64 Function(ffi.Pointer<ffi.Void>)>>(
          'WOWNERO_Wallet_estimateBlockChainHeight');
  late final _WOWNERO_Wallet_estimateBlockChainHeight =
      _WOWNERO_Wallet_estimateBlockChainHeightPtr.asFunction<
          int Function(ffi.Pointer<ffi.Void>)>();

  int WOWNERO_Wallet_daemonBlockChainHeight(
    ffi.Pointer<ffi.Void> wallet_ptr,
  ) {
    return _WOWNERO_Wallet_daemonBlockChainHeight(
      wallet_ptr,
    );
  }

  late final _WOWNERO_Wallet_daemonBlockChainHeightPtr =
      _lookup<ffi.NativeFunction<ffi.Uint64 Function(ffi.Pointer<ffi.Void>)>>(
          'WOWNERO_Wallet_daemonBlockChainHeight');
  late final _WOWNERO_Wallet_daemonBlockChainHeight =
      _WOWNERO_Wallet_daemonBlockChainHeightPtr.asFunction<
          int Function(ffi.Pointer<ffi.Void>)>();

  int WOWNERO_Wallet_daemonBlockChainHeight_cached(
    ffi.Pointer<ffi.Void> wallet_ptr,
  ) {
    return _WOWNERO_Wallet_daemonBlockChainHeight_cached(
      wallet_ptr,
    );
  }

  late final _WOWNERO_Wallet_daemonBlockChainHeight_cachedPtr =
      _lookup<ffi.NativeFunction<ffi.Uint64 Function(ffi.Pointer<ffi.Void>)>>(
          'WOWNERO_Wallet_daemonBlockChainHeight_cached');
  late final _WOWNERO_Wallet_daemonBlockChainHeight_cached =
      _WOWNERO_Wallet_daemonBlockChainHeight_cachedPtr.asFunction<
          int Function(ffi.Pointer<ffi.Void>)>();

  void WOWNERO_Wallet_daemonBlockChainHeight_runThread(
    ffi.Pointer<ffi.Void> wallet_ptr,
    int seconds,
  ) {
    return _WOWNERO_Wallet_daemonBlockChainHeight_runThread(
      wallet_ptr,
      seconds,
    );
  }

  late final _WOWNERO_Wallet_daemonBlockChainHeight_runThreadPtr = _lookup<
          ffi
          .NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>, ffi.Int)>>(
      'WOWNERO_Wallet_daemonBlockChainHeight_runThread');
  late final _WOWNERO_Wallet_daemonBlockChainHeight_runThread =
      _WOWNERO_Wallet_daemonBlockChainHeight_runThreadPtr.asFunction<
          void Function(ffi.Pointer<ffi.Void>, int)>();

  int WOWNERO_Wallet_daemonBlockChainTargetHeight(
    ffi.Pointer<ffi.Void> wallet_ptr,
  ) {
    return _WOWNERO_Wallet_daemonBlockChainTargetHeight(
      wallet_ptr,
    );
  }

  late final _WOWNERO_Wallet_daemonBlockChainTargetHeightPtr =
      _lookup<ffi.NativeFunction<ffi.Uint64 Function(ffi.Pointer<ffi.Void>)>>(
          'WOWNERO_Wallet_daemonBlockChainTargetHeight');
  late final _WOWNERO_Wallet_daemonBlockChainTargetHeight =
      _WOWNERO_Wallet_daemonBlockChainTargetHeightPtr.asFunction<
          int Function(ffi.Pointer<ffi.Void>)>();

  bool WOWNERO_Wallet_synchronized(
    ffi.Pointer<ffi.Void> wallet_ptr,
  ) {
    return _WOWNERO_Wallet_synchronized(
      wallet_ptr,
    );
  }

  late final _WOWNERO_Wallet_synchronizedPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(ffi.Pointer<ffi.Void>)>>(
          'WOWNERO_Wallet_synchronized');
  late final _WOWNERO_Wallet_synchronized = _WOWNERO_Wallet_synchronizedPtr
      .asFunction<bool Function(ffi.Pointer<ffi.Void>)>();

  ffi.Pointer<ffi.Char> WOWNERO_Wallet_displayAmount(
    int amount,
  ) {
    return _WOWNERO_Wallet_displayAmount(
      amount,
    );
  }

  late final _WOWNERO_Wallet_displayAmountPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Char> Function(ffi.Uint64)>>(
          'WOWNERO_Wallet_displayAmount');
  late final _WOWNERO_Wallet_displayAmount = _WOWNERO_Wallet_displayAmountPtr
      .asFunction<ffi.Pointer<ffi.Char> Function(int)>();

  int WOWNERO_Wallet_amountFromString(
    ffi.Pointer<ffi.Char> amount,
  ) {
    return _WOWNERO_Wallet_amountFromString(
      amount,
    );
  }

  late final _WOWNERO_Wallet_amountFromStringPtr =
      _lookup<ffi.NativeFunction<ffi.Uint64 Function(ffi.Pointer<ffi.Char>)>>(
          'WOWNERO_Wallet_amountFromString');
  late final _WOWNERO_Wallet_amountFromString =
      _WOWNERO_Wallet_amountFromStringPtr.asFunction<
          int Function(ffi.Pointer<ffi.Char>)>();

  int WOWNERO_Wallet_amountFromDouble(
    double amount,
  ) {
    return _WOWNERO_Wallet_amountFromDouble(
      amount,
    );
  }

  late final _WOWNERO_Wallet_amountFromDoublePtr =
      _lookup<ffi.NativeFunction<ffi.Uint64 Function(ffi.Double)>>(
          'WOWNERO_Wallet_amountFromDouble');
  late final _WOWNERO_Wallet_amountFromDouble =
      _WOWNERO_Wallet_amountFromDoublePtr.asFunction<int Function(double)>();

  ffi.Pointer<ffi.Char> WOWNERO_Wallet_genPaymentId() {
    return _WOWNERO_Wallet_genPaymentId();
  }

  late final _WOWNERO_Wallet_genPaymentIdPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Char> Function()>>(
          'WOWNERO_Wallet_genPaymentId');
  late final _WOWNERO_Wallet_genPaymentId = _WOWNERO_Wallet_genPaymentIdPtr
      .asFunction<ffi.Pointer<ffi.Char> Function()>();

  bool WOWNERO_Wallet_paymentIdValid(
    ffi.Pointer<ffi.Char> paiment_id,
  ) {
    return _WOWNERO_Wallet_paymentIdValid(
      paiment_id,
    );
  }

  late final _WOWNERO_Wallet_paymentIdValidPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(ffi.Pointer<ffi.Char>)>>(
          'WOWNERO_Wallet_paymentIdValid');
  late final _WOWNERO_Wallet_paymentIdValid = _WOWNERO_Wallet_paymentIdValidPtr
      .asFunction<bool Function(ffi.Pointer<ffi.Char>)>();

  bool WOWNERO_Wallet_addressValid(
    ffi.Pointer<ffi.Char> str,
    int nettype,
  ) {
    return _WOWNERO_Wallet_addressValid(
      str,
      nettype,
    );
  }

  late final _WOWNERO_Wallet_addressValidPtr = _lookup<
          ffi
          .NativeFunction<ffi.Bool Function(ffi.Pointer<ffi.Char>, ffi.Int)>>(
      'WOWNERO_Wallet_addressValid');
  late final _WOWNERO_Wallet_addressValid = _WOWNERO_Wallet_addressValidPtr
      .asFunction<bool Function(ffi.Pointer<ffi.Char>, int)>();

  bool WOWNERO_Wallet_keyValid(
    ffi.Pointer<ffi.Char> secret_key_string,
    ffi.Pointer<ffi.Char> address_string,
    bool isViewKey,
    int nettype,
  ) {
    return _WOWNERO_Wallet_keyValid(
      secret_key_string,
      address_string,
      isViewKey,
      nettype,
    );
  }

  late final _WOWNERO_Wallet_keyValidPtr = _lookup<
      ffi.NativeFunction<
          ffi.Bool Function(ffi.Pointer<ffi.Char>, ffi.Pointer<ffi.Char>,
              ffi.Bool, ffi.Int)>>('WOWNERO_Wallet_keyValid');
  late final _WOWNERO_Wallet_keyValid = _WOWNERO_Wallet_keyValidPtr.asFunction<
      bool Function(ffi.Pointer<ffi.Char>, ffi.Pointer<ffi.Char>, bool, int)>();

  ffi.Pointer<ffi.Char> WOWNERO_Wallet_keyValid_error(
    ffi.Pointer<ffi.Char> secret_key_string,
    ffi.Pointer<ffi.Char> address_string,
    bool isViewKey,
    int nettype,
  ) {
    return _WOWNERO_Wallet_keyValid_error(
      secret_key_string,
      address_string,
      isViewKey,
      nettype,
    );
  }

  late final _WOWNERO_Wallet_keyValid_errorPtr = _lookup<
      ffi.NativeFunction<
          ffi.Pointer<ffi.Char> Function(
              ffi.Pointer<ffi.Char>,
              ffi.Pointer<ffi.Char>,
              ffi.Bool,
              ffi.Int)>>('WOWNERO_Wallet_keyValid_error');
  late final _WOWNERO_Wallet_keyValid_error =
      _WOWNERO_Wallet_keyValid_errorPtr.asFunction<
          ffi.Pointer<ffi.Char> Function(
              ffi.Pointer<ffi.Char>, ffi.Pointer<ffi.Char>, bool, int)>();

  ffi.Pointer<ffi.Char> WOWNERO_Wallet_paymentIdFromAddress(
    ffi.Pointer<ffi.Char> strarg,
    int nettype,
  ) {
    return _WOWNERO_Wallet_paymentIdFromAddress(
      strarg,
      nettype,
    );
  }

  late final _WOWNERO_Wallet_paymentIdFromAddressPtr = _lookup<
      ffi.NativeFunction<
          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Char>,
              ffi.Int)>>('WOWNERO_Wallet_paymentIdFromAddress');
  late final _WOWNERO_Wallet_paymentIdFromAddress =
      _WOWNERO_Wallet_paymentIdFromAddressPtr.asFunction<
          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Char>, int)>();

  int WOWNERO_Wallet_maximumAllowedAmount() {
    return _WOWNERO_Wallet_maximumAllowedAmount();
  }

  late final _WOWNERO_Wallet_maximumAllowedAmountPtr =
      _lookup<ffi.NativeFunction<ffi.Uint64 Function()>>(
          'WOWNERO_Wallet_maximumAllowedAmount');
  late final _WOWNERO_Wallet_maximumAllowedAmount =
      _WOWNERO_Wallet_maximumAllowedAmountPtr.asFunction<int Function()>();

  void WOWNERO_Wallet_init3(
    ffi.Pointer<ffi.Void> wallet_ptr,
    ffi.Pointer<ffi.Char> argv0,
    ffi.Pointer<ffi.Char> default_log_base_name,
    ffi.Pointer<ffi.Char> log_path,
    bool console,
  ) {
    return _WOWNERO_Wallet_init3(
      wallet_ptr,
      argv0,
      default_log_base_name,
      log_path,
      console,
    );
  }

  late final _WOWNERO_Wallet_init3Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              ffi.Pointer<ffi.Void>,
              ffi.Pointer<ffi.Char>,
              ffi.Pointer<ffi.Char>,
              ffi.Pointer<ffi.Char>,
              ffi.Bool)>>('WOWNERO_Wallet_init3');
  late final _WOWNERO_Wallet_init3 = _WOWNERO_Wallet_init3Ptr.asFunction<
      void Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>,
          ffi.Pointer<ffi.Char>, ffi.Pointer<ffi.Char>, bool)>();

  ffi.Pointer<ffi.Char> WOWNERO_Wallet_getPolyseed(
    ffi.Pointer<ffi.Void> wallet_ptr,
    ffi.Pointer<ffi.Char> passphrase,
  ) {
    return _WOWNERO_Wallet_getPolyseed(
      wallet_ptr,
      passphrase,
    );
  }

  late final _WOWNERO_Wallet_getPolyseedPtr = _lookup<
      ffi.NativeFunction<
          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>,
              ffi.Pointer<ffi.Char>)>>('WOWNERO_Wallet_getPolyseed');
  late final _WOWNERO_Wallet_getPolyseed =
      _WOWNERO_Wallet_getPolyseedPtr.asFunction<
          ffi.Pointer<ffi.Char> Function(
              ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();

  ffi.Pointer<ffi.Char> WOWNERO_Wallet_createPolyseed(
    ffi.Pointer<ffi.Char> language,
  ) {
    return _WOWNERO_Wallet_createPolyseed(
      language,
    );
  }

  late final _WOWNERO_Wallet_createPolyseedPtr = _lookup<
      ffi.NativeFunction<
          ffi.Pointer<ffi.Char> Function(
              ffi.Pointer<ffi.Char>)>>('WOWNERO_Wallet_createPolyseed');
  late final _WOWNERO_Wallet_createPolyseed = _WOWNERO_Wallet_createPolyseedPtr
      .asFunction<ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Char>)>();

  void WOWNERO_Wallet_startRefresh(
    ffi.Pointer<ffi.Void> wallet_ptr,
  ) {
    return _WOWNERO_Wallet_startRefresh(
      wallet_ptr,
    );
  }

  late final _WOWNERO_Wallet_startRefreshPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>)>>(
          'WOWNERO_Wallet_startRefresh');
  late final _WOWNERO_Wallet_startRefresh = _WOWNERO_Wallet_startRefreshPtr
      .asFunction<void Function(ffi.Pointer<ffi.Void>)>();

  void WOWNERO_Wallet_pauseRefresh(
    ffi.Pointer<ffi.Void> wallet_ptr,
  ) {
    return _WOWNERO_Wallet_pauseRefresh(
      wallet_ptr,
    );
  }

  late final _WOWNERO_Wallet_pauseRefreshPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>)>>(
          'WOWNERO_Wallet_pauseRefresh');
  late final _WOWNERO_Wallet_pauseRefresh = _WOWNERO_Wallet_pauseRefreshPtr
      .asFunction<void Function(ffi.Pointer<ffi.Void>)>();

  bool WOWNERO_Wallet_refresh(
    ffi.Pointer<ffi.Void> wallet_ptr,
  ) {
    return _WOWNERO_Wallet_refresh(
      wallet_ptr,
    );
  }

  late final _WOWNERO_Wallet_refreshPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(ffi.Pointer<ffi.Void>)>>(
          'WOWNERO_Wallet_refresh');
  late final _WOWNERO_Wallet_refresh = _WOWNERO_Wallet_refreshPtr.asFunction<
      bool Function(ffi.Pointer<ffi.Void>)>();

  void WOWNERO_Wallet_refreshAsync(
    ffi.Pointer<ffi.Void> wallet_ptr,
  ) {
    return _WOWNERO_Wallet_refreshAsync(
      wallet_ptr,
    );
  }

  late final _WOWNERO_Wallet_refreshAsyncPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>)>>(
          'WOWNERO_Wallet_refreshAsync');
  late final _WOWNERO_Wallet_refreshAsync = _WOWNERO_Wallet_refreshAsyncPtr
      .asFunction<void Function(ffi.Pointer<ffi.Void>)>();

  bool WOWNERO_Wallet_rescanBlockchain(
    ffi.Pointer<ffi.Void> wallet_ptr,
  ) {
    return _WOWNERO_Wallet_rescanBlockchain(
      wallet_ptr,
    );
  }

  late final _WOWNERO_Wallet_rescanBlockchainPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(ffi.Pointer<ffi.Void>)>>(
          'WOWNERO_Wallet_rescanBlockchain');
  late final _WOWNERO_Wallet_rescanBlockchain =
      _WOWNERO_Wallet_rescanBlockchainPtr.asFunction<
          bool Function(ffi.Pointer<ffi.Void>)>();

  void WOWNERO_Wallet_rescanBlockchainAsync(
    ffi.Pointer<ffi.Void> wallet_ptr,
  ) {
    return _WOWNERO_Wallet_rescanBlockchainAsync(
      wallet_ptr,
    );
  }

  late final _WOWNERO_Wallet_rescanBlockchainAsyncPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>)>>(
          'WOWNERO_Wallet_rescanBlockchainAsync');
  late final _WOWNERO_Wallet_rescanBlockchainAsync =
      _WOWNERO_Wallet_rescanBlockchainAsyncPtr.asFunction<
          void Function(ffi.Pointer<ffi.Void>)>();

  void WOWNERO_Wallet_setAutoRefreshInterval(
    ffi.Pointer<ffi.Void> wallet_ptr,
    int millis,
  ) {
    return _WOWNERO_Wallet_setAutoRefreshInterval(
      wallet_ptr,
      millis,
    );
  }

  late final _WOWNERO_Wallet_setAutoRefreshIntervalPtr = _lookup<
          ffi
          .NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>, ffi.Int)>>(
      'WOWNERO_Wallet_setAutoRefreshInterval');
  late final _WOWNERO_Wallet_setAutoRefreshInterval =
      _WOWNERO_Wallet_setAutoRefreshIntervalPtr.asFunction<
          void Function(ffi.Pointer<ffi.Void>, int)>();

  int WOWNERO_Wallet_autoRefreshInterval(
    ffi.Pointer<ffi.Void> wallet_ptr,
  ) {
    return _WOWNERO_Wallet_autoRefreshInterval(
      wallet_ptr,
    );
  }

  late final _WOWNERO_Wallet_autoRefreshIntervalPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(ffi.Pointer<ffi.Void>)>>(
          'WOWNERO_Wallet_autoRefreshInterval');
  late final _WOWNERO_Wallet_autoRefreshInterval =
      _WOWNERO_Wallet_autoRefreshIntervalPtr.asFunction<
          int Function(ffi.Pointer<ffi.Void>)>();

  void WOWNERO_Wallet_addSubaddressAccount(
    ffi.Pointer<ffi.Void> wallet_ptr,
    ffi.Pointer<ffi.Char> label,
  ) {
    return _WOWNERO_Wallet_addSubaddressAccount(
      wallet_ptr,
      label,
    );
  }

  late final _WOWNERO_Wallet_addSubaddressAccountPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(ffi.Pointer<ffi.Void>,
              ffi.Pointer<ffi.Char>)>>('WOWNERO_Wallet_addSubaddressAccount');
  late final _WOWNERO_Wallet_addSubaddressAccount =
      _WOWNERO_Wallet_addSubaddressAccountPtr.asFunction<
          void Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();

  int WOWNERO_Wallet_numSubaddressAccounts(
    ffi.Pointer<ffi.Void> wallet_ptr,
  ) {
    return _WOWNERO_Wallet_numSubaddressAccounts(
      wallet_ptr,
    );
  }

  late final _WOWNERO_Wallet_numSubaddressAccountsPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(ffi.Pointer<ffi.Void>)>>(
          'WOWNERO_Wallet_numSubaddressAccounts');
  late final _WOWNERO_Wallet_numSubaddressAccounts =
      _WOWNERO_Wallet_numSubaddressAccountsPtr.asFunction<
          int Function(ffi.Pointer<ffi.Void>)>();

  int WOWNERO_Wallet_numSubaddresses(
    ffi.Pointer<ffi.Void> wallet_ptr,
    int accountIndex,
  ) {
    return _WOWNERO_Wallet_numSubaddresses(
      wallet_ptr,
      accountIndex,
    );
  }

  late final _WOWNERO_Wallet_numSubaddressesPtr = _lookup<
      ffi.NativeFunction<
          ffi.Size Function(ffi.Pointer<ffi.Void>,
              ffi.Uint32)>>('WOWNERO_Wallet_numSubaddresses');
  late final _WOWNERO_Wallet_numSubaddresses =
      _WOWNERO_Wallet_numSubaddressesPtr.asFunction<
          int Function(ffi.Pointer<ffi.Void>, int)>();

  void WOWNERO_Wallet_addSubaddress(
    ffi.Pointer<ffi.Void> wallet_ptr,
    int accountIndex,
    ffi.Pointer<ffi.Char> label,
  ) {
    return _WOWNERO_Wallet_addSubaddress(
      wallet_ptr,
      accountIndex,
      label,
    );
  }

  late final _WOWNERO_Wallet_addSubaddressPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(ffi.Pointer<ffi.Void>, ffi.Uint32,
              ffi.Pointer<ffi.Char>)>>('WOWNERO_Wallet_addSubaddress');
  late final _WOWNERO_Wallet_addSubaddress =
      _WOWNERO_Wallet_addSubaddressPtr.asFunction<
          void Function(ffi.Pointer<ffi.Void>, int, ffi.Pointer<ffi.Char>)>();

  ffi.Pointer<ffi.Char> WOWNERO_Wallet_getSubaddressLabel(
    ffi.Pointer<ffi.Void> wallet_ptr,
    int accountIndex,
    int addressIndex,
  ) {
    return _WOWNERO_Wallet_getSubaddressLabel(
      wallet_ptr,
      accountIndex,
      addressIndex,
    );
  }

  late final _WOWNERO_Wallet_getSubaddressLabelPtr = _lookup<
      ffi.NativeFunction<
          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>, ffi.Uint32,
              ffi.Uint32)>>('WOWNERO_Wallet_getSubaddressLabel');
  late final _WOWNERO_Wallet_getSubaddressLabel =
      _WOWNERO_Wallet_getSubaddressLabelPtr.asFunction<
          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>, int, int)>();

  void WOWNERO_Wallet_setSubaddressLabel(
    ffi.Pointer<ffi.Void> wallet_ptr,
    int accountIndex,
    int addressIndex,
    ffi.Pointer<ffi.Char> label,
  ) {
    return _WOWNERO_Wallet_setSubaddressLabel(
      wallet_ptr,
      accountIndex,
      addressIndex,
      label,
    );
  }

  late final _WOWNERO_Wallet_setSubaddressLabelPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(ffi.Pointer<ffi.Void>, ffi.Uint32, ffi.Uint32,
              ffi.Pointer<ffi.Char>)>>('WOWNERO_Wallet_setSubaddressLabel');
  late final _WOWNERO_Wallet_setSubaddressLabel =
      _WOWNERO_Wallet_setSubaddressLabelPtr.asFunction<
          void Function(
              ffi.Pointer<ffi.Void>, int, int, ffi.Pointer<ffi.Char>)>();

  ffi.Pointer<ffi.Char> WOWNERO_Wallet_getMultisigInfo(
    ffi.Pointer<ffi.Void> wallet_ptr,
  ) {
    return _WOWNERO_Wallet_getMultisigInfo(
      wallet_ptr,
    );
  }

  late final _WOWNERO_Wallet_getMultisigInfoPtr = _lookup<
      ffi.NativeFunction<
          ffi.Pointer<ffi.Char> Function(
              ffi.Pointer<ffi.Void>)>>('WOWNERO_Wallet_getMultisigInfo');
  late final _WOWNERO_Wallet_getMultisigInfo =
      _WOWNERO_Wallet_getMultisigInfoPtr.asFunction<
          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>();

  ffi.Pointer<ffi.Void> WOWNERO_Wallet_createTransactionMultDest(
    ffi.Pointer<ffi.Void> wallet_ptr,
    ffi.Pointer<ffi.Char> dst_addr_list,
    ffi.Pointer<ffi.Char> dst_addr_list_separator,
    ffi.Pointer<ffi.Char> payment_id,
    bool amount_sweep_all,
    ffi.Pointer<ffi.Char> amount_list,
    ffi.Pointer<ffi.Char> amount_list_separator,
    int mixin_count,
    int pendingTransactionPriority,
    int subaddr_account,
    ffi.Pointer<ffi.Char> preferredInputs,
    ffi.Pointer<ffi.Char> preferredInputs_separator,
  ) {
    return _WOWNERO_Wallet_createTransactionMultDest(
      wallet_ptr,
      dst_addr_list,
      dst_addr_list_separator,
      payment_id,
      amount_sweep_all,
      amount_list,
      amount_list_separator,
      mixin_count,
      pendingTransactionPriority,
      subaddr_account,
      preferredInputs,
      preferredInputs_separator,
    );
  }

  late final _WOWNERO_Wallet_createTransactionMultDestPtr = _lookup<
          ffi.NativeFunction<
              ffi.Pointer<ffi.Void> Function(
                  ffi.Pointer<ffi.Void>,
                  ffi.Pointer<ffi.Char>,
                  ffi.Pointer<ffi.Char>,
                  ffi.Pointer<ffi.Char>,
                  ffi.Bool,
                  ffi.Pointer<ffi.Char>,
                  ffi.Pointer<ffi.Char>,
                  ffi.Uint32,
                  ffi.Int,
                  ffi.Uint32,
                  ffi.Pointer<ffi.Char>,
                  ffi.Pointer<ffi.Char>)>>(
      'WOWNERO_Wallet_createTransactionMultDest');
  late final _WOWNERO_Wallet_createTransactionMultDest =
      _WOWNERO_Wallet_createTransactionMultDestPtr.asFunction<
          ffi.Pointer<ffi.Void> Function(
              ffi.Pointer<ffi.Void>,
              ffi.Pointer<ffi.Char>,
              ffi.Pointer<ffi.Char>,
              ffi.Pointer<ffi.Char>,
              bool,
              ffi.Pointer<ffi.Char>,
              ffi.Pointer<ffi.Char>,
              int,
              int,
              int,
              ffi.Pointer<ffi.Char>,
              ffi.Pointer<ffi.Char>)>();

  ffi.Pointer<ffi.Void> WOWNERO_Wallet_createTransaction(
    ffi.Pointer<ffi.Void> wallet_ptr,
    ffi.Pointer<ffi.Char> dst_addr,
    ffi.Pointer<ffi.Char> payment_id,
    int amount,
    int mixin_count,
    int pendingTransactionPriority,
    int subaddr_account,
    ffi.Pointer<ffi.Char> preferredInputs,
    ffi.Pointer<ffi.Char> separator,
  ) {
    return _WOWNERO_Wallet_createTransaction(
      wallet_ptr,
      dst_addr,
      payment_id,
      amount,
      mixin_count,
      pendingTransactionPriority,
      subaddr_account,
      preferredInputs,
      separator,
    );
  }

  late final _WOWNERO_Wallet_createTransactionPtr = _lookup<
      ffi.NativeFunction<
          ffi.Pointer<ffi.Void> Function(
              ffi.Pointer<ffi.Void>,
              ffi.Pointer<ffi.Char>,
              ffi.Pointer<ffi.Char>,
              ffi.Uint64,
              ffi.Uint32,
              ffi.Int,
              ffi.Uint32,
              ffi.Pointer<ffi.Char>,
              ffi.Pointer<ffi.Char>)>>('WOWNERO_Wallet_createTransaction');
  late final _WOWNERO_Wallet_createTransaction =
      _WOWNERO_Wallet_createTransactionPtr.asFunction<
          ffi.Pointer<ffi.Void> Function(
              ffi.Pointer<ffi.Void>,
              ffi.Pointer<ffi.Char>,
              ffi.Pointer<ffi.Char>,
              int,
              int,
              int,
              int,
              ffi.Pointer<ffi.Char>,
              ffi.Pointer<ffi.Char>)>();

  ffi.Pointer<ffi.Void> WOWNERO_Wallet_loadUnsignedTx(
    ffi.Pointer<ffi.Void> wallet_ptr,
    ffi.Pointer<ffi.Char> unsigned_filename,
  ) {
    return _WOWNERO_Wallet_loadUnsignedTx(
      wallet_ptr,
      unsigned_filename,
    );
  }

  late final _WOWNERO_Wallet_loadUnsignedTxPtr = _lookup<
      ffi.NativeFunction<
          ffi.Pointer<ffi.Void> Function(ffi.Pointer<ffi.Void>,
              ffi.Pointer<ffi.Char>)>>('WOWNERO_Wallet_loadUnsignedTx');
  late final _WOWNERO_Wallet_loadUnsignedTx =
      _WOWNERO_Wallet_loadUnsignedTxPtr.asFunction<
          ffi.Pointer<ffi.Void> Function(
              ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();

  bool WOWNERO_Wallet_submitTransaction(
    ffi.Pointer<ffi.Void> wallet_ptr,
    ffi.Pointer<ffi.Char> fileName,
  ) {
    return _WOWNERO_Wallet_submitTransaction(
      wallet_ptr,
      fileName,
    );
  }

  late final _WOWNERO_Wallet_submitTransactionPtr = _lookup<
      ffi.NativeFunction<
          ffi.Bool Function(ffi.Pointer<ffi.Void>,
              ffi.Pointer<ffi.Char>)>>('WOWNERO_Wallet_submitTransaction');
  late final _WOWNERO_Wallet_submitTransaction =
      _WOWNERO_Wallet_submitTransactionPtr.asFunction<
          bool Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();

  bool WOWNERO_Wallet_hasUnknownKeyImages(
    ffi.Pointer<ffi.Void> wallet_ptr,
  ) {
    return _WOWNERO_Wallet_hasUnknownKeyImages(
      wallet_ptr,
    );
  }

  late final _WOWNERO_Wallet_hasUnknownKeyImagesPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(ffi.Pointer<ffi.Void>)>>(
          'WOWNERO_Wallet_hasUnknownKeyImages');
  late final _WOWNERO_Wallet_hasUnknownKeyImages =
      _WOWNERO_Wallet_hasUnknownKeyImagesPtr.asFunction<
          bool Function(ffi.Pointer<ffi.Void>)>();

  bool WOWNERO_Wallet_exportKeyImages(
    ffi.Pointer<ffi.Void> wallet_ptr,
    ffi.Pointer<ffi.Char> filename,
    bool all,
  ) {
    return _WOWNERO_Wallet_exportKeyImages(
      wallet_ptr,
      filename,
      all,
    );
  }

  late final _WOWNERO_Wallet_exportKeyImagesPtr = _lookup<
      ffi.NativeFunction<
          ffi.Bool Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>,
              ffi.Bool)>>('WOWNERO_Wallet_exportKeyImages');
  late final _WOWNERO_Wallet_exportKeyImages =
      _WOWNERO_Wallet_exportKeyImagesPtr.asFunction<
          bool Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>, bool)>();

  bool WOWNERO_Wallet_importKeyImages(
    ffi.Pointer<ffi.Void> wallet_ptr,
    ffi.Pointer<ffi.Char> filename,
  ) {
    return _WOWNERO_Wallet_importKeyImages(
      wallet_ptr,
      filename,
    );
  }

  late final _WOWNERO_Wallet_importKeyImagesPtr = _lookup<
      ffi.NativeFunction<
          ffi.Bool Function(ffi.Pointer<ffi.Void>,
              ffi.Pointer<ffi.Char>)>>('WOWNERO_Wallet_importKeyImages');
  late final _WOWNERO_Wallet_importKeyImages =
      _WOWNERO_Wallet_importKeyImagesPtr.asFunction<
          bool Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();

  bool WOWNERO_Wallet_exportOutputs(
    ffi.Pointer<ffi.Void> wallet_ptr,
    ffi.Pointer<ffi.Char> filename,
    bool all,
  ) {
    return _WOWNERO_Wallet_exportOutputs(
      wallet_ptr,
      filename,
      all,
    );
  }

  late final _WOWNERO_Wallet_exportOutputsPtr = _lookup<
      ffi.NativeFunction<
          ffi.Bool Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>,
              ffi.Bool)>>('WOWNERO_Wallet_exportOutputs');
  late final _WOWNERO_Wallet_exportOutputs =
      _WOWNERO_Wallet_exportOutputsPtr.asFunction<
          bool Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>, bool)>();

  bool WOWNERO_Wallet_importOutputs(
    ffi.Pointer<ffi.Void> wallet_ptr,
    ffi.Pointer<ffi.Char> filename,
  ) {
    return _WOWNERO_Wallet_importOutputs(
      wallet_ptr,
      filename,
    );
  }

  late final _WOWNERO_Wallet_importOutputsPtr = _lookup<
      ffi.NativeFunction<
          ffi.Bool Function(ffi.Pointer<ffi.Void>,
              ffi.Pointer<ffi.Char>)>>('WOWNERO_Wallet_importOutputs');
  late final _WOWNERO_Wallet_importOutputs =
      _WOWNERO_Wallet_importOutputsPtr.asFunction<
          bool Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();

  bool WOWNERO_Wallet_setupBackgroundSync(
    ffi.Pointer<ffi.Void> wallet_ptr,
    int background_sync_type,
    ffi.Pointer<ffi.Char> wallet_password,
    ffi.Pointer<ffi.Char> background_cache_password,
  ) {
    return _WOWNERO_Wallet_setupBackgroundSync(
      wallet_ptr,
      background_sync_type,
      wallet_password,
      background_cache_password,
    );
  }

  late final _WOWNERO_Wallet_setupBackgroundSyncPtr = _lookup<
      ffi.NativeFunction<
          ffi.Bool Function(
              ffi.Pointer<ffi.Void>,
              ffi.Int,
              ffi.Pointer<ffi.Char>,
              ffi.Pointer<ffi.Char>)>>('WOWNERO_Wallet_setupBackgroundSync');
  late final _WOWNERO_Wallet_setupBackgroundSync =
      _WOWNERO_Wallet_setupBackgroundSyncPtr.asFunction<
          bool Function(ffi.Pointer<ffi.Void>, int, ffi.Pointer<ffi.Char>,
              ffi.Pointer<ffi.Char>)>();

  int WOWNERO_Wallet_getBackgroundSyncType(
    ffi.Pointer<ffi.Void> wallet_ptr,
  ) {
    return _WOWNERO_Wallet_getBackgroundSyncType(
      wallet_ptr,
    );
  }

  late final _WOWNERO_Wallet_getBackgroundSyncTypePtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(ffi.Pointer<ffi.Void>)>>(
          'WOWNERO_Wallet_getBackgroundSyncType');
  late final _WOWNERO_Wallet_getBackgroundSyncType =
      _WOWNERO_Wallet_getBackgroundSyncTypePtr.asFunction<
          int Function(ffi.Pointer<ffi.Void>)>();

  bool WOWNERO_Wallet_startBackgroundSync(
    ffi.Pointer<ffi.Void> wallet_ptr,
  ) {
    return _WOWNERO_Wallet_startBackgroundSync(
      wallet_ptr,
    );
  }

  late final _WOWNERO_Wallet_startBackgroundSyncPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(ffi.Pointer<ffi.Void>)>>(
          'WOWNERO_Wallet_startBackgroundSync');
  late final _WOWNERO_Wallet_startBackgroundSync =
      _WOWNERO_Wallet_startBackgroundSyncPtr.asFunction<
          bool Function(ffi.Pointer<ffi.Void>)>();

  bool WOWNERO_Wallet_stopBackgroundSync(
    ffi.Pointer<ffi.Void> wallet_ptr,
    ffi.Pointer<ffi.Char> wallet_password,
  ) {
    return _WOWNERO_Wallet_stopBackgroundSync(
      wallet_ptr,
      wallet_password,
    );
  }

  late final _WOWNERO_Wallet_stopBackgroundSyncPtr = _lookup<
      ffi.NativeFunction<
          ffi.Bool Function(ffi.Pointer<ffi.Void>,
              ffi.Pointer<ffi.Char>)>>('WOWNERO_Wallet_stopBackgroundSync');
  late final _WOWNERO_Wallet_stopBackgroundSync =
      _WOWNERO_Wallet_stopBackgroundSyncPtr.asFunction<
          bool Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();

  bool WOWNERO_Wallet_isBackgroundSyncing(
    ffi.Pointer<ffi.Void> wallet_ptr,
  ) {
    return _WOWNERO_Wallet_isBackgroundSyncing(
      wallet_ptr,
    );
  }

  late final _WOWNERO_Wallet_isBackgroundSyncingPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(ffi.Pointer<ffi.Void>)>>(
          'WOWNERO_Wallet_isBackgroundSyncing');
  late final _WOWNERO_Wallet_isBackgroundSyncing =
      _WOWNERO_Wallet_isBackgroundSyncingPtr.asFunction<
          bool Function(ffi.Pointer<ffi.Void>)>();

  bool WOWNERO_Wallet_isBackgroundWallet(
    ffi.Pointer<ffi.Void> wallet_ptr,
  ) {
    return _WOWNERO_Wallet_isBackgroundWallet(
      wallet_ptr,
    );
  }

  late final _WOWNERO_Wallet_isBackgroundWalletPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(ffi.Pointer<ffi.Void>)>>(
          'WOWNERO_Wallet_isBackgroundWallet');
  late final _WOWNERO_Wallet_isBackgroundWallet =
      _WOWNERO_Wallet_isBackgroundWalletPtr.asFunction<
          bool Function(ffi.Pointer<ffi.Void>)>();

  ffi.Pointer<ffi.Void> WOWNERO_Wallet_history(
    ffi.Pointer<ffi.Void> wallet_ptr,
  ) {
    return _WOWNERO_Wallet_history(
      wallet_ptr,
    );
  }

  late final _WOWNERO_Wallet_historyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Pointer<ffi.Void> Function(
              ffi.Pointer<ffi.Void>)>>('WOWNERO_Wallet_history');
  late final _WOWNERO_Wallet_history = _WOWNERO_Wallet_historyPtr.asFunction<
      ffi.Pointer<ffi.Void> Function(ffi.Pointer<ffi.Void>)>();

  ffi.Pointer<ffi.Void> WOWNERO_Wallet_addressBook(
    ffi.Pointer<ffi.Void> wallet_ptr,
  ) {
    return _WOWNERO_Wallet_addressBook(
      wallet_ptr,
    );
  }

  late final _WOWNERO_Wallet_addressBookPtr = _lookup<
      ffi.NativeFunction<
          ffi.Pointer<ffi.Void> Function(
              ffi.Pointer<ffi.Void>)>>('WOWNERO_Wallet_addressBook');
  late final _WOWNERO_Wallet_addressBook = _WOWNERO_Wallet_addressBookPtr
      .asFunction<ffi.Pointer<ffi.Void> Function(ffi.Pointer<ffi.Void>)>();

  ffi.Pointer<ffi.Void> WOWNERO_Wallet_coins(
    ffi.Pointer<ffi.Void> wallet_ptr,
  ) {
    return _WOWNERO_Wallet_coins(
      wallet_ptr,
    );
  }

  late final _WOWNERO_Wallet_coinsPtr = _lookup<
      ffi.NativeFunction<
          ffi.Pointer<ffi.Void> Function(
              ffi.Pointer<ffi.Void>)>>('WOWNERO_Wallet_coins');
  late final _WOWNERO_Wallet_coins = _WOWNERO_Wallet_coinsPtr.asFunction<
      ffi.Pointer<ffi.Void> Function(ffi.Pointer<ffi.Void>)>();

  ffi.Pointer<ffi.Void> WOWNERO_Wallet_subaddress(
    ffi.Pointer<ffi.Void> wallet_ptr,
  ) {
    return _WOWNERO_Wallet_subaddress(
      wallet_ptr,
    );
  }

  late final _WOWNERO_Wallet_subaddressPtr = _lookup<
      ffi.NativeFunction<
          ffi.Pointer<ffi.Void> Function(
              ffi.Pointer<ffi.Void>)>>('WOWNERO_Wallet_subaddress');
  late final _WOWNERO_Wallet_subaddress = _WOWNERO_Wallet_subaddressPtr
      .asFunction<ffi.Pointer<ffi.Void> Function(ffi.Pointer<ffi.Void>)>();

  ffi.Pointer<ffi.Void> WOWNERO_Wallet_subaddressAccount(
    ffi.Pointer<ffi.Void> wallet_ptr,
  ) {
    return _WOWNERO_Wallet_subaddressAccount(
      wallet_ptr,
    );
  }

  late final _WOWNERO_Wallet_subaddressAccountPtr = _lookup<
      ffi.NativeFunction<
          ffi.Pointer<ffi.Void> Function(
              ffi.Pointer<ffi.Void>)>>('WOWNERO_Wallet_subaddressAccount');
  late final _WOWNERO_Wallet_subaddressAccount =
      _WOWNERO_Wallet_subaddressAccountPtr.asFunction<
          ffi.Pointer<ffi.Void> Function(ffi.Pointer<ffi.Void>)>();

  int WOWNERO_Wallet_defaultMixin(
    ffi.Pointer<ffi.Void> wallet_ptr,
  ) {
    return _WOWNERO_Wallet_defaultMixin(
      wallet_ptr,
    );
  }

  late final _WOWNERO_Wallet_defaultMixinPtr =
      _lookup<ffi.NativeFunction<ffi.Uint32 Function(ffi.Pointer<ffi.Void>)>>(
          'WOWNERO_Wallet_defaultMixin');
  late final _WOWNERO_Wallet_defaultMixin = _WOWNERO_Wallet_defaultMixinPtr
      .asFunction<int Function(ffi.Pointer<ffi.Void>)>();

  void WOWNERO_Wallet_setDefaultMixin(
    ffi.Pointer<ffi.Void> wallet_ptr,
    int arg,
  ) {
    return _WOWNERO_Wallet_setDefaultMixin(
      wallet_ptr,
      arg,
    );
  }

  late final _WOWNERO_Wallet_setDefaultMixinPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(ffi.Pointer<ffi.Void>,
              ffi.Uint32)>>('WOWNERO_Wallet_setDefaultMixin');
  late final _WOWNERO_Wallet_setDefaultMixin =
      _WOWNERO_Wallet_setDefaultMixinPtr.asFunction<
          void Function(ffi.Pointer<ffi.Void>, int)>();

  bool WOWNERO_Wallet_setCacheAttribute(
    ffi.Pointer<ffi.Void> wallet_ptr,
    ffi.Pointer<ffi.Char> key,
    ffi.Pointer<ffi.Char> val,
  ) {
    return _WOWNERO_Wallet_setCacheAttribute(
      wallet_ptr,
      key,
      val,
    );
  }

  late final _WOWNERO_Wallet_setCacheAttributePtr = _lookup<
      ffi.NativeFunction<
          ffi.Bool Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>,
              ffi.Pointer<ffi.Char>)>>('WOWNERO_Wallet_setCacheAttribute');
  late final _WOWNERO_Wallet_setCacheAttribute =
      _WOWNERO_Wallet_setCacheAttributePtr.asFunction<
          bool Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>,
              ffi.Pointer<ffi.Char>)>();

  ffi.Pointer<ffi.Char> WOWNERO_Wallet_getCacheAttribute(
    ffi.Pointer<ffi.Void> wallet_ptr,
    ffi.Pointer<ffi.Char> key,
  ) {
    return _WOWNERO_Wallet_getCacheAttribute(
      wallet_ptr,
      key,
    );
  }

  late final _WOWNERO_Wallet_getCacheAttributePtr = _lookup<
      ffi.NativeFunction<
          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>,
              ffi.Pointer<ffi.Char>)>>('WOWNERO_Wallet_getCacheAttribute');
  late final _WOWNERO_Wallet_getCacheAttribute =
      _WOWNERO_Wallet_getCacheAttributePtr.asFunction<
          ffi.Pointer<ffi.Char> Function(
              ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();

  bool WOWNERO_Wallet_setUserNote(
    ffi.Pointer<ffi.Void> wallet_ptr,
    ffi.Pointer<ffi.Char> txid,
    ffi.Pointer<ffi.Char> note,
  ) {
    return _WOWNERO_Wallet_setUserNote(
      wallet_ptr,
      txid,
      note,
    );
  }

  late final _WOWNERO_Wallet_setUserNotePtr = _lookup<
      ffi.NativeFunction<
          ffi.Bool Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>,
              ffi.Pointer<ffi.Char>)>>('WOWNERO_Wallet_setUserNote');
  late final _WOWNERO_Wallet_setUserNote =
      _WOWNERO_Wallet_setUserNotePtr.asFunction<
          bool Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>,
              ffi.Pointer<ffi.Char>)>();

  ffi.Pointer<ffi.Char> WOWNERO_Wallet_getUserNote(
    ffi.Pointer<ffi.Void> wallet_ptr,
    ffi.Pointer<ffi.Char> txid,
  ) {
    return _WOWNERO_Wallet_getUserNote(
      wallet_ptr,
      txid,
    );
  }

  late final _WOWNERO_Wallet_getUserNotePtr = _lookup<
      ffi.NativeFunction<
          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>,
              ffi.Pointer<ffi.Char>)>>('WOWNERO_Wallet_getUserNote');
  late final _WOWNERO_Wallet_getUserNote =
      _WOWNERO_Wallet_getUserNotePtr.asFunction<
          ffi.Pointer<ffi.Char> Function(
              ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();

  ffi.Pointer<ffi.Char> WOWNERO_Wallet_getTxKey(
    ffi.Pointer<ffi.Void> wallet_ptr,
    ffi.Pointer<ffi.Char> txid,
  ) {
    return _WOWNERO_Wallet_getTxKey(
      wallet_ptr,
      txid,
    );
  }

  late final _WOWNERO_Wallet_getTxKeyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>,
              ffi.Pointer<ffi.Char>)>>('WOWNERO_Wallet_getTxKey');
  late final _WOWNERO_Wallet_getTxKey = _WOWNERO_Wallet_getTxKeyPtr.asFunction<
      ffi.Pointer<ffi.Char> Function(
          ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();

  ffi.Pointer<ffi.Char> WOWNERO_Wallet_signMessage(
    ffi.Pointer<ffi.Void> wallet_ptr,
    ffi.Pointer<ffi.Char> message,
    ffi.Pointer<ffi.Char> address,
  ) {
    return _WOWNERO_Wallet_signMessage(
      wallet_ptr,
      message,
      address,
    );
  }

  late final _WOWNERO_Wallet_signMessagePtr = _lookup<
      ffi.NativeFunction<
          ffi.Pointer<ffi.Char> Function(
              ffi.Pointer<ffi.Void>,
              ffi.Pointer<ffi.Char>,
              ffi.Pointer<ffi.Char>)>>('WOWNERO_Wallet_signMessage');
  late final _WOWNERO_Wallet_signMessage =
      _WOWNERO_Wallet_signMessagePtr.asFunction<
          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>,
              ffi.Pointer<ffi.Char>, ffi.Pointer<ffi.Char>)>();

  bool WOWNERO_Wallet_verifySignedMessage(
    ffi.Pointer<ffi.Void> wallet_ptr,
    ffi.Pointer<ffi.Char> message,
    ffi.Pointer<ffi.Char> address,
    ffi.Pointer<ffi.Char> signature,
  ) {
    return _WOWNERO_Wallet_verifySignedMessage(
      wallet_ptr,
      message,
      address,
      signature,
    );
  }

  late final _WOWNERO_Wallet_verifySignedMessagePtr = _lookup<
      ffi.NativeFunction<
          ffi.Bool Function(
              ffi.Pointer<ffi.Void>,
              ffi.Pointer<ffi.Char>,
              ffi.Pointer<ffi.Char>,
              ffi.Pointer<ffi.Char>)>>('WOWNERO_Wallet_verifySignedMessage');
  late final _WOWNERO_Wallet_verifySignedMessage =
      _WOWNERO_Wallet_verifySignedMessagePtr.asFunction<
          bool Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>,
              ffi.Pointer<ffi.Char>, ffi.Pointer<ffi.Char>)>();

  bool WOWNERO_Wallet_rescanSpent(
    ffi.Pointer<ffi.Void> wallet_ptr,
  ) {
    return _WOWNERO_Wallet_rescanSpent(
      wallet_ptr,
    );
  }

  late final _WOWNERO_Wallet_rescanSpentPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(ffi.Pointer<ffi.Void>)>>(
          'WOWNERO_Wallet_rescanSpent');
  late final _WOWNERO_Wallet_rescanSpent = _WOWNERO_Wallet_rescanSpentPtr
      .asFunction<bool Function(ffi.Pointer<ffi.Void>)>();

  void WOWNERO_Wallet_setOffline(
    ffi.Pointer<ffi.Void> wallet_ptr,
    bool offline,
  ) {
    return _WOWNERO_Wallet_setOffline(
      wallet_ptr,
      offline,
    );
  }

  late final _WOWNERO_Wallet_setOfflinePtr = _lookup<
          ffi
          .NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>, ffi.Bool)>>(
      'WOWNERO_Wallet_setOffline');
  late final _WOWNERO_Wallet_setOffline = _WOWNERO_Wallet_setOfflinePtr
      .asFunction<void Function(ffi.Pointer<ffi.Void>, bool)>();

  bool WOWNERO_Wallet_isOffline(
    ffi.Pointer<ffi.Void> wallet_ptr,
  ) {
    return _WOWNERO_Wallet_isOffline(
      wallet_ptr,
    );
  }

  late final _WOWNERO_Wallet_isOfflinePtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(ffi.Pointer<ffi.Void>)>>(
          'WOWNERO_Wallet_isOffline');
  late final _WOWNERO_Wallet_isOffline = _WOWNERO_Wallet_isOfflinePtr
      .asFunction<bool Function(ffi.Pointer<ffi.Void>)>();

  void WOWNERO_Wallet_segregatePreForkOutputs(
    ffi.Pointer<ffi.Void> wallet_ptr,
    bool segregate,
  ) {
    return _WOWNERO_Wallet_segregatePreForkOutputs(
      wallet_ptr,
      segregate,
    );
  }

  late final _WOWNERO_Wallet_segregatePreForkOutputsPtr = _lookup<
          ffi
          .NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>, ffi.Bool)>>(
      'WOWNERO_Wallet_segregatePreForkOutputs');
  late final _WOWNERO_Wallet_segregatePreForkOutputs =
      _WOWNERO_Wallet_segregatePreForkOutputsPtr.asFunction<
          void Function(ffi.Pointer<ffi.Void>, bool)>();

  void WOWNERO_Wallet_segregationHeight(
    ffi.Pointer<ffi.Void> wallet_ptr,
    int height,
  ) {
    return _WOWNERO_Wallet_segregationHeight(
      wallet_ptr,
      height,
    );
  }

  late final _WOWNERO_Wallet_segregationHeightPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(ffi.Pointer<ffi.Void>,
              ffi.Uint64)>>('WOWNERO_Wallet_segregationHeight');
  late final _WOWNERO_Wallet_segregationHeight =
      _WOWNERO_Wallet_segregationHeightPtr.asFunction<
          void Function(ffi.Pointer<ffi.Void>, int)>();

  void WOWNERO_Wallet_keyReuseMitigation2(
    ffi.Pointer<ffi.Void> wallet_ptr,
    bool mitigation,
  ) {
    return _WOWNERO_Wallet_keyReuseMitigation2(
      wallet_ptr,
      mitigation,
    );
  }

  late final _WOWNERO_Wallet_keyReuseMitigation2Ptr = _lookup<
          ffi
          .NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>, ffi.Bool)>>(
      'WOWNERO_Wallet_keyReuseMitigation2');
  late final _WOWNERO_Wallet_keyReuseMitigation2 =
      _WOWNERO_Wallet_keyReuseMitigation2Ptr.asFunction<
          void Function(ffi.Pointer<ffi.Void>, bool)>();

  bool WOWNERO_Wallet_lockKeysFile(
    ffi.Pointer<ffi.Void> wallet_ptr,
  ) {
    return _WOWNERO_Wallet_lockKeysFile(
      wallet_ptr,
    );
  }

  late final _WOWNERO_Wallet_lockKeysFilePtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(ffi.Pointer<ffi.Void>)>>(
          'WOWNERO_Wallet_lockKeysFile');
  late final _WOWNERO_Wallet_lockKeysFile = _WOWNERO_Wallet_lockKeysFilePtr
      .asFunction<bool Function(ffi.Pointer<ffi.Void>)>();

  bool WOWNERO_Wallet_unlockKeysFile(
    ffi.Pointer<ffi.Void> wallet_ptr,
  ) {
    return _WOWNERO_Wallet_unlockKeysFile(
      wallet_ptr,
    );
  }

  late final _WOWNERO_Wallet_unlockKeysFilePtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(ffi.Pointer<ffi.Void>)>>(
          'WOWNERO_Wallet_unlockKeysFile');
  late final _WOWNERO_Wallet_unlockKeysFile = _WOWNERO_Wallet_unlockKeysFilePtr
      .asFunction<bool Function(ffi.Pointer<ffi.Void>)>();

  bool WOWNERO_Wallet_isKeysFileLocked(
    ffi.Pointer<ffi.Void> wallet_ptr,
  ) {
    return _WOWNERO_Wallet_isKeysFileLocked(
      wallet_ptr,
    );
  }

  late final _WOWNERO_Wallet_isKeysFileLockedPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(ffi.Pointer<ffi.Void>)>>(
          'WOWNERO_Wallet_isKeysFileLocked');
  late final _WOWNERO_Wallet_isKeysFileLocked =
      _WOWNERO_Wallet_isKeysFileLockedPtr.asFunction<
          bool Function(ffi.Pointer<ffi.Void>)>();

  int WOWNERO_Wallet_getDeviceType(
    ffi.Pointer<ffi.Void> wallet_ptr,
  ) {
    return _WOWNERO_Wallet_getDeviceType(
      wallet_ptr,
    );
  }

  late final _WOWNERO_Wallet_getDeviceTypePtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(ffi.Pointer<ffi.Void>)>>(
          'WOWNERO_Wallet_getDeviceType');
  late final _WOWNERO_Wallet_getDeviceType = _WOWNERO_Wallet_getDeviceTypePtr
      .asFunction<int Function(ffi.Pointer<ffi.Void>)>();

  int WOWNERO_Wallet_coldKeyImageSync(
    ffi.Pointer<ffi.Void> wallet_ptr,
    int spent,
    int unspent,
  ) {
    return _WOWNERO_Wallet_coldKeyImageSync(
      wallet_ptr,
      spent,
      unspent,
    );
  }

  late final _WOWNERO_Wallet_coldKeyImageSyncPtr = _lookup<
      ffi.NativeFunction<
          ffi.Uint64 Function(ffi.Pointer<ffi.Void>, ffi.Uint64,
              ffi.Uint64)>>('WOWNERO_Wallet_coldKeyImageSync');
  late final _WOWNERO_Wallet_coldKeyImageSync =
      _WOWNERO_Wallet_coldKeyImageSyncPtr.asFunction<
          int Function(ffi.Pointer<ffi.Void>, int, int)>();

  ffi.Pointer<ffi.Char> WOWNERO_Wallet_deviceShowAddress(
    ffi.Pointer<ffi.Void> wallet_ptr,
    int accountIndex,
    int addressIndex,
  ) {
    return _WOWNERO_Wallet_deviceShowAddress(
      wallet_ptr,
      accountIndex,
      addressIndex,
    );
  }

  late final _WOWNERO_Wallet_deviceShowAddressPtr = _lookup<
      ffi.NativeFunction<
          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>, ffi.Uint32,
              ffi.Uint32)>>('WOWNERO_Wallet_deviceShowAddress');
  late final _WOWNERO_Wallet_deviceShowAddress =
      _WOWNERO_Wallet_deviceShowAddressPtr.asFunction<
          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>, int, int)>();

  bool WOWNERO_Wallet_reconnectDevice(
    ffi.Pointer<ffi.Void> wallet_ptr,
  ) {
    return _WOWNERO_Wallet_reconnectDevice(
      wallet_ptr,
    );
  }

  late final _WOWNERO_Wallet_reconnectDevicePtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(ffi.Pointer<ffi.Void>)>>(
          'WOWNERO_Wallet_reconnectDevice');
  late final _WOWNERO_Wallet_reconnectDevice =
      _WOWNERO_Wallet_reconnectDevicePtr.asFunction<
          bool Function(ffi.Pointer<ffi.Void>)>();

  int WOWNERO_Wallet_getBytesReceived(
    ffi.Pointer<ffi.Void> wallet_ptr,
  ) {
    return _WOWNERO_Wallet_getBytesReceived(
      wallet_ptr,
    );
  }

  late final _WOWNERO_Wallet_getBytesReceivedPtr =
      _lookup<ffi.NativeFunction<ffi.Uint64 Function(ffi.Pointer<ffi.Void>)>>(
          'WOWNERO_Wallet_getBytesReceived');
  late final _WOWNERO_Wallet_getBytesReceived =
      _WOWNERO_Wallet_getBytesReceivedPtr.asFunction<
          int Function(ffi.Pointer<ffi.Void>)>();

  int WOWNERO_Wallet_getBytesSent(
    ffi.Pointer<ffi.Void> wallet_ptr,
  ) {
    return _WOWNERO_Wallet_getBytesSent(
      wallet_ptr,
    );
  }

  late final _WOWNERO_Wallet_getBytesSentPtr =
      _lookup<ffi.NativeFunction<ffi.Uint64 Function(ffi.Pointer<ffi.Void>)>>(
          'WOWNERO_Wallet_getBytesSent');
  late final _WOWNERO_Wallet_getBytesSent = _WOWNERO_Wallet_getBytesSentPtr
      .asFunction<int Function(ffi.Pointer<ffi.Void>)>();

  ffi.Pointer<ffi.Void> WOWNERO_WalletManager_createWallet(
    ffi.Pointer<ffi.Void> wm_ptr,
    ffi.Pointer<ffi.Char> path,
    ffi.Pointer<ffi.Char> password,
    ffi.Pointer<ffi.Char> language,
    int networkType,
  ) {
    return _WOWNERO_WalletManager_createWallet(
      wm_ptr,
      path,
      password,
      language,
      networkType,
    );
  }

  late final _WOWNERO_WalletManager_createWalletPtr = _lookup<
      ffi.NativeFunction<
          ffi.Pointer<ffi.Void> Function(
              ffi.Pointer<ffi.Void>,
              ffi.Pointer<ffi.Char>,
              ffi.Pointer<ffi.Char>,
              ffi.Pointer<ffi.Char>,
              ffi.Int)>>('WOWNERO_WalletManager_createWallet');
  late final _WOWNERO_WalletManager_createWallet =
      _WOWNERO_WalletManager_createWalletPtr.asFunction<
          ffi.Pointer<ffi.Void> Function(
              ffi.Pointer<ffi.Void>,
              ffi.Pointer<ffi.Char>,
              ffi.Pointer<ffi.Char>,
              ffi.Pointer<ffi.Char>,
              int)>();

  ffi.Pointer<ffi.Void> WOWNERO_WalletManager_openWallet(
    ffi.Pointer<ffi.Void> wm_ptr,
    ffi.Pointer<ffi.Char> path,
    ffi.Pointer<ffi.Char> password,
    int networkType,
  ) {
    return _WOWNERO_WalletManager_openWallet(
      wm_ptr,
      path,
      password,
      networkType,
    );
  }

  late final _WOWNERO_WalletManager_openWalletPtr = _lookup<
      ffi.NativeFunction<
          ffi.Pointer<ffi.Void> Function(
              ffi.Pointer<ffi.Void>,
              ffi.Pointer<ffi.Char>,
              ffi.Pointer<ffi.Char>,
              ffi.Int)>>('WOWNERO_WalletManager_openWallet');
  late final _WOWNERO_WalletManager_openWallet =
      _WOWNERO_WalletManager_openWalletPtr.asFunction<
          ffi.Pointer<ffi.Void> Function(ffi.Pointer<ffi.Void>,
              ffi.Pointer<ffi.Char>, ffi.Pointer<ffi.Char>, int)>();

  ffi.Pointer<ffi.Void> WOWNERO_WalletManager_recoveryWallet(
    ffi.Pointer<ffi.Void> wm_ptr,
    ffi.Pointer<ffi.Char> path,
    ffi.Pointer<ffi.Char> password,
    ffi.Pointer<ffi.Char> mnemonic,
    int networkType,
    int restoreHeight,
    int kdfRounds,
    ffi.Pointer<ffi.Char> seedOffset,
  ) {
    return _WOWNERO_WalletManager_recoveryWallet(
      wm_ptr,
      path,
      password,
      mnemonic,
      networkType,
      restoreHeight,
      kdfRounds,
      seedOffset,
    );
  }

  late final _WOWNERO_WalletManager_recoveryWalletPtr = _lookup<
      ffi.NativeFunction<
          ffi.Pointer<ffi.Void> Function(
              ffi.Pointer<ffi.Void>,
              ffi.Pointer<ffi.Char>,
              ffi.Pointer<ffi.Char>,
              ffi.Pointer<ffi.Char>,
              ffi.Int,
              ffi.Uint64,
              ffi.Uint64,
              ffi.Pointer<ffi.Char>)>>('WOWNERO_WalletManager_recoveryWallet');
  late final _WOWNERO_WalletManager_recoveryWallet =
      _WOWNERO_WalletManager_recoveryWalletPtr.asFunction<
          ffi.Pointer<ffi.Void> Function(
              ffi.Pointer<ffi.Void>,
              ffi.Pointer<ffi.Char>,
              ffi.Pointer<ffi.Char>,
              ffi.Pointer<ffi.Char>,
              int,
              int,
              int,
              ffi.Pointer<ffi.Char>)>();

  ffi.Pointer<ffi.Void> WOWNERO_WalletManager_createWalletFromKeys(
    ffi.Pointer<ffi.Void> wm_ptr,
    ffi.Pointer<ffi.Char> path,
    ffi.Pointer<ffi.Char> password,
    ffi.Pointer<ffi.Char> language,
    int nettype,
    int restoreHeight,
    ffi.Pointer<ffi.Char> addressString,
    ffi.Pointer<ffi.Char> viewKeyString,
    ffi.Pointer<ffi.Char> spendKeyString,
    int kdf_rounds,
  ) {
    return _WOWNERO_WalletManager_createWalletFromKeys(
      wm_ptr,
      path,
      password,
      language,
      nettype,
      restoreHeight,
      addressString,
      viewKeyString,
      spendKeyString,
      kdf_rounds,
    );
  }

  late final _WOWNERO_WalletManager_createWalletFromKeysPtr = _lookup<
      ffi.NativeFunction<
          ffi.Pointer<ffi.Void> Function(
              ffi.Pointer<ffi.Void>,
              ffi.Pointer<ffi.Char>,
              ffi.Pointer<ffi.Char>,
              ffi.Pointer<ffi.Char>,
              ffi.Int,
              ffi.Uint64,
              ffi.Pointer<ffi.Char>,
              ffi.Pointer<ffi.Char>,
              ffi.Pointer<ffi.Char>,
              ffi.Uint64)>>('WOWNERO_WalletManager_createWalletFromKeys');
  late final _WOWNERO_WalletManager_createWalletFromKeys =
      _WOWNERO_WalletManager_createWalletFromKeysPtr.asFunction<
          ffi.Pointer<ffi.Void> Function(
              ffi.Pointer<ffi.Void>,
              ffi.Pointer<ffi.Char>,
              ffi.Pointer<ffi.Char>,
              ffi.Pointer<ffi.Char>,
              int,
              int,
              ffi.Pointer<ffi.Char>,
              ffi.Pointer<ffi.Char>,
              ffi.Pointer<ffi.Char>,
              int)>();

  ffi.Pointer<ffi.Void>
      WOWNERO_WalletManager_createDeterministicWalletFromSpendKey(
    ffi.Pointer<ffi.Void> wm_ptr,
    ffi.Pointer<ffi.Char> path,
    ffi.Pointer<ffi.Char> password,
    ffi.Pointer<ffi.Char> language,
    int nettype,
    int restoreHeight,
    ffi.Pointer<ffi.Char> spendKeyString,
    int kdf_rounds,
  ) {
    return _WOWNERO_WalletManager_createDeterministicWalletFromSpendKey(
      wm_ptr,
      path,
      password,
      language,
      nettype,
      restoreHeight,
      spendKeyString,
      kdf_rounds,
    );
  }

  late final _WOWNERO_WalletManager_createDeterministicWalletFromSpendKeyPtr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Pointer<ffi.Void> Function(
                      ffi.Pointer<ffi.Void>,
                      ffi.Pointer<ffi.Char>,
                      ffi.Pointer<ffi.Char>,
                      ffi.Pointer<ffi.Char>,
                      ffi.Int,
                      ffi.Uint64,
                      ffi.Pointer<ffi.Char>,
                      ffi.Uint64)>>(
          'WOWNERO_WalletManager_createDeterministicWalletFromSpendKey');
  late final _WOWNERO_WalletManager_createDeterministicWalletFromSpendKey =
      _WOWNERO_WalletManager_createDeterministicWalletFromSpendKeyPtr
          .asFunction<
              ffi.Pointer<ffi.Void> Function(
                  ffi.Pointer<ffi.Void>,
                  ffi.Pointer<ffi.Char>,
                  ffi.Pointer<ffi.Char>,
                  ffi.Pointer<ffi.Char>,
                  int,
                  int,
                  ffi.Pointer<ffi.Char>,
                  int)>();

  ffi.Pointer<ffi.Void> WOWNERO_WalletManager_createWalletFromPolyseed(
    ffi.Pointer<ffi.Void> wm_ptr,
    ffi.Pointer<ffi.Char> path,
    ffi.Pointer<ffi.Char> password,
    int nettype,
    ffi.Pointer<ffi.Char> mnemonic,
    ffi.Pointer<ffi.Char> passphrase,
    bool newWallet,
    int restore_height,
    int kdf_rounds,
  ) {
    return _WOWNERO_WalletManager_createWalletFromPolyseed(
      wm_ptr,
      path,
      password,
      nettype,
      mnemonic,
      passphrase,
      newWallet,
      restore_height,
      kdf_rounds,
    );
  }

  late final _WOWNERO_WalletManager_createWalletFromPolyseedPtr = _lookup<
      ffi.NativeFunction<
          ffi.Pointer<ffi.Void> Function(
              ffi.Pointer<ffi.Void>,
              ffi.Pointer<ffi.Char>,
              ffi.Pointer<ffi.Char>,
              ffi.Int,
              ffi.Pointer<ffi.Char>,
              ffi.Pointer<ffi.Char>,
              ffi.Bool,
              ffi.Uint64,
              ffi.Uint64)>>('WOWNERO_WalletManager_createWalletFromPolyseed');
  late final _WOWNERO_WalletManager_createWalletFromPolyseed =
      _WOWNERO_WalletManager_createWalletFromPolyseedPtr.asFunction<
          ffi.Pointer<ffi.Void> Function(
              ffi.Pointer<ffi.Void>,
              ffi.Pointer<ffi.Char>,
              ffi.Pointer<ffi.Char>,
              int,
              ffi.Pointer<ffi.Char>,
              ffi.Pointer<ffi.Char>,
              bool,
              int,
              int)>();

  bool WOWNERO_WalletManager_closeWallet(
    ffi.Pointer<ffi.Void> wm_ptr,
    ffi.Pointer<ffi.Void> wallet_ptr,
    bool store,
  ) {
    return _WOWNERO_WalletManager_closeWallet(
      wm_ptr,
      wallet_ptr,
      store,
    );
  }

  late final _WOWNERO_WalletManager_closeWalletPtr = _lookup<
      ffi.NativeFunction<
          ffi.Bool Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Void>,
              ffi.Bool)>>('WOWNERO_WalletManager_closeWallet');
  late final _WOWNERO_WalletManager_closeWallet =
      _WOWNERO_WalletManager_closeWalletPtr.asFunction<
          bool Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Void>, bool)>();

  bool WOWNERO_WalletManager_walletExists(
    ffi.Pointer<ffi.Void> wm_ptr,
    ffi.Pointer<ffi.Char> path,
  ) {
    return _WOWNERO_WalletManager_walletExists(
      wm_ptr,
      path,
    );
  }

  late final _WOWNERO_WalletManager_walletExistsPtr = _lookup<
      ffi.NativeFunction<
          ffi.Bool Function(ffi.Pointer<ffi.Void>,
              ffi.Pointer<ffi.Char>)>>('WOWNERO_WalletManager_walletExists');
  late final _WOWNERO_WalletManager_walletExists =
      _WOWNERO_WalletManager_walletExistsPtr.asFunction<
          bool Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();

  bool WOWNERO_WalletManager_verifyWalletPassword(
    ffi.Pointer<ffi.Void> wm_ptr,
    ffi.Pointer<ffi.Char> keys_file_name,
    ffi.Pointer<ffi.Char> password,
    bool no_spend_key,
    int kdf_rounds,
  ) {
    return _WOWNERO_WalletManager_verifyWalletPassword(
      wm_ptr,
      keys_file_name,
      password,
      no_spend_key,
      kdf_rounds,
    );
  }

  late final _WOWNERO_WalletManager_verifyWalletPasswordPtr = _lookup<
      ffi.NativeFunction<
          ffi.Bool Function(
              ffi.Pointer<ffi.Void>,
              ffi.Pointer<ffi.Char>,
              ffi.Pointer<ffi.Char>,
              ffi.Bool,
              ffi.Uint64)>>('WOWNERO_WalletManager_verifyWalletPassword');
  late final _WOWNERO_WalletManager_verifyWalletPassword =
      _WOWNERO_WalletManager_verifyWalletPasswordPtr.asFunction<
          bool Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>,
              ffi.Pointer<ffi.Char>, bool, int)>();

  ffi.Pointer<ffi.Char> WOWNERO_WalletManager_findWallets(
    ffi.Pointer<ffi.Void> wm_ptr,
    ffi.Pointer<ffi.Char> path,
    ffi.Pointer<ffi.Char> separator,
  ) {
    return _WOWNERO_WalletManager_findWallets(
      wm_ptr,
      path,
      separator,
    );
  }

  late final _WOWNERO_WalletManager_findWalletsPtr = _lookup<
      ffi.NativeFunction<
          ffi.Pointer<ffi.Char> Function(
              ffi.Pointer<ffi.Void>,
              ffi.Pointer<ffi.Char>,
              ffi.Pointer<ffi.Char>)>>('WOWNERO_WalletManager_findWallets');
  late final _WOWNERO_WalletManager_findWallets =
      _WOWNERO_WalletManager_findWalletsPtr.asFunction<
          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>,
              ffi.Pointer<ffi.Char>, ffi.Pointer<ffi.Char>)>();

  ffi.Pointer<ffi.Char> WOWNERO_WalletManager_errorString(
    ffi.Pointer<ffi.Void> wm_ptr,
  ) {
    return _WOWNERO_WalletManager_errorString(
      wm_ptr,
    );
  }

  late final _WOWNERO_WalletManager_errorStringPtr = _lookup<
      ffi.NativeFunction<
          ffi.Pointer<ffi.Char> Function(
              ffi.Pointer<ffi.Void>)>>('WOWNERO_WalletManager_errorString');
  late final _WOWNERO_WalletManager_errorString =
      _WOWNERO_WalletManager_errorStringPtr.asFunction<
          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>();

  void WOWNERO_WalletManager_setDaemonAddress(
    ffi.Pointer<ffi.Void> wm_ptr,
    ffi.Pointer<ffi.Char> address,
  ) {
    return _WOWNERO_WalletManager_setDaemonAddress(
      wm_ptr,
      address,
    );
  }

  late final _WOWNERO_WalletManager_setDaemonAddressPtr = _lookup<
          ffi.NativeFunction<
              ffi.Void Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>>(
      'WOWNERO_WalletManager_setDaemonAddress');
  late final _WOWNERO_WalletManager_setDaemonAddress =
      _WOWNERO_WalletManager_setDaemonAddressPtr.asFunction<
          void Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();

  int WOWNERO_WalletManager_blockchainHeight(
    ffi.Pointer<ffi.Void> wm_ptr,
  ) {
    return _WOWNERO_WalletManager_blockchainHeight(
      wm_ptr,
    );
  }

  late final _WOWNERO_WalletManager_blockchainHeightPtr =
      _lookup<ffi.NativeFunction<ffi.Uint64 Function(ffi.Pointer<ffi.Void>)>>(
          'WOWNERO_WalletManager_blockchainHeight');
  late final _WOWNERO_WalletManager_blockchainHeight =
      _WOWNERO_WalletManager_blockchainHeightPtr.asFunction<
          int Function(ffi.Pointer<ffi.Void>)>();

  int WOWNERO_WalletManager_blockchainTargetHeight(
    ffi.Pointer<ffi.Void> wm_ptr,
  ) {
    return _WOWNERO_WalletManager_blockchainTargetHeight(
      wm_ptr,
    );
  }

  late final _WOWNERO_WalletManager_blockchainTargetHeightPtr =
      _lookup<ffi.NativeFunction<ffi.Uint64 Function(ffi.Pointer<ffi.Void>)>>(
          'WOWNERO_WalletManager_blockchainTargetHeight');
  late final _WOWNERO_WalletManager_blockchainTargetHeight =
      _WOWNERO_WalletManager_blockchainTargetHeightPtr.asFunction<
          int Function(ffi.Pointer<ffi.Void>)>();

  int WOWNERO_WalletManager_networkDifficulty(
    ffi.Pointer<ffi.Void> wm_ptr,
  ) {
    return _WOWNERO_WalletManager_networkDifficulty(
      wm_ptr,
    );
  }

  late final _WOWNERO_WalletManager_networkDifficultyPtr =
      _lookup<ffi.NativeFunction<ffi.Uint64 Function(ffi.Pointer<ffi.Void>)>>(
          'WOWNERO_WalletManager_networkDifficulty');
  late final _WOWNERO_WalletManager_networkDifficulty =
      _WOWNERO_WalletManager_networkDifficultyPtr.asFunction<
          int Function(ffi.Pointer<ffi.Void>)>();

  double WOWNERO_WalletManager_miningHashRate(
    ffi.Pointer<ffi.Void> wm_ptr,
  ) {
    return _WOWNERO_WalletManager_miningHashRate(
      wm_ptr,
    );
  }

  late final _WOWNERO_WalletManager_miningHashRatePtr =
      _lookup<ffi.NativeFunction<ffi.Double Function(ffi.Pointer<ffi.Void>)>>(
          'WOWNERO_WalletManager_miningHashRate');
  late final _WOWNERO_WalletManager_miningHashRate =
      _WOWNERO_WalletManager_miningHashRatePtr.asFunction<
          double Function(ffi.Pointer<ffi.Void>)>();

  int WOWNERO_WalletManager_blockTarget(
    ffi.Pointer<ffi.Void> wm_ptr,
  ) {
    return _WOWNERO_WalletManager_blockTarget(
      wm_ptr,
    );
  }

  late final _WOWNERO_WalletManager_blockTargetPtr =
      _lookup<ffi.NativeFunction<ffi.Uint64 Function(ffi.Pointer<ffi.Void>)>>(
          'WOWNERO_WalletManager_blockTarget');
  late final _WOWNERO_WalletManager_blockTarget =
      _WOWNERO_WalletManager_blockTargetPtr.asFunction<
          int Function(ffi.Pointer<ffi.Void>)>();

  bool WOWNERO_WalletManager_isMining(
    ffi.Pointer<ffi.Void> wm_ptr,
  ) {
    return _WOWNERO_WalletManager_isMining(
      wm_ptr,
    );
  }

  late final _WOWNERO_WalletManager_isMiningPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(ffi.Pointer<ffi.Void>)>>(
          'WOWNERO_WalletManager_isMining');
  late final _WOWNERO_WalletManager_isMining =
      _WOWNERO_WalletManager_isMiningPtr.asFunction<
          bool Function(ffi.Pointer<ffi.Void>)>();

  bool WOWNERO_WalletManager_startMining(
    ffi.Pointer<ffi.Void> wm_ptr,
    ffi.Pointer<ffi.Char> address,
    int threads,
    bool backgroundMining,
    bool ignoreBattery,
  ) {
    return _WOWNERO_WalletManager_startMining(
      wm_ptr,
      address,
      threads,
      backgroundMining,
      ignoreBattery,
    );
  }

  late final _WOWNERO_WalletManager_startMiningPtr = _lookup<
      ffi.NativeFunction<
          ffi.Bool Function(
              ffi.Pointer<ffi.Void>,
              ffi.Pointer<ffi.Char>,
              ffi.Uint32,
              ffi.Bool,
              ffi.Bool)>>('WOWNERO_WalletManager_startMining');
  late final _WOWNERO_WalletManager_startMining =
      _WOWNERO_WalletManager_startMiningPtr.asFunction<
          bool Function(
              ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>, int, bool, bool)>();

  bool WOWNERO_WalletManager_stopMining(
    ffi.Pointer<ffi.Void> wm_ptr,
    ffi.Pointer<ffi.Char> address,
  ) {
    return _WOWNERO_WalletManager_stopMining(
      wm_ptr,
      address,
    );
  }

  late final _WOWNERO_WalletManager_stopMiningPtr = _lookup<
      ffi.NativeFunction<
          ffi.Bool Function(ffi.Pointer<ffi.Void>,
              ffi.Pointer<ffi.Char>)>>('WOWNERO_WalletManager_stopMining');
  late final _WOWNERO_WalletManager_stopMining =
      _WOWNERO_WalletManager_stopMiningPtr.asFunction<
          bool Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();

  ffi.Pointer<ffi.Char> WOWNERO_WalletManager_resolveOpenAlias(
    ffi.Pointer<ffi.Void> wm_ptr,
    ffi.Pointer<ffi.Char> address,
    bool dnssec_valid,
  ) {
    return _WOWNERO_WalletManager_resolveOpenAlias(
      wm_ptr,
      address,
      dnssec_valid,
    );
  }

  late final _WOWNERO_WalletManager_resolveOpenAliasPtr = _lookup<
      ffi.NativeFunction<
          ffi.Pointer<ffi.Char> Function(
              ffi.Pointer<ffi.Void>,
              ffi.Pointer<ffi.Char>,
              ffi.Bool)>>('WOWNERO_WalletManager_resolveOpenAlias');
  late final _WOWNERO_WalletManager_resolveOpenAlias =
      _WOWNERO_WalletManager_resolveOpenAliasPtr.asFunction<
          ffi.Pointer<ffi.Char> Function(
              ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>, bool)>();

  bool WOWNERO_WalletManager_setProxy(
    ffi.Pointer<ffi.Void> wm_ptr,
    ffi.Pointer<ffi.Char> address,
  ) {
    return _WOWNERO_WalletManager_setProxy(
      wm_ptr,
      address,
    );
  }

  late final _WOWNERO_WalletManager_setProxyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Bool Function(ffi.Pointer<ffi.Void>,
              ffi.Pointer<ffi.Char>)>>('WOWNERO_WalletManager_setProxy');
  late final _WOWNERO_WalletManager_setProxy =
      _WOWNERO_WalletManager_setProxyPtr.asFunction<
          bool Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();

  ffi.Pointer<ffi.Void> WOWNERO_WalletManagerFactory_getWalletManager() {
    return _WOWNERO_WalletManagerFactory_getWalletManager();
  }

  late final _WOWNERO_WalletManagerFactory_getWalletManagerPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Void> Function()>>(
          'WOWNERO_WalletManagerFactory_getWalletManager');
  late final _WOWNERO_WalletManagerFactory_getWalletManager =
      _WOWNERO_WalletManagerFactory_getWalletManagerPtr.asFunction<
          ffi.Pointer<ffi.Void> Function()>();

  void WOWNERO_WalletManagerFactory_setLogLevel(
    int level,
  ) {
    return _WOWNERO_WalletManagerFactory_setLogLevel(
      level,
    );
  }

  late final _WOWNERO_WalletManagerFactory_setLogLevelPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Int)>>(
          'WOWNERO_WalletManagerFactory_setLogLevel');
  late final _WOWNERO_WalletManagerFactory_setLogLevel =
      _WOWNERO_WalletManagerFactory_setLogLevelPtr.asFunction<
          void Function(int)>();

  void WOWNERO_WalletManagerFactory_setLogCategories(
    ffi.Pointer<ffi.Char> categories,
  ) {
    return _WOWNERO_WalletManagerFactory_setLogCategories(
      categories,
    );
  }

  late final _WOWNERO_WalletManagerFactory_setLogCategoriesPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Char>)>>(
          'WOWNERO_WalletManagerFactory_setLogCategories');
  late final _WOWNERO_WalletManagerFactory_setLogCategories =
      _WOWNERO_WalletManagerFactory_setLogCategoriesPtr.asFunction<
          void Function(ffi.Pointer<ffi.Char>)>();

  void WOWNERO_DEBUG_test0() {
    return _WOWNERO_DEBUG_test0();
  }

  late final _WOWNERO_DEBUG_test0Ptr =
      _lookup<ffi.NativeFunction<ffi.Void Function()>>('WOWNERO_DEBUG_test0');
  late final _WOWNERO_DEBUG_test0 =
      _WOWNERO_DEBUG_test0Ptr.asFunction<void Function()>();

  bool WOWNERO_DEBUG_test1(
    bool x,
  ) {
    return _WOWNERO_DEBUG_test1(
      x,
    );
  }

  late final _WOWNERO_DEBUG_test1Ptr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(ffi.Bool)>>(
          'WOWNERO_DEBUG_test1');
  late final _WOWNERO_DEBUG_test1 =
      _WOWNERO_DEBUG_test1Ptr.asFunction<bool Function(bool)>();

  int WOWNERO_DEBUG_test2(
    int x,
  ) {
    return _WOWNERO_DEBUG_test2(
      x,
    );
  }

  late final _WOWNERO_DEBUG_test2Ptr =
      _lookup<ffi.NativeFunction<ffi.Int Function(ffi.Int)>>(
          'WOWNERO_DEBUG_test2');
  late final _WOWNERO_DEBUG_test2 =
      _WOWNERO_DEBUG_test2Ptr.asFunction<int Function(int)>();

  int WOWNERO_DEBUG_test3(
    int x,
  ) {
    return _WOWNERO_DEBUG_test3(
      x,
    );
  }

  late final _WOWNERO_DEBUG_test3Ptr =
      _lookup<ffi.NativeFunction<ffi.Uint64 Function(ffi.Uint64)>>(
          'WOWNERO_DEBUG_test3');
  late final _WOWNERO_DEBUG_test3 =
      _WOWNERO_DEBUG_test3Ptr.asFunction<int Function(int)>();

  ffi.Pointer<ffi.Void> WOWNERO_DEBUG_test4(
    int x,
  ) {
    return _WOWNERO_DEBUG_test4(
      x,
    );
  }

  late final _WOWNERO_DEBUG_test4Ptr =
      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Void> Function(ffi.Uint64)>>(
          'WOWNERO_DEBUG_test4');
  late final _WOWNERO_DEBUG_test4 =
      _WOWNERO_DEBUG_test4Ptr.asFunction<ffi.Pointer<ffi.Void> Function(int)>();

  ffi.Pointer<ffi.Char> WOWNERO_DEBUG_test5() {
    return _WOWNERO_DEBUG_test5();
  }

  late final _WOWNERO_DEBUG_test5Ptr =
      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Char> Function()>>(
          'WOWNERO_DEBUG_test5');
  late final _WOWNERO_DEBUG_test5 =
      _WOWNERO_DEBUG_test5Ptr.asFunction<ffi.Pointer<ffi.Char> Function()>();

  ffi.Pointer<ffi.Char> WOWNERO_DEBUG_test5_std() {
    return _WOWNERO_DEBUG_test5_std();
  }

  late final _WOWNERO_DEBUG_test5_stdPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Char> Function()>>(
          'WOWNERO_DEBUG_test5_std');
  late final _WOWNERO_DEBUG_test5_std = _WOWNERO_DEBUG_test5_stdPtr.asFunction<
      ffi.Pointer<ffi.Char> Function()>();

  bool WOWNERO_DEBUG_isPointerNull(
    ffi.Pointer<ffi.Void> wallet_ptr,
  ) {
    return _WOWNERO_DEBUG_isPointerNull(
      wallet_ptr,
    );
  }

  late final _WOWNERO_DEBUG_isPointerNullPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(ffi.Pointer<ffi.Void>)>>(
          'WOWNERO_DEBUG_isPointerNull');
  late final _WOWNERO_DEBUG_isPointerNull = _WOWNERO_DEBUG_isPointerNullPtr
      .asFunction<bool Function(ffi.Pointer<ffi.Void>)>();

  ffi.Pointer<ffi.Void> WOWNERO_cw_getWalletListener(
    ffi.Pointer<ffi.Void> wallet_ptr,
  ) {
    return _WOWNERO_cw_getWalletListener(
      wallet_ptr,
    );
  }

  late final _WOWNERO_cw_getWalletListenerPtr = _lookup<
      ffi.NativeFunction<
          ffi.Pointer<ffi.Void> Function(
              ffi.Pointer<ffi.Void>)>>('WOWNERO_cw_getWalletListener');
  late final _WOWNERO_cw_getWalletListener = _WOWNERO_cw_getWalletListenerPtr
      .asFunction<ffi.Pointer<ffi.Void> Function(ffi.Pointer<ffi.Void>)>();

  void WOWNERO_cw_WalletListener_resetNeedToRefresh(
    ffi.Pointer<ffi.Void> cw_walletListener_ptr,
  ) {
    return _WOWNERO_cw_WalletListener_resetNeedToRefresh(
      cw_walletListener_ptr,
    );
  }

  late final _WOWNERO_cw_WalletListener_resetNeedToRefreshPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>)>>(
          'WOWNERO_cw_WalletListener_resetNeedToRefresh');
  late final _WOWNERO_cw_WalletListener_resetNeedToRefresh =
      _WOWNERO_cw_WalletListener_resetNeedToRefreshPtr.asFunction<
          void Function(ffi.Pointer<ffi.Void>)>();

  bool WOWNERO_cw_WalletListener_isNeedToRefresh(
    ffi.Pointer<ffi.Void> cw_walletListener_ptr,
  ) {
    return _WOWNERO_cw_WalletListener_isNeedToRefresh(
      cw_walletListener_ptr,
    );
  }

  late final _WOWNERO_cw_WalletListener_isNeedToRefreshPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(ffi.Pointer<ffi.Void>)>>(
          'WOWNERO_cw_WalletListener_isNeedToRefresh');
  late final _WOWNERO_cw_WalletListener_isNeedToRefresh =
      _WOWNERO_cw_WalletListener_isNeedToRefreshPtr.asFunction<
          bool Function(ffi.Pointer<ffi.Void>)>();

  bool WOWNERO_cw_WalletListener_isNewTransactionExist(
    ffi.Pointer<ffi.Void> cw_walletListener_ptr,
  ) {
    return _WOWNERO_cw_WalletListener_isNewTransactionExist(
      cw_walletListener_ptr,
    );
  }

  late final _WOWNERO_cw_WalletListener_isNewTransactionExistPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(ffi.Pointer<ffi.Void>)>>(
          'WOWNERO_cw_WalletListener_isNewTransactionExist');
  late final _WOWNERO_cw_WalletListener_isNewTransactionExist =
      _WOWNERO_cw_WalletListener_isNewTransactionExistPtr.asFunction<
          bool Function(ffi.Pointer<ffi.Void>)>();

  void WOWNERO_cw_WalletListener_resetIsNewTransactionExist(
    ffi.Pointer<ffi.Void> cw_walletListener_ptr,
  ) {
    return _WOWNERO_cw_WalletListener_resetIsNewTransactionExist(
      cw_walletListener_ptr,
    );
  }

  late final _WOWNERO_cw_WalletListener_resetIsNewTransactionExistPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>)>>(
          'WOWNERO_cw_WalletListener_resetIsNewTransactionExist');
  late final _WOWNERO_cw_WalletListener_resetIsNewTransactionExist =
      _WOWNERO_cw_WalletListener_resetIsNewTransactionExistPtr.asFunction<
          void Function(ffi.Pointer<ffi.Void>)>();

  int WOWNERO_cw_WalletListener_height(
    ffi.Pointer<ffi.Void> cw_walletListener_ptr,
  ) {
    return _WOWNERO_cw_WalletListener_height(
      cw_walletListener_ptr,
    );
  }

  late final _WOWNERO_cw_WalletListener_heightPtr =
      _lookup<ffi.NativeFunction<ffi.Uint64 Function(ffi.Pointer<ffi.Void>)>>(
          'WOWNERO_cw_WalletListener_height');
  late final _WOWNERO_cw_WalletListener_height =
      _WOWNERO_cw_WalletListener_heightPtr.asFunction<
          int Function(ffi.Pointer<ffi.Void>)>();

  ffi.Pointer<ffi.Void> WOWNERO_deprecated_restore14WordSeed(
    ffi.Pointer<ffi.Char> path,
    ffi.Pointer<ffi.Char> password,
    ffi.Pointer<ffi.Char> seed,
    int networkType,
  ) {
    return _WOWNERO_deprecated_restore14WordSeed(
      path,
      password,
      seed,
      networkType,
    );
  }

  late final _WOWNERO_deprecated_restore14WordSeedPtr = _lookup<
      ffi.NativeFunction<
          ffi.Pointer<ffi.Void> Function(
              ffi.Pointer<ffi.Char>,
              ffi.Pointer<ffi.Char>,
              ffi.Pointer<ffi.Char>,
              ffi.Int32)>>('WOWNERO_deprecated_restore14WordSeed');
  late final _WOWNERO_deprecated_restore14WordSeed =
      _WOWNERO_deprecated_restore14WordSeedPtr.asFunction<
          ffi.Pointer<ffi.Void> Function(ffi.Pointer<ffi.Char>,
              ffi.Pointer<ffi.Char>, ffi.Pointer<ffi.Char>, int)>();

  ffi.Pointer<ffi.Void> WOWNERO_deprecated_create14WordSeed(
    ffi.Pointer<ffi.Char> path,
    ffi.Pointer<ffi.Char> password,
    ffi.Pointer<ffi.Char> language,
    int networkType,
  ) {
    return _WOWNERO_deprecated_create14WordSeed(
      path,
      password,
      language,
      networkType,
    );
  }

  late final _WOWNERO_deprecated_create14WordSeedPtr = _lookup<
      ffi.NativeFunction<
          ffi.Pointer<ffi.Void> Function(
              ffi.Pointer<ffi.Char>,
              ffi.Pointer<ffi.Char>,
              ffi.Pointer<ffi.Char>,
              ffi.Int32)>>('WOWNERO_deprecated_create14WordSeed');
  late final _WOWNERO_deprecated_create14WordSeed =
      _WOWNERO_deprecated_create14WordSeedPtr.asFunction<
          ffi.Pointer<ffi.Void> Function(ffi.Pointer<ffi.Char>,
              ffi.Pointer<ffi.Char>, ffi.Pointer<ffi.Char>, int)>();

  int WOWNERO_deprecated_14WordSeedHeight(
    ffi.Pointer<ffi.Char> seed,
  ) {
    return _WOWNERO_deprecated_14WordSeedHeight(
      seed,
    );
  }

  late final _WOWNERO_deprecated_14WordSeedHeightPtr =
      _lookup<ffi.NativeFunction<ffi.Uint64 Function(ffi.Pointer<ffi.Char>)>>(
          'WOWNERO_deprecated_14WordSeedHeight');
  late final _WOWNERO_deprecated_14WordSeedHeight =
      _WOWNERO_deprecated_14WordSeedHeightPtr.asFunction<
          int Function(ffi.Pointer<ffi.Char>)>();

  void WOWNERO_free(
    ffi.Pointer<ffi.Void> ptr,
  ) {
    return _WOWNERO_free(
      ptr,
    );
  }

  late final _WOWNERO_freePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>)>>(
          'WOWNERO_free');
  late final _WOWNERO_free =
      _WOWNERO_freePtr.asFunction<void Function(ffi.Pointer<ffi.Void>)>();

  ffi.Pointer<ffi.Char> WOWNERO_checksum_wallet2_api_c_h() {
    return _WOWNERO_checksum_wallet2_api_c_h();
  }

  late final _WOWNERO_checksum_wallet2_api_c_hPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Char> Function()>>(
          'WOWNERO_checksum_wallet2_api_c_h');
  late final _WOWNERO_checksum_wallet2_api_c_h =
      _WOWNERO_checksum_wallet2_api_c_hPtr.asFunction<
          ffi.Pointer<ffi.Char> Function()>();

  ffi.Pointer<ffi.Char> WOWNERO_checksum_wallet2_api_c_cpp() {
    return _WOWNERO_checksum_wallet2_api_c_cpp();
  }

  late final _WOWNERO_checksum_wallet2_api_c_cppPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Char> Function()>>(
          'WOWNERO_checksum_wallet2_api_c_cpp');
  late final _WOWNERO_checksum_wallet2_api_c_cpp =
      _WOWNERO_checksum_wallet2_api_c_cppPtr.asFunction<
          ffi.Pointer<ffi.Char> Function()>();

  ffi.Pointer<ffi.Char> WOWNERO_checksum_wallet2_api_c_exp() {
    return _WOWNERO_checksum_wallet2_api_c_exp();
  }

  late final _WOWNERO_checksum_wallet2_api_c_expPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Char> Function()>>(
          'WOWNERO_checksum_wallet2_api_c_exp');
  late final _WOWNERO_checksum_wallet2_api_c_exp =
      _WOWNERO_checksum_wallet2_api_c_expPtr.asFunction<
          ffi.Pointer<ffi.Char> Function()>();
}