This release adds the new LaunchInstances API, which can launch instances synchronously in an AutoScaling group. The API also returns instances info and launch error back immediately.

Amazon Bedrock Runtime Service Tier Support Launch
AWS Site-to-Site VPN now supports VPN Concentrator, a new feature that enables customers to connect multiple low-bandwidth sites connections through a single attachment, simplifying multi-site connectivity for distributed enterprises.
Add support for new ListRequiredTags API used to retrieve the required tags specified in a customer's effective tag policy.
Added the AssociateDelegationRequest, GetDelegationRequest, AcceptDelegationRequest, RejectDelegatonRequest, ListDelegationRequests, UpdateDelegationRequest, SendDelegationToken and GetHumanReadableSummary APIs for the IAM temporary delegation feature.
AWS Backup now supports a low-cost warm storage tier for Amazon S3 backup data.
Amazon MSK adds three new APIs, ListTopics, DescribeTopic, and DescribeTopicPartitions for viewing Kafka topics in your MSK clusters.
New CloudFormation DescribeEvents API with operation ID tracking and failure filtering capabilities to quickly identify root causes of deployment failures. Also, a DeploymentMode parameter for the CreateChangeSet API that enables creation of drift-aware change sets for safe drift management.
Adds support for European Sovereign Cloud ARNs in Storage Gateway API parameters.
AssociateWebACL, UpdateWebACL and PutLoggingConfiguration will now throw WAFFeatureNotIncludedInPricingPlanException when the request contains a feature that is not included in the CloudFront pricing plan of the WebACL.
CloudWatch Logs updates: Added capability to setup a recurring schedule for log insights queries. Logs introduced Scheduled Queries (managed through Create/Update/Get/Delete/List/History Scheduled Query APIs). For more information, see CloudWatch Logs API documentation.
This release added support for ring timer configuration for campaign calls.

Author: aws-sdk-cpp-automation

VERSION

@@ -1 +1 @@
-1.11.692
+1.11.693

generated/src/aws-cpp-sdk-autoscaling/include/aws/autoscaling/AutoScalingClient.h

@@ -1869,6 +1869,33 @@ class AWS_AUTOSCALING_API AutoScalingClient : public Aws::Client::AWSXMLClient,
     return SubmitAsync(&AutoScalingClient::GetPredictiveScalingForecast, request, handler, context);
   }
 
+  /**
+   * <p> Launches a specified number of instances in an Auto Scaling group. Returns
+   * instance IDs and other details if launch is successful or error details if
+   * launch is unsuccessful. </p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/autoscaling-2011-01-01/LaunchInstances">AWS
+   * API Reference</a></p>
+   */
+  virtual Model::LaunchInstancesOutcome LaunchInstances(const Model::LaunchInstancesRequest& request) const;
+
+  /**
+   * A Callable wrapper for LaunchInstances that returns a future to the operation so that it can be executed in parallel to other requests.
+   */
+  template <typename LaunchInstancesRequestT = Model::LaunchInstancesRequest>
+  Model::LaunchInstancesOutcomeCallable LaunchInstancesCallable(const LaunchInstancesRequestT& request) const {
+    return SubmitCallable(&AutoScalingClient::LaunchInstances, request);
+  }
+
+  /**
+   * An Async wrapper for LaunchInstances that queues the request into a thread executor and triggers associated callback when operation has
+   * finished.
+   */
+  template <typename LaunchInstancesRequestT = Model::LaunchInstancesRequest>
+  void LaunchInstancesAsync(const LaunchInstancesRequestT& request, const LaunchInstancesResponseReceivedHandler& handler,
+                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
+    return SubmitAsync(&AutoScalingClient::LaunchInstances, request, handler, context);
+  }
+
   /**
    * <p>Creates or updates a lifecycle hook for the specified Auto Scaling group.</p>
    * <p>Lifecycle hooks let you create solutions that are aware of events in the Auto

generated/src/aws-cpp-sdk-autoscaling/include/aws/autoscaling/AutoScalingErrors.h

@@ -46,6 +46,7 @@ enum class AutoScalingErrors {
 
   ACTIVE_INSTANCE_REFRESH_NOT_FOUND_FAULT = static_cast<int>(Aws::Client::CoreErrors::SERVICE_EXTENSION_START_RANGE) + 1,
   ALREADY_EXISTS_FAULT,
+  IDEMPOTENT_PARAMETER_MISMATCH,
   INSTANCE_REFRESH_IN_PROGRESS_FAULT,
   INVALID_NEXT_TOKEN,
   IRREVERSIBLE_INSTANCE_REFRESH_FAULT,

generated/src/aws-cpp-sdk-autoscaling/include/aws/autoscaling/AutoScalingServiceClientModel.h

@@ -71,6 +71,7 @@
 #include <aws/autoscaling/model/EnterStandbyResult.h>
 #include <aws/autoscaling/model/ExitStandbyResult.h>
 #include <aws/autoscaling/model/GetPredictiveScalingForecastResult.h>
+#include <aws/autoscaling/model/LaunchInstancesResult.h>
 #include <aws/autoscaling/model/PutLifecycleHookResult.h>
 #include <aws/autoscaling/model/PutScalingPolicyResult.h>
 #include <aws/autoscaling/model/PutWarmPoolResult.h>
@@ -163,6 +164,7 @@ class EnterStandbyRequest;
 class ExecutePolicyRequest;
 class ExitStandbyRequest;
 class GetPredictiveScalingForecastRequest;
+class LaunchInstancesRequest;
 class PutLifecycleHookRequest;
 class PutNotificationConfigurationRequest;
 class PutScalingPolicyRequest;
@@ -231,6 +233,7 @@ typedef Aws::Utils::Outcome<EnterStandbyResult, AutoScalingError> EnterStandbyOu
 typedef Aws::Utils::Outcome<Aws::NoResult, AutoScalingError> ExecutePolicyOutcome;
 typedef Aws::Utils::Outcome<ExitStandbyResult, AutoScalingError> ExitStandbyOutcome;
 typedef Aws::Utils::Outcome<GetPredictiveScalingForecastResult, AutoScalingError> GetPredictiveScalingForecastOutcome;
+typedef Aws::Utils::Outcome<LaunchInstancesResult, AutoScalingError> LaunchInstancesOutcome;
 typedef Aws::Utils::Outcome<PutLifecycleHookResult, AutoScalingError> PutLifecycleHookOutcome;
 typedef Aws::Utils::Outcome<Aws::NoResult, AutoScalingError> PutNotificationConfigurationOutcome;
 typedef Aws::Utils::Outcome<PutScalingPolicyResult, AutoScalingError> PutScalingPolicyOutcome;
@@ -299,6 +302,7 @@ typedef std::future<EnterStandbyOutcome> EnterStandbyOutcomeCallable;
 typedef std::future<ExecutePolicyOutcome> ExecutePolicyOutcomeCallable;
 typedef std::future<ExitStandbyOutcome> ExitStandbyOutcomeCallable;
 typedef std::future<GetPredictiveScalingForecastOutcome> GetPredictiveScalingForecastOutcomeCallable;
+typedef std::future<LaunchInstancesOutcome> LaunchInstancesOutcomeCallable;
 typedef std::future<PutLifecycleHookOutcome> PutLifecycleHookOutcomeCallable;
 typedef std::future<PutNotificationConfigurationOutcome> PutNotificationConfigurationOutcomeCallable;
 typedef std::future<PutScalingPolicyOutcome> PutScalingPolicyOutcomeCallable;
@@ -482,6 +486,9 @@ typedef std::function<void(const AutoScalingClient*, const Model::GetPredictiveS
                            const Model::GetPredictiveScalingForecastOutcome&,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>&)>
     GetPredictiveScalingForecastResponseReceivedHandler;
+typedef std::function<void(const AutoScalingClient*, const Model::LaunchInstancesRequest&, const Model::LaunchInstancesOutcome&,
+                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>&)>
+    LaunchInstancesResponseReceivedHandler;
 typedef std::function<void(const AutoScalingClient*, const Model::PutLifecycleHookRequest&, const Model::PutLifecycleHookOutcome&,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>&)>
     PutLifecycleHookResponseReceivedHandler;

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

@@ -0,0 +1,174 @@
+/**
+ * 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/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+
+#include <utility>
+
+namespace Aws {
+namespace Utils {
+namespace Xml {
+class XmlNode;
+}  // namespace Xml
+}  // namespace Utils
+namespace AutoScaling {
+namespace Model {
+
+/**
+ * <p> Contains details about a collection of instances launched in the Auto
+ * Scaling group. </p><p><h3>See Also:</h3>   <a
+ * href="http://docs.aws.amazon.com/goto/WebAPI/autoscaling-2011-01-01/InstanceCollection">AWS
+ * API Reference</a></p>
+ */
+class InstanceCollection {
+ public:
+  AWS_AUTOSCALING_API InstanceCollection() = default;
+  AWS_AUTOSCALING_API InstanceCollection(const Aws::Utils::Xml::XmlNode& xmlNode);
+  AWS_AUTOSCALING_API InstanceCollection& 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 instance type of the launched instances. </p>
+   */
+  inline const Aws::String& GetInstanceType() const { return m_instanceType; }
+  inline bool InstanceTypeHasBeenSet() const { return m_instanceTypeHasBeenSet; }
+  template <typename InstanceTypeT = Aws::String>
+  void SetInstanceType(InstanceTypeT&& value) {
+    m_instanceTypeHasBeenSet = true;
+    m_instanceType = std::forward<InstanceTypeT>(value);
+  }
+  template <typename InstanceTypeT = Aws::String>
+  InstanceCollection& WithInstanceType(InstanceTypeT&& value) {
+    SetInstanceType(std::forward<InstanceTypeT>(value));
+    return *this;
+  }
+  ///@}
+
+  ///@{
+  /**
+   * <p> The market type for the instances (On-Demand or Spot). </p>
+   */
+  inline const Aws::String& GetMarketType() const { return m_marketType; }
+  inline bool MarketTypeHasBeenSet() const { return m_marketTypeHasBeenSet; }
+  template <typename MarketTypeT = Aws::String>
+  void SetMarketType(MarketTypeT&& value) {
+    m_marketTypeHasBeenSet = true;
+    m_marketType = std::forward<MarketTypeT>(value);
+  }
+  template <typename MarketTypeT = Aws::String>
+  InstanceCollection& WithMarketType(MarketTypeT&& value) {
+    SetMarketType(std::forward<MarketTypeT>(value));
+    return *this;
+  }
+  ///@}
+
+  ///@{
+  /**
+   * <p> The ID of the subnet where the instances were launched. </p>
+   */
+  inline const Aws::String& GetSubnetId() const { return m_subnetId; }
+  inline bool SubnetIdHasBeenSet() const { return m_subnetIdHasBeenSet; }
+  template <typename SubnetIdT = Aws::String>
+  void SetSubnetId(SubnetIdT&& value) {
+    m_subnetIdHasBeenSet = true;
+    m_subnetId = std::forward<SubnetIdT>(value);
+  }
+  template <typename SubnetIdT = Aws::String>
+  InstanceCollection& WithSubnetId(SubnetIdT&& value) {
+    SetSubnetId(std::forward<SubnetIdT>(value));
+    return *this;
+  }
+  ///@}
+
+  ///@{
+  /**
+   * <p> The Availability Zone where the instances were launched. </p>
+   */
+  inline const Aws::String& GetAvailabilityZone() const { return m_availabilityZone; }
+  inline bool AvailabilityZoneHasBeenSet() const { return m_availabilityZoneHasBeenSet; }
+  template <typename AvailabilityZoneT = Aws::String>
+  void SetAvailabilityZone(AvailabilityZoneT&& value) {
+    m_availabilityZoneHasBeenSet = true;
+    m_availabilityZone = std::forward<AvailabilityZoneT>(value);
+  }
+  template <typename AvailabilityZoneT = Aws::String>
+  InstanceCollection& WithAvailabilityZone(AvailabilityZoneT&& value) {
+    SetAvailabilityZone(std::forward<AvailabilityZoneT>(value));
+    return *this;
+  }
+  ///@}
+
+  ///@{
+  /**
+   * <p> The Availability Zone ID where the instances in this collection were
+   * launched. </p>
+   */
+  inline const Aws::String& GetAvailabilityZoneId() const { return m_availabilityZoneId; }
+  inline bool AvailabilityZoneIdHasBeenSet() const { return m_availabilityZoneIdHasBeenSet; }
+  template <typename AvailabilityZoneIdT = Aws::String>
+  void SetAvailabilityZoneId(AvailabilityZoneIdT&& value) {
+    m_availabilityZoneIdHasBeenSet = true;
+    m_availabilityZoneId = std::forward<AvailabilityZoneIdT>(value);
+  }
+  template <typename AvailabilityZoneIdT = Aws::String>
+  InstanceCollection& WithAvailabilityZoneId(AvailabilityZoneIdT&& value) {
+    SetAvailabilityZoneId(std::forward<AvailabilityZoneIdT>(value));
+    return *this;
+  }
+  ///@}
+
+  ///@{
+  /**
+   * <p> A list of instance IDs for the successfully launched instances. </p>
+   */
+  inline const Aws::Vector<Aws::String>& GetInstanceIds() const { return m_instanceIds; }
+  inline bool InstanceIdsHasBeenSet() const { return m_instanceIdsHasBeenSet; }
+  template <typename InstanceIdsT = Aws::Vector<Aws::String>>
+  void SetInstanceIds(InstanceIdsT&& value) {
+    m_instanceIdsHasBeenSet = true;
+    m_instanceIds = std::forward<InstanceIdsT>(value);
+  }
+  template <typename InstanceIdsT = Aws::Vector<Aws::String>>
+  InstanceCollection& WithInstanceIds(InstanceIdsT&& value) {
+    SetInstanceIds(std::forward<InstanceIdsT>(value));
+    return *this;
+  }
+  template <typename InstanceIdsT = Aws::String>
+  InstanceCollection& AddInstanceIds(InstanceIdsT&& value) {
+    m_instanceIdsHasBeenSet = true;
+    m_instanceIds.emplace_back(std::forward<InstanceIdsT>(value));
+    return *this;
+  }
+  ///@}
+ private:
+  Aws::String m_instanceType;
+  bool m_instanceTypeHasBeenSet = false;
+
+  Aws::String m_marketType;
+  bool m_marketTypeHasBeenSet = false;
+
+  Aws::String m_subnetId;
+  bool m_subnetIdHasBeenSet = false;
+
+  Aws::String m_availabilityZone;
+  bool m_availabilityZoneHasBeenSet = false;
+
+  Aws::String m_availabilityZoneId;
+  bool m_availabilityZoneIdHasBeenSet = false;
+
+  Aws::Vector<Aws::String> m_instanceIds;
+  bool m_instanceIdsHasBeenSet = false;
+};
+
+}  // namespace Model
+}  // namespace AutoScaling
+}  // namespace Aws