ResourceDetails.h

 
#pragma once
#include <aws/core/utils/Document.h>
#include <aws/core/utils/memory/stl/AWSMap.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/securityhub/SecurityHub_EXPORTS.h>
#include <aws/securityhub/model/AwsAmazonMqBrokerDetails.h>
#include <aws/securityhub/model/AwsApiGatewayRestApiDetails.h>
#include <aws/securityhub/model/AwsApiGatewayStageDetails.h>
#include <aws/securityhub/model/AwsApiGatewayV2ApiDetails.h>
#include <aws/securityhub/model/AwsApiGatewayV2StageDetails.h>
#include <aws/securityhub/model/AwsAppSyncGraphQlApiDetails.h>
#include <aws/securityhub/model/AwsAthenaWorkGroupDetails.h>
#include <aws/securityhub/model/AwsAutoScalingAutoScalingGroupDetails.h>
#include <aws/securityhub/model/AwsAutoScalingLaunchConfigurationDetails.h>
#include <aws/securityhub/model/AwsBackupBackupPlanDetails.h>
#include <aws/securityhub/model/AwsBackupBackupVaultDetails.h>
#include <aws/securityhub/model/AwsBackupRecoveryPointDetails.h>
#include <aws/securityhub/model/AwsCertificateManagerCertificateDetails.h>
#include <aws/securityhub/model/AwsCloudFormationStackDetails.h>
#include <aws/securityhub/model/AwsCloudFrontDistributionDetails.h>
#include <aws/securityhub/model/AwsCloudTrailTrailDetails.h>
#include <aws/securityhub/model/AwsCloudWatchAlarmDetails.h>
#include <aws/securityhub/model/AwsCodeBuildProjectDetails.h>
#include <aws/securityhub/model/AwsDmsEndpointDetails.h>
#include <aws/securityhub/model/AwsDmsReplicationInstanceDetails.h>
#include <aws/securityhub/model/AwsDmsReplicationTaskDetails.h>
#include <aws/securityhub/model/AwsDynamoDbTableDetails.h>
#include <aws/securityhub/model/AwsEc2ClientVpnEndpointDetails.h>
#include <aws/securityhub/model/AwsEc2EipDetails.h>
#include <aws/securityhub/model/AwsEc2InstanceDetails.h>
#include <aws/securityhub/model/AwsEc2LaunchTemplateDetails.h>
#include <aws/securityhub/model/AwsEc2NetworkAclDetails.h>
#include <aws/securityhub/model/AwsEc2NetworkInterfaceDetails.h>
#include <aws/securityhub/model/AwsEc2RouteTableDetails.h>
#include <aws/securityhub/model/AwsEc2SecurityGroupDetails.h>
#include <aws/securityhub/model/AwsEc2SubnetDetails.h>
#include <aws/securityhub/model/AwsEc2TransitGatewayDetails.h>
#include <aws/securityhub/model/AwsEc2VolumeDetails.h>
#include <aws/securityhub/model/AwsEc2VpcDetails.h>
#include <aws/securityhub/model/AwsEc2VpcEndpointServiceDetails.h>
#include <aws/securityhub/model/AwsEc2VpcPeeringConnectionDetails.h>
#include <aws/securityhub/model/AwsEc2VpnConnectionDetails.h>
#include <aws/securityhub/model/AwsEcrContainerImageDetails.h>
#include <aws/securityhub/model/AwsEcrRepositoryDetails.h>
#include <aws/securityhub/model/AwsEcsClusterDetails.h>
#include <aws/securityhub/model/AwsEcsContainerDetails.h>
#include <aws/securityhub/model/AwsEcsServiceDetails.h>
#include <aws/securityhub/model/AwsEcsTaskDefinitionDetails.h>
#include <aws/securityhub/model/AwsEcsTaskDetails.h>
#include <aws/securityhub/model/AwsEfsAccessPointDetails.h>
#include <aws/securityhub/model/AwsEksClusterDetails.h>
#include <aws/securityhub/model/AwsElasticBeanstalkEnvironmentDetails.h>
#include <aws/securityhub/model/AwsElasticsearchDomainDetails.h>
#include <aws/securityhub/model/AwsElbLoadBalancerDetails.h>
#include <aws/securityhub/model/AwsElbv2LoadBalancerDetails.h>
#include <aws/securityhub/model/AwsEventSchemasRegistryDetails.h>
#include <aws/securityhub/model/AwsEventsEndpointDetails.h>
#include <aws/securityhub/model/AwsEventsEventbusDetails.h>
#include <aws/securityhub/model/AwsGuardDutyDetectorDetails.h>
#include <aws/securityhub/model/AwsIamAccessKeyDetails.h>
#include <aws/securityhub/model/AwsIamGroupDetails.h>
#include <aws/securityhub/model/AwsIamPolicyDetails.h>
#include <aws/securityhub/model/AwsIamRoleDetails.h>
#include <aws/securityhub/model/AwsIamUserDetails.h>
#include <aws/securityhub/model/AwsKinesisStreamDetails.h>
#include <aws/securityhub/model/AwsKmsKeyDetails.h>
#include <aws/securityhub/model/AwsLambdaFunctionDetails.h>
#include <aws/securityhub/model/AwsLambdaLayerVersionDetails.h>
#include <aws/securityhub/model/AwsMskClusterDetails.h>
#include <aws/securityhub/model/AwsNetworkFirewallFirewallDetails.h>
#include <aws/securityhub/model/AwsNetworkFirewallFirewallPolicyDetails.h>
#include <aws/securityhub/model/AwsNetworkFirewallRuleGroupDetails.h>
#include <aws/securityhub/model/AwsOpenSearchServiceDomainDetails.h>
#include <aws/securityhub/model/AwsRdsDbClusterDetails.h>
#include <aws/securityhub/model/AwsRdsDbClusterSnapshotDetails.h>
#include <aws/securityhub/model/AwsRdsDbInstanceDetails.h>
#include <aws/securityhub/model/AwsRdsDbSecurityGroupDetails.h>
#include <aws/securityhub/model/AwsRdsDbSnapshotDetails.h>
#include <aws/securityhub/model/AwsRdsEventSubscriptionDetails.h>
#include <aws/securityhub/model/AwsRedshiftClusterDetails.h>
#include <aws/securityhub/model/AwsRoute53HostedZoneDetails.h>
#include <aws/securityhub/model/AwsS3AccessPointDetails.h>
#include <aws/securityhub/model/AwsS3AccountPublicAccessBlockDetails.h>
#include <aws/securityhub/model/AwsS3BucketDetails.h>
#include <aws/securityhub/model/AwsS3ObjectDetails.h>
#include <aws/securityhub/model/AwsSageMakerNotebookInstanceDetails.h>
#include <aws/securityhub/model/AwsSecretsManagerSecretDetails.h>
#include <aws/securityhub/model/AwsSnsTopicDetails.h>
#include <aws/securityhub/model/AwsSqsQueueDetails.h>
#include <aws/securityhub/model/AwsSsmPatchComplianceDetails.h>
#include <aws/securityhub/model/AwsStepFunctionStateMachineDetails.h>
#include <aws/securityhub/model/AwsWafRateBasedRuleDetails.h>
#include <aws/securityhub/model/AwsWafRegionalRateBasedRuleDetails.h>
#include <aws/securityhub/model/AwsWafRegionalRuleDetails.h>
#include <aws/securityhub/model/AwsWafRegionalRuleGroupDetails.h>
#include <aws/securityhub/model/AwsWafRegionalWebAclDetails.h>
#include <aws/securityhub/model/AwsWafRuleDetails.h>
#include <aws/securityhub/model/AwsWafRuleGroupDetails.h>
#include <aws/securityhub/model/AwsWafWebAclDetails.h>
#include <aws/securityhub/model/AwsWafv2RuleGroupDetails.h>
#include <aws/securityhub/model/AwsWafv2WebAclDetails.h>
#include <aws/securityhub/model/AwsXrayEncryptionConfigDetails.h>
#include <aws/securityhub/model/CodeRepositoryDetails.h>
#include <aws/securityhub/model/ContainerDetails.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace SecurityHub {
namespace Model {
 
class ResourceDetails {
 public:
  AWS_SECURITYHUB_API ResourceDetails() = default;
  AWS_SECURITYHUB_API ResourceDetails(Aws::Utils::Json::JsonView jsonValue);
  AWS_SECURITYHUB_API ResourceDetails& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_SECURITYHUB_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const AwsAutoScalingAutoScalingGroupDetails& GetAwsAutoScalingAutoScalingGroup() const { return m_awsAutoScalingAutoScalingGroup; }
  inline bool AwsAutoScalingAutoScalingGroupHasBeenSet() const { return m_awsAutoScalingAutoScalingGroupHasBeenSet; }
  template <typename AwsAutoScalingAutoScalingGroupT = AwsAutoScalingAutoScalingGroupDetails>
  void SetAwsAutoScalingAutoScalingGroup(AwsAutoScalingAutoScalingGroupT&& value) {
    m_awsAutoScalingAutoScalingGroupHasBeenSet = true;
    m_awsAutoScalingAutoScalingGroup = std::forward<AwsAutoScalingAutoScalingGroupT>(value);
  }
  template <typename AwsAutoScalingAutoScalingGroupT = AwsAutoScalingAutoScalingGroupDetails>
  ResourceDetails& WithAwsAutoScalingAutoScalingGroup(AwsAutoScalingAutoScalingGroupT&& value) {
    SetAwsAutoScalingAutoScalingGroup(std::forward<AwsAutoScalingAutoScalingGroupT>(value));
    return *this;
  }
 
 
  inline const AwsCodeBuildProjectDetails& GetAwsCodeBuildProject() const { return m_awsCodeBuildProject; }
  inline bool AwsCodeBuildProjectHasBeenSet() const { return m_awsCodeBuildProjectHasBeenSet; }
  template <typename AwsCodeBuildProjectT = AwsCodeBuildProjectDetails>
  void SetAwsCodeBuildProject(AwsCodeBuildProjectT&& value) {
    m_awsCodeBuildProjectHasBeenSet = true;
    m_awsCodeBuildProject = std::forward<AwsCodeBuildProjectT>(value);
  }
  template <typename AwsCodeBuildProjectT = AwsCodeBuildProjectDetails>
  ResourceDetails& WithAwsCodeBuildProject(AwsCodeBuildProjectT&& value) {
    SetAwsCodeBuildProject(std::forward<AwsCodeBuildProjectT>(value));
    return *this;
  }
 
 
  inline const AwsCloudFrontDistributionDetails& GetAwsCloudFrontDistribution() const { return m_awsCloudFrontDistribution; }
  inline bool AwsCloudFrontDistributionHasBeenSet() const { return m_awsCloudFrontDistributionHasBeenSet; }
  template <typename AwsCloudFrontDistributionT = AwsCloudFrontDistributionDetails>
  void SetAwsCloudFrontDistribution(AwsCloudFrontDistributionT&& value) {
    m_awsCloudFrontDistributionHasBeenSet = true;
    m_awsCloudFrontDistribution = std::forward<AwsCloudFrontDistributionT>(value);
  }
  template <typename AwsCloudFrontDistributionT = AwsCloudFrontDistributionDetails>
  ResourceDetails& WithAwsCloudFrontDistribution(AwsCloudFrontDistributionT&& value) {
    SetAwsCloudFrontDistribution(std::forward<AwsCloudFrontDistributionT>(value));
    return *this;
  }
 
 
  inline const AwsEc2InstanceDetails& GetAwsEc2Instance() const { return m_awsEc2Instance; }
  inline bool AwsEc2InstanceHasBeenSet() const { return m_awsEc2InstanceHasBeenSet; }
  template <typename AwsEc2InstanceT = AwsEc2InstanceDetails>
  void SetAwsEc2Instance(AwsEc2InstanceT&& value) {
    m_awsEc2InstanceHasBeenSet = true;
    m_awsEc2Instance = std::forward<AwsEc2InstanceT>(value);
  }
  template <typename AwsEc2InstanceT = AwsEc2InstanceDetails>
  ResourceDetails& WithAwsEc2Instance(AwsEc2InstanceT&& value) {
    SetAwsEc2Instance(std::forward<AwsEc2InstanceT>(value));
    return *this;
  }
 
 
  inline const AwsEc2NetworkInterfaceDetails& GetAwsEc2NetworkInterface() const { return m_awsEc2NetworkInterface; }
  inline bool AwsEc2NetworkInterfaceHasBeenSet() const { return m_awsEc2NetworkInterfaceHasBeenSet; }
  template <typename AwsEc2NetworkInterfaceT = AwsEc2NetworkInterfaceDetails>
  void SetAwsEc2NetworkInterface(AwsEc2NetworkInterfaceT&& value) {
    m_awsEc2NetworkInterfaceHasBeenSet = true;
    m_awsEc2NetworkInterface = std::forward<AwsEc2NetworkInterfaceT>(value);
  }
  template <typename AwsEc2NetworkInterfaceT = AwsEc2NetworkInterfaceDetails>
  ResourceDetails& WithAwsEc2NetworkInterface(AwsEc2NetworkInterfaceT&& value) {
    SetAwsEc2NetworkInterface(std::forward<AwsEc2NetworkInterfaceT>(value));
    return *this;
  }
 
 
  inline const AwsEc2SecurityGroupDetails& GetAwsEc2SecurityGroup() const { return m_awsEc2SecurityGroup; }
  inline bool AwsEc2SecurityGroupHasBeenSet() const { return m_awsEc2SecurityGroupHasBeenSet; }
  template <typename AwsEc2SecurityGroupT = AwsEc2SecurityGroupDetails>
  void SetAwsEc2SecurityGroup(AwsEc2SecurityGroupT&& value) {
    m_awsEc2SecurityGroupHasBeenSet = true;
    m_awsEc2SecurityGroup = std::forward<AwsEc2SecurityGroupT>(value);
  }
  template <typename AwsEc2SecurityGroupT = AwsEc2SecurityGroupDetails>
  ResourceDetails& WithAwsEc2SecurityGroup(AwsEc2SecurityGroupT&& value) {
    SetAwsEc2SecurityGroup(std::forward<AwsEc2SecurityGroupT>(value));
    return *this;
  }
 
 
  inline const AwsEc2VolumeDetails& GetAwsEc2Volume() const { return m_awsEc2Volume; }
  inline bool AwsEc2VolumeHasBeenSet() const { return m_awsEc2VolumeHasBeenSet; }
  template <typename AwsEc2VolumeT = AwsEc2VolumeDetails>
  void SetAwsEc2Volume(AwsEc2VolumeT&& value) {
    m_awsEc2VolumeHasBeenSet = true;
    m_awsEc2Volume = std::forward<AwsEc2VolumeT>(value);
  }
  template <typename AwsEc2VolumeT = AwsEc2VolumeDetails>
  ResourceDetails& WithAwsEc2Volume(AwsEc2VolumeT&& value) {
    SetAwsEc2Volume(std::forward<AwsEc2VolumeT>(value));
    return *this;
  }
 
 
  inline const AwsEc2VpcDetails& GetAwsEc2Vpc() const { return m_awsEc2Vpc; }
  inline bool AwsEc2VpcHasBeenSet() const { return m_awsEc2VpcHasBeenSet; }
  template <typename AwsEc2VpcT = AwsEc2VpcDetails>
  void SetAwsEc2Vpc(AwsEc2VpcT&& value) {
    m_awsEc2VpcHasBeenSet = true;
    m_awsEc2Vpc = std::forward<AwsEc2VpcT>(value);
  }
  template <typename AwsEc2VpcT = AwsEc2VpcDetails>
  ResourceDetails& WithAwsEc2Vpc(AwsEc2VpcT&& value) {
    SetAwsEc2Vpc(std::forward<AwsEc2VpcT>(value));
    return *this;
  }
 
 
  inline const AwsEc2EipDetails& GetAwsEc2Eip() const { return m_awsEc2Eip; }
  inline bool AwsEc2EipHasBeenSet() const { return m_awsEc2EipHasBeenSet; }
  template <typename AwsEc2EipT = AwsEc2EipDetails>
  void SetAwsEc2Eip(AwsEc2EipT&& value) {
    m_awsEc2EipHasBeenSet = true;
    m_awsEc2Eip = std::forward<AwsEc2EipT>(value);
  }
  template <typename AwsEc2EipT = AwsEc2EipDetails>
  ResourceDetails& WithAwsEc2Eip(AwsEc2EipT&& value) {
    SetAwsEc2Eip(std::forward<AwsEc2EipT>(value));
    return *this;
  }
 
 
  inline const AwsEc2SubnetDetails& GetAwsEc2Subnet() const { return m_awsEc2Subnet; }
  inline bool AwsEc2SubnetHasBeenSet() const { return m_awsEc2SubnetHasBeenSet; }
  template <typename AwsEc2SubnetT = AwsEc2SubnetDetails>
  void SetAwsEc2Subnet(AwsEc2SubnetT&& value) {
    m_awsEc2SubnetHasBeenSet = true;
    m_awsEc2Subnet = std::forward<AwsEc2SubnetT>(value);
  }
  template <typename AwsEc2SubnetT = AwsEc2SubnetDetails>
  ResourceDetails& WithAwsEc2Subnet(AwsEc2SubnetT&& value) {
    SetAwsEc2Subnet(std::forward<AwsEc2SubnetT>(value));
    return *this;
  }
 
 
  inline const AwsEc2NetworkAclDetails& GetAwsEc2NetworkAcl() const { return m_awsEc2NetworkAcl; }
  inline bool AwsEc2NetworkAclHasBeenSet() const { return m_awsEc2NetworkAclHasBeenSet; }
  template <typename AwsEc2NetworkAclT = AwsEc2NetworkAclDetails>
  void SetAwsEc2NetworkAcl(AwsEc2NetworkAclT&& value) {
    m_awsEc2NetworkAclHasBeenSet = true;
    m_awsEc2NetworkAcl = std::forward<AwsEc2NetworkAclT>(value);
  }
  template <typename AwsEc2NetworkAclT = AwsEc2NetworkAclDetails>
  ResourceDetails& WithAwsEc2NetworkAcl(AwsEc2NetworkAclT&& value) {
    SetAwsEc2NetworkAcl(std::forward<AwsEc2NetworkAclT>(value));
    return *this;
  }
 
 
  inline const AwsElbv2LoadBalancerDetails& GetAwsElbv2LoadBalancer() const { return m_awsElbv2LoadBalancer; }
  inline bool AwsElbv2LoadBalancerHasBeenSet() const { return m_awsElbv2LoadBalancerHasBeenSet; }
  template <typename AwsElbv2LoadBalancerT = AwsElbv2LoadBalancerDetails>
  void SetAwsElbv2LoadBalancer(AwsElbv2LoadBalancerT&& value) {
    m_awsElbv2LoadBalancerHasBeenSet = true;
    m_awsElbv2LoadBalancer = std::forward<AwsElbv2LoadBalancerT>(value);
  }
  template <typename AwsElbv2LoadBalancerT = AwsElbv2LoadBalancerDetails>
  ResourceDetails& WithAwsElbv2LoadBalancer(AwsElbv2LoadBalancerT&& value) {
    SetAwsElbv2LoadBalancer(std::forward<AwsElbv2LoadBalancerT>(value));
    return *this;
  }
 
 
  inline const AwsElasticBeanstalkEnvironmentDetails& GetAwsElasticBeanstalkEnvironment() const { return m_awsElasticBeanstalkEnvironment; }
  inline bool AwsElasticBeanstalkEnvironmentHasBeenSet() const { return m_awsElasticBeanstalkEnvironmentHasBeenSet; }
  template <typename AwsElasticBeanstalkEnvironmentT = AwsElasticBeanstalkEnvironmentDetails>
  void SetAwsElasticBeanstalkEnvironment(AwsElasticBeanstalkEnvironmentT&& value) {
    m_awsElasticBeanstalkEnvironmentHasBeenSet = true;
    m_awsElasticBeanstalkEnvironment = std::forward<AwsElasticBeanstalkEnvironmentT>(value);
  }
  template <typename AwsElasticBeanstalkEnvironmentT = AwsElasticBeanstalkEnvironmentDetails>
  ResourceDetails& WithAwsElasticBeanstalkEnvironment(AwsElasticBeanstalkEnvironmentT&& value) {
    SetAwsElasticBeanstalkEnvironment(std::forward<AwsElasticBeanstalkEnvironmentT>(value));
    return *this;
  }
 
 
  inline const AwsElasticsearchDomainDetails& GetAwsElasticsearchDomain() const { return m_awsElasticsearchDomain; }
  inline bool AwsElasticsearchDomainHasBeenSet() const { return m_awsElasticsearchDomainHasBeenSet; }
  template <typename AwsElasticsearchDomainT = AwsElasticsearchDomainDetails>
  void SetAwsElasticsearchDomain(AwsElasticsearchDomainT&& value) {
    m_awsElasticsearchDomainHasBeenSet = true;
    m_awsElasticsearchDomain = std::forward<AwsElasticsearchDomainT>(value);
  }
  template <typename AwsElasticsearchDomainT = AwsElasticsearchDomainDetails>
  ResourceDetails& WithAwsElasticsearchDomain(AwsElasticsearchDomainT&& value) {
    SetAwsElasticsearchDomain(std::forward<AwsElasticsearchDomainT>(value));
    return *this;
  }
 
 
  inline const AwsS3BucketDetails& GetAwsS3Bucket() const { return m_awsS3Bucket; }
  inline bool AwsS3BucketHasBeenSet() const { return m_awsS3BucketHasBeenSet; }
  template <typename AwsS3BucketT = AwsS3BucketDetails>
  void SetAwsS3Bucket(AwsS3BucketT&& value) {
    m_awsS3BucketHasBeenSet = true;
    m_awsS3Bucket = std::forward<AwsS3BucketT>(value);
  }
  template <typename AwsS3BucketT = AwsS3BucketDetails>
  ResourceDetails& WithAwsS3Bucket(AwsS3BucketT&& value) {
    SetAwsS3Bucket(std::forward<AwsS3BucketT>(value));
    return *this;
  }
 
 
  inline const AwsS3AccountPublicAccessBlockDetails& GetAwsS3AccountPublicAccessBlock() const { return m_awsS3AccountPublicAccessBlock; }
  inline bool AwsS3AccountPublicAccessBlockHasBeenSet() const { return m_awsS3AccountPublicAccessBlockHasBeenSet; }
  template <typename AwsS3AccountPublicAccessBlockT = AwsS3AccountPublicAccessBlockDetails>
  void SetAwsS3AccountPublicAccessBlock(AwsS3AccountPublicAccessBlockT&& value) {
    m_awsS3AccountPublicAccessBlockHasBeenSet = true;
    m_awsS3AccountPublicAccessBlock = std::forward<AwsS3AccountPublicAccessBlockT>(value);
  }
  template <typename AwsS3AccountPublicAccessBlockT = AwsS3AccountPublicAccessBlockDetails>
  ResourceDetails& WithAwsS3AccountPublicAccessBlock(AwsS3AccountPublicAccessBlockT&& value) {
    SetAwsS3AccountPublicAccessBlock(std::forward<AwsS3AccountPublicAccessBlockT>(value));
    return *this;
  }
 
 
  inline const AwsS3ObjectDetails& GetAwsS3Object() const { return m_awsS3Object; }
  inline bool AwsS3ObjectHasBeenSet() const { return m_awsS3ObjectHasBeenSet; }
  template <typename AwsS3ObjectT = AwsS3ObjectDetails>
  void SetAwsS3Object(AwsS3ObjectT&& value) {
    m_awsS3ObjectHasBeenSet = true;
    m_awsS3Object = std::forward<AwsS3ObjectT>(value);
  }
  template <typename AwsS3ObjectT = AwsS3ObjectDetails>
  ResourceDetails& WithAwsS3Object(AwsS3ObjectT&& value) {
    SetAwsS3Object(std::forward<AwsS3ObjectT>(value));
    return *this;
  }
 
 
  inline const AwsSecretsManagerSecretDetails& GetAwsSecretsManagerSecret() const { return m_awsSecretsManagerSecret; }
  inline bool AwsSecretsManagerSecretHasBeenSet() const { return m_awsSecretsManagerSecretHasBeenSet; }
  template <typename AwsSecretsManagerSecretT = AwsSecretsManagerSecretDetails>
  void SetAwsSecretsManagerSecret(AwsSecretsManagerSecretT&& value) {
    m_awsSecretsManagerSecretHasBeenSet = true;
    m_awsSecretsManagerSecret = std::forward<AwsSecretsManagerSecretT>(value);
  }
  template <typename AwsSecretsManagerSecretT = AwsSecretsManagerSecretDetails>
  ResourceDetails& WithAwsSecretsManagerSecret(AwsSecretsManagerSecretT&& value) {
    SetAwsSecretsManagerSecret(std::forward<AwsSecretsManagerSecretT>(value));
    return *this;
  }
 
 
  inline const AwsIamAccessKeyDetails& GetAwsIamAccessKey() const { return m_awsIamAccessKey; }
  inline bool AwsIamAccessKeyHasBeenSet() const { return m_awsIamAccessKeyHasBeenSet; }
  template <typename AwsIamAccessKeyT = AwsIamAccessKeyDetails>
  void SetAwsIamAccessKey(AwsIamAccessKeyT&& value) {
    m_awsIamAccessKeyHasBeenSet = true;
    m_awsIamAccessKey = std::forward<AwsIamAccessKeyT>(value);
  }
  template <typename AwsIamAccessKeyT = AwsIamAccessKeyDetails>
  ResourceDetails& WithAwsIamAccessKey(AwsIamAccessKeyT&& value) {
    SetAwsIamAccessKey(std::forward<AwsIamAccessKeyT>(value));
    return *this;
  }
 
 
  inline const AwsIamUserDetails& GetAwsIamUser() const { return m_awsIamUser; }
  inline bool AwsIamUserHasBeenSet() const { return m_awsIamUserHasBeenSet; }
  template <typename AwsIamUserT = AwsIamUserDetails>
  void SetAwsIamUser(AwsIamUserT&& value) {
    m_awsIamUserHasBeenSet = true;
    m_awsIamUser = std::forward<AwsIamUserT>(value);
  }
  template <typename AwsIamUserT = AwsIamUserDetails>
  ResourceDetails& WithAwsIamUser(AwsIamUserT&& value) {
    SetAwsIamUser(std::forward<AwsIamUserT>(value));
    return *this;
  }
 
 
  inline const AwsIamPolicyDetails& GetAwsIamPolicy() const { return m_awsIamPolicy; }
  inline bool AwsIamPolicyHasBeenSet() const { return m_awsIamPolicyHasBeenSet; }
  template <typename AwsIamPolicyT = AwsIamPolicyDetails>
  void SetAwsIamPolicy(AwsIamPolicyT&& value) {
    m_awsIamPolicyHasBeenSet = true;
    m_awsIamPolicy = std::forward<AwsIamPolicyT>(value);
  }
  template <typename AwsIamPolicyT = AwsIamPolicyDetails>
  ResourceDetails& WithAwsIamPolicy(AwsIamPolicyT&& value) {
    SetAwsIamPolicy(std::forward<AwsIamPolicyT>(value));
    return *this;
  }
 
 
  inline const AwsApiGatewayV2StageDetails& GetAwsApiGatewayV2Stage() const { return m_awsApiGatewayV2Stage; }
  inline bool AwsApiGatewayV2StageHasBeenSet() const { return m_awsApiGatewayV2StageHasBeenSet; }
  template <typename AwsApiGatewayV2StageT = AwsApiGatewayV2StageDetails>
  void SetAwsApiGatewayV2Stage(AwsApiGatewayV2StageT&& value) {
    m_awsApiGatewayV2StageHasBeenSet = true;
    m_awsApiGatewayV2Stage = std::forward<AwsApiGatewayV2StageT>(value);
  }
  template <typename AwsApiGatewayV2StageT = AwsApiGatewayV2StageDetails>
  ResourceDetails& WithAwsApiGatewayV2Stage(AwsApiGatewayV2StageT&& value) {
    SetAwsApiGatewayV2Stage(std::forward<AwsApiGatewayV2StageT>(value));
    return *this;
  }
 
 
  inline const AwsApiGatewayV2ApiDetails& GetAwsApiGatewayV2Api() const { return m_awsApiGatewayV2Api; }
  inline bool AwsApiGatewayV2ApiHasBeenSet() const { return m_awsApiGatewayV2ApiHasBeenSet; }
  template <typename AwsApiGatewayV2ApiT = AwsApiGatewayV2ApiDetails>
  void SetAwsApiGatewayV2Api(AwsApiGatewayV2ApiT&& value) {
    m_awsApiGatewayV2ApiHasBeenSet = true;
    m_awsApiGatewayV2Api = std::forward<AwsApiGatewayV2ApiT>(value);
  }
  template <typename AwsApiGatewayV2ApiT = AwsApiGatewayV2ApiDetails>
  ResourceDetails& WithAwsApiGatewayV2Api(AwsApiGatewayV2ApiT&& value) {
    SetAwsApiGatewayV2Api(std::forward<AwsApiGatewayV2ApiT>(value));
    return *this;
  }
 
 
  inline const AwsDynamoDbTableDetails& GetAwsDynamoDbTable() const { return m_awsDynamoDbTable; }
  inline bool AwsDynamoDbTableHasBeenSet() const { return m_awsDynamoDbTableHasBeenSet; }
  template <typename AwsDynamoDbTableT = AwsDynamoDbTableDetails>
  void SetAwsDynamoDbTable(AwsDynamoDbTableT&& value) {
    m_awsDynamoDbTableHasBeenSet = true;
    m_awsDynamoDbTable = std::forward<AwsDynamoDbTableT>(value);
  }
  template <typename AwsDynamoDbTableT = AwsDynamoDbTableDetails>
  ResourceDetails& WithAwsDynamoDbTable(AwsDynamoDbTableT&& value) {
    SetAwsDynamoDbTable(std::forward<AwsDynamoDbTableT>(value));
    return *this;
  }
 
 
  inline const AwsApiGatewayStageDetails& GetAwsApiGatewayStage() const { return m_awsApiGatewayStage; }
  inline bool AwsApiGatewayStageHasBeenSet() const { return m_awsApiGatewayStageHasBeenSet; }
  template <typename AwsApiGatewayStageT = AwsApiGatewayStageDetails>
  void SetAwsApiGatewayStage(AwsApiGatewayStageT&& value) {
    m_awsApiGatewayStageHasBeenSet = true;
    m_awsApiGatewayStage = std::forward<AwsApiGatewayStageT>(value);
  }
  template <typename AwsApiGatewayStageT = AwsApiGatewayStageDetails>
  ResourceDetails& WithAwsApiGatewayStage(AwsApiGatewayStageT&& value) {
    SetAwsApiGatewayStage(std::forward<AwsApiGatewayStageT>(value));
    return *this;
  }
 
 
  inline const AwsApiGatewayRestApiDetails& GetAwsApiGatewayRestApi() const { return m_awsApiGatewayRestApi; }
  inline bool AwsApiGatewayRestApiHasBeenSet() const { return m_awsApiGatewayRestApiHasBeenSet; }
  template <typename AwsApiGatewayRestApiT = AwsApiGatewayRestApiDetails>
  void SetAwsApiGatewayRestApi(AwsApiGatewayRestApiT&& value) {
    m_awsApiGatewayRestApiHasBeenSet = true;
    m_awsApiGatewayRestApi = std::forward<AwsApiGatewayRestApiT>(value);
  }
  template <typename AwsApiGatewayRestApiT = AwsApiGatewayRestApiDetails>
  ResourceDetails& WithAwsApiGatewayRestApi(AwsApiGatewayRestApiT&& value) {
    SetAwsApiGatewayRestApi(std::forward<AwsApiGatewayRestApiT>(value));
    return *this;
  }
 
 
  inline const AwsCloudTrailTrailDetails& GetAwsCloudTrailTrail() const { return m_awsCloudTrailTrail; }
  inline bool AwsCloudTrailTrailHasBeenSet() const { return m_awsCloudTrailTrailHasBeenSet; }
  template <typename AwsCloudTrailTrailT = AwsCloudTrailTrailDetails>
  void SetAwsCloudTrailTrail(AwsCloudTrailTrailT&& value) {
    m_awsCloudTrailTrailHasBeenSet = true;
    m_awsCloudTrailTrail = std::forward<AwsCloudTrailTrailT>(value);
  }
  template <typename AwsCloudTrailTrailT = AwsCloudTrailTrailDetails>
  ResourceDetails& WithAwsCloudTrailTrail(AwsCloudTrailTrailT&& value) {
    SetAwsCloudTrailTrail(std::forward<AwsCloudTrailTrailT>(value));
    return *this;
  }
 
 
  inline const AwsSsmPatchComplianceDetails& GetAwsSsmPatchCompliance() const { return m_awsSsmPatchCompliance; }
  inline bool AwsSsmPatchComplianceHasBeenSet() const { return m_awsSsmPatchComplianceHasBeenSet; }
  template <typename AwsSsmPatchComplianceT = AwsSsmPatchComplianceDetails>
  void SetAwsSsmPatchCompliance(AwsSsmPatchComplianceT&& value) {
    m_awsSsmPatchComplianceHasBeenSet = true;
    m_awsSsmPatchCompliance = std::forward<AwsSsmPatchComplianceT>(value);
  }
  template <typename AwsSsmPatchComplianceT = AwsSsmPatchComplianceDetails>
  ResourceDetails& WithAwsSsmPatchCompliance(AwsSsmPatchComplianceT&& value) {
    SetAwsSsmPatchCompliance(std::forward<AwsSsmPatchComplianceT>(value));
    return *this;
  }
 
 
  inline const AwsCertificateManagerCertificateDetails& GetAwsCertificateManagerCertificate() const {
    return m_awsCertificateManagerCertificate;
  }
  inline bool AwsCertificateManagerCertificateHasBeenSet() const { return m_awsCertificateManagerCertificateHasBeenSet; }
  template <typename AwsCertificateManagerCertificateT = AwsCertificateManagerCertificateDetails>
  void SetAwsCertificateManagerCertificate(AwsCertificateManagerCertificateT&& value) {
    m_awsCertificateManagerCertificateHasBeenSet = true;
    m_awsCertificateManagerCertificate = std::forward<AwsCertificateManagerCertificateT>(value);
  }
  template <typename AwsCertificateManagerCertificateT = AwsCertificateManagerCertificateDetails>
  ResourceDetails& WithAwsCertificateManagerCertificate(AwsCertificateManagerCertificateT&& value) {
    SetAwsCertificateManagerCertificate(std::forward<AwsCertificateManagerCertificateT>(value));
    return *this;
  }
 
 
  inline const AwsRedshiftClusterDetails& GetAwsRedshiftCluster() const { return m_awsRedshiftCluster; }
  inline bool AwsRedshiftClusterHasBeenSet() const { return m_awsRedshiftClusterHasBeenSet; }
  template <typename AwsRedshiftClusterT = AwsRedshiftClusterDetails>
  void SetAwsRedshiftCluster(AwsRedshiftClusterT&& value) {
    m_awsRedshiftClusterHasBeenSet = true;
    m_awsRedshiftCluster = std::forward<AwsRedshiftClusterT>(value);
  }
  template <typename AwsRedshiftClusterT = AwsRedshiftClusterDetails>
  ResourceDetails& WithAwsRedshiftCluster(AwsRedshiftClusterT&& value) {
    SetAwsRedshiftCluster(std::forward<AwsRedshiftClusterT>(value));
    return *this;
  }
 
 
  inline const AwsElbLoadBalancerDetails& GetAwsElbLoadBalancer() const { return m_awsElbLoadBalancer; }
  inline bool AwsElbLoadBalancerHasBeenSet() const { return m_awsElbLoadBalancerHasBeenSet; }
  template <typename AwsElbLoadBalancerT = AwsElbLoadBalancerDetails>
  void SetAwsElbLoadBalancer(AwsElbLoadBalancerT&& value) {
    m_awsElbLoadBalancerHasBeenSet = true;
    m_awsElbLoadBalancer = std::forward<AwsElbLoadBalancerT>(value);
  }
  template <typename AwsElbLoadBalancerT = AwsElbLoadBalancerDetails>
  ResourceDetails& WithAwsElbLoadBalancer(AwsElbLoadBalancerT&& value) {
    SetAwsElbLoadBalancer(std::forward<AwsElbLoadBalancerT>(value));
    return *this;
  }
 
 
  inline const AwsIamGroupDetails& GetAwsIamGroup() const { return m_awsIamGroup; }
  inline bool AwsIamGroupHasBeenSet() const { return m_awsIamGroupHasBeenSet; }
  template <typename AwsIamGroupT = AwsIamGroupDetails>
  void SetAwsIamGroup(AwsIamGroupT&& value) {
    m_awsIamGroupHasBeenSet = true;
    m_awsIamGroup = std::forward<AwsIamGroupT>(value);
  }
  template <typename AwsIamGroupT = AwsIamGroupDetails>
  ResourceDetails& WithAwsIamGroup(AwsIamGroupT&& value) {
    SetAwsIamGroup(std::forward<AwsIamGroupT>(value));
    return *this;
  }
 
 
  inline const AwsIamRoleDetails& GetAwsIamRole() const { return m_awsIamRole; }
  inline bool AwsIamRoleHasBeenSet() const { return m_awsIamRoleHasBeenSet; }
  template <typename AwsIamRoleT = AwsIamRoleDetails>
  void SetAwsIamRole(AwsIamRoleT&& value) {
    m_awsIamRoleHasBeenSet = true;
    m_awsIamRole = std::forward<AwsIamRoleT>(value);
  }
  template <typename AwsIamRoleT = AwsIamRoleDetails>
  ResourceDetails& WithAwsIamRole(AwsIamRoleT&& value) {
    SetAwsIamRole(std::forward<AwsIamRoleT>(value));
    return *this;
  }
 
 
  inline const AwsKmsKeyDetails& GetAwsKmsKey() const { return m_awsKmsKey; }
  inline bool AwsKmsKeyHasBeenSet() const { return m_awsKmsKeyHasBeenSet; }
  template <typename AwsKmsKeyT = AwsKmsKeyDetails>
  void SetAwsKmsKey(AwsKmsKeyT&& value) {
    m_awsKmsKeyHasBeenSet = true;
    m_awsKmsKey = std::forward<AwsKmsKeyT>(value);
  }
  template <typename AwsKmsKeyT = AwsKmsKeyDetails>
  ResourceDetails& WithAwsKmsKey(AwsKmsKeyT&& value) {
    SetAwsKmsKey(std::forward<AwsKmsKeyT>(value));
    return *this;
  }
 
 
  inline const AwsLambdaFunctionDetails& GetAwsLambdaFunction() const { return m_awsLambdaFunction; }
  inline bool AwsLambdaFunctionHasBeenSet() const { return m_awsLambdaFunctionHasBeenSet; }
  template <typename AwsLambdaFunctionT = AwsLambdaFunctionDetails>
  void SetAwsLambdaFunction(AwsLambdaFunctionT&& value) {
    m_awsLambdaFunctionHasBeenSet = true;
    m_awsLambdaFunction = std::forward<AwsLambdaFunctionT>(value);
  }
  template <typename AwsLambdaFunctionT = AwsLambdaFunctionDetails>
  ResourceDetails& WithAwsLambdaFunction(AwsLambdaFunctionT&& value) {
    SetAwsLambdaFunction(std::forward<AwsLambdaFunctionT>(value));
    return *this;
  }
 
 
  inline const AwsLambdaLayerVersionDetails& GetAwsLambdaLayerVersion() const { return m_awsLambdaLayerVersion; }
  inline bool AwsLambdaLayerVersionHasBeenSet() const { return m_awsLambdaLayerVersionHasBeenSet; }
  template <typename AwsLambdaLayerVersionT = AwsLambdaLayerVersionDetails>
  void SetAwsLambdaLayerVersion(AwsLambdaLayerVersionT&& value) {
    m_awsLambdaLayerVersionHasBeenSet = true;
    m_awsLambdaLayerVersion = std::forward<AwsLambdaLayerVersionT>(value);
  }
  template <typename AwsLambdaLayerVersionT = AwsLambdaLayerVersionDetails>
  ResourceDetails& WithAwsLambdaLayerVersion(AwsLambdaLayerVersionT&& value) {
    SetAwsLambdaLayerVersion(std::forward<AwsLambdaLayerVersionT>(value));
    return *this;
  }
 
 
  inline const AwsRdsDbInstanceDetails& GetAwsRdsDbInstance() const { return m_awsRdsDbInstance; }
  inline bool AwsRdsDbInstanceHasBeenSet() const { return m_awsRdsDbInstanceHasBeenSet; }
  template <typename AwsRdsDbInstanceT = AwsRdsDbInstanceDetails>
  void SetAwsRdsDbInstance(AwsRdsDbInstanceT&& value) {
    m_awsRdsDbInstanceHasBeenSet = true;
    m_awsRdsDbInstance = std::forward<AwsRdsDbInstanceT>(value);
  }
  template <typename AwsRdsDbInstanceT = AwsRdsDbInstanceDetails>
  ResourceDetails& WithAwsRdsDbInstance(AwsRdsDbInstanceT&& value) {
    SetAwsRdsDbInstance(std::forward<AwsRdsDbInstanceT>(value));
    return *this;
  }
 
 
  inline const AwsSnsTopicDetails& GetAwsSnsTopic() const { return m_awsSnsTopic; }
  inline bool AwsSnsTopicHasBeenSet() const { return m_awsSnsTopicHasBeenSet; }
  template <typename AwsSnsTopicT = AwsSnsTopicDetails>
  void SetAwsSnsTopic(AwsSnsTopicT&& value) {
    m_awsSnsTopicHasBeenSet = true;
    m_awsSnsTopic = std::forward<AwsSnsTopicT>(value);
  }
  template <typename AwsSnsTopicT = AwsSnsTopicDetails>
  ResourceDetails& WithAwsSnsTopic(AwsSnsTopicT&& value) {
    SetAwsSnsTopic(std::forward<AwsSnsTopicT>(value));
    return *this;
  }
 
 
  inline const AwsSqsQueueDetails& GetAwsSqsQueue() const { return m_awsSqsQueue; }
  inline bool AwsSqsQueueHasBeenSet() const { return m_awsSqsQueueHasBeenSet; }
  template <typename AwsSqsQueueT = AwsSqsQueueDetails>
  void SetAwsSqsQueue(AwsSqsQueueT&& value) {
    m_awsSqsQueueHasBeenSet = true;
    m_awsSqsQueue = std::forward<AwsSqsQueueT>(value);
  }
  template <typename AwsSqsQueueT = AwsSqsQueueDetails>
  ResourceDetails& WithAwsSqsQueue(AwsSqsQueueT&& value) {
    SetAwsSqsQueue(std::forward<AwsSqsQueueT>(value));
    return *this;
  }
 
 
  inline const AwsWafWebAclDetails& GetAwsWafWebAcl() const { return m_awsWafWebAcl; }
  inline bool AwsWafWebAclHasBeenSet() const { return m_awsWafWebAclHasBeenSet; }
  template <typename AwsWafWebAclT = AwsWafWebAclDetails>
  void SetAwsWafWebAcl(AwsWafWebAclT&& value) {
    m_awsWafWebAclHasBeenSet = true;
    m_awsWafWebAcl = std::forward<AwsWafWebAclT>(value);
  }
  template <typename AwsWafWebAclT = AwsWafWebAclDetails>
  ResourceDetails& WithAwsWafWebAcl(AwsWafWebAclT&& value) {
    SetAwsWafWebAcl(std::forward<AwsWafWebAclT>(value));
    return *this;
  }
 
 
  inline const AwsRdsDbSnapshotDetails& GetAwsRdsDbSnapshot() const { return m_awsRdsDbSnapshot; }
  inline bool AwsRdsDbSnapshotHasBeenSet() const { return m_awsRdsDbSnapshotHasBeenSet; }
  template <typename AwsRdsDbSnapshotT = AwsRdsDbSnapshotDetails>
  void SetAwsRdsDbSnapshot(AwsRdsDbSnapshotT&& value) {
    m_awsRdsDbSnapshotHasBeenSet = true;
    m_awsRdsDbSnapshot = std::forward<AwsRdsDbSnapshotT>(value);
  }
  template <typename AwsRdsDbSnapshotT = AwsRdsDbSnapshotDetails>
  ResourceDetails& WithAwsRdsDbSnapshot(AwsRdsDbSnapshotT&& value) {
    SetAwsRdsDbSnapshot(std::forward<AwsRdsDbSnapshotT>(value));
    return *this;
  }
 
 
  inline const AwsRdsDbClusterSnapshotDetails& GetAwsRdsDbClusterSnapshot() const { return m_awsRdsDbClusterSnapshot; }
  inline bool AwsRdsDbClusterSnapshotHasBeenSet() const { return m_awsRdsDbClusterSnapshotHasBeenSet; }
  template <typename AwsRdsDbClusterSnapshotT = AwsRdsDbClusterSnapshotDetails>
  void SetAwsRdsDbClusterSnapshot(AwsRdsDbClusterSnapshotT&& value) {
    m_awsRdsDbClusterSnapshotHasBeenSet = true;
    m_awsRdsDbClusterSnapshot = std::forward<AwsRdsDbClusterSnapshotT>(value);
  }
  template <typename AwsRdsDbClusterSnapshotT = AwsRdsDbClusterSnapshotDetails>
  ResourceDetails& WithAwsRdsDbClusterSnapshot(AwsRdsDbClusterSnapshotT&& value) {
    SetAwsRdsDbClusterSnapshot(std::forward<AwsRdsDbClusterSnapshotT>(value));
    return *this;
  }
 
 
  inline const AwsRdsDbClusterDetails& GetAwsRdsDbCluster() const { return m_awsRdsDbCluster; }
  inline bool AwsRdsDbClusterHasBeenSet() const { return m_awsRdsDbClusterHasBeenSet; }
  template <typename AwsRdsDbClusterT = AwsRdsDbClusterDetails>
  void SetAwsRdsDbCluster(AwsRdsDbClusterT&& value) {
    m_awsRdsDbClusterHasBeenSet = true;
    m_awsRdsDbCluster = std::forward<AwsRdsDbClusterT>(value);
  }
  template <typename AwsRdsDbClusterT = AwsRdsDbClusterDetails>
  ResourceDetails& WithAwsRdsDbCluster(AwsRdsDbClusterT&& value) {
    SetAwsRdsDbCluster(std::forward<AwsRdsDbClusterT>(value));
    return *this;
  }
 
 
  inline const AwsEcsClusterDetails& GetAwsEcsCluster() const { return m_awsEcsCluster; }
  inline bool AwsEcsClusterHasBeenSet() const { return m_awsEcsClusterHasBeenSet; }
  template <typename AwsEcsClusterT = AwsEcsClusterDetails>
  void SetAwsEcsCluster(AwsEcsClusterT&& value) {
    m_awsEcsClusterHasBeenSet = true;
    m_awsEcsCluster = std::forward<AwsEcsClusterT>(value);
  }
  template <typename AwsEcsClusterT = AwsEcsClusterDetails>
  ResourceDetails& WithAwsEcsCluster(AwsEcsClusterT&& value) {
    SetAwsEcsCluster(std::forward<AwsEcsClusterT>(value));
    return *this;
  }
 
 
  inline const AwsEcsContainerDetails& GetAwsEcsContainer() const { return m_awsEcsContainer; }
  inline bool AwsEcsContainerHasBeenSet() const { return m_awsEcsContainerHasBeenSet; }
  template <typename AwsEcsContainerT = AwsEcsContainerDetails>
  void SetAwsEcsContainer(AwsEcsContainerT&& value) {
    m_awsEcsContainerHasBeenSet = true;
    m_awsEcsContainer = std::forward<AwsEcsContainerT>(value);
  }
  template <typename AwsEcsContainerT = AwsEcsContainerDetails>
  ResourceDetails& WithAwsEcsContainer(AwsEcsContainerT&& value) {
    SetAwsEcsContainer(std::forward<AwsEcsContainerT>(value));
    return *this;
  }
 
 
  inline const AwsEcsTaskDefinitionDetails& GetAwsEcsTaskDefinition() const { return m_awsEcsTaskDefinition; }
  inline bool AwsEcsTaskDefinitionHasBeenSet() const { return m_awsEcsTaskDefinitionHasBeenSet; }
  template <typename AwsEcsTaskDefinitionT = AwsEcsTaskDefinitionDetails>
  void SetAwsEcsTaskDefinition(AwsEcsTaskDefinitionT&& value) {
    m_awsEcsTaskDefinitionHasBeenSet = true;
    m_awsEcsTaskDefinition = std::forward<AwsEcsTaskDefinitionT>(value);
  }
  template <typename AwsEcsTaskDefinitionT = AwsEcsTaskDefinitionDetails>
  ResourceDetails& WithAwsEcsTaskDefinition(AwsEcsTaskDefinitionT&& value) {
    SetAwsEcsTaskDefinition(std::forward<AwsEcsTaskDefinitionT>(value));
    return *this;
  }
 
 
  inline const ContainerDetails& GetContainer() const { return m_container; }
  inline bool ContainerHasBeenSet() const { return m_containerHasBeenSet; }
  template <typename ContainerT = ContainerDetails>
  void SetContainer(ContainerT&& value) {
    m_containerHasBeenSet = true;
    m_container = std::forward<ContainerT>(value);
  }
  template <typename ContainerT = ContainerDetails>
  ResourceDetails& WithContainer(ContainerT&& value) {
    SetContainer(std::forward<ContainerT>(value));
    return *this;
  }
 
 
  inline const Aws::Map<Aws::String, Aws::String>& GetOther() const { return m_other; }
  inline bool OtherHasBeenSet() const { return m_otherHasBeenSet; }
  template <typename OtherT = Aws::Map<Aws::String, Aws::String>>
  void SetOther(OtherT&& value) {
    m_otherHasBeenSet = true;
    m_other = std::forward<OtherT>(value);
  }
  template <typename OtherT = Aws::Map<Aws::String, Aws::String>>
  ResourceDetails& WithOther(OtherT&& value) {
    SetOther(std::forward<OtherT>(value));
    return *this;
  }
  template <typename OtherKeyT = Aws::String, typename OtherValueT = Aws::String>
  ResourceDetails& AddOther(OtherKeyT&& key, OtherValueT&& value) {
    m_otherHasBeenSet = true;
    m_other.emplace(std::forward<OtherKeyT>(key), std::forward<OtherValueT>(value));
    return *this;
  }
 
 
  inline const AwsRdsEventSubscriptionDetails& GetAwsRdsEventSubscription() const { return m_awsRdsEventSubscription; }
  inline bool AwsRdsEventSubscriptionHasBeenSet() const { return m_awsRdsEventSubscriptionHasBeenSet; }
  template <typename AwsRdsEventSubscriptionT = AwsRdsEventSubscriptionDetails>
  void SetAwsRdsEventSubscription(AwsRdsEventSubscriptionT&& value) {
    m_awsRdsEventSubscriptionHasBeenSet = true;
    m_awsRdsEventSubscription = std::forward<AwsRdsEventSubscriptionT>(value);
  }
  template <typename AwsRdsEventSubscriptionT = AwsRdsEventSubscriptionDetails>
  ResourceDetails& WithAwsRdsEventSubscription(AwsRdsEventSubscriptionT&& value) {
    SetAwsRdsEventSubscription(std::forward<AwsRdsEventSubscriptionT>(value));
    return *this;
  }
 
 
  inline const AwsEcsServiceDetails& GetAwsEcsService() const { return m_awsEcsService; }
  inline bool AwsEcsServiceHasBeenSet() const { return m_awsEcsServiceHasBeenSet; }
  template <typename AwsEcsServiceT = AwsEcsServiceDetails>
  void SetAwsEcsService(AwsEcsServiceT&& value) {
    m_awsEcsServiceHasBeenSet = true;
    m_awsEcsService = std::forward<AwsEcsServiceT>(value);
  }
  template <typename AwsEcsServiceT = AwsEcsServiceDetails>
  ResourceDetails& WithAwsEcsService(AwsEcsServiceT&& value) {
    SetAwsEcsService(std::forward<AwsEcsServiceT>(value));
    return *this;
  }
 
 
  inline const AwsAutoScalingLaunchConfigurationDetails& GetAwsAutoScalingLaunchConfiguration() const {
    return m_awsAutoScalingLaunchConfiguration;
  }
  inline bool AwsAutoScalingLaunchConfigurationHasBeenSet() const { return m_awsAutoScalingLaunchConfigurationHasBeenSet; }
  template <typename AwsAutoScalingLaunchConfigurationT = AwsAutoScalingLaunchConfigurationDetails>
  void SetAwsAutoScalingLaunchConfiguration(AwsAutoScalingLaunchConfigurationT&& value) {
    m_awsAutoScalingLaunchConfigurationHasBeenSet = true;
    m_awsAutoScalingLaunchConfiguration = std::forward<AwsAutoScalingLaunchConfigurationT>(value);
  }
  template <typename AwsAutoScalingLaunchConfigurationT = AwsAutoScalingLaunchConfigurationDetails>
  ResourceDetails& WithAwsAutoScalingLaunchConfiguration(AwsAutoScalingLaunchConfigurationT&& value) {
    SetAwsAutoScalingLaunchConfiguration(std::forward<AwsAutoScalingLaunchConfigurationT>(value));
    return *this;
  }
 
 
  inline const AwsEc2VpnConnectionDetails& GetAwsEc2VpnConnection() const { return m_awsEc2VpnConnection; }
  inline bool AwsEc2VpnConnectionHasBeenSet() const { return m_awsEc2VpnConnectionHasBeenSet; }
  template <typename AwsEc2VpnConnectionT = AwsEc2VpnConnectionDetails>
  void SetAwsEc2VpnConnection(AwsEc2VpnConnectionT&& value) {
    m_awsEc2VpnConnectionHasBeenSet = true;
    m_awsEc2VpnConnection = std::forward<AwsEc2VpnConnectionT>(value);
  }
  template <typename AwsEc2VpnConnectionT = AwsEc2VpnConnectionDetails>
  ResourceDetails& WithAwsEc2VpnConnection(AwsEc2VpnConnectionT&& value) {
    SetAwsEc2VpnConnection(std::forward<AwsEc2VpnConnectionT>(value));
    return *this;
  }
 
 
  inline const AwsEcrContainerImageDetails& GetAwsEcrContainerImage() const { return m_awsEcrContainerImage; }
  inline bool AwsEcrContainerImageHasBeenSet() const { return m_awsEcrContainerImageHasBeenSet; }
  template <typename AwsEcrContainerImageT = AwsEcrContainerImageDetails>
  void SetAwsEcrContainerImage(AwsEcrContainerImageT&& value) {
    m_awsEcrContainerImageHasBeenSet = true;
    m_awsEcrContainerImage = std::forward<AwsEcrContainerImageT>(value);
  }
  template <typename AwsEcrContainerImageT = AwsEcrContainerImageDetails>
  ResourceDetails& WithAwsEcrContainerImage(AwsEcrContainerImageT&& value) {
    SetAwsEcrContainerImage(std::forward<AwsEcrContainerImageT>(value));
    return *this;
  }
 
 
  inline const AwsOpenSearchServiceDomainDetails& GetAwsOpenSearchServiceDomain() const { return m_awsOpenSearchServiceDomain; }
  inline bool AwsOpenSearchServiceDomainHasBeenSet() const { return m_awsOpenSearchServiceDomainHasBeenSet; }
  template <typename AwsOpenSearchServiceDomainT = AwsOpenSearchServiceDomainDetails>
  void SetAwsOpenSearchServiceDomain(AwsOpenSearchServiceDomainT&& value) {
    m_awsOpenSearchServiceDomainHasBeenSet = true;
    m_awsOpenSearchServiceDomain = std::forward<AwsOpenSearchServiceDomainT>(value);
  }
  template <typename AwsOpenSearchServiceDomainT = AwsOpenSearchServiceDomainDetails>
  ResourceDetails& WithAwsOpenSearchServiceDomain(AwsOpenSearchServiceDomainT&& value) {
    SetAwsOpenSearchServiceDomain(std::forward<AwsOpenSearchServiceDomainT>(value));
    return *this;
  }
 
 
  inline const AwsEc2VpcEndpointServiceDetails& GetAwsEc2VpcEndpointService() const { return m_awsEc2VpcEndpointService; }
  inline bool AwsEc2VpcEndpointServiceHasBeenSet() const { return m_awsEc2VpcEndpointServiceHasBeenSet; }
  template <typename AwsEc2VpcEndpointServiceT = AwsEc2VpcEndpointServiceDetails>
  void SetAwsEc2VpcEndpointService(AwsEc2VpcEndpointServiceT&& value) {
    m_awsEc2VpcEndpointServiceHasBeenSet = true;
    m_awsEc2VpcEndpointService = std::forward<AwsEc2VpcEndpointServiceT>(value);
  }
  template <typename AwsEc2VpcEndpointServiceT = AwsEc2VpcEndpointServiceDetails>
  ResourceDetails& WithAwsEc2VpcEndpointService(AwsEc2VpcEndpointServiceT&& value) {
    SetAwsEc2VpcEndpointService(std::forward<AwsEc2VpcEndpointServiceT>(value));
    return *this;
  }
 
 
  inline const AwsXrayEncryptionConfigDetails& GetAwsXrayEncryptionConfig() const { return m_awsXrayEncryptionConfig; }
  inline bool AwsXrayEncryptionConfigHasBeenSet() const { return m_awsXrayEncryptionConfigHasBeenSet; }
  template <typename AwsXrayEncryptionConfigT = AwsXrayEncryptionConfigDetails>
  void SetAwsXrayEncryptionConfig(AwsXrayEncryptionConfigT&& value) {
    m_awsXrayEncryptionConfigHasBeenSet = true;
    m_awsXrayEncryptionConfig = std::forward<AwsXrayEncryptionConfigT>(value);
  }
  template <typename AwsXrayEncryptionConfigT = AwsXrayEncryptionConfigDetails>
  ResourceDetails& WithAwsXrayEncryptionConfig(AwsXrayEncryptionConfigT&& value) {
    SetAwsXrayEncryptionConfig(std::forward<AwsXrayEncryptionConfigT>(value));
    return *this;
  }
 
 
  inline const AwsWafRateBasedRuleDetails& GetAwsWafRateBasedRule() const { return m_awsWafRateBasedRule; }
  inline bool AwsWafRateBasedRuleHasBeenSet() const { return m_awsWafRateBasedRuleHasBeenSet; }
  template <typename AwsWafRateBasedRuleT = AwsWafRateBasedRuleDetails>
  void SetAwsWafRateBasedRule(AwsWafRateBasedRuleT&& value) {
    m_awsWafRateBasedRuleHasBeenSet = true;
    m_awsWafRateBasedRule = std::forward<AwsWafRateBasedRuleT>(value);
  }
  template <typename AwsWafRateBasedRuleT = AwsWafRateBasedRuleDetails>
  ResourceDetails& WithAwsWafRateBasedRule(AwsWafRateBasedRuleT&& value) {
    SetAwsWafRateBasedRule(std::forward<AwsWafRateBasedRuleT>(value));
    return *this;
  }
 
 
  inline const AwsWafRegionalRateBasedRuleDetails& GetAwsWafRegionalRateBasedRule() const { return m_awsWafRegionalRateBasedRule; }
  inline bool AwsWafRegionalRateBasedRuleHasBeenSet() const { return m_awsWafRegionalRateBasedRuleHasBeenSet; }
  template <typename AwsWafRegionalRateBasedRuleT = AwsWafRegionalRateBasedRuleDetails>
  void SetAwsWafRegionalRateBasedRule(AwsWafRegionalRateBasedRuleT&& value) {
    m_awsWafRegionalRateBasedRuleHasBeenSet = true;
    m_awsWafRegionalRateBasedRule = std::forward<AwsWafRegionalRateBasedRuleT>(value);
  }
  template <typename AwsWafRegionalRateBasedRuleT = AwsWafRegionalRateBasedRuleDetails>
  ResourceDetails& WithAwsWafRegionalRateBasedRule(AwsWafRegionalRateBasedRuleT&& value) {
    SetAwsWafRegionalRateBasedRule(std::forward<AwsWafRegionalRateBasedRuleT>(value));
    return *this;
  }
 
 
  inline const AwsEcrRepositoryDetails& GetAwsEcrRepository() const { return m_awsEcrRepository; }
  inline bool AwsEcrRepositoryHasBeenSet() const { return m_awsEcrRepositoryHasBeenSet; }
  template <typename AwsEcrRepositoryT = AwsEcrRepositoryDetails>
  void SetAwsEcrRepository(AwsEcrRepositoryT&& value) {
    m_awsEcrRepositoryHasBeenSet = true;
    m_awsEcrRepository = std::forward<AwsEcrRepositoryT>(value);
  }
  template <typename AwsEcrRepositoryT = AwsEcrRepositoryDetails>
  ResourceDetails& WithAwsEcrRepository(AwsEcrRepositoryT&& value) {
    SetAwsEcrRepository(std::forward<AwsEcrRepositoryT>(value));
    return *this;
  }
 
 
  inline const AwsEksClusterDetails& GetAwsEksCluster() const { return m_awsEksCluster; }
  inline bool AwsEksClusterHasBeenSet() const { return m_awsEksClusterHasBeenSet; }
  template <typename AwsEksClusterT = AwsEksClusterDetails>
  void SetAwsEksCluster(AwsEksClusterT&& value) {
    m_awsEksClusterHasBeenSet = true;
    m_awsEksCluster = std::forward<AwsEksClusterT>(value);
  }
  template <typename AwsEksClusterT = AwsEksClusterDetails>
  ResourceDetails& WithAwsEksCluster(AwsEksClusterT&& value) {
    SetAwsEksCluster(std::forward<AwsEksClusterT>(value));
    return *this;
  }
 
 
  inline const AwsNetworkFirewallFirewallPolicyDetails& GetAwsNetworkFirewallFirewallPolicy() const {
    return m_awsNetworkFirewallFirewallPolicy;
  }
  inline bool AwsNetworkFirewallFirewallPolicyHasBeenSet() const { return m_awsNetworkFirewallFirewallPolicyHasBeenSet; }
  template <typename AwsNetworkFirewallFirewallPolicyT = AwsNetworkFirewallFirewallPolicyDetails>
  void SetAwsNetworkFirewallFirewallPolicy(AwsNetworkFirewallFirewallPolicyT&& value) {
    m_awsNetworkFirewallFirewallPolicyHasBeenSet = true;
    m_awsNetworkFirewallFirewallPolicy = std::forward<AwsNetworkFirewallFirewallPolicyT>(value);
  }
  template <typename AwsNetworkFirewallFirewallPolicyT = AwsNetworkFirewallFirewallPolicyDetails>
  ResourceDetails& WithAwsNetworkFirewallFirewallPolicy(AwsNetworkFirewallFirewallPolicyT&& value) {
    SetAwsNetworkFirewallFirewallPolicy(std::forward<AwsNetworkFirewallFirewallPolicyT>(value));
    return *this;
  }
 
 
  inline const AwsNetworkFirewallFirewallDetails& GetAwsNetworkFirewallFirewall() const { return m_awsNetworkFirewallFirewall; }
  inline bool AwsNetworkFirewallFirewallHasBeenSet() const { return m_awsNetworkFirewallFirewallHasBeenSet; }
  template <typename AwsNetworkFirewallFirewallT = AwsNetworkFirewallFirewallDetails>
  void SetAwsNetworkFirewallFirewall(AwsNetworkFirewallFirewallT&& value) {
    m_awsNetworkFirewallFirewallHasBeenSet = true;
    m_awsNetworkFirewallFirewall = std::forward<AwsNetworkFirewallFirewallT>(value);
  }
  template <typename AwsNetworkFirewallFirewallT = AwsNetworkFirewallFirewallDetails>
  ResourceDetails& WithAwsNetworkFirewallFirewall(AwsNetworkFirewallFirewallT&& value) {
    SetAwsNetworkFirewallFirewall(std::forward<AwsNetworkFirewallFirewallT>(value));
    return *this;
  }
 
 
  inline const AwsNetworkFirewallRuleGroupDetails& GetAwsNetworkFirewallRuleGroup() const { return m_awsNetworkFirewallRuleGroup; }
  inline bool AwsNetworkFirewallRuleGroupHasBeenSet() const { return m_awsNetworkFirewallRuleGroupHasBeenSet; }
  template <typename AwsNetworkFirewallRuleGroupT = AwsNetworkFirewallRuleGroupDetails>
  void SetAwsNetworkFirewallRuleGroup(AwsNetworkFirewallRuleGroupT&& value) {
    m_awsNetworkFirewallRuleGroupHasBeenSet = true;
    m_awsNetworkFirewallRuleGroup = std::forward<AwsNetworkFirewallRuleGroupT>(value);
  }
  template <typename AwsNetworkFirewallRuleGroupT = AwsNetworkFirewallRuleGroupDetails>
  ResourceDetails& WithAwsNetworkFirewallRuleGroup(AwsNetworkFirewallRuleGroupT&& value) {
    SetAwsNetworkFirewallRuleGroup(std::forward<AwsNetworkFirewallRuleGroupT>(value));
    return *this;
  }
 
 
  inline const AwsRdsDbSecurityGroupDetails& GetAwsRdsDbSecurityGroup() const { return m_awsRdsDbSecurityGroup; }
  inline bool AwsRdsDbSecurityGroupHasBeenSet() const { return m_awsRdsDbSecurityGroupHasBeenSet; }
  template <typename AwsRdsDbSecurityGroupT = AwsRdsDbSecurityGroupDetails>
  void SetAwsRdsDbSecurityGroup(AwsRdsDbSecurityGroupT&& value) {
    m_awsRdsDbSecurityGroupHasBeenSet = true;
    m_awsRdsDbSecurityGroup = std::forward<AwsRdsDbSecurityGroupT>(value);
  }
  template <typename AwsRdsDbSecurityGroupT = AwsRdsDbSecurityGroupDetails>
  ResourceDetails& WithAwsRdsDbSecurityGroup(AwsRdsDbSecurityGroupT&& value) {
    SetAwsRdsDbSecurityGroup(std::forward<AwsRdsDbSecurityGroupT>(value));
    return *this;
  }
 
 
  inline const AwsKinesisStreamDetails& GetAwsKinesisStream() const { return m_awsKinesisStream; }
  inline bool AwsKinesisStreamHasBeenSet() const { return m_awsKinesisStreamHasBeenSet; }
  template <typename AwsKinesisStreamT = AwsKinesisStreamDetails>
  void SetAwsKinesisStream(AwsKinesisStreamT&& value) {
    m_awsKinesisStreamHasBeenSet = true;
    m_awsKinesisStream = std::forward<AwsKinesisStreamT>(value);
  }
  template <typename AwsKinesisStreamT = AwsKinesisStreamDetails>
  ResourceDetails& WithAwsKinesisStream(AwsKinesisStreamT&& value) {
    SetAwsKinesisStream(std::forward<AwsKinesisStreamT>(value));
    return *this;
  }
 
 
  inline const AwsEc2TransitGatewayDetails& GetAwsEc2TransitGateway() const { return m_awsEc2TransitGateway; }
  inline bool AwsEc2TransitGatewayHasBeenSet() const { return m_awsEc2TransitGatewayHasBeenSet; }
  template <typename AwsEc2TransitGatewayT = AwsEc2TransitGatewayDetails>
  void SetAwsEc2TransitGateway(AwsEc2TransitGatewayT&& value) {
    m_awsEc2TransitGatewayHasBeenSet = true;
    m_awsEc2TransitGateway = std::forward<AwsEc2TransitGatewayT>(value);
  }
  template <typename AwsEc2TransitGatewayT = AwsEc2TransitGatewayDetails>
  ResourceDetails& WithAwsEc2TransitGateway(AwsEc2TransitGatewayT&& value) {
    SetAwsEc2TransitGateway(std::forward<AwsEc2TransitGatewayT>(value));
    return *this;
  }
 
 
  inline const AwsEfsAccessPointDetails& GetAwsEfsAccessPoint() const { return m_awsEfsAccessPoint; }
  inline bool AwsEfsAccessPointHasBeenSet() const { return m_awsEfsAccessPointHasBeenSet; }
  template <typename AwsEfsAccessPointT = AwsEfsAccessPointDetails>
  void SetAwsEfsAccessPoint(AwsEfsAccessPointT&& value) {
    m_awsEfsAccessPointHasBeenSet = true;
    m_awsEfsAccessPoint = std::forward<AwsEfsAccessPointT>(value);
  }
  template <typename AwsEfsAccessPointT = AwsEfsAccessPointDetails>
  ResourceDetails& WithAwsEfsAccessPoint(AwsEfsAccessPointT&& value) {
    SetAwsEfsAccessPoint(std::forward<AwsEfsAccessPointT>(value));
    return *this;
  }
 
 
  inline const AwsCloudFormationStackDetails& GetAwsCloudFormationStack() const { return m_awsCloudFormationStack; }
  inline bool AwsCloudFormationStackHasBeenSet() const { return m_awsCloudFormationStackHasBeenSet; }
  template <typename AwsCloudFormationStackT = AwsCloudFormationStackDetails>
  void SetAwsCloudFormationStack(AwsCloudFormationStackT&& value) {
    m_awsCloudFormationStackHasBeenSet = true;
    m_awsCloudFormationStack = std::forward<AwsCloudFormationStackT>(value);
  }
  template <typename AwsCloudFormationStackT = AwsCloudFormationStackDetails>
  ResourceDetails& WithAwsCloudFormationStack(AwsCloudFormationStackT&& value) {
    SetAwsCloudFormationStack(std::forward<AwsCloudFormationStackT>(value));
    return *this;
  }
 
 
  inline const AwsCloudWatchAlarmDetails& GetAwsCloudWatchAlarm() const { return m_awsCloudWatchAlarm; }
  inline bool AwsCloudWatchAlarmHasBeenSet() const { return m_awsCloudWatchAlarmHasBeenSet; }
  template <typename AwsCloudWatchAlarmT = AwsCloudWatchAlarmDetails>
  void SetAwsCloudWatchAlarm(AwsCloudWatchAlarmT&& value) {
    m_awsCloudWatchAlarmHasBeenSet = true;
    m_awsCloudWatchAlarm = std::forward<AwsCloudWatchAlarmT>(value);
  }
  template <typename AwsCloudWatchAlarmT = AwsCloudWatchAlarmDetails>
  ResourceDetails& WithAwsCloudWatchAlarm(AwsCloudWatchAlarmT&& value) {
    SetAwsCloudWatchAlarm(std::forward<AwsCloudWatchAlarmT>(value));
    return *this;
  }
 
 
  inline const AwsEc2VpcPeeringConnectionDetails& GetAwsEc2VpcPeeringConnection() const { return m_awsEc2VpcPeeringConnection; }
  inline bool AwsEc2VpcPeeringConnectionHasBeenSet() const { return m_awsEc2VpcPeeringConnectionHasBeenSet; }
  template <typename AwsEc2VpcPeeringConnectionT = AwsEc2VpcPeeringConnectionDetails>
  void SetAwsEc2VpcPeeringConnection(AwsEc2VpcPeeringConnectionT&& value) {
    m_awsEc2VpcPeeringConnectionHasBeenSet = true;
    m_awsEc2VpcPeeringConnection = std::forward<AwsEc2VpcPeeringConnectionT>(value);
  }
  template <typename AwsEc2VpcPeeringConnectionT = AwsEc2VpcPeeringConnectionDetails>
  ResourceDetails& WithAwsEc2VpcPeeringConnection(AwsEc2VpcPeeringConnectionT&& value) {
    SetAwsEc2VpcPeeringConnection(std::forward<AwsEc2VpcPeeringConnectionT>(value));
    return *this;
  }
 
 
  inline const AwsWafRegionalRuleGroupDetails& GetAwsWafRegionalRuleGroup() const { return m_awsWafRegionalRuleGroup; }
  inline bool AwsWafRegionalRuleGroupHasBeenSet() const { return m_awsWafRegionalRuleGroupHasBeenSet; }
  template <typename AwsWafRegionalRuleGroupT = AwsWafRegionalRuleGroupDetails>
  void SetAwsWafRegionalRuleGroup(AwsWafRegionalRuleGroupT&& value) {
    m_awsWafRegionalRuleGroupHasBeenSet = true;
    m_awsWafRegionalRuleGroup = std::forward<AwsWafRegionalRuleGroupT>(value);
  }
  template <typename AwsWafRegionalRuleGroupT = AwsWafRegionalRuleGroupDetails>
  ResourceDetails& WithAwsWafRegionalRuleGroup(AwsWafRegionalRuleGroupT&& value) {
    SetAwsWafRegionalRuleGroup(std::forward<AwsWafRegionalRuleGroupT>(value));
    return *this;
  }
 
 
  inline const AwsWafRegionalRuleDetails& GetAwsWafRegionalRule() const { return m_awsWafRegionalRule; }
  inline bool AwsWafRegionalRuleHasBeenSet() const { return m_awsWafRegionalRuleHasBeenSet; }
  template <typename AwsWafRegionalRuleT = AwsWafRegionalRuleDetails>
  void SetAwsWafRegionalRule(AwsWafRegionalRuleT&& value) {
    m_awsWafRegionalRuleHasBeenSet = true;
    m_awsWafRegionalRule = std::forward<AwsWafRegionalRuleT>(value);
  }
  template <typename AwsWafRegionalRuleT = AwsWafRegionalRuleDetails>
  ResourceDetails& WithAwsWafRegionalRule(AwsWafRegionalRuleT&& value) {
    SetAwsWafRegionalRule(std::forward<AwsWafRegionalRuleT>(value));
    return *this;
  }
 
 
  inline const AwsWafRegionalWebAclDetails& GetAwsWafRegionalWebAcl() const { return m_awsWafRegionalWebAcl; }
  inline bool AwsWafRegionalWebAclHasBeenSet() const { return m_awsWafRegionalWebAclHasBeenSet; }
  template <typename AwsWafRegionalWebAclT = AwsWafRegionalWebAclDetails>
  void SetAwsWafRegionalWebAcl(AwsWafRegionalWebAclT&& value) {
    m_awsWafRegionalWebAclHasBeenSet = true;
    m_awsWafRegionalWebAcl = std::forward<AwsWafRegionalWebAclT>(value);
  }
  template <typename AwsWafRegionalWebAclT = AwsWafRegionalWebAclDetails>
  ResourceDetails& WithAwsWafRegionalWebAcl(AwsWafRegionalWebAclT&& value) {
    SetAwsWafRegionalWebAcl(std::forward<AwsWafRegionalWebAclT>(value));
    return *this;
  }
 
 
  inline const AwsWafRuleDetails& GetAwsWafRule() const { return m_awsWafRule; }
  inline bool AwsWafRuleHasBeenSet() const { return m_awsWafRuleHasBeenSet; }
  template <typename AwsWafRuleT = AwsWafRuleDetails>
  void SetAwsWafRule(AwsWafRuleT&& value) {
    m_awsWafRuleHasBeenSet = true;
    m_awsWafRule = std::forward<AwsWafRuleT>(value);
  }
  template <typename AwsWafRuleT = AwsWafRuleDetails>
  ResourceDetails& WithAwsWafRule(AwsWafRuleT&& value) {
    SetAwsWafRule(std::forward<AwsWafRuleT>(value));
    return *this;
  }
 
 
  inline const AwsWafRuleGroupDetails& GetAwsWafRuleGroup() const { return m_awsWafRuleGroup; }
  inline bool AwsWafRuleGroupHasBeenSet() const { return m_awsWafRuleGroupHasBeenSet; }
  template <typename AwsWafRuleGroupT = AwsWafRuleGroupDetails>
  void SetAwsWafRuleGroup(AwsWafRuleGroupT&& value) {
    m_awsWafRuleGroupHasBeenSet = true;
    m_awsWafRuleGroup = std::forward<AwsWafRuleGroupT>(value);
  }
  template <typename AwsWafRuleGroupT = AwsWafRuleGroupDetails>
  ResourceDetails& WithAwsWafRuleGroup(AwsWafRuleGroupT&& value) {
    SetAwsWafRuleGroup(std::forward<AwsWafRuleGroupT>(value));
    return *this;
  }
 
 
  inline const AwsEcsTaskDetails& GetAwsEcsTask() const { return m_awsEcsTask; }
  inline bool AwsEcsTaskHasBeenSet() const { return m_awsEcsTaskHasBeenSet; }
  template <typename AwsEcsTaskT = AwsEcsTaskDetails>
  void SetAwsEcsTask(AwsEcsTaskT&& value) {
    m_awsEcsTaskHasBeenSet = true;
    m_awsEcsTask = std::forward<AwsEcsTaskT>(value);
  }
  template <typename AwsEcsTaskT = AwsEcsTaskDetails>
  ResourceDetails& WithAwsEcsTask(AwsEcsTaskT&& value) {
    SetAwsEcsTask(std::forward<AwsEcsTaskT>(value));
    return *this;
  }
 
 
  inline const AwsBackupBackupVaultDetails& GetAwsBackupBackupVault() const { return m_awsBackupBackupVault; }
  inline bool AwsBackupBackupVaultHasBeenSet() const { return m_awsBackupBackupVaultHasBeenSet; }
  template <typename AwsBackupBackupVaultT = AwsBackupBackupVaultDetails>
  void SetAwsBackupBackupVault(AwsBackupBackupVaultT&& value) {
    m_awsBackupBackupVaultHasBeenSet = true;
    m_awsBackupBackupVault = std::forward<AwsBackupBackupVaultT>(value);
  }
  template <typename AwsBackupBackupVaultT = AwsBackupBackupVaultDetails>
  ResourceDetails& WithAwsBackupBackupVault(AwsBackupBackupVaultT&& value) {
    SetAwsBackupBackupVault(std::forward<AwsBackupBackupVaultT>(value));
    return *this;
  }
 
 
  inline const AwsBackupBackupPlanDetails& GetAwsBackupBackupPlan() const { return m_awsBackupBackupPlan; }
  inline bool AwsBackupBackupPlanHasBeenSet() const { return m_awsBackupBackupPlanHasBeenSet; }
  template <typename AwsBackupBackupPlanT = AwsBackupBackupPlanDetails>
  void SetAwsBackupBackupPlan(AwsBackupBackupPlanT&& value) {
    m_awsBackupBackupPlanHasBeenSet = true;
    m_awsBackupBackupPlan = std::forward<AwsBackupBackupPlanT>(value);
  }
  template <typename AwsBackupBackupPlanT = AwsBackupBackupPlanDetails>
  ResourceDetails& WithAwsBackupBackupPlan(AwsBackupBackupPlanT&& value) {
    SetAwsBackupBackupPlan(std::forward<AwsBackupBackupPlanT>(value));
    return *this;
  }
 
 
  inline const AwsBackupRecoveryPointDetails& GetAwsBackupRecoveryPoint() const { return m_awsBackupRecoveryPoint; }
  inline bool AwsBackupRecoveryPointHasBeenSet() const { return m_awsBackupRecoveryPointHasBeenSet; }
  template <typename AwsBackupRecoveryPointT = AwsBackupRecoveryPointDetails>
  void SetAwsBackupRecoveryPoint(AwsBackupRecoveryPointT&& value) {
    m_awsBackupRecoveryPointHasBeenSet = true;
    m_awsBackupRecoveryPoint = std::forward<AwsBackupRecoveryPointT>(value);
  }
  template <typename AwsBackupRecoveryPointT = AwsBackupRecoveryPointDetails>
  ResourceDetails& WithAwsBackupRecoveryPoint(AwsBackupRecoveryPointT&& value) {
    SetAwsBackupRecoveryPoint(std::forward<AwsBackupRecoveryPointT>(value));
    return *this;
  }
 
 
  inline const AwsEc2LaunchTemplateDetails& GetAwsEc2LaunchTemplate() const { return m_awsEc2LaunchTemplate; }
  inline bool AwsEc2LaunchTemplateHasBeenSet() const { return m_awsEc2LaunchTemplateHasBeenSet; }
  template <typename AwsEc2LaunchTemplateT = AwsEc2LaunchTemplateDetails>
  void SetAwsEc2LaunchTemplate(AwsEc2LaunchTemplateT&& value) {
    m_awsEc2LaunchTemplateHasBeenSet = true;
    m_awsEc2LaunchTemplate = std::forward<AwsEc2LaunchTemplateT>(value);
  }
  template <typename AwsEc2LaunchTemplateT = AwsEc2LaunchTemplateDetails>
  ResourceDetails& WithAwsEc2LaunchTemplate(AwsEc2LaunchTemplateT&& value) {
    SetAwsEc2LaunchTemplate(std::forward<AwsEc2LaunchTemplateT>(value));
    return *this;
  }
 
 
  inline const AwsSageMakerNotebookInstanceDetails& GetAwsSageMakerNotebookInstance() const { return m_awsSageMakerNotebookInstance; }
  inline bool AwsSageMakerNotebookInstanceHasBeenSet() const { return m_awsSageMakerNotebookInstanceHasBeenSet; }
  template <typename AwsSageMakerNotebookInstanceT = AwsSageMakerNotebookInstanceDetails>
  void SetAwsSageMakerNotebookInstance(AwsSageMakerNotebookInstanceT&& value) {
    m_awsSageMakerNotebookInstanceHasBeenSet = true;
    m_awsSageMakerNotebookInstance = std::forward<AwsSageMakerNotebookInstanceT>(value);
  }
  template <typename AwsSageMakerNotebookInstanceT = AwsSageMakerNotebookInstanceDetails>
  ResourceDetails& WithAwsSageMakerNotebookInstance(AwsSageMakerNotebookInstanceT&& value) {
    SetAwsSageMakerNotebookInstance(std::forward<AwsSageMakerNotebookInstanceT>(value));
    return *this;
  }
 
 
  inline const AwsWafv2WebAclDetails& GetAwsWafv2WebAcl() const { return m_awsWafv2WebAcl; }
  inline bool AwsWafv2WebAclHasBeenSet() const { return m_awsWafv2WebAclHasBeenSet; }
  template <typename AwsWafv2WebAclT = AwsWafv2WebAclDetails>
  void SetAwsWafv2WebAcl(AwsWafv2WebAclT&& value) {
    m_awsWafv2WebAclHasBeenSet = true;
    m_awsWafv2WebAcl = std::forward<AwsWafv2WebAclT>(value);
  }
  template <typename AwsWafv2WebAclT = AwsWafv2WebAclDetails>
  ResourceDetails& WithAwsWafv2WebAcl(AwsWafv2WebAclT&& value) {
    SetAwsWafv2WebAcl(std::forward<AwsWafv2WebAclT>(value));
    return *this;
  }
 
 
  inline const AwsWafv2RuleGroupDetails& GetAwsWafv2RuleGroup() const { return m_awsWafv2RuleGroup; }
  inline bool AwsWafv2RuleGroupHasBeenSet() const { return m_awsWafv2RuleGroupHasBeenSet; }
  template <typename AwsWafv2RuleGroupT = AwsWafv2RuleGroupDetails>
  void SetAwsWafv2RuleGroup(AwsWafv2RuleGroupT&& value) {
    m_awsWafv2RuleGroupHasBeenSet = true;
    m_awsWafv2RuleGroup = std::forward<AwsWafv2RuleGroupT>(value);
  }
  template <typename AwsWafv2RuleGroupT = AwsWafv2RuleGroupDetails>
  ResourceDetails& WithAwsWafv2RuleGroup(AwsWafv2RuleGroupT&& value) {
    SetAwsWafv2RuleGroup(std::forward<AwsWafv2RuleGroupT>(value));
    return *this;
  }
 
 
  inline const AwsEc2RouteTableDetails& GetAwsEc2RouteTable() const { return m_awsEc2RouteTable; }
  inline bool AwsEc2RouteTableHasBeenSet() const { return m_awsEc2RouteTableHasBeenSet; }
  template <typename AwsEc2RouteTableT = AwsEc2RouteTableDetails>
  void SetAwsEc2RouteTable(AwsEc2RouteTableT&& value) {
    m_awsEc2RouteTableHasBeenSet = true;
    m_awsEc2RouteTable = std::forward<AwsEc2RouteTableT>(value);
  }
  template <typename AwsEc2RouteTableT = AwsEc2RouteTableDetails>
  ResourceDetails& WithAwsEc2RouteTable(AwsEc2RouteTableT&& value) {
    SetAwsEc2RouteTable(std::forward<AwsEc2RouteTableT>(value));
    return *this;
  }
 
 
  inline const AwsAmazonMqBrokerDetails& GetAwsAmazonMqBroker() const { return m_awsAmazonMqBroker; }
  inline bool AwsAmazonMqBrokerHasBeenSet() const { return m_awsAmazonMqBrokerHasBeenSet; }
  template <typename AwsAmazonMqBrokerT = AwsAmazonMqBrokerDetails>
  void SetAwsAmazonMqBroker(AwsAmazonMqBrokerT&& value) {
    m_awsAmazonMqBrokerHasBeenSet = true;
    m_awsAmazonMqBroker = std::forward<AwsAmazonMqBrokerT>(value);
  }
  template <typename AwsAmazonMqBrokerT = AwsAmazonMqBrokerDetails>
  ResourceDetails& WithAwsAmazonMqBroker(AwsAmazonMqBrokerT&& value) {
    SetAwsAmazonMqBroker(std::forward<AwsAmazonMqBrokerT>(value));
    return *this;
  }
 
 
  inline const AwsAppSyncGraphQlApiDetails& GetAwsAppSyncGraphQlApi() const { return m_awsAppSyncGraphQlApi; }
  inline bool AwsAppSyncGraphQlApiHasBeenSet() const { return m_awsAppSyncGraphQlApiHasBeenSet; }
  template <typename AwsAppSyncGraphQlApiT = AwsAppSyncGraphQlApiDetails>
  void SetAwsAppSyncGraphQlApi(AwsAppSyncGraphQlApiT&& value) {
    m_awsAppSyncGraphQlApiHasBeenSet = true;
    m_awsAppSyncGraphQlApi = std::forward<AwsAppSyncGraphQlApiT>(value);
  }
  template <typename AwsAppSyncGraphQlApiT = AwsAppSyncGraphQlApiDetails>
  ResourceDetails& WithAwsAppSyncGraphQlApi(AwsAppSyncGraphQlApiT&& value) {
    SetAwsAppSyncGraphQlApi(std::forward<AwsAppSyncGraphQlApiT>(value));
    return *this;
  }
 
 
  inline const AwsEventSchemasRegistryDetails& GetAwsEventSchemasRegistry() const { return m_awsEventSchemasRegistry; }
  inline bool AwsEventSchemasRegistryHasBeenSet() const { return m_awsEventSchemasRegistryHasBeenSet; }
  template <typename AwsEventSchemasRegistryT = AwsEventSchemasRegistryDetails>
  void SetAwsEventSchemasRegistry(AwsEventSchemasRegistryT&& value) {
    m_awsEventSchemasRegistryHasBeenSet = true;
    m_awsEventSchemasRegistry = std::forward<AwsEventSchemasRegistryT>(value);
  }
  template <typename AwsEventSchemasRegistryT = AwsEventSchemasRegistryDetails>
  ResourceDetails& WithAwsEventSchemasRegistry(AwsEventSchemasRegistryT&& value) {
    SetAwsEventSchemasRegistry(std::forward<AwsEventSchemasRegistryT>(value));
    return *this;
  }
 
 
  inline const AwsGuardDutyDetectorDetails& GetAwsGuardDutyDetector() const { return m_awsGuardDutyDetector; }
  inline bool AwsGuardDutyDetectorHasBeenSet() const { return m_awsGuardDutyDetectorHasBeenSet; }
  template <typename AwsGuardDutyDetectorT = AwsGuardDutyDetectorDetails>
  void SetAwsGuardDutyDetector(AwsGuardDutyDetectorT&& value) {
    m_awsGuardDutyDetectorHasBeenSet = true;
    m_awsGuardDutyDetector = std::forward<AwsGuardDutyDetectorT>(value);
  }
  template <typename AwsGuardDutyDetectorT = AwsGuardDutyDetectorDetails>
  ResourceDetails& WithAwsGuardDutyDetector(AwsGuardDutyDetectorT&& value) {
    SetAwsGuardDutyDetector(std::forward<AwsGuardDutyDetectorT>(value));
    return *this;
  }
 
 
  inline const AwsStepFunctionStateMachineDetails& GetAwsStepFunctionStateMachine() const { return m_awsStepFunctionStateMachine; }
  inline bool AwsStepFunctionStateMachineHasBeenSet() const { return m_awsStepFunctionStateMachineHasBeenSet; }
  template <typename AwsStepFunctionStateMachineT = AwsStepFunctionStateMachineDetails>
  void SetAwsStepFunctionStateMachine(AwsStepFunctionStateMachineT&& value) {
    m_awsStepFunctionStateMachineHasBeenSet = true;
    m_awsStepFunctionStateMachine = std::forward<AwsStepFunctionStateMachineT>(value);
  }
  template <typename AwsStepFunctionStateMachineT = AwsStepFunctionStateMachineDetails>
  ResourceDetails& WithAwsStepFunctionStateMachine(AwsStepFunctionStateMachineT&& value) {
    SetAwsStepFunctionStateMachine(std::forward<AwsStepFunctionStateMachineT>(value));
    return *this;
  }
 
 
  inline const AwsAthenaWorkGroupDetails& GetAwsAthenaWorkGroup() const { return m_awsAthenaWorkGroup; }
  inline bool AwsAthenaWorkGroupHasBeenSet() const { return m_awsAthenaWorkGroupHasBeenSet; }
  template <typename AwsAthenaWorkGroupT = AwsAthenaWorkGroupDetails>
  void SetAwsAthenaWorkGroup(AwsAthenaWorkGroupT&& value) {
    m_awsAthenaWorkGroupHasBeenSet = true;
    m_awsAthenaWorkGroup = std::forward<AwsAthenaWorkGroupT>(value);
  }
  template <typename AwsAthenaWorkGroupT = AwsAthenaWorkGroupDetails>
  ResourceDetails& WithAwsAthenaWorkGroup(AwsAthenaWorkGroupT&& value) {
    SetAwsAthenaWorkGroup(std::forward<AwsAthenaWorkGroupT>(value));
    return *this;
  }
 
 
  inline const AwsEventsEventbusDetails& GetAwsEventsEventbus() const { return m_awsEventsEventbus; }
  inline bool AwsEventsEventbusHasBeenSet() const { return m_awsEventsEventbusHasBeenSet; }
  template <typename AwsEventsEventbusT = AwsEventsEventbusDetails>
  void SetAwsEventsEventbus(AwsEventsEventbusT&& value) {
    m_awsEventsEventbusHasBeenSet = true;
    m_awsEventsEventbus = std::forward<AwsEventsEventbusT>(value);
  }
  template <typename AwsEventsEventbusT = AwsEventsEventbusDetails>
  ResourceDetails& WithAwsEventsEventbus(AwsEventsEventbusT&& value) {
    SetAwsEventsEventbus(std::forward<AwsEventsEventbusT>(value));
    return *this;
  }
 
 
  inline const AwsDmsEndpointDetails& GetAwsDmsEndpoint() const { return m_awsDmsEndpoint; }
  inline bool AwsDmsEndpointHasBeenSet() const { return m_awsDmsEndpointHasBeenSet; }
  template <typename AwsDmsEndpointT = AwsDmsEndpointDetails>
  void SetAwsDmsEndpoint(AwsDmsEndpointT&& value) {
    m_awsDmsEndpointHasBeenSet = true;
    m_awsDmsEndpoint = std::forward<AwsDmsEndpointT>(value);
  }
  template <typename AwsDmsEndpointT = AwsDmsEndpointDetails>
  ResourceDetails& WithAwsDmsEndpoint(AwsDmsEndpointT&& value) {
    SetAwsDmsEndpoint(std::forward<AwsDmsEndpointT>(value));
    return *this;
  }
 
 
  inline const AwsEventsEndpointDetails& GetAwsEventsEndpoint() const { return m_awsEventsEndpoint; }
  inline bool AwsEventsEndpointHasBeenSet() const { return m_awsEventsEndpointHasBeenSet; }
  template <typename AwsEventsEndpointT = AwsEventsEndpointDetails>
  void SetAwsEventsEndpoint(AwsEventsEndpointT&& value) {
    m_awsEventsEndpointHasBeenSet = true;
    m_awsEventsEndpoint = std::forward<AwsEventsEndpointT>(value);
  }
  template <typename AwsEventsEndpointT = AwsEventsEndpointDetails>
  ResourceDetails& WithAwsEventsEndpoint(AwsEventsEndpointT&& value) {
    SetAwsEventsEndpoint(std::forward<AwsEventsEndpointT>(value));
    return *this;
  }
 
 
  inline const AwsDmsReplicationTaskDetails& GetAwsDmsReplicationTask() const { return m_awsDmsReplicationTask; }
  inline bool AwsDmsReplicationTaskHasBeenSet() const { return m_awsDmsReplicationTaskHasBeenSet; }
  template <typename AwsDmsReplicationTaskT = AwsDmsReplicationTaskDetails>
  void SetAwsDmsReplicationTask(AwsDmsReplicationTaskT&& value) {
    m_awsDmsReplicationTaskHasBeenSet = true;
    m_awsDmsReplicationTask = std::forward<AwsDmsReplicationTaskT>(value);
  }
  template <typename AwsDmsReplicationTaskT = AwsDmsReplicationTaskDetails>
  ResourceDetails& WithAwsDmsReplicationTask(AwsDmsReplicationTaskT&& value) {
    SetAwsDmsReplicationTask(std::forward<AwsDmsReplicationTaskT>(value));
    return *this;
  }
 
 
  inline const AwsDmsReplicationInstanceDetails& GetAwsDmsReplicationInstance() const { return m_awsDmsReplicationInstance; }
  inline bool AwsDmsReplicationInstanceHasBeenSet() const { return m_awsDmsReplicationInstanceHasBeenSet; }
  template <typename AwsDmsReplicationInstanceT = AwsDmsReplicationInstanceDetails>
  void SetAwsDmsReplicationInstance(AwsDmsReplicationInstanceT&& value) {
    m_awsDmsReplicationInstanceHasBeenSet = true;
    m_awsDmsReplicationInstance = std::forward<AwsDmsReplicationInstanceT>(value);
  }
  template <typename AwsDmsReplicationInstanceT = AwsDmsReplicationInstanceDetails>
  ResourceDetails& WithAwsDmsReplicationInstance(AwsDmsReplicationInstanceT&& value) {
    SetAwsDmsReplicationInstance(std::forward<AwsDmsReplicationInstanceT>(value));
    return *this;
  }
 
 
  inline const AwsRoute53HostedZoneDetails& GetAwsRoute53HostedZone() const { return m_awsRoute53HostedZone; }
  inline bool AwsRoute53HostedZoneHasBeenSet() const { return m_awsRoute53HostedZoneHasBeenSet; }
  template <typename AwsRoute53HostedZoneT = AwsRoute53HostedZoneDetails>
  void SetAwsRoute53HostedZone(AwsRoute53HostedZoneT&& value) {
    m_awsRoute53HostedZoneHasBeenSet = true;
    m_awsRoute53HostedZone = std::forward<AwsRoute53HostedZoneT>(value);
  }
  template <typename AwsRoute53HostedZoneT = AwsRoute53HostedZoneDetails>
  ResourceDetails& WithAwsRoute53HostedZone(AwsRoute53HostedZoneT&& value) {
    SetAwsRoute53HostedZone(std::forward<AwsRoute53HostedZoneT>(value));
    return *this;
  }
 
 
  inline const AwsMskClusterDetails& GetAwsMskCluster() const { return m_awsMskCluster; }
  inline bool AwsMskClusterHasBeenSet() const { return m_awsMskClusterHasBeenSet; }
  template <typename AwsMskClusterT = AwsMskClusterDetails>
  void SetAwsMskCluster(AwsMskClusterT&& value) {
    m_awsMskClusterHasBeenSet = true;
    m_awsMskCluster = std::forward<AwsMskClusterT>(value);
  }
  template <typename AwsMskClusterT = AwsMskClusterDetails>
  ResourceDetails& WithAwsMskCluster(AwsMskClusterT&& value) {
    SetAwsMskCluster(std::forward<AwsMskClusterT>(value));
    return *this;
  }
 
 
  inline const AwsS3AccessPointDetails& GetAwsS3AccessPoint() const { return m_awsS3AccessPoint; }
  inline bool AwsS3AccessPointHasBeenSet() const { return m_awsS3AccessPointHasBeenSet; }
  template <typename AwsS3AccessPointT = AwsS3AccessPointDetails>
  void SetAwsS3AccessPoint(AwsS3AccessPointT&& value) {
    m_awsS3AccessPointHasBeenSet = true;
    m_awsS3AccessPoint = std::forward<AwsS3AccessPointT>(value);
  }
  template <typename AwsS3AccessPointT = AwsS3AccessPointDetails>
  ResourceDetails& WithAwsS3AccessPoint(AwsS3AccessPointT&& value) {
    SetAwsS3AccessPoint(std::forward<AwsS3AccessPointT>(value));
    return *this;
  }
 
 
  inline const AwsEc2ClientVpnEndpointDetails& GetAwsEc2ClientVpnEndpoint() const { return m_awsEc2ClientVpnEndpoint; }
  inline bool AwsEc2ClientVpnEndpointHasBeenSet() const { return m_awsEc2ClientVpnEndpointHasBeenSet; }
  template <typename AwsEc2ClientVpnEndpointT = AwsEc2ClientVpnEndpointDetails>
  void SetAwsEc2ClientVpnEndpoint(AwsEc2ClientVpnEndpointT&& value) {
    m_awsEc2ClientVpnEndpointHasBeenSet = true;
    m_awsEc2ClientVpnEndpoint = std::forward<AwsEc2ClientVpnEndpointT>(value);
  }
  template <typename AwsEc2ClientVpnEndpointT = AwsEc2ClientVpnEndpointDetails>
  ResourceDetails& WithAwsEc2ClientVpnEndpoint(AwsEc2ClientVpnEndpointT&& value) {
    SetAwsEc2ClientVpnEndpoint(std::forward<AwsEc2ClientVpnEndpointT>(value));
    return *this;
  }
 
 
  inline const CodeRepositoryDetails& GetCodeRepository() const { return m_codeRepository; }
  inline bool CodeRepositoryHasBeenSet() const { return m_codeRepositoryHasBeenSet; }
  template <typename CodeRepositoryT = CodeRepositoryDetails>
  void SetCodeRepository(CodeRepositoryT&& value) {
    m_codeRepositoryHasBeenSet = true;
    m_codeRepository = std::forward<CodeRepositoryT>(value);
  }
  template <typename CodeRepositoryT = CodeRepositoryDetails>
  ResourceDetails& WithCodeRepository(CodeRepositoryT&& value) {
    SetCodeRepository(std::forward<CodeRepositoryT>(value));
    return *this;
  }
 
 
  inline Aws::Utils::DocumentView GetAzureResource() const { return m_azureResource; }
  inline bool AzureResourceHasBeenSet() const { return m_azureResourceHasBeenSet; }
  template <typename AzureResourceT = Aws::Utils::Document>
  void SetAzureResource(AzureResourceT&& value) {
    m_azureResourceHasBeenSet = true;
    m_azureResource = std::forward<AzureResourceT>(value);
  }
  template <typename AzureResourceT = Aws::Utils::Document>
  ResourceDetails& WithAzureResource(AzureResourceT&& value) {
    SetAzureResource(std::forward<AzureResourceT>(value));
    return *this;
  }
 private:
  AwsAutoScalingAutoScalingGroupDetails m_awsAutoScalingAutoScalingGroup;
 
  AwsCodeBuildProjectDetails m_awsCodeBuildProject;
 
  AwsCloudFrontDistributionDetails m_awsCloudFrontDistribution;
 
  AwsEc2InstanceDetails m_awsEc2Instance;
 
  AwsEc2NetworkInterfaceDetails m_awsEc2NetworkInterface;
 
  AwsEc2SecurityGroupDetails m_awsEc2SecurityGroup;
 
  AwsEc2VolumeDetails m_awsEc2Volume;
 
  AwsEc2VpcDetails m_awsEc2Vpc;
 
  AwsEc2EipDetails m_awsEc2Eip;
 
  AwsEc2SubnetDetails m_awsEc2Subnet;
 
  AwsEc2NetworkAclDetails m_awsEc2NetworkAcl;
 
  AwsElbv2LoadBalancerDetails m_awsElbv2LoadBalancer;
 
  AwsElasticBeanstalkEnvironmentDetails m_awsElasticBeanstalkEnvironment;
 
  AwsElasticsearchDomainDetails m_awsElasticsearchDomain;
 
  AwsS3BucketDetails m_awsS3Bucket;
 
  AwsS3AccountPublicAccessBlockDetails m_awsS3AccountPublicAccessBlock;
 
  AwsS3ObjectDetails m_awsS3Object;
 
  AwsSecretsManagerSecretDetails m_awsSecretsManagerSecret;
 
  AwsIamAccessKeyDetails m_awsIamAccessKey;
 
  AwsIamUserDetails m_awsIamUser;
 
  AwsIamPolicyDetails m_awsIamPolicy;
 
  AwsApiGatewayV2StageDetails m_awsApiGatewayV2Stage;
 
  AwsApiGatewayV2ApiDetails m_awsApiGatewayV2Api;
 
  AwsDynamoDbTableDetails m_awsDynamoDbTable;
 
  AwsApiGatewayStageDetails m_awsApiGatewayStage;
 
  AwsApiGatewayRestApiDetails m_awsApiGatewayRestApi;
 
  AwsCloudTrailTrailDetails m_awsCloudTrailTrail;
 
  AwsSsmPatchComplianceDetails m_awsSsmPatchCompliance;
 
  AwsCertificateManagerCertificateDetails m_awsCertificateManagerCertificate;
 
  AwsRedshiftClusterDetails m_awsRedshiftCluster;
 
  AwsElbLoadBalancerDetails m_awsElbLoadBalancer;
 
  AwsIamGroupDetails m_awsIamGroup;
 
  AwsIamRoleDetails m_awsIamRole;
 
  AwsKmsKeyDetails m_awsKmsKey;
 
  AwsLambdaFunctionDetails m_awsLambdaFunction;
 
  AwsLambdaLayerVersionDetails m_awsLambdaLayerVersion;
 
  AwsRdsDbInstanceDetails m_awsRdsDbInstance;
 
  AwsSnsTopicDetails m_awsSnsTopic;
 
  AwsSqsQueueDetails m_awsSqsQueue;
 
  AwsWafWebAclDetails m_awsWafWebAcl;
 
  AwsRdsDbSnapshotDetails m_awsRdsDbSnapshot;
 
  AwsRdsDbClusterSnapshotDetails m_awsRdsDbClusterSnapshot;
 
  AwsRdsDbClusterDetails m_awsRdsDbCluster;
 
  AwsEcsClusterDetails m_awsEcsCluster;
 
  AwsEcsContainerDetails m_awsEcsContainer;
 
  AwsEcsTaskDefinitionDetails m_awsEcsTaskDefinition;
 
  ContainerDetails m_container;
 
  Aws::Map<Aws::String, Aws::String> m_other;
 
  AwsRdsEventSubscriptionDetails m_awsRdsEventSubscription;
 
  AwsEcsServiceDetails m_awsEcsService;
 
  AwsAutoScalingLaunchConfigurationDetails m_awsAutoScalingLaunchConfiguration;
 
  AwsEc2VpnConnectionDetails m_awsEc2VpnConnection;
 
  AwsEcrContainerImageDetails m_awsEcrContainerImage;
 
  AwsOpenSearchServiceDomainDetails m_awsOpenSearchServiceDomain;
 
  AwsEc2VpcEndpointServiceDetails m_awsEc2VpcEndpointService;
 
  AwsXrayEncryptionConfigDetails m_awsXrayEncryptionConfig;
 
  AwsWafRateBasedRuleDetails m_awsWafRateBasedRule;
 
  AwsWafRegionalRateBasedRuleDetails m_awsWafRegionalRateBasedRule;
 
  AwsEcrRepositoryDetails m_awsEcrRepository;
 
  AwsEksClusterDetails m_awsEksCluster;
 
  AwsNetworkFirewallFirewallPolicyDetails m_awsNetworkFirewallFirewallPolicy;
 
  AwsNetworkFirewallFirewallDetails m_awsNetworkFirewallFirewall;
 
  AwsNetworkFirewallRuleGroupDetails m_awsNetworkFirewallRuleGroup;
 
  AwsRdsDbSecurityGroupDetails m_awsRdsDbSecurityGroup;
 
  AwsKinesisStreamDetails m_awsKinesisStream;
 
  AwsEc2TransitGatewayDetails m_awsEc2TransitGateway;
 
  AwsEfsAccessPointDetails m_awsEfsAccessPoint;
 
  AwsCloudFormationStackDetails m_awsCloudFormationStack;
 
  AwsCloudWatchAlarmDetails m_awsCloudWatchAlarm;
 
  AwsEc2VpcPeeringConnectionDetails m_awsEc2VpcPeeringConnection;
 
  AwsWafRegionalRuleGroupDetails m_awsWafRegionalRuleGroup;
 
  AwsWafRegionalRuleDetails m_awsWafRegionalRule;
 
  AwsWafRegionalWebAclDetails m_awsWafRegionalWebAcl;
 
  AwsWafRuleDetails m_awsWafRule;
 
  AwsWafRuleGroupDetails m_awsWafRuleGroup;
 
  AwsEcsTaskDetails m_awsEcsTask;
 
  AwsBackupBackupVaultDetails m_awsBackupBackupVault;
 
  AwsBackupBackupPlanDetails m_awsBackupBackupPlan;
 
  AwsBackupRecoveryPointDetails m_awsBackupRecoveryPoint;
 
  AwsEc2LaunchTemplateDetails m_awsEc2LaunchTemplate;
 
  AwsSageMakerNotebookInstanceDetails m_awsSageMakerNotebookInstance;
 
  AwsWafv2WebAclDetails m_awsWafv2WebAcl;
 
  AwsWafv2RuleGroupDetails m_awsWafv2RuleGroup;
 
  AwsEc2RouteTableDetails m_awsEc2RouteTable;
 
  AwsAmazonMqBrokerDetails m_awsAmazonMqBroker;
 
  AwsAppSyncGraphQlApiDetails m_awsAppSyncGraphQlApi;
 
  AwsEventSchemasRegistryDetails m_awsEventSchemasRegistry;
 
  AwsGuardDutyDetectorDetails m_awsGuardDutyDetector;
 
  AwsStepFunctionStateMachineDetails m_awsStepFunctionStateMachine;
 
  AwsAthenaWorkGroupDetails m_awsAthenaWorkGroup;
 
  AwsEventsEventbusDetails m_awsEventsEventbus;
 
  AwsDmsEndpointDetails m_awsDmsEndpoint;
 
  AwsEventsEndpointDetails m_awsEventsEndpoint;
 
  AwsDmsReplicationTaskDetails m_awsDmsReplicationTask;
 
  AwsDmsReplicationInstanceDetails m_awsDmsReplicationInstance;
 
  AwsRoute53HostedZoneDetails m_awsRoute53HostedZone;
 
  AwsMskClusterDetails m_awsMskCluster;
 
  AwsS3AccessPointDetails m_awsS3AccessPoint;
 
  AwsEc2ClientVpnEndpointDetails m_awsEc2ClientVpnEndpoint;
 
  CodeRepositoryDetails m_codeRepository;
 
  Aws::Utils::Document m_azureResource;
  bool m_awsAutoScalingAutoScalingGroupHasBeenSet = false;
  bool m_awsCodeBuildProjectHasBeenSet = false;
  bool m_awsCloudFrontDistributionHasBeenSet = false;
  bool m_awsEc2InstanceHasBeenSet = false;
  bool m_awsEc2NetworkInterfaceHasBeenSet = false;
  bool m_awsEc2SecurityGroupHasBeenSet = false;
  bool m_awsEc2VolumeHasBeenSet = false;
  bool m_awsEc2VpcHasBeenSet = false;
  bool m_awsEc2EipHasBeenSet = false;
  bool m_awsEc2SubnetHasBeenSet = false;
  bool m_awsEc2NetworkAclHasBeenSet = false;
  bool m_awsElbv2LoadBalancerHasBeenSet = false;
  bool m_awsElasticBeanstalkEnvironmentHasBeenSet = false;
  bool m_awsElasticsearchDomainHasBeenSet = false;
  bool m_awsS3BucketHasBeenSet = false;
  bool m_awsS3AccountPublicAccessBlockHasBeenSet = false;
  bool m_awsS3ObjectHasBeenSet = false;
  bool m_awsSecretsManagerSecretHasBeenSet = false;
  bool m_awsIamAccessKeyHasBeenSet = false;
  bool m_awsIamUserHasBeenSet = false;
  bool m_awsIamPolicyHasBeenSet = false;
  bool m_awsApiGatewayV2StageHasBeenSet = false;
  bool m_awsApiGatewayV2ApiHasBeenSet = false;
  bool m_awsDynamoDbTableHasBeenSet = false;
  bool m_awsApiGatewayStageHasBeenSet = false;
  bool m_awsApiGatewayRestApiHasBeenSet = false;
  bool m_awsCloudTrailTrailHasBeenSet = false;
  bool m_awsSsmPatchComplianceHasBeenSet = false;
  bool m_awsCertificateManagerCertificateHasBeenSet = false;
  bool m_awsRedshiftClusterHasBeenSet = false;
  bool m_awsElbLoadBalancerHasBeenSet = false;
  bool m_awsIamGroupHasBeenSet = false;
  bool m_awsIamRoleHasBeenSet = false;
  bool m_awsKmsKeyHasBeenSet = false;
  bool m_awsLambdaFunctionHasBeenSet = false;
  bool m_awsLambdaLayerVersionHasBeenSet = false;
  bool m_awsRdsDbInstanceHasBeenSet = false;
  bool m_awsSnsTopicHasBeenSet = false;
  bool m_awsSqsQueueHasBeenSet = false;
  bool m_awsWafWebAclHasBeenSet = false;
  bool m_awsRdsDbSnapshotHasBeenSet = false;
  bool m_awsRdsDbClusterSnapshotHasBeenSet = false;
  bool m_awsRdsDbClusterHasBeenSet = false;
  bool m_awsEcsClusterHasBeenSet = false;
  bool m_awsEcsContainerHasBeenSet = false;
  bool m_awsEcsTaskDefinitionHasBeenSet = false;
  bool m_containerHasBeenSet = false;
  bool m_otherHasBeenSet = false;
  bool m_awsRdsEventSubscriptionHasBeenSet = false;
  bool m_awsEcsServiceHasBeenSet = false;
  bool m_awsAutoScalingLaunchConfigurationHasBeenSet = false;
  bool m_awsEc2VpnConnectionHasBeenSet = false;
  bool m_awsEcrContainerImageHasBeenSet = false;
  bool m_awsOpenSearchServiceDomainHasBeenSet = false;
  bool m_awsEc2VpcEndpointServiceHasBeenSet = false;
  bool m_awsXrayEncryptionConfigHasBeenSet = false;
  bool m_awsWafRateBasedRuleHasBeenSet = false;
  bool m_awsWafRegionalRateBasedRuleHasBeenSet = false;
  bool m_awsEcrRepositoryHasBeenSet = false;
  bool m_awsEksClusterHasBeenSet = false;
  bool m_awsNetworkFirewallFirewallPolicyHasBeenSet = false;
  bool m_awsNetworkFirewallFirewallHasBeenSet = false;
  bool m_awsNetworkFirewallRuleGroupHasBeenSet = false;
  bool m_awsRdsDbSecurityGroupHasBeenSet = false;
  bool m_awsKinesisStreamHasBeenSet = false;
  bool m_awsEc2TransitGatewayHasBeenSet = false;
  bool m_awsEfsAccessPointHasBeenSet = false;
  bool m_awsCloudFormationStackHasBeenSet = false;
  bool m_awsCloudWatchAlarmHasBeenSet = false;
  bool m_awsEc2VpcPeeringConnectionHasBeenSet = false;
  bool m_awsWafRegionalRuleGroupHasBeenSet = false;
  bool m_awsWafRegionalRuleHasBeenSet = false;
  bool m_awsWafRegionalWebAclHasBeenSet = false;
  bool m_awsWafRuleHasBeenSet = false;
  bool m_awsWafRuleGroupHasBeenSet = false;
  bool m_awsEcsTaskHasBeenSet = false;
  bool m_awsBackupBackupVaultHasBeenSet = false;
  bool m_awsBackupBackupPlanHasBeenSet = false;
  bool m_awsBackupRecoveryPointHasBeenSet = false;
  bool m_awsEc2LaunchTemplateHasBeenSet = false;
  bool m_awsSageMakerNotebookInstanceHasBeenSet = false;
  bool m_awsWafv2WebAclHasBeenSet = false;
  bool m_awsWafv2RuleGroupHasBeenSet = false;
  bool m_awsEc2RouteTableHasBeenSet = false;
  bool m_awsAmazonMqBrokerHasBeenSet = false;
  bool m_awsAppSyncGraphQlApiHasBeenSet = false;
  bool m_awsEventSchemasRegistryHasBeenSet = false;
  bool m_awsGuardDutyDetectorHasBeenSet = false;
  bool m_awsStepFunctionStateMachineHasBeenSet = false;
  bool m_awsAthenaWorkGroupHasBeenSet = false;
  bool m_awsEventsEventbusHasBeenSet = false;
  bool m_awsDmsEndpointHasBeenSet = false;
  bool m_awsEventsEndpointHasBeenSet = false;
  bool m_awsDmsReplicationTaskHasBeenSet = false;
  bool m_awsDmsReplicationInstanceHasBeenSet = false;
  bool m_awsRoute53HostedZoneHasBeenSet = false;
  bool m_awsMskClusterHasBeenSet = false;
  bool m_awsS3AccessPointHasBeenSet = false;
  bool m_awsEc2ClientVpnEndpointHasBeenSet = false;
  bool m_codeRepositoryHasBeenSet = false;
  bool m_azureResourceHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace SecurityHub
}  // namespace Aws