AwsSecurityFinding.h

 
#pragma once
#include <aws/securityhub/SecurityHub_EXPORTS.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/securityhub/model/Severity.h>
#include <aws/securityhub/model/Remediation.h>
#include <aws/core/utils/memory/stl/AWSMap.h>
#include <aws/securityhub/model/Network.h>
#include <aws/securityhub/model/ProcessDetails.h>
#include <aws/securityhub/model/Compliance.h>
#include <aws/securityhub/model/VerificationState.h>
#include <aws/securityhub/model/WorkflowState.h>
#include <aws/securityhub/model/Workflow.h>
#include <aws/securityhub/model/RecordState.h>
#include <aws/securityhub/model/Note.h>
#include <aws/securityhub/model/PatchSummary.h>
#include <aws/securityhub/model/Action.h>
#include <aws/securityhub/model/FindingProviderFields.h>
#include <aws/securityhub/model/GeneratorDetails.h>
#include <aws/securityhub/model/Malware.h>
#include <aws/securityhub/model/NetworkPathComponent.h>
#include <aws/securityhub/model/Threat.h>
#include <aws/securityhub/model/ThreatIntelIndicator.h>
#include <aws/securityhub/model/Resource.h>
#include <aws/securityhub/model/RelatedFinding.h>
#include <aws/securityhub/model/Vulnerability.h>
#include <utility>
 
namespace Aws
{
namespace Utils
{
namespace Json
{
  class JsonValue;
  class JsonView;
} // namespace Json
} // namespace Utils
namespace SecurityHub
{
namespace Model
{
 
  class AwsSecurityFinding
  {
  public:
    AWS_SECURITYHUB_API AwsSecurityFinding();
    AWS_SECURITYHUB_API AwsSecurityFinding(Aws::Utils::Json::JsonView jsonValue);
    AWS_SECURITYHUB_API AwsSecurityFinding& operator=(Aws::Utils::Json::JsonView jsonValue);
    AWS_SECURITYHUB_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
 
    inline const Aws::String& GetSchemaVersion() const{ return m_schemaVersion; }
    inline bool SchemaVersionHasBeenSet() const { return m_schemaVersionHasBeenSet; }
    inline void SetSchemaVersion(const Aws::String& value) { m_schemaVersionHasBeenSet = true; m_schemaVersion = value; }
    inline void SetSchemaVersion(Aws::String&& value) { m_schemaVersionHasBeenSet = true; m_schemaVersion = std::move(value); }
    inline void SetSchemaVersion(const char* value) { m_schemaVersionHasBeenSet = true; m_schemaVersion.assign(value); }
    inline AwsSecurityFinding& WithSchemaVersion(const Aws::String& value) { SetSchemaVersion(value); return *this;}
    inline AwsSecurityFinding& WithSchemaVersion(Aws::String&& value) { SetSchemaVersion(std::move(value)); return *this;}
    inline AwsSecurityFinding& WithSchemaVersion(const char* value) { SetSchemaVersion(value); return *this;}
 
 
    inline const Aws::String& GetId() const{ return m_id; }
    inline bool IdHasBeenSet() const { return m_idHasBeenSet; }
    inline void SetId(const Aws::String& value) { m_idHasBeenSet = true; m_id = value; }
    inline void SetId(Aws::String&& value) { m_idHasBeenSet = true; m_id = std::move(value); }
    inline void SetId(const char* value) { m_idHasBeenSet = true; m_id.assign(value); }
    inline AwsSecurityFinding& WithId(const Aws::String& value) { SetId(value); return *this;}
    inline AwsSecurityFinding& WithId(Aws::String&& value) { SetId(std::move(value)); return *this;}
    inline AwsSecurityFinding& WithId(const char* value) { SetId(value); return *this;}
 
 
    inline const Aws::String& GetProductArn() const{ return m_productArn; }
    inline bool ProductArnHasBeenSet() const { return m_productArnHasBeenSet; }
    inline void SetProductArn(const Aws::String& value) { m_productArnHasBeenSet = true; m_productArn = value; }
    inline void SetProductArn(Aws::String&& value) { m_productArnHasBeenSet = true; m_productArn = std::move(value); }
    inline void SetProductArn(const char* value) { m_productArnHasBeenSet = true; m_productArn.assign(value); }
    inline AwsSecurityFinding& WithProductArn(const Aws::String& value) { SetProductArn(value); return *this;}
    inline AwsSecurityFinding& WithProductArn(Aws::String&& value) { SetProductArn(std::move(value)); return *this;}
    inline AwsSecurityFinding& WithProductArn(const char* value) { SetProductArn(value); return *this;}
 
 
    inline const Aws::String& GetProductName() const{ return m_productName; }
    inline bool ProductNameHasBeenSet() const { return m_productNameHasBeenSet; }
    inline void SetProductName(const Aws::String& value) { m_productNameHasBeenSet = true; m_productName = value; }
    inline void SetProductName(Aws::String&& value) { m_productNameHasBeenSet = true; m_productName = std::move(value); }
    inline void SetProductName(const char* value) { m_productNameHasBeenSet = true; m_productName.assign(value); }
    inline AwsSecurityFinding& WithProductName(const Aws::String& value) { SetProductName(value); return *this;}
    inline AwsSecurityFinding& WithProductName(Aws::String&& value) { SetProductName(std::move(value)); return *this;}
    inline AwsSecurityFinding& WithProductName(const char* value) { SetProductName(value); return *this;}
 
 
    inline const Aws::String& GetCompanyName() const{ return m_companyName; }
    inline bool CompanyNameHasBeenSet() const { return m_companyNameHasBeenSet; }
    inline void SetCompanyName(const Aws::String& value) { m_companyNameHasBeenSet = true; m_companyName = value; }
    inline void SetCompanyName(Aws::String&& value) { m_companyNameHasBeenSet = true; m_companyName = std::move(value); }
    inline void SetCompanyName(const char* value) { m_companyNameHasBeenSet = true; m_companyName.assign(value); }
    inline AwsSecurityFinding& WithCompanyName(const Aws::String& value) { SetCompanyName(value); return *this;}
    inline AwsSecurityFinding& WithCompanyName(Aws::String&& value) { SetCompanyName(std::move(value)); return *this;}
    inline AwsSecurityFinding& WithCompanyName(const char* value) { SetCompanyName(value); return *this;}
 
 
    inline const Aws::String& GetRegion() const{ return m_region; }
    inline bool RegionHasBeenSet() const { return m_regionHasBeenSet; }
    inline void SetRegion(const Aws::String& value) { m_regionHasBeenSet = true; m_region = value; }
    inline void SetRegion(Aws::String&& value) { m_regionHasBeenSet = true; m_region = std::move(value); }
    inline void SetRegion(const char* value) { m_regionHasBeenSet = true; m_region.assign(value); }
    inline AwsSecurityFinding& WithRegion(const Aws::String& value) { SetRegion(value); return *this;}
    inline AwsSecurityFinding& WithRegion(Aws::String&& value) { SetRegion(std::move(value)); return *this;}
    inline AwsSecurityFinding& WithRegion(const char* value) { SetRegion(value); return *this;}
 
 
    inline const Aws::String& GetGeneratorId() const{ return m_generatorId; }
    inline bool GeneratorIdHasBeenSet() const { return m_generatorIdHasBeenSet; }
    inline void SetGeneratorId(const Aws::String& value) { m_generatorIdHasBeenSet = true; m_generatorId = value; }
    inline void SetGeneratorId(Aws::String&& value) { m_generatorIdHasBeenSet = true; m_generatorId = std::move(value); }
    inline void SetGeneratorId(const char* value) { m_generatorIdHasBeenSet = true; m_generatorId.assign(value); }
    inline AwsSecurityFinding& WithGeneratorId(const Aws::String& value) { SetGeneratorId(value); return *this;}
    inline AwsSecurityFinding& WithGeneratorId(Aws::String&& value) { SetGeneratorId(std::move(value)); return *this;}
    inline AwsSecurityFinding& WithGeneratorId(const char* value) { SetGeneratorId(value); return *this;}
 
 
    inline const Aws::String& GetAwsAccountId() const{ return m_awsAccountId; }
    inline bool AwsAccountIdHasBeenSet() const { return m_awsAccountIdHasBeenSet; }
    inline void SetAwsAccountId(const Aws::String& value) { m_awsAccountIdHasBeenSet = true; m_awsAccountId = value; }
    inline void SetAwsAccountId(Aws::String&& value) { m_awsAccountIdHasBeenSet = true; m_awsAccountId = std::move(value); }
    inline void SetAwsAccountId(const char* value) { m_awsAccountIdHasBeenSet = true; m_awsAccountId.assign(value); }
    inline AwsSecurityFinding& WithAwsAccountId(const Aws::String& value) { SetAwsAccountId(value); return *this;}
    inline AwsSecurityFinding& WithAwsAccountId(Aws::String&& value) { SetAwsAccountId(std::move(value)); return *this;}
    inline AwsSecurityFinding& WithAwsAccountId(const char* value) { SetAwsAccountId(value); return *this;}
 
 
    inline const Aws::Vector<Aws::String>& GetTypes() const{ return m_types; }
    inline bool TypesHasBeenSet() const { return m_typesHasBeenSet; }
    inline void SetTypes(const Aws::Vector<Aws::String>& value) { m_typesHasBeenSet = true; m_types = value; }
    inline void SetTypes(Aws::Vector<Aws::String>&& value) { m_typesHasBeenSet = true; m_types = std::move(value); }
    inline AwsSecurityFinding& WithTypes(const Aws::Vector<Aws::String>& value) { SetTypes(value); return *this;}
    inline AwsSecurityFinding& WithTypes(Aws::Vector<Aws::String>&& value) { SetTypes(std::move(value)); return *this;}
    inline AwsSecurityFinding& AddTypes(const Aws::String& value) { m_typesHasBeenSet = true; m_types.push_back(value); return *this; }
    inline AwsSecurityFinding& AddTypes(Aws::String&& value) { m_typesHasBeenSet = true; m_types.push_back(std::move(value)); return *this; }
    inline AwsSecurityFinding& AddTypes(const char* value) { m_typesHasBeenSet = true; m_types.push_back(value); return *this; }
 
 
    inline const Aws::String& GetFirstObservedAt() const{ return m_firstObservedAt; }
    inline bool FirstObservedAtHasBeenSet() const { return m_firstObservedAtHasBeenSet; }
    inline void SetFirstObservedAt(const Aws::String& value) { m_firstObservedAtHasBeenSet = true; m_firstObservedAt = value; }
    inline void SetFirstObservedAt(Aws::String&& value) { m_firstObservedAtHasBeenSet = true; m_firstObservedAt = std::move(value); }
    inline void SetFirstObservedAt(const char* value) { m_firstObservedAtHasBeenSet = true; m_firstObservedAt.assign(value); }
    inline AwsSecurityFinding& WithFirstObservedAt(const Aws::String& value) { SetFirstObservedAt(value); return *this;}
    inline AwsSecurityFinding& WithFirstObservedAt(Aws::String&& value) { SetFirstObservedAt(std::move(value)); return *this;}
    inline AwsSecurityFinding& WithFirstObservedAt(const char* value) { SetFirstObservedAt(value); return *this;}
 
 
    inline const Aws::String& GetLastObservedAt() const{ return m_lastObservedAt; }
    inline bool LastObservedAtHasBeenSet() const { return m_lastObservedAtHasBeenSet; }
    inline void SetLastObservedAt(const Aws::String& value) { m_lastObservedAtHasBeenSet = true; m_lastObservedAt = value; }
    inline void SetLastObservedAt(Aws::String&& value) { m_lastObservedAtHasBeenSet = true; m_lastObservedAt = std::move(value); }
    inline void SetLastObservedAt(const char* value) { m_lastObservedAtHasBeenSet = true; m_lastObservedAt.assign(value); }
    inline AwsSecurityFinding& WithLastObservedAt(const Aws::String& value) { SetLastObservedAt(value); return *this;}
    inline AwsSecurityFinding& WithLastObservedAt(Aws::String&& value) { SetLastObservedAt(std::move(value)); return *this;}
    inline AwsSecurityFinding& WithLastObservedAt(const char* value) { SetLastObservedAt(value); return *this;}
 
 
    inline const Aws::String& GetCreatedAt() const{ return m_createdAt; }
    inline bool CreatedAtHasBeenSet() const { return m_createdAtHasBeenSet; }
    inline void SetCreatedAt(const Aws::String& value) { m_createdAtHasBeenSet = true; m_createdAt = value; }
    inline void SetCreatedAt(Aws::String&& value) { m_createdAtHasBeenSet = true; m_createdAt = std::move(value); }
    inline void SetCreatedAt(const char* value) { m_createdAtHasBeenSet = true; m_createdAt.assign(value); }
    inline AwsSecurityFinding& WithCreatedAt(const Aws::String& value) { SetCreatedAt(value); return *this;}
    inline AwsSecurityFinding& WithCreatedAt(Aws::String&& value) { SetCreatedAt(std::move(value)); return *this;}
    inline AwsSecurityFinding& WithCreatedAt(const char* value) { SetCreatedAt(value); return *this;}
 
 
    inline const Aws::String& GetUpdatedAt() const{ return m_updatedAt; }
    inline bool UpdatedAtHasBeenSet() const { return m_updatedAtHasBeenSet; }
    inline void SetUpdatedAt(const Aws::String& value) { m_updatedAtHasBeenSet = true; m_updatedAt = value; }
    inline void SetUpdatedAt(Aws::String&& value) { m_updatedAtHasBeenSet = true; m_updatedAt = std::move(value); }
    inline void SetUpdatedAt(const char* value) { m_updatedAtHasBeenSet = true; m_updatedAt.assign(value); }
    inline AwsSecurityFinding& WithUpdatedAt(const Aws::String& value) { SetUpdatedAt(value); return *this;}
    inline AwsSecurityFinding& WithUpdatedAt(Aws::String&& value) { SetUpdatedAt(std::move(value)); return *this;}
    inline AwsSecurityFinding& WithUpdatedAt(const char* value) { SetUpdatedAt(value); return *this;}
 
 
    inline const Severity& GetSeverity() const{ return m_severity; }
    inline bool SeverityHasBeenSet() const { return m_severityHasBeenSet; }
    inline void SetSeverity(const Severity& value) { m_severityHasBeenSet = true; m_severity = value; }
    inline void SetSeverity(Severity&& value) { m_severityHasBeenSet = true; m_severity = std::move(value); }
    inline AwsSecurityFinding& WithSeverity(const Severity& value) { SetSeverity(value); return *this;}
    inline AwsSecurityFinding& WithSeverity(Severity&& value) { SetSeverity(std::move(value)); return *this;}
 
 
    inline int GetConfidence() const{ return m_confidence; }
    inline bool ConfidenceHasBeenSet() const { return m_confidenceHasBeenSet; }
    inline void SetConfidence(int value) { m_confidenceHasBeenSet = true; m_confidence = value; }
    inline AwsSecurityFinding& WithConfidence(int value) { SetConfidence(value); return *this;}
 
 
    inline int GetCriticality() const{ return m_criticality; }
    inline bool CriticalityHasBeenSet() const { return m_criticalityHasBeenSet; }
    inline void SetCriticality(int value) { m_criticalityHasBeenSet = true; m_criticality = value; }
    inline AwsSecurityFinding& WithCriticality(int value) { SetCriticality(value); return *this;}
 
 
    inline const Aws::String& GetTitle() const{ return m_title; }
    inline bool TitleHasBeenSet() const { return m_titleHasBeenSet; }
    inline void SetTitle(const Aws::String& value) { m_titleHasBeenSet = true; m_title = value; }
    inline void SetTitle(Aws::String&& value) { m_titleHasBeenSet = true; m_title = std::move(value); }
    inline void SetTitle(const char* value) { m_titleHasBeenSet = true; m_title.assign(value); }
    inline AwsSecurityFinding& WithTitle(const Aws::String& value) { SetTitle(value); return *this;}
    inline AwsSecurityFinding& WithTitle(Aws::String&& value) { SetTitle(std::move(value)); return *this;}
    inline AwsSecurityFinding& WithTitle(const char* value) { SetTitle(value); return *this;}
 
 
    inline const Aws::String& GetDescription() const{ return m_description; }
    inline bool DescriptionHasBeenSet() const { return m_descriptionHasBeenSet; }
    inline void SetDescription(const Aws::String& value) { m_descriptionHasBeenSet = true; m_description = value; }
    inline void SetDescription(Aws::String&& value) { m_descriptionHasBeenSet = true; m_description = std::move(value); }
    inline void SetDescription(const char* value) { m_descriptionHasBeenSet = true; m_description.assign(value); }
    inline AwsSecurityFinding& WithDescription(const Aws::String& value) { SetDescription(value); return *this;}
    inline AwsSecurityFinding& WithDescription(Aws::String&& value) { SetDescription(std::move(value)); return *this;}
    inline AwsSecurityFinding& WithDescription(const char* value) { SetDescription(value); return *this;}
 
 
    inline const Remediation& GetRemediation() const{ return m_remediation; }
    inline bool RemediationHasBeenSet() const { return m_remediationHasBeenSet; }
    inline void SetRemediation(const Remediation& value) { m_remediationHasBeenSet = true; m_remediation = value; }
    inline void SetRemediation(Remediation&& value) { m_remediationHasBeenSet = true; m_remediation = std::move(value); }
    inline AwsSecurityFinding& WithRemediation(const Remediation& value) { SetRemediation(value); return *this;}
    inline AwsSecurityFinding& WithRemediation(Remediation&& value) { SetRemediation(std::move(value)); return *this;}
 
 
    inline const Aws::String& GetSourceUrl() const{ return m_sourceUrl; }
    inline bool SourceUrlHasBeenSet() const { return m_sourceUrlHasBeenSet; }
    inline void SetSourceUrl(const Aws::String& value) { m_sourceUrlHasBeenSet = true; m_sourceUrl = value; }
    inline void SetSourceUrl(Aws::String&& value) { m_sourceUrlHasBeenSet = true; m_sourceUrl = std::move(value); }
    inline void SetSourceUrl(const char* value) { m_sourceUrlHasBeenSet = true; m_sourceUrl.assign(value); }
    inline AwsSecurityFinding& WithSourceUrl(const Aws::String& value) { SetSourceUrl(value); return *this;}
    inline AwsSecurityFinding& WithSourceUrl(Aws::String&& value) { SetSourceUrl(std::move(value)); return *this;}
    inline AwsSecurityFinding& WithSourceUrl(const char* value) { SetSourceUrl(value); return *this;}
 
 
    inline const Aws::Map<Aws::String, Aws::String>& GetProductFields() const{ return m_productFields; }
    inline bool ProductFieldsHasBeenSet() const { return m_productFieldsHasBeenSet; }
    inline void SetProductFields(const Aws::Map<Aws::String, Aws::String>& value) { m_productFieldsHasBeenSet = true; m_productFields = value; }
    inline void SetProductFields(Aws::Map<Aws::String, Aws::String>&& value) { m_productFieldsHasBeenSet = true; m_productFields = std::move(value); }
    inline AwsSecurityFinding& WithProductFields(const Aws::Map<Aws::String, Aws::String>& value) { SetProductFields(value); return *this;}
    inline AwsSecurityFinding& WithProductFields(Aws::Map<Aws::String, Aws::String>&& value) { SetProductFields(std::move(value)); return *this;}
    inline AwsSecurityFinding& AddProductFields(const Aws::String& key, const Aws::String& value) { m_productFieldsHasBeenSet = true; m_productFields.emplace(key, value); return *this; }
    inline AwsSecurityFinding& AddProductFields(Aws::String&& key, const Aws::String& value) { m_productFieldsHasBeenSet = true; m_productFields.emplace(std::move(key), value); return *this; }
    inline AwsSecurityFinding& AddProductFields(const Aws::String& key, Aws::String&& value) { m_productFieldsHasBeenSet = true; m_productFields.emplace(key, std::move(value)); return *this; }
    inline AwsSecurityFinding& AddProductFields(Aws::String&& key, Aws::String&& value) { m_productFieldsHasBeenSet = true; m_productFields.emplace(std::move(key), std::move(value)); return *this; }
    inline AwsSecurityFinding& AddProductFields(const char* key, Aws::String&& value) { m_productFieldsHasBeenSet = true; m_productFields.emplace(key, std::move(value)); return *this; }
    inline AwsSecurityFinding& AddProductFields(Aws::String&& key, const char* value) { m_productFieldsHasBeenSet = true; m_productFields.emplace(std::move(key), value); return *this; }
    inline AwsSecurityFinding& AddProductFields(const char* key, const char* value) { m_productFieldsHasBeenSet = true; m_productFields.emplace(key, value); return *this; }
 
 
    inline const Aws::Map<Aws::String, Aws::String>& GetUserDefinedFields() const{ return m_userDefinedFields; }
    inline bool UserDefinedFieldsHasBeenSet() const { return m_userDefinedFieldsHasBeenSet; }
    inline void SetUserDefinedFields(const Aws::Map<Aws::String, Aws::String>& value) { m_userDefinedFieldsHasBeenSet = true; m_userDefinedFields = value; }
    inline void SetUserDefinedFields(Aws::Map<Aws::String, Aws::String>&& value) { m_userDefinedFieldsHasBeenSet = true; m_userDefinedFields = std::move(value); }
    inline AwsSecurityFinding& WithUserDefinedFields(const Aws::Map<Aws::String, Aws::String>& value) { SetUserDefinedFields(value); return *this;}
    inline AwsSecurityFinding& WithUserDefinedFields(Aws::Map<Aws::String, Aws::String>&& value) { SetUserDefinedFields(std::move(value)); return *this;}
    inline AwsSecurityFinding& AddUserDefinedFields(const Aws::String& key, const Aws::String& value) { m_userDefinedFieldsHasBeenSet = true; m_userDefinedFields.emplace(key, value); return *this; }
    inline AwsSecurityFinding& AddUserDefinedFields(Aws::String&& key, const Aws::String& value) { m_userDefinedFieldsHasBeenSet = true; m_userDefinedFields.emplace(std::move(key), value); return *this; }
    inline AwsSecurityFinding& AddUserDefinedFields(const Aws::String& key, Aws::String&& value) { m_userDefinedFieldsHasBeenSet = true; m_userDefinedFields.emplace(key, std::move(value)); return *this; }
    inline AwsSecurityFinding& AddUserDefinedFields(Aws::String&& key, Aws::String&& value) { m_userDefinedFieldsHasBeenSet = true; m_userDefinedFields.emplace(std::move(key), std::move(value)); return *this; }
    inline AwsSecurityFinding& AddUserDefinedFields(const char* key, Aws::String&& value) { m_userDefinedFieldsHasBeenSet = true; m_userDefinedFields.emplace(key, std::move(value)); return *this; }
    inline AwsSecurityFinding& AddUserDefinedFields(Aws::String&& key, const char* value) { m_userDefinedFieldsHasBeenSet = true; m_userDefinedFields.emplace(std::move(key), value); return *this; }
    inline AwsSecurityFinding& AddUserDefinedFields(const char* key, const char* value) { m_userDefinedFieldsHasBeenSet = true; m_userDefinedFields.emplace(key, value); return *this; }
 
 
    inline const Aws::Vector<Malware>& GetMalware() const{ return m_malware; }
    inline bool MalwareHasBeenSet() const { return m_malwareHasBeenSet; }
    inline void SetMalware(const Aws::Vector<Malware>& value) { m_malwareHasBeenSet = true; m_malware = value; }
    inline void SetMalware(Aws::Vector<Malware>&& value) { m_malwareHasBeenSet = true; m_malware = std::move(value); }
    inline AwsSecurityFinding& WithMalware(const Aws::Vector<Malware>& value) { SetMalware(value); return *this;}
    inline AwsSecurityFinding& WithMalware(Aws::Vector<Malware>&& value) { SetMalware(std::move(value)); return *this;}
    inline AwsSecurityFinding& AddMalware(const Malware& value) { m_malwareHasBeenSet = true; m_malware.push_back(value); return *this; }
    inline AwsSecurityFinding& AddMalware(Malware&& value) { m_malwareHasBeenSet = true; m_malware.push_back(std::move(value)); return *this; }
 
 
    inline const Network& GetNetwork() const{ return m_network; }
    inline bool NetworkHasBeenSet() const { return m_networkHasBeenSet; }
    inline void SetNetwork(const Network& value) { m_networkHasBeenSet = true; m_network = value; }
    inline void SetNetwork(Network&& value) { m_networkHasBeenSet = true; m_network = std::move(value); }
    inline AwsSecurityFinding& WithNetwork(const Network& value) { SetNetwork(value); return *this;}
    inline AwsSecurityFinding& WithNetwork(Network&& value) { SetNetwork(std::move(value)); return *this;}
 
 
    inline const Aws::Vector<NetworkPathComponent>& GetNetworkPath() const{ return m_networkPath; }
    inline bool NetworkPathHasBeenSet() const { return m_networkPathHasBeenSet; }
    inline void SetNetworkPath(const Aws::Vector<NetworkPathComponent>& value) { m_networkPathHasBeenSet = true; m_networkPath = value; }
    inline void SetNetworkPath(Aws::Vector<NetworkPathComponent>&& value) { m_networkPathHasBeenSet = true; m_networkPath = std::move(value); }
    inline AwsSecurityFinding& WithNetworkPath(const Aws::Vector<NetworkPathComponent>& value) { SetNetworkPath(value); return *this;}
    inline AwsSecurityFinding& WithNetworkPath(Aws::Vector<NetworkPathComponent>&& value) { SetNetworkPath(std::move(value)); return *this;}
    inline AwsSecurityFinding& AddNetworkPath(const NetworkPathComponent& value) { m_networkPathHasBeenSet = true; m_networkPath.push_back(value); return *this; }
    inline AwsSecurityFinding& AddNetworkPath(NetworkPathComponent&& value) { m_networkPathHasBeenSet = true; m_networkPath.push_back(std::move(value)); return *this; }
 
 
    inline const ProcessDetails& GetProcess() const{ return m_process; }
    inline bool ProcessHasBeenSet() const { return m_processHasBeenSet; }
    inline void SetProcess(const ProcessDetails& value) { m_processHasBeenSet = true; m_process = value; }
    inline void SetProcess(ProcessDetails&& value) { m_processHasBeenSet = true; m_process = std::move(value); }
    inline AwsSecurityFinding& WithProcess(const ProcessDetails& value) { SetProcess(value); return *this;}
    inline AwsSecurityFinding& WithProcess(ProcessDetails&& value) { SetProcess(std::move(value)); return *this;}
 
 
    inline const Aws::Vector<Threat>& GetThreats() const{ return m_threats; }
    inline bool ThreatsHasBeenSet() const { return m_threatsHasBeenSet; }
    inline void SetThreats(const Aws::Vector<Threat>& value) { m_threatsHasBeenSet = true; m_threats = value; }
    inline void SetThreats(Aws::Vector<Threat>&& value) { m_threatsHasBeenSet = true; m_threats = std::move(value); }
    inline AwsSecurityFinding& WithThreats(const Aws::Vector<Threat>& value) { SetThreats(value); return *this;}
    inline AwsSecurityFinding& WithThreats(Aws::Vector<Threat>&& value) { SetThreats(std::move(value)); return *this;}
    inline AwsSecurityFinding& AddThreats(const Threat& value) { m_threatsHasBeenSet = true; m_threats.push_back(value); return *this; }
    inline AwsSecurityFinding& AddThreats(Threat&& value) { m_threatsHasBeenSet = true; m_threats.push_back(std::move(value)); return *this; }
 
 
    inline const Aws::Vector<ThreatIntelIndicator>& GetThreatIntelIndicators() const{ return m_threatIntelIndicators; }
    inline bool ThreatIntelIndicatorsHasBeenSet() const { return m_threatIntelIndicatorsHasBeenSet; }
    inline void SetThreatIntelIndicators(const Aws::Vector<ThreatIntelIndicator>& value) { m_threatIntelIndicatorsHasBeenSet = true; m_threatIntelIndicators = value; }
    inline void SetThreatIntelIndicators(Aws::Vector<ThreatIntelIndicator>&& value) { m_threatIntelIndicatorsHasBeenSet = true; m_threatIntelIndicators = std::move(value); }
    inline AwsSecurityFinding& WithThreatIntelIndicators(const Aws::Vector<ThreatIntelIndicator>& value) { SetThreatIntelIndicators(value); return *this;}
    inline AwsSecurityFinding& WithThreatIntelIndicators(Aws::Vector<ThreatIntelIndicator>&& value) { SetThreatIntelIndicators(std::move(value)); return *this;}
    inline AwsSecurityFinding& AddThreatIntelIndicators(const ThreatIntelIndicator& value) { m_threatIntelIndicatorsHasBeenSet = true; m_threatIntelIndicators.push_back(value); return *this; }
    inline AwsSecurityFinding& AddThreatIntelIndicators(ThreatIntelIndicator&& value) { m_threatIntelIndicatorsHasBeenSet = true; m_threatIntelIndicators.push_back(std::move(value)); return *this; }
 
 
    inline const Aws::Vector<Resource>& GetResources() const{ return m_resources; }
    inline bool ResourcesHasBeenSet() const { return m_resourcesHasBeenSet; }
    inline void SetResources(const Aws::Vector<Resource>& value) { m_resourcesHasBeenSet = true; m_resources = value; }
    inline void SetResources(Aws::Vector<Resource>&& value) { m_resourcesHasBeenSet = true; m_resources = std::move(value); }
    inline AwsSecurityFinding& WithResources(const Aws::Vector<Resource>& value) { SetResources(value); return *this;}
    inline AwsSecurityFinding& WithResources(Aws::Vector<Resource>&& value) { SetResources(std::move(value)); return *this;}
    inline AwsSecurityFinding& AddResources(const Resource& value) { m_resourcesHasBeenSet = true; m_resources.push_back(value); return *this; }
    inline AwsSecurityFinding& AddResources(Resource&& value) { m_resourcesHasBeenSet = true; m_resources.push_back(std::move(value)); return *this; }
 
 
    inline const Compliance& GetCompliance() const{ return m_compliance; }
    inline bool ComplianceHasBeenSet() const { return m_complianceHasBeenSet; }
    inline void SetCompliance(const Compliance& value) { m_complianceHasBeenSet = true; m_compliance = value; }
    inline void SetCompliance(Compliance&& value) { m_complianceHasBeenSet = true; m_compliance = std::move(value); }
    inline AwsSecurityFinding& WithCompliance(const Compliance& value) { SetCompliance(value); return *this;}
    inline AwsSecurityFinding& WithCompliance(Compliance&& value) { SetCompliance(std::move(value)); return *this;}
 
 
    inline const VerificationState& GetVerificationState() const{ return m_verificationState; }
    inline bool VerificationStateHasBeenSet() const { return m_verificationStateHasBeenSet; }
    inline void SetVerificationState(const VerificationState& value) { m_verificationStateHasBeenSet = true; m_verificationState = value; }
    inline void SetVerificationState(VerificationState&& value) { m_verificationStateHasBeenSet = true; m_verificationState = std::move(value); }
    inline AwsSecurityFinding& WithVerificationState(const VerificationState& value) { SetVerificationState(value); return *this;}
    inline AwsSecurityFinding& WithVerificationState(VerificationState&& value) { SetVerificationState(std::move(value)); return *this;}
 
 
    inline const WorkflowState& GetWorkflowState() const{ return m_workflowState; }
    inline bool WorkflowStateHasBeenSet() const { return m_workflowStateHasBeenSet; }
    inline void SetWorkflowState(const WorkflowState& value) { m_workflowStateHasBeenSet = true; m_workflowState = value; }
    inline void SetWorkflowState(WorkflowState&& value) { m_workflowStateHasBeenSet = true; m_workflowState = std::move(value); }
    inline AwsSecurityFinding& WithWorkflowState(const WorkflowState& value) { SetWorkflowState(value); return *this;}
    inline AwsSecurityFinding& WithWorkflowState(WorkflowState&& value) { SetWorkflowState(std::move(value)); return *this;}
 
 
    inline const Workflow& GetWorkflow() const{ return m_workflow; }
    inline bool WorkflowHasBeenSet() const { return m_workflowHasBeenSet; }
    inline void SetWorkflow(const Workflow& value) { m_workflowHasBeenSet = true; m_workflow = value; }
    inline void SetWorkflow(Workflow&& value) { m_workflowHasBeenSet = true; m_workflow = std::move(value); }
    inline AwsSecurityFinding& WithWorkflow(const Workflow& value) { SetWorkflow(value); return *this;}
    inline AwsSecurityFinding& WithWorkflow(Workflow&& value) { SetWorkflow(std::move(value)); return *this;}
 
 
    inline const RecordState& GetRecordState() const{ return m_recordState; }
    inline bool RecordStateHasBeenSet() const { return m_recordStateHasBeenSet; }
    inline void SetRecordState(const RecordState& value) { m_recordStateHasBeenSet = true; m_recordState = value; }
    inline void SetRecordState(RecordState&& value) { m_recordStateHasBeenSet = true; m_recordState = std::move(value); }
    inline AwsSecurityFinding& WithRecordState(const RecordState& value) { SetRecordState(value); return *this;}
    inline AwsSecurityFinding& WithRecordState(RecordState&& value) { SetRecordState(std::move(value)); return *this;}
 
 
    inline const Aws::Vector<RelatedFinding>& GetRelatedFindings() const{ return m_relatedFindings; }
    inline bool RelatedFindingsHasBeenSet() const { return m_relatedFindingsHasBeenSet; }
    inline void SetRelatedFindings(const Aws::Vector<RelatedFinding>& value) { m_relatedFindingsHasBeenSet = true; m_relatedFindings = value; }
    inline void SetRelatedFindings(Aws::Vector<RelatedFinding>&& value) { m_relatedFindingsHasBeenSet = true; m_relatedFindings = std::move(value); }
    inline AwsSecurityFinding& WithRelatedFindings(const Aws::Vector<RelatedFinding>& value) { SetRelatedFindings(value); return *this;}
    inline AwsSecurityFinding& WithRelatedFindings(Aws::Vector<RelatedFinding>&& value) { SetRelatedFindings(std::move(value)); return *this;}
    inline AwsSecurityFinding& AddRelatedFindings(const RelatedFinding& value) { m_relatedFindingsHasBeenSet = true; m_relatedFindings.push_back(value); return *this; }
    inline AwsSecurityFinding& AddRelatedFindings(RelatedFinding&& value) { m_relatedFindingsHasBeenSet = true; m_relatedFindings.push_back(std::move(value)); return *this; }
 
 
    inline const Note& GetNote() const{ return m_note; }
    inline bool NoteHasBeenSet() const { return m_noteHasBeenSet; }
    inline void SetNote(const Note& value) { m_noteHasBeenSet = true; m_note = value; }
    inline void SetNote(Note&& value) { m_noteHasBeenSet = true; m_note = std::move(value); }
    inline AwsSecurityFinding& WithNote(const Note& value) { SetNote(value); return *this;}
    inline AwsSecurityFinding& WithNote(Note&& value) { SetNote(std::move(value)); return *this;}
 
 
    inline const Aws::Vector<Vulnerability>& GetVulnerabilities() const{ return m_vulnerabilities; }
    inline bool VulnerabilitiesHasBeenSet() const { return m_vulnerabilitiesHasBeenSet; }
    inline void SetVulnerabilities(const Aws::Vector<Vulnerability>& value) { m_vulnerabilitiesHasBeenSet = true; m_vulnerabilities = value; }
    inline void SetVulnerabilities(Aws::Vector<Vulnerability>&& value) { m_vulnerabilitiesHasBeenSet = true; m_vulnerabilities = std::move(value); }
    inline AwsSecurityFinding& WithVulnerabilities(const Aws::Vector<Vulnerability>& value) { SetVulnerabilities(value); return *this;}
    inline AwsSecurityFinding& WithVulnerabilities(Aws::Vector<Vulnerability>&& value) { SetVulnerabilities(std::move(value)); return *this;}
    inline AwsSecurityFinding& AddVulnerabilities(const Vulnerability& value) { m_vulnerabilitiesHasBeenSet = true; m_vulnerabilities.push_back(value); return *this; }
    inline AwsSecurityFinding& AddVulnerabilities(Vulnerability&& value) { m_vulnerabilitiesHasBeenSet = true; m_vulnerabilities.push_back(std::move(value)); return *this; }
 
 
    inline const PatchSummary& GetPatchSummary() const{ return m_patchSummary; }
    inline bool PatchSummaryHasBeenSet() const { return m_patchSummaryHasBeenSet; }
    inline void SetPatchSummary(const PatchSummary& value) { m_patchSummaryHasBeenSet = true; m_patchSummary = value; }
    inline void SetPatchSummary(PatchSummary&& value) { m_patchSummaryHasBeenSet = true; m_patchSummary = std::move(value); }
    inline AwsSecurityFinding& WithPatchSummary(const PatchSummary& value) { SetPatchSummary(value); return *this;}
    inline AwsSecurityFinding& WithPatchSummary(PatchSummary&& value) { SetPatchSummary(std::move(value)); return *this;}
 
 
    inline const Action& GetAction() const{ return m_action; }
    inline bool ActionHasBeenSet() const { return m_actionHasBeenSet; }
    inline void SetAction(const Action& value) { m_actionHasBeenSet = true; m_action = value; }
    inline void SetAction(Action&& value) { m_actionHasBeenSet = true; m_action = std::move(value); }
    inline AwsSecurityFinding& WithAction(const Action& value) { SetAction(value); return *this;}
    inline AwsSecurityFinding& WithAction(Action&& value) { SetAction(std::move(value)); return *this;}
 
 
    inline const FindingProviderFields& GetFindingProviderFields() const{ return m_findingProviderFields; }
    inline bool FindingProviderFieldsHasBeenSet() const { return m_findingProviderFieldsHasBeenSet; }
    inline void SetFindingProviderFields(const FindingProviderFields& value) { m_findingProviderFieldsHasBeenSet = true; m_findingProviderFields = value; }
    inline void SetFindingProviderFields(FindingProviderFields&& value) { m_findingProviderFieldsHasBeenSet = true; m_findingProviderFields = std::move(value); }
    inline AwsSecurityFinding& WithFindingProviderFields(const FindingProviderFields& value) { SetFindingProviderFields(value); return *this;}
    inline AwsSecurityFinding& WithFindingProviderFields(FindingProviderFields&& value) { SetFindingProviderFields(std::move(value)); return *this;}
 
 
    inline bool GetSample() const{ return m_sample; }
    inline bool SampleHasBeenSet() const { return m_sampleHasBeenSet; }
    inline void SetSample(bool value) { m_sampleHasBeenSet = true; m_sample = value; }
    inline AwsSecurityFinding& WithSample(bool value) { SetSample(value); return *this;}
 
 
    inline const GeneratorDetails& GetGeneratorDetails() const{ return m_generatorDetails; }
    inline bool GeneratorDetailsHasBeenSet() const { return m_generatorDetailsHasBeenSet; }
    inline void SetGeneratorDetails(const GeneratorDetails& value) { m_generatorDetailsHasBeenSet = true; m_generatorDetails = value; }
    inline void SetGeneratorDetails(GeneratorDetails&& value) { m_generatorDetailsHasBeenSet = true; m_generatorDetails = std::move(value); }
    inline AwsSecurityFinding& WithGeneratorDetails(const GeneratorDetails& value) { SetGeneratorDetails(value); return *this;}
    inline AwsSecurityFinding& WithGeneratorDetails(GeneratorDetails&& value) { SetGeneratorDetails(std::move(value)); return *this;}
 
 
    inline const Aws::String& GetProcessedAt() const{ return m_processedAt; }
    inline bool ProcessedAtHasBeenSet() const { return m_processedAtHasBeenSet; }
    inline void SetProcessedAt(const Aws::String& value) { m_processedAtHasBeenSet = true; m_processedAt = value; }
    inline void SetProcessedAt(Aws::String&& value) { m_processedAtHasBeenSet = true; m_processedAt = std::move(value); }
    inline void SetProcessedAt(const char* value) { m_processedAtHasBeenSet = true; m_processedAt.assign(value); }
    inline AwsSecurityFinding& WithProcessedAt(const Aws::String& value) { SetProcessedAt(value); return *this;}
    inline AwsSecurityFinding& WithProcessedAt(Aws::String&& value) { SetProcessedAt(std::move(value)); return *this;}
    inline AwsSecurityFinding& WithProcessedAt(const char* value) { SetProcessedAt(value); return *this;}
 
 
    inline const Aws::String& GetAwsAccountName() const{ return m_awsAccountName; }
    inline bool AwsAccountNameHasBeenSet() const { return m_awsAccountNameHasBeenSet; }
    inline void SetAwsAccountName(const Aws::String& value) { m_awsAccountNameHasBeenSet = true; m_awsAccountName = value; }
    inline void SetAwsAccountName(Aws::String&& value) { m_awsAccountNameHasBeenSet = true; m_awsAccountName = std::move(value); }
    inline void SetAwsAccountName(const char* value) { m_awsAccountNameHasBeenSet = true; m_awsAccountName.assign(value); }
    inline AwsSecurityFinding& WithAwsAccountName(const Aws::String& value) { SetAwsAccountName(value); return *this;}
    inline AwsSecurityFinding& WithAwsAccountName(Aws::String&& value) { SetAwsAccountName(std::move(value)); return *this;}
    inline AwsSecurityFinding& WithAwsAccountName(const char* value) { SetAwsAccountName(value); return *this;}
  private:
 
    Aws::String m_schemaVersion;
    bool m_schemaVersionHasBeenSet = false;
 
    Aws::String m_id;
    bool m_idHasBeenSet = false;
 
    Aws::String m_productArn;
    bool m_productArnHasBeenSet = false;
 
    Aws::String m_productName;
    bool m_productNameHasBeenSet = false;
 
    Aws::String m_companyName;
    bool m_companyNameHasBeenSet = false;
 
    Aws::String m_region;
    bool m_regionHasBeenSet = false;
 
    Aws::String m_generatorId;
    bool m_generatorIdHasBeenSet = false;
 
    Aws::String m_awsAccountId;
    bool m_awsAccountIdHasBeenSet = false;
 
    Aws::Vector<Aws::String> m_types;
    bool m_typesHasBeenSet = false;
 
    Aws::String m_firstObservedAt;
    bool m_firstObservedAtHasBeenSet = false;
 
    Aws::String m_lastObservedAt;
    bool m_lastObservedAtHasBeenSet = false;
 
    Aws::String m_createdAt;
    bool m_createdAtHasBeenSet = false;
 
    Aws::String m_updatedAt;
    bool m_updatedAtHasBeenSet = false;
 
    Severity m_severity;
    bool m_severityHasBeenSet = false;
 
    int m_confidence;
    bool m_confidenceHasBeenSet = false;
 
    int m_criticality;
    bool m_criticalityHasBeenSet = false;
 
    Aws::String m_title;
    bool m_titleHasBeenSet = false;
 
    Aws::String m_description;
    bool m_descriptionHasBeenSet = false;
 
    Remediation m_remediation;
    bool m_remediationHasBeenSet = false;
 
    Aws::String m_sourceUrl;
    bool m_sourceUrlHasBeenSet = false;
 
    Aws::Map<Aws::String, Aws::String> m_productFields;
    bool m_productFieldsHasBeenSet = false;
 
    Aws::Map<Aws::String, Aws::String> m_userDefinedFields;
    bool m_userDefinedFieldsHasBeenSet = false;
 
    Aws::Vector<Malware> m_malware;
    bool m_malwareHasBeenSet = false;
 
    Network m_network;
    bool m_networkHasBeenSet = false;
 
    Aws::Vector<NetworkPathComponent> m_networkPath;
    bool m_networkPathHasBeenSet = false;
 
    ProcessDetails m_process;
    bool m_processHasBeenSet = false;
 
    Aws::Vector<Threat> m_threats;
    bool m_threatsHasBeenSet = false;
 
    Aws::Vector<ThreatIntelIndicator> m_threatIntelIndicators;
    bool m_threatIntelIndicatorsHasBeenSet = false;
 
    Aws::Vector<Resource> m_resources;
    bool m_resourcesHasBeenSet = false;
 
    Compliance m_compliance;
    bool m_complianceHasBeenSet = false;
 
    VerificationState m_verificationState;
    bool m_verificationStateHasBeenSet = false;
 
    WorkflowState m_workflowState;
    bool m_workflowStateHasBeenSet = false;
 
    Workflow m_workflow;
    bool m_workflowHasBeenSet = false;
 
    RecordState m_recordState;
    bool m_recordStateHasBeenSet = false;
 
    Aws::Vector<RelatedFinding> m_relatedFindings;
    bool m_relatedFindingsHasBeenSet = false;
 
    Note m_note;
    bool m_noteHasBeenSet = false;
 
    Aws::Vector<Vulnerability> m_vulnerabilities;
    bool m_vulnerabilitiesHasBeenSet = false;
 
    PatchSummary m_patchSummary;
    bool m_patchSummaryHasBeenSet = false;
 
    Action m_action;
    bool m_actionHasBeenSet = false;
 
    FindingProviderFields m_findingProviderFields;
    bool m_findingProviderFieldsHasBeenSet = false;
 
    bool m_sample;
    bool m_sampleHasBeenSet = false;
 
    GeneratorDetails m_generatorDetails;
    bool m_generatorDetailsHasBeenSet = false;
 
    Aws::String m_processedAt;
    bool m_processedAtHasBeenSet = false;
 
    Aws::String m_awsAccountName;
    bool m_awsAccountNameHasBeenSet = false;
  };
 
} // namespace Model
} // namespace SecurityHub
} // namespace Aws