Added data protection settings with support for inline data redaction.

This release supports Metadata Enforcement Rule feature for Create Subscription Request action.
Enabling call caching feature that allows customers to reuse previously computed results from a set of completed tasks in a new workflow run.
This release adds support for Provisioning Timestream Compute Units (TCUs), a new feature that allows provisioning dedicated compute resources for your queries, providing predictable and cost-effective query performance.
Add Node 22.x (node22.x) support to AWS Lambda
Added support for Rocky Linux 8 on Amazon WorkSpaces Personal.
This release adds support for scale storage on the DB instance using a Blue/Green Deployment.
This release adds support for configuring Load balancer Capacity Unit reservations
This release adds support for exclusion tags for Recycle Bin, which allows you to identify resources that are to be excluded, or ignored, by a Region-level retention rule.
This release adds action type "Delete" to the GetRecommendation, ListRecommendations and ListRecommendationSummaries APIs to support new EBS and ECS recommendations with action type "Delete".
Add support to import data from commercially available discovery tools without file manipulation.
This release enables AWS Compute Optimizer to analyze and generate optimization recommendations for Amazon Aurora database instances. It also enables Compute Optimizer to identify idle Amazon EC2 instances, Amazon EBS volumes, Amazon ECS services running on Fargate, and Amazon RDS databases.
Releasing new Prompt Optimization to enhance your prompts for improved performance
This release adds support for the Availability Zone rebalancing feature on Amazon ECS.
With this release, customers can express their desire to launch instances only in an ODCR or ODCR group rather than OnDemand capacity. Customers can express their baseline instances' CPU-performance in attribute-based Instance Requirements configuration by referencing an instance family.
With this release, customers can prioritize launching instances into ODCRs using targets from ASGs or Launch Templates. Customers can express their baseline instances' CPU-performance in attribute-based Instance Requirements configuration by referencing an instance family that meets their needs.
Adds support for child enabled baselines which allow you to see the enabled baseline status for individual accounts.
This release adds the ability to reconfigure concurrent job settings for existing queues and create queues with custom concurrent job settings.
Add support for gRPC, VPC origins, and Anycast IP Lists. Allow LoggingConfig IncludeCookies to be set regardless of whether the LoggingConfig is enabled.
MediaPackage v2 now supports the Media Quality Confidence Score (MQCS) published from MediaLive. Customers can control input switching based on the MQCS and publishing HTTP Headers for the MQCS via the API.

VERSION

@@ -1 +1 @@
-1.11.451
+1.11.452

generated/src/aws-cpp-sdk-autoscaling/include/aws/autoscaling/model/AutoScalingGroup.h

@@ -15,6 +15,7 @@
 #include <aws/autoscaling/model/InstanceMaintenancePolicy.h>
 #include <aws/autoscaling/model/AvailabilityZoneDistribution.h>
 #include <aws/autoscaling/model/AvailabilityZoneImpairmentPolicy.h>
+#include <aws/autoscaling/model/CapacityReservationSpecification.h>
 #include <aws/autoscaling/model/Instance.h>
 #include <aws/autoscaling/model/SuspendedProcess.h>
 #include <aws/autoscaling/model/EnabledMetric.h>
@@ -525,6 +526,18 @@ namespace Model
     inline AutoScalingGroup& WithAvailabilityZoneImpairmentPolicy(const AvailabilityZoneImpairmentPolicy& value) { SetAvailabilityZoneImpairmentPolicy(value); return *this;}
     inline AutoScalingGroup& WithAvailabilityZoneImpairmentPolicy(AvailabilityZoneImpairmentPolicy&& value) { SetAvailabilityZoneImpairmentPolicy(std::move(value)); return *this;}
     ///@}
+
+    ///@{
+    /**
+     * <p> The capacity reservation specification. </p>
+     */
+    inline const CapacityReservationSpecification& GetCapacityReservationSpecification() const{ return m_capacityReservationSpecification; }
+    inline bool CapacityReservationSpecificationHasBeenSet() const { return m_capacityReservationSpecificationHasBeenSet; }
+    inline void SetCapacityReservationSpecification(const CapacityReservationSpecification& value) { m_capacityReservationSpecificationHasBeenSet = true; m_capacityReservationSpecification = value; }
+    inline void SetCapacityReservationSpecification(CapacityReservationSpecification&& value) { m_capacityReservationSpecificationHasBeenSet = true; m_capacityReservationSpecification = std::move(value); }
+    inline AutoScalingGroup& WithCapacityReservationSpecification(const CapacityReservationSpecification& value) { SetCapacityReservationSpecification(value); return *this;}
+    inline AutoScalingGroup& WithCapacityReservationSpecification(CapacityReservationSpecification&& value) { SetCapacityReservationSpecification(std::move(value)); return *this;}
+    ///@}
   private:
 
     Aws::String m_autoScalingGroupName;
@@ -637,6 +650,9 @@ namespace Model
 
     AvailabilityZoneImpairmentPolicy m_availabilityZoneImpairmentPolicy;
     bool m_availabilityZoneImpairmentPolicyHasBeenSet = false;
+
+    CapacityReservationSpecification m_capacityReservationSpecification;
+    bool m_capacityReservationSpecificationHasBeenSet = false;
   };
 
 } // namespace Model

generated/src/aws-cpp-sdk-autoscaling/include/aws/autoscaling/model/BaselinePerformanceFactorsRequest.h

@@ -0,0 +1,69 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/autoscaling/AutoScaling_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSStreamFwd.h>
+#include <aws/autoscaling/model/CpuPerformanceFactorRequest.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Xml
+{
+  class XmlNode;
+} // namespace Xml
+} // namespace Utils
+namespace AutoScaling
+{
+namespace Model
+{
+
+  /**
+   * <p> The baseline performance to consider, using an instance family as a baseline
+   * reference. The instance family establishes the lowest acceptable level of
+   * performance. Auto Scaling uses this baseline to guide instance type selection,
+   * but there is no guarantee that the selected instance types will always exceed
+   * the baseline for every application. </p> <p>Currently, this parameter only
+   * supports CPU performance as a baseline performance factor. For example,
+   * specifying <code>c6i</code> uses the CPU performance of the <code>c6i</code>
+   * family as the baseline reference.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/autoscaling-2011-01-01/BaselinePerformanceFactorsRequest">AWS
+   * API Reference</a></p>
+   */
+  class BaselinePerformanceFactorsRequest
+  {
+  public:
+    AWS_AUTOSCALING_API BaselinePerformanceFactorsRequest();
+    AWS_AUTOSCALING_API BaselinePerformanceFactorsRequest(const Aws::Utils::Xml::XmlNode& xmlNode);
+    AWS_AUTOSCALING_API BaselinePerformanceFactorsRequest& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
+
+    AWS_AUTOSCALING_API void OutputToStream(Aws::OStream& ostream, const char* location, unsigned index, const char* locationValue) const;
+    AWS_AUTOSCALING_API void OutputToStream(Aws::OStream& oStream, const char* location) const;
+
+
+    ///@{
+    /**
+     * <p> The CPU performance to consider, using an instance family as the baseline
+     * reference. </p>
+     */
+    inline const CpuPerformanceFactorRequest& GetCpu() const{ return m_cpu; }
+    inline bool CpuHasBeenSet() const { return m_cpuHasBeenSet; }
+    inline void SetCpu(const CpuPerformanceFactorRequest& value) { m_cpuHasBeenSet = true; m_cpu = value; }
+    inline void SetCpu(CpuPerformanceFactorRequest&& value) { m_cpuHasBeenSet = true; m_cpu = std::move(value); }
+    inline BaselinePerformanceFactorsRequest& WithCpu(const CpuPerformanceFactorRequest& value) { SetCpu(value); return *this;}
+    inline BaselinePerformanceFactorsRequest& WithCpu(CpuPerformanceFactorRequest&& value) { SetCpu(std::move(value)); return *this;}
+    ///@}
+  private:
+
+    CpuPerformanceFactorRequest m_cpu;
+    bool m_cpuHasBeenSet = false;
+  };
+
+} // namespace Model
+} // namespace AutoScaling
+} // namespace Aws

generated/src/aws-cpp-sdk-autoscaling/include/aws/autoscaling/model/CapacityReservationPreference.h

@@ -0,0 +1,33 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/autoscaling/AutoScaling_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+
+namespace Aws
+{
+namespace AutoScaling
+{
+namespace Model
+{
+  enum class CapacityReservationPreference
+  {
+    NOT_SET,
+    capacity_reservations_only,
+    capacity_reservations_first,
+    none,
+    default_
+  };
+
+namespace CapacityReservationPreferenceMapper
+{
+AWS_AUTOSCALING_API CapacityReservationPreference GetCapacityReservationPreferenceForName(const Aws::String& name);
+
+AWS_AUTOSCALING_API Aws::String GetNameForCapacityReservationPreference(CapacityReservationPreference value);
+} // namespace CapacityReservationPreferenceMapper
+} // namespace Model
+} // namespace AutoScaling
+} // namespace Aws

generated/src/aws-cpp-sdk-autoscaling/include/aws/autoscaling/model/CapacityReservationSpecification.h

@@ -0,0 +1,92 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/autoscaling/AutoScaling_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSStreamFwd.h>
+#include <aws/autoscaling/model/CapacityReservationPreference.h>
+#include <aws/autoscaling/model/CapacityReservationTarget.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Xml
+{
+  class XmlNode;
+} // namespace Xml
+} // namespace Utils
+namespace AutoScaling
+{
+namespace Model
+{
+
+  /**
+   * <p> Describes the Capacity Reservation preference and targeting options. If you
+   * specify <code>open</code> or <code>none</code> for
+   * <code>CapacityReservationPreference</code>, do not specify a
+   * <code>CapacityReservationTarget</code>. </p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/autoscaling-2011-01-01/CapacityReservationSpecification">AWS
+   * API Reference</a></p>
+   */
+  class CapacityReservationSpecification
+  {
+  public:
+    AWS_AUTOSCALING_API CapacityReservationSpecification();
+    AWS_AUTOSCALING_API CapacityReservationSpecification(const Aws::Utils::Xml::XmlNode& xmlNode);
+    AWS_AUTOSCALING_API CapacityReservationSpecification& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
+
+    AWS_AUTOSCALING_API void OutputToStream(Aws::OStream& ostream, const char* location, unsigned index, const char* locationValue) const;
+    AWS_AUTOSCALING_API void OutputToStream(Aws::OStream& oStream, const char* location) const;
+
+
+    ///@{
+    /**
+     * <p> The capacity reservation preference. The following options are available:
+     * </p> <ul> <li> <p> <code>capacity-reservations-only</code> - Auto Scaling will
+     * only launch instances into a Capacity Reservation or Capacity Reservation
+     * resource group. If capacity isn't available, instances will fail to launch.</p>
+     * </li> <li> <p> <code>capacity-reservations-first</code> - Auto Scaling will try
+     * to launch instances into a Capacity Reservation or Capacity Reservation resource
+     * group first. If capacity isn't available, instances will run in On-Demand
+     * capacity.</p> </li> <li> <p> <code>none</code> - Auto Scaling will not launch
+     * instances into a Capacity Reservation. Instances will run in On-Demand capacity.
+     * </p> </li> <li> <p> <code>default</code> - Auto Scaling uses the Capacity
+     * Reservation preference from your launch template or an open Capacity
+     * Reservation.</p> </li> </ul>
+     */
+    inline const CapacityReservationPreference& GetCapacityReservationPreference() const{ return m_capacityReservationPreference; }
+    inline bool CapacityReservationPreferenceHasBeenSet() const { return m_capacityReservationPreferenceHasBeenSet; }
+    inline void SetCapacityReservationPreference(const CapacityReservationPreference& value) { m_capacityReservationPreferenceHasBeenSet = true; m_capacityReservationPreference = value; }
+    inline void SetCapacityReservationPreference(CapacityReservationPreference&& value) { m_capacityReservationPreferenceHasBeenSet = true; m_capacityReservationPreference = std::move(value); }
+    inline CapacityReservationSpecification& WithCapacityReservationPreference(const CapacityReservationPreference& value) { SetCapacityReservationPreference(value); return *this;}
+    inline CapacityReservationSpecification& WithCapacityReservationPreference(CapacityReservationPreference&& value) { SetCapacityReservationPreference(std::move(value)); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p> Describes a target Capacity Reservation or Capacity Reservation resource
+     * group. </p>
+     */
+    inline const CapacityReservationTarget& GetCapacityReservationTarget() const{ return m_capacityReservationTarget; }
+    inline bool CapacityReservationTargetHasBeenSet() const { return m_capacityReservationTargetHasBeenSet; }
+    inline void SetCapacityReservationTarget(const CapacityReservationTarget& value) { m_capacityReservationTargetHasBeenSet = true; m_capacityReservationTarget = value; }
+    inline void SetCapacityReservationTarget(CapacityReservationTarget&& value) { m_capacityReservationTargetHasBeenSet = true; m_capacityReservationTarget = std::move(value); }
+    inline CapacityReservationSpecification& WithCapacityReservationTarget(const CapacityReservationTarget& value) { SetCapacityReservationTarget(value); return *this;}
+    inline CapacityReservationSpecification& WithCapacityReservationTarget(CapacityReservationTarget&& value) { SetCapacityReservationTarget(std::move(value)); return *this;}
+    ///@}
+  private:
+
+    CapacityReservationPreference m_capacityReservationPreference;
+    bool m_capacityReservationPreferenceHasBeenSet = false;
+
+    CapacityReservationTarget m_capacityReservationTarget;
+    bool m_capacityReservationTargetHasBeenSet = false;
+  };
+
+} // namespace Model
+} // namespace AutoScaling
+} // namespace Aws

generated/src/aws-cpp-sdk-autoscaling/include/aws/autoscaling/model/CapacityReservationTarget.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/autoscaling/AutoScaling_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSStreamFwd.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Xml
+{
+  class XmlNode;
+} // namespace Xml
+} // namespace Utils
+namespace AutoScaling
+{
+namespace Model
+{
+
+  /**
+   * <p> The target for the Capacity Reservation. Specify Capacity Reservations IDs
+   * or Capacity Reservation resource group ARNs. </p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/autoscaling-2011-01-01/CapacityReservationTarget">AWS
+   * API Reference</a></p>
+   */
+  class CapacityReservationTarget
+  {
+  public:
+    AWS_AUTOSCALING_API CapacityReservationTarget();
+    AWS_AUTOSCALING_API CapacityReservationTarget(const Aws::Utils::Xml::XmlNode& xmlNode);
+    AWS_AUTOSCALING_API CapacityReservationTarget& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
+
+    AWS_AUTOSCALING_API void OutputToStream(Aws::OStream& ostream, const char* location, unsigned index, const char* locationValue) const;
+    AWS_AUTOSCALING_API void OutputToStream(Aws::OStream& oStream, const char* location) const;
+
+
+    ///@{
+    /**
+     * <p> The Capacity Reservation IDs to launch instances into. </p>
+     */
+    inline const Aws::Vector<Aws::String>& GetCapacityReservationIds() const{ return m_capacityReservationIds; }
+    inline bool CapacityReservationIdsHasBeenSet() const { return m_capacityReservationIdsHasBeenSet; }
+    inline void SetCapacityReservationIds(const Aws::Vector<Aws::String>& value) { m_capacityReservationIdsHasBeenSet = true; m_capacityReservationIds = value; }
+    inline void SetCapacityReservationIds(Aws::Vector<Aws::String>&& value) { m_capacityReservationIdsHasBeenSet = true; m_capacityReservationIds = std::move(value); }
+    inline CapacityReservationTarget& WithCapacityReservationIds(const Aws::Vector<Aws::String>& value) { SetCapacityReservationIds(value); return *this;}
+    inline CapacityReservationTarget& WithCapacityReservationIds(Aws::Vector<Aws::String>&& value) { SetCapacityReservationIds(std::move(value)); return *this;}
+    inline CapacityReservationTarget& AddCapacityReservationIds(const Aws::String& value) { m_capacityReservationIdsHasBeenSet = true; m_capacityReservationIds.push_back(value); return *this; }
+    inline CapacityReservationTarget& AddCapacityReservationIds(Aws::String&& value) { m_capacityReservationIdsHasBeenSet = true; m_capacityReservationIds.push_back(std::move(value)); return *this; }
+    inline CapacityReservationTarget& AddCapacityReservationIds(const char* value) { m_capacityReservationIdsHasBeenSet = true; m_capacityReservationIds.push_back(value); return *this; }
+    ///@}
+
+    ///@{
+    /**
+     * <p> The resource group ARNs of the Capacity Reservation to launch instances
+     * into. </p>
+     */
+    inline const Aws::Vector<Aws::String>& GetCapacityReservationResourceGroupArns() const{ return m_capacityReservationResourceGroupArns; }
+    inline bool CapacityReservationResourceGroupArnsHasBeenSet() const { return m_capacityReservationResourceGroupArnsHasBeenSet; }
+    inline void SetCapacityReservationResourceGroupArns(const Aws::Vector<Aws::String>& value) { m_capacityReservationResourceGroupArnsHasBeenSet = true; m_capacityReservationResourceGroupArns = value; }
+    inline void SetCapacityReservationResourceGroupArns(Aws::Vector<Aws::String>&& value) { m_capacityReservationResourceGroupArnsHasBeenSet = true; m_capacityReservationResourceGroupArns = std::move(value); }
+    inline CapacityReservationTarget& WithCapacityReservationResourceGroupArns(const Aws::Vector<Aws::String>& value) { SetCapacityReservationResourceGroupArns(value); return *this;}
+    inline CapacityReservationTarget& WithCapacityReservationResourceGroupArns(Aws::Vector<Aws::String>&& value) { SetCapacityReservationResourceGroupArns(std::move(value)); return *this;}
+    inline CapacityReservationTarget& AddCapacityReservationResourceGroupArns(const Aws::String& value) { m_capacityReservationResourceGroupArnsHasBeenSet = true; m_capacityReservationResourceGroupArns.push_back(value); return *this; }
+    inline CapacityReservationTarget& AddCapacityReservationResourceGroupArns(Aws::String&& value) { m_capacityReservationResourceGroupArnsHasBeenSet = true; m_capacityReservationResourceGroupArns.push_back(std::move(value)); return *this; }
+    inline CapacityReservationTarget& AddCapacityReservationResourceGroupArns(const char* value) { m_capacityReservationResourceGroupArnsHasBeenSet = true; m_capacityReservationResourceGroupArns.push_back(value); return *this; }
+    ///@}
+  private:
+
+    Aws::Vector<Aws::String> m_capacityReservationIds;
+    bool m_capacityReservationIdsHasBeenSet = false;
+
+    Aws::Vector<Aws::String> m_capacityReservationResourceGroupArns;
+    bool m_capacityReservationResourceGroupArnsHasBeenSet = false;
+  };
+
+} // namespace Model
+} // namespace AutoScaling
+} // namespace Aws

generated/src/aws-cpp-sdk-autoscaling/include/aws/autoscaling/model/CpuPerformanceFactorRequest.h

@@ -0,0 +1,69 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/autoscaling/AutoScaling_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSStreamFwd.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/autoscaling/model/PerformanceFactorReferenceRequest.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Xml
+{
+  class XmlNode;
+} // namespace Xml
+} // namespace Utils
+namespace AutoScaling
+{
+namespace Model
+{
+
+  /**
+   * <p> The CPU performance to consider, using an instance family as the baseline
+   * reference. </p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/autoscaling-2011-01-01/CpuPerformanceFactorRequest">AWS
+   * API Reference</a></p>
+   */
+  class CpuPerformanceFactorRequest
+  {
+  public:
+    AWS_AUTOSCALING_API CpuPerformanceFactorRequest();
+    AWS_AUTOSCALING_API CpuPerformanceFactorRequest(const Aws::Utils::Xml::XmlNode& xmlNode);
+    AWS_AUTOSCALING_API CpuPerformanceFactorRequest& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
+
+    AWS_AUTOSCALING_API void OutputToStream(Aws::OStream& ostream, const char* location, unsigned index, const char* locationValue) const;
+    AWS_AUTOSCALING_API void OutputToStream(Aws::OStream& oStream, const char* location) const;
+
+
+    ///@{
+    /**
+     * <p> Specify an instance family to use as the baseline reference for CPU
+     * performance. All instance types that match your specified attributes will be
+     * compared against the CPU performance of the referenced instance family,
+     * regardless of CPU manufacturer or architecture differences. </p> 
+     * <p>Currently only one instance family can be specified in the list.</p> 
+     */
+    inline const Aws::Vector<PerformanceFactorReferenceRequest>& GetReferences() const{ return m_references; }
+    inline bool ReferencesHasBeenSet() const { return m_referencesHasBeenSet; }
+    inline void SetReferences(const Aws::Vector<PerformanceFactorReferenceRequest>& value) { m_referencesHasBeenSet = true; m_references = value; }
+    inline void SetReferences(Aws::Vector<PerformanceFactorReferenceRequest>&& value) { m_referencesHasBeenSet = true; m_references = std::move(value); }
+    inline CpuPerformanceFactorRequest& WithReferences(const Aws::Vector<PerformanceFactorReferenceRequest>& value) { SetReferences(value); return *this;}
+    inline CpuPerformanceFactorRequest& WithReferences(Aws::Vector<PerformanceFactorReferenceRequest>&& value) { SetReferences(std::move(value)); return *this;}
+    inline CpuPerformanceFactorRequest& AddReferences(const PerformanceFactorReferenceRequest& value) { m_referencesHasBeenSet = true; m_references.push_back(value); return *this; }
+    inline CpuPerformanceFactorRequest& AddReferences(PerformanceFactorReferenceRequest&& value) { m_referencesHasBeenSet = true; m_references.push_back(std::move(value)); return *this; }
+    ///@}
+  private:
+
+    Aws::Vector<PerformanceFactorReferenceRequest> m_references;
+    bool m_referencesHasBeenSet = false;
+  };
+
+} // namespace Model
+} // namespace AutoScaling
+} // namespace Aws