SavingsPlansPurchaseAnalysisConfiguration.h

 
#pragma once
#include <aws/ce/CostExplorer_EXPORTS.h>
#include <aws/ce/model/AccountScope.h>
#include <aws/ce/model/AnalysisType.h>
#include <aws/ce/model/DateInterval.h>
#include <aws/ce/model/SavingsPlans.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace CostExplorer {
namespace Model {
 
class SavingsPlansPurchaseAnalysisConfiguration {
 public:
  AWS_COSTEXPLORER_API SavingsPlansPurchaseAnalysisConfiguration() = default;
  AWS_COSTEXPLORER_API SavingsPlansPurchaseAnalysisConfiguration(Aws::Utils::Json::JsonView jsonValue);
  AWS_COSTEXPLORER_API SavingsPlansPurchaseAnalysisConfiguration& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_COSTEXPLORER_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline AccountScope GetAccountScope() const { return m_accountScope; }
  inline bool AccountScopeHasBeenSet() const { return m_accountScopeHasBeenSet; }
  inline void SetAccountScope(AccountScope value) {
    m_accountScopeHasBeenSet = true;
    m_accountScope = value;
  }
  inline SavingsPlansPurchaseAnalysisConfiguration& WithAccountScope(AccountScope value) {
    SetAccountScope(value);
    return *this;
  }
 
 
  inline const Aws::String& GetAccountId() const { return m_accountId; }
  inline bool AccountIdHasBeenSet() const { return m_accountIdHasBeenSet; }
  template <typename AccountIdT = Aws::String>
  void SetAccountId(AccountIdT&& value) {
    m_accountIdHasBeenSet = true;
    m_accountId = std::forward<AccountIdT>(value);
  }
  template <typename AccountIdT = Aws::String>
  SavingsPlansPurchaseAnalysisConfiguration& WithAccountId(AccountIdT&& value) {
    SetAccountId(std::forward<AccountIdT>(value));
    return *this;
  }
 
 
  inline AnalysisType GetAnalysisType() const { return m_analysisType; }
  inline bool AnalysisTypeHasBeenSet() const { return m_analysisTypeHasBeenSet; }
  inline void SetAnalysisType(AnalysisType value) {
    m_analysisTypeHasBeenSet = true;
    m_analysisType = value;
  }
  inline SavingsPlansPurchaseAnalysisConfiguration& WithAnalysisType(AnalysisType value) {
    SetAnalysisType(value);
    return *this;
  }
 
 
  inline const Aws::Vector<SavingsPlans>& GetSavingsPlansToAdd() const { return m_savingsPlansToAdd; }
  inline bool SavingsPlansToAddHasBeenSet() const { return m_savingsPlansToAddHasBeenSet; }
  template <typename SavingsPlansToAddT = Aws::Vector<SavingsPlans>>
  void SetSavingsPlansToAdd(SavingsPlansToAddT&& value) {
    m_savingsPlansToAddHasBeenSet = true;
    m_savingsPlansToAdd = std::forward<SavingsPlansToAddT>(value);
  }
  template <typename SavingsPlansToAddT = Aws::Vector<SavingsPlans>>
  SavingsPlansPurchaseAnalysisConfiguration& WithSavingsPlansToAdd(SavingsPlansToAddT&& value) {
    SetSavingsPlansToAdd(std::forward<SavingsPlansToAddT>(value));
    return *this;
  }
  template <typename SavingsPlansToAddT = SavingsPlans>
  SavingsPlansPurchaseAnalysisConfiguration& AddSavingsPlansToAdd(SavingsPlansToAddT&& value) {
    m_savingsPlansToAddHasBeenSet = true;
    m_savingsPlansToAdd.emplace_back(std::forward<SavingsPlansToAddT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<Aws::String>& GetSavingsPlansToExclude() const { return m_savingsPlansToExclude; }
  inline bool SavingsPlansToExcludeHasBeenSet() const { return m_savingsPlansToExcludeHasBeenSet; }
  template <typename SavingsPlansToExcludeT = Aws::Vector<Aws::String>>
  void SetSavingsPlansToExclude(SavingsPlansToExcludeT&& value) {
    m_savingsPlansToExcludeHasBeenSet = true;
    m_savingsPlansToExclude = std::forward<SavingsPlansToExcludeT>(value);
  }
  template <typename SavingsPlansToExcludeT = Aws::Vector<Aws::String>>
  SavingsPlansPurchaseAnalysisConfiguration& WithSavingsPlansToExclude(SavingsPlansToExcludeT&& value) {
    SetSavingsPlansToExclude(std::forward<SavingsPlansToExcludeT>(value));
    return *this;
  }
  template <typename SavingsPlansToExcludeT = Aws::String>
  SavingsPlansPurchaseAnalysisConfiguration& AddSavingsPlansToExclude(SavingsPlansToExcludeT&& value) {
    m_savingsPlansToExcludeHasBeenSet = true;
    m_savingsPlansToExclude.emplace_back(std::forward<SavingsPlansToExcludeT>(value));
    return *this;
  }
 
 
  inline const DateInterval& GetLookBackTimePeriod() const { return m_lookBackTimePeriod; }
  inline bool LookBackTimePeriodHasBeenSet() const { return m_lookBackTimePeriodHasBeenSet; }
  template <typename LookBackTimePeriodT = DateInterval>
  void SetLookBackTimePeriod(LookBackTimePeriodT&& value) {
    m_lookBackTimePeriodHasBeenSet = true;
    m_lookBackTimePeriod = std::forward<LookBackTimePeriodT>(value);
  }
  template <typename LookBackTimePeriodT = DateInterval>
  SavingsPlansPurchaseAnalysisConfiguration& WithLookBackTimePeriod(LookBackTimePeriodT&& value) {
    SetLookBackTimePeriod(std::forward<LookBackTimePeriodT>(value));
    return *this;
  }
 private:
  AccountScope m_accountScope{AccountScope::NOT_SET};
 
  Aws::String m_accountId;
 
  AnalysisType m_analysisType{AnalysisType::NOT_SET};
 
  Aws::Vector<SavingsPlans> m_savingsPlansToAdd;
 
  Aws::Vector<Aws::String> m_savingsPlansToExclude;
 
  DateInterval m_lookBackTimePeriod;
  bool m_accountScopeHasBeenSet = false;
  bool m_accountIdHasBeenSet = false;
  bool m_analysisTypeHasBeenSet = false;
  bool m_savingsPlansToAddHasBeenSet = false;
  bool m_savingsPlansToExcludeHasBeenSet = false;
  bool m_lookBackTimePeriodHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace CostExplorer
}  // namespace Aws