Adjust Vietnam PaymentVoucherNumber regex and minor API change.

This release adds support for adding, removing, and listing SLO time exclusion windows with the BatchUpdateExclusionWindows and ListServiceLevelObjectiveExclusionWindows APIs.
Provide support for vector map styles in the GetStaticMap operation.
CloudWatch RUM now supports unminification of JS error stack traces.
AWS WAF now lets you inspect fragments of request URIs. You can specify the scope of the URI to inspect and narrow the set of URI fragments.

Author: aws-sdk-cpp-automation

VERSION

@@ -1 +1 @@
-1.11.526
+1.11.527

generated/src/aws-cpp-sdk-application-signals/include/aws/application-signals/ApplicationSignalsClient.h

@@ -127,6 +127,32 @@ namespace ApplicationSignals
             return SubmitAsync(&ApplicationSignalsClient::BatchGetServiceLevelObjectiveBudgetReport, request, handler, context);
         }
 
+        /**
+         * <p>Add or remove time window exclusions for one or more Service Level Objectives
+         * (SLOs).</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/application-signals-2024-04-15/BatchUpdateExclusionWindows">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::BatchUpdateExclusionWindowsOutcome BatchUpdateExclusionWindows(const Model::BatchUpdateExclusionWindowsRequest& request) const;
+
+        /**
+         * A Callable wrapper for BatchUpdateExclusionWindows that returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        template<typename BatchUpdateExclusionWindowsRequestT = Model::BatchUpdateExclusionWindowsRequest>
+        Model::BatchUpdateExclusionWindowsOutcomeCallable BatchUpdateExclusionWindowsCallable(const BatchUpdateExclusionWindowsRequestT& request) const
+        {
+            return SubmitCallable(&ApplicationSignalsClient::BatchUpdateExclusionWindows, request);
+        }
+
+        /**
+         * An Async wrapper for BatchUpdateExclusionWindows that queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        template<typename BatchUpdateExclusionWindowsRequestT = Model::BatchUpdateExclusionWindowsRequest>
+        void BatchUpdateExclusionWindowsAsync(const BatchUpdateExclusionWindowsRequestT& request, const BatchUpdateExclusionWindowsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
+        {
+            return SubmitAsync(&ApplicationSignalsClient::BatchUpdateExclusionWindows, request, handler, context);
+        }
+
         /**
          * <p>Creates a service level objective (SLO), which can help you ensure that your
          * critical business operations are meeting customer expectations. Use SLOs to set
@@ -339,6 +365,32 @@ namespace ApplicationSignals
             return SubmitAsync(&ApplicationSignalsClient::ListServiceDependents, request, handler, context);
         }
 
+        /**
+         * <p>Retrieves all exclusion windows configured for a specific SLO.</p><p><h3>See
+         * Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/application-signals-2024-04-15/ListServiceLevelObjectiveExclusionWindows">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::ListServiceLevelObjectiveExclusionWindowsOutcome ListServiceLevelObjectiveExclusionWindows(const Model::ListServiceLevelObjectiveExclusionWindowsRequest& request) const;
+
+        /**
+         * A Callable wrapper for ListServiceLevelObjectiveExclusionWindows that returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        template<typename ListServiceLevelObjectiveExclusionWindowsRequestT = Model::ListServiceLevelObjectiveExclusionWindowsRequest>
+        Model::ListServiceLevelObjectiveExclusionWindowsOutcomeCallable ListServiceLevelObjectiveExclusionWindowsCallable(const ListServiceLevelObjectiveExclusionWindowsRequestT& request) const
+        {
+            return SubmitCallable(&ApplicationSignalsClient::ListServiceLevelObjectiveExclusionWindows, request);
+        }
+
+        /**
+         * An Async wrapper for ListServiceLevelObjectiveExclusionWindows that queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        template<typename ListServiceLevelObjectiveExclusionWindowsRequestT = Model::ListServiceLevelObjectiveExclusionWindowsRequest>
+        void ListServiceLevelObjectiveExclusionWindowsAsync(const ListServiceLevelObjectiveExclusionWindowsRequestT& request, const ListServiceLevelObjectiveExclusionWindowsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
+        {
+            return SubmitAsync(&ApplicationSignalsClient::ListServiceLevelObjectiveExclusionWindows, request, handler, context);
+        }
+
         /**
          * <p>Returns a list of SLOs created in this account.</p><p><h3>See Also:</h3>   <a
          * href="http://docs.aws.amazon.com/goto/WebAPI/application-signals-2024-04-15/ListServiceLevelObjectives">AWS

generated/src/aws-cpp-sdk-application-signals/include/aws/application-signals/ApplicationSignalsServiceClientModel.h

@@ -19,12 +19,14 @@
 
 /* Service model headers required in ApplicationSignalsClient header */
 #include <aws/application-signals/model/BatchGetServiceLevelObjectiveBudgetReportResult.h>
+#include <aws/application-signals/model/BatchUpdateExclusionWindowsResult.h>
 #include <aws/application-signals/model/CreateServiceLevelObjectiveResult.h>
 #include <aws/application-signals/model/DeleteServiceLevelObjectiveResult.h>
 #include <aws/application-signals/model/GetServiceResult.h>
 #include <aws/application-signals/model/GetServiceLevelObjectiveResult.h>
 #include <aws/application-signals/model/ListServiceDependenciesResult.h>
 #include <aws/application-signals/model/ListServiceDependentsResult.h>
+#include <aws/application-signals/model/ListServiceLevelObjectiveExclusionWindowsResult.h>
 #include <aws/application-signals/model/ListServiceLevelObjectivesResult.h>
 #include <aws/application-signals/model/ListServiceOperationsResult.h>
 #include <aws/application-signals/model/ListServicesResult.h>
@@ -76,12 +78,14 @@ namespace Aws
     {
       /* Service model forward declarations required in ApplicationSignalsClient header */
       class BatchGetServiceLevelObjectiveBudgetReportRequest;
+      class BatchUpdateExclusionWindowsRequest;
       class CreateServiceLevelObjectiveRequest;
       class DeleteServiceLevelObjectiveRequest;
       class GetServiceRequest;
       class GetServiceLevelObjectiveRequest;
       class ListServiceDependenciesRequest;
       class ListServiceDependentsRequest;
+      class ListServiceLevelObjectiveExclusionWindowsRequest;
       class ListServiceLevelObjectivesRequest;
       class ListServiceOperationsRequest;
       class ListServicesRequest;
@@ -94,12 +98,14 @@ namespace Aws
 
       /* Service model Outcome class definitions */
       typedef Aws::Utils::Outcome<BatchGetServiceLevelObjectiveBudgetReportResult, ApplicationSignalsError> BatchGetServiceLevelObjectiveBudgetReportOutcome;
+      typedef Aws::Utils::Outcome<BatchUpdateExclusionWindowsResult, ApplicationSignalsError> BatchUpdateExclusionWindowsOutcome;
       typedef Aws::Utils::Outcome<CreateServiceLevelObjectiveResult, ApplicationSignalsError> CreateServiceLevelObjectiveOutcome;
       typedef Aws::Utils::Outcome<DeleteServiceLevelObjectiveResult, ApplicationSignalsError> DeleteServiceLevelObjectiveOutcome;
       typedef Aws::Utils::Outcome<GetServiceResult, ApplicationSignalsError> GetServiceOutcome;
       typedef Aws::Utils::Outcome<GetServiceLevelObjectiveResult, ApplicationSignalsError> GetServiceLevelObjectiveOutcome;
       typedef Aws::Utils::Outcome<ListServiceDependenciesResult, ApplicationSignalsError> ListServiceDependenciesOutcome;
       typedef Aws::Utils::Outcome<ListServiceDependentsResult, ApplicationSignalsError> ListServiceDependentsOutcome;
+      typedef Aws::Utils::Outcome<ListServiceLevelObjectiveExclusionWindowsResult, ApplicationSignalsError> ListServiceLevelObjectiveExclusionWindowsOutcome;
       typedef Aws::Utils::Outcome<ListServiceLevelObjectivesResult, ApplicationSignalsError> ListServiceLevelObjectivesOutcome;
       typedef Aws::Utils::Outcome<ListServiceOperationsResult, ApplicationSignalsError> ListServiceOperationsOutcome;
       typedef Aws::Utils::Outcome<ListServicesResult, ApplicationSignalsError> ListServicesOutcome;
@@ -112,12 +118,14 @@ namespace Aws
 
       /* Service model Outcome callable definitions */
       typedef std::future<BatchGetServiceLevelObjectiveBudgetReportOutcome> BatchGetServiceLevelObjectiveBudgetReportOutcomeCallable;
+      typedef std::future<BatchUpdateExclusionWindowsOutcome> BatchUpdateExclusionWindowsOutcomeCallable;
       typedef std::future<CreateServiceLevelObjectiveOutcome> CreateServiceLevelObjectiveOutcomeCallable;
       typedef std::future<DeleteServiceLevelObjectiveOutcome> DeleteServiceLevelObjectiveOutcomeCallable;
       typedef std::future<GetServiceOutcome> GetServiceOutcomeCallable;
       typedef std::future<GetServiceLevelObjectiveOutcome> GetServiceLevelObjectiveOutcomeCallable;
       typedef std::future<ListServiceDependenciesOutcome> ListServiceDependenciesOutcomeCallable;
       typedef std::future<ListServiceDependentsOutcome> ListServiceDependentsOutcomeCallable;
+      typedef std::future<ListServiceLevelObjectiveExclusionWindowsOutcome> ListServiceLevelObjectiveExclusionWindowsOutcomeCallable;
       typedef std::future<ListServiceLevelObjectivesOutcome> ListServiceLevelObjectivesOutcomeCallable;
       typedef std::future<ListServiceOperationsOutcome> ListServiceOperationsOutcomeCallable;
       typedef std::future<ListServicesOutcome> ListServicesOutcomeCallable;
@@ -133,12 +141,14 @@ namespace Aws
 
     /* Service model async handlers definitions */
     typedef std::function<void(const ApplicationSignalsClient*, const Model::BatchGetServiceLevelObjectiveBudgetReportRequest&, const Model::BatchGetServiceLevelObjectiveBudgetReportOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > BatchGetServiceLevelObjectiveBudgetReportResponseReceivedHandler;
+    typedef std::function<void(const ApplicationSignalsClient*, const Model::BatchUpdateExclusionWindowsRequest&, const Model::BatchUpdateExclusionWindowsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > BatchUpdateExclusionWindowsResponseReceivedHandler;
     typedef std::function<void(const ApplicationSignalsClient*, const Model::CreateServiceLevelObjectiveRequest&, const Model::CreateServiceLevelObjectiveOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > CreateServiceLevelObjectiveResponseReceivedHandler;
     typedef std::function<void(const ApplicationSignalsClient*, const Model::DeleteServiceLevelObjectiveRequest&, const Model::DeleteServiceLevelObjectiveOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DeleteServiceLevelObjectiveResponseReceivedHandler;
     typedef std::function<void(const ApplicationSignalsClient*, const Model::GetServiceRequest&, const Model::GetServiceOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > GetServiceResponseReceivedHandler;
     typedef std::function<void(const ApplicationSignalsClient*, const Model::GetServiceLevelObjectiveRequest&, const Model::GetServiceLevelObjectiveOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > GetServiceLevelObjectiveResponseReceivedHandler;
     typedef std::function<void(const ApplicationSignalsClient*, const Model::ListServiceDependenciesRequest&, const Model::ListServiceDependenciesOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListServiceDependenciesResponseReceivedHandler;
     typedef std::function<void(const ApplicationSignalsClient*, const Model::ListServiceDependentsRequest&, const Model::ListServiceDependentsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListServiceDependentsResponseReceivedHandler;
+    typedef std::function<void(const ApplicationSignalsClient*, const Model::ListServiceLevelObjectiveExclusionWindowsRequest&, const Model::ListServiceLevelObjectiveExclusionWindowsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListServiceLevelObjectiveExclusionWindowsResponseReceivedHandler;
     typedef std::function<void(const ApplicationSignalsClient*, const Model::ListServiceLevelObjectivesRequest&, const Model::ListServiceLevelObjectivesOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListServiceLevelObjectivesResponseReceivedHandler;
     typedef std::function<void(const ApplicationSignalsClient*, const Model::ListServiceOperationsRequest&, const Model::ListServiceOperationsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListServiceOperationsResponseReceivedHandler;
     typedef std::function<void(const ApplicationSignalsClient*, const Model::ListServicesRequest&, const Model::ListServicesOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListServicesResponseReceivedHandler;

generated/src/aws-cpp-sdk-application-signals/include/aws/application-signals/model/BatchUpdateExclusionWindowsError.h

@@ -0,0 +1,97 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/application-signals/ApplicationSignals_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace ApplicationSignals
+{
+namespace Model
+{
+
+  /**
+   * <p>An array of structures, where each structure includes an error indicating
+   * that one of the requests in the array was not valid.</p><p><h3>See Also:</h3>  
+   * <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/application-signals-2024-04-15/BatchUpdateExclusionWindowsError">AWS
+   * API Reference</a></p>
+   */
+  class BatchUpdateExclusionWindowsError
+  {
+  public:
+    AWS_APPLICATIONSIGNALS_API BatchUpdateExclusionWindowsError();
+    AWS_APPLICATIONSIGNALS_API BatchUpdateExclusionWindowsError(Aws::Utils::Json::JsonView jsonValue);
+    AWS_APPLICATIONSIGNALS_API BatchUpdateExclusionWindowsError& operator=(Aws::Utils::Json::JsonView jsonValue);
+    AWS_APPLICATIONSIGNALS_API Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    ///@{
+    /**
+     * <p>The SLO ID in the error.</p>
+     */
+    inline const Aws::String& GetSloId() const{ return m_sloId; }
+    inline bool SloIdHasBeenSet() const { return m_sloIdHasBeenSet; }
+    inline void SetSloId(const Aws::String& value) { m_sloIdHasBeenSet = true; m_sloId = value; }
+    inline void SetSloId(Aws::String&& value) { m_sloIdHasBeenSet = true; m_sloId = std::move(value); }
+    inline void SetSloId(const char* value) { m_sloIdHasBeenSet = true; m_sloId.assign(value); }
+    inline BatchUpdateExclusionWindowsError& WithSloId(const Aws::String& value) { SetSloId(value); return *this;}
+    inline BatchUpdateExclusionWindowsError& WithSloId(Aws::String&& value) { SetSloId(std::move(value)); return *this;}
+    inline BatchUpdateExclusionWindowsError& WithSloId(const char* value) { SetSloId(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The error code.</p>
+     */
+    inline const Aws::String& GetErrorCode() const{ return m_errorCode; }
+    inline bool ErrorCodeHasBeenSet() const { return m_errorCodeHasBeenSet; }
+    inline void SetErrorCode(const Aws::String& value) { m_errorCodeHasBeenSet = true; m_errorCode = value; }
+    inline void SetErrorCode(Aws::String&& value) { m_errorCodeHasBeenSet = true; m_errorCode = std::move(value); }
+    inline void SetErrorCode(const char* value) { m_errorCodeHasBeenSet = true; m_errorCode.assign(value); }
+    inline BatchUpdateExclusionWindowsError& WithErrorCode(const Aws::String& value) { SetErrorCode(value); return *this;}
+    inline BatchUpdateExclusionWindowsError& WithErrorCode(Aws::String&& value) { SetErrorCode(std::move(value)); return *this;}
+    inline BatchUpdateExclusionWindowsError& WithErrorCode(const char* value) { SetErrorCode(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The error message.</p>
+     */
+    inline const Aws::String& GetErrorMessage() const{ return m_errorMessage; }
+    inline bool ErrorMessageHasBeenSet() const { return m_errorMessageHasBeenSet; }
+    inline void SetErrorMessage(const Aws::String& value) { m_errorMessageHasBeenSet = true; m_errorMessage = value; }
+    inline void SetErrorMessage(Aws::String&& value) { m_errorMessageHasBeenSet = true; m_errorMessage = std::move(value); }
+    inline void SetErrorMessage(const char* value) { m_errorMessageHasBeenSet = true; m_errorMessage.assign(value); }
+    inline BatchUpdateExclusionWindowsError& WithErrorMessage(const Aws::String& value) { SetErrorMessage(value); return *this;}
+    inline BatchUpdateExclusionWindowsError& WithErrorMessage(Aws::String&& value) { SetErrorMessage(std::move(value)); return *this;}
+    inline BatchUpdateExclusionWindowsError& WithErrorMessage(const char* value) { SetErrorMessage(value); return *this;}
+    ///@}
+  private:
+
+    Aws::String m_sloId;
+    bool m_sloIdHasBeenSet = false;
+
+    Aws::String m_errorCode;
+    bool m_errorCodeHasBeenSet = false;
+
+    Aws::String m_errorMessage;
+    bool m_errorMessageHasBeenSet = false;
+  };
+
+} // namespace Model
+} // namespace ApplicationSignals
+} // namespace Aws