Support for dataset enrichment and geo spatial in new data preparation experience

Adds support for up to 3 mediaTailorPlaybackConfiguration objects in an ad configuration resource
Amazon Connect Cases now supports SLA durations of up to 2 years (1,051,200 minutes), increased from the previous maximum of 90 days (129,600 minutes). This enables you to track long-running service level agreements for cases that require extended resolution timelines.
Amazon EVS now supports up to 32 hosts per EVS environment, increasing the previous host limit to allow a larger scale of VMware workload deployments and reduce operational overhead.
Amazon ECS now supports Pause lifecycle hooks for service deployments, allowing customers to automatically pause deployments at specified stages and use the new ContinueServiceDeployment API to continue or roll back with confidence.
Services manage service-linked analyzers through dedicated APIs - CreateServiceLinkedAnalyzer and DeleteServiceLinkedAnalyzer that separate service-linked specific operations from customer-managed operations. It also shows up in ListAnalyzers and GetAnalyzer responses.
Amazon VPC IP Address Manager (IPAM) now supports tags on IPAM pool allocations, enabling all standard tagging features for allocations including tag-on-create.

Author: aws-sdk-cpp-automation

VERSION

@@ -1 +1 @@
-1.11.808
+1.11.809

generated/src/aws-cpp-sdk-accessanalyzer/include/aws/accessanalyzer/AccessAnalyzerClient.h

@@ -335,6 +335,40 @@ class AWS_ACCESSANALYZER_API AccessAnalyzerClient : public Aws::Client::AWSJsonC
     return SubmitAsync(&AccessAnalyzerClient::CreateArchiveRule, request, handler, context);
   }
 
+  /**
+   * <p>Creates a service-linked analyzer managed by an Amazon Web Services service.
+   * This operation can only be invoked by authorized Amazon Web Services services.
+   * Direct customer invocation returns <code>AccessDeniedException</code>.</p>
+   * <p>Service-linked analyzers enable Amazon Web Services services to create and
+   * manage analyzers on behalf of customers. The lifecycle of these analyzers is
+   * managed by the calling service.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/accessanalyzer-2019-11-01/CreateServiceLinkedAnalyzer">AWS
+   * API Reference</a></p>
+   */
+  virtual Model::CreateServiceLinkedAnalyzerOutcome CreateServiceLinkedAnalyzer(
+      const Model::CreateServiceLinkedAnalyzerRequest& request) const;
+
+  /**
+   * A Callable wrapper for CreateServiceLinkedAnalyzer that returns a future to the operation so that it can be executed in parallel to
+   * other requests.
+   */
+  template <typename CreateServiceLinkedAnalyzerRequestT = Model::CreateServiceLinkedAnalyzerRequest>
+  Model::CreateServiceLinkedAnalyzerOutcomeCallable CreateServiceLinkedAnalyzerCallable(
+      const CreateServiceLinkedAnalyzerRequestT& request) const {
+    return SubmitCallable(&AccessAnalyzerClient::CreateServiceLinkedAnalyzer, request);
+  }
+
+  /**
+   * An Async wrapper for CreateServiceLinkedAnalyzer that queues the request into a thread executor and triggers associated callback when
+   * operation has finished.
+   */
+  template <typename CreateServiceLinkedAnalyzerRequestT = Model::CreateServiceLinkedAnalyzerRequest>
+  void CreateServiceLinkedAnalyzerAsync(const CreateServiceLinkedAnalyzerRequestT& request,
+                                        const CreateServiceLinkedAnalyzerResponseReceivedHandler& handler,
+                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
+    return SubmitAsync(&AccessAnalyzerClient::CreateServiceLinkedAnalyzer, request, handler, context);
+  }
+
   /**
    * <p>Deletes the specified analyzer. When you delete an analyzer, IAM Access
    * Analyzer is disabled for the account or organization in the current or specific
@@ -389,6 +423,40 @@ class AWS_ACCESSANALYZER_API AccessAnalyzerClient : public Aws::Client::AWSJsonC
     return SubmitAsync(&AccessAnalyzerClient::DeleteArchiveRule, request, handler, context);
   }
 
+  /**
+   * <p>Deletes a service-linked analyzer. This operation can be invoked by both
+   * authorized Amazon Web Services services and customers.</p> <p>When invoked by a
+   * customer, IAM Access Analyzer performs a callback to the managing service to
+   * verify whether the analyzer is still in use and can be deleted. If the service
+   * indicates the analyzer is still in use, the deletion is rejected with
+   * <code>ConflictException</code>.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/accessanalyzer-2019-11-01/DeleteServiceLinkedAnalyzer">AWS
+   * API Reference</a></p>
+   */
+  virtual Model::DeleteServiceLinkedAnalyzerOutcome DeleteServiceLinkedAnalyzer(
+      const Model::DeleteServiceLinkedAnalyzerRequest& request) const;
+
+  /**
+   * A Callable wrapper for DeleteServiceLinkedAnalyzer that returns a future to the operation so that it can be executed in parallel to
+   * other requests.
+   */
+  template <typename DeleteServiceLinkedAnalyzerRequestT = Model::DeleteServiceLinkedAnalyzerRequest>
+  Model::DeleteServiceLinkedAnalyzerOutcomeCallable DeleteServiceLinkedAnalyzerCallable(
+      const DeleteServiceLinkedAnalyzerRequestT& request) const {
+    return SubmitCallable(&AccessAnalyzerClient::DeleteServiceLinkedAnalyzer, request);
+  }
+
+  /**
+   * An Async wrapper for DeleteServiceLinkedAnalyzer that queues the request into a thread executor and triggers associated callback when
+   * operation has finished.
+   */
+  template <typename DeleteServiceLinkedAnalyzerRequestT = Model::DeleteServiceLinkedAnalyzerRequest>
+  void DeleteServiceLinkedAnalyzerAsync(const DeleteServiceLinkedAnalyzerRequestT& request,
+                                        const DeleteServiceLinkedAnalyzerResponseReceivedHandler& handler,
+                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
+    return SubmitAsync(&AccessAnalyzerClient::DeleteServiceLinkedAnalyzer, request, handler, context);
+  }
+
   /**
    * <p>Creates a recommendation for an unused permissions finding.</p><p><h3>See
    * Also:</h3>   <a

generated/src/aws-cpp-sdk-accessanalyzer/include/aws/accessanalyzer/AccessAnalyzerServiceClientModel.h

@@ -25,6 +25,7 @@
 #include <aws/accessanalyzer/model/CheckNoPublicAccessSdkResult.h>
 #include <aws/accessanalyzer/model/CreateAccessPreviewResult.h>
 #include <aws/accessanalyzer/model/CreateAnalyzerResult.h>
+#include <aws/accessanalyzer/model/CreateServiceLinkedAnalyzerResult.h>
 #include <aws/accessanalyzer/model/GetAccessPreviewResult.h>
 #include <aws/accessanalyzer/model/GetAnalyzedResourceResult.h>
 #include <aws/accessanalyzer/model/GetAnalyzerResult.h>
@@ -92,8 +93,10 @@ class CheckNoPublicAccessRequest;
 class CreateAccessPreviewRequest;
 class CreateAnalyzerRequest;
 class CreateArchiveRuleRequest;
+class CreateServiceLinkedAnalyzerRequest;
 class DeleteAnalyzerRequest;
 class DeleteArchiveRuleRequest;
+class DeleteServiceLinkedAnalyzerRequest;
 class GenerateFindingRecommendationRequest;
 class GetAccessPreviewRequest;
 class GetAnalyzedResourceRequest;
@@ -132,8 +135,10 @@ typedef Aws::Utils::Outcome<CheckNoPublicAccessSdkResult, AccessAnalyzerError> C
 typedef Aws::Utils::Outcome<CreateAccessPreviewResult, AccessAnalyzerError> CreateAccessPreviewOutcome;
 typedef Aws::Utils::Outcome<CreateAnalyzerResult, AccessAnalyzerError> CreateAnalyzerOutcome;
 typedef Aws::Utils::Outcome<Aws::NoResult, AccessAnalyzerError> CreateArchiveRuleOutcome;
+typedef Aws::Utils::Outcome<CreateServiceLinkedAnalyzerResult, AccessAnalyzerError> CreateServiceLinkedAnalyzerOutcome;
 typedef Aws::Utils::Outcome<Aws::NoResult, AccessAnalyzerError> DeleteAnalyzerOutcome;
 typedef Aws::Utils::Outcome<Aws::NoResult, AccessAnalyzerError> DeleteArchiveRuleOutcome;
+typedef Aws::Utils::Outcome<Aws::NoResult, AccessAnalyzerError> DeleteServiceLinkedAnalyzerOutcome;
 typedef Aws::Utils::Outcome<Aws::NoResult, AccessAnalyzerError> GenerateFindingRecommendationOutcome;
 typedef Aws::Utils::Outcome<GetAccessPreviewResult, AccessAnalyzerError> GetAccessPreviewOutcome;
 typedef Aws::Utils::Outcome<GetAnalyzedResourceResult, AccessAnalyzerError> GetAnalyzedResourceOutcome;
@@ -172,8 +177,10 @@ typedef std::future<CheckNoPublicAccessOutcome> CheckNoPublicAccessOutcomeCallab
 typedef std::future<CreateAccessPreviewOutcome> CreateAccessPreviewOutcomeCallable;
 typedef std::future<CreateAnalyzerOutcome> CreateAnalyzerOutcomeCallable;
 typedef std::future<CreateArchiveRuleOutcome> CreateArchiveRuleOutcomeCallable;
+typedef std::future<CreateServiceLinkedAnalyzerOutcome> CreateServiceLinkedAnalyzerOutcomeCallable;
 typedef std::future<DeleteAnalyzerOutcome> DeleteAnalyzerOutcomeCallable;
 typedef std::future<DeleteArchiveRuleOutcome> DeleteArchiveRuleOutcomeCallable;
+typedef std::future<DeleteServiceLinkedAnalyzerOutcome> DeleteServiceLinkedAnalyzerOutcomeCallable;
 typedef std::future<GenerateFindingRecommendationOutcome> GenerateFindingRecommendationOutcomeCallable;
 typedef std::future<GetAccessPreviewOutcome> GetAccessPreviewOutcomeCallable;
 typedef std::future<GetAnalyzedResourceOutcome> GetAnalyzedResourceOutcomeCallable;
@@ -231,12 +238,18 @@ typedef std::function<void(const AccessAnalyzerClient*, const Model::CreateAnaly
 typedef std::function<void(const AccessAnalyzerClient*, const Model::CreateArchiveRuleRequest&, const Model::CreateArchiveRuleOutcome&,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>&)>
     CreateArchiveRuleResponseReceivedHandler;
+typedef std::function<void(const AccessAnalyzerClient*, const Model::CreateServiceLinkedAnalyzerRequest&,
+                           const Model::CreateServiceLinkedAnalyzerOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&)>
+    CreateServiceLinkedAnalyzerResponseReceivedHandler;
 typedef std::function<void(const AccessAnalyzerClient*, const Model::DeleteAnalyzerRequest&, const Model::DeleteAnalyzerOutcome&,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>&)>
     DeleteAnalyzerResponseReceivedHandler;
 typedef std::function<void(const AccessAnalyzerClient*, const Model::DeleteArchiveRuleRequest&, const Model::DeleteArchiveRuleOutcome&,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>&)>
     DeleteArchiveRuleResponseReceivedHandler;
+typedef std::function<void(const AccessAnalyzerClient*, const Model::DeleteServiceLinkedAnalyzerRequest&,
+                           const Model::DeleteServiceLinkedAnalyzerOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&)>
+    DeleteServiceLinkedAnalyzerResponseReceivedHandler;
 typedef std::function<void(const AccessAnalyzerClient*, const Model::GenerateFindingRecommendationRequest&,
                            const Model::GenerateFindingRecommendationOutcome&,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>&)>

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

@@ -239,6 +239,26 @@ class AnalyzerSummary {
     return *this;
   }
   ///@}
+
+  ///@{
+  /**
+   * <p>The service principal that manages this analyzer (for example,
+   * <code>securityhubv2.amazonaws.com</code>). This field is only present for
+   * service-linked analyzers and is not included for customer-managed analyzers.</p>
+   */
+  inline const Aws::String& GetManagedBy() const { return m_managedBy; }
+  inline bool ManagedByHasBeenSet() const { return m_managedByHasBeenSet; }
+  template <typename ManagedByT = Aws::String>
+  void SetManagedBy(ManagedByT&& value) {
+    m_managedByHasBeenSet = true;
+    m_managedBy = std::forward<ManagedByT>(value);
+  }
+  template <typename ManagedByT = Aws::String>
+  AnalyzerSummary& WithManagedBy(ManagedByT&& value) {
+    SetManagedBy(std::forward<ManagedByT>(value));
+    return *this;
+  }
+  ///@}
  private:
   Aws::String m_arn;
 
@@ -259,6 +279,8 @@ class AnalyzerSummary {
   StatusReason m_statusReason;
 
   AnalyzerConfiguration m_configuration;
+
+  Aws::String m_managedBy;
   bool m_arnHasBeenSet = false;
   bool m_nameHasBeenSet = false;
   bool m_typeHasBeenSet = false;
@@ -269,6 +291,7 @@ class AnalyzerSummary {
   bool m_statusHasBeenSet = false;
   bool m_statusReasonHasBeenSet = false;
   bool m_configurationHasBeenSet = false;
+  bool m_managedByHasBeenSet = false;
 };
 
 }  // namespace Model

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

@@ -0,0 +1,135 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/accessanalyzer/AccessAnalyzerRequest.h>
+#include <aws/accessanalyzer/AccessAnalyzer_EXPORTS.h>
+#include <aws/accessanalyzer/model/AnalyzerConfiguration.h>
+#include <aws/accessanalyzer/model/InlineArchiveRule.h>
+#include <aws/accessanalyzer/model/Type.h>
+#include <aws/core/utils/UUID.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+
+#include <utility>
+
+namespace Aws {
+namespace AccessAnalyzer {
+namespace Model {
+
+/**
+ * <p>Creates a service-linked analyzer.</p><p><h3>See Also:</h3>   <a
+ * href="http://docs.aws.amazon.com/goto/WebAPI/accessanalyzer-2019-11-01/CreateServiceLinkedAnalyzerRequest">AWS
+ * API Reference</a></p>
+ */
+class CreateServiceLinkedAnalyzerRequest : public AccessAnalyzerRequest {
+ public:
+  AWS_ACCESSANALYZER_API CreateServiceLinkedAnalyzerRequest() = 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 "CreateServiceLinkedAnalyzer"; }
+
+  AWS_ACCESSANALYZER_API Aws::String SerializePayload() const override;
+
+  ///@{
+  /**
+   * <p>The type of analyzer to create. Valid values are
+   * <code>ACCOUNT_UNUSED_ACCESS</code> and
+   * <code>ORGANIZATION_UNUSED_ACCESS</code>.</p>
+   */
+  inline Type GetType() const { return m_type; }
+  inline bool TypeHasBeenSet() const { return m_typeHasBeenSet; }
+  inline void SetType(Type value) {
+    m_typeHasBeenSet = true;
+    m_type = value;
+  }
+  inline CreateServiceLinkedAnalyzerRequest& WithType(Type value) {
+    SetType(value);
+    return *this;
+  }
+  ///@}
+
+  ///@{
+  /**
+   * <p>Specifies the archive rules to add for the analyzer. Archive rules
+   * automatically archive findings that meet the criteria you define for the
+   * rule.</p>
+   */
+  inline const Aws::Vector<InlineArchiveRule>& GetArchiveRules() const { return m_archiveRules; }
+  inline bool ArchiveRulesHasBeenSet() const { return m_archiveRulesHasBeenSet; }
+  template <typename ArchiveRulesT = Aws::Vector<InlineArchiveRule>>
+  void SetArchiveRules(ArchiveRulesT&& value) {
+    m_archiveRulesHasBeenSet = true;
+    m_archiveRules = std::forward<ArchiveRulesT>(value);
+  }
+  template <typename ArchiveRulesT = Aws::Vector<InlineArchiveRule>>
+  CreateServiceLinkedAnalyzerRequest& WithArchiveRules(ArchiveRulesT&& value) {
+    SetArchiveRules(std::forward<ArchiveRulesT>(value));
+    return *this;
+  }
+  template <typename ArchiveRulesT = InlineArchiveRule>
+  CreateServiceLinkedAnalyzerRequest& AddArchiveRules(ArchiveRulesT&& value) {
+    m_archiveRulesHasBeenSet = true;
+    m_archiveRules.emplace_back(std::forward<ArchiveRulesT>(value));
+    return *this;
+  }
+  ///@}
+
+  ///@{
+  /**
+   * <p>A client token.</p>
+   */
+  inline const Aws::String& GetClientToken() const { return m_clientToken; }
+  inline bool ClientTokenHasBeenSet() const { return m_clientTokenHasBeenSet; }
+  template <typename ClientTokenT = Aws::String>
+  void SetClientToken(ClientTokenT&& value) {
+    m_clientTokenHasBeenSet = true;
+    m_clientToken = std::forward<ClientTokenT>(value);
+  }
+  template <typename ClientTokenT = Aws::String>
+  CreateServiceLinkedAnalyzerRequest& WithClientToken(ClientTokenT&& value) {
+    SetClientToken(std::forward<ClientTokenT>(value));
+    return *this;
+  }
+  ///@}
+
+  ///@{
+  /**
+   * <p>Specifies the configuration of the analyzer. The specified scope of unused
+   * access is used for the configuration.</p>
+   */
+  inline const AnalyzerConfiguration& GetConfiguration() const { return m_configuration; }
+  inline bool ConfigurationHasBeenSet() const { return m_configurationHasBeenSet; }
+  template <typename ConfigurationT = AnalyzerConfiguration>
+  void SetConfiguration(ConfigurationT&& value) {
+    m_configurationHasBeenSet = true;
+    m_configuration = std::forward<ConfigurationT>(value);
+  }
+  template <typename ConfigurationT = AnalyzerConfiguration>
+  CreateServiceLinkedAnalyzerRequest& WithConfiguration(ConfigurationT&& value) {
+    SetConfiguration(std::forward<ConfigurationT>(value));
+    return *this;
+  }
+  ///@}
+ private:
+  Type m_type{Type::NOT_SET};
+
+  Aws::Vector<InlineArchiveRule> m_archiveRules;
+
+  Aws::String m_clientToken{Aws::Utils::UUID::PseudoRandomUUID()};
+
+  AnalyzerConfiguration m_configuration;
+  bool m_typeHasBeenSet = false;
+  bool m_archiveRulesHasBeenSet = false;
+  bool m_clientTokenHasBeenSet = true;
+  bool m_configurationHasBeenSet = false;
+};
+
+}  // namespace Model
+}  // namespace AccessAnalyzer
+}  // namespace Aws