CloudWatchClient.h

 
#pragma once
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/crt/cbor/Cbor.h>
#include <aws/monitoring/CloudWatchPaginationBase.h>
#include <aws/monitoring/CloudWatchServiceClientModel.h>
#include <aws/monitoring/CloudWatchWaiter.h>
#include <aws/monitoring/CloudWatch_EXPORTS.h>
 
namespace Aws {
namespace CloudWatch {
class AWS_CLOUDWATCH_API CloudWatchClient : public Aws::Client::AWSRpcV2CborClient,
                                            public Aws::Client::ClientWithAsyncTemplateMethods<CloudWatchClient>,
                                            public CloudWatchPaginationBase<CloudWatchClient>,
                                            public CloudWatchWaiter<CloudWatchClient> {
 public:
  typedef Aws::Client::AWSRpcV2CborClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef CloudWatchClientConfiguration ClientConfigurationType;
  typedef CloudWatchEndpointProvider EndpointProviderType;
 
  CloudWatchClient(
      const Aws::CloudWatch::CloudWatchClientConfiguration& clientConfiguration = Aws::CloudWatch::CloudWatchClientConfiguration(),
      std::shared_ptr<CloudWatchEndpointProviderBase> endpointProvider = nullptr);
 
  CloudWatchClient(
      const Aws::Auth::AWSCredentials& credentials, std::shared_ptr<CloudWatchEndpointProviderBase> endpointProvider = nullptr,
      const Aws::CloudWatch::CloudWatchClientConfiguration& clientConfiguration = Aws::CloudWatch::CloudWatchClientConfiguration());
 
  CloudWatchClient(
      const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
      std::shared_ptr<CloudWatchEndpointProviderBase> endpointProvider = nullptr,
      const Aws::CloudWatch::CloudWatchClientConfiguration& clientConfiguration = Aws::CloudWatch::CloudWatchClientConfiguration());
 
  /* Legacy constructors due deprecation */
  CloudWatchClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  CloudWatchClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  CloudWatchClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                   const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~CloudWatchClient();
 
  virtual Model::AssociateDatasetKmsKeyOutcome AssociateDatasetKmsKey(const Model::AssociateDatasetKmsKeyRequest& request) const;
 
  template <typename AssociateDatasetKmsKeyRequestT = Model::AssociateDatasetKmsKeyRequest>
  Model::AssociateDatasetKmsKeyOutcomeCallable AssociateDatasetKmsKeyCallable(const AssociateDatasetKmsKeyRequestT& request) const {
    return SubmitCallable(&CloudWatchClient::AssociateDatasetKmsKey, request);
  }
 
  template <typename AssociateDatasetKmsKeyRequestT = Model::AssociateDatasetKmsKeyRequest>
  void AssociateDatasetKmsKeyAsync(const AssociateDatasetKmsKeyRequestT& request,
                                   const AssociateDatasetKmsKeyResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudWatchClient::AssociateDatasetKmsKey, request, handler, context);
  }
 
  virtual Model::DeleteAlarmMuteRuleOutcome DeleteAlarmMuteRule(const Model::DeleteAlarmMuteRuleRequest& request) const;
 
  template <typename DeleteAlarmMuteRuleRequestT = Model::DeleteAlarmMuteRuleRequest>
  Model::DeleteAlarmMuteRuleOutcomeCallable DeleteAlarmMuteRuleCallable(const DeleteAlarmMuteRuleRequestT& request) const {
    return SubmitCallable(&CloudWatchClient::DeleteAlarmMuteRule, request);
  }
 
  template <typename DeleteAlarmMuteRuleRequestT = Model::DeleteAlarmMuteRuleRequest>
  void DeleteAlarmMuteRuleAsync(const DeleteAlarmMuteRuleRequestT& request, const DeleteAlarmMuteRuleResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudWatchClient::DeleteAlarmMuteRule, request, handler, context);
  }
 
  virtual Model::DeleteAlarmsOutcome DeleteAlarms(const Model::DeleteAlarmsRequest& request) const;
 
  template <typename DeleteAlarmsRequestT = Model::DeleteAlarmsRequest>
  Model::DeleteAlarmsOutcomeCallable DeleteAlarmsCallable(const DeleteAlarmsRequestT& request) const {
    return SubmitCallable(&CloudWatchClient::DeleteAlarms, request);
  }
 
  template <typename DeleteAlarmsRequestT = Model::DeleteAlarmsRequest>
  void DeleteAlarmsAsync(const DeleteAlarmsRequestT& request, const DeleteAlarmsResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudWatchClient::DeleteAlarms, request, handler, context);
  }
 
  virtual Model::DeleteAnomalyDetectorOutcome DeleteAnomalyDetector(const Model::DeleteAnomalyDetectorRequest& request = {}) const;
 
  template <typename DeleteAnomalyDetectorRequestT = Model::DeleteAnomalyDetectorRequest>
  Model::DeleteAnomalyDetectorOutcomeCallable DeleteAnomalyDetectorCallable(const DeleteAnomalyDetectorRequestT& request = {}) const {
    return SubmitCallable(&CloudWatchClient::DeleteAnomalyDetector, request);
  }
 
  template <typename DeleteAnomalyDetectorRequestT = Model::DeleteAnomalyDetectorRequest>
  void DeleteAnomalyDetectorAsync(const DeleteAnomalyDetectorResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                  const DeleteAnomalyDetectorRequestT& request = {}) const {
    return SubmitAsync(&CloudWatchClient::DeleteAnomalyDetector, request, handler, context);
  }
 
  virtual Model::DeleteDashboardsOutcome DeleteDashboards(const Model::DeleteDashboardsRequest& request) const;
 
  template <typename DeleteDashboardsRequestT = Model::DeleteDashboardsRequest>
  Model::DeleteDashboardsOutcomeCallable DeleteDashboardsCallable(const DeleteDashboardsRequestT& request) const {
    return SubmitCallable(&CloudWatchClient::DeleteDashboards, request);
  }
 
  template <typename DeleteDashboardsRequestT = Model::DeleteDashboardsRequest>
  void DeleteDashboardsAsync(const DeleteDashboardsRequestT& request, const DeleteDashboardsResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudWatchClient::DeleteDashboards, request, handler, context);
  }
 
  virtual Model::DeleteInsightRulesOutcome DeleteInsightRules(const Model::DeleteInsightRulesRequest& request) const;
 
  template <typename DeleteInsightRulesRequestT = Model::DeleteInsightRulesRequest>
  Model::DeleteInsightRulesOutcomeCallable DeleteInsightRulesCallable(const DeleteInsightRulesRequestT& request) const {
    return SubmitCallable(&CloudWatchClient::DeleteInsightRules, request);
  }
 
  template <typename DeleteInsightRulesRequestT = Model::DeleteInsightRulesRequest>
  void DeleteInsightRulesAsync(const DeleteInsightRulesRequestT& request, const DeleteInsightRulesResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudWatchClient::DeleteInsightRules, request, handler, context);
  }
 
  virtual Model::DeleteMetricStreamOutcome DeleteMetricStream(const Model::DeleteMetricStreamRequest& request) const;
 
  template <typename DeleteMetricStreamRequestT = Model::DeleteMetricStreamRequest>
  Model::DeleteMetricStreamOutcomeCallable DeleteMetricStreamCallable(const DeleteMetricStreamRequestT& request) const {
    return SubmitCallable(&CloudWatchClient::DeleteMetricStream, request);
  }
 
  template <typename DeleteMetricStreamRequestT = Model::DeleteMetricStreamRequest>
  void DeleteMetricStreamAsync(const DeleteMetricStreamRequestT& request, const DeleteMetricStreamResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudWatchClient::DeleteMetricStream, request, handler, context);
  }
 
  virtual Model::DescribeAlarmContributorsOutcome DescribeAlarmContributors(const Model::DescribeAlarmContributorsRequest& request) const;
 
  template <typename DescribeAlarmContributorsRequestT = Model::DescribeAlarmContributorsRequest>
  Model::DescribeAlarmContributorsOutcomeCallable DescribeAlarmContributorsCallable(
      const DescribeAlarmContributorsRequestT& request) const {
    return SubmitCallable(&CloudWatchClient::DescribeAlarmContributors, request);
  }
 
  template <typename DescribeAlarmContributorsRequestT = Model::DescribeAlarmContributorsRequest>
  void DescribeAlarmContributorsAsync(const DescribeAlarmContributorsRequestT& request,
                                      const DescribeAlarmContributorsResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudWatchClient::DescribeAlarmContributors, request, handler, context);
  }
 
  virtual Model::DescribeAlarmHistoryOutcome DescribeAlarmHistory(const Model::DescribeAlarmHistoryRequest& request = {}) const;
 
  template <typename DescribeAlarmHistoryRequestT = Model::DescribeAlarmHistoryRequest>
  Model::DescribeAlarmHistoryOutcomeCallable DescribeAlarmHistoryCallable(const DescribeAlarmHistoryRequestT& request = {}) const {
    return SubmitCallable(&CloudWatchClient::DescribeAlarmHistory, request);
  }
 
  template <typename DescribeAlarmHistoryRequestT = Model::DescribeAlarmHistoryRequest>
  void DescribeAlarmHistoryAsync(const DescribeAlarmHistoryResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                 const DescribeAlarmHistoryRequestT& request = {}) const {
    return SubmitAsync(&CloudWatchClient::DescribeAlarmHistory, request, handler, context);
  }
 
  virtual Model::DescribeAlarmsOutcome DescribeAlarms(const Model::DescribeAlarmsRequest& request = {}) const;
 
  template <typename DescribeAlarmsRequestT = Model::DescribeAlarmsRequest>
  Model::DescribeAlarmsOutcomeCallable DescribeAlarmsCallable(const DescribeAlarmsRequestT& request = {}) const {
    return SubmitCallable(&CloudWatchClient::DescribeAlarms, request);
  }
 
  template <typename DescribeAlarmsRequestT = Model::DescribeAlarmsRequest>
  void DescribeAlarmsAsync(const DescribeAlarmsResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                           const DescribeAlarmsRequestT& request = {}) const {
    return SubmitAsync(&CloudWatchClient::DescribeAlarms, request, handler, context);
  }
 
  virtual Model::DescribeAlarmsForMetricOutcome DescribeAlarmsForMetric(const Model::DescribeAlarmsForMetricRequest& request) const;
 
  template <typename DescribeAlarmsForMetricRequestT = Model::DescribeAlarmsForMetricRequest>
  Model::DescribeAlarmsForMetricOutcomeCallable DescribeAlarmsForMetricCallable(const DescribeAlarmsForMetricRequestT& request) const {
    return SubmitCallable(&CloudWatchClient::DescribeAlarmsForMetric, request);
  }
 
  template <typename DescribeAlarmsForMetricRequestT = Model::DescribeAlarmsForMetricRequest>
  void DescribeAlarmsForMetricAsync(const DescribeAlarmsForMetricRequestT& request,
                                    const DescribeAlarmsForMetricResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudWatchClient::DescribeAlarmsForMetric, request, handler, context);
  }
 
  virtual Model::DescribeAnomalyDetectorsOutcome DescribeAnomalyDetectors(const Model::DescribeAnomalyDetectorsRequest& request = {}) const;
 
  template <typename DescribeAnomalyDetectorsRequestT = Model::DescribeAnomalyDetectorsRequest>
  Model::DescribeAnomalyDetectorsOutcomeCallable DescribeAnomalyDetectorsCallable(
      const DescribeAnomalyDetectorsRequestT& request = {}) const {
    return SubmitCallable(&CloudWatchClient::DescribeAnomalyDetectors, request);
  }
 
  template <typename DescribeAnomalyDetectorsRequestT = Model::DescribeAnomalyDetectorsRequest>
  void DescribeAnomalyDetectorsAsync(const DescribeAnomalyDetectorsResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                     const DescribeAnomalyDetectorsRequestT& request = {}) const {
    return SubmitAsync(&CloudWatchClient::DescribeAnomalyDetectors, request, handler, context);
  }
 
  virtual Model::DescribeInsightRulesOutcome DescribeInsightRules(const Model::DescribeInsightRulesRequest& request = {}) const;
 
  template <typename DescribeInsightRulesRequestT = Model::DescribeInsightRulesRequest>
  Model::DescribeInsightRulesOutcomeCallable DescribeInsightRulesCallable(const DescribeInsightRulesRequestT& request = {}) const {
    return SubmitCallable(&CloudWatchClient::DescribeInsightRules, request);
  }
 
  template <typename DescribeInsightRulesRequestT = Model::DescribeInsightRulesRequest>
  void DescribeInsightRulesAsync(const DescribeInsightRulesResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                 const DescribeInsightRulesRequestT& request = {}) const {
    return SubmitAsync(&CloudWatchClient::DescribeInsightRules, request, handler, context);
  }
 
  virtual Model::DisableAlarmActionsOutcome DisableAlarmActions(const Model::DisableAlarmActionsRequest& request) const;
 
  template <typename DisableAlarmActionsRequestT = Model::DisableAlarmActionsRequest>
  Model::DisableAlarmActionsOutcomeCallable DisableAlarmActionsCallable(const DisableAlarmActionsRequestT& request) const {
    return SubmitCallable(&CloudWatchClient::DisableAlarmActions, request);
  }
 
  template <typename DisableAlarmActionsRequestT = Model::DisableAlarmActionsRequest>
  void DisableAlarmActionsAsync(const DisableAlarmActionsRequestT& request, const DisableAlarmActionsResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudWatchClient::DisableAlarmActions, request, handler, context);
  }
 
  virtual Model::DisableInsightRulesOutcome DisableInsightRules(const Model::DisableInsightRulesRequest& request) const;
 
  template <typename DisableInsightRulesRequestT = Model::DisableInsightRulesRequest>
  Model::DisableInsightRulesOutcomeCallable DisableInsightRulesCallable(const DisableInsightRulesRequestT& request) const {
    return SubmitCallable(&CloudWatchClient::DisableInsightRules, request);
  }
 
  template <typename DisableInsightRulesRequestT = Model::DisableInsightRulesRequest>
  void DisableInsightRulesAsync(const DisableInsightRulesRequestT& request, const DisableInsightRulesResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudWatchClient::DisableInsightRules, request, handler, context);
  }
 
  virtual Model::DisassociateDatasetKmsKeyOutcome DisassociateDatasetKmsKey(const Model::DisassociateDatasetKmsKeyRequest& request) const;
 
  template <typename DisassociateDatasetKmsKeyRequestT = Model::DisassociateDatasetKmsKeyRequest>
  Model::DisassociateDatasetKmsKeyOutcomeCallable DisassociateDatasetKmsKeyCallable(
      const DisassociateDatasetKmsKeyRequestT& request) const {
    return SubmitCallable(&CloudWatchClient::DisassociateDatasetKmsKey, request);
  }
 
  template <typename DisassociateDatasetKmsKeyRequestT = Model::DisassociateDatasetKmsKeyRequest>
  void DisassociateDatasetKmsKeyAsync(const DisassociateDatasetKmsKeyRequestT& request,
                                      const DisassociateDatasetKmsKeyResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudWatchClient::DisassociateDatasetKmsKey, request, handler, context);
  }
 
  virtual Model::EnableAlarmActionsOutcome EnableAlarmActions(const Model::EnableAlarmActionsRequest& request) const;
 
  template <typename EnableAlarmActionsRequestT = Model::EnableAlarmActionsRequest>
  Model::EnableAlarmActionsOutcomeCallable EnableAlarmActionsCallable(const EnableAlarmActionsRequestT& request) const {
    return SubmitCallable(&CloudWatchClient::EnableAlarmActions, request);
  }
 
  template <typename EnableAlarmActionsRequestT = Model::EnableAlarmActionsRequest>
  void EnableAlarmActionsAsync(const EnableAlarmActionsRequestT& request, const EnableAlarmActionsResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudWatchClient::EnableAlarmActions, request, handler, context);
  }
 
  virtual Model::EnableInsightRulesOutcome EnableInsightRules(const Model::EnableInsightRulesRequest& request) const;
 
  template <typename EnableInsightRulesRequestT = Model::EnableInsightRulesRequest>
  Model::EnableInsightRulesOutcomeCallable EnableInsightRulesCallable(const EnableInsightRulesRequestT& request) const {
    return SubmitCallable(&CloudWatchClient::EnableInsightRules, request);
  }
 
  template <typename EnableInsightRulesRequestT = Model::EnableInsightRulesRequest>
  void EnableInsightRulesAsync(const EnableInsightRulesRequestT& request, const EnableInsightRulesResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudWatchClient::EnableInsightRules, request, handler, context);
  }
 
  virtual Model::GetAlarmMuteRuleOutcome GetAlarmMuteRule(const Model::GetAlarmMuteRuleRequest& request) const;
 
  template <typename GetAlarmMuteRuleRequestT = Model::GetAlarmMuteRuleRequest>
  Model::GetAlarmMuteRuleOutcomeCallable GetAlarmMuteRuleCallable(const GetAlarmMuteRuleRequestT& request) const {
    return SubmitCallable(&CloudWatchClient::GetAlarmMuteRule, request);
  }
 
  template <typename GetAlarmMuteRuleRequestT = Model::GetAlarmMuteRuleRequest>
  void GetAlarmMuteRuleAsync(const GetAlarmMuteRuleRequestT& request, const GetAlarmMuteRuleResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudWatchClient::GetAlarmMuteRule, request, handler, context);
  }
 
  virtual Model::GetDashboardOutcome GetDashboard(const Model::GetDashboardRequest& request) const;
 
  template <typename GetDashboardRequestT = Model::GetDashboardRequest>
  Model::GetDashboardOutcomeCallable GetDashboardCallable(const GetDashboardRequestT& request) const {
    return SubmitCallable(&CloudWatchClient::GetDashboard, request);
  }
 
  template <typename GetDashboardRequestT = Model::GetDashboardRequest>
  void GetDashboardAsync(const GetDashboardRequestT& request, const GetDashboardResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudWatchClient::GetDashboard, request, handler, context);
  }
 
  virtual Model::GetDatasetOutcome GetDataset(const Model::GetDatasetRequest& request) const;
 
  template <typename GetDatasetRequestT = Model::GetDatasetRequest>
  Model::GetDatasetOutcomeCallable GetDatasetCallable(const GetDatasetRequestT& request) const {
    return SubmitCallable(&CloudWatchClient::GetDataset, request);
  }
 
  template <typename GetDatasetRequestT = Model::GetDatasetRequest>
  void GetDatasetAsync(const GetDatasetRequestT& request, const GetDatasetResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudWatchClient::GetDataset, request, handler, context);
  }
 
  virtual Model::GetInsightRuleReportOutcome GetInsightRuleReport(const Model::GetInsightRuleReportRequest& request) const;
 
  template <typename GetInsightRuleReportRequestT = Model::GetInsightRuleReportRequest>
  Model::GetInsightRuleReportOutcomeCallable GetInsightRuleReportCallable(const GetInsightRuleReportRequestT& request) const {
    return SubmitCallable(&CloudWatchClient::GetInsightRuleReport, request);
  }
 
  template <typename GetInsightRuleReportRequestT = Model::GetInsightRuleReportRequest>
  void GetInsightRuleReportAsync(const GetInsightRuleReportRequestT& request, const GetInsightRuleReportResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudWatchClient::GetInsightRuleReport, request, handler, context);
  }
 
  virtual Model::GetMetricDataOutcome GetMetricData(const Model::GetMetricDataRequest& request) const;
 
  template <typename GetMetricDataRequestT = Model::GetMetricDataRequest>
  Model::GetMetricDataOutcomeCallable GetMetricDataCallable(const GetMetricDataRequestT& request) const {
    return SubmitCallable(&CloudWatchClient::GetMetricData, request);
  }
 
  template <typename GetMetricDataRequestT = Model::GetMetricDataRequest>
  void GetMetricDataAsync(const GetMetricDataRequestT& request, const GetMetricDataResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudWatchClient::GetMetricData, request, handler, context);
  }
 
  virtual Model::GetMetricStatisticsOutcome GetMetricStatistics(const Model::GetMetricStatisticsRequest& request) const;
 
  template <typename GetMetricStatisticsRequestT = Model::GetMetricStatisticsRequest>
  Model::GetMetricStatisticsOutcomeCallable GetMetricStatisticsCallable(const GetMetricStatisticsRequestT& request) const {
    return SubmitCallable(&CloudWatchClient::GetMetricStatistics, request);
  }
 
  template <typename GetMetricStatisticsRequestT = Model::GetMetricStatisticsRequest>
  void GetMetricStatisticsAsync(const GetMetricStatisticsRequestT& request, const GetMetricStatisticsResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudWatchClient::GetMetricStatistics, request, handler, context);
  }
 
  virtual Model::GetMetricStreamOutcome GetMetricStream(const Model::GetMetricStreamRequest& request) const;
 
  template <typename GetMetricStreamRequestT = Model::GetMetricStreamRequest>
  Model::GetMetricStreamOutcomeCallable GetMetricStreamCallable(const GetMetricStreamRequestT& request) const {
    return SubmitCallable(&CloudWatchClient::GetMetricStream, request);
  }
 
  template <typename GetMetricStreamRequestT = Model::GetMetricStreamRequest>
  void GetMetricStreamAsync(const GetMetricStreamRequestT& request, const GetMetricStreamResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudWatchClient::GetMetricStream, request, handler, context);
  }
 
  virtual Model::GetMetricWidgetImageOutcome GetMetricWidgetImage(const Model::GetMetricWidgetImageRequest& request) const;
 
  template <typename GetMetricWidgetImageRequestT = Model::GetMetricWidgetImageRequest>
  Model::GetMetricWidgetImageOutcomeCallable GetMetricWidgetImageCallable(const GetMetricWidgetImageRequestT& request) const {
    return SubmitCallable(&CloudWatchClient::GetMetricWidgetImage, request);
  }
 
  template <typename GetMetricWidgetImageRequestT = Model::GetMetricWidgetImageRequest>
  void GetMetricWidgetImageAsync(const GetMetricWidgetImageRequestT& request, const GetMetricWidgetImageResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudWatchClient::GetMetricWidgetImage, request, handler, context);
  }
 
  virtual Model::GetOTelEnrichmentOutcome GetOTelEnrichment(const Model::GetOTelEnrichmentRequest& request = {}) const;
 
  template <typename GetOTelEnrichmentRequestT = Model::GetOTelEnrichmentRequest>
  Model::GetOTelEnrichmentOutcomeCallable GetOTelEnrichmentCallable(const GetOTelEnrichmentRequestT& request = {}) const {
    return SubmitCallable(&CloudWatchClient::GetOTelEnrichment, request);
  }
 
  template <typename GetOTelEnrichmentRequestT = Model::GetOTelEnrichmentRequest>
  void GetOTelEnrichmentAsync(const GetOTelEnrichmentResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                              const GetOTelEnrichmentRequestT& request = {}) const {
    return SubmitAsync(&CloudWatchClient::GetOTelEnrichment, request, handler, context);
  }
 
  virtual Model::ListAlarmMuteRulesOutcome ListAlarmMuteRules(const Model::ListAlarmMuteRulesRequest& request = {}) const;
 
  template <typename ListAlarmMuteRulesRequestT = Model::ListAlarmMuteRulesRequest>
  Model::ListAlarmMuteRulesOutcomeCallable ListAlarmMuteRulesCallable(const ListAlarmMuteRulesRequestT& request = {}) const {
    return SubmitCallable(&CloudWatchClient::ListAlarmMuteRules, request);
  }
 
  template <typename ListAlarmMuteRulesRequestT = Model::ListAlarmMuteRulesRequest>
  void ListAlarmMuteRulesAsync(const ListAlarmMuteRulesResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                               const ListAlarmMuteRulesRequestT& request = {}) const {
    return SubmitAsync(&CloudWatchClient::ListAlarmMuteRules, request, handler, context);
  }
 
  virtual Model::ListDashboardsOutcome ListDashboards(const Model::ListDashboardsRequest& request = {}) const;
 
  template <typename ListDashboardsRequestT = Model::ListDashboardsRequest>
  Model::ListDashboardsOutcomeCallable ListDashboardsCallable(const ListDashboardsRequestT& request = {}) const {
    return SubmitCallable(&CloudWatchClient::ListDashboards, request);
  }
 
  template <typename ListDashboardsRequestT = Model::ListDashboardsRequest>
  void ListDashboardsAsync(const ListDashboardsResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                           const ListDashboardsRequestT& request = {}) const {
    return SubmitAsync(&CloudWatchClient::ListDashboards, request, handler, context);
  }
 
  virtual Model::ListManagedInsightRulesOutcome ListManagedInsightRules(const Model::ListManagedInsightRulesRequest& request) const;
 
  template <typename ListManagedInsightRulesRequestT = Model::ListManagedInsightRulesRequest>
  Model::ListManagedInsightRulesOutcomeCallable ListManagedInsightRulesCallable(const ListManagedInsightRulesRequestT& request) const {
    return SubmitCallable(&CloudWatchClient::ListManagedInsightRules, request);
  }
 
  template <typename ListManagedInsightRulesRequestT = Model::ListManagedInsightRulesRequest>
  void ListManagedInsightRulesAsync(const ListManagedInsightRulesRequestT& request,
                                    const ListManagedInsightRulesResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudWatchClient::ListManagedInsightRules, request, handler, context);
  }
 
  virtual Model::ListMetricStreamsOutcome ListMetricStreams(const Model::ListMetricStreamsRequest& request = {}) const;
 
  template <typename ListMetricStreamsRequestT = Model::ListMetricStreamsRequest>
  Model::ListMetricStreamsOutcomeCallable ListMetricStreamsCallable(const ListMetricStreamsRequestT& request = {}) const {
    return SubmitCallable(&CloudWatchClient::ListMetricStreams, request);
  }
 
  template <typename ListMetricStreamsRequestT = Model::ListMetricStreamsRequest>
  void ListMetricStreamsAsync(const ListMetricStreamsResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                              const ListMetricStreamsRequestT& request = {}) const {
    return SubmitAsync(&CloudWatchClient::ListMetricStreams, request, handler, context);
  }
 
  virtual Model::ListMetricsOutcome ListMetrics(const Model::ListMetricsRequest& request = {}) const;
 
  template <typename ListMetricsRequestT = Model::ListMetricsRequest>
  Model::ListMetricsOutcomeCallable ListMetricsCallable(const ListMetricsRequestT& request = {}) const {
    return SubmitCallable(&CloudWatchClient::ListMetrics, request);
  }
 
  template <typename ListMetricsRequestT = Model::ListMetricsRequest>
  void ListMetricsAsync(const ListMetricsResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                        const ListMetricsRequestT& request = {}) const {
    return SubmitAsync(&CloudWatchClient::ListMetrics, request, handler, context);
  }
 
  virtual Model::ListTagsForResourceOutcome ListTagsForResource(const Model::ListTagsForResourceRequest& request) const;
 
  template <typename ListTagsForResourceRequestT = Model::ListTagsForResourceRequest>
  Model::ListTagsForResourceOutcomeCallable ListTagsForResourceCallable(const ListTagsForResourceRequestT& request) const {
    return SubmitCallable(&CloudWatchClient::ListTagsForResource, request);
  }
 
  template <typename ListTagsForResourceRequestT = Model::ListTagsForResourceRequest>
  void ListTagsForResourceAsync(const ListTagsForResourceRequestT& request, const ListTagsForResourceResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudWatchClient::ListTagsForResource, request, handler, context);
  }
 
  virtual Model::PutAlarmMuteRuleOutcome PutAlarmMuteRule(const Model::PutAlarmMuteRuleRequest& request) const;
 
  template <typename PutAlarmMuteRuleRequestT = Model::PutAlarmMuteRuleRequest>
  Model::PutAlarmMuteRuleOutcomeCallable PutAlarmMuteRuleCallable(const PutAlarmMuteRuleRequestT& request) const {
    return SubmitCallable(&CloudWatchClient::PutAlarmMuteRule, request);
  }
 
  template <typename PutAlarmMuteRuleRequestT = Model::PutAlarmMuteRuleRequest>
  void PutAlarmMuteRuleAsync(const PutAlarmMuteRuleRequestT& request, const PutAlarmMuteRuleResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudWatchClient::PutAlarmMuteRule, request, handler, context);
  }
 
  virtual Model::PutAnomalyDetectorOutcome PutAnomalyDetector(const Model::PutAnomalyDetectorRequest& request = {}) const;
 
  template <typename PutAnomalyDetectorRequestT = Model::PutAnomalyDetectorRequest>
  Model::PutAnomalyDetectorOutcomeCallable PutAnomalyDetectorCallable(const PutAnomalyDetectorRequestT& request = {}) const {
    return SubmitCallable(&CloudWatchClient::PutAnomalyDetector, request);
  }
 
  template <typename PutAnomalyDetectorRequestT = Model::PutAnomalyDetectorRequest>
  void PutAnomalyDetectorAsync(const PutAnomalyDetectorResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                               const PutAnomalyDetectorRequestT& request = {}) const {
    return SubmitAsync(&CloudWatchClient::PutAnomalyDetector, request, handler, context);
  }
 
  virtual Model::PutCompositeAlarmOutcome PutCompositeAlarm(const Model::PutCompositeAlarmRequest& request) const;
 
  template <typename PutCompositeAlarmRequestT = Model::PutCompositeAlarmRequest>
  Model::PutCompositeAlarmOutcomeCallable PutCompositeAlarmCallable(const PutCompositeAlarmRequestT& request) const {
    return SubmitCallable(&CloudWatchClient::PutCompositeAlarm, request);
  }
 
  template <typename PutCompositeAlarmRequestT = Model::PutCompositeAlarmRequest>
  void PutCompositeAlarmAsync(const PutCompositeAlarmRequestT& request, const PutCompositeAlarmResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudWatchClient::PutCompositeAlarm, request, handler, context);
  }
 
  virtual Model::PutDashboardOutcome PutDashboard(const Model::PutDashboardRequest& request) const;
 
  template <typename PutDashboardRequestT = Model::PutDashboardRequest>
  Model::PutDashboardOutcomeCallable PutDashboardCallable(const PutDashboardRequestT& request) const {
    return SubmitCallable(&CloudWatchClient::PutDashboard, request);
  }
 
  template <typename PutDashboardRequestT = Model::PutDashboardRequest>
  void PutDashboardAsync(const PutDashboardRequestT& request, const PutDashboardResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudWatchClient::PutDashboard, request, handler, context);
  }
 
  virtual Model::PutInsightRuleOutcome PutInsightRule(const Model::PutInsightRuleRequest& request) const;
 
  template <typename PutInsightRuleRequestT = Model::PutInsightRuleRequest>
  Model::PutInsightRuleOutcomeCallable PutInsightRuleCallable(const PutInsightRuleRequestT& request) const {
    return SubmitCallable(&CloudWatchClient::PutInsightRule, request);
  }
 
  template <typename PutInsightRuleRequestT = Model::PutInsightRuleRequest>
  void PutInsightRuleAsync(const PutInsightRuleRequestT& request, const PutInsightRuleResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudWatchClient::PutInsightRule, request, handler, context);
  }
 
  virtual Model::PutManagedInsightRulesOutcome PutManagedInsightRules(const Model::PutManagedInsightRulesRequest& request) const;
 
  template <typename PutManagedInsightRulesRequestT = Model::PutManagedInsightRulesRequest>
  Model::PutManagedInsightRulesOutcomeCallable PutManagedInsightRulesCallable(const PutManagedInsightRulesRequestT& request) const {
    return SubmitCallable(&CloudWatchClient::PutManagedInsightRules, request);
  }
 
  template <typename PutManagedInsightRulesRequestT = Model::PutManagedInsightRulesRequest>
  void PutManagedInsightRulesAsync(const PutManagedInsightRulesRequestT& request,
                                   const PutManagedInsightRulesResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudWatchClient::PutManagedInsightRules, request, handler, context);
  }
 
  virtual Model::PutMetricAlarmOutcome PutMetricAlarm(const Model::PutMetricAlarmRequest& request) const;
 
  template <typename PutMetricAlarmRequestT = Model::PutMetricAlarmRequest>
  Model::PutMetricAlarmOutcomeCallable PutMetricAlarmCallable(const PutMetricAlarmRequestT& request) const {
    return SubmitCallable(&CloudWatchClient::PutMetricAlarm, request);
  }
 
  template <typename PutMetricAlarmRequestT = Model::PutMetricAlarmRequest>
  void PutMetricAlarmAsync(const PutMetricAlarmRequestT& request, const PutMetricAlarmResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudWatchClient::PutMetricAlarm, request, handler, context);
  }
 
  virtual Model::PutMetricDataOutcome PutMetricData(const Model::PutMetricDataRequest& request) const;
 
  template <typename PutMetricDataRequestT = Model::PutMetricDataRequest>
  Model::PutMetricDataOutcomeCallable PutMetricDataCallable(const PutMetricDataRequestT& request) const {
    return SubmitCallable(&CloudWatchClient::PutMetricData, request);
  }
 
  template <typename PutMetricDataRequestT = Model::PutMetricDataRequest>
  void PutMetricDataAsync(const PutMetricDataRequestT& request, const PutMetricDataResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudWatchClient::PutMetricData, request, handler, context);
  }
 
  virtual Model::PutMetricStreamOutcome PutMetricStream(const Model::PutMetricStreamRequest& request) const;
 
  template <typename PutMetricStreamRequestT = Model::PutMetricStreamRequest>
  Model::PutMetricStreamOutcomeCallable PutMetricStreamCallable(const PutMetricStreamRequestT& request) const {
    return SubmitCallable(&CloudWatchClient::PutMetricStream, request);
  }
 
  template <typename PutMetricStreamRequestT = Model::PutMetricStreamRequest>
  void PutMetricStreamAsync(const PutMetricStreamRequestT& request, const PutMetricStreamResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudWatchClient::PutMetricStream, request, handler, context);
  }
 
  virtual Model::SetAlarmStateOutcome SetAlarmState(const Model::SetAlarmStateRequest& request) const;
 
  template <typename SetAlarmStateRequestT = Model::SetAlarmStateRequest>
  Model::SetAlarmStateOutcomeCallable SetAlarmStateCallable(const SetAlarmStateRequestT& request) const {
    return SubmitCallable(&CloudWatchClient::SetAlarmState, request);
  }
 
  template <typename SetAlarmStateRequestT = Model::SetAlarmStateRequest>
  void SetAlarmStateAsync(const SetAlarmStateRequestT& request, const SetAlarmStateResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudWatchClient::SetAlarmState, request, handler, context);
  }
 
  virtual Model::StartMetricStreamsOutcome StartMetricStreams(const Model::StartMetricStreamsRequest& request) const;
 
  template <typename StartMetricStreamsRequestT = Model::StartMetricStreamsRequest>
  Model::StartMetricStreamsOutcomeCallable StartMetricStreamsCallable(const StartMetricStreamsRequestT& request) const {
    return SubmitCallable(&CloudWatchClient::StartMetricStreams, request);
  }
 
  template <typename StartMetricStreamsRequestT = Model::StartMetricStreamsRequest>
  void StartMetricStreamsAsync(const StartMetricStreamsRequestT& request, const StartMetricStreamsResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudWatchClient::StartMetricStreams, request, handler, context);
  }
 
  virtual Model::StartOTelEnrichmentOutcome StartOTelEnrichment(const Model::StartOTelEnrichmentRequest& request = {}) const;
 
  template <typename StartOTelEnrichmentRequestT = Model::StartOTelEnrichmentRequest>
  Model::StartOTelEnrichmentOutcomeCallable StartOTelEnrichmentCallable(const StartOTelEnrichmentRequestT& request = {}) const {
    return SubmitCallable(&CloudWatchClient::StartOTelEnrichment, request);
  }
 
  template <typename StartOTelEnrichmentRequestT = Model::StartOTelEnrichmentRequest>
  void StartOTelEnrichmentAsync(const StartOTelEnrichmentResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                const StartOTelEnrichmentRequestT& request = {}) const {
    return SubmitAsync(&CloudWatchClient::StartOTelEnrichment, request, handler, context);
  }
 
  virtual Model::StopMetricStreamsOutcome StopMetricStreams(const Model::StopMetricStreamsRequest& request) const;
 
  template <typename StopMetricStreamsRequestT = Model::StopMetricStreamsRequest>
  Model::StopMetricStreamsOutcomeCallable StopMetricStreamsCallable(const StopMetricStreamsRequestT& request) const {
    return SubmitCallable(&CloudWatchClient::StopMetricStreams, request);
  }
 
  template <typename StopMetricStreamsRequestT = Model::StopMetricStreamsRequest>
  void StopMetricStreamsAsync(const StopMetricStreamsRequestT& request, const StopMetricStreamsResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudWatchClient::StopMetricStreams, request, handler, context);
  }
 
  virtual Model::StopOTelEnrichmentOutcome StopOTelEnrichment(const Model::StopOTelEnrichmentRequest& request = {}) const;
 
  template <typename StopOTelEnrichmentRequestT = Model::StopOTelEnrichmentRequest>
  Model::StopOTelEnrichmentOutcomeCallable StopOTelEnrichmentCallable(const StopOTelEnrichmentRequestT& request = {}) const {
    return SubmitCallable(&CloudWatchClient::StopOTelEnrichment, request);
  }
 
  template <typename StopOTelEnrichmentRequestT = Model::StopOTelEnrichmentRequest>
  void StopOTelEnrichmentAsync(const StopOTelEnrichmentResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                               const StopOTelEnrichmentRequestT& request = {}) const {
    return SubmitAsync(&CloudWatchClient::StopOTelEnrichment, request, handler, context);
  }
 
  virtual Model::TagResourceOutcome TagResource(const Model::TagResourceRequest& request) const;
 
  template <typename TagResourceRequestT = Model::TagResourceRequest>
  Model::TagResourceOutcomeCallable TagResourceCallable(const TagResourceRequestT& request) const {
    return SubmitCallable(&CloudWatchClient::TagResource, request);
  }
 
  template <typename TagResourceRequestT = Model::TagResourceRequest>
  void TagResourceAsync(const TagResourceRequestT& request, const TagResourceResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudWatchClient::TagResource, request, handler, context);
  }
 
  virtual Model::UntagResourceOutcome UntagResource(const Model::UntagResourceRequest& request) const;
 
  template <typename UntagResourceRequestT = Model::UntagResourceRequest>
  Model::UntagResourceOutcomeCallable UntagResourceCallable(const UntagResourceRequestT& request) const {
    return SubmitCallable(&CloudWatchClient::UntagResource, request);
  }
 
  template <typename UntagResourceRequestT = Model::UntagResourceRequest>
  void UntagResourceAsync(const UntagResourceRequestT& request, const UntagResourceResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudWatchClient::UntagResource, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<CloudWatchEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<CloudWatchClient>;
  void init(const CloudWatchClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, CloudWatchError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request, Aws::Http::HttpMethod httpMethod) const;
 
  CloudWatchClientConfiguration m_clientConfiguration;
  std::shared_ptr<CloudWatchEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace CloudWatch
}  // namespace Aws