OrganizationEventDetails.h

 
#pragma once
#include <aws/core/utils/memory/stl/AWSMap.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/health/Health_EXPORTS.h>
#include <aws/health/model/Event.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace Health {
namespace Model {
 
class OrganizationEventDetails {
 public:
  AWS_HEALTH_API OrganizationEventDetails() = default;
  AWS_HEALTH_API OrganizationEventDetails(Aws::Utils::Json::JsonView jsonValue);
  AWS_HEALTH_API OrganizationEventDetails& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_HEALTH_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const Aws::String& GetAwsAccountId() const { return m_awsAccountId; }
  inline bool AwsAccountIdHasBeenSet() const { return m_awsAccountIdHasBeenSet; }
  template <typename AwsAccountIdT = Aws::String>
  void SetAwsAccountId(AwsAccountIdT&& value) {
    m_awsAccountIdHasBeenSet = true;
    m_awsAccountId = std::forward<AwsAccountIdT>(value);
  }
  template <typename AwsAccountIdT = Aws::String>
  OrganizationEventDetails& WithAwsAccountId(AwsAccountIdT&& value) {
    SetAwsAccountId(std::forward<AwsAccountIdT>(value));
    return *this;
  }
 
 
  inline const Event& GetEvent() const { return m_event; }
  inline bool EventHasBeenSet() const { return m_eventHasBeenSet; }
  template <typename EventT = Event>
  void SetEvent(EventT&& value) {
    m_eventHasBeenSet = true;
    m_event = std::forward<EventT>(value);
  }
  template <typename EventT = Event>
  OrganizationEventDetails& WithEvent(EventT&& value) {
    SetEvent(std::forward<EventT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetEventDescription() const { return m_eventDescription; }
  inline bool EventDescriptionHasBeenSet() const { return m_eventDescriptionHasBeenSet; }
  template <typename EventDescriptionT = Aws::String>
  void SetEventDescription(EventDescriptionT&& value) {
    m_eventDescriptionHasBeenSet = true;
    m_eventDescription = std::forward<EventDescriptionT>(value);
  }
  template <typename EventDescriptionT = Aws::String>
  OrganizationEventDetails& WithEventDescription(EventDescriptionT&& value) {
    SetEventDescription(std::forward<EventDescriptionT>(value));
    return *this;
  }
 
 
  inline const Aws::Map<Aws::String, Aws::String>& GetEventMetadata() const { return m_eventMetadata; }
  inline bool EventMetadataHasBeenSet() const { return m_eventMetadataHasBeenSet; }
  template <typename EventMetadataT = Aws::Map<Aws::String, Aws::String>>
  void SetEventMetadata(EventMetadataT&& value) {
    m_eventMetadataHasBeenSet = true;
    m_eventMetadata = std::forward<EventMetadataT>(value);
  }
  template <typename EventMetadataT = Aws::Map<Aws::String, Aws::String>>
  OrganizationEventDetails& WithEventMetadata(EventMetadataT&& value) {
    SetEventMetadata(std::forward<EventMetadataT>(value));
    return *this;
  }
  template <typename EventMetadataKeyT = Aws::String, typename EventMetadataValueT = Aws::String>
  OrganizationEventDetails& AddEventMetadata(EventMetadataKeyT&& key, EventMetadataValueT&& value) {
    m_eventMetadataHasBeenSet = true;
    m_eventMetadata.emplace(std::forward<EventMetadataKeyT>(key), std::forward<EventMetadataValueT>(value));
    return *this;
  }
 private:
  Aws::String m_awsAccountId;
 
  Event m_event;
 
  Aws::String m_eventDescription;
 
  Aws::Map<Aws::String, Aws::String> m_eventMetadata;
  bool m_awsAccountIdHasBeenSet = false;
  bool m_eventHasBeenSet = false;
  bool m_eventDescriptionHasBeenSet = false;
  bool m_eventMetadataHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace Health
}  // namespace Aws