DocumentDescription.h

 
#pragma once
#include <aws/core/utils/DateTime.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/ssm/SSM_EXPORTS.h>
#include <aws/ssm/model/AttachmentInformation.h>
#include <aws/ssm/model/DocumentFormat.h>
#include <aws/ssm/model/DocumentHashType.h>
#include <aws/ssm/model/DocumentParameter.h>
#include <aws/ssm/model/DocumentRequires.h>
#include <aws/ssm/model/DocumentStatus.h>
#include <aws/ssm/model/DocumentType.h>
#include <aws/ssm/model/PlatformType.h>
#include <aws/ssm/model/ReviewInformation.h>
#include <aws/ssm/model/ReviewStatus.h>
#include <aws/ssm/model/Tag.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace SSM {
namespace Model {
 
class DocumentDescription {
 public:
  AWS_SSM_API DocumentDescription() = default;
  AWS_SSM_API DocumentDescription(Aws::Utils::Json::JsonView jsonValue);
  AWS_SSM_API DocumentDescription& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_SSM_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const Aws::String& GetSha1() const { return m_sha1; }
  inline bool Sha1HasBeenSet() const { return m_sha1HasBeenSet; }
  template <typename Sha1T = Aws::String>
  void SetSha1(Sha1T&& value) {
    m_sha1HasBeenSet = true;
    m_sha1 = std::forward<Sha1T>(value);
  }
  template <typename Sha1T = Aws::String>
  DocumentDescription& WithSha1(Sha1T&& value) {
    SetSha1(std::forward<Sha1T>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetHash() const { return m_hash; }
  inline bool HashHasBeenSet() const { return m_hashHasBeenSet; }
  template <typename HashT = Aws::String>
  void SetHash(HashT&& value) {
    m_hashHasBeenSet = true;
    m_hash = std::forward<HashT>(value);
  }
  template <typename HashT = Aws::String>
  DocumentDescription& WithHash(HashT&& value) {
    SetHash(std::forward<HashT>(value));
    return *this;
  }
 
 
  inline DocumentHashType GetHashType() const { return m_hashType; }
  inline bool HashTypeHasBeenSet() const { return m_hashTypeHasBeenSet; }
  inline void SetHashType(DocumentHashType value) {
    m_hashTypeHasBeenSet = true;
    m_hashType = value;
  }
  inline DocumentDescription& WithHashType(DocumentHashType value) {
    SetHashType(value);
    return *this;
  }
 
 
  inline const Aws::String& GetName() const { return m_name; }
  inline bool NameHasBeenSet() const { return m_nameHasBeenSet; }
  template <typename NameT = Aws::String>
  void SetName(NameT&& value) {
    m_nameHasBeenSet = true;
    m_name = std::forward<NameT>(value);
  }
  template <typename NameT = Aws::String>
  DocumentDescription& WithName(NameT&& value) {
    SetName(std::forward<NameT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetDisplayName() const { return m_displayName; }
  inline bool DisplayNameHasBeenSet() const { return m_displayNameHasBeenSet; }
  template <typename DisplayNameT = Aws::String>
  void SetDisplayName(DisplayNameT&& value) {
    m_displayNameHasBeenSet = true;
    m_displayName = std::forward<DisplayNameT>(value);
  }
  template <typename DisplayNameT = Aws::String>
  DocumentDescription& WithDisplayName(DisplayNameT&& value) {
    SetDisplayName(std::forward<DisplayNameT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetVersionName() const { return m_versionName; }
  inline bool VersionNameHasBeenSet() const { return m_versionNameHasBeenSet; }
  template <typename VersionNameT = Aws::String>
  void SetVersionName(VersionNameT&& value) {
    m_versionNameHasBeenSet = true;
    m_versionName = std::forward<VersionNameT>(value);
  }
  template <typename VersionNameT = Aws::String>
  DocumentDescription& WithVersionName(VersionNameT&& value) {
    SetVersionName(std::forward<VersionNameT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetOwner() const { return m_owner; }
  inline bool OwnerHasBeenSet() const { return m_ownerHasBeenSet; }
  template <typename OwnerT = Aws::String>
  void SetOwner(OwnerT&& value) {
    m_ownerHasBeenSet = true;
    m_owner = std::forward<OwnerT>(value);
  }
  template <typename OwnerT = Aws::String>
  DocumentDescription& WithOwner(OwnerT&& value) {
    SetOwner(std::forward<OwnerT>(value));
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetCreatedDate() const { return m_createdDate; }
  inline bool CreatedDateHasBeenSet() const { return m_createdDateHasBeenSet; }
  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>
  DocumentDescription& WithCreatedDate(CreatedDateT&& value) {
    SetCreatedDate(std::forward<CreatedDateT>(value));
    return *this;
  }
 
 
  inline DocumentStatus GetStatus() const { return m_status; }
  inline bool StatusHasBeenSet() const { return m_statusHasBeenSet; }
  inline void SetStatus(DocumentStatus value) {
    m_statusHasBeenSet = true;
    m_status = value;
  }
  inline DocumentDescription& WithStatus(DocumentStatus value) {
    SetStatus(value);
    return *this;
  }
 
 
  inline const Aws::String& GetStatusInformation() const { return m_statusInformation; }
  inline bool StatusInformationHasBeenSet() const { return m_statusInformationHasBeenSet; }
  template <typename StatusInformationT = Aws::String>
  void SetStatusInformation(StatusInformationT&& value) {
    m_statusInformationHasBeenSet = true;
    m_statusInformation = std::forward<StatusInformationT>(value);
  }
  template <typename StatusInformationT = Aws::String>
  DocumentDescription& WithStatusInformation(StatusInformationT&& value) {
    SetStatusInformation(std::forward<StatusInformationT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetDocumentVersion() const { return m_documentVersion; }
  inline bool DocumentVersionHasBeenSet() const { return m_documentVersionHasBeenSet; }
  template <typename DocumentVersionT = Aws::String>
  void SetDocumentVersion(DocumentVersionT&& value) {
    m_documentVersionHasBeenSet = true;
    m_documentVersion = std::forward<DocumentVersionT>(value);
  }
  template <typename DocumentVersionT = Aws::String>
  DocumentDescription& WithDocumentVersion(DocumentVersionT&& value) {
    SetDocumentVersion(std::forward<DocumentVersionT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetDescription() const { return m_description; }
  inline bool DescriptionHasBeenSet() const { return m_descriptionHasBeenSet; }
  template <typename DescriptionT = Aws::String>
  void SetDescription(DescriptionT&& value) {
    m_descriptionHasBeenSet = true;
    m_description = std::forward<DescriptionT>(value);
  }
  template <typename DescriptionT = Aws::String>
  DocumentDescription& WithDescription(DescriptionT&& value) {
    SetDescription(std::forward<DescriptionT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<DocumentParameter>& GetParameters() const { return m_parameters; }
  inline bool ParametersHasBeenSet() const { return m_parametersHasBeenSet; }
  template <typename ParametersT = Aws::Vector<DocumentParameter>>
  void SetParameters(ParametersT&& value) {
    m_parametersHasBeenSet = true;
    m_parameters = std::forward<ParametersT>(value);
  }
  template <typename ParametersT = Aws::Vector<DocumentParameter>>
  DocumentDescription& WithParameters(ParametersT&& value) {
    SetParameters(std::forward<ParametersT>(value));
    return *this;
  }
  template <typename ParametersT = DocumentParameter>
  DocumentDescription& AddParameters(ParametersT&& value) {
    m_parametersHasBeenSet = true;
    m_parameters.emplace_back(std::forward<ParametersT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<PlatformType>& GetPlatformTypes() const { return m_platformTypes; }
  inline bool PlatformTypesHasBeenSet() const { return m_platformTypesHasBeenSet; }
  template <typename PlatformTypesT = Aws::Vector<PlatformType>>
  void SetPlatformTypes(PlatformTypesT&& value) {
    m_platformTypesHasBeenSet = true;
    m_platformTypes = std::forward<PlatformTypesT>(value);
  }
  template <typename PlatformTypesT = Aws::Vector<PlatformType>>
  DocumentDescription& WithPlatformTypes(PlatformTypesT&& value) {
    SetPlatformTypes(std::forward<PlatformTypesT>(value));
    return *this;
  }
  inline DocumentDescription& AddPlatformTypes(PlatformType value) {
    m_platformTypesHasBeenSet = true;
    m_platformTypes.push_back(value);
    return *this;
  }
 
 
  inline DocumentType GetDocumentType() const { return m_documentType; }
  inline bool DocumentTypeHasBeenSet() const { return m_documentTypeHasBeenSet; }
  inline void SetDocumentType(DocumentType value) {
    m_documentTypeHasBeenSet = true;
    m_documentType = value;
  }
  inline DocumentDescription& WithDocumentType(DocumentType value) {
    SetDocumentType(value);
    return *this;
  }
 
 
  inline const Aws::String& GetSchemaVersion() const { return m_schemaVersion; }
  inline bool SchemaVersionHasBeenSet() const { return m_schemaVersionHasBeenSet; }
  template <typename SchemaVersionT = Aws::String>
  void SetSchemaVersion(SchemaVersionT&& value) {
    m_schemaVersionHasBeenSet = true;
    m_schemaVersion = std::forward<SchemaVersionT>(value);
  }
  template <typename SchemaVersionT = Aws::String>
  DocumentDescription& WithSchemaVersion(SchemaVersionT&& value) {
    SetSchemaVersion(std::forward<SchemaVersionT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetLatestVersion() const { return m_latestVersion; }
  inline bool LatestVersionHasBeenSet() const { return m_latestVersionHasBeenSet; }
  template <typename LatestVersionT = Aws::String>
  void SetLatestVersion(LatestVersionT&& value) {
    m_latestVersionHasBeenSet = true;
    m_latestVersion = std::forward<LatestVersionT>(value);
  }
  template <typename LatestVersionT = Aws::String>
  DocumentDescription& WithLatestVersion(LatestVersionT&& value) {
    SetLatestVersion(std::forward<LatestVersionT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetDefaultVersion() const { return m_defaultVersion; }
  inline bool DefaultVersionHasBeenSet() const { return m_defaultVersionHasBeenSet; }
  template <typename DefaultVersionT = Aws::String>
  void SetDefaultVersion(DefaultVersionT&& value) {
    m_defaultVersionHasBeenSet = true;
    m_defaultVersion = std::forward<DefaultVersionT>(value);
  }
  template <typename DefaultVersionT = Aws::String>
  DocumentDescription& WithDefaultVersion(DefaultVersionT&& value) {
    SetDefaultVersion(std::forward<DefaultVersionT>(value));
    return *this;
  }
 
 
  inline DocumentFormat GetDocumentFormat() const { return m_documentFormat; }
  inline bool DocumentFormatHasBeenSet() const { return m_documentFormatHasBeenSet; }
  inline void SetDocumentFormat(DocumentFormat value) {
    m_documentFormatHasBeenSet = true;
    m_documentFormat = value;
  }
  inline DocumentDescription& WithDocumentFormat(DocumentFormat value) {
    SetDocumentFormat(value);
    return *this;
  }
 
 
  inline const Aws::String& GetTargetType() const { return m_targetType; }
  inline bool TargetTypeHasBeenSet() const { return m_targetTypeHasBeenSet; }
  template <typename TargetTypeT = Aws::String>
  void SetTargetType(TargetTypeT&& value) {
    m_targetTypeHasBeenSet = true;
    m_targetType = std::forward<TargetTypeT>(value);
  }
  template <typename TargetTypeT = Aws::String>
  DocumentDescription& WithTargetType(TargetTypeT&& value) {
    SetTargetType(std::forward<TargetTypeT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<Tag>& GetTags() const { return m_tags; }
  inline bool TagsHasBeenSet() const { return m_tagsHasBeenSet; }
  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>>
  DocumentDescription& WithTags(TagsT&& value) {
    SetTags(std::forward<TagsT>(value));
    return *this;
  }
  template <typename TagsT = Tag>
  DocumentDescription& AddTags(TagsT&& value) {
    m_tagsHasBeenSet = true;
    m_tags.emplace_back(std::forward<TagsT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<AttachmentInformation>& GetAttachmentsInformation() const { return m_attachmentsInformation; }
  inline bool AttachmentsInformationHasBeenSet() const { return m_attachmentsInformationHasBeenSet; }
  template <typename AttachmentsInformationT = Aws::Vector<AttachmentInformation>>
  void SetAttachmentsInformation(AttachmentsInformationT&& value) {
    m_attachmentsInformationHasBeenSet = true;
    m_attachmentsInformation = std::forward<AttachmentsInformationT>(value);
  }
  template <typename AttachmentsInformationT = Aws::Vector<AttachmentInformation>>
  DocumentDescription& WithAttachmentsInformation(AttachmentsInformationT&& value) {
    SetAttachmentsInformation(std::forward<AttachmentsInformationT>(value));
    return *this;
  }
  template <typename AttachmentsInformationT = AttachmentInformation>
  DocumentDescription& AddAttachmentsInformation(AttachmentsInformationT&& value) {
    m_attachmentsInformationHasBeenSet = true;
    m_attachmentsInformation.emplace_back(std::forward<AttachmentsInformationT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<DocumentRequires>& GetRequires() const { return m_requires; }
  inline bool RequiresHasBeenSet() const { return m_requiresHasBeenSet; }
  template <typename RequiresT = Aws::Vector<DocumentRequires>>
  void SetRequires(RequiresT&& value) {
    m_requiresHasBeenSet = true;
    m_requires = std::forward<RequiresT>(value);
  }
  template <typename RequiresT = Aws::Vector<DocumentRequires>>
  DocumentDescription& WithRequires(RequiresT&& value) {
    SetRequires(std::forward<RequiresT>(value));
    return *this;
  }
  template <typename RequiresT = DocumentRequires>
  DocumentDescription& AddRequires(RequiresT&& value) {
    m_requiresHasBeenSet = true;
    m_requires.emplace_back(std::forward<RequiresT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetAuthor() const { return m_author; }
  inline bool AuthorHasBeenSet() const { return m_authorHasBeenSet; }
  template <typename AuthorT = Aws::String>
  void SetAuthor(AuthorT&& value) {
    m_authorHasBeenSet = true;
    m_author = std::forward<AuthorT>(value);
  }
  template <typename AuthorT = Aws::String>
  DocumentDescription& WithAuthor(AuthorT&& value) {
    SetAuthor(std::forward<AuthorT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<ReviewInformation>& GetReviewInformation() const { return m_reviewInformation; }
  inline bool ReviewInformationHasBeenSet() const { return m_reviewInformationHasBeenSet; }
  template <typename ReviewInformationT = Aws::Vector<ReviewInformation>>
  void SetReviewInformation(ReviewInformationT&& value) {
    m_reviewInformationHasBeenSet = true;
    m_reviewInformation = std::forward<ReviewInformationT>(value);
  }
  template <typename ReviewInformationT = Aws::Vector<ReviewInformation>>
  DocumentDescription& WithReviewInformation(ReviewInformationT&& value) {
    SetReviewInformation(std::forward<ReviewInformationT>(value));
    return *this;
  }
  template <typename ReviewInformationT = ReviewInformation>
  DocumentDescription& AddReviewInformation(ReviewInformationT&& value) {
    m_reviewInformationHasBeenSet = true;
    m_reviewInformation.emplace_back(std::forward<ReviewInformationT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetApprovedVersion() const { return m_approvedVersion; }
  inline bool ApprovedVersionHasBeenSet() const { return m_approvedVersionHasBeenSet; }
  template <typename ApprovedVersionT = Aws::String>
  void SetApprovedVersion(ApprovedVersionT&& value) {
    m_approvedVersionHasBeenSet = true;
    m_approvedVersion = std::forward<ApprovedVersionT>(value);
  }
  template <typename ApprovedVersionT = Aws::String>
  DocumentDescription& WithApprovedVersion(ApprovedVersionT&& value) {
    SetApprovedVersion(std::forward<ApprovedVersionT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetPendingReviewVersion() const { return m_pendingReviewVersion; }
  inline bool PendingReviewVersionHasBeenSet() const { return m_pendingReviewVersionHasBeenSet; }
  template <typename PendingReviewVersionT = Aws::String>
  void SetPendingReviewVersion(PendingReviewVersionT&& value) {
    m_pendingReviewVersionHasBeenSet = true;
    m_pendingReviewVersion = std::forward<PendingReviewVersionT>(value);
  }
  template <typename PendingReviewVersionT = Aws::String>
  DocumentDescription& WithPendingReviewVersion(PendingReviewVersionT&& value) {
    SetPendingReviewVersion(std::forward<PendingReviewVersionT>(value));
    return *this;
  }
 
 
  inline ReviewStatus GetReviewStatus() const { return m_reviewStatus; }
  inline bool ReviewStatusHasBeenSet() const { return m_reviewStatusHasBeenSet; }
  inline void SetReviewStatus(ReviewStatus value) {
    m_reviewStatusHasBeenSet = true;
    m_reviewStatus = value;
  }
  inline DocumentDescription& WithReviewStatus(ReviewStatus value) {
    SetReviewStatus(value);
    return *this;
  }
 
 
  inline const Aws::Vector<Aws::String>& GetCategory() const { return m_category; }
  inline bool CategoryHasBeenSet() const { return m_categoryHasBeenSet; }
  template <typename CategoryT = Aws::Vector<Aws::String>>
  void SetCategory(CategoryT&& value) {
    m_categoryHasBeenSet = true;
    m_category = std::forward<CategoryT>(value);
  }
  template <typename CategoryT = Aws::Vector<Aws::String>>
  DocumentDescription& WithCategory(CategoryT&& value) {
    SetCategory(std::forward<CategoryT>(value));
    return *this;
  }
  template <typename CategoryT = Aws::String>
  DocumentDescription& AddCategory(CategoryT&& value) {
    m_categoryHasBeenSet = true;
    m_category.emplace_back(std::forward<CategoryT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<Aws::String>& GetCategoryEnum() const { return m_categoryEnum; }
  inline bool CategoryEnumHasBeenSet() const { return m_categoryEnumHasBeenSet; }
  template <typename CategoryEnumT = Aws::Vector<Aws::String>>
  void SetCategoryEnum(CategoryEnumT&& value) {
    m_categoryEnumHasBeenSet = true;
    m_categoryEnum = std::forward<CategoryEnumT>(value);
  }
  template <typename CategoryEnumT = Aws::Vector<Aws::String>>
  DocumentDescription& WithCategoryEnum(CategoryEnumT&& value) {
    SetCategoryEnum(std::forward<CategoryEnumT>(value));
    return *this;
  }
  template <typename CategoryEnumT = Aws::String>
  DocumentDescription& AddCategoryEnum(CategoryEnumT&& value) {
    m_categoryEnumHasBeenSet = true;
    m_categoryEnum.emplace_back(std::forward<CategoryEnumT>(value));
    return *this;
  }
 private:
  Aws::String m_sha1;
 
  Aws::String m_hash;
 
  DocumentHashType m_hashType{DocumentHashType::NOT_SET};
 
  Aws::String m_name;
 
  Aws::String m_displayName;
 
  Aws::String m_versionName;
 
  Aws::String m_owner;
 
  Aws::Utils::DateTime m_createdDate{};
 
  DocumentStatus m_status{DocumentStatus::NOT_SET};
 
  Aws::String m_statusInformation;
 
  Aws::String m_documentVersion;
 
  Aws::String m_description;
 
  Aws::Vector<DocumentParameter> m_parameters;
 
  Aws::Vector<PlatformType> m_platformTypes;
 
  DocumentType m_documentType{DocumentType::NOT_SET};
 
  Aws::String m_schemaVersion;
 
  Aws::String m_latestVersion;
 
  Aws::String m_defaultVersion;
 
  DocumentFormat m_documentFormat{DocumentFormat::NOT_SET};
 
  Aws::String m_targetType;
 
  Aws::Vector<Tag> m_tags;
 
  Aws::Vector<AttachmentInformation> m_attachmentsInformation;
 
  Aws::Vector<DocumentRequires> m_requires;
 
  Aws::String m_author;
 
  Aws::Vector<ReviewInformation> m_reviewInformation;
 
  Aws::String m_approvedVersion;
 
  Aws::String m_pendingReviewVersion;
 
  ReviewStatus m_reviewStatus{ReviewStatus::NOT_SET};
 
  Aws::Vector<Aws::String> m_category;
 
  Aws::Vector<Aws::String> m_categoryEnum;
  bool m_sha1HasBeenSet = false;
  bool m_hashHasBeenSet = false;
  bool m_hashTypeHasBeenSet = false;
  bool m_nameHasBeenSet = false;
  bool m_displayNameHasBeenSet = false;
  bool m_versionNameHasBeenSet = false;
  bool m_ownerHasBeenSet = false;
  bool m_createdDateHasBeenSet = false;
  bool m_statusHasBeenSet = false;
  bool m_statusInformationHasBeenSet = false;
  bool m_documentVersionHasBeenSet = false;
  bool m_descriptionHasBeenSet = false;
  bool m_parametersHasBeenSet = false;
  bool m_platformTypesHasBeenSet = false;
  bool m_documentTypeHasBeenSet = false;
  bool m_schemaVersionHasBeenSet = false;
  bool m_latestVersionHasBeenSet = false;
  bool m_defaultVersionHasBeenSet = false;
  bool m_documentFormatHasBeenSet = false;
  bool m_targetTypeHasBeenSet = false;
  bool m_tagsHasBeenSet = false;
  bool m_attachmentsInformationHasBeenSet = false;
  bool m_requiresHasBeenSet = false;
  bool m_authorHasBeenSet = false;
  bool m_reviewInformationHasBeenSet = false;
  bool m_approvedVersionHasBeenSet = false;
  bool m_pendingReviewVersionHasBeenSet = false;
  bool m_reviewStatusHasBeenSet = false;
  bool m_categoryHasBeenSet = false;
  bool m_categoryEnumHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace SSM
}  // namespace Aws