We've added stricter parameter validations to AWS IoT FleetWise signal catalog, model manifest, and decoder manifest APIs.

With this release, Bedrock Evaluation will now support custom metrics for evaluation.
This release adds following capabilities to Contact Lens Rules APIs 1/ 'ASSIGN_SLA' action and  '$.Case.TemplateId' comparison value for 'OnCaseCreate' and 'OnCaseUpdate' event sources 2/ 'OnSlaBreach' Cases event source which supports '$.RelatedItem.SlaConfiguration.Name' comparison value
Adds a new AccountSetting - defaultLogDriverMode for ECS.
Added support for IPv6 and dual stack for Valkey and Redis clusters. Customers can now launch new Valkey and Redis clusters with IPv6 and dual stack networking support.
Added new resource types to evaluate for public access in resource policies and added support for S3 directory bucket access points.
Doc only update for EC2 Auto Scaling.
Add versioning for HealthOmics workflows
Add Workspace Configuration APIs for Amazon Prometheus

Author: aws-sdk-cpp-automation

VERSION

@@ -1 +1 @@
-1.11.548
+1.11.549

generated/src/aws-cpp-sdk-accessanalyzer/include/aws/accessanalyzer/model/AccessCheckResourceType.h

@@ -33,7 +33,15 @@ namespace Model
     AWS_SecretsManager_Secret,
     AWS_SNS_Topic,
     AWS_SQS_Queue,
-    AWS_IAM_AssumeRolePolicyDocument
+    AWS_IAM_AssumeRolePolicyDocument,
+    AWS_S3Tables_TableBucket,
+    AWS_ApiGateway_RestApi,
+    AWS_CodeArtifact_Domain,
+    AWS_Backup_BackupVault,
+    AWS_CloudTrail_Dashboard,
+    AWS_CloudTrail_EventDataStore,
+    AWS_S3Tables_Table,
+    AWS_S3Express_AccessPoint
   };
 
 namespace AccessCheckResourceTypeMapper

generated/src/aws-cpp-sdk-accessanalyzer/include/aws/accessanalyzer/model/NetworkOriginConfiguration.h

@@ -26,12 +26,11 @@ namespace Model
 
   /**
    * <p>The proposed <code>InternetConfiguration</code> or
-   * <code>VpcConfiguration</code> to apply to the Amazon S3 access point.
-   * <code>VpcConfiguration</code> does not apply to multi-region access points. You
-   * can make the access point accessible from the internet, or you can specify that
-   * all requests made through that access point must originate from a specific
-   * virtual private cloud (VPC). You can specify only one type of network
-   * configuration. For more information, see <a
+   * <code>VpcConfiguration</code> to apply to the Amazon S3 access point. You can
+   * make the access point accessible from the internet, or you can specify that all
+   * requests made through that access point must originate from a specific virtual
+   * private cloud (VPC). You can specify only one type of network configuration. For
+   * more information, see <a
    * href="https://docs.aws.amazon.com/AmazonS3/latest/dev/creating-access-points.html">Creating
    * access points</a>.</p><p><h3>See Also:</h3>   <a
    * href="http://docs.aws.amazon.com/goto/WebAPI/accessanalyzer-2019-11-01/NetworkOriginConfiguration">AWS

generated/src/aws-cpp-sdk-accessanalyzer/include/aws/accessanalyzer/model/S3AccessPointConfiguration.h

@@ -81,7 +81,7 @@ namespace Model
      * multi-region access points. If the access preview is for a new resource and
      * neither is specified, the access preview uses <code>Internet</code> for the
      * network origin. If the access preview is for an existing resource and neither is
-     * specified, the access preview uses the exiting network origin.</p>
+     * specified, the access preview uses the existing network origin.</p>
      */
     inline const NetworkOriginConfiguration& GetNetworkOrigin() const { return m_networkOrigin; }
     inline bool NetworkOriginHasBeenSet() const { return m_networkOriginHasBeenSet; }

generated/src/aws-cpp-sdk-accessanalyzer/include/aws/accessanalyzer/model/S3ExpressDirectoryAccessPointConfiguration.h

@@ -0,0 +1,83 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/accessanalyzer/AccessAnalyzer_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/accessanalyzer/model/NetworkOriginConfiguration.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace AccessAnalyzer
+{
+namespace Model
+{
+
+  /**
+   * <p>Proposed configuration for an access point attached to an Amazon S3 directory
+   * bucket. You can propose up to 10 access points per bucket. If the proposed
+   * access point configuration is for an existing Amazon S3 directory bucket, the
+   * access preview uses the proposed access point configuration in place of the
+   * existing access points. To propose an access point without a policy, you can
+   * provide an empty string as the access point policy. For more information about
+   * access points for Amazon S3 directory buckets, see <a
+   * href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/access-points-directory-buckets.html">Managing
+   * access to directory buckets with access points</a> in the Amazon Simple Storage
+   * Service User Guide.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/accessanalyzer-2019-11-01/S3ExpressDirectoryAccessPointConfiguration">AWS
+   * API Reference</a></p>
+   */
+  class S3ExpressDirectoryAccessPointConfiguration
+  {
+  public:
+    AWS_ACCESSANALYZER_API S3ExpressDirectoryAccessPointConfiguration() = default;
+    AWS_ACCESSANALYZER_API S3ExpressDirectoryAccessPointConfiguration(Aws::Utils::Json::JsonView jsonValue);
+    AWS_ACCESSANALYZER_API S3ExpressDirectoryAccessPointConfiguration& operator=(Aws::Utils::Json::JsonView jsonValue);
+    AWS_ACCESSANALYZER_API Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    ///@{
+    /**
+     * <p>The proposed access point policy for an Amazon S3 directory bucket access
+     * point.</p>
+     */
+    inline const Aws::String& GetAccessPointPolicy() const { return m_accessPointPolicy; }
+    inline bool AccessPointPolicyHasBeenSet() const { return m_accessPointPolicyHasBeenSet; }
+    template<typename AccessPointPolicyT = Aws::String>
+    void SetAccessPointPolicy(AccessPointPolicyT&& value) { m_accessPointPolicyHasBeenSet = true; m_accessPointPolicy = std::forward<AccessPointPolicyT>(value); }
+    template<typename AccessPointPolicyT = Aws::String>
+    S3ExpressDirectoryAccessPointConfiguration& WithAccessPointPolicy(AccessPointPolicyT&& value) { SetAccessPointPolicy(std::forward<AccessPointPolicyT>(value)); return *this;}
+    ///@}
+
+    ///@{
+    
+    inline const NetworkOriginConfiguration& GetNetworkOrigin() const { return m_networkOrigin; }
+    inline bool NetworkOriginHasBeenSet() const { return m_networkOriginHasBeenSet; }
+    template<typename NetworkOriginT = NetworkOriginConfiguration>
+    void SetNetworkOrigin(NetworkOriginT&& value) { m_networkOriginHasBeenSet = true; m_networkOrigin = std::forward<NetworkOriginT>(value); }
+    template<typename NetworkOriginT = NetworkOriginConfiguration>
+    S3ExpressDirectoryAccessPointConfiguration& WithNetworkOrigin(NetworkOriginT&& value) { SetNetworkOrigin(std::forward<NetworkOriginT>(value)); return *this;}
+    ///@}
+  private:
+
+    Aws::String m_accessPointPolicy;
+    bool m_accessPointPolicyHasBeenSet = false;
+
+    NetworkOriginConfiguration m_networkOrigin;
+    bool m_networkOriginHasBeenSet = false;
+  };
+
+} // namespace Model
+} // namespace AccessAnalyzer
+} // namespace Aws

generated/src/aws-cpp-sdk-accessanalyzer/include/aws/accessanalyzer/model/S3ExpressDirectoryBucketConfiguration.h

@@ -6,6 +6,8 @@
 #pragma once
 #include <aws/accessanalyzer/AccessAnalyzer_EXPORTS.h>
 #include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSMap.h>
+#include <aws/accessanalyzer/model/S3ExpressDirectoryAccessPointConfiguration.h>
 #include <utility>
 
 namespace Aws
@@ -35,8 +37,8 @@ namespace Model
    * existing bucket policy, you can specify an empty string. For more information
    * about Amazon S3 directory bucket policies, see <a
    * href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-express-security-iam-example-bucket-policies.html">Example
-   * directory bucket policies for S3 Express One Zone</a>.</p><p><h3>See Also:</h3> 
-   * <a
+   * bucket policies for directory buckets</a> in the Amazon Simple Storage Service
+   * User Guide.</p><p><h3>See Also:</h3>   <a
    * href="http://docs.aws.amazon.com/goto/WebAPI/accessanalyzer-2019-11-01/S3ExpressDirectoryBucketConfiguration">AWS
    * API Reference</a></p>
    */
@@ -60,10 +62,29 @@ namespace Model
     template<typename BucketPolicyT = Aws::String>
     S3ExpressDirectoryBucketConfiguration& WithBucketPolicy(BucketPolicyT&& value) { SetBucketPolicy(std::forward<BucketPolicyT>(value)); return *this;}
     ///@}
+
+    ///@{
+    /**
+     * <p>The proposed access points for the Amazon S3 directory bucket.</p>
+     */
+    inline const Aws::Map<Aws::String, S3ExpressDirectoryAccessPointConfiguration>& GetAccessPoints() const { return m_accessPoints; }
+    inline bool AccessPointsHasBeenSet() const { return m_accessPointsHasBeenSet; }
+    template<typename AccessPointsT = Aws::Map<Aws::String, S3ExpressDirectoryAccessPointConfiguration>>
+    void SetAccessPoints(AccessPointsT&& value) { m_accessPointsHasBeenSet = true; m_accessPoints = std::forward<AccessPointsT>(value); }
+    template<typename AccessPointsT = Aws::Map<Aws::String, S3ExpressDirectoryAccessPointConfiguration>>
+    S3ExpressDirectoryBucketConfiguration& WithAccessPoints(AccessPointsT&& value) { SetAccessPoints(std::forward<AccessPointsT>(value)); return *this;}
+    template<typename AccessPointsKeyT = Aws::String, typename AccessPointsValueT = S3ExpressDirectoryAccessPointConfiguration>
+    S3ExpressDirectoryBucketConfiguration& AddAccessPoints(AccessPointsKeyT&& key, AccessPointsValueT&& value) {
+      m_accessPointsHasBeenSet = true; m_accessPoints.emplace(std::forward<AccessPointsKeyT>(key), std::forward<AccessPointsValueT>(value)); return *this;
+    }
+    ///@}
   private:
 
     Aws::String m_bucketPolicy;
     bool m_bucketPolicyHasBeenSet = false;
+
+    Aws::Map<Aws::String, S3ExpressDirectoryAccessPointConfiguration> m_accessPoints;
+    bool m_accessPointsHasBeenSet = false;
   };
 
 } // namespace Model

generated/src/aws-cpp-sdk-accessanalyzer/source/model/AccessCheckResourceType.cpp

@@ -38,6 +38,14 @@ namespace Aws
         static const int AWS_SNS_Topic_HASH = HashingUtils::HashString("AWS::SNS::Topic");
         static const int AWS_SQS_Queue_HASH = HashingUtils::HashString("AWS::SQS::Queue");
         static const int AWS_IAM_AssumeRolePolicyDocument_HASH = HashingUtils::HashString("AWS::IAM::AssumeRolePolicyDocument");
+        static const int AWS_S3Tables_TableBucket_HASH = HashingUtils::HashString("AWS::S3Tables::TableBucket");
+        static const int AWS_ApiGateway_RestApi_HASH = HashingUtils::HashString("AWS::ApiGateway::RestApi");
+        static const int AWS_CodeArtifact_Domain_HASH = HashingUtils::HashString("AWS::CodeArtifact::Domain");
+        static const int AWS_Backup_BackupVault_HASH = HashingUtils::HashString("AWS::Backup::BackupVault");
+        static const int AWS_CloudTrail_Dashboard_HASH = HashingUtils::HashString("AWS::CloudTrail::Dashboard");
+        static const int AWS_CloudTrail_EventDataStore_HASH = HashingUtils::HashString("AWS::CloudTrail::EventDataStore");
+        static const int AWS_S3Tables_Table_HASH = HashingUtils::HashString("AWS::S3Tables::Table");
+        static const int AWS_S3Express_AccessPoint_HASH = HashingUtils::HashString("AWS::S3Express::AccessPoint");
 
 
         AccessCheckResourceType GetAccessCheckResourceTypeForName(const Aws::String& name)
@@ -115,6 +123,38 @@ namespace Aws
           {
             return AccessCheckResourceType::AWS_IAM_AssumeRolePolicyDocument;
           }
+          else if (hashCode == AWS_S3Tables_TableBucket_HASH)
+          {
+            return AccessCheckResourceType::AWS_S3Tables_TableBucket;
+          }
+          else if (hashCode == AWS_ApiGateway_RestApi_HASH)
+          {
+            return AccessCheckResourceType::AWS_ApiGateway_RestApi;
+          }
+          else if (hashCode == AWS_CodeArtifact_Domain_HASH)
+          {
+            return AccessCheckResourceType::AWS_CodeArtifact_Domain;
+          }
+          else if (hashCode == AWS_Backup_BackupVault_HASH)
+          {
+            return AccessCheckResourceType::AWS_Backup_BackupVault;
+          }
+          else if (hashCode == AWS_CloudTrail_Dashboard_HASH)
+          {
+            return AccessCheckResourceType::AWS_CloudTrail_Dashboard;
+          }
+          else if (hashCode == AWS_CloudTrail_EventDataStore_HASH)
+          {
+            return AccessCheckResourceType::AWS_CloudTrail_EventDataStore;
+          }
+          else if (hashCode == AWS_S3Tables_Table_HASH)
+          {
+            return AccessCheckResourceType::AWS_S3Tables_Table;
+          }
+          else if (hashCode == AWS_S3Express_AccessPoint_HASH)
+          {
+            return AccessCheckResourceType::AWS_S3Express_AccessPoint;
+          }
           EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
           if(overflowContainer)
           {
@@ -167,6 +207,22 @@ namespace Aws
             return "AWS::SQS::Queue";
           case AccessCheckResourceType::AWS_IAM_AssumeRolePolicyDocument:
             return "AWS::IAM::AssumeRolePolicyDocument";
+          case AccessCheckResourceType::AWS_S3Tables_TableBucket:
+            return "AWS::S3Tables::TableBucket";
+          case AccessCheckResourceType::AWS_ApiGateway_RestApi:
+            return "AWS::ApiGateway::RestApi";
+          case AccessCheckResourceType::AWS_CodeArtifact_Domain:
+            return "AWS::CodeArtifact::Domain";
+          case AccessCheckResourceType::AWS_Backup_BackupVault:
+            return "AWS::Backup::BackupVault";
+          case AccessCheckResourceType::AWS_CloudTrail_Dashboard:
+            return "AWS::CloudTrail::Dashboard";
+          case AccessCheckResourceType::AWS_CloudTrail_EventDataStore:
+            return "AWS::CloudTrail::EventDataStore";
+          case AccessCheckResourceType::AWS_S3Tables_Table:
+            return "AWS::S3Tables::Table";
+          case AccessCheckResourceType::AWS_S3Express_AccessPoint:
+            return "AWS::S3Express::AccessPoint";
           default:
             EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
             if(overflowContainer)

generated/src/aws-cpp-sdk-accessanalyzer/source/model/S3ExpressDirectoryAccessPointConfiguration.cpp

@@ -0,0 +1,62 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/accessanalyzer/model/S3ExpressDirectoryAccessPointConfiguration.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+
+#include <utility>
+
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+
+namespace Aws
+{
+namespace AccessAnalyzer
+{
+namespace Model
+{
+
+S3ExpressDirectoryAccessPointConfiguration::S3ExpressDirectoryAccessPointConfiguration(JsonView jsonValue)
+{
+  *this = jsonValue;
+}
+
+S3ExpressDirectoryAccessPointConfiguration& S3ExpressDirectoryAccessPointConfiguration::operator =(JsonView jsonValue)
+{
+  if(jsonValue.ValueExists("accessPointPolicy"))
+  {
+    m_accessPointPolicy = jsonValue.GetString("accessPointPolicy");
+    m_accessPointPolicyHasBeenSet = true;
+  }
+  if(jsonValue.ValueExists("networkOrigin"))
+  {
+    m_networkOrigin = jsonValue.GetObject("networkOrigin");
+    m_networkOriginHasBeenSet = true;
+  }
+  return *this;
+}
+
+JsonValue S3ExpressDirectoryAccessPointConfiguration::Jsonize() const
+{
+  JsonValue payload;
+
+  if(m_accessPointPolicyHasBeenSet)
+  {
+   payload.WithString("accessPointPolicy", m_accessPointPolicy);
+
+  }
+
+  if(m_networkOriginHasBeenSet)
+  {
+   payload.WithObject("networkOrigin", m_networkOrigin.Jsonize());
+
+  }
+
+  return payload;
+}
+
+} // namespace Model
+} // namespace AccessAnalyzer
+} // namespace Aws

generated/src/aws-cpp-sdk-accessanalyzer/source/model/S3ExpressDirectoryBucketConfiguration.cpp

@@ -30,6 +30,15 @@ S3ExpressDirectoryBucketConfiguration& S3ExpressDirectoryBucketConfiguration::op
     m_bucketPolicy = jsonValue.GetString("bucketPolicy");
     m_bucketPolicyHasBeenSet = true;
   }
+  if(jsonValue.ValueExists("accessPoints"))
+  {
+    Aws::Map<Aws::String, JsonView> accessPointsJsonMap = jsonValue.GetObject("accessPoints").GetAllObjects();
+    for(auto& accessPointsItem : accessPointsJsonMap)
+    {
+      m_accessPoints[accessPointsItem.first] = accessPointsItem.second.AsObject();
+    }
+    m_accessPointsHasBeenSet = true;
+  }
   return *this;
 }
 
@@ -43,6 +52,17 @@ JsonValue S3ExpressDirectoryBucketConfiguration::Jsonize() const
 
   }
 
+  if(m_accessPointsHasBeenSet)
+  {
+   JsonValue accessPointsJsonMap;
+   for(auto& accessPointsItem : m_accessPoints)
+   {
+     accessPointsJsonMap.WithObject(accessPointsItem.first, accessPointsItem.second.Jsonize());
+   }
+   payload.WithObject("accessPoints", std::move(accessPointsJsonMap));
+
+  }
+
   return payload;
 }