CloudWatchClient.h

 
#pragma once
#include <aws/monitoring/CloudWatch_EXPORTS.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/AmazonSerializableWebServiceRequest.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/utils/xml/XmlSerializer.h>
#include <aws/monitoring/CloudWatchServiceClientModel.h>
 
namespace Aws
{
namespace CloudWatch
{
  class AWS_CLOUDWATCH_API CloudWatchClient : public Aws::Client::AWSXMLClient, public Aws::Client::ClientWithAsyncTemplateMethods<CloudWatchClient>
  {
    public:
      typedef Aws::Client::AWSXMLClient 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();
 
 
        Aws::String ConvertRequestToPresignedUrl(const Aws::AmazonSerializableWebServiceRequest& requestToConvert, const char* region) const;
 
 
        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::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::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::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::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::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::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::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::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);
        }
 
 
        void OverrideEndpoint(const Aws::String& endpoint);
        std::shared_ptr<CloudWatchEndpointProviderBase>& accessEndpointProvider();
  private:
        friend class Aws::Client::ClientWithAsyncTemplateMethods<CloudWatchClient>;
        void init(const CloudWatchClientConfiguration& clientConfiguration);
 
        CloudWatchClientConfiguration m_clientConfiguration;
        std::shared_ptr<CloudWatchEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace CloudWatch
} // namespace Aws