Resource.h

 
#pragma once
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/guardduty/GuardDuty_EXPORTS.h>
#include <aws/guardduty/model/AccessKeyDetails.h>
#include <aws/guardduty/model/Container.h>
#include <aws/guardduty/model/EbsSnapshotDetails.h>
#include <aws/guardduty/model/EbsVolumeDetails.h>
#include <aws/guardduty/model/Ec2ImageDetails.h>
#include <aws/guardduty/model/EcsClusterDetails.h>
#include <aws/guardduty/model/EksClusterDetails.h>
#include <aws/guardduty/model/InstanceDetails.h>
#include <aws/guardduty/model/KubernetesDetails.h>
#include <aws/guardduty/model/LambdaDetails.h>
#include <aws/guardduty/model/RdsDbInstanceDetails.h>
#include <aws/guardduty/model/RdsDbUserDetails.h>
#include <aws/guardduty/model/RdsLimitlessDbDetails.h>
#include <aws/guardduty/model/RecoveryPointDetails.h>
#include <aws/guardduty/model/S3BucketDetail.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace GuardDuty {
namespace Model {
 
class Resource {
 public:
  AWS_GUARDDUTY_API Resource() = default;
  AWS_GUARDDUTY_API Resource(Aws::Utils::Json::JsonView jsonValue);
  AWS_GUARDDUTY_API Resource& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_GUARDDUTY_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const AccessKeyDetails& GetAccessKeyDetails() const { return m_accessKeyDetails; }
  inline bool AccessKeyDetailsHasBeenSet() const { return m_accessKeyDetailsHasBeenSet; }
  template <typename AccessKeyDetailsT = AccessKeyDetails>
  void SetAccessKeyDetails(AccessKeyDetailsT&& value) {
    m_accessKeyDetailsHasBeenSet = true;
    m_accessKeyDetails = std::forward<AccessKeyDetailsT>(value);
  }
  template <typename AccessKeyDetailsT = AccessKeyDetails>
  Resource& WithAccessKeyDetails(AccessKeyDetailsT&& value) {
    SetAccessKeyDetails(std::forward<AccessKeyDetailsT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<S3BucketDetail>& GetS3BucketDetails() const { return m_s3BucketDetails; }
  inline bool S3BucketDetailsHasBeenSet() const { return m_s3BucketDetailsHasBeenSet; }
  template <typename S3BucketDetailsT = Aws::Vector<S3BucketDetail>>
  void SetS3BucketDetails(S3BucketDetailsT&& value) {
    m_s3BucketDetailsHasBeenSet = true;
    m_s3BucketDetails = std::forward<S3BucketDetailsT>(value);
  }
  template <typename S3BucketDetailsT = Aws::Vector<S3BucketDetail>>
  Resource& WithS3BucketDetails(S3BucketDetailsT&& value) {
    SetS3BucketDetails(std::forward<S3BucketDetailsT>(value));
    return *this;
  }
  template <typename S3BucketDetailsT = S3BucketDetail>
  Resource& AddS3BucketDetails(S3BucketDetailsT&& value) {
    m_s3BucketDetailsHasBeenSet = true;
    m_s3BucketDetails.emplace_back(std::forward<S3BucketDetailsT>(value));
    return *this;
  }
 
 
  inline const InstanceDetails& GetInstanceDetails() const { return m_instanceDetails; }
  inline bool InstanceDetailsHasBeenSet() const { return m_instanceDetailsHasBeenSet; }
  template <typename InstanceDetailsT = InstanceDetails>
  void SetInstanceDetails(InstanceDetailsT&& value) {
    m_instanceDetailsHasBeenSet = true;
    m_instanceDetails = std::forward<InstanceDetailsT>(value);
  }
  template <typename InstanceDetailsT = InstanceDetails>
  Resource& WithInstanceDetails(InstanceDetailsT&& value) {
    SetInstanceDetails(std::forward<InstanceDetailsT>(value));
    return *this;
  }
 
 
  inline const EksClusterDetails& GetEksClusterDetails() const { return m_eksClusterDetails; }
  inline bool EksClusterDetailsHasBeenSet() const { return m_eksClusterDetailsHasBeenSet; }
  template <typename EksClusterDetailsT = EksClusterDetails>
  void SetEksClusterDetails(EksClusterDetailsT&& value) {
    m_eksClusterDetailsHasBeenSet = true;
    m_eksClusterDetails = std::forward<EksClusterDetailsT>(value);
  }
  template <typename EksClusterDetailsT = EksClusterDetails>
  Resource& WithEksClusterDetails(EksClusterDetailsT&& value) {
    SetEksClusterDetails(std::forward<EksClusterDetailsT>(value));
    return *this;
  }
 
 
  inline const KubernetesDetails& GetKubernetesDetails() const { return m_kubernetesDetails; }
  inline bool KubernetesDetailsHasBeenSet() const { return m_kubernetesDetailsHasBeenSet; }
  template <typename KubernetesDetailsT = KubernetesDetails>
  void SetKubernetesDetails(KubernetesDetailsT&& value) {
    m_kubernetesDetailsHasBeenSet = true;
    m_kubernetesDetails = std::forward<KubernetesDetailsT>(value);
  }
  template <typename KubernetesDetailsT = KubernetesDetails>
  Resource& WithKubernetesDetails(KubernetesDetailsT&& value) {
    SetKubernetesDetails(std::forward<KubernetesDetailsT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetResourceType() const { return m_resourceType; }
  inline bool ResourceTypeHasBeenSet() const { return m_resourceTypeHasBeenSet; }
  template <typename ResourceTypeT = Aws::String>
  void SetResourceType(ResourceTypeT&& value) {
    m_resourceTypeHasBeenSet = true;
    m_resourceType = std::forward<ResourceTypeT>(value);
  }
  template <typename ResourceTypeT = Aws::String>
  Resource& WithResourceType(ResourceTypeT&& value) {
    SetResourceType(std::forward<ResourceTypeT>(value));
    return *this;
  }
 
 
  inline const EbsVolumeDetails& GetEbsVolumeDetails() const { return m_ebsVolumeDetails; }
  inline bool EbsVolumeDetailsHasBeenSet() const { return m_ebsVolumeDetailsHasBeenSet; }
  template <typename EbsVolumeDetailsT = EbsVolumeDetails>
  void SetEbsVolumeDetails(EbsVolumeDetailsT&& value) {
    m_ebsVolumeDetailsHasBeenSet = true;
    m_ebsVolumeDetails = std::forward<EbsVolumeDetailsT>(value);
  }
  template <typename EbsVolumeDetailsT = EbsVolumeDetails>
  Resource& WithEbsVolumeDetails(EbsVolumeDetailsT&& value) {
    SetEbsVolumeDetails(std::forward<EbsVolumeDetailsT>(value));
    return *this;
  }
 
 
  inline const EcsClusterDetails& GetEcsClusterDetails() const { return m_ecsClusterDetails; }
  inline bool EcsClusterDetailsHasBeenSet() const { return m_ecsClusterDetailsHasBeenSet; }
  template <typename EcsClusterDetailsT = EcsClusterDetails>
  void SetEcsClusterDetails(EcsClusterDetailsT&& value) {
    m_ecsClusterDetailsHasBeenSet = true;
    m_ecsClusterDetails = std::forward<EcsClusterDetailsT>(value);
  }
  template <typename EcsClusterDetailsT = EcsClusterDetails>
  Resource& WithEcsClusterDetails(EcsClusterDetailsT&& value) {
    SetEcsClusterDetails(std::forward<EcsClusterDetailsT>(value));
    return *this;
  }
 
 
  inline const Container& GetContainerDetails() const { return m_containerDetails; }
  inline bool ContainerDetailsHasBeenSet() const { return m_containerDetailsHasBeenSet; }
  template <typename ContainerDetailsT = Container>
  void SetContainerDetails(ContainerDetailsT&& value) {
    m_containerDetailsHasBeenSet = true;
    m_containerDetails = std::forward<ContainerDetailsT>(value);
  }
  template <typename ContainerDetailsT = Container>
  Resource& WithContainerDetails(ContainerDetailsT&& value) {
    SetContainerDetails(std::forward<ContainerDetailsT>(value));
    return *this;
  }
 
 
  inline const RdsDbInstanceDetails& GetRdsDbInstanceDetails() const { return m_rdsDbInstanceDetails; }
  inline bool RdsDbInstanceDetailsHasBeenSet() const { return m_rdsDbInstanceDetailsHasBeenSet; }
  template <typename RdsDbInstanceDetailsT = RdsDbInstanceDetails>
  void SetRdsDbInstanceDetails(RdsDbInstanceDetailsT&& value) {
    m_rdsDbInstanceDetailsHasBeenSet = true;
    m_rdsDbInstanceDetails = std::forward<RdsDbInstanceDetailsT>(value);
  }
  template <typename RdsDbInstanceDetailsT = RdsDbInstanceDetails>
  Resource& WithRdsDbInstanceDetails(RdsDbInstanceDetailsT&& value) {
    SetRdsDbInstanceDetails(std::forward<RdsDbInstanceDetailsT>(value));
    return *this;
  }
 
 
  inline const RdsLimitlessDbDetails& GetRdsLimitlessDbDetails() const { return m_rdsLimitlessDbDetails; }
  inline bool RdsLimitlessDbDetailsHasBeenSet() const { return m_rdsLimitlessDbDetailsHasBeenSet; }
  template <typename RdsLimitlessDbDetailsT = RdsLimitlessDbDetails>
  void SetRdsLimitlessDbDetails(RdsLimitlessDbDetailsT&& value) {
    m_rdsLimitlessDbDetailsHasBeenSet = true;
    m_rdsLimitlessDbDetails = std::forward<RdsLimitlessDbDetailsT>(value);
  }
  template <typename RdsLimitlessDbDetailsT = RdsLimitlessDbDetails>
  Resource& WithRdsLimitlessDbDetails(RdsLimitlessDbDetailsT&& value) {
    SetRdsLimitlessDbDetails(std::forward<RdsLimitlessDbDetailsT>(value));
    return *this;
  }
 
 
  inline const RdsDbUserDetails& GetRdsDbUserDetails() const { return m_rdsDbUserDetails; }
  inline bool RdsDbUserDetailsHasBeenSet() const { return m_rdsDbUserDetailsHasBeenSet; }
  template <typename RdsDbUserDetailsT = RdsDbUserDetails>
  void SetRdsDbUserDetails(RdsDbUserDetailsT&& value) {
    m_rdsDbUserDetailsHasBeenSet = true;
    m_rdsDbUserDetails = std::forward<RdsDbUserDetailsT>(value);
  }
  template <typename RdsDbUserDetailsT = RdsDbUserDetails>
  Resource& WithRdsDbUserDetails(RdsDbUserDetailsT&& value) {
    SetRdsDbUserDetails(std::forward<RdsDbUserDetailsT>(value));
    return *this;
  }
 
 
  inline const LambdaDetails& GetLambdaDetails() const { return m_lambdaDetails; }
  inline bool LambdaDetailsHasBeenSet() const { return m_lambdaDetailsHasBeenSet; }
  template <typename LambdaDetailsT = LambdaDetails>
  void SetLambdaDetails(LambdaDetailsT&& value) {
    m_lambdaDetailsHasBeenSet = true;
    m_lambdaDetails = std::forward<LambdaDetailsT>(value);
  }
  template <typename LambdaDetailsT = LambdaDetails>
  Resource& WithLambdaDetails(LambdaDetailsT&& value) {
    SetLambdaDetails(std::forward<LambdaDetailsT>(value));
    return *this;
  }
 
 
  inline const EbsSnapshotDetails& GetEbsSnapshotDetails() const { return m_ebsSnapshotDetails; }
  inline bool EbsSnapshotDetailsHasBeenSet() const { return m_ebsSnapshotDetailsHasBeenSet; }
  template <typename EbsSnapshotDetailsT = EbsSnapshotDetails>
  void SetEbsSnapshotDetails(EbsSnapshotDetailsT&& value) {
    m_ebsSnapshotDetailsHasBeenSet = true;
    m_ebsSnapshotDetails = std::forward<EbsSnapshotDetailsT>(value);
  }
  template <typename EbsSnapshotDetailsT = EbsSnapshotDetails>
  Resource& WithEbsSnapshotDetails(EbsSnapshotDetailsT&& value) {
    SetEbsSnapshotDetails(std::forward<EbsSnapshotDetailsT>(value));
    return *this;
  }
 
 
  inline const Ec2ImageDetails& GetEc2ImageDetails() const { return m_ec2ImageDetails; }
  inline bool Ec2ImageDetailsHasBeenSet() const { return m_ec2ImageDetailsHasBeenSet; }
  template <typename Ec2ImageDetailsT = Ec2ImageDetails>
  void SetEc2ImageDetails(Ec2ImageDetailsT&& value) {
    m_ec2ImageDetailsHasBeenSet = true;
    m_ec2ImageDetails = std::forward<Ec2ImageDetailsT>(value);
  }
  template <typename Ec2ImageDetailsT = Ec2ImageDetails>
  Resource& WithEc2ImageDetails(Ec2ImageDetailsT&& value) {
    SetEc2ImageDetails(std::forward<Ec2ImageDetailsT>(value));
    return *this;
  }
 
 
  inline const RecoveryPointDetails& GetRecoveryPointDetails() const { return m_recoveryPointDetails; }
  inline bool RecoveryPointDetailsHasBeenSet() const { return m_recoveryPointDetailsHasBeenSet; }
  template <typename RecoveryPointDetailsT = RecoveryPointDetails>
  void SetRecoveryPointDetails(RecoveryPointDetailsT&& value) {
    m_recoveryPointDetailsHasBeenSet = true;
    m_recoveryPointDetails = std::forward<RecoveryPointDetailsT>(value);
  }
  template <typename RecoveryPointDetailsT = RecoveryPointDetails>
  Resource& WithRecoveryPointDetails(RecoveryPointDetailsT&& value) {
    SetRecoveryPointDetails(std::forward<RecoveryPointDetailsT>(value));
    return *this;
  }
 private:
  AccessKeyDetails m_accessKeyDetails;
 
  Aws::Vector<S3BucketDetail> m_s3BucketDetails;
 
  InstanceDetails m_instanceDetails;
 
  EksClusterDetails m_eksClusterDetails;
 
  KubernetesDetails m_kubernetesDetails;
 
  Aws::String m_resourceType;
 
  EbsVolumeDetails m_ebsVolumeDetails;
 
  EcsClusterDetails m_ecsClusterDetails;
 
  Container m_containerDetails;
 
  RdsDbInstanceDetails m_rdsDbInstanceDetails;
 
  RdsLimitlessDbDetails m_rdsLimitlessDbDetails;
 
  RdsDbUserDetails m_rdsDbUserDetails;
 
  LambdaDetails m_lambdaDetails;
 
  EbsSnapshotDetails m_ebsSnapshotDetails;
 
  Ec2ImageDetails m_ec2ImageDetails;
 
  RecoveryPointDetails m_recoveryPointDetails;
  bool m_accessKeyDetailsHasBeenSet = false;
  bool m_s3BucketDetailsHasBeenSet = false;
  bool m_instanceDetailsHasBeenSet = false;
  bool m_eksClusterDetailsHasBeenSet = false;
  bool m_kubernetesDetailsHasBeenSet = false;
  bool m_resourceTypeHasBeenSet = false;
  bool m_ebsVolumeDetailsHasBeenSet = false;
  bool m_ecsClusterDetailsHasBeenSet = false;
  bool m_containerDetailsHasBeenSet = false;
  bool m_rdsDbInstanceDetailsHasBeenSet = false;
  bool m_rdsLimitlessDbDetailsHasBeenSet = false;
  bool m_rdsDbUserDetailsHasBeenSet = false;
  bool m_lambdaDetailsHasBeenSet = false;
  bool m_ebsSnapshotDetailsHasBeenSet = false;
  bool m_ec2ImageDetailsHasBeenSet = false;
  bool m_recoveryPointDetailsHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace GuardDuty
}  // namespace Aws