OrganizationEvent.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/health/Health_EXPORTS.h>
#include <aws/health/model/EventActionability.h>
#include <aws/health/model/EventPersona.h>
#include <aws/health/model/EventScopeCode.h>
#include <aws/health/model/EventStatusCode.h>
#include <aws/health/model/EventTypeCategory.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace Health {
namespace Model {
 
class OrganizationEvent {
 public:
  AWS_HEALTH_API OrganizationEvent() = default;
  AWS_HEALTH_API OrganizationEvent(Aws::Utils::Json::JsonView jsonValue);
  AWS_HEALTH_API OrganizationEvent& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_HEALTH_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const Aws::String& GetArn() const { return m_arn; }
  inline bool ArnHasBeenSet() const { return m_arnHasBeenSet; }
  template <typename ArnT = Aws::String>
  void SetArn(ArnT&& value) {
    m_arnHasBeenSet = true;
    m_arn = std::forward<ArnT>(value);
  }
  template <typename ArnT = Aws::String>
  OrganizationEvent& WithArn(ArnT&& value) {
    SetArn(std::forward<ArnT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetService() const { return m_service; }
  inline bool ServiceHasBeenSet() const { return m_serviceHasBeenSet; }
  template <typename ServiceT = Aws::String>
  void SetService(ServiceT&& value) {
    m_serviceHasBeenSet = true;
    m_service = std::forward<ServiceT>(value);
  }
  template <typename ServiceT = Aws::String>
  OrganizationEvent& WithService(ServiceT&& value) {
    SetService(std::forward<ServiceT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetEventTypeCode() const { return m_eventTypeCode; }
  inline bool EventTypeCodeHasBeenSet() const { return m_eventTypeCodeHasBeenSet; }
  template <typename EventTypeCodeT = Aws::String>
  void SetEventTypeCode(EventTypeCodeT&& value) {
    m_eventTypeCodeHasBeenSet = true;
    m_eventTypeCode = std::forward<EventTypeCodeT>(value);
  }
  template <typename EventTypeCodeT = Aws::String>
  OrganizationEvent& WithEventTypeCode(EventTypeCodeT&& value) {
    SetEventTypeCode(std::forward<EventTypeCodeT>(value));
    return *this;
  }
 
 
  inline EventTypeCategory GetEventTypeCategory() const { return m_eventTypeCategory; }
  inline bool EventTypeCategoryHasBeenSet() const { return m_eventTypeCategoryHasBeenSet; }
  inline void SetEventTypeCategory(EventTypeCategory value) {
    m_eventTypeCategoryHasBeenSet = true;
    m_eventTypeCategory = value;
  }
  inline OrganizationEvent& WithEventTypeCategory(EventTypeCategory value) {
    SetEventTypeCategory(value);
    return *this;
  }
 
 
  inline EventScopeCode GetEventScopeCode() const { return m_eventScopeCode; }
  inline bool EventScopeCodeHasBeenSet() const { return m_eventScopeCodeHasBeenSet; }
  inline void SetEventScopeCode(EventScopeCode value) {
    m_eventScopeCodeHasBeenSet = true;
    m_eventScopeCode = value;
  }
  inline OrganizationEvent& WithEventScopeCode(EventScopeCode value) {
    SetEventScopeCode(value);
    return *this;
  }
 
 
  inline const Aws::String& GetRegion() const { return m_region; }
  inline bool RegionHasBeenSet() const { return m_regionHasBeenSet; }
  template <typename RegionT = Aws::String>
  void SetRegion(RegionT&& value) {
    m_regionHasBeenSet = true;
    m_region = std::forward<RegionT>(value);
  }
  template <typename RegionT = Aws::String>
  OrganizationEvent& WithRegion(RegionT&& value) {
    SetRegion(std::forward<RegionT>(value));
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetStartTime() const { return m_startTime; }
  inline bool StartTimeHasBeenSet() const { return m_startTimeHasBeenSet; }
  template <typename StartTimeT = Aws::Utils::DateTime>
  void SetStartTime(StartTimeT&& value) {
    m_startTimeHasBeenSet = true;
    m_startTime = std::forward<StartTimeT>(value);
  }
  template <typename StartTimeT = Aws::Utils::DateTime>
  OrganizationEvent& WithStartTime(StartTimeT&& value) {
    SetStartTime(std::forward<StartTimeT>(value));
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetEndTime() const { return m_endTime; }
  inline bool EndTimeHasBeenSet() const { return m_endTimeHasBeenSet; }
  template <typename EndTimeT = Aws::Utils::DateTime>
  void SetEndTime(EndTimeT&& value) {
    m_endTimeHasBeenSet = true;
    m_endTime = std::forward<EndTimeT>(value);
  }
  template <typename EndTimeT = Aws::Utils::DateTime>
  OrganizationEvent& WithEndTime(EndTimeT&& value) {
    SetEndTime(std::forward<EndTimeT>(value));
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetLastUpdatedTime() const { return m_lastUpdatedTime; }
  inline bool LastUpdatedTimeHasBeenSet() const { return m_lastUpdatedTimeHasBeenSet; }
  template <typename LastUpdatedTimeT = Aws::Utils::DateTime>
  void SetLastUpdatedTime(LastUpdatedTimeT&& value) {
    m_lastUpdatedTimeHasBeenSet = true;
    m_lastUpdatedTime = std::forward<LastUpdatedTimeT>(value);
  }
  template <typename LastUpdatedTimeT = Aws::Utils::DateTime>
  OrganizationEvent& WithLastUpdatedTime(LastUpdatedTimeT&& value) {
    SetLastUpdatedTime(std::forward<LastUpdatedTimeT>(value));
    return *this;
  }
 
 
  inline EventStatusCode GetStatusCode() const { return m_statusCode; }
  inline bool StatusCodeHasBeenSet() const { return m_statusCodeHasBeenSet; }
  inline void SetStatusCode(EventStatusCode value) {
    m_statusCodeHasBeenSet = true;
    m_statusCode = value;
  }
  inline OrganizationEvent& WithStatusCode(EventStatusCode value) {
    SetStatusCode(value);
    return *this;
  }
 
 
  inline EventActionability GetActionability() const { return m_actionability; }
  inline bool ActionabilityHasBeenSet() const { return m_actionabilityHasBeenSet; }
  inline void SetActionability(EventActionability value) {
    m_actionabilityHasBeenSet = true;
    m_actionability = value;
  }
  inline OrganizationEvent& WithActionability(EventActionability value) {
    SetActionability(value);
    return *this;
  }
 
 
  inline const Aws::Vector<EventPersona>& GetPersonas() const { return m_personas; }
  inline bool PersonasHasBeenSet() const { return m_personasHasBeenSet; }
  template <typename PersonasT = Aws::Vector<EventPersona>>
  void SetPersonas(PersonasT&& value) {
    m_personasHasBeenSet = true;
    m_personas = std::forward<PersonasT>(value);
  }
  template <typename PersonasT = Aws::Vector<EventPersona>>
  OrganizationEvent& WithPersonas(PersonasT&& value) {
    SetPersonas(std::forward<PersonasT>(value));
    return *this;
  }
  inline OrganizationEvent& AddPersonas(EventPersona value) {
    m_personasHasBeenSet = true;
    m_personas.push_back(value);
    return *this;
  }
 private:
  Aws::String m_arn;
 
  Aws::String m_service;
 
  Aws::String m_eventTypeCode;
 
  EventTypeCategory m_eventTypeCategory{EventTypeCategory::NOT_SET};
 
  EventScopeCode m_eventScopeCode{EventScopeCode::NOT_SET};
 
  Aws::String m_region;
 
  Aws::Utils::DateTime m_startTime{};
 
  Aws::Utils::DateTime m_endTime{};
 
  Aws::Utils::DateTime m_lastUpdatedTime{};
 
  EventStatusCode m_statusCode{EventStatusCode::NOT_SET};
 
  EventActionability m_actionability{EventActionability::NOT_SET};
 
  Aws::Vector<EventPersona> m_personas;
  bool m_arnHasBeenSet = false;
  bool m_serviceHasBeenSet = false;
  bool m_eventTypeCodeHasBeenSet = false;
  bool m_eventTypeCategoryHasBeenSet = false;
  bool m_eventScopeCodeHasBeenSet = false;
  bool m_regionHasBeenSet = false;
  bool m_startTimeHasBeenSet = false;
  bool m_endTimeHasBeenSet = false;
  bool m_lastUpdatedTimeHasBeenSet = false;
  bool m_statusCodeHasBeenSet = false;
  bool m_actionabilityHasBeenSet = false;
  bool m_personasHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace Health
}  // namespace Aws