Updated descriptions for number of PreParseTextTransformations allowed per rule statement

This release adds support for customer-managed backup restore, and encryption of new DbInstances and DbClusters using customer-managed KMS keys.
Launch CMK support for Telemetry Enablement Organization and Account Rules.
Added eksNodeName, instanceId, and zone optional parameters to the AssumeRoleForPodIdentity API.
This launch allows customers to use Network Firewall as an explicit Proxy and protect their workloads against threat of data exfiltration.
Updates Kantar server URL validation to accept Fifty5Blue domain. Adds support for output to S3 Glacier Instant Retrieval.
Added route visibility support for AWS Direct Connect, allowing customers to call ListVirtualInterfaceRoutes to view the BGP routes including AS path and BGP communities advertised over their virtual interfaces.

Author: aws-sdk-cpp-automation

VERSION

@@ -1 +1 @@
-1.11.861
+1.11.862

generated/src/aws-cpp-sdk-directconnect/include/aws/directconnect/DirectConnectClient.h

@@ -1729,6 +1729,40 @@ class AWS_DIRECTCONNECT_API DirectConnectClient : public Aws::Client::AWSJsonCli
     return SubmitAsync(&DirectConnectClient::DisassociateMacSecKey, request, handler, context);
   }
 
+  /**
+   * <p>Lists the routes for the specified virtual interface.</p> <p>Use the
+   * <code>routeDirection</code> filter to control which routes are returned:</p>
+   * <ul> <li> <p> <code>accepted</code>: routes received from the customer network
+   * over the virtual interface.</p> </li> <li> <p> <code>advertised</code>: routes
+   * advertised to the customer network over the virtual interface.</p> </li>
+   * </ul><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/directconnect-2012-10-25/ListVirtualInterfaceRoutes">AWS
+   * API Reference</a></p>
+   */
+  virtual Model::ListVirtualInterfaceRoutesOutcome ListVirtualInterfaceRoutes(
+      const Model::ListVirtualInterfaceRoutesRequest& request = {}) const;
+
+  /**
+   * A Callable wrapper for ListVirtualInterfaceRoutes that returns a future to the operation so that it can be executed in parallel to
+   * other requests.
+   */
+  template <typename ListVirtualInterfaceRoutesRequestT = Model::ListVirtualInterfaceRoutesRequest>
+  Model::ListVirtualInterfaceRoutesOutcomeCallable ListVirtualInterfaceRoutesCallable(
+      const ListVirtualInterfaceRoutesRequestT& request = {}) const {
+    return SubmitCallable(&DirectConnectClient::ListVirtualInterfaceRoutes, request);
+  }
+
+  /**
+   * An Async wrapper for ListVirtualInterfaceRoutes that queues the request into a thread executor and triggers associated callback when
+   * operation has finished.
+   */
+  template <typename ListVirtualInterfaceRoutesRequestT = Model::ListVirtualInterfaceRoutesRequest>
+  void ListVirtualInterfaceRoutesAsync(const ListVirtualInterfaceRoutesResponseReceivedHandler& handler,
+                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
+                                       const ListVirtualInterfaceRoutesRequestT& request = {}) const {
+    return SubmitAsync(&DirectConnectClient::ListVirtualInterfaceRoutes, request, handler, context);
+  }
+
   /**
    * <p>Lists the virtual interface failover test history.</p><p><h3>See Also:</h3>
    * <a

generated/src/aws-cpp-sdk-directconnect/include/aws/directconnect/DirectConnectServiceClientModel.h

@@ -83,6 +83,8 @@
 #include <aws/directconnect/model/DescribeVirtualInterfacesResult.h>
 #include <aws/directconnect/model/DisassociateConnectionFromLagResult.h>
 #include <aws/directconnect/model/DisassociateMacSecKeyResult.h>
+#include <aws/directconnect/model/ListVirtualInterfaceRoutesRequest.h>
+#include <aws/directconnect/model/ListVirtualInterfaceRoutesResult.h>
 #include <aws/directconnect/model/ListVirtualInterfaceTestHistoryRequest.h>
 #include <aws/directconnect/model/ListVirtualInterfaceTestHistoryResult.h>
 #include <aws/directconnect/model/StartBgpFailoverTestResult.h>
@@ -177,6 +179,7 @@ class DescribeVirtualGatewaysRequest;
 class DescribeVirtualInterfacesRequest;
 class DisassociateConnectionFromLagRequest;
 class DisassociateMacSecKeyRequest;
+class ListVirtualInterfaceRoutesRequest;
 class ListVirtualInterfaceTestHistoryRequest;
 class StartBgpFailoverTestRequest;
 class StopBgpFailoverTestRequest;
@@ -245,6 +248,7 @@ typedef Aws::Utils::Outcome<DescribeVirtualGatewaysResult, DirectConnectError> D
 typedef Aws::Utils::Outcome<DescribeVirtualInterfacesResult, DirectConnectError> DescribeVirtualInterfacesOutcome;
 typedef Aws::Utils::Outcome<DisassociateConnectionFromLagResult, DirectConnectError> DisassociateConnectionFromLagOutcome;
 typedef Aws::Utils::Outcome<DisassociateMacSecKeyResult, DirectConnectError> DisassociateMacSecKeyOutcome;
+typedef Aws::Utils::Outcome<ListVirtualInterfaceRoutesResult, DirectConnectError> ListVirtualInterfaceRoutesOutcome;
 typedef Aws::Utils::Outcome<ListVirtualInterfaceTestHistoryResult, DirectConnectError> ListVirtualInterfaceTestHistoryOutcome;
 typedef Aws::Utils::Outcome<StartBgpFailoverTestResult, DirectConnectError> StartBgpFailoverTestOutcome;
 typedef Aws::Utils::Outcome<StopBgpFailoverTestResult, DirectConnectError> StopBgpFailoverTestOutcome;
@@ -308,6 +312,7 @@ typedef std::future<DescribeVirtualGatewaysOutcome> DescribeVirtualGatewaysOutco
 typedef std::future<DescribeVirtualInterfacesOutcome> DescribeVirtualInterfacesOutcomeCallable;
 typedef std::future<DisassociateConnectionFromLagOutcome> DisassociateConnectionFromLagOutcomeCallable;
 typedef std::future<DisassociateMacSecKeyOutcome> DisassociateMacSecKeyOutcomeCallable;
+typedef std::future<ListVirtualInterfaceRoutesOutcome> ListVirtualInterfaceRoutesOutcomeCallable;
 typedef std::future<ListVirtualInterfaceTestHistoryOutcome> ListVirtualInterfaceTestHistoryOutcomeCallable;
 typedef std::future<StartBgpFailoverTestOutcome> StartBgpFailoverTestOutcomeCallable;
 typedef std::future<StopBgpFailoverTestOutcome> StopBgpFailoverTestOutcomeCallable;
@@ -490,6 +495,9 @@ typedef std::function<void(const DirectConnectClient*, const Model::Disassociate
 typedef std::function<void(const DirectConnectClient*, const Model::DisassociateMacSecKeyRequest&,
                            const Model::DisassociateMacSecKeyOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&)>
     DisassociateMacSecKeyResponseReceivedHandler;
+typedef std::function<void(const DirectConnectClient*, const Model::ListVirtualInterfaceRoutesRequest&,
+                           const Model::ListVirtualInterfaceRoutesOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&)>
+    ListVirtualInterfaceRoutesResponseReceivedHandler;
 typedef std::function<void(const DirectConnectClient*, const Model::ListVirtualInterfaceTestHistoryRequest&,
                            const Model::ListVirtualInterfaceTestHistoryOutcome&,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>&)>

generated/src/aws-cpp-sdk-directconnect/include/aws/directconnect/model/AsPathSegment.h

@@ -0,0 +1,85 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/directconnect/DirectConnect_EXPORTS.h>
+#include <aws/directconnect/model/AsPathType.h>
+
+#include <utility>
+
+namespace Aws {
+namespace Utils {
+namespace Json {
+class JsonValue;
+class JsonView;
+}  // namespace Json
+}  // namespace Utils
+namespace DirectConnect {
+namespace Model {
+
+/**
+ * <p>A segment of an autonomous system (AS) path.</p><p><h3>See Also:</h3>   <a
+ * href="http://docs.aws.amazon.com/goto/WebAPI/directconnect-2012-10-25/AsPathSegment">AWS
+ * API Reference</a></p>
+ */
+class AsPathSegment {
+ public:
+  AWS_DIRECTCONNECT_API AsPathSegment() = default;
+  AWS_DIRECTCONNECT_API AsPathSegment(Aws::Utils::Json::JsonView jsonValue);
+  AWS_DIRECTCONNECT_API AsPathSegment& operator=(Aws::Utils::Json::JsonView jsonValue);
+  AWS_DIRECTCONNECT_API Aws::Utils::Json::JsonValue Jsonize() const;
+
+  ///@{
+  /**
+   * <p>The type of the AS path segment.</p> <p>The valid values are <code>seq</code>
+   * (an ordered <code>AS_SEQUENCE</code>) and <code>set</code> (an unordered
+   * <code>AS_SET</code>).</p>
+   */
+  inline AsPathType GetPathType() const { return m_pathType; }
+  inline bool PathTypeHasBeenSet() const { return m_pathTypeHasBeenSet; }
+  inline void SetPathType(AsPathType value) {
+    m_pathTypeHasBeenSet = true;
+    m_pathType = value;
+  }
+  inline AsPathSegment& WithPathType(AsPathType value) {
+    SetPathType(value);
+    return *this;
+  }
+  ///@}
+
+  ///@{
+  /**
+   * <p>The autonomous system (AS) numbers in the segment.</p>
+   */
+  inline const Aws::Vector<long long>& GetPath() const { return m_path; }
+  inline bool PathHasBeenSet() const { return m_pathHasBeenSet; }
+  template <typename PathT = Aws::Vector<long long>>
+  void SetPath(PathT&& value) {
+    m_pathHasBeenSet = true;
+    m_path = std::forward<PathT>(value);
+  }
+  template <typename PathT = Aws::Vector<long long>>
+  AsPathSegment& WithPath(PathT&& value) {
+    SetPath(std::forward<PathT>(value));
+    return *this;
+  }
+  inline AsPathSegment& AddPath(long long value) {
+    m_pathHasBeenSet = true;
+    m_path.push_back(value);
+    return *this;
+  }
+  ///@}
+ private:
+  AsPathType m_pathType{AsPathType::NOT_SET};
+
+  Aws::Vector<long long> m_path;
+  bool m_pathTypeHasBeenSet = false;
+  bool m_pathHasBeenSet = false;
+};
+
+}  // namespace Model
+}  // namespace DirectConnect
+}  // namespace Aws

generated/src/aws-cpp-sdk-directconnect/include/aws/directconnect/model/AsPathType.h

@@ -0,0 +1,22 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/directconnect/DirectConnect_EXPORTS.h>
+
+namespace Aws {
+namespace DirectConnect {
+namespace Model {
+enum class AsPathType { NOT_SET, seq, set };
+
+namespace AsPathTypeMapper {
+AWS_DIRECTCONNECT_API AsPathType GetAsPathTypeForName(const Aws::String& name);
+
+AWS_DIRECTCONNECT_API Aws::String GetNameForAsPathType(AsPathType value);
+}  // namespace AsPathTypeMapper
+}  // namespace Model
+}  // namespace DirectConnect
+}  // namespace Aws

generated/src/aws-cpp-sdk-directconnect/include/aws/directconnect/model/ListVirtualInterfaceRoutesRequest.h

@@ -0,0 +1,122 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/directconnect/DirectConnectRequest.h>
+#include <aws/directconnect/DirectConnect_EXPORTS.h>
+#include <aws/directconnect/model/RouteFilters.h>
+
+#include <utility>
+
+namespace Aws {
+namespace DirectConnect {
+namespace Model {
+
+/**
+ */
+class ListVirtualInterfaceRoutesRequest : public DirectConnectRequest {
+ public:
+  AWS_DIRECTCONNECT_API ListVirtualInterfaceRoutesRequest() = default;
+
+  // Service request name is the Operation name which will send this request out,
+  // each operation should has unique request name, so that we can get operation's name from this request.
+  // Note: this is not true for response, multiple operations may have the same response name,
+  // so we can not get operation's name from response.
+  inline virtual const char* GetServiceRequestName() const override { return "ListVirtualInterfaceRoutes"; }
+
+  AWS_DIRECTCONNECT_API Aws::String SerializePayload() const override;
+
+  AWS_DIRECTCONNECT_API Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+  ///@{
+  /**
+   * <p>The ID of the virtual interface.</p>
+   */
+  inline const Aws::String& GetVirtualInterfaceId() const { return m_virtualInterfaceId; }
+  inline bool VirtualInterfaceIdHasBeenSet() const { return m_virtualInterfaceIdHasBeenSet; }
+  template <typename VirtualInterfaceIdT = Aws::String>
+  void SetVirtualInterfaceId(VirtualInterfaceIdT&& value) {
+    m_virtualInterfaceIdHasBeenSet = true;
+    m_virtualInterfaceId = std::forward<VirtualInterfaceIdT>(value);
+  }
+  template <typename VirtualInterfaceIdT = Aws::String>
+  ListVirtualInterfaceRoutesRequest& WithVirtualInterfaceId(VirtualInterfaceIdT&& value) {
+    SetVirtualInterfaceId(std::forward<VirtualInterfaceIdT>(value));
+    return *this;
+  }
+  ///@}
+
+  ///@{
+  /**
+   * <p>The filters to apply to the routes returned.</p>
+   */
+  inline const RouteFilters& GetFilters() const { return m_filters; }
+  inline bool FiltersHasBeenSet() const { return m_filtersHasBeenSet; }
+  template <typename FiltersT = RouteFilters>
+  void SetFilters(FiltersT&& value) {
+    m_filtersHasBeenSet = true;
+    m_filters = std::forward<FiltersT>(value);
+  }
+  template <typename FiltersT = RouteFilters>
+  ListVirtualInterfaceRoutesRequest& WithFilters(FiltersT&& value) {
+    SetFilters(std::forward<FiltersT>(value));
+    return *this;
+  }
+  ///@}
+
+  ///@{
+  /**
+   * <p>The maximum number of results to return with a single call. To retrieve the
+   * remaining results, make another call with the returned <code>nextToken</code>
+   * value.</p> <p>If <code>MaxResults</code> is given a value larger than 100, only
+   * 100 results are returned.</p>
+   */
+  inline int GetMaxResults() const { return m_maxResults; }
+  inline bool MaxResultsHasBeenSet() const { return m_maxResultsHasBeenSet; }
+  inline void SetMaxResults(int value) {
+    m_maxResultsHasBeenSet = true;
+    m_maxResults = value;
+  }
+  inline ListVirtualInterfaceRoutesRequest& WithMaxResults(int value) {
+    SetMaxResults(value);
+    return *this;
+  }
+  ///@}
+
+  ///@{
+  /**
+   * <p>The token for the next page of results.</p>
+   */
+  inline const Aws::String& GetNextToken() const { return m_nextToken; }
+  inline bool NextTokenHasBeenSet() const { return m_nextTokenHasBeenSet; }
+  template <typename NextTokenT = Aws::String>
+  void SetNextToken(NextTokenT&& value) {
+    m_nextTokenHasBeenSet = true;
+    m_nextToken = std::forward<NextTokenT>(value);
+  }
+  template <typename NextTokenT = Aws::String>
+  ListVirtualInterfaceRoutesRequest& WithNextToken(NextTokenT&& value) {
+    SetNextToken(std::forward<NextTokenT>(value));
+    return *this;
+  }
+  ///@}
+ private:
+  Aws::String m_virtualInterfaceId;
+
+  RouteFilters m_filters;
+
+  int m_maxResults{0};
+
+  Aws::String m_nextToken;
+  bool m_virtualInterfaceIdHasBeenSet = false;
+  bool m_filtersHasBeenSet = false;
+  bool m_maxResultsHasBeenSet = false;
+  bool m_nextTokenHasBeenSet = false;
+};
+
+}  // namespace Model
+}  // namespace DirectConnect
+}  // namespace Aws