LookoutMetricsClient.h

 
#pragma once
#include <aws/lookoutmetrics/LookoutMetrics_EXPORTS.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/lookoutmetrics/LookoutMetricsServiceClientModel.h>
 
namespace Aws
{
namespace LookoutMetrics
{
  class AWS_LOOKOUTMETRICS_API LookoutMetricsClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<LookoutMetricsClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef LookoutMetricsClientConfiguration ClientConfigurationType;
      typedef LookoutMetricsEndpointProvider EndpointProviderType;
 
        LookoutMetricsClient(const Aws::LookoutMetrics::LookoutMetricsClientConfiguration& clientConfiguration = Aws::LookoutMetrics::LookoutMetricsClientConfiguration(),
                             std::shared_ptr<LookoutMetricsEndpointProviderBase> endpointProvider = nullptr);
 
        LookoutMetricsClient(const Aws::Auth::AWSCredentials& credentials,
                             std::shared_ptr<LookoutMetricsEndpointProviderBase> endpointProvider = nullptr,
                             const Aws::LookoutMetrics::LookoutMetricsClientConfiguration& clientConfiguration = Aws::LookoutMetrics::LookoutMetricsClientConfiguration());
 
        LookoutMetricsClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                             std::shared_ptr<LookoutMetricsEndpointProviderBase> endpointProvider = nullptr,
                             const Aws::LookoutMetrics::LookoutMetricsClientConfiguration& clientConfiguration = Aws::LookoutMetrics::LookoutMetricsClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        LookoutMetricsClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        LookoutMetricsClient(const Aws::Auth::AWSCredentials& credentials,
                             const Aws::Client::ClientConfiguration& clientConfiguration);
 
        LookoutMetricsClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                             const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~LookoutMetricsClient();
 
        virtual Model::ActivateAnomalyDetectorOutcome ActivateAnomalyDetector(const Model::ActivateAnomalyDetectorRequest& request) const;
 
        template<typename ActivateAnomalyDetectorRequestT = Model::ActivateAnomalyDetectorRequest>
        Model::ActivateAnomalyDetectorOutcomeCallable ActivateAnomalyDetectorCallable(const ActivateAnomalyDetectorRequestT& request) const
        {
            return SubmitCallable(&LookoutMetricsClient::ActivateAnomalyDetector, request);
        }
 
        template<typename ActivateAnomalyDetectorRequestT = Model::ActivateAnomalyDetectorRequest>
        void ActivateAnomalyDetectorAsync(const ActivateAnomalyDetectorRequestT& request, const ActivateAnomalyDetectorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LookoutMetricsClient::ActivateAnomalyDetector, request, handler, context);
        }
 
        virtual Model::BackTestAnomalyDetectorOutcome BackTestAnomalyDetector(const Model::BackTestAnomalyDetectorRequest& request) const;
 
        template<typename BackTestAnomalyDetectorRequestT = Model::BackTestAnomalyDetectorRequest>
        Model::BackTestAnomalyDetectorOutcomeCallable BackTestAnomalyDetectorCallable(const BackTestAnomalyDetectorRequestT& request) const
        {
            return SubmitCallable(&LookoutMetricsClient::BackTestAnomalyDetector, request);
        }
 
        template<typename BackTestAnomalyDetectorRequestT = Model::BackTestAnomalyDetectorRequest>
        void BackTestAnomalyDetectorAsync(const BackTestAnomalyDetectorRequestT& request, const BackTestAnomalyDetectorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LookoutMetricsClient::BackTestAnomalyDetector, request, handler, context);
        }
 
        virtual Model::CreateAlertOutcome CreateAlert(const Model::CreateAlertRequest& request) const;
 
        template<typename CreateAlertRequestT = Model::CreateAlertRequest>
        Model::CreateAlertOutcomeCallable CreateAlertCallable(const CreateAlertRequestT& request) const
        {
            return SubmitCallable(&LookoutMetricsClient::CreateAlert, request);
        }
 
        template<typename CreateAlertRequestT = Model::CreateAlertRequest>
        void CreateAlertAsync(const CreateAlertRequestT& request, const CreateAlertResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LookoutMetricsClient::CreateAlert, request, handler, context);
        }
 
        virtual Model::CreateAnomalyDetectorOutcome CreateAnomalyDetector(const Model::CreateAnomalyDetectorRequest& request) const;
 
        template<typename CreateAnomalyDetectorRequestT = Model::CreateAnomalyDetectorRequest>
        Model::CreateAnomalyDetectorOutcomeCallable CreateAnomalyDetectorCallable(const CreateAnomalyDetectorRequestT& request) const
        {
            return SubmitCallable(&LookoutMetricsClient::CreateAnomalyDetector, request);
        }
 
        template<typename CreateAnomalyDetectorRequestT = Model::CreateAnomalyDetectorRequest>
        void CreateAnomalyDetectorAsync(const CreateAnomalyDetectorRequestT& request, const CreateAnomalyDetectorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LookoutMetricsClient::CreateAnomalyDetector, request, handler, context);
        }
 
        virtual Model::CreateMetricSetOutcome CreateMetricSet(const Model::CreateMetricSetRequest& request) const;
 
        template<typename CreateMetricSetRequestT = Model::CreateMetricSetRequest>
        Model::CreateMetricSetOutcomeCallable CreateMetricSetCallable(const CreateMetricSetRequestT& request) const
        {
            return SubmitCallable(&LookoutMetricsClient::CreateMetricSet, request);
        }
 
        template<typename CreateMetricSetRequestT = Model::CreateMetricSetRequest>
        void CreateMetricSetAsync(const CreateMetricSetRequestT& request, const CreateMetricSetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LookoutMetricsClient::CreateMetricSet, request, handler, context);
        }
 
        virtual Model::DeactivateAnomalyDetectorOutcome DeactivateAnomalyDetector(const Model::DeactivateAnomalyDetectorRequest& request) const;
 
        template<typename DeactivateAnomalyDetectorRequestT = Model::DeactivateAnomalyDetectorRequest>
        Model::DeactivateAnomalyDetectorOutcomeCallable DeactivateAnomalyDetectorCallable(const DeactivateAnomalyDetectorRequestT& request) const
        {
            return SubmitCallable(&LookoutMetricsClient::DeactivateAnomalyDetector, request);
        }
 
        template<typename DeactivateAnomalyDetectorRequestT = Model::DeactivateAnomalyDetectorRequest>
        void DeactivateAnomalyDetectorAsync(const DeactivateAnomalyDetectorRequestT& request, const DeactivateAnomalyDetectorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LookoutMetricsClient::DeactivateAnomalyDetector, request, handler, context);
        }
 
        virtual Model::DeleteAlertOutcome DeleteAlert(const Model::DeleteAlertRequest& request) const;
 
        template<typename DeleteAlertRequestT = Model::DeleteAlertRequest>
        Model::DeleteAlertOutcomeCallable DeleteAlertCallable(const DeleteAlertRequestT& request) const
        {
            return SubmitCallable(&LookoutMetricsClient::DeleteAlert, request);
        }
 
        template<typename DeleteAlertRequestT = Model::DeleteAlertRequest>
        void DeleteAlertAsync(const DeleteAlertRequestT& request, const DeleteAlertResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LookoutMetricsClient::DeleteAlert, 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(&LookoutMetricsClient::DeleteAnomalyDetector, request);
        }
 
        template<typename DeleteAnomalyDetectorRequestT = Model::DeleteAnomalyDetectorRequest>
        void DeleteAnomalyDetectorAsync(const DeleteAnomalyDetectorRequestT& request, const DeleteAnomalyDetectorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LookoutMetricsClient::DeleteAnomalyDetector, request, handler, context);
        }
 
        virtual Model::DescribeAlertOutcome DescribeAlert(const Model::DescribeAlertRequest& request) const;
 
        template<typename DescribeAlertRequestT = Model::DescribeAlertRequest>
        Model::DescribeAlertOutcomeCallable DescribeAlertCallable(const DescribeAlertRequestT& request) const
        {
            return SubmitCallable(&LookoutMetricsClient::DescribeAlert, request);
        }
 
        template<typename DescribeAlertRequestT = Model::DescribeAlertRequest>
        void DescribeAlertAsync(const DescribeAlertRequestT& request, const DescribeAlertResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LookoutMetricsClient::DescribeAlert, request, handler, context);
        }
 
        virtual Model::DescribeAnomalyDetectionExecutionsOutcome DescribeAnomalyDetectionExecutions(const Model::DescribeAnomalyDetectionExecutionsRequest& request) const;
 
        template<typename DescribeAnomalyDetectionExecutionsRequestT = Model::DescribeAnomalyDetectionExecutionsRequest>
        Model::DescribeAnomalyDetectionExecutionsOutcomeCallable DescribeAnomalyDetectionExecutionsCallable(const DescribeAnomalyDetectionExecutionsRequestT& request) const
        {
            return SubmitCallable(&LookoutMetricsClient::DescribeAnomalyDetectionExecutions, request);
        }
 
        template<typename DescribeAnomalyDetectionExecutionsRequestT = Model::DescribeAnomalyDetectionExecutionsRequest>
        void DescribeAnomalyDetectionExecutionsAsync(const DescribeAnomalyDetectionExecutionsRequestT& request, const DescribeAnomalyDetectionExecutionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LookoutMetricsClient::DescribeAnomalyDetectionExecutions, request, handler, context);
        }
 
        virtual Model::DescribeAnomalyDetectorOutcome DescribeAnomalyDetector(const Model::DescribeAnomalyDetectorRequest& request) const;
 
        template<typename DescribeAnomalyDetectorRequestT = Model::DescribeAnomalyDetectorRequest>
        Model::DescribeAnomalyDetectorOutcomeCallable DescribeAnomalyDetectorCallable(const DescribeAnomalyDetectorRequestT& request) const
        {
            return SubmitCallable(&LookoutMetricsClient::DescribeAnomalyDetector, request);
        }
 
        template<typename DescribeAnomalyDetectorRequestT = Model::DescribeAnomalyDetectorRequest>
        void DescribeAnomalyDetectorAsync(const DescribeAnomalyDetectorRequestT& request, const DescribeAnomalyDetectorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LookoutMetricsClient::DescribeAnomalyDetector, request, handler, context);
        }
 
        virtual Model::DescribeMetricSetOutcome DescribeMetricSet(const Model::DescribeMetricSetRequest& request) const;
 
        template<typename DescribeMetricSetRequestT = Model::DescribeMetricSetRequest>
        Model::DescribeMetricSetOutcomeCallable DescribeMetricSetCallable(const DescribeMetricSetRequestT& request) const
        {
            return SubmitCallable(&LookoutMetricsClient::DescribeMetricSet, request);
        }
 
        template<typename DescribeMetricSetRequestT = Model::DescribeMetricSetRequest>
        void DescribeMetricSetAsync(const DescribeMetricSetRequestT& request, const DescribeMetricSetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LookoutMetricsClient::DescribeMetricSet, request, handler, context);
        }
 
        virtual Model::DetectMetricSetConfigOutcome DetectMetricSetConfig(const Model::DetectMetricSetConfigRequest& request) const;
 
        template<typename DetectMetricSetConfigRequestT = Model::DetectMetricSetConfigRequest>
        Model::DetectMetricSetConfigOutcomeCallable DetectMetricSetConfigCallable(const DetectMetricSetConfigRequestT& request) const
        {
            return SubmitCallable(&LookoutMetricsClient::DetectMetricSetConfig, request);
        }
 
        template<typename DetectMetricSetConfigRequestT = Model::DetectMetricSetConfigRequest>
        void DetectMetricSetConfigAsync(const DetectMetricSetConfigRequestT& request, const DetectMetricSetConfigResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LookoutMetricsClient::DetectMetricSetConfig, request, handler, context);
        }
 
        virtual Model::GetAnomalyGroupOutcome GetAnomalyGroup(const Model::GetAnomalyGroupRequest& request) const;
 
        template<typename GetAnomalyGroupRequestT = Model::GetAnomalyGroupRequest>
        Model::GetAnomalyGroupOutcomeCallable GetAnomalyGroupCallable(const GetAnomalyGroupRequestT& request) const
        {
            return SubmitCallable(&LookoutMetricsClient::GetAnomalyGroup, request);
        }
 
        template<typename GetAnomalyGroupRequestT = Model::GetAnomalyGroupRequest>
        void GetAnomalyGroupAsync(const GetAnomalyGroupRequestT& request, const GetAnomalyGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LookoutMetricsClient::GetAnomalyGroup, request, handler, context);
        }
 
        virtual Model::GetDataQualityMetricsOutcome GetDataQualityMetrics(const Model::GetDataQualityMetricsRequest& request) const;
 
        template<typename GetDataQualityMetricsRequestT = Model::GetDataQualityMetricsRequest>
        Model::GetDataQualityMetricsOutcomeCallable GetDataQualityMetricsCallable(const GetDataQualityMetricsRequestT& request) const
        {
            return SubmitCallable(&LookoutMetricsClient::GetDataQualityMetrics, request);
        }
 
        template<typename GetDataQualityMetricsRequestT = Model::GetDataQualityMetricsRequest>
        void GetDataQualityMetricsAsync(const GetDataQualityMetricsRequestT& request, const GetDataQualityMetricsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LookoutMetricsClient::GetDataQualityMetrics, request, handler, context);
        }
 
        virtual Model::GetFeedbackOutcome GetFeedback(const Model::GetFeedbackRequest& request) const;
 
        template<typename GetFeedbackRequestT = Model::GetFeedbackRequest>
        Model::GetFeedbackOutcomeCallable GetFeedbackCallable(const GetFeedbackRequestT& request) const
        {
            return SubmitCallable(&LookoutMetricsClient::GetFeedback, request);
        }
 
        template<typename GetFeedbackRequestT = Model::GetFeedbackRequest>
        void GetFeedbackAsync(const GetFeedbackRequestT& request, const GetFeedbackResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LookoutMetricsClient::GetFeedback, request, handler, context);
        }
 
        virtual Model::GetSampleDataOutcome GetSampleData(const Model::GetSampleDataRequest& request = {}) const;
 
        template<typename GetSampleDataRequestT = Model::GetSampleDataRequest>
        Model::GetSampleDataOutcomeCallable GetSampleDataCallable(const GetSampleDataRequestT& request = {}) const
        {
            return SubmitCallable(&LookoutMetricsClient::GetSampleData, request);
        }
 
        template<typename GetSampleDataRequestT = Model::GetSampleDataRequest>
        void GetSampleDataAsync(const GetSampleDataResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetSampleDataRequestT& request = {}) const
        {
            return SubmitAsync(&LookoutMetricsClient::GetSampleData, request, handler, context);
        }
 
        virtual Model::ListAlertsOutcome ListAlerts(const Model::ListAlertsRequest& request = {}) const;
 
        template<typename ListAlertsRequestT = Model::ListAlertsRequest>
        Model::ListAlertsOutcomeCallable ListAlertsCallable(const ListAlertsRequestT& request = {}) const
        {
            return SubmitCallable(&LookoutMetricsClient::ListAlerts, request);
        }
 
        template<typename ListAlertsRequestT = Model::ListAlertsRequest>
        void ListAlertsAsync(const ListAlertsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListAlertsRequestT& request = {}) const
        {
            return SubmitAsync(&LookoutMetricsClient::ListAlerts, request, handler, context);
        }
 
        virtual Model::ListAnomalyDetectorsOutcome ListAnomalyDetectors(const Model::ListAnomalyDetectorsRequest& request = {}) const;
 
        template<typename ListAnomalyDetectorsRequestT = Model::ListAnomalyDetectorsRequest>
        Model::ListAnomalyDetectorsOutcomeCallable ListAnomalyDetectorsCallable(const ListAnomalyDetectorsRequestT& request = {}) const
        {
            return SubmitCallable(&LookoutMetricsClient::ListAnomalyDetectors, request);
        }
 
        template<typename ListAnomalyDetectorsRequestT = Model::ListAnomalyDetectorsRequest>
        void ListAnomalyDetectorsAsync(const ListAnomalyDetectorsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListAnomalyDetectorsRequestT& request = {}) const
        {
            return SubmitAsync(&LookoutMetricsClient::ListAnomalyDetectors, request, handler, context);
        }
 
        virtual Model::ListAnomalyGroupRelatedMetricsOutcome ListAnomalyGroupRelatedMetrics(const Model::ListAnomalyGroupRelatedMetricsRequest& request) const;
 
        template<typename ListAnomalyGroupRelatedMetricsRequestT = Model::ListAnomalyGroupRelatedMetricsRequest>
        Model::ListAnomalyGroupRelatedMetricsOutcomeCallable ListAnomalyGroupRelatedMetricsCallable(const ListAnomalyGroupRelatedMetricsRequestT& request) const
        {
            return SubmitCallable(&LookoutMetricsClient::ListAnomalyGroupRelatedMetrics, request);
        }
 
        template<typename ListAnomalyGroupRelatedMetricsRequestT = Model::ListAnomalyGroupRelatedMetricsRequest>
        void ListAnomalyGroupRelatedMetricsAsync(const ListAnomalyGroupRelatedMetricsRequestT& request, const ListAnomalyGroupRelatedMetricsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LookoutMetricsClient::ListAnomalyGroupRelatedMetrics, request, handler, context);
        }
 
        virtual Model::ListAnomalyGroupSummariesOutcome ListAnomalyGroupSummaries(const Model::ListAnomalyGroupSummariesRequest& request) const;
 
        template<typename ListAnomalyGroupSummariesRequestT = Model::ListAnomalyGroupSummariesRequest>
        Model::ListAnomalyGroupSummariesOutcomeCallable ListAnomalyGroupSummariesCallable(const ListAnomalyGroupSummariesRequestT& request) const
        {
            return SubmitCallable(&LookoutMetricsClient::ListAnomalyGroupSummaries, request);
        }
 
        template<typename ListAnomalyGroupSummariesRequestT = Model::ListAnomalyGroupSummariesRequest>
        void ListAnomalyGroupSummariesAsync(const ListAnomalyGroupSummariesRequestT& request, const ListAnomalyGroupSummariesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LookoutMetricsClient::ListAnomalyGroupSummaries, request, handler, context);
        }
 
        virtual Model::ListAnomalyGroupTimeSeriesOutcome ListAnomalyGroupTimeSeries(const Model::ListAnomalyGroupTimeSeriesRequest& request) const;
 
        template<typename ListAnomalyGroupTimeSeriesRequestT = Model::ListAnomalyGroupTimeSeriesRequest>
        Model::ListAnomalyGroupTimeSeriesOutcomeCallable ListAnomalyGroupTimeSeriesCallable(const ListAnomalyGroupTimeSeriesRequestT& request) const
        {
            return SubmitCallable(&LookoutMetricsClient::ListAnomalyGroupTimeSeries, request);
        }
 
        template<typename ListAnomalyGroupTimeSeriesRequestT = Model::ListAnomalyGroupTimeSeriesRequest>
        void ListAnomalyGroupTimeSeriesAsync(const ListAnomalyGroupTimeSeriesRequestT& request, const ListAnomalyGroupTimeSeriesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LookoutMetricsClient::ListAnomalyGroupTimeSeries, request, handler, context);
        }
 
        virtual Model::ListMetricSetsOutcome ListMetricSets(const Model::ListMetricSetsRequest& request = {}) const;
 
        template<typename ListMetricSetsRequestT = Model::ListMetricSetsRequest>
        Model::ListMetricSetsOutcomeCallable ListMetricSetsCallable(const ListMetricSetsRequestT& request = {}) const
        {
            return SubmitCallable(&LookoutMetricsClient::ListMetricSets, request);
        }
 
        template<typename ListMetricSetsRequestT = Model::ListMetricSetsRequest>
        void ListMetricSetsAsync(const ListMetricSetsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListMetricSetsRequestT& request = {}) const
        {
            return SubmitAsync(&LookoutMetricsClient::ListMetricSets, 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(&LookoutMetricsClient::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(&LookoutMetricsClient::ListTagsForResource, request, handler, context);
        }
 
        virtual Model::PutFeedbackOutcome PutFeedback(const Model::PutFeedbackRequest& request) const;
 
        template<typename PutFeedbackRequestT = Model::PutFeedbackRequest>
        Model::PutFeedbackOutcomeCallable PutFeedbackCallable(const PutFeedbackRequestT& request) const
        {
            return SubmitCallable(&LookoutMetricsClient::PutFeedback, request);
        }
 
        template<typename PutFeedbackRequestT = Model::PutFeedbackRequest>
        void PutFeedbackAsync(const PutFeedbackRequestT& request, const PutFeedbackResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LookoutMetricsClient::PutFeedback, 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(&LookoutMetricsClient::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(&LookoutMetricsClient::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(&LookoutMetricsClient::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(&LookoutMetricsClient::UntagResource, request, handler, context);
        }
 
        virtual Model::UpdateAlertOutcome UpdateAlert(const Model::UpdateAlertRequest& request) const;
 
        template<typename UpdateAlertRequestT = Model::UpdateAlertRequest>
        Model::UpdateAlertOutcomeCallable UpdateAlertCallable(const UpdateAlertRequestT& request) const
        {
            return SubmitCallable(&LookoutMetricsClient::UpdateAlert, request);
        }
 
        template<typename UpdateAlertRequestT = Model::UpdateAlertRequest>
        void UpdateAlertAsync(const UpdateAlertRequestT& request, const UpdateAlertResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LookoutMetricsClient::UpdateAlert, request, handler, context);
        }
 
        virtual Model::UpdateAnomalyDetectorOutcome UpdateAnomalyDetector(const Model::UpdateAnomalyDetectorRequest& request) const;
 
        template<typename UpdateAnomalyDetectorRequestT = Model::UpdateAnomalyDetectorRequest>
        Model::UpdateAnomalyDetectorOutcomeCallable UpdateAnomalyDetectorCallable(const UpdateAnomalyDetectorRequestT& request) const
        {
            return SubmitCallable(&LookoutMetricsClient::UpdateAnomalyDetector, request);
        }
 
        template<typename UpdateAnomalyDetectorRequestT = Model::UpdateAnomalyDetectorRequest>
        void UpdateAnomalyDetectorAsync(const UpdateAnomalyDetectorRequestT& request, const UpdateAnomalyDetectorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LookoutMetricsClient::UpdateAnomalyDetector, request, handler, context);
        }
 
        virtual Model::UpdateMetricSetOutcome UpdateMetricSet(const Model::UpdateMetricSetRequest& request) const;
 
        template<typename UpdateMetricSetRequestT = Model::UpdateMetricSetRequest>
        Model::UpdateMetricSetOutcomeCallable UpdateMetricSetCallable(const UpdateMetricSetRequestT& request) const
        {
            return SubmitCallable(&LookoutMetricsClient::UpdateMetricSet, request);
        }
 
        template<typename UpdateMetricSetRequestT = Model::UpdateMetricSetRequest>
        void UpdateMetricSetAsync(const UpdateMetricSetRequestT& request, const UpdateMetricSetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LookoutMetricsClient::UpdateMetricSet, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<LookoutMetricsEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<LookoutMetricsClient>;
      void init(const LookoutMetricsClientConfiguration& clientConfiguration);
 
      LookoutMetricsClientConfiguration m_clientConfiguration;
      std::shared_ptr<LookoutMetricsEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace LookoutMetrics
} // namespace Aws