ConfigurationRecorder.h

 
#pragma once
#include <aws/config/ConfigService_EXPORTS.h>
#include <aws/config/model/RecordingGroup.h>
#include <aws/config/model/RecordingMode.h>
#include <aws/config/model/RecordingScope.h>
#include <aws/core/utils/memory/stl/AWSString.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace ConfigService {
namespace Model {
 
class ConfigurationRecorder {
 public:
  AWS_CONFIGSERVICE_API ConfigurationRecorder() = default;
  AWS_CONFIGSERVICE_API ConfigurationRecorder(Aws::Utils::Json::JsonView jsonValue);
  AWS_CONFIGSERVICE_API ConfigurationRecorder& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_CONFIGSERVICE_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const Aws::String& GetArn() const { return m_arn; }
  inline bool ArnHasBeenSet() const { return m_arnHasBeenSet; }
  template <typename ArnT = Aws::String>
  void SetArn(ArnT&& value) {
    m_arnHasBeenSet = true;
    m_arn = std::forward<ArnT>(value);
  }
  template <typename ArnT = Aws::String>
  ConfigurationRecorder& WithArn(ArnT&& value) {
    SetArn(std::forward<ArnT>(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>
  ConfigurationRecorder& WithName(NameT&& value) {
    SetName(std::forward<NameT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetRoleARN() const { return m_roleARN; }
  inline bool RoleARNHasBeenSet() const { return m_roleARNHasBeenSet; }
  template <typename RoleARNT = Aws::String>
  void SetRoleARN(RoleARNT&& value) {
    m_roleARNHasBeenSet = true;
    m_roleARN = std::forward<RoleARNT>(value);
  }
  template <typename RoleARNT = Aws::String>
  ConfigurationRecorder& WithRoleARN(RoleARNT&& value) {
    SetRoleARN(std::forward<RoleARNT>(value));
    return *this;
  }
 
 
  inline const RecordingGroup& GetRecordingGroup() const { return m_recordingGroup; }
  inline bool RecordingGroupHasBeenSet() const { return m_recordingGroupHasBeenSet; }
  template <typename RecordingGroupT = RecordingGroup>
  void SetRecordingGroup(RecordingGroupT&& value) {
    m_recordingGroupHasBeenSet = true;
    m_recordingGroup = std::forward<RecordingGroupT>(value);
  }
  template <typename RecordingGroupT = RecordingGroup>
  ConfigurationRecorder& WithRecordingGroup(RecordingGroupT&& value) {
    SetRecordingGroup(std::forward<RecordingGroupT>(value));
    return *this;
  }
 
 
  inline const RecordingMode& GetRecordingMode() const { return m_recordingMode; }
  inline bool RecordingModeHasBeenSet() const { return m_recordingModeHasBeenSet; }
  template <typename RecordingModeT = RecordingMode>
  void SetRecordingMode(RecordingModeT&& value) {
    m_recordingModeHasBeenSet = true;
    m_recordingMode = std::forward<RecordingModeT>(value);
  }
  template <typename RecordingModeT = RecordingMode>
  ConfigurationRecorder& WithRecordingMode(RecordingModeT&& value) {
    SetRecordingMode(std::forward<RecordingModeT>(value));
    return *this;
  }
 
 
  inline RecordingScope GetRecordingScope() const { return m_recordingScope; }
  inline bool RecordingScopeHasBeenSet() const { return m_recordingScopeHasBeenSet; }
  inline void SetRecordingScope(RecordingScope value) {
    m_recordingScopeHasBeenSet = true;
    m_recordingScope = value;
  }
  inline ConfigurationRecorder& WithRecordingScope(RecordingScope value) {
    SetRecordingScope(value);
    return *this;
  }
 
 
  inline const Aws::String& GetServicePrincipal() const { return m_servicePrincipal; }
  inline bool ServicePrincipalHasBeenSet() const { return m_servicePrincipalHasBeenSet; }
  template <typename ServicePrincipalT = Aws::String>
  void SetServicePrincipal(ServicePrincipalT&& value) {
    m_servicePrincipalHasBeenSet = true;
    m_servicePrincipal = std::forward<ServicePrincipalT>(value);
  }
  template <typename ServicePrincipalT = Aws::String>
  ConfigurationRecorder& WithServicePrincipal(ServicePrincipalT&& value) {
    SetServicePrincipal(std::forward<ServicePrincipalT>(value));
    return *this;
  }
 private:
  Aws::String m_arn;
 
  Aws::String m_name;
 
  Aws::String m_roleARN;
 
  RecordingGroup m_recordingGroup;
 
  RecordingMode m_recordingMode;
 
  RecordingScope m_recordingScope{RecordingScope::NOT_SET};
 
  Aws::String m_servicePrincipal;
  bool m_arnHasBeenSet = false;
  bool m_nameHasBeenSet = false;
  bool m_roleARNHasBeenSet = false;
  bool m_recordingGroupHasBeenSet = false;
  bool m_recordingModeHasBeenSet = false;
  bool m_recordingScopeHasBeenSet = false;
  bool m_servicePrincipalHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace ConfigService
}  // namespace Aws