Add support for SageMaker Hyperpod continuous scaling and custom AMI; Introduce new APIs: ListClusterEvents, DescribeClusterEvent, BatchAddClusterNodes

Adds a new Aurora Serverless v2 attribute to the DBCluster resource to expose the platform version. Also updates the attribute to be part of both the engine version and platform version descriptions.
This release adds support for Automated Reasoning checks output models for the Amazon Bedrock Guardrails ApplyGuardrail API.
Add support for deletion protection on EKS clusters
This release introduces Automated Reasoning checks for Amazon Bedrock Guardrails. The feature adds new APIs for policy building, refinement, version management, and testing. Guardrail APIs now support Automated Reasoning policy configuration and validation output.

Author: aws-sdk-cpp-automation

VERSION

@@ -1 +1 @@
-1.11.619
+1.11.620

generated/src/aws-cpp-sdk-bedrock-runtime/include/aws/bedrock-runtime/model/GuardrailAssessment.h

@@ -10,6 +10,7 @@
 #include <aws/bedrock-runtime/model/GuardrailWordPolicyAssessment.h>
 #include <aws/bedrock-runtime/model/GuardrailSensitiveInformationPolicyAssessment.h>
 #include <aws/bedrock-runtime/model/GuardrailContextualGroundingPolicyAssessment.h>
+#include <aws/bedrock-runtime/model/GuardrailAutomatedReasoningPolicyAssessment.h>
 #include <aws/bedrock-runtime/model/GuardrailInvocationMetrics.h>
 #include <utility>
 
@@ -103,6 +104,19 @@ namespace Model
     GuardrailAssessment& WithContextualGroundingPolicy(ContextualGroundingPolicyT&& value) { SetContextualGroundingPolicy(std::forward<ContextualGroundingPolicyT>(value)); return *this;}
     ///@}
 
+    ///@{
+    /**
+     * <p>The automated reasoning policy assessment results, including logical
+     * validation findings for the input content.</p>
+     */
+    inline const GuardrailAutomatedReasoningPolicyAssessment& GetAutomatedReasoningPolicy() const { return m_automatedReasoningPolicy; }
+    inline bool AutomatedReasoningPolicyHasBeenSet() const { return m_automatedReasoningPolicyHasBeenSet; }
+    template<typename AutomatedReasoningPolicyT = GuardrailAutomatedReasoningPolicyAssessment>
+    void SetAutomatedReasoningPolicy(AutomatedReasoningPolicyT&& value) { m_automatedReasoningPolicyHasBeenSet = true; m_automatedReasoningPolicy = std::forward<AutomatedReasoningPolicyT>(value); }
+    template<typename AutomatedReasoningPolicyT = GuardrailAutomatedReasoningPolicyAssessment>
+    GuardrailAssessment& WithAutomatedReasoningPolicy(AutomatedReasoningPolicyT&& value) { SetAutomatedReasoningPolicy(std::forward<AutomatedReasoningPolicyT>(value)); return *this;}
+    ///@}
+
     ///@{
     /**
      * <p>The invocation metrics for the guardrail assessment.</p>
@@ -131,6 +145,9 @@ namespace Model
     GuardrailContextualGroundingPolicyAssessment m_contextualGroundingPolicy;
     bool m_contextualGroundingPolicyHasBeenSet = false;
 
+    GuardrailAutomatedReasoningPolicyAssessment m_automatedReasoningPolicy;
+    bool m_automatedReasoningPolicyHasBeenSet = false;
+
     GuardrailInvocationMetrics m_invocationMetrics;
     bool m_invocationMetricsHasBeenSet = false;
   };

generated/src/aws-cpp-sdk-bedrock-runtime/include/aws/bedrock-runtime/model/GuardrailAutomatedReasoningFinding.h

@@ -0,0 +1,144 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/bedrock-runtime/BedrockRuntime_EXPORTS.h>
+#include <aws/bedrock-runtime/model/GuardrailAutomatedReasoningValidFinding.h>
+#include <aws/bedrock-runtime/model/GuardrailAutomatedReasoningInvalidFinding.h>
+#include <aws/bedrock-runtime/model/GuardrailAutomatedReasoningSatisfiableFinding.h>
+#include <aws/bedrock-runtime/model/GuardrailAutomatedReasoningImpossibleFinding.h>
+#include <aws/bedrock-runtime/model/GuardrailAutomatedReasoningTranslationAmbiguousFinding.h>
+#include <aws/bedrock-runtime/model/GuardrailAutomatedReasoningTooComplexFinding.h>
+#include <aws/bedrock-runtime/model/GuardrailAutomatedReasoningNoTranslationsFinding.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace BedrockRuntime
+{
+namespace Model
+{
+
+  /**
+   * <p>Represents a logical validation result from automated reasoning policy
+   * evaluation. The finding indicates whether claims in the input are logically
+   * valid, invalid, satisfiable, impossible, or have other logical
+   * issues.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/bedrock-runtime-2023-09-30/GuardrailAutomatedReasoningFinding">AWS
+   * API Reference</a></p>
+   */
+  class GuardrailAutomatedReasoningFinding
+  {
+  public:
+    AWS_BEDROCKRUNTIME_API GuardrailAutomatedReasoningFinding() = default;
+    AWS_BEDROCKRUNTIME_API GuardrailAutomatedReasoningFinding(Aws::Utils::Json::JsonView jsonValue);
+    AWS_BEDROCKRUNTIME_API GuardrailAutomatedReasoningFinding& operator=(Aws::Utils::Json::JsonView jsonValue);
+    AWS_BEDROCKRUNTIME_API Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    ///@{
+    
+    inline const GuardrailAutomatedReasoningValidFinding& GetValid() const { return m_valid; }
+    inline bool ValidHasBeenSet() const { return m_validHasBeenSet; }
+    template<typename ValidT = GuardrailAutomatedReasoningValidFinding>
+    void SetValid(ValidT&& value) { m_validHasBeenSet = true; m_valid = std::forward<ValidT>(value); }
+    template<typename ValidT = GuardrailAutomatedReasoningValidFinding>
+    GuardrailAutomatedReasoningFinding& WithValid(ValidT&& value) { SetValid(std::forward<ValidT>(value)); return *this;}
+    ///@}
+
+    ///@{
+    
+    inline const GuardrailAutomatedReasoningInvalidFinding& GetInvalid() const { return m_invalid; }
+    inline bool InvalidHasBeenSet() const { return m_invalidHasBeenSet; }
+    template<typename InvalidT = GuardrailAutomatedReasoningInvalidFinding>
+    void SetInvalid(InvalidT&& value) { m_invalidHasBeenSet = true; m_invalid = std::forward<InvalidT>(value); }
+    template<typename InvalidT = GuardrailAutomatedReasoningInvalidFinding>
+    GuardrailAutomatedReasoningFinding& WithInvalid(InvalidT&& value) { SetInvalid(std::forward<InvalidT>(value)); return *this;}
+    ///@}
+
+    ///@{
+    
+    inline const GuardrailAutomatedReasoningSatisfiableFinding& GetSatisfiable() const { return m_satisfiable; }
+    inline bool SatisfiableHasBeenSet() const { return m_satisfiableHasBeenSet; }
+    template<typename SatisfiableT = GuardrailAutomatedReasoningSatisfiableFinding>
+    void SetSatisfiable(SatisfiableT&& value) { m_satisfiableHasBeenSet = true; m_satisfiable = std::forward<SatisfiableT>(value); }
+    template<typename SatisfiableT = GuardrailAutomatedReasoningSatisfiableFinding>
+    GuardrailAutomatedReasoningFinding& WithSatisfiable(SatisfiableT&& value) { SetSatisfiable(std::forward<SatisfiableT>(value)); return *this;}
+    ///@}
+
+    ///@{
+    
+    inline const GuardrailAutomatedReasoningImpossibleFinding& GetImpossible() const { return m_impossible; }
+    inline bool ImpossibleHasBeenSet() const { return m_impossibleHasBeenSet; }
+    template<typename ImpossibleT = GuardrailAutomatedReasoningImpossibleFinding>
+    void SetImpossible(ImpossibleT&& value) { m_impossibleHasBeenSet = true; m_impossible = std::forward<ImpossibleT>(value); }
+    template<typename ImpossibleT = GuardrailAutomatedReasoningImpossibleFinding>
+    GuardrailAutomatedReasoningFinding& WithImpossible(ImpossibleT&& value) { SetImpossible(std::forward<ImpossibleT>(value)); return *this;}
+    ///@}
+
+    ///@{
+    
+    inline const GuardrailAutomatedReasoningTranslationAmbiguousFinding& GetTranslationAmbiguous() const { return m_translationAmbiguous; }
+    inline bool TranslationAmbiguousHasBeenSet() const { return m_translationAmbiguousHasBeenSet; }
+    template<typename TranslationAmbiguousT = GuardrailAutomatedReasoningTranslationAmbiguousFinding>
+    void SetTranslationAmbiguous(TranslationAmbiguousT&& value) { m_translationAmbiguousHasBeenSet = true; m_translationAmbiguous = std::forward<TranslationAmbiguousT>(value); }
+    template<typename TranslationAmbiguousT = GuardrailAutomatedReasoningTranslationAmbiguousFinding>
+    GuardrailAutomatedReasoningFinding& WithTranslationAmbiguous(TranslationAmbiguousT&& value) { SetTranslationAmbiguous(std::forward<TranslationAmbiguousT>(value)); return *this;}
+    ///@}
+
+    ///@{
+    
+    inline const GuardrailAutomatedReasoningTooComplexFinding& GetTooComplex() const { return m_tooComplex; }
+    inline bool TooComplexHasBeenSet() const { return m_tooComplexHasBeenSet; }
+    template<typename TooComplexT = GuardrailAutomatedReasoningTooComplexFinding>
+    void SetTooComplex(TooComplexT&& value) { m_tooComplexHasBeenSet = true; m_tooComplex = std::forward<TooComplexT>(value); }
+    template<typename TooComplexT = GuardrailAutomatedReasoningTooComplexFinding>
+    GuardrailAutomatedReasoningFinding& WithTooComplex(TooComplexT&& value) { SetTooComplex(std::forward<TooComplexT>(value)); return *this;}
+    ///@}
+
+    ///@{
+    
+    inline const GuardrailAutomatedReasoningNoTranslationsFinding& GetNoTranslations() const { return m_noTranslations; }
+    inline bool NoTranslationsHasBeenSet() const { return m_noTranslationsHasBeenSet; }
+    template<typename NoTranslationsT = GuardrailAutomatedReasoningNoTranslationsFinding>
+    void SetNoTranslations(NoTranslationsT&& value) { m_noTranslationsHasBeenSet = true; m_noTranslations = std::forward<NoTranslationsT>(value); }
+    template<typename NoTranslationsT = GuardrailAutomatedReasoningNoTranslationsFinding>
+    GuardrailAutomatedReasoningFinding& WithNoTranslations(NoTranslationsT&& value) { SetNoTranslations(std::forward<NoTranslationsT>(value)); return *this;}
+    ///@}
+  private:
+
+    GuardrailAutomatedReasoningValidFinding m_valid;
+    bool m_validHasBeenSet = false;
+
+    GuardrailAutomatedReasoningInvalidFinding m_invalid;
+    bool m_invalidHasBeenSet = false;
+
+    GuardrailAutomatedReasoningSatisfiableFinding m_satisfiable;
+    bool m_satisfiableHasBeenSet = false;
+
+    GuardrailAutomatedReasoningImpossibleFinding m_impossible;
+    bool m_impossibleHasBeenSet = false;
+
+    GuardrailAutomatedReasoningTranslationAmbiguousFinding m_translationAmbiguous;
+    bool m_translationAmbiguousHasBeenSet = false;
+
+    GuardrailAutomatedReasoningTooComplexFinding m_tooComplex;
+    bool m_tooComplexHasBeenSet = false;
+
+    GuardrailAutomatedReasoningNoTranslationsFinding m_noTranslations;
+    bool m_noTranslationsHasBeenSet = false;
+  };
+
+} // namespace Model
+} // namespace BedrockRuntime
+} // namespace Aws

generated/src/aws-cpp-sdk-bedrock-runtime/include/aws/bedrock-runtime/model/GuardrailAutomatedReasoningImpossibleFinding.h

@@ -0,0 +1,97 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/bedrock-runtime/BedrockRuntime_EXPORTS.h>
+#include <aws/bedrock-runtime/model/GuardrailAutomatedReasoningTranslation.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/bedrock-runtime/model/GuardrailAutomatedReasoningLogicWarning.h>
+#include <aws/bedrock-runtime/model/GuardrailAutomatedReasoningRule.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace BedrockRuntime
+{
+namespace Model
+{
+
+  /**
+   * <p>Indicates that no valid claims can be made due to logical contradictions in
+   * the premises or rules.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/bedrock-runtime-2023-09-30/GuardrailAutomatedReasoningImpossibleFinding">AWS
+   * API Reference</a></p>
+   */
+  class GuardrailAutomatedReasoningImpossibleFinding
+  {
+  public:
+    AWS_BEDROCKRUNTIME_API GuardrailAutomatedReasoningImpossibleFinding() = default;
+    AWS_BEDROCKRUNTIME_API GuardrailAutomatedReasoningImpossibleFinding(Aws::Utils::Json::JsonView jsonValue);
+    AWS_BEDROCKRUNTIME_API GuardrailAutomatedReasoningImpossibleFinding& operator=(Aws::Utils::Json::JsonView jsonValue);
+    AWS_BEDROCKRUNTIME_API Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    ///@{
+    /**
+     * <p>The logical translation of the input that this finding evaluates.</p>
+     */
+    inline const GuardrailAutomatedReasoningTranslation& GetTranslation() const { return m_translation; }
+    inline bool TranslationHasBeenSet() const { return m_translationHasBeenSet; }
+    template<typename TranslationT = GuardrailAutomatedReasoningTranslation>
+    void SetTranslation(TranslationT&& value) { m_translationHasBeenSet = true; m_translation = std::forward<TranslationT>(value); }
+    template<typename TranslationT = GuardrailAutomatedReasoningTranslation>
+    GuardrailAutomatedReasoningImpossibleFinding& WithTranslation(TranslationT&& value) { SetTranslation(std::forward<TranslationT>(value)); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The automated reasoning policy rules that contradict the claims and/or
+     * premises in the input.</p>
+     */
+    inline const Aws::Vector<GuardrailAutomatedReasoningRule>& GetContradictingRules() const { return m_contradictingRules; }
+    inline bool ContradictingRulesHasBeenSet() const { return m_contradictingRulesHasBeenSet; }
+    template<typename ContradictingRulesT = Aws::Vector<GuardrailAutomatedReasoningRule>>
+    void SetContradictingRules(ContradictingRulesT&& value) { m_contradictingRulesHasBeenSet = true; m_contradictingRules = std::forward<ContradictingRulesT>(value); }
+    template<typename ContradictingRulesT = Aws::Vector<GuardrailAutomatedReasoningRule>>
+    GuardrailAutomatedReasoningImpossibleFinding& WithContradictingRules(ContradictingRulesT&& value) { SetContradictingRules(std::forward<ContradictingRulesT>(value)); return *this;}
+    template<typename ContradictingRulesT = GuardrailAutomatedReasoningRule>
+    GuardrailAutomatedReasoningImpossibleFinding& AddContradictingRules(ContradictingRulesT&& value) { m_contradictingRulesHasBeenSet = true; m_contradictingRules.emplace_back(std::forward<ContradictingRulesT>(value)); return *this; }
+    ///@}
+
+    ///@{
+    /**
+     * <p>Indication of a logic issue with the translation without needing to consider
+     * the automated reasoning policy rules.</p>
+     */
+    inline const GuardrailAutomatedReasoningLogicWarning& GetLogicWarning() const { return m_logicWarning; }
+    inline bool LogicWarningHasBeenSet() const { return m_logicWarningHasBeenSet; }
+    template<typename LogicWarningT = GuardrailAutomatedReasoningLogicWarning>
+    void SetLogicWarning(LogicWarningT&& value) { m_logicWarningHasBeenSet = true; m_logicWarning = std::forward<LogicWarningT>(value); }
+    template<typename LogicWarningT = GuardrailAutomatedReasoningLogicWarning>
+    GuardrailAutomatedReasoningImpossibleFinding& WithLogicWarning(LogicWarningT&& value) { SetLogicWarning(std::forward<LogicWarningT>(value)); return *this;}
+    ///@}
+  private:
+
+    GuardrailAutomatedReasoningTranslation m_translation;
+    bool m_translationHasBeenSet = false;
+
+    Aws::Vector<GuardrailAutomatedReasoningRule> m_contradictingRules;
+    bool m_contradictingRulesHasBeenSet = false;
+
+    GuardrailAutomatedReasoningLogicWarning m_logicWarning;
+    bool m_logicWarningHasBeenSet = false;
+  };
+
+} // namespace Model
+} // namespace BedrockRuntime
+} // namespace Aws

generated/src/aws-cpp-sdk-bedrock-runtime/include/aws/bedrock-runtime/model/GuardrailAutomatedReasoningInputTextReference.h

@@ -0,0 +1,60 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/bedrock-runtime/BedrockRuntime_EXPORTS.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 BedrockRuntime
+{
+namespace Model
+{
+
+  /**
+   * <p>References a portion of the original input text that corresponds to logical
+   * elements.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/bedrock-runtime-2023-09-30/GuardrailAutomatedReasoningInputTextReference">AWS
+   * API Reference</a></p>
+   */
+  class GuardrailAutomatedReasoningInputTextReference
+  {
+  public:
+    AWS_BEDROCKRUNTIME_API GuardrailAutomatedReasoningInputTextReference() = default;
+    AWS_BEDROCKRUNTIME_API GuardrailAutomatedReasoningInputTextReference(Aws::Utils::Json::JsonView jsonValue);
+    AWS_BEDROCKRUNTIME_API GuardrailAutomatedReasoningInputTextReference& operator=(Aws::Utils::Json::JsonView jsonValue);
+    AWS_BEDROCKRUNTIME_API Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    ///@{
+    /**
+     * <p>The specific text from the original input that this reference points to.</p>
+     */
+    inline const Aws::String& GetText() const { return m_text; }
+    inline bool TextHasBeenSet() const { return m_textHasBeenSet; }
+    template<typename TextT = Aws::String>
+    void SetText(TextT&& value) { m_textHasBeenSet = true; m_text = std::forward<TextT>(value); }
+    template<typename TextT = Aws::String>
+    GuardrailAutomatedReasoningInputTextReference& WithText(TextT&& value) { SetText(std::forward<TextT>(value)); return *this;}
+    ///@}
+  private:
+
+    Aws::String m_text;
+    bool m_textHasBeenSet = false;
+  };
+
+} // namespace Model
+} // namespace BedrockRuntime
+} // namespace Aws