WriteJourneyRequest.h

 
#pragma once
#include <aws/core/utils/memory/stl/AWSMap.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/pinpoint/Pinpoint_EXPORTS.h>
#include <aws/pinpoint/model/Activity.h>
#include <aws/pinpoint/model/ClosedDays.h>
#include <aws/pinpoint/model/JourneyChannelSettings.h>
#include <aws/pinpoint/model/JourneyLimits.h>
#include <aws/pinpoint/model/JourneySchedule.h>
#include <aws/pinpoint/model/OpenHours.h>
#include <aws/pinpoint/model/QuietTime.h>
#include <aws/pinpoint/model/StartCondition.h>
#include <aws/pinpoint/model/State.h>
#include <aws/pinpoint/model/__TimezoneEstimationMethodsElement.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace Pinpoint {
namespace Model {
 
class WriteJourneyRequest {
 public:
  AWS_PINPOINT_API WriteJourneyRequest() = default;
  AWS_PINPOINT_API WriteJourneyRequest(Aws::Utils::Json::JsonView jsonValue);
  AWS_PINPOINT_API WriteJourneyRequest& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_PINPOINT_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const Aws::Map<Aws::String, Activity>& GetActivities() const { return m_activities; }
  inline bool ActivitiesHasBeenSet() const { return m_activitiesHasBeenSet; }
  template <typename ActivitiesT = Aws::Map<Aws::String, Activity>>
  void SetActivities(ActivitiesT&& value) {
    m_activitiesHasBeenSet = true;
    m_activities = std::forward<ActivitiesT>(value);
  }
  template <typename ActivitiesT = Aws::Map<Aws::String, Activity>>
  WriteJourneyRequest& WithActivities(ActivitiesT&& value) {
    SetActivities(std::forward<ActivitiesT>(value));
    return *this;
  }
  template <typename ActivitiesKeyT = Aws::String, typename ActivitiesValueT = Activity>
  WriteJourneyRequest& AddActivities(ActivitiesKeyT&& key, ActivitiesValueT&& value) {
    m_activitiesHasBeenSet = true;
    m_activities.emplace(std::forward<ActivitiesKeyT>(key), std::forward<ActivitiesValueT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetCreationDate() const { return m_creationDate; }
  inline bool CreationDateHasBeenSet() const { return m_creationDateHasBeenSet; }
  template <typename CreationDateT = Aws::String>
  void SetCreationDate(CreationDateT&& value) {
    m_creationDateHasBeenSet = true;
    m_creationDate = std::forward<CreationDateT>(value);
  }
  template <typename CreationDateT = Aws::String>
  WriteJourneyRequest& WithCreationDate(CreationDateT&& value) {
    SetCreationDate(std::forward<CreationDateT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetLastModifiedDate() const { return m_lastModifiedDate; }
  inline bool LastModifiedDateHasBeenSet() const { return m_lastModifiedDateHasBeenSet; }
  template <typename LastModifiedDateT = Aws::String>
  void SetLastModifiedDate(LastModifiedDateT&& value) {
    m_lastModifiedDateHasBeenSet = true;
    m_lastModifiedDate = std::forward<LastModifiedDateT>(value);
  }
  template <typename LastModifiedDateT = Aws::String>
  WriteJourneyRequest& WithLastModifiedDate(LastModifiedDateT&& value) {
    SetLastModifiedDate(std::forward<LastModifiedDateT>(value));
    return *this;
  }
 
 
  inline const JourneyLimits& GetLimits() const { return m_limits; }
  inline bool LimitsHasBeenSet() const { return m_limitsHasBeenSet; }
  template <typename LimitsT = JourneyLimits>
  void SetLimits(LimitsT&& value) {
    m_limitsHasBeenSet = true;
    m_limits = std::forward<LimitsT>(value);
  }
  template <typename LimitsT = JourneyLimits>
  WriteJourneyRequest& WithLimits(LimitsT&& value) {
    SetLimits(std::forward<LimitsT>(value));
    return *this;
  }
 
 
  inline bool GetLocalTime() const { return m_localTime; }
  inline bool LocalTimeHasBeenSet() const { return m_localTimeHasBeenSet; }
  inline void SetLocalTime(bool value) {
    m_localTimeHasBeenSet = true;
    m_localTime = value;
  }
  inline WriteJourneyRequest& WithLocalTime(bool value) {
    SetLocalTime(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>
  WriteJourneyRequest& WithName(NameT&& value) {
    SetName(std::forward<NameT>(value));
    return *this;
  }
 
 
  inline const QuietTime& GetQuietTime() const { return m_quietTime; }
  inline bool QuietTimeHasBeenSet() const { return m_quietTimeHasBeenSet; }
  template <typename QuietTimeT = QuietTime>
  void SetQuietTime(QuietTimeT&& value) {
    m_quietTimeHasBeenSet = true;
    m_quietTime = std::forward<QuietTimeT>(value);
  }
  template <typename QuietTimeT = QuietTime>
  WriteJourneyRequest& WithQuietTime(QuietTimeT&& value) {
    SetQuietTime(std::forward<QuietTimeT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetRefreshFrequency() const { return m_refreshFrequency; }
  inline bool RefreshFrequencyHasBeenSet() const { return m_refreshFrequencyHasBeenSet; }
  template <typename RefreshFrequencyT = Aws::String>
  void SetRefreshFrequency(RefreshFrequencyT&& value) {
    m_refreshFrequencyHasBeenSet = true;
    m_refreshFrequency = std::forward<RefreshFrequencyT>(value);
  }
  template <typename RefreshFrequencyT = Aws::String>
  WriteJourneyRequest& WithRefreshFrequency(RefreshFrequencyT&& value) {
    SetRefreshFrequency(std::forward<RefreshFrequencyT>(value));
    return *this;
  }
 
 
  inline const JourneySchedule& GetSchedule() const { return m_schedule; }
  inline bool ScheduleHasBeenSet() const { return m_scheduleHasBeenSet; }
  template <typename ScheduleT = JourneySchedule>
  void SetSchedule(ScheduleT&& value) {
    m_scheduleHasBeenSet = true;
    m_schedule = std::forward<ScheduleT>(value);
  }
  template <typename ScheduleT = JourneySchedule>
  WriteJourneyRequest& WithSchedule(ScheduleT&& value) {
    SetSchedule(std::forward<ScheduleT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetStartActivity() const { return m_startActivity; }
  inline bool StartActivityHasBeenSet() const { return m_startActivityHasBeenSet; }
  template <typename StartActivityT = Aws::String>
  void SetStartActivity(StartActivityT&& value) {
    m_startActivityHasBeenSet = true;
    m_startActivity = std::forward<StartActivityT>(value);
  }
  template <typename StartActivityT = Aws::String>
  WriteJourneyRequest& WithStartActivity(StartActivityT&& value) {
    SetStartActivity(std::forward<StartActivityT>(value));
    return *this;
  }
 
 
  inline const StartCondition& GetStartCondition() const { return m_startCondition; }
  inline bool StartConditionHasBeenSet() const { return m_startConditionHasBeenSet; }
  template <typename StartConditionT = StartCondition>
  void SetStartCondition(StartConditionT&& value) {
    m_startConditionHasBeenSet = true;
    m_startCondition = std::forward<StartConditionT>(value);
  }
  template <typename StartConditionT = StartCondition>
  WriteJourneyRequest& WithStartCondition(StartConditionT&& value) {
    SetStartCondition(std::forward<StartConditionT>(value));
    return *this;
  }
 
 
  inline State GetState() const { return m_state; }
  inline bool StateHasBeenSet() const { return m_stateHasBeenSet; }
  inline void SetState(State value) {
    m_stateHasBeenSet = true;
    m_state = value;
  }
  inline WriteJourneyRequest& WithState(State value) {
    SetState(value);
    return *this;
  }
 
 
  inline bool GetWaitForQuietTime() const { return m_waitForQuietTime; }
  inline bool WaitForQuietTimeHasBeenSet() const { return m_waitForQuietTimeHasBeenSet; }
  inline void SetWaitForQuietTime(bool value) {
    m_waitForQuietTimeHasBeenSet = true;
    m_waitForQuietTime = value;
  }
  inline WriteJourneyRequest& WithWaitForQuietTime(bool value) {
    SetWaitForQuietTime(value);
    return *this;
  }
 
 
  inline bool GetRefreshOnSegmentUpdate() const { return m_refreshOnSegmentUpdate; }
  inline bool RefreshOnSegmentUpdateHasBeenSet() const { return m_refreshOnSegmentUpdateHasBeenSet; }
  inline void SetRefreshOnSegmentUpdate(bool value) {
    m_refreshOnSegmentUpdateHasBeenSet = true;
    m_refreshOnSegmentUpdate = value;
  }
  inline WriteJourneyRequest& WithRefreshOnSegmentUpdate(bool value) {
    SetRefreshOnSegmentUpdate(value);
    return *this;
  }
 
 
  inline const JourneyChannelSettings& GetJourneyChannelSettings() const { return m_journeyChannelSettings; }
  inline bool JourneyChannelSettingsHasBeenSet() const { return m_journeyChannelSettingsHasBeenSet; }
  template <typename JourneyChannelSettingsT = JourneyChannelSettings>
  void SetJourneyChannelSettings(JourneyChannelSettingsT&& value) {
    m_journeyChannelSettingsHasBeenSet = true;
    m_journeyChannelSettings = std::forward<JourneyChannelSettingsT>(value);
  }
  template <typename JourneyChannelSettingsT = JourneyChannelSettings>
  WriteJourneyRequest& WithJourneyChannelSettings(JourneyChannelSettingsT&& value) {
    SetJourneyChannelSettings(std::forward<JourneyChannelSettingsT>(value));
    return *this;
  }
 
 
  inline bool GetSendingSchedule() const { return m_sendingSchedule; }
  inline bool SendingScheduleHasBeenSet() const { return m_sendingScheduleHasBeenSet; }
  inline void SetSendingSchedule(bool value) {
    m_sendingScheduleHasBeenSet = true;
    m_sendingSchedule = value;
  }
  inline WriteJourneyRequest& WithSendingSchedule(bool value) {
    SetSendingSchedule(value);
    return *this;
  }
 
 
  inline const OpenHours& GetOpenHours() const { return m_openHours; }
  inline bool OpenHoursHasBeenSet() const { return m_openHoursHasBeenSet; }
  template <typename OpenHoursT = OpenHours>
  void SetOpenHours(OpenHoursT&& value) {
    m_openHoursHasBeenSet = true;
    m_openHours = std::forward<OpenHoursT>(value);
  }
  template <typename OpenHoursT = OpenHours>
  WriteJourneyRequest& WithOpenHours(OpenHoursT&& value) {
    SetOpenHours(std::forward<OpenHoursT>(value));
    return *this;
  }
 
 
  inline const ClosedDays& GetClosedDays() const { return m_closedDays; }
  inline bool ClosedDaysHasBeenSet() const { return m_closedDaysHasBeenSet; }
  template <typename ClosedDaysT = ClosedDays>
  void SetClosedDays(ClosedDaysT&& value) {
    m_closedDaysHasBeenSet = true;
    m_closedDays = std::forward<ClosedDaysT>(value);
  }
  template <typename ClosedDaysT = ClosedDays>
  WriteJourneyRequest& WithClosedDays(ClosedDaysT&& value) {
    SetClosedDays(std::forward<ClosedDaysT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<__TimezoneEstimationMethodsElement>& GetTimezoneEstimationMethods() const { return m_timezoneEstimationMethods; }
  inline bool TimezoneEstimationMethodsHasBeenSet() const { return m_timezoneEstimationMethodsHasBeenSet; }
  template <typename TimezoneEstimationMethodsT = Aws::Vector<__TimezoneEstimationMethodsElement>>
  void SetTimezoneEstimationMethods(TimezoneEstimationMethodsT&& value) {
    m_timezoneEstimationMethodsHasBeenSet = true;
    m_timezoneEstimationMethods = std::forward<TimezoneEstimationMethodsT>(value);
  }
  template <typename TimezoneEstimationMethodsT = Aws::Vector<__TimezoneEstimationMethodsElement>>
  WriteJourneyRequest& WithTimezoneEstimationMethods(TimezoneEstimationMethodsT&& value) {
    SetTimezoneEstimationMethods(std::forward<TimezoneEstimationMethodsT>(value));
    return *this;
  }
  inline WriteJourneyRequest& AddTimezoneEstimationMethods(__TimezoneEstimationMethodsElement value) {
    m_timezoneEstimationMethodsHasBeenSet = true;
    m_timezoneEstimationMethods.push_back(value);
    return *this;
  }
 private:
  Aws::Map<Aws::String, Activity> m_activities;
 
  Aws::String m_creationDate;
 
  Aws::String m_lastModifiedDate;
 
  JourneyLimits m_limits;
 
  bool m_localTime{false};
 
  Aws::String m_name;
 
  QuietTime m_quietTime;
 
  Aws::String m_refreshFrequency;
 
  JourneySchedule m_schedule;
 
  Aws::String m_startActivity;
 
  StartCondition m_startCondition;
 
  State m_state{State::NOT_SET};
 
  bool m_waitForQuietTime{false};
 
  bool m_refreshOnSegmentUpdate{false};
 
  JourneyChannelSettings m_journeyChannelSettings;
 
  bool m_sendingSchedule{false};
 
  OpenHours m_openHours;
 
  ClosedDays m_closedDays;
 
  Aws::Vector<__TimezoneEstimationMethodsElement> m_timezoneEstimationMethods;
  bool m_activitiesHasBeenSet = false;
  bool m_creationDateHasBeenSet = false;
  bool m_lastModifiedDateHasBeenSet = false;
  bool m_limitsHasBeenSet = false;
  bool m_localTimeHasBeenSet = false;
  bool m_nameHasBeenSet = false;
  bool m_quietTimeHasBeenSet = false;
  bool m_refreshFrequencyHasBeenSet = false;
  bool m_scheduleHasBeenSet = false;
  bool m_startActivityHasBeenSet = false;
  bool m_startConditionHasBeenSet = false;
  bool m_stateHasBeenSet = false;
  bool m_waitForQuietTimeHasBeenSet = false;
  bool m_refreshOnSegmentUpdateHasBeenSet = false;
  bool m_journeyChannelSettingsHasBeenSet = false;
  bool m_sendingScheduleHasBeenSet = false;
  bool m_openHoursHasBeenSet = false;
  bool m_closedDaysHasBeenSet = false;
  bool m_timezoneEstimationMethodsHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace Pinpoint
}  // namespace Aws