DatastoreProperties.h

 
#pragma once
#include <aws/core/utils/DateTime.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/healthlake/HealthLake_EXPORTS.h>
#include <aws/healthlake/model/AnalyticsConfiguration.h>
#include <aws/healthlake/model/DatastoreBackupStatus.h>
#include <aws/healthlake/model/DatastoreStatus.h>
#include <aws/healthlake/model/ErrorCause.h>
#include <aws/healthlake/model/FHIRVersion.h>
#include <aws/healthlake/model/IdentityProviderConfiguration.h>
#include <aws/healthlake/model/NlpConfiguration.h>
#include <aws/healthlake/model/PreloadDataConfig.h>
#include <aws/healthlake/model/ProfileConfiguration.h>
#include <aws/healthlake/model/SseConfiguration.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace HealthLake {
namespace Model {
 
class DatastoreProperties {
 public:
  AWS_HEALTHLAKE_API DatastoreProperties() = default;
  AWS_HEALTHLAKE_API DatastoreProperties(Aws::Utils::Json::JsonView jsonValue);
  AWS_HEALTHLAKE_API DatastoreProperties& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_HEALTHLAKE_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const Aws::String& GetDatastoreId() const { return m_datastoreId; }
  inline bool DatastoreIdHasBeenSet() const { return m_datastoreIdHasBeenSet; }
  template <typename DatastoreIdT = Aws::String>
  void SetDatastoreId(DatastoreIdT&& value) {
    m_datastoreIdHasBeenSet = true;
    m_datastoreId = std::forward<DatastoreIdT>(value);
  }
  template <typename DatastoreIdT = Aws::String>
  DatastoreProperties& WithDatastoreId(DatastoreIdT&& value) {
    SetDatastoreId(std::forward<DatastoreIdT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetDatastoreArn() const { return m_datastoreArn; }
  inline bool DatastoreArnHasBeenSet() const { return m_datastoreArnHasBeenSet; }
  template <typename DatastoreArnT = Aws::String>
  void SetDatastoreArn(DatastoreArnT&& value) {
    m_datastoreArnHasBeenSet = true;
    m_datastoreArn = std::forward<DatastoreArnT>(value);
  }
  template <typename DatastoreArnT = Aws::String>
  DatastoreProperties& WithDatastoreArn(DatastoreArnT&& value) {
    SetDatastoreArn(std::forward<DatastoreArnT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetDatastoreName() const { return m_datastoreName; }
  inline bool DatastoreNameHasBeenSet() const { return m_datastoreNameHasBeenSet; }
  template <typename DatastoreNameT = Aws::String>
  void SetDatastoreName(DatastoreNameT&& value) {
    m_datastoreNameHasBeenSet = true;
    m_datastoreName = std::forward<DatastoreNameT>(value);
  }
  template <typename DatastoreNameT = Aws::String>
  DatastoreProperties& WithDatastoreName(DatastoreNameT&& value) {
    SetDatastoreName(std::forward<DatastoreNameT>(value));
    return *this;
  }
 
 
  inline DatastoreStatus GetDatastoreStatus() const { return m_datastoreStatus; }
  inline bool DatastoreStatusHasBeenSet() const { return m_datastoreStatusHasBeenSet; }
  inline void SetDatastoreStatus(DatastoreStatus value) {
    m_datastoreStatusHasBeenSet = true;
    m_datastoreStatus = value;
  }
  inline DatastoreProperties& WithDatastoreStatus(DatastoreStatus value) {
    SetDatastoreStatus(value);
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetCreatedAt() const { return m_createdAt; }
  inline bool CreatedAtHasBeenSet() const { return m_createdAtHasBeenSet; }
  template <typename CreatedAtT = Aws::Utils::DateTime>
  void SetCreatedAt(CreatedAtT&& value) {
    m_createdAtHasBeenSet = true;
    m_createdAt = std::forward<CreatedAtT>(value);
  }
  template <typename CreatedAtT = Aws::Utils::DateTime>
  DatastoreProperties& WithCreatedAt(CreatedAtT&& value) {
    SetCreatedAt(std::forward<CreatedAtT>(value));
    return *this;
  }
 
 
  inline FHIRVersion GetDatastoreTypeVersion() const { return m_datastoreTypeVersion; }
  inline bool DatastoreTypeVersionHasBeenSet() const { return m_datastoreTypeVersionHasBeenSet; }
  inline void SetDatastoreTypeVersion(FHIRVersion value) {
    m_datastoreTypeVersionHasBeenSet = true;
    m_datastoreTypeVersion = value;
  }
  inline DatastoreProperties& WithDatastoreTypeVersion(FHIRVersion value) {
    SetDatastoreTypeVersion(value);
    return *this;
  }
 
 
  inline const Aws::String& GetDatastoreEndpoint() const { return m_datastoreEndpoint; }
  inline bool DatastoreEndpointHasBeenSet() const { return m_datastoreEndpointHasBeenSet; }
  template <typename DatastoreEndpointT = Aws::String>
  void SetDatastoreEndpoint(DatastoreEndpointT&& value) {
    m_datastoreEndpointHasBeenSet = true;
    m_datastoreEndpoint = std::forward<DatastoreEndpointT>(value);
  }
  template <typename DatastoreEndpointT = Aws::String>
  DatastoreProperties& WithDatastoreEndpoint(DatastoreEndpointT&& value) {
    SetDatastoreEndpoint(std::forward<DatastoreEndpointT>(value));
    return *this;
  }
 
 
  inline const SseConfiguration& GetSseConfiguration() const { return m_sseConfiguration; }
  inline bool SseConfigurationHasBeenSet() const { return m_sseConfigurationHasBeenSet; }
  template <typename SseConfigurationT = SseConfiguration>
  void SetSseConfiguration(SseConfigurationT&& value) {
    m_sseConfigurationHasBeenSet = true;
    m_sseConfiguration = std::forward<SseConfigurationT>(value);
  }
  template <typename SseConfigurationT = SseConfiguration>
  DatastoreProperties& WithSseConfiguration(SseConfigurationT&& value) {
    SetSseConfiguration(std::forward<SseConfigurationT>(value));
    return *this;
  }
 
 
  inline const PreloadDataConfig& GetPreloadDataConfig() const { return m_preloadDataConfig; }
  inline bool PreloadDataConfigHasBeenSet() const { return m_preloadDataConfigHasBeenSet; }
  template <typename PreloadDataConfigT = PreloadDataConfig>
  void SetPreloadDataConfig(PreloadDataConfigT&& value) {
    m_preloadDataConfigHasBeenSet = true;
    m_preloadDataConfig = std::forward<PreloadDataConfigT>(value);
  }
  template <typename PreloadDataConfigT = PreloadDataConfig>
  DatastoreProperties& WithPreloadDataConfig(PreloadDataConfigT&& value) {
    SetPreloadDataConfig(std::forward<PreloadDataConfigT>(value));
    return *this;
  }
 
 
  inline const IdentityProviderConfiguration& GetIdentityProviderConfiguration() const { return m_identityProviderConfiguration; }
  inline bool IdentityProviderConfigurationHasBeenSet() const { return m_identityProviderConfigurationHasBeenSet; }
  template <typename IdentityProviderConfigurationT = IdentityProviderConfiguration>
  void SetIdentityProviderConfiguration(IdentityProviderConfigurationT&& value) {
    m_identityProviderConfigurationHasBeenSet = true;
    m_identityProviderConfiguration = std::forward<IdentityProviderConfigurationT>(value);
  }
  template <typename IdentityProviderConfigurationT = IdentityProviderConfiguration>
  DatastoreProperties& WithIdentityProviderConfiguration(IdentityProviderConfigurationT&& value) {
    SetIdentityProviderConfiguration(std::forward<IdentityProviderConfigurationT>(value));
    return *this;
  }
 
 
  inline const ErrorCause& GetErrorCause() const { return m_errorCause; }
  inline bool ErrorCauseHasBeenSet() const { return m_errorCauseHasBeenSet; }
  template <typename ErrorCauseT = ErrorCause>
  void SetErrorCause(ErrorCauseT&& value) {
    m_errorCauseHasBeenSet = true;
    m_errorCause = std::forward<ErrorCauseT>(value);
  }
  template <typename ErrorCauseT = ErrorCause>
  DatastoreProperties& WithErrorCause(ErrorCauseT&& value) {
    SetErrorCause(std::forward<ErrorCauseT>(value));
    return *this;
  }
 
 
  inline const NlpConfiguration& GetNlpConfiguration() const { return m_nlpConfiguration; }
  inline bool NlpConfigurationHasBeenSet() const { return m_nlpConfigurationHasBeenSet; }
  template <typename NlpConfigurationT = NlpConfiguration>
  void SetNlpConfiguration(NlpConfigurationT&& value) {
    m_nlpConfigurationHasBeenSet = true;
    m_nlpConfiguration = std::forward<NlpConfigurationT>(value);
  }
  template <typename NlpConfigurationT = NlpConfiguration>
  DatastoreProperties& WithNlpConfiguration(NlpConfigurationT&& value) {
    SetNlpConfiguration(std::forward<NlpConfigurationT>(value));
    return *this;
  }
 
 
  inline const AnalyticsConfiguration& GetAnalyticsConfiguration() const { return m_analyticsConfiguration; }
  inline bool AnalyticsConfigurationHasBeenSet() const { return m_analyticsConfigurationHasBeenSet; }
  template <typename AnalyticsConfigurationT = AnalyticsConfiguration>
  void SetAnalyticsConfiguration(AnalyticsConfigurationT&& value) {
    m_analyticsConfigurationHasBeenSet = true;
    m_analyticsConfiguration = std::forward<AnalyticsConfigurationT>(value);
  }
  template <typename AnalyticsConfigurationT = AnalyticsConfiguration>
  DatastoreProperties& WithAnalyticsConfiguration(AnalyticsConfigurationT&& value) {
    SetAnalyticsConfiguration(std::forward<AnalyticsConfigurationT>(value));
    return *this;
  }
 
 
  inline const ProfileConfiguration& GetProfileConfiguration() const { return m_profileConfiguration; }
  inline bool ProfileConfigurationHasBeenSet() const { return m_profileConfigurationHasBeenSet; }
  template <typename ProfileConfigurationT = ProfileConfiguration>
  void SetProfileConfiguration(ProfileConfigurationT&& value) {
    m_profileConfigurationHasBeenSet = true;
    m_profileConfiguration = std::forward<ProfileConfigurationT>(value);
  }
  template <typename ProfileConfigurationT = ProfileConfiguration>
  DatastoreProperties& WithProfileConfiguration(ProfileConfigurationT&& value) {
    SetProfileConfiguration(std::forward<ProfileConfigurationT>(value));
    return *this;
  }
 
 
  inline const DatastoreBackupStatus& GetBackupStatusInfo() const { return m_backupStatusInfo; }
  inline bool BackupStatusInfoHasBeenSet() const { return m_backupStatusInfoHasBeenSet; }
  template <typename BackupStatusInfoT = DatastoreBackupStatus>
  void SetBackupStatusInfo(BackupStatusInfoT&& value) {
    m_backupStatusInfoHasBeenSet = true;
    m_backupStatusInfo = std::forward<BackupStatusInfoT>(value);
  }
  template <typename BackupStatusInfoT = DatastoreBackupStatus>
  DatastoreProperties& WithBackupStatusInfo(BackupStatusInfoT&& value) {
    SetBackupStatusInfo(std::forward<BackupStatusInfoT>(value));
    return *this;
  }
 private:
  Aws::String m_datastoreId;
 
  Aws::String m_datastoreArn;
 
  Aws::String m_datastoreName;
 
  DatastoreStatus m_datastoreStatus{DatastoreStatus::NOT_SET};
 
  Aws::Utils::DateTime m_createdAt{};
 
  FHIRVersion m_datastoreTypeVersion{FHIRVersion::NOT_SET};
 
  Aws::String m_datastoreEndpoint;
 
  SseConfiguration m_sseConfiguration;
 
  PreloadDataConfig m_preloadDataConfig;
 
  IdentityProviderConfiguration m_identityProviderConfiguration;
 
  ErrorCause m_errorCause;
 
  NlpConfiguration m_nlpConfiguration;
 
  AnalyticsConfiguration m_analyticsConfiguration;
 
  ProfileConfiguration m_profileConfiguration;
 
  DatastoreBackupStatus m_backupStatusInfo;
  bool m_datastoreIdHasBeenSet = false;
  bool m_datastoreArnHasBeenSet = false;
  bool m_datastoreNameHasBeenSet = false;
  bool m_datastoreStatusHasBeenSet = false;
  bool m_createdAtHasBeenSet = false;
  bool m_datastoreTypeVersionHasBeenSet = false;
  bool m_datastoreEndpointHasBeenSet = false;
  bool m_sseConfigurationHasBeenSet = false;
  bool m_preloadDataConfigHasBeenSet = false;
  bool m_identityProviderConfigurationHasBeenSet = false;
  bool m_errorCauseHasBeenSet = false;
  bool m_nlpConfigurationHasBeenSet = false;
  bool m_analyticsConfigurationHasBeenSet = false;
  bool m_profileConfigurationHasBeenSet = false;
  bool m_backupStatusInfoHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace HealthLake
}  // namespace Aws