Add dual stack endpoint to SDK

Added functionality for the Required and Hidden case rule types to be conditionally evaluated on up to 5 conditions.
Not need to include to any release notes. The only change is to correct LoadTimeout unit from milliseconds to seconds in RedshiftSettings
Adding first class support for AG-UI protocol in AgentCore Runtime.
This release introduces a new generative AI feature called Lex Bot Analyzer. This feature leverage AI to analyze the bot configuration against AWS Lex best practices to identify configuration issues and provides recommendations.

Author: aws-sdk-cpp-automation

VERSION

@@ -1 +1 @@
-1.11.765
+1.11.766

generated/src/aws-cpp-sdk-bedrock-agentcore-control/include/aws/bedrock-agentcore-control/model/ServerProtocol.h

@@ -10,7 +10,7 @@
 namespace Aws {
 namespace BedrockAgentCoreControl {
 namespace Model {
-enum class ServerProtocol { NOT_SET, MCP, HTTP, A2A };
+enum class ServerProtocol { NOT_SET, MCP, HTTP, A2A, AGUI };
 
 namespace ServerProtocolMapper {
 AWS_BEDROCKAGENTCORECONTROL_API ServerProtocol GetServerProtocolForName(const Aws::String& name);

generated/src/aws-cpp-sdk-bedrock-agentcore-control/source/model/ServerProtocol.cpp

@@ -18,6 +18,7 @@ namespace ServerProtocolMapper {
 static const int MCP_HASH = HashingUtils::HashString("MCP");
 static const int HTTP_HASH = HashingUtils::HashString("HTTP");
 static const int A2A_HASH = HashingUtils::HashString("A2A");
+static const int AGUI_HASH = HashingUtils::HashString("AGUI");
 
 ServerProtocol GetServerProtocolForName(const Aws::String& name) {
   int hashCode = HashingUtils::HashString(name.c_str());
@@ -27,6 +28,8 @@ ServerProtocol GetServerProtocolForName(const Aws::String& name) {
     return ServerProtocol::HTTP;
   } else if (hashCode == A2A_HASH) {
     return ServerProtocol::A2A;
+  } else if (hashCode == AGUI_HASH) {
+    return ServerProtocol::AGUI;
   }
   EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
   if (overflowContainer) {
@@ -47,6 +50,8 @@ Aws::String GetNameForServerProtocol(ServerProtocol enumValue) {
       return "HTTP";
     case ServerProtocol::A2A:
       return "A2A";
+    case ServerProtocol::AGUI:
+      return "AGUI";
     default:
       EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
       if (overflowContainer) {

generated/src/aws-cpp-sdk-connectcases/include/aws/connectcases/model/BooleanCondition.h

@@ -6,6 +6,7 @@
 #pragma once
 #include <aws/connectcases/ConnectCases_EXPORTS.h>
 #include <aws/connectcases/model/BooleanOperands.h>
+#include <aws/core/utils/memory/stl/AWSAllocator.h>
 
 #include <utility>
 
@@ -18,6 +19,7 @@ class JsonView;
 }  // namespace Utils
 namespace ConnectCases {
 namespace Model {
+class CompoundCondition;
 
 /**
  * <p>Boolean condition for a rule. In the Amazon Connect admin website, case rules
@@ -70,12 +72,56 @@ class BooleanCondition {
     return *this;
   }
   ///@}
+
+  ///@{
+  /**
+   * <p>Combines multiple conditions with AND operator. All conditions must be true
+   * for the compound condition to be true.</p>
+   */
+  inline const CompoundCondition& GetAndAll() const { return *m_andAll; }
+  inline bool AndAllHasBeenSet() const { return m_andAllHasBeenSet; }
+  template <typename AndAllT = CompoundCondition>
+  void SetAndAll(AndAllT&& value) {
+    m_andAllHasBeenSet = true;
+    m_andAll = Aws::MakeShared<CompoundCondition>("BooleanCondition", std::forward<AndAllT>(value));
+  }
+  template <typename AndAllT = CompoundCondition>
+  BooleanCondition& WithAndAll(AndAllT&& value) {
+    SetAndAll(std::forward<AndAllT>(value));
+    return *this;
+  }
+  ///@}
+
+  ///@{
+  /**
+   * <p>Combines multiple conditions with OR operator. At least one condition must be
+   * true for the compound condition to be true.</p>
+   */
+  inline const CompoundCondition& GetOrAll() const { return *m_orAll; }
+  inline bool OrAllHasBeenSet() const { return m_orAllHasBeenSet; }
+  template <typename OrAllT = CompoundCondition>
+  void SetOrAll(OrAllT&& value) {
+    m_orAllHasBeenSet = true;
+    m_orAll = Aws::MakeShared<CompoundCondition>("BooleanCondition", std::forward<OrAllT>(value));
+  }
+  template <typename OrAllT = CompoundCondition>
+  BooleanCondition& WithOrAll(OrAllT&& value) {
+    SetOrAll(std::forward<OrAllT>(value));
+    return *this;
+  }
+  ///@}
  private:
   BooleanOperands m_equalTo;
 
   BooleanOperands m_notEqualTo;
+
+  std::shared_ptr<CompoundCondition> m_andAll;
+
+  std::shared_ptr<CompoundCondition> m_orAll;
   bool m_equalToHasBeenSet = false;
   bool m_notEqualToHasBeenSet = false;
+  bool m_andAllHasBeenSet = false;
+  bool m_orAllHasBeenSet = false;
 };
 
 }  // namespace Model

generated/src/aws-cpp-sdk-connectcases/include/aws/connectcases/model/CompoundCondition.h

@@ -0,0 +1,70 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/connectcases/ConnectCases_EXPORTS.h>
+#include <aws/connectcases/model/BooleanCondition.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+
+#include <utility>
+
+namespace Aws {
+namespace Utils {
+namespace Json {
+class JsonValue;
+class JsonView;
+}  // namespace Json
+}  // namespace Utils
+namespace ConnectCases {
+namespace Model {
+class BooleanCondition;
+
+/**
+ * <p>A compound condition that combines multiple boolean conditions using logical
+ * operators. In the Amazon Connect admin website, case rules are known as <i>case
+ * field conditions</i>. For more information about case field conditions, see <a
+ * href="https://docs.aws.amazon.com/connect/latest/adminguide/case-field-conditions.html">Add
+ * case field conditions to a case template</a>.</p><p><h3>See Also:</h3>   <a
+ * href="http://docs.aws.amazon.com/goto/WebAPI/connectcases-2022-10-03/CompoundCondition">AWS
+ * API Reference</a></p>
+ */
+class CompoundCondition {
+ public:
+  AWS_CONNECTCASES_API CompoundCondition() = default;
+  AWS_CONNECTCASES_API CompoundCondition(Aws::Utils::Json::JsonView jsonValue);
+  AWS_CONNECTCASES_API CompoundCondition& operator=(Aws::Utils::Json::JsonView jsonValue);
+  AWS_CONNECTCASES_API Aws::Utils::Json::JsonValue Jsonize() const;
+
+  ///@{
+  /**
+   * <p>The list of conditions to combine using the logical operator.</p>
+   */
+  inline const Aws::Vector<BooleanCondition>& GetConditions() const { return m_conditions; }
+  inline bool ConditionsHasBeenSet() const { return m_conditionsHasBeenSet; }
+  template <typename ConditionsT = Aws::Vector<BooleanCondition>>
+  void SetConditions(ConditionsT&& value) {
+    m_conditionsHasBeenSet = true;
+    m_conditions = std::forward<ConditionsT>(value);
+  }
+  template <typename ConditionsT = Aws::Vector<BooleanCondition>>
+  CompoundCondition& WithConditions(ConditionsT&& value) {
+    SetConditions(std::forward<ConditionsT>(value));
+    return *this;
+  }
+  template <typename ConditionsT = BooleanCondition>
+  CompoundCondition& AddConditions(ConditionsT&& value) {
+    m_conditionsHasBeenSet = true;
+    m_conditions.emplace_back(std::forward<ConditionsT>(value));
+    return *this;
+  }
+  ///@}
+ private:
+  Aws::Vector<BooleanCondition> m_conditions;
+  bool m_conditionsHasBeenSet = false;
+};
+
+}  // namespace Model
+}  // namespace ConnectCases
+}  // namespace Aws

generated/src/aws-cpp-sdk-connectcases/source/model/BooleanCondition.cpp

@@ -4,6 +4,7 @@
  */
 
 #include <aws/connectcases/model/BooleanCondition.h>
+#include <aws/connectcases/model/CompoundCondition.h>
 #include <aws/core/utils/json/JsonSerializer.h>
 
 #include <utility>
@@ -26,6 +27,14 @@ BooleanCondition& BooleanCondition::operator=(JsonView jsonValue) {
     m_notEqualTo = jsonValue.GetObject("notEqualTo");
     m_notEqualToHasBeenSet = true;
   }
+  if (jsonValue.ValueExists("andAll")) {
+    m_andAll = Aws::MakeShared<CompoundCondition>("BooleanCondition", jsonValue.GetObject("andAll"));
+    m_andAllHasBeenSet = true;
+  }
+  if (jsonValue.ValueExists("orAll")) {
+    m_orAll = Aws::MakeShared<CompoundCondition>("BooleanCondition", jsonValue.GetObject("orAll"));
+    m_orAllHasBeenSet = true;
+  }
   return *this;
 }
 
@@ -40,6 +49,14 @@ JsonValue BooleanCondition::Jsonize() const {
     payload.WithObject("notEqualTo", m_notEqualTo.Jsonize());
   }
 
+  if (m_andAllHasBeenSet) {
+    payload.WithObject("andAll", m_andAll->Jsonize());
+  }
+
+  if (m_orAllHasBeenSet) {
+    payload.WithObject("orAll", m_orAll->Jsonize());
+  }
+
   return payload;
 }
 

generated/src/aws-cpp-sdk-connectcases/source/model/CompoundCondition.cpp

@@ -0,0 +1,47 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/connectcases/model/CompoundCondition.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+
+#include <utility>
+
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+
+namespace Aws {
+namespace ConnectCases {
+namespace Model {
+
+CompoundCondition::CompoundCondition(JsonView jsonValue) { *this = jsonValue; }
+
+CompoundCondition& CompoundCondition::operator=(JsonView jsonValue) {
+  if (jsonValue.ValueExists("conditions")) {
+    Aws::Utils::Array<JsonView> conditionsJsonList = jsonValue.GetArray("conditions");
+    for (unsigned conditionsIndex = 0; conditionsIndex < conditionsJsonList.GetLength(); ++conditionsIndex) {
+      m_conditions.push_back(conditionsJsonList[conditionsIndex].AsObject());
+    }
+    m_conditionsHasBeenSet = true;
+  }
+  return *this;
+}
+
+JsonValue CompoundCondition::Jsonize() const {
+  JsonValue payload;
+
+  if (m_conditionsHasBeenSet) {
+    Aws::Utils::Array<JsonValue> conditionsJsonList(m_conditions.size());
+    for (unsigned conditionsIndex = 0; conditionsIndex < conditionsJsonList.GetLength(); ++conditionsIndex) {
+      conditionsJsonList[conditionsIndex].AsObject(m_conditions[conditionsIndex].Jsonize());
+    }
+    payload.WithArray("conditions", std::move(conditionsJsonList));
+  }
+
+  return payload;
+}
+
+}  // namespace Model
+}  // namespace ConnectCases
+}  // namespace Aws

generated/src/aws-cpp-sdk-dms/include/aws/dms/model/RedshiftSettings.h

@@ -306,7 +306,7 @@ class RedshiftSettings {
 
   ///@{
   /**
-   * <p>The amount of time to wait (in milliseconds) before timing out of operations
+   * <p>The amount of time to wait (in seconds) before timing out of operations
    * performed by DMS on a Redshift cluster, such as Redshift COPY, INSERT, DELETE,
    * and UPDATE.</p>
    */