PatchRule.h

 
#pragma once
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/ssm/SSM_EXPORTS.h>
#include <aws/ssm/model/PatchComplianceLevel.h>
#include <aws/ssm/model/PatchFilterGroup.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace SSM {
namespace Model {
 
class PatchRule {
 public:
  AWS_SSM_API PatchRule() = default;
  AWS_SSM_API PatchRule(Aws::Utils::Json::JsonView jsonValue);
  AWS_SSM_API PatchRule& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_SSM_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const PatchFilterGroup& GetPatchFilterGroup() const { return m_patchFilterGroup; }
  inline bool PatchFilterGroupHasBeenSet() const { return m_patchFilterGroupHasBeenSet; }
  template <typename PatchFilterGroupT = PatchFilterGroup>
  void SetPatchFilterGroup(PatchFilterGroupT&& value) {
    m_patchFilterGroupHasBeenSet = true;
    m_patchFilterGroup = std::forward<PatchFilterGroupT>(value);
  }
  template <typename PatchFilterGroupT = PatchFilterGroup>
  PatchRule& WithPatchFilterGroup(PatchFilterGroupT&& value) {
    SetPatchFilterGroup(std::forward<PatchFilterGroupT>(value));
    return *this;
  }
 
 
  inline PatchComplianceLevel GetComplianceLevel() const { return m_complianceLevel; }
  inline bool ComplianceLevelHasBeenSet() const { return m_complianceLevelHasBeenSet; }
  inline void SetComplianceLevel(PatchComplianceLevel value) {
    m_complianceLevelHasBeenSet = true;
    m_complianceLevel = value;
  }
  inline PatchRule& WithComplianceLevel(PatchComplianceLevel value) {
    SetComplianceLevel(value);
    return *this;
  }
 
 
  inline int GetApproveAfterDays() const { return m_approveAfterDays; }
  inline bool ApproveAfterDaysHasBeenSet() const { return m_approveAfterDaysHasBeenSet; }
  inline void SetApproveAfterDays(int value) {
    m_approveAfterDaysHasBeenSet = true;
    m_approveAfterDays = value;
  }
  inline PatchRule& WithApproveAfterDays(int value) {
    SetApproveAfterDays(value);
    return *this;
  }
 
 
  inline const Aws::String& GetApproveUntilDate() const { return m_approveUntilDate; }
  inline bool ApproveUntilDateHasBeenSet() const { return m_approveUntilDateHasBeenSet; }
  template <typename ApproveUntilDateT = Aws::String>
  void SetApproveUntilDate(ApproveUntilDateT&& value) {
    m_approveUntilDateHasBeenSet = true;
    m_approveUntilDate = std::forward<ApproveUntilDateT>(value);
  }
  template <typename ApproveUntilDateT = Aws::String>
  PatchRule& WithApproveUntilDate(ApproveUntilDateT&& value) {
    SetApproveUntilDate(std::forward<ApproveUntilDateT>(value));
    return *this;
  }
 
 
  inline bool GetEnableNonSecurity() const { return m_enableNonSecurity; }
  inline bool EnableNonSecurityHasBeenSet() const { return m_enableNonSecurityHasBeenSet; }
  inline void SetEnableNonSecurity(bool value) {
    m_enableNonSecurityHasBeenSet = true;
    m_enableNonSecurity = value;
  }
  inline PatchRule& WithEnableNonSecurity(bool value) {
    SetEnableNonSecurity(value);
    return *this;
  }
 private:
  PatchFilterGroup m_patchFilterGroup;
 
  PatchComplianceLevel m_complianceLevel{PatchComplianceLevel::NOT_SET};
 
  int m_approveAfterDays{0};
 
  Aws::String m_approveUntilDate;
 
  bool m_enableNonSecurity{false};
  bool m_patchFilterGroupHasBeenSet = false;
  bool m_complianceLevelHasBeenSet = false;
  bool m_approveAfterDaysHasBeenSet = false;
  bool m_approveUntilDateHasBeenSet = false;
  bool m_enableNonSecurityHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace SSM
}  // namespace Aws