ResourceDataSyncItem.h

 
#pragma once
#include <aws/core/utils/DateTime.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/ssm/SSM_EXPORTS.h>
#include <aws/ssm/model/LastResourceDataSyncStatus.h>
#include <aws/ssm/model/ResourceDataSyncS3Destination.h>
#include <aws/ssm/model/ResourceDataSyncSourceWithState.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace SSM {
namespace Model {
 
class ResourceDataSyncItem {
 public:
  AWS_SSM_API ResourceDataSyncItem() = default;
  AWS_SSM_API ResourceDataSyncItem(Aws::Utils::Json::JsonView jsonValue);
  AWS_SSM_API ResourceDataSyncItem& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_SSM_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const Aws::String& GetSyncName() const { return m_syncName; }
  inline bool SyncNameHasBeenSet() const { return m_syncNameHasBeenSet; }
  template <typename SyncNameT = Aws::String>
  void SetSyncName(SyncNameT&& value) {
    m_syncNameHasBeenSet = true;
    m_syncName = std::forward<SyncNameT>(value);
  }
  template <typename SyncNameT = Aws::String>
  ResourceDataSyncItem& WithSyncName(SyncNameT&& value) {
    SetSyncName(std::forward<SyncNameT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetSyncType() const { return m_syncType; }
  inline bool SyncTypeHasBeenSet() const { return m_syncTypeHasBeenSet; }
  template <typename SyncTypeT = Aws::String>
  void SetSyncType(SyncTypeT&& value) {
    m_syncTypeHasBeenSet = true;
    m_syncType = std::forward<SyncTypeT>(value);
  }
  template <typename SyncTypeT = Aws::String>
  ResourceDataSyncItem& WithSyncType(SyncTypeT&& value) {
    SetSyncType(std::forward<SyncTypeT>(value));
    return *this;
  }
 
 
  inline const ResourceDataSyncSourceWithState& GetSyncSource() const { return m_syncSource; }
  inline bool SyncSourceHasBeenSet() const { return m_syncSourceHasBeenSet; }
  template <typename SyncSourceT = ResourceDataSyncSourceWithState>
  void SetSyncSource(SyncSourceT&& value) {
    m_syncSourceHasBeenSet = true;
    m_syncSource = std::forward<SyncSourceT>(value);
  }
  template <typename SyncSourceT = ResourceDataSyncSourceWithState>
  ResourceDataSyncItem& WithSyncSource(SyncSourceT&& value) {
    SetSyncSource(std::forward<SyncSourceT>(value));
    return *this;
  }
 
 
  inline const ResourceDataSyncS3Destination& GetS3Destination() const { return m_s3Destination; }
  inline bool S3DestinationHasBeenSet() const { return m_s3DestinationHasBeenSet; }
  template <typename S3DestinationT = ResourceDataSyncS3Destination>
  void SetS3Destination(S3DestinationT&& value) {
    m_s3DestinationHasBeenSet = true;
    m_s3Destination = std::forward<S3DestinationT>(value);
  }
  template <typename S3DestinationT = ResourceDataSyncS3Destination>
  ResourceDataSyncItem& WithS3Destination(S3DestinationT&& value) {
    SetS3Destination(std::forward<S3DestinationT>(value));
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetLastSyncTime() const { return m_lastSyncTime; }
  inline bool LastSyncTimeHasBeenSet() const { return m_lastSyncTimeHasBeenSet; }
  template <typename LastSyncTimeT = Aws::Utils::DateTime>
  void SetLastSyncTime(LastSyncTimeT&& value) {
    m_lastSyncTimeHasBeenSet = true;
    m_lastSyncTime = std::forward<LastSyncTimeT>(value);
  }
  template <typename LastSyncTimeT = Aws::Utils::DateTime>
  ResourceDataSyncItem& WithLastSyncTime(LastSyncTimeT&& value) {
    SetLastSyncTime(std::forward<LastSyncTimeT>(value));
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetLastSuccessfulSyncTime() const { return m_lastSuccessfulSyncTime; }
  inline bool LastSuccessfulSyncTimeHasBeenSet() const { return m_lastSuccessfulSyncTimeHasBeenSet; }
  template <typename LastSuccessfulSyncTimeT = Aws::Utils::DateTime>
  void SetLastSuccessfulSyncTime(LastSuccessfulSyncTimeT&& value) {
    m_lastSuccessfulSyncTimeHasBeenSet = true;
    m_lastSuccessfulSyncTime = std::forward<LastSuccessfulSyncTimeT>(value);
  }
  template <typename LastSuccessfulSyncTimeT = Aws::Utils::DateTime>
  ResourceDataSyncItem& WithLastSuccessfulSyncTime(LastSuccessfulSyncTimeT&& value) {
    SetLastSuccessfulSyncTime(std::forward<LastSuccessfulSyncTimeT>(value));
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetSyncLastModifiedTime() const { return m_syncLastModifiedTime; }
  inline bool SyncLastModifiedTimeHasBeenSet() const { return m_syncLastModifiedTimeHasBeenSet; }
  template <typename SyncLastModifiedTimeT = Aws::Utils::DateTime>
  void SetSyncLastModifiedTime(SyncLastModifiedTimeT&& value) {
    m_syncLastModifiedTimeHasBeenSet = true;
    m_syncLastModifiedTime = std::forward<SyncLastModifiedTimeT>(value);
  }
  template <typename SyncLastModifiedTimeT = Aws::Utils::DateTime>
  ResourceDataSyncItem& WithSyncLastModifiedTime(SyncLastModifiedTimeT&& value) {
    SetSyncLastModifiedTime(std::forward<SyncLastModifiedTimeT>(value));
    return *this;
  }
 
 
  inline LastResourceDataSyncStatus GetLastStatus() const { return m_lastStatus; }
  inline bool LastStatusHasBeenSet() const { return m_lastStatusHasBeenSet; }
  inline void SetLastStatus(LastResourceDataSyncStatus value) {
    m_lastStatusHasBeenSet = true;
    m_lastStatus = value;
  }
  inline ResourceDataSyncItem& WithLastStatus(LastResourceDataSyncStatus value) {
    SetLastStatus(value);
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetSyncCreatedTime() const { return m_syncCreatedTime; }
  inline bool SyncCreatedTimeHasBeenSet() const { return m_syncCreatedTimeHasBeenSet; }
  template <typename SyncCreatedTimeT = Aws::Utils::DateTime>
  void SetSyncCreatedTime(SyncCreatedTimeT&& value) {
    m_syncCreatedTimeHasBeenSet = true;
    m_syncCreatedTime = std::forward<SyncCreatedTimeT>(value);
  }
  template <typename SyncCreatedTimeT = Aws::Utils::DateTime>
  ResourceDataSyncItem& WithSyncCreatedTime(SyncCreatedTimeT&& value) {
    SetSyncCreatedTime(std::forward<SyncCreatedTimeT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetLastSyncStatusMessage() const { return m_lastSyncStatusMessage; }
  inline bool LastSyncStatusMessageHasBeenSet() const { return m_lastSyncStatusMessageHasBeenSet; }
  template <typename LastSyncStatusMessageT = Aws::String>
  void SetLastSyncStatusMessage(LastSyncStatusMessageT&& value) {
    m_lastSyncStatusMessageHasBeenSet = true;
    m_lastSyncStatusMessage = std::forward<LastSyncStatusMessageT>(value);
  }
  template <typename LastSyncStatusMessageT = Aws::String>
  ResourceDataSyncItem& WithLastSyncStatusMessage(LastSyncStatusMessageT&& value) {
    SetLastSyncStatusMessage(std::forward<LastSyncStatusMessageT>(value));
    return *this;
  }
 private:
  Aws::String m_syncName;
 
  Aws::String m_syncType;
 
  ResourceDataSyncSourceWithState m_syncSource;
 
  ResourceDataSyncS3Destination m_s3Destination;
 
  Aws::Utils::DateTime m_lastSyncTime{};
 
  Aws::Utils::DateTime m_lastSuccessfulSyncTime{};
 
  Aws::Utils::DateTime m_syncLastModifiedTime{};
 
  LastResourceDataSyncStatus m_lastStatus{LastResourceDataSyncStatus::NOT_SET};
 
  Aws::Utils::DateTime m_syncCreatedTime{};
 
  Aws::String m_lastSyncStatusMessage;
  bool m_syncNameHasBeenSet = false;
  bool m_syncTypeHasBeenSet = false;
  bool m_syncSourceHasBeenSet = false;
  bool m_s3DestinationHasBeenSet = false;
  bool m_lastSyncTimeHasBeenSet = false;
  bool m_lastSuccessfulSyncTimeHasBeenSet = false;
  bool m_syncLastModifiedTimeHasBeenSet = false;
  bool m_lastStatusHasBeenSet = false;
  bool m_syncCreatedTimeHasBeenSet = false;
  bool m_lastSyncStatusMessageHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace SSM
}  // namespace Aws