TransactionEvent.h

 
#pragma once
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/managedblockchain-query/ManagedBlockchainQuery_EXPORTS.h>
#include <aws/managedblockchain-query/model/BlockchainInstant.h>
#include <aws/managedblockchain-query/model/ConfirmationStatus.h>
#include <aws/managedblockchain-query/model/QueryNetwork.h>
#include <aws/managedblockchain-query/model/QueryTransactionEventType.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace ManagedBlockchainQuery {
namespace Model {
 
class TransactionEvent {
 public:
  AWS_MANAGEDBLOCKCHAINQUERY_API TransactionEvent() = default;
  AWS_MANAGEDBLOCKCHAINQUERY_API TransactionEvent(Aws::Utils::Json::JsonView jsonValue);
  AWS_MANAGEDBLOCKCHAINQUERY_API TransactionEvent& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_MANAGEDBLOCKCHAINQUERY_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline QueryNetwork GetNetwork() const { return m_network; }
  inline bool NetworkHasBeenSet() const { return m_networkHasBeenSet; }
  inline void SetNetwork(QueryNetwork value) {
    m_networkHasBeenSet = true;
    m_network = value;
  }
  inline TransactionEvent& WithNetwork(QueryNetwork value) {
    SetNetwork(value);
    return *this;
  }
 
 
  inline const Aws::String& GetTransactionHash() const { return m_transactionHash; }
  inline bool TransactionHashHasBeenSet() const { return m_transactionHashHasBeenSet; }
  template <typename TransactionHashT = Aws::String>
  void SetTransactionHash(TransactionHashT&& value) {
    m_transactionHashHasBeenSet = true;
    m_transactionHash = std::forward<TransactionHashT>(value);
  }
  template <typename TransactionHashT = Aws::String>
  TransactionEvent& WithTransactionHash(TransactionHashT&& value) {
    SetTransactionHash(std::forward<TransactionHashT>(value));
    return *this;
  }
 
 
  inline QueryTransactionEventType GetEventType() const { return m_eventType; }
  inline bool EventTypeHasBeenSet() const { return m_eventTypeHasBeenSet; }
  inline void SetEventType(QueryTransactionEventType value) {
    m_eventTypeHasBeenSet = true;
    m_eventType = value;
  }
  inline TransactionEvent& WithEventType(QueryTransactionEventType value) {
    SetEventType(value);
    return *this;
  }
 
 
  inline const Aws::String& GetFrom() const { return m_from; }
  inline bool FromHasBeenSet() const { return m_fromHasBeenSet; }
  template <typename FromT = Aws::String>
  void SetFrom(FromT&& value) {
    m_fromHasBeenSet = true;
    m_from = std::forward<FromT>(value);
  }
  template <typename FromT = Aws::String>
  TransactionEvent& WithFrom(FromT&& value) {
    SetFrom(std::forward<FromT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetTo() const { return m_to; }
  inline bool ToHasBeenSet() const { return m_toHasBeenSet; }
  template <typename ToT = Aws::String>
  void SetTo(ToT&& value) {
    m_toHasBeenSet = true;
    m_to = std::forward<ToT>(value);
  }
  template <typename ToT = Aws::String>
  TransactionEvent& WithTo(ToT&& value) {
    SetTo(std::forward<ToT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetValue() const { return m_value; }
  inline bool ValueHasBeenSet() const { return m_valueHasBeenSet; }
  template <typename ValueT = Aws::String>
  void SetValue(ValueT&& value) {
    m_valueHasBeenSet = true;
    m_value = std::forward<ValueT>(value);
  }
  template <typename ValueT = Aws::String>
  TransactionEvent& WithValue(ValueT&& value) {
    SetValue(std::forward<ValueT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetContractAddress() const { return m_contractAddress; }
  inline bool ContractAddressHasBeenSet() const { return m_contractAddressHasBeenSet; }
  template <typename ContractAddressT = Aws::String>
  void SetContractAddress(ContractAddressT&& value) {
    m_contractAddressHasBeenSet = true;
    m_contractAddress = std::forward<ContractAddressT>(value);
  }
  template <typename ContractAddressT = Aws::String>
  TransactionEvent& WithContractAddress(ContractAddressT&& value) {
    SetContractAddress(std::forward<ContractAddressT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetTokenId() const { return m_tokenId; }
  inline bool TokenIdHasBeenSet() const { return m_tokenIdHasBeenSet; }
  template <typename TokenIdT = Aws::String>
  void SetTokenId(TokenIdT&& value) {
    m_tokenIdHasBeenSet = true;
    m_tokenId = std::forward<TokenIdT>(value);
  }
  template <typename TokenIdT = Aws::String>
  TransactionEvent& WithTokenId(TokenIdT&& value) {
    SetTokenId(std::forward<TokenIdT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetTransactionId() const { return m_transactionId; }
  inline bool TransactionIdHasBeenSet() const { return m_transactionIdHasBeenSet; }
  template <typename TransactionIdT = Aws::String>
  void SetTransactionId(TransactionIdT&& value) {
    m_transactionIdHasBeenSet = true;
    m_transactionId = std::forward<TransactionIdT>(value);
  }
  template <typename TransactionIdT = Aws::String>
  TransactionEvent& WithTransactionId(TransactionIdT&& value) {
    SetTransactionId(std::forward<TransactionIdT>(value));
    return *this;
  }
 
 
  inline int GetVoutIndex() const { return m_voutIndex; }
  inline bool VoutIndexHasBeenSet() const { return m_voutIndexHasBeenSet; }
  inline void SetVoutIndex(int value) {
    m_voutIndexHasBeenSet = true;
    m_voutIndex = value;
  }
  inline TransactionEvent& WithVoutIndex(int value) {
    SetVoutIndex(value);
    return *this;
  }
 
 
  inline bool GetVoutSpent() const { return m_voutSpent; }
  inline bool VoutSpentHasBeenSet() const { return m_voutSpentHasBeenSet; }
  inline void SetVoutSpent(bool value) {
    m_voutSpentHasBeenSet = true;
    m_voutSpent = value;
  }
  inline TransactionEvent& WithVoutSpent(bool value) {
    SetVoutSpent(value);
    return *this;
  }
 
 
  inline const Aws::String& GetSpentVoutTransactionId() const { return m_spentVoutTransactionId; }
  inline bool SpentVoutTransactionIdHasBeenSet() const { return m_spentVoutTransactionIdHasBeenSet; }
  template <typename SpentVoutTransactionIdT = Aws::String>
  void SetSpentVoutTransactionId(SpentVoutTransactionIdT&& value) {
    m_spentVoutTransactionIdHasBeenSet = true;
    m_spentVoutTransactionId = std::forward<SpentVoutTransactionIdT>(value);
  }
  template <typename SpentVoutTransactionIdT = Aws::String>
  TransactionEvent& WithSpentVoutTransactionId(SpentVoutTransactionIdT&& value) {
    SetSpentVoutTransactionId(std::forward<SpentVoutTransactionIdT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetSpentVoutTransactionHash() const { return m_spentVoutTransactionHash; }
  inline bool SpentVoutTransactionHashHasBeenSet() const { return m_spentVoutTransactionHashHasBeenSet; }
  template <typename SpentVoutTransactionHashT = Aws::String>
  void SetSpentVoutTransactionHash(SpentVoutTransactionHashT&& value) {
    m_spentVoutTransactionHashHasBeenSet = true;
    m_spentVoutTransactionHash = std::forward<SpentVoutTransactionHashT>(value);
  }
  template <typename SpentVoutTransactionHashT = Aws::String>
  TransactionEvent& WithSpentVoutTransactionHash(SpentVoutTransactionHashT&& value) {
    SetSpentVoutTransactionHash(std::forward<SpentVoutTransactionHashT>(value));
    return *this;
  }
 
 
  inline int GetSpentVoutIndex() const { return m_spentVoutIndex; }
  inline bool SpentVoutIndexHasBeenSet() const { return m_spentVoutIndexHasBeenSet; }
  inline void SetSpentVoutIndex(int value) {
    m_spentVoutIndexHasBeenSet = true;
    m_spentVoutIndex = value;
  }
  inline TransactionEvent& WithSpentVoutIndex(int value) {
    SetSpentVoutIndex(value);
    return *this;
  }
 
 
  inline const BlockchainInstant& GetBlockchainInstant() const { return m_blockchainInstant; }
  inline bool BlockchainInstantHasBeenSet() const { return m_blockchainInstantHasBeenSet; }
  template <typename BlockchainInstantT = BlockchainInstant>
  void SetBlockchainInstant(BlockchainInstantT&& value) {
    m_blockchainInstantHasBeenSet = true;
    m_blockchainInstant = std::forward<BlockchainInstantT>(value);
  }
  template <typename BlockchainInstantT = BlockchainInstant>
  TransactionEvent& WithBlockchainInstant(BlockchainInstantT&& value) {
    SetBlockchainInstant(std::forward<BlockchainInstantT>(value));
    return *this;
  }
 
 
  inline ConfirmationStatus GetConfirmationStatus() const { return m_confirmationStatus; }
  inline bool ConfirmationStatusHasBeenSet() const { return m_confirmationStatusHasBeenSet; }
  inline void SetConfirmationStatus(ConfirmationStatus value) {
    m_confirmationStatusHasBeenSet = true;
    m_confirmationStatus = value;
  }
  inline TransactionEvent& WithConfirmationStatus(ConfirmationStatus value) {
    SetConfirmationStatus(value);
    return *this;
  }
 private:
  QueryNetwork m_network{QueryNetwork::NOT_SET};
 
  Aws::String m_transactionHash;
 
  QueryTransactionEventType m_eventType{QueryTransactionEventType::NOT_SET};
 
  Aws::String m_from;
 
  Aws::String m_to;
 
  Aws::String m_value;
 
  Aws::String m_contractAddress;
 
  Aws::String m_tokenId;
 
  Aws::String m_transactionId;
 
  int m_voutIndex{0};
 
  bool m_voutSpent{false};
 
  Aws::String m_spentVoutTransactionId;
 
  Aws::String m_spentVoutTransactionHash;
 
  int m_spentVoutIndex{0};
 
  BlockchainInstant m_blockchainInstant;
 
  ConfirmationStatus m_confirmationStatus{ConfirmationStatus::NOT_SET};
  bool m_networkHasBeenSet = false;
  bool m_transactionHashHasBeenSet = false;
  bool m_eventTypeHasBeenSet = false;
  bool m_fromHasBeenSet = false;
  bool m_toHasBeenSet = false;
  bool m_valueHasBeenSet = false;
  bool m_contractAddressHasBeenSet = false;
  bool m_tokenIdHasBeenSet = false;
  bool m_transactionIdHasBeenSet = false;
  bool m_voutIndexHasBeenSet = false;
  bool m_voutSpentHasBeenSet = false;
  bool m_spentVoutTransactionIdHasBeenSet = false;
  bool m_spentVoutTransactionHashHasBeenSet = false;
  bool m_spentVoutIndexHasBeenSet = false;
  bool m_blockchainInstantHasBeenSet = false;
  bool m_confirmationStatusHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace ManagedBlockchainQuery
}  // namespace Aws