Document.h

 
#pragma once
#include <aws/core/utils/Array.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/kendra/Kendra_EXPORTS.h>
#include <aws/kendra/model/ContentType.h>
#include <aws/kendra/model/DocumentAttribute.h>
#include <aws/kendra/model/HierarchicalPrincipal.h>
#include <aws/kendra/model/Principal.h>
#include <aws/kendra/model/S3Path.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace kendra {
namespace Model {
 
class Document {
 public:
  AWS_KENDRA_API Document() = default;
  AWS_KENDRA_API Document(Aws::Utils::Json::JsonView jsonValue);
  AWS_KENDRA_API Document& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_KENDRA_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const Aws::String& GetId() const { return m_id; }
  inline bool IdHasBeenSet() const { return m_idHasBeenSet; }
  template <typename IdT = Aws::String>
  void SetId(IdT&& value) {
    m_idHasBeenSet = true;
    m_id = std::forward<IdT>(value);
  }
  template <typename IdT = Aws::String>
  Document& WithId(IdT&& value) {
    SetId(std::forward<IdT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetTitle() const { return m_title; }
  inline bool TitleHasBeenSet() const { return m_titleHasBeenSet; }
  template <typename TitleT = Aws::String>
  void SetTitle(TitleT&& value) {
    m_titleHasBeenSet = true;
    m_title = std::forward<TitleT>(value);
  }
  template <typename TitleT = Aws::String>
  Document& WithTitle(TitleT&& value) {
    SetTitle(std::forward<TitleT>(value));
    return *this;
  }
 
 
  inline const Aws::Utils::ByteBuffer& GetBlob() const { return m_blob; }
  inline bool BlobHasBeenSet() const { return m_blobHasBeenSet; }
  template <typename BlobT = Aws::Utils::ByteBuffer>
  void SetBlob(BlobT&& value) {
    m_blobHasBeenSet = true;
    m_blob = std::forward<BlobT>(value);
  }
  template <typename BlobT = Aws::Utils::ByteBuffer>
  Document& WithBlob(BlobT&& value) {
    SetBlob(std::forward<BlobT>(value));
    return *this;
  }
 
 
  inline const S3Path& GetS3Path() const { return m_s3Path; }
  inline bool S3PathHasBeenSet() const { return m_s3PathHasBeenSet; }
  template <typename S3PathT = S3Path>
  void SetS3Path(S3PathT&& value) {
    m_s3PathHasBeenSet = true;
    m_s3Path = std::forward<S3PathT>(value);
  }
  template <typename S3PathT = S3Path>
  Document& WithS3Path(S3PathT&& value) {
    SetS3Path(std::forward<S3PathT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<DocumentAttribute>& GetAttributes() const { return m_attributes; }
  inline bool AttributesHasBeenSet() const { return m_attributesHasBeenSet; }
  template <typename AttributesT = Aws::Vector<DocumentAttribute>>
  void SetAttributes(AttributesT&& value) {
    m_attributesHasBeenSet = true;
    m_attributes = std::forward<AttributesT>(value);
  }
  template <typename AttributesT = Aws::Vector<DocumentAttribute>>
  Document& WithAttributes(AttributesT&& value) {
    SetAttributes(std::forward<AttributesT>(value));
    return *this;
  }
  template <typename AttributesT = DocumentAttribute>
  Document& AddAttributes(AttributesT&& value) {
    m_attributesHasBeenSet = true;
    m_attributes.emplace_back(std::forward<AttributesT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<Principal>& GetAccessControlList() const { return m_accessControlList; }
  inline bool AccessControlListHasBeenSet() const { return m_accessControlListHasBeenSet; }
  template <typename AccessControlListT = Aws::Vector<Principal>>
  void SetAccessControlList(AccessControlListT&& value) {
    m_accessControlListHasBeenSet = true;
    m_accessControlList = std::forward<AccessControlListT>(value);
  }
  template <typename AccessControlListT = Aws::Vector<Principal>>
  Document& WithAccessControlList(AccessControlListT&& value) {
    SetAccessControlList(std::forward<AccessControlListT>(value));
    return *this;
  }
  template <typename AccessControlListT = Principal>
  Document& AddAccessControlList(AccessControlListT&& value) {
    m_accessControlListHasBeenSet = true;
    m_accessControlList.emplace_back(std::forward<AccessControlListT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<HierarchicalPrincipal>& GetHierarchicalAccessControlList() const { return m_hierarchicalAccessControlList; }
  inline bool HierarchicalAccessControlListHasBeenSet() const { return m_hierarchicalAccessControlListHasBeenSet; }
  template <typename HierarchicalAccessControlListT = Aws::Vector<HierarchicalPrincipal>>
  void SetHierarchicalAccessControlList(HierarchicalAccessControlListT&& value) {
    m_hierarchicalAccessControlListHasBeenSet = true;
    m_hierarchicalAccessControlList = std::forward<HierarchicalAccessControlListT>(value);
  }
  template <typename HierarchicalAccessControlListT = Aws::Vector<HierarchicalPrincipal>>
  Document& WithHierarchicalAccessControlList(HierarchicalAccessControlListT&& value) {
    SetHierarchicalAccessControlList(std::forward<HierarchicalAccessControlListT>(value));
    return *this;
  }
  template <typename HierarchicalAccessControlListT = HierarchicalPrincipal>
  Document& AddHierarchicalAccessControlList(HierarchicalAccessControlListT&& value) {
    m_hierarchicalAccessControlListHasBeenSet = true;
    m_hierarchicalAccessControlList.emplace_back(std::forward<HierarchicalAccessControlListT>(value));
    return *this;
  }
 
 
  inline ContentType GetContentType() const { return m_contentType; }
  inline bool ContentTypeHasBeenSet() const { return m_contentTypeHasBeenSet; }
  inline void SetContentType(ContentType value) {
    m_contentTypeHasBeenSet = true;
    m_contentType = value;
  }
  inline Document& WithContentType(ContentType value) {
    SetContentType(value);
    return *this;
  }
 
 
  inline const Aws::String& GetAccessControlConfigurationId() const { return m_accessControlConfigurationId; }
  inline bool AccessControlConfigurationIdHasBeenSet() const { return m_accessControlConfigurationIdHasBeenSet; }
  template <typename AccessControlConfigurationIdT = Aws::String>
  void SetAccessControlConfigurationId(AccessControlConfigurationIdT&& value) {
    m_accessControlConfigurationIdHasBeenSet = true;
    m_accessControlConfigurationId = std::forward<AccessControlConfigurationIdT>(value);
  }
  template <typename AccessControlConfigurationIdT = Aws::String>
  Document& WithAccessControlConfigurationId(AccessControlConfigurationIdT&& value) {
    SetAccessControlConfigurationId(std::forward<AccessControlConfigurationIdT>(value));
    return *this;
  }
 private:
  Aws::String m_id;
 
  Aws::String m_title;
 
  Aws::Utils::ByteBuffer m_blob{};
 
  S3Path m_s3Path;
 
  Aws::Vector<DocumentAttribute> m_attributes;
 
  Aws::Vector<Principal> m_accessControlList;
 
  Aws::Vector<HierarchicalPrincipal> m_hierarchicalAccessControlList;
 
  ContentType m_contentType{ContentType::NOT_SET};
 
  Aws::String m_accessControlConfigurationId;
  bool m_idHasBeenSet = false;
  bool m_titleHasBeenSet = false;
  bool m_blobHasBeenSet = false;
  bool m_s3PathHasBeenSet = false;
  bool m_attributesHasBeenSet = false;
  bool m_accessControlListHasBeenSet = false;
  bool m_hierarchicalAccessControlListHasBeenSet = false;
  bool m_contentTypeHasBeenSet = false;
  bool m_accessControlConfigurationIdHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace kendra
}  // namespace Aws