ReferenceSummary.h

 
#pragma once
#include <aws/connect/Connect_EXPORTS.h>
#include <aws/connect/model/AttachmentReference.h>
#include <aws/connect/model/DateReference.h>
#include <aws/connect/model/EmailMessageReference.h>
#include <aws/connect/model/EmailReference.h>
#include <aws/connect/model/NumberReference.h>
#include <aws/connect/model/StringReference.h>
#include <aws/connect/model/UrlReference.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace Connect {
namespace Model {
 
class ReferenceSummary {
 public:
  AWS_CONNECT_API ReferenceSummary() = default;
  AWS_CONNECT_API ReferenceSummary(Aws::Utils::Json::JsonView jsonValue);
  AWS_CONNECT_API ReferenceSummary& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_CONNECT_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const UrlReference& GetUrl() const { return m_url; }
  inline bool UrlHasBeenSet() const { return m_urlHasBeenSet; }
  template <typename UrlT = UrlReference>
  void SetUrl(UrlT&& value) {
    m_urlHasBeenSet = true;
    m_url = std::forward<UrlT>(value);
  }
  template <typename UrlT = UrlReference>
  ReferenceSummary& WithUrl(UrlT&& value) {
    SetUrl(std::forward<UrlT>(value));
    return *this;
  }
 
 
  inline const AttachmentReference& GetAttachment() const { return m_attachment; }
  inline bool AttachmentHasBeenSet() const { return m_attachmentHasBeenSet; }
  template <typename AttachmentT = AttachmentReference>
  void SetAttachment(AttachmentT&& value) {
    m_attachmentHasBeenSet = true;
    m_attachment = std::forward<AttachmentT>(value);
  }
  template <typename AttachmentT = AttachmentReference>
  ReferenceSummary& WithAttachment(AttachmentT&& value) {
    SetAttachment(std::forward<AttachmentT>(value));
    return *this;
  }
 
 
  inline const EmailMessageReference& GetEmailMessage() const { return m_emailMessage; }
  inline bool EmailMessageHasBeenSet() const { return m_emailMessageHasBeenSet; }
  template <typename EmailMessageT = EmailMessageReference>
  void SetEmailMessage(EmailMessageT&& value) {
    m_emailMessageHasBeenSet = true;
    m_emailMessage = std::forward<EmailMessageT>(value);
  }
  template <typename EmailMessageT = EmailMessageReference>
  ReferenceSummary& WithEmailMessage(EmailMessageT&& value) {
    SetEmailMessage(std::forward<EmailMessageT>(value));
    return *this;
  }
 
 
  inline const EmailMessageReference& GetEmailMessageRedacted() const { return m_emailMessageRedacted; }
  inline bool EmailMessageRedactedHasBeenSet() const { return m_emailMessageRedactedHasBeenSet; }
  template <typename EmailMessageRedactedT = EmailMessageReference>
  void SetEmailMessageRedacted(EmailMessageRedactedT&& value) {
    m_emailMessageRedactedHasBeenSet = true;
    m_emailMessageRedacted = std::forward<EmailMessageRedactedT>(value);
  }
  template <typename EmailMessageRedactedT = EmailMessageReference>
  ReferenceSummary& WithEmailMessageRedacted(EmailMessageRedactedT&& value) {
    SetEmailMessageRedacted(std::forward<EmailMessageRedactedT>(value));
    return *this;
  }
 
 
  inline const EmailMessageReference& GetEmailMessagePlainText() const { return m_emailMessagePlainText; }
  inline bool EmailMessagePlainTextHasBeenSet() const { return m_emailMessagePlainTextHasBeenSet; }
  template <typename EmailMessagePlainTextT = EmailMessageReference>
  void SetEmailMessagePlainText(EmailMessagePlainTextT&& value) {
    m_emailMessagePlainTextHasBeenSet = true;
    m_emailMessagePlainText = std::forward<EmailMessagePlainTextT>(value);
  }
  template <typename EmailMessagePlainTextT = EmailMessageReference>
  ReferenceSummary& WithEmailMessagePlainText(EmailMessagePlainTextT&& value) {
    SetEmailMessagePlainText(std::forward<EmailMessagePlainTextT>(value));
    return *this;
  }
 
 
  inline const EmailMessageReference& GetEmailMessagePlainTextRedacted() const { return m_emailMessagePlainTextRedacted; }
  inline bool EmailMessagePlainTextRedactedHasBeenSet() const { return m_emailMessagePlainTextRedactedHasBeenSet; }
  template <typename EmailMessagePlainTextRedactedT = EmailMessageReference>
  void SetEmailMessagePlainTextRedacted(EmailMessagePlainTextRedactedT&& value) {
    m_emailMessagePlainTextRedactedHasBeenSet = true;
    m_emailMessagePlainTextRedacted = std::forward<EmailMessagePlainTextRedactedT>(value);
  }
  template <typename EmailMessagePlainTextRedactedT = EmailMessageReference>
  ReferenceSummary& WithEmailMessagePlainTextRedacted(EmailMessagePlainTextRedactedT&& value) {
    SetEmailMessagePlainTextRedacted(std::forward<EmailMessagePlainTextRedactedT>(value));
    return *this;
  }
 
 
  inline const StringReference& GetString() const { return m_string; }
  inline bool StringHasBeenSet() const { return m_stringHasBeenSet; }
  template <typename StringT = StringReference>
  void SetString(StringT&& value) {
    m_stringHasBeenSet = true;
    m_string = std::forward<StringT>(value);
  }
  template <typename StringT = StringReference>
  ReferenceSummary& WithString(StringT&& value) {
    SetString(std::forward<StringT>(value));
    return *this;
  }
 
 
  inline const NumberReference& GetNumber() const { return m_number; }
  inline bool NumberHasBeenSet() const { return m_numberHasBeenSet; }
  template <typename NumberT = NumberReference>
  void SetNumber(NumberT&& value) {
    m_numberHasBeenSet = true;
    m_number = std::forward<NumberT>(value);
  }
  template <typename NumberT = NumberReference>
  ReferenceSummary& WithNumber(NumberT&& value) {
    SetNumber(std::forward<NumberT>(value));
    return *this;
  }
 
 
  inline const DateReference& GetDate() const { return m_date; }
  inline bool DateHasBeenSet() const { return m_dateHasBeenSet; }
  template <typename DateT = DateReference>
  void SetDate(DateT&& value) {
    m_dateHasBeenSet = true;
    m_date = std::forward<DateT>(value);
  }
  template <typename DateT = DateReference>
  ReferenceSummary& WithDate(DateT&& value) {
    SetDate(std::forward<DateT>(value));
    return *this;
  }
 
 
  inline const EmailReference& GetEmail() const { return m_email; }
  inline bool EmailHasBeenSet() const { return m_emailHasBeenSet; }
  template <typename EmailT = EmailReference>
  void SetEmail(EmailT&& value) {
    m_emailHasBeenSet = true;
    m_email = std::forward<EmailT>(value);
  }
  template <typename EmailT = EmailReference>
  ReferenceSummary& WithEmail(EmailT&& value) {
    SetEmail(std::forward<EmailT>(value));
    return *this;
  }
 private:
  UrlReference m_url;
 
  AttachmentReference m_attachment;
 
  EmailMessageReference m_emailMessage;
 
  EmailMessageReference m_emailMessageRedacted;
 
  EmailMessageReference m_emailMessagePlainText;
 
  EmailMessageReference m_emailMessagePlainTextRedacted;
 
  StringReference m_string;
 
  NumberReference m_number;
 
  DateReference m_date;
 
  EmailReference m_email;
  bool m_urlHasBeenSet = false;
  bool m_attachmentHasBeenSet = false;
  bool m_emailMessageHasBeenSet = false;
  bool m_emailMessageRedactedHasBeenSet = false;
  bool m_emailMessagePlainTextHasBeenSet = false;
  bool m_emailMessagePlainTextRedactedHasBeenSet = false;
  bool m_stringHasBeenSet = false;
  bool m_numberHasBeenSet = false;
  bool m_dateHasBeenSet = false;
  bool m_emailHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace Connect
}  // namespace Aws