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/DatastoreStatus.h>
#include <aws/healthlake/model/ErrorCause.h>
#include <aws/healthlake/model/FHIRVersion.h>
#include <aws/healthlake/model/IdentityProviderConfiguration.h>
#include <aws/healthlake/model/PreloadDataConfig.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;
  }
 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;
  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;
};
 
}  // namespace Model
}  // namespace HealthLake
}  // namespace Aws