DescribeSecretResult.h

 
#pragma once
#include <aws/core/http/HttpResponse.h>
#include <aws/core/utils/DateTime.h>
#include <aws/core/utils/memory/stl/AWSMap.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/secretsmanager/SecretsManager_EXPORTS.h>
#include <aws/secretsmanager/model/ExternalSecretRotationMetadataItem.h>
#include <aws/secretsmanager/model/ReplicationStatusType.h>
#include <aws/secretsmanager/model/RotationRulesType.h>
#include <aws/secretsmanager/model/Tag.h>
 
#include <utility>
 
namespace Aws {
template <typename RESULT_TYPE>
class AmazonWebServiceResult;
 
namespace Utils {
namespace Json {
class JsonValue;
}  // namespace Json
}  // namespace Utils
namespace SecretsManager {
namespace Model {
class DescribeSecretResult {
 public:
  AWS_SECRETSMANAGER_API DescribeSecretResult() = default;
  AWS_SECRETSMANAGER_API DescribeSecretResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
  AWS_SECRETSMANAGER_API DescribeSecretResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
 
 
  inline const Aws::String& GetARN() const { return m_aRN; }
  template <typename ARNT = Aws::String>
  void SetARN(ARNT&& value) {
    m_aRNHasBeenSet = true;
    m_aRN = std::forward<ARNT>(value);
  }
  template <typename ARNT = Aws::String>
  DescribeSecretResult& WithARN(ARNT&& value) {
    SetARN(std::forward<ARNT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetName() const { return m_name; }
  template <typename NameT = Aws::String>
  void SetName(NameT&& value) {
    m_nameHasBeenSet = true;
    m_name = std::forward<NameT>(value);
  }
  template <typename NameT = Aws::String>
  DescribeSecretResult& WithName(NameT&& value) {
    SetName(std::forward<NameT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetType() const { return m_type; }
  template <typename TypeT = Aws::String>
  void SetType(TypeT&& value) {
    m_typeHasBeenSet = true;
    m_type = std::forward<TypeT>(value);
  }
  template <typename TypeT = Aws::String>
  DescribeSecretResult& WithType(TypeT&& value) {
    SetType(std::forward<TypeT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetDescription() const { return m_description; }
  template <typename DescriptionT = Aws::String>
  void SetDescription(DescriptionT&& value) {
    m_descriptionHasBeenSet = true;
    m_description = std::forward<DescriptionT>(value);
  }
  template <typename DescriptionT = Aws::String>
  DescribeSecretResult& WithDescription(DescriptionT&& value) {
    SetDescription(std::forward<DescriptionT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetKmsKeyId() const { return m_kmsKeyId; }
  template <typename KmsKeyIdT = Aws::String>
  void SetKmsKeyId(KmsKeyIdT&& value) {
    m_kmsKeyIdHasBeenSet = true;
    m_kmsKeyId = std::forward<KmsKeyIdT>(value);
  }
  template <typename KmsKeyIdT = Aws::String>
  DescribeSecretResult& WithKmsKeyId(KmsKeyIdT&& value) {
    SetKmsKeyId(std::forward<KmsKeyIdT>(value));
    return *this;
  }
 
 
  inline bool GetRotationEnabled() const { return m_rotationEnabled; }
  inline void SetRotationEnabled(bool value) {
    m_rotationEnabledHasBeenSet = true;
    m_rotationEnabled = value;
  }
  inline DescribeSecretResult& WithRotationEnabled(bool value) {
    SetRotationEnabled(value);
    return *this;
  }
 
 
  inline const Aws::String& GetRotationLambdaARN() const { return m_rotationLambdaARN; }
  template <typename RotationLambdaARNT = Aws::String>
  void SetRotationLambdaARN(RotationLambdaARNT&& value) {
    m_rotationLambdaARNHasBeenSet = true;
    m_rotationLambdaARN = std::forward<RotationLambdaARNT>(value);
  }
  template <typename RotationLambdaARNT = Aws::String>
  DescribeSecretResult& WithRotationLambdaARN(RotationLambdaARNT&& value) {
    SetRotationLambdaARN(std::forward<RotationLambdaARNT>(value));
    return *this;
  }
 
 
  inline const RotationRulesType& GetRotationRules() const { return m_rotationRules; }
  template <typename RotationRulesT = RotationRulesType>
  void SetRotationRules(RotationRulesT&& value) {
    m_rotationRulesHasBeenSet = true;
    m_rotationRules = std::forward<RotationRulesT>(value);
  }
  template <typename RotationRulesT = RotationRulesType>
  DescribeSecretResult& WithRotationRules(RotationRulesT&& value) {
    SetRotationRules(std::forward<RotationRulesT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<ExternalSecretRotationMetadataItem>& GetExternalSecretRotationMetadata() const {
    return m_externalSecretRotationMetadata;
  }
  template <typename ExternalSecretRotationMetadataT = Aws::Vector<ExternalSecretRotationMetadataItem>>
  void SetExternalSecretRotationMetadata(ExternalSecretRotationMetadataT&& value) {
    m_externalSecretRotationMetadataHasBeenSet = true;
    m_externalSecretRotationMetadata = std::forward<ExternalSecretRotationMetadataT>(value);
  }
  template <typename ExternalSecretRotationMetadataT = Aws::Vector<ExternalSecretRotationMetadataItem>>
  DescribeSecretResult& WithExternalSecretRotationMetadata(ExternalSecretRotationMetadataT&& value) {
    SetExternalSecretRotationMetadata(std::forward<ExternalSecretRotationMetadataT>(value));
    return *this;
  }
  template <typename ExternalSecretRotationMetadataT = ExternalSecretRotationMetadataItem>
  DescribeSecretResult& AddExternalSecretRotationMetadata(ExternalSecretRotationMetadataT&& value) {
    m_externalSecretRotationMetadataHasBeenSet = true;
    m_externalSecretRotationMetadata.emplace_back(std::forward<ExternalSecretRotationMetadataT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetExternalSecretRotationRoleArn() const { return m_externalSecretRotationRoleArn; }
  template <typename ExternalSecretRotationRoleArnT = Aws::String>
  void SetExternalSecretRotationRoleArn(ExternalSecretRotationRoleArnT&& value) {
    m_externalSecretRotationRoleArnHasBeenSet = true;
    m_externalSecretRotationRoleArn = std::forward<ExternalSecretRotationRoleArnT>(value);
  }
  template <typename ExternalSecretRotationRoleArnT = Aws::String>
  DescribeSecretResult& WithExternalSecretRotationRoleArn(ExternalSecretRotationRoleArnT&& value) {
    SetExternalSecretRotationRoleArn(std::forward<ExternalSecretRotationRoleArnT>(value));
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetLastRotatedDate() const { return m_lastRotatedDate; }
  template <typename LastRotatedDateT = Aws::Utils::DateTime>
  void SetLastRotatedDate(LastRotatedDateT&& value) {
    m_lastRotatedDateHasBeenSet = true;
    m_lastRotatedDate = std::forward<LastRotatedDateT>(value);
  }
  template <typename LastRotatedDateT = Aws::Utils::DateTime>
  DescribeSecretResult& WithLastRotatedDate(LastRotatedDateT&& value) {
    SetLastRotatedDate(std::forward<LastRotatedDateT>(value));
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetLastChangedDate() const { return m_lastChangedDate; }
  template <typename LastChangedDateT = Aws::Utils::DateTime>
  void SetLastChangedDate(LastChangedDateT&& value) {
    m_lastChangedDateHasBeenSet = true;
    m_lastChangedDate = std::forward<LastChangedDateT>(value);
  }
  template <typename LastChangedDateT = Aws::Utils::DateTime>
  DescribeSecretResult& WithLastChangedDate(LastChangedDateT&& value) {
    SetLastChangedDate(std::forward<LastChangedDateT>(value));
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetLastAccessedDate() const { return m_lastAccessedDate; }
  template <typename LastAccessedDateT = Aws::Utils::DateTime>
  void SetLastAccessedDate(LastAccessedDateT&& value) {
    m_lastAccessedDateHasBeenSet = true;
    m_lastAccessedDate = std::forward<LastAccessedDateT>(value);
  }
  template <typename LastAccessedDateT = Aws::Utils::DateTime>
  DescribeSecretResult& WithLastAccessedDate(LastAccessedDateT&& value) {
    SetLastAccessedDate(std::forward<LastAccessedDateT>(value));
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetDeletedDate() const { return m_deletedDate; }
  template <typename DeletedDateT = Aws::Utils::DateTime>
  void SetDeletedDate(DeletedDateT&& value) {
    m_deletedDateHasBeenSet = true;
    m_deletedDate = std::forward<DeletedDateT>(value);
  }
  template <typename DeletedDateT = Aws::Utils::DateTime>
  DescribeSecretResult& WithDeletedDate(DeletedDateT&& value) {
    SetDeletedDate(std::forward<DeletedDateT>(value));
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetNextRotationDate() const { return m_nextRotationDate; }
  template <typename NextRotationDateT = Aws::Utils::DateTime>
  void SetNextRotationDate(NextRotationDateT&& value) {
    m_nextRotationDateHasBeenSet = true;
    m_nextRotationDate = std::forward<NextRotationDateT>(value);
  }
  template <typename NextRotationDateT = Aws::Utils::DateTime>
  DescribeSecretResult& WithNextRotationDate(NextRotationDateT&& value) {
    SetNextRotationDate(std::forward<NextRotationDateT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<Tag>& GetTags() const { return m_tags; }
  template <typename TagsT = Aws::Vector<Tag>>
  void SetTags(TagsT&& value) {
    m_tagsHasBeenSet = true;
    m_tags = std::forward<TagsT>(value);
  }
  template <typename TagsT = Aws::Vector<Tag>>
  DescribeSecretResult& WithTags(TagsT&& value) {
    SetTags(std::forward<TagsT>(value));
    return *this;
  }
  template <typename TagsT = Tag>
  DescribeSecretResult& AddTags(TagsT&& value) {
    m_tagsHasBeenSet = true;
    m_tags.emplace_back(std::forward<TagsT>(value));
    return *this;
  }
 
 
  inline const Aws::Map<Aws::String, Aws::Vector<Aws::String>>& GetVersionIdsToStages() const { return m_versionIdsToStages; }
  template <typename VersionIdsToStagesT = Aws::Map<Aws::String, Aws::Vector<Aws::String>>>
  void SetVersionIdsToStages(VersionIdsToStagesT&& value) {
    m_versionIdsToStagesHasBeenSet = true;
    m_versionIdsToStages = std::forward<VersionIdsToStagesT>(value);
  }
  template <typename VersionIdsToStagesT = Aws::Map<Aws::String, Aws::Vector<Aws::String>>>
  DescribeSecretResult& WithVersionIdsToStages(VersionIdsToStagesT&& value) {
    SetVersionIdsToStages(std::forward<VersionIdsToStagesT>(value));
    return *this;
  }
  template <typename VersionIdsToStagesKeyT = Aws::String, typename VersionIdsToStagesValueT = Aws::Vector<Aws::String>>
  DescribeSecretResult& AddVersionIdsToStages(VersionIdsToStagesKeyT&& key, VersionIdsToStagesValueT&& value) {
    m_versionIdsToStagesHasBeenSet = true;
    m_versionIdsToStages.emplace(std::forward<VersionIdsToStagesKeyT>(key), std::forward<VersionIdsToStagesValueT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetOwningService() const { return m_owningService; }
  template <typename OwningServiceT = Aws::String>
  void SetOwningService(OwningServiceT&& value) {
    m_owningServiceHasBeenSet = true;
    m_owningService = std::forward<OwningServiceT>(value);
  }
  template <typename OwningServiceT = Aws::String>
  DescribeSecretResult& WithOwningService(OwningServiceT&& value) {
    SetOwningService(std::forward<OwningServiceT>(value));
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetCreatedDate() const { return m_createdDate; }
  template <typename CreatedDateT = Aws::Utils::DateTime>
  void SetCreatedDate(CreatedDateT&& value) {
    m_createdDateHasBeenSet = true;
    m_createdDate = std::forward<CreatedDateT>(value);
  }
  template <typename CreatedDateT = Aws::Utils::DateTime>
  DescribeSecretResult& WithCreatedDate(CreatedDateT&& value) {
    SetCreatedDate(std::forward<CreatedDateT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetPrimaryRegion() const { return m_primaryRegion; }
  template <typename PrimaryRegionT = Aws::String>
  void SetPrimaryRegion(PrimaryRegionT&& value) {
    m_primaryRegionHasBeenSet = true;
    m_primaryRegion = std::forward<PrimaryRegionT>(value);
  }
  template <typename PrimaryRegionT = Aws::String>
  DescribeSecretResult& WithPrimaryRegion(PrimaryRegionT&& value) {
    SetPrimaryRegion(std::forward<PrimaryRegionT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<ReplicationStatusType>& GetReplicationStatus() const { return m_replicationStatus; }
  template <typename ReplicationStatusT = Aws::Vector<ReplicationStatusType>>
  void SetReplicationStatus(ReplicationStatusT&& value) {
    m_replicationStatusHasBeenSet = true;
    m_replicationStatus = std::forward<ReplicationStatusT>(value);
  }
  template <typename ReplicationStatusT = Aws::Vector<ReplicationStatusType>>
  DescribeSecretResult& WithReplicationStatus(ReplicationStatusT&& value) {
    SetReplicationStatus(std::forward<ReplicationStatusT>(value));
    return *this;
  }
  template <typename ReplicationStatusT = ReplicationStatusType>
  DescribeSecretResult& AddReplicationStatus(ReplicationStatusT&& value) {
    m_replicationStatusHasBeenSet = true;
    m_replicationStatus.emplace_back(std::forward<ReplicationStatusT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetRequestId() const { return m_requestId; }
  template <typename RequestIdT = Aws::String>
  void SetRequestId(RequestIdT&& value) {
    m_requestIdHasBeenSet = true;
    m_requestId = std::forward<RequestIdT>(value);
  }
  template <typename RequestIdT = Aws::String>
  DescribeSecretResult& WithRequestId(RequestIdT&& value) {
    SetRequestId(std::forward<RequestIdT>(value));
    return *this;
  }
  inline Aws::Http::HttpResponseCode GetHttpResponseCode() const { return m_HttpResponseCode; }
 
 private:
  Aws::String m_aRN;
 
  Aws::String m_name;
 
  Aws::String m_type;
 
  Aws::String m_description;
 
  Aws::String m_kmsKeyId;
 
  bool m_rotationEnabled{false};
 
  Aws::String m_rotationLambdaARN;
 
  RotationRulesType m_rotationRules;
 
  Aws::Vector<ExternalSecretRotationMetadataItem> m_externalSecretRotationMetadata;
 
  Aws::String m_externalSecretRotationRoleArn;
 
  Aws::Utils::DateTime m_lastRotatedDate{};
 
  Aws::Utils::DateTime m_lastChangedDate{};
 
  Aws::Utils::DateTime m_lastAccessedDate{};
 
  Aws::Utils::DateTime m_deletedDate{};
 
  Aws::Utils::DateTime m_nextRotationDate{};
 
  Aws::Vector<Tag> m_tags;
 
  Aws::Map<Aws::String, Aws::Vector<Aws::String>> m_versionIdsToStages;
 
  Aws::String m_owningService;
 
  Aws::Utils::DateTime m_createdDate{};
 
  Aws::String m_primaryRegion;
 
  Aws::Vector<ReplicationStatusType> m_replicationStatus;
 
  Aws::String m_requestId;
  Aws::Http::HttpResponseCode m_HttpResponseCode;
  bool m_aRNHasBeenSet = false;
  bool m_nameHasBeenSet = false;
  bool m_typeHasBeenSet = false;
  bool m_descriptionHasBeenSet = false;
  bool m_kmsKeyIdHasBeenSet = false;
  bool m_rotationEnabledHasBeenSet = false;
  bool m_rotationLambdaARNHasBeenSet = false;
  bool m_rotationRulesHasBeenSet = false;
  bool m_externalSecretRotationMetadataHasBeenSet = false;
  bool m_externalSecretRotationRoleArnHasBeenSet = false;
  bool m_lastRotatedDateHasBeenSet = false;
  bool m_lastChangedDateHasBeenSet = false;
  bool m_lastAccessedDateHasBeenSet = false;
  bool m_deletedDateHasBeenSet = false;
  bool m_nextRotationDateHasBeenSet = false;
  bool m_tagsHasBeenSet = false;
  bool m_versionIdsToStagesHasBeenSet = false;
  bool m_owningServiceHasBeenSet = false;
  bool m_createdDateHasBeenSet = false;
  bool m_primaryRegionHasBeenSet = false;
  bool m_replicationStatusHasBeenSet = false;
  bool m_requestIdHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace SecretsManager
}  // namespace Aws