ExportLicenseRecommendationsRequest.h

 
#pragma once
#include <aws/compute-optimizer/ComputeOptimizerRequest.h>
#include <aws/compute-optimizer/ComputeOptimizer_EXPORTS.h>
#include <aws/compute-optimizer/model/ExportableLicenseField.h>
#include <aws/compute-optimizer/model/FileFormat.h>
#include <aws/compute-optimizer/model/LicenseRecommendationFilter.h>
#include <aws/compute-optimizer/model/S3DestinationConfig.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
 
#include <utility>
 
namespace Aws {
namespace ComputeOptimizer {
namespace Model {
 
class ExportLicenseRecommendationsRequest : public ComputeOptimizerRequest {
 public:
  AWS_COMPUTEOPTIMIZER_API ExportLicenseRecommendationsRequest() = default;
 
  // Service request name is the Operation name which will send this request out,
  // each operation should has unique request name, so that we can get operation's name from this request.
  // Note: this is not true for response, multiple operations may have the same response name,
  // so we can not get operation's name from response.
  inline virtual const char* GetServiceRequestName() const override { return "ExportLicenseRecommendations"; }
 
  AWS_COMPUTEOPTIMIZER_API Aws::String SerializePayload() const override;
 
  AWS_COMPUTEOPTIMIZER_API Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
 
 
  inline const Aws::Vector<Aws::String>& GetAccountIds() const { return m_accountIds; }
  inline bool AccountIdsHasBeenSet() const { return m_accountIdsHasBeenSet; }
  template <typename AccountIdsT = Aws::Vector<Aws::String>>
  void SetAccountIds(AccountIdsT&& value) {
    m_accountIdsHasBeenSet = true;
    m_accountIds = std::forward<AccountIdsT>(value);
  }
  template <typename AccountIdsT = Aws::Vector<Aws::String>>
  ExportLicenseRecommendationsRequest& WithAccountIds(AccountIdsT&& value) {
    SetAccountIds(std::forward<AccountIdsT>(value));
    return *this;
  }
  template <typename AccountIdsT = Aws::String>
  ExportLicenseRecommendationsRequest& AddAccountIds(AccountIdsT&& value) {
    m_accountIdsHasBeenSet = true;
    m_accountIds.emplace_back(std::forward<AccountIdsT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<LicenseRecommendationFilter>& GetFilters() const { return m_filters; }
  inline bool FiltersHasBeenSet() const { return m_filtersHasBeenSet; }
  template <typename FiltersT = Aws::Vector<LicenseRecommendationFilter>>
  void SetFilters(FiltersT&& value) {
    m_filtersHasBeenSet = true;
    m_filters = std::forward<FiltersT>(value);
  }
  template <typename FiltersT = Aws::Vector<LicenseRecommendationFilter>>
  ExportLicenseRecommendationsRequest& WithFilters(FiltersT&& value) {
    SetFilters(std::forward<FiltersT>(value));
    return *this;
  }
  template <typename FiltersT = LicenseRecommendationFilter>
  ExportLicenseRecommendationsRequest& AddFilters(FiltersT&& value) {
    m_filtersHasBeenSet = true;
    m_filters.emplace_back(std::forward<FiltersT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<ExportableLicenseField>& GetFieldsToExport() const { return m_fieldsToExport; }
  inline bool FieldsToExportHasBeenSet() const { return m_fieldsToExportHasBeenSet; }
  template <typename FieldsToExportT = Aws::Vector<ExportableLicenseField>>
  void SetFieldsToExport(FieldsToExportT&& value) {
    m_fieldsToExportHasBeenSet = true;
    m_fieldsToExport = std::forward<FieldsToExportT>(value);
  }
  template <typename FieldsToExportT = Aws::Vector<ExportableLicenseField>>
  ExportLicenseRecommendationsRequest& WithFieldsToExport(FieldsToExportT&& value) {
    SetFieldsToExport(std::forward<FieldsToExportT>(value));
    return *this;
  }
  inline ExportLicenseRecommendationsRequest& AddFieldsToExport(ExportableLicenseField value) {
    m_fieldsToExportHasBeenSet = true;
    m_fieldsToExport.push_back(value);
    return *this;
  }
 
 
  inline const S3DestinationConfig& GetS3DestinationConfig() const { return m_s3DestinationConfig; }
  inline bool S3DestinationConfigHasBeenSet() const { return m_s3DestinationConfigHasBeenSet; }
  template <typename S3DestinationConfigT = S3DestinationConfig>
  void SetS3DestinationConfig(S3DestinationConfigT&& value) {
    m_s3DestinationConfigHasBeenSet = true;
    m_s3DestinationConfig = std::forward<S3DestinationConfigT>(value);
  }
  template <typename S3DestinationConfigT = S3DestinationConfig>
  ExportLicenseRecommendationsRequest& WithS3DestinationConfig(S3DestinationConfigT&& value) {
    SetS3DestinationConfig(std::forward<S3DestinationConfigT>(value));
    return *this;
  }
 
 
  inline FileFormat GetFileFormat() const { return m_fileFormat; }
  inline bool FileFormatHasBeenSet() const { return m_fileFormatHasBeenSet; }
  inline void SetFileFormat(FileFormat value) {
    m_fileFormatHasBeenSet = true;
    m_fileFormat = value;
  }
  inline ExportLicenseRecommendationsRequest& WithFileFormat(FileFormat value) {
    SetFileFormat(value);
    return *this;
  }
 
 
  inline bool GetIncludeMemberAccounts() const { return m_includeMemberAccounts; }
  inline bool IncludeMemberAccountsHasBeenSet() const { return m_includeMemberAccountsHasBeenSet; }
  inline void SetIncludeMemberAccounts(bool value) {
    m_includeMemberAccountsHasBeenSet = true;
    m_includeMemberAccounts = value;
  }
  inline ExportLicenseRecommendationsRequest& WithIncludeMemberAccounts(bool value) {
    SetIncludeMemberAccounts(value);
    return *this;
  }
 private:
  Aws::Vector<Aws::String> m_accountIds;
 
  Aws::Vector<LicenseRecommendationFilter> m_filters;
 
  Aws::Vector<ExportableLicenseField> m_fieldsToExport;
 
  S3DestinationConfig m_s3DestinationConfig;
 
  FileFormat m_fileFormat{FileFormat::NOT_SET};
 
  bool m_includeMemberAccounts{false};
  bool m_accountIdsHasBeenSet = false;
  bool m_filtersHasBeenSet = false;
  bool m_fieldsToExportHasBeenSet = false;
  bool m_s3DestinationConfigHasBeenSet = false;
  bool m_fileFormatHasBeenSet = false;
  bool m_includeMemberAccountsHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace ComputeOptimizer
}  // namespace Aws