SpaceSettings.h

 
#pragma once
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/sagemaker/SageMaker_EXPORTS.h>
#include <aws/sagemaker/model/AppType.h>
#include <aws/sagemaker/model/CustomFileSystem.h>
#include <aws/sagemaker/model/FeatureStatus.h>
#include <aws/sagemaker/model/JupyterServerAppSettings.h>
#include <aws/sagemaker/model/KernelGatewayAppSettings.h>
#include <aws/sagemaker/model/SpaceCodeEditorAppSettings.h>
#include <aws/sagemaker/model/SpaceJupyterLabAppSettings.h>
#include <aws/sagemaker/model/SpaceStorageSettings.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace SageMaker {
namespace Model {
 
class SpaceSettings {
 public:
  AWS_SAGEMAKER_API SpaceSettings() = default;
  AWS_SAGEMAKER_API SpaceSettings(Aws::Utils::Json::JsonView jsonValue);
  AWS_SAGEMAKER_API SpaceSettings& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_SAGEMAKER_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const JupyterServerAppSettings& GetJupyterServerAppSettings() const { return m_jupyterServerAppSettings; }
  inline bool JupyterServerAppSettingsHasBeenSet() const { return m_jupyterServerAppSettingsHasBeenSet; }
  template <typename JupyterServerAppSettingsT = JupyterServerAppSettings>
  void SetJupyterServerAppSettings(JupyterServerAppSettingsT&& value) {
    m_jupyterServerAppSettingsHasBeenSet = true;
    m_jupyterServerAppSettings = std::forward<JupyterServerAppSettingsT>(value);
  }
  template <typename JupyterServerAppSettingsT = JupyterServerAppSettings>
  SpaceSettings& WithJupyterServerAppSettings(JupyterServerAppSettingsT&& value) {
    SetJupyterServerAppSettings(std::forward<JupyterServerAppSettingsT>(value));
    return *this;
  }
 
 
  inline const KernelGatewayAppSettings& GetKernelGatewayAppSettings() const { return m_kernelGatewayAppSettings; }
  inline bool KernelGatewayAppSettingsHasBeenSet() const { return m_kernelGatewayAppSettingsHasBeenSet; }
  template <typename KernelGatewayAppSettingsT = KernelGatewayAppSettings>
  void SetKernelGatewayAppSettings(KernelGatewayAppSettingsT&& value) {
    m_kernelGatewayAppSettingsHasBeenSet = true;
    m_kernelGatewayAppSettings = std::forward<KernelGatewayAppSettingsT>(value);
  }
  template <typename KernelGatewayAppSettingsT = KernelGatewayAppSettings>
  SpaceSettings& WithKernelGatewayAppSettings(KernelGatewayAppSettingsT&& value) {
    SetKernelGatewayAppSettings(std::forward<KernelGatewayAppSettingsT>(value));
    return *this;
  }
 
 
  inline const SpaceCodeEditorAppSettings& GetCodeEditorAppSettings() const { return m_codeEditorAppSettings; }
  inline bool CodeEditorAppSettingsHasBeenSet() const { return m_codeEditorAppSettingsHasBeenSet; }
  template <typename CodeEditorAppSettingsT = SpaceCodeEditorAppSettings>
  void SetCodeEditorAppSettings(CodeEditorAppSettingsT&& value) {
    m_codeEditorAppSettingsHasBeenSet = true;
    m_codeEditorAppSettings = std::forward<CodeEditorAppSettingsT>(value);
  }
  template <typename CodeEditorAppSettingsT = SpaceCodeEditorAppSettings>
  SpaceSettings& WithCodeEditorAppSettings(CodeEditorAppSettingsT&& value) {
    SetCodeEditorAppSettings(std::forward<CodeEditorAppSettingsT>(value));
    return *this;
  }
 
 
  inline const SpaceJupyterLabAppSettings& GetJupyterLabAppSettings() const { return m_jupyterLabAppSettings; }
  inline bool JupyterLabAppSettingsHasBeenSet() const { return m_jupyterLabAppSettingsHasBeenSet; }
  template <typename JupyterLabAppSettingsT = SpaceJupyterLabAppSettings>
  void SetJupyterLabAppSettings(JupyterLabAppSettingsT&& value) {
    m_jupyterLabAppSettingsHasBeenSet = true;
    m_jupyterLabAppSettings = std::forward<JupyterLabAppSettingsT>(value);
  }
  template <typename JupyterLabAppSettingsT = SpaceJupyterLabAppSettings>
  SpaceSettings& WithJupyterLabAppSettings(JupyterLabAppSettingsT&& value) {
    SetJupyterLabAppSettings(std::forward<JupyterLabAppSettingsT>(value));
    return *this;
  }
 
 
  inline AppType GetAppType() const { return m_appType; }
  inline bool AppTypeHasBeenSet() const { return m_appTypeHasBeenSet; }
  inline void SetAppType(AppType value) {
    m_appTypeHasBeenSet = true;
    m_appType = value;
  }
  inline SpaceSettings& WithAppType(AppType value) {
    SetAppType(value);
    return *this;
  }
 
 
  inline const SpaceStorageSettings& GetSpaceStorageSettings() const { return m_spaceStorageSettings; }
  inline bool SpaceStorageSettingsHasBeenSet() const { return m_spaceStorageSettingsHasBeenSet; }
  template <typename SpaceStorageSettingsT = SpaceStorageSettings>
  void SetSpaceStorageSettings(SpaceStorageSettingsT&& value) {
    m_spaceStorageSettingsHasBeenSet = true;
    m_spaceStorageSettings = std::forward<SpaceStorageSettingsT>(value);
  }
  template <typename SpaceStorageSettingsT = SpaceStorageSettings>
  SpaceSettings& WithSpaceStorageSettings(SpaceStorageSettingsT&& value) {
    SetSpaceStorageSettings(std::forward<SpaceStorageSettingsT>(value));
    return *this;
  }
 
 
  inline FeatureStatus GetSpaceManagedResources() const { return m_spaceManagedResources; }
  inline bool SpaceManagedResourcesHasBeenSet() const { return m_spaceManagedResourcesHasBeenSet; }
  inline void SetSpaceManagedResources(FeatureStatus value) {
    m_spaceManagedResourcesHasBeenSet = true;
    m_spaceManagedResources = value;
  }
  inline SpaceSettings& WithSpaceManagedResources(FeatureStatus value) {
    SetSpaceManagedResources(value);
    return *this;
  }
 
 
  inline const Aws::Vector<CustomFileSystem>& GetCustomFileSystems() const { return m_customFileSystems; }
  inline bool CustomFileSystemsHasBeenSet() const { return m_customFileSystemsHasBeenSet; }
  template <typename CustomFileSystemsT = Aws::Vector<CustomFileSystem>>
  void SetCustomFileSystems(CustomFileSystemsT&& value) {
    m_customFileSystemsHasBeenSet = true;
    m_customFileSystems = std::forward<CustomFileSystemsT>(value);
  }
  template <typename CustomFileSystemsT = Aws::Vector<CustomFileSystem>>
  SpaceSettings& WithCustomFileSystems(CustomFileSystemsT&& value) {
    SetCustomFileSystems(std::forward<CustomFileSystemsT>(value));
    return *this;
  }
  template <typename CustomFileSystemsT = CustomFileSystem>
  SpaceSettings& AddCustomFileSystems(CustomFileSystemsT&& value) {
    m_customFileSystemsHasBeenSet = true;
    m_customFileSystems.emplace_back(std::forward<CustomFileSystemsT>(value));
    return *this;
  }
 
 
  inline FeatureStatus GetRemoteAccess() const { return m_remoteAccess; }
  inline bool RemoteAccessHasBeenSet() const { return m_remoteAccessHasBeenSet; }
  inline void SetRemoteAccess(FeatureStatus value) {
    m_remoteAccessHasBeenSet = true;
    m_remoteAccess = value;
  }
  inline SpaceSettings& WithRemoteAccess(FeatureStatus value) {
    SetRemoteAccess(value);
    return *this;
  }
 private:
  JupyterServerAppSettings m_jupyterServerAppSettings;
 
  KernelGatewayAppSettings m_kernelGatewayAppSettings;
 
  SpaceCodeEditorAppSettings m_codeEditorAppSettings;
 
  SpaceJupyterLabAppSettings m_jupyterLabAppSettings;
 
  AppType m_appType{AppType::NOT_SET};
 
  SpaceStorageSettings m_spaceStorageSettings;
 
  FeatureStatus m_spaceManagedResources{FeatureStatus::NOT_SET};
 
  Aws::Vector<CustomFileSystem> m_customFileSystems;
 
  FeatureStatus m_remoteAccess{FeatureStatus::NOT_SET};
  bool m_jupyterServerAppSettingsHasBeenSet = false;
  bool m_kernelGatewayAppSettingsHasBeenSet = false;
  bool m_codeEditorAppSettingsHasBeenSet = false;
  bool m_jupyterLabAppSettingsHasBeenSet = false;
  bool m_appTypeHasBeenSet = false;
  bool m_spaceStorageSettingsHasBeenSet = false;
  bool m_spaceManagedResourcesHasBeenSet = false;
  bool m_customFileSystemsHasBeenSet = false;
  bool m_remoteAccessHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace SageMaker
}  // namespace Aws