AggregationResponse.h

 
#pragma once
#include <aws/inspector2/Inspector2_EXPORTS.h>
#include <aws/inspector2/model/AccountAggregationResponse.h>
#include <aws/inspector2/model/AmiAggregationResponse.h>
#include <aws/inspector2/model/AwsEcrContainerAggregationResponse.h>
#include <aws/inspector2/model/CodeRepositoryAggregationResponse.h>
#include <aws/inspector2/model/ContainerImageAggregationResponse.h>
#include <aws/inspector2/model/Ec2InstanceAggregationResponse.h>
#include <aws/inspector2/model/FindingTypeAggregationResponse.h>
#include <aws/inspector2/model/ImageLayerAggregationResponse.h>
#include <aws/inspector2/model/LambdaFunctionAggregationResponse.h>
#include <aws/inspector2/model/LambdaLayerAggregationResponse.h>
#include <aws/inspector2/model/PackageAggregationResponse.h>
#include <aws/inspector2/model/RepositoryAggregationResponse.h>
#include <aws/inspector2/model/ServerlessFunctionAggregationResponse.h>
#include <aws/inspector2/model/TitleAggregationResponse.h>
#include <aws/inspector2/model/VmInstanceAggregationResponse.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace Inspector2 {
namespace Model {
 
class AggregationResponse {
 public:
  AWS_INSPECTOR2_API AggregationResponse() = default;
  AWS_INSPECTOR2_API AggregationResponse(Aws::Utils::Json::JsonView jsonValue);
  AWS_INSPECTOR2_API AggregationResponse& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_INSPECTOR2_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const AccountAggregationResponse& GetAccountAggregation() const { return m_accountAggregation; }
  inline bool AccountAggregationHasBeenSet() const { return m_accountAggregationHasBeenSet; }
  template <typename AccountAggregationT = AccountAggregationResponse>
  void SetAccountAggregation(AccountAggregationT&& value) {
    m_accountAggregationHasBeenSet = true;
    m_accountAggregation = std::forward<AccountAggregationT>(value);
  }
  template <typename AccountAggregationT = AccountAggregationResponse>
  AggregationResponse& WithAccountAggregation(AccountAggregationT&& value) {
    SetAccountAggregation(std::forward<AccountAggregationT>(value));
    return *this;
  }
 
 
  inline const AmiAggregationResponse& GetAmiAggregation() const { return m_amiAggregation; }
  inline bool AmiAggregationHasBeenSet() const { return m_amiAggregationHasBeenSet; }
  template <typename AmiAggregationT = AmiAggregationResponse>
  void SetAmiAggregation(AmiAggregationT&& value) {
    m_amiAggregationHasBeenSet = true;
    m_amiAggregation = std::forward<AmiAggregationT>(value);
  }
  template <typename AmiAggregationT = AmiAggregationResponse>
  AggregationResponse& WithAmiAggregation(AmiAggregationT&& value) {
    SetAmiAggregation(std::forward<AmiAggregationT>(value));
    return *this;
  }
 
 
  inline const AwsEcrContainerAggregationResponse& GetAwsEcrContainerAggregation() const { return m_awsEcrContainerAggregation; }
  inline bool AwsEcrContainerAggregationHasBeenSet() const { return m_awsEcrContainerAggregationHasBeenSet; }
  template <typename AwsEcrContainerAggregationT = AwsEcrContainerAggregationResponse>
  void SetAwsEcrContainerAggregation(AwsEcrContainerAggregationT&& value) {
    m_awsEcrContainerAggregationHasBeenSet = true;
    m_awsEcrContainerAggregation = std::forward<AwsEcrContainerAggregationT>(value);
  }
  template <typename AwsEcrContainerAggregationT = AwsEcrContainerAggregationResponse>
  AggregationResponse& WithAwsEcrContainerAggregation(AwsEcrContainerAggregationT&& value) {
    SetAwsEcrContainerAggregation(std::forward<AwsEcrContainerAggregationT>(value));
    return *this;
  }
 
 
  inline const Ec2InstanceAggregationResponse& GetEc2InstanceAggregation() const { return m_ec2InstanceAggregation; }
  inline bool Ec2InstanceAggregationHasBeenSet() const { return m_ec2InstanceAggregationHasBeenSet; }
  template <typename Ec2InstanceAggregationT = Ec2InstanceAggregationResponse>
  void SetEc2InstanceAggregation(Ec2InstanceAggregationT&& value) {
    m_ec2InstanceAggregationHasBeenSet = true;
    m_ec2InstanceAggregation = std::forward<Ec2InstanceAggregationT>(value);
  }
  template <typename Ec2InstanceAggregationT = Ec2InstanceAggregationResponse>
  AggregationResponse& WithEc2InstanceAggregation(Ec2InstanceAggregationT&& value) {
    SetEc2InstanceAggregation(std::forward<Ec2InstanceAggregationT>(value));
    return *this;
  }
 
 
  inline const FindingTypeAggregationResponse& GetFindingTypeAggregation() const { return m_findingTypeAggregation; }
  inline bool FindingTypeAggregationHasBeenSet() const { return m_findingTypeAggregationHasBeenSet; }
  template <typename FindingTypeAggregationT = FindingTypeAggregationResponse>
  void SetFindingTypeAggregation(FindingTypeAggregationT&& value) {
    m_findingTypeAggregationHasBeenSet = true;
    m_findingTypeAggregation = std::forward<FindingTypeAggregationT>(value);
  }
  template <typename FindingTypeAggregationT = FindingTypeAggregationResponse>
  AggregationResponse& WithFindingTypeAggregation(FindingTypeAggregationT&& value) {
    SetFindingTypeAggregation(std::forward<FindingTypeAggregationT>(value));
    return *this;
  }
 
 
  inline const ImageLayerAggregationResponse& GetImageLayerAggregation() const { return m_imageLayerAggregation; }
  inline bool ImageLayerAggregationHasBeenSet() const { return m_imageLayerAggregationHasBeenSet; }
  template <typename ImageLayerAggregationT = ImageLayerAggregationResponse>
  void SetImageLayerAggregation(ImageLayerAggregationT&& value) {
    m_imageLayerAggregationHasBeenSet = true;
    m_imageLayerAggregation = std::forward<ImageLayerAggregationT>(value);
  }
  template <typename ImageLayerAggregationT = ImageLayerAggregationResponse>
  AggregationResponse& WithImageLayerAggregation(ImageLayerAggregationT&& value) {
    SetImageLayerAggregation(std::forward<ImageLayerAggregationT>(value));
    return *this;
  }
 
 
  inline const PackageAggregationResponse& GetPackageAggregation() const { return m_packageAggregation; }
  inline bool PackageAggregationHasBeenSet() const { return m_packageAggregationHasBeenSet; }
  template <typename PackageAggregationT = PackageAggregationResponse>
  void SetPackageAggregation(PackageAggregationT&& value) {
    m_packageAggregationHasBeenSet = true;
    m_packageAggregation = std::forward<PackageAggregationT>(value);
  }
  template <typename PackageAggregationT = PackageAggregationResponse>
  AggregationResponse& WithPackageAggregation(PackageAggregationT&& value) {
    SetPackageAggregation(std::forward<PackageAggregationT>(value));
    return *this;
  }
 
 
  inline const RepositoryAggregationResponse& GetRepositoryAggregation() const { return m_repositoryAggregation; }
  inline bool RepositoryAggregationHasBeenSet() const { return m_repositoryAggregationHasBeenSet; }
  template <typename RepositoryAggregationT = RepositoryAggregationResponse>
  void SetRepositoryAggregation(RepositoryAggregationT&& value) {
    m_repositoryAggregationHasBeenSet = true;
    m_repositoryAggregation = std::forward<RepositoryAggregationT>(value);
  }
  template <typename RepositoryAggregationT = RepositoryAggregationResponse>
  AggregationResponse& WithRepositoryAggregation(RepositoryAggregationT&& value) {
    SetRepositoryAggregation(std::forward<RepositoryAggregationT>(value));
    return *this;
  }
 
 
  inline const TitleAggregationResponse& GetTitleAggregation() const { return m_titleAggregation; }
  inline bool TitleAggregationHasBeenSet() const { return m_titleAggregationHasBeenSet; }
  template <typename TitleAggregationT = TitleAggregationResponse>
  void SetTitleAggregation(TitleAggregationT&& value) {
    m_titleAggregationHasBeenSet = true;
    m_titleAggregation = std::forward<TitleAggregationT>(value);
  }
  template <typename TitleAggregationT = TitleAggregationResponse>
  AggregationResponse& WithTitleAggregation(TitleAggregationT&& value) {
    SetTitleAggregation(std::forward<TitleAggregationT>(value));
    return *this;
  }
 
 
  inline const LambdaLayerAggregationResponse& GetLambdaLayerAggregation() const { return m_lambdaLayerAggregation; }
  inline bool LambdaLayerAggregationHasBeenSet() const { return m_lambdaLayerAggregationHasBeenSet; }
  template <typename LambdaLayerAggregationT = LambdaLayerAggregationResponse>
  void SetLambdaLayerAggregation(LambdaLayerAggregationT&& value) {
    m_lambdaLayerAggregationHasBeenSet = true;
    m_lambdaLayerAggregation = std::forward<LambdaLayerAggregationT>(value);
  }
  template <typename LambdaLayerAggregationT = LambdaLayerAggregationResponse>
  AggregationResponse& WithLambdaLayerAggregation(LambdaLayerAggregationT&& value) {
    SetLambdaLayerAggregation(std::forward<LambdaLayerAggregationT>(value));
    return *this;
  }
 
 
  inline const LambdaFunctionAggregationResponse& GetLambdaFunctionAggregation() const { return m_lambdaFunctionAggregation; }
  inline bool LambdaFunctionAggregationHasBeenSet() const { return m_lambdaFunctionAggregationHasBeenSet; }
  template <typename LambdaFunctionAggregationT = LambdaFunctionAggregationResponse>
  void SetLambdaFunctionAggregation(LambdaFunctionAggregationT&& value) {
    m_lambdaFunctionAggregationHasBeenSet = true;
    m_lambdaFunctionAggregation = std::forward<LambdaFunctionAggregationT>(value);
  }
  template <typename LambdaFunctionAggregationT = LambdaFunctionAggregationResponse>
  AggregationResponse& WithLambdaFunctionAggregation(LambdaFunctionAggregationT&& value) {
    SetLambdaFunctionAggregation(std::forward<LambdaFunctionAggregationT>(value));
    return *this;
  }
 
 
  inline const CodeRepositoryAggregationResponse& GetCodeRepositoryAggregation() const { return m_codeRepositoryAggregation; }
  inline bool CodeRepositoryAggregationHasBeenSet() const { return m_codeRepositoryAggregationHasBeenSet; }
  template <typename CodeRepositoryAggregationT = CodeRepositoryAggregationResponse>
  void SetCodeRepositoryAggregation(CodeRepositoryAggregationT&& value) {
    m_codeRepositoryAggregationHasBeenSet = true;
    m_codeRepositoryAggregation = std::forward<CodeRepositoryAggregationT>(value);
  }
  template <typename CodeRepositoryAggregationT = CodeRepositoryAggregationResponse>
  AggregationResponse& WithCodeRepositoryAggregation(CodeRepositoryAggregationT&& value) {
    SetCodeRepositoryAggregation(std::forward<CodeRepositoryAggregationT>(value));
    return *this;
  }
 
 
  inline const VmInstanceAggregationResponse& GetVmInstanceAggregation() const { return m_vmInstanceAggregation; }
  inline bool VmInstanceAggregationHasBeenSet() const { return m_vmInstanceAggregationHasBeenSet; }
  template <typename VmInstanceAggregationT = VmInstanceAggregationResponse>
  void SetVmInstanceAggregation(VmInstanceAggregationT&& value) {
    m_vmInstanceAggregationHasBeenSet = true;
    m_vmInstanceAggregation = std::forward<VmInstanceAggregationT>(value);
  }
  template <typename VmInstanceAggregationT = VmInstanceAggregationResponse>
  AggregationResponse& WithVmInstanceAggregation(VmInstanceAggregationT&& value) {
    SetVmInstanceAggregation(std::forward<VmInstanceAggregationT>(value));
    return *this;
  }
 
 
  inline const ContainerImageAggregationResponse& GetContainerImageAggregation() const { return m_containerImageAggregation; }
  inline bool ContainerImageAggregationHasBeenSet() const { return m_containerImageAggregationHasBeenSet; }
  template <typename ContainerImageAggregationT = ContainerImageAggregationResponse>
  void SetContainerImageAggregation(ContainerImageAggregationT&& value) {
    m_containerImageAggregationHasBeenSet = true;
    m_containerImageAggregation = std::forward<ContainerImageAggregationT>(value);
  }
  template <typename ContainerImageAggregationT = ContainerImageAggregationResponse>
  AggregationResponse& WithContainerImageAggregation(ContainerImageAggregationT&& value) {
    SetContainerImageAggregation(std::forward<ContainerImageAggregationT>(value));
    return *this;
  }
 
 
  inline const ServerlessFunctionAggregationResponse& GetServerlessFunctionAggregation() const { return m_serverlessFunctionAggregation; }
  inline bool ServerlessFunctionAggregationHasBeenSet() const { return m_serverlessFunctionAggregationHasBeenSet; }
  template <typename ServerlessFunctionAggregationT = ServerlessFunctionAggregationResponse>
  void SetServerlessFunctionAggregation(ServerlessFunctionAggregationT&& value) {
    m_serverlessFunctionAggregationHasBeenSet = true;
    m_serverlessFunctionAggregation = std::forward<ServerlessFunctionAggregationT>(value);
  }
  template <typename ServerlessFunctionAggregationT = ServerlessFunctionAggregationResponse>
  AggregationResponse& WithServerlessFunctionAggregation(ServerlessFunctionAggregationT&& value) {
    SetServerlessFunctionAggregation(std::forward<ServerlessFunctionAggregationT>(value));
    return *this;
  }
 private:
  AccountAggregationResponse m_accountAggregation;
 
  AmiAggregationResponse m_amiAggregation;
 
  AwsEcrContainerAggregationResponse m_awsEcrContainerAggregation;
 
  Ec2InstanceAggregationResponse m_ec2InstanceAggregation;
 
  FindingTypeAggregationResponse m_findingTypeAggregation;
 
  ImageLayerAggregationResponse m_imageLayerAggregation;
 
  PackageAggregationResponse m_packageAggregation;
 
  RepositoryAggregationResponse m_repositoryAggregation;
 
  TitleAggregationResponse m_titleAggregation;
 
  LambdaLayerAggregationResponse m_lambdaLayerAggregation;
 
  LambdaFunctionAggregationResponse m_lambdaFunctionAggregation;
 
  CodeRepositoryAggregationResponse m_codeRepositoryAggregation;
 
  VmInstanceAggregationResponse m_vmInstanceAggregation;
 
  ContainerImageAggregationResponse m_containerImageAggregation;
 
  ServerlessFunctionAggregationResponse m_serverlessFunctionAggregation;
  bool m_accountAggregationHasBeenSet = false;
  bool m_amiAggregationHasBeenSet = false;
  bool m_awsEcrContainerAggregationHasBeenSet = false;
  bool m_ec2InstanceAggregationHasBeenSet = false;
  bool m_findingTypeAggregationHasBeenSet = false;
  bool m_imageLayerAggregationHasBeenSet = false;
  bool m_packageAggregationHasBeenSet = false;
  bool m_repositoryAggregationHasBeenSet = false;
  bool m_titleAggregationHasBeenSet = false;
  bool m_lambdaLayerAggregationHasBeenSet = false;
  bool m_lambdaFunctionAggregationHasBeenSet = false;
  bool m_codeRepositoryAggregationHasBeenSet = false;
  bool m_vmInstanceAggregationHasBeenSet = false;
  bool m_containerImageAggregationHasBeenSet = false;
  bool m_serverlessFunctionAggregationHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace Inspector2
}  // namespace Aws