AggregationRequest.h

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