DevOpsGuruClient.h

 
#pragma once
#include <aws/devops-guru/DevOpsGuru_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/devops-guru/DevOpsGuruServiceClientModel.h>
 
namespace Aws
{
namespace DevOpsGuru
{
  class AWS_DEVOPSGURU_API DevOpsGuruClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<DevOpsGuruClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef DevOpsGuruClientConfiguration ClientConfigurationType;
      typedef DevOpsGuruEndpointProvider EndpointProviderType;
 
        DevOpsGuruClient(const Aws::DevOpsGuru::DevOpsGuruClientConfiguration& clientConfiguration = Aws::DevOpsGuru::DevOpsGuruClientConfiguration(),
                         std::shared_ptr<DevOpsGuruEndpointProviderBase> endpointProvider = nullptr);
 
        DevOpsGuruClient(const Aws::Auth::AWSCredentials& credentials,
                         std::shared_ptr<DevOpsGuruEndpointProviderBase> endpointProvider = nullptr,
                         const Aws::DevOpsGuru::DevOpsGuruClientConfiguration& clientConfiguration = Aws::DevOpsGuru::DevOpsGuruClientConfiguration());
 
        DevOpsGuruClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                         std::shared_ptr<DevOpsGuruEndpointProviderBase> endpointProvider = nullptr,
                         const Aws::DevOpsGuru::DevOpsGuruClientConfiguration& clientConfiguration = Aws::DevOpsGuru::DevOpsGuruClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        DevOpsGuruClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        DevOpsGuruClient(const Aws::Auth::AWSCredentials& credentials,
                         const Aws::Client::ClientConfiguration& clientConfiguration);
 
        DevOpsGuruClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                         const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~DevOpsGuruClient();
 
        virtual Model::AddNotificationChannelOutcome AddNotificationChannel(const Model::AddNotificationChannelRequest& request) const;
 
        template<typename AddNotificationChannelRequestT = Model::AddNotificationChannelRequest>
        Model::AddNotificationChannelOutcomeCallable AddNotificationChannelCallable(const AddNotificationChannelRequestT& request) const
        {
            return SubmitCallable(&DevOpsGuruClient::AddNotificationChannel, request);
        }
 
        template<typename AddNotificationChannelRequestT = Model::AddNotificationChannelRequest>
        void AddNotificationChannelAsync(const AddNotificationChannelRequestT& request, const AddNotificationChannelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DevOpsGuruClient::AddNotificationChannel, request, handler, context);
        }
 
        virtual Model::DeleteInsightOutcome DeleteInsight(const Model::DeleteInsightRequest& request) const;
 
        template<typename DeleteInsightRequestT = Model::DeleteInsightRequest>
        Model::DeleteInsightOutcomeCallable DeleteInsightCallable(const DeleteInsightRequestT& request) const
        {
            return SubmitCallable(&DevOpsGuruClient::DeleteInsight, request);
        }
 
        template<typename DeleteInsightRequestT = Model::DeleteInsightRequest>
        void DeleteInsightAsync(const DeleteInsightRequestT& request, const DeleteInsightResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DevOpsGuruClient::DeleteInsight, request, handler, context);
        }
 
        virtual Model::DescribeAccountHealthOutcome DescribeAccountHealth(const Model::DescribeAccountHealthRequest& request = {}) const;
 
        template<typename DescribeAccountHealthRequestT = Model::DescribeAccountHealthRequest>
        Model::DescribeAccountHealthOutcomeCallable DescribeAccountHealthCallable(const DescribeAccountHealthRequestT& request = {}) const
        {
            return SubmitCallable(&DevOpsGuruClient::DescribeAccountHealth, request);
        }
 
        template<typename DescribeAccountHealthRequestT = Model::DescribeAccountHealthRequest>
        void DescribeAccountHealthAsync(const DescribeAccountHealthResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeAccountHealthRequestT& request = {}) const
        {
            return SubmitAsync(&DevOpsGuruClient::DescribeAccountHealth, request, handler, context);
        }
 
        virtual Model::DescribeAccountOverviewOutcome DescribeAccountOverview(const Model::DescribeAccountOverviewRequest& request) const;
 
        template<typename DescribeAccountOverviewRequestT = Model::DescribeAccountOverviewRequest>
        Model::DescribeAccountOverviewOutcomeCallable DescribeAccountOverviewCallable(const DescribeAccountOverviewRequestT& request) const
        {
            return SubmitCallable(&DevOpsGuruClient::DescribeAccountOverview, request);
        }
 
        template<typename DescribeAccountOverviewRequestT = Model::DescribeAccountOverviewRequest>
        void DescribeAccountOverviewAsync(const DescribeAccountOverviewRequestT& request, const DescribeAccountOverviewResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DevOpsGuruClient::DescribeAccountOverview, request, handler, context);
        }
 
        virtual Model::DescribeAnomalyOutcome DescribeAnomaly(const Model::DescribeAnomalyRequest& request) const;
 
        template<typename DescribeAnomalyRequestT = Model::DescribeAnomalyRequest>
        Model::DescribeAnomalyOutcomeCallable DescribeAnomalyCallable(const DescribeAnomalyRequestT& request) const
        {
            return SubmitCallable(&DevOpsGuruClient::DescribeAnomaly, request);
        }
 
        template<typename DescribeAnomalyRequestT = Model::DescribeAnomalyRequest>
        void DescribeAnomalyAsync(const DescribeAnomalyRequestT& request, const DescribeAnomalyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DevOpsGuruClient::DescribeAnomaly, request, handler, context);
        }
 
        virtual Model::DescribeEventSourcesConfigOutcome DescribeEventSourcesConfig(const Model::DescribeEventSourcesConfigRequest& request = {}) const;
 
        template<typename DescribeEventSourcesConfigRequestT = Model::DescribeEventSourcesConfigRequest>
        Model::DescribeEventSourcesConfigOutcomeCallable DescribeEventSourcesConfigCallable(const DescribeEventSourcesConfigRequestT& request = {}) const
        {
            return SubmitCallable(&DevOpsGuruClient::DescribeEventSourcesConfig, request);
        }
 
        template<typename DescribeEventSourcesConfigRequestT = Model::DescribeEventSourcesConfigRequest>
        void DescribeEventSourcesConfigAsync(const DescribeEventSourcesConfigResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeEventSourcesConfigRequestT& request = {}) const
        {
            return SubmitAsync(&DevOpsGuruClient::DescribeEventSourcesConfig, request, handler, context);
        }
 
        virtual Model::DescribeFeedbackOutcome DescribeFeedback(const Model::DescribeFeedbackRequest& request = {}) const;
 
        template<typename DescribeFeedbackRequestT = Model::DescribeFeedbackRequest>
        Model::DescribeFeedbackOutcomeCallable DescribeFeedbackCallable(const DescribeFeedbackRequestT& request = {}) const
        {
            return SubmitCallable(&DevOpsGuruClient::DescribeFeedback, request);
        }
 
        template<typename DescribeFeedbackRequestT = Model::DescribeFeedbackRequest>
        void DescribeFeedbackAsync(const DescribeFeedbackResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeFeedbackRequestT& request = {}) const
        {
            return SubmitAsync(&DevOpsGuruClient::DescribeFeedback, request, handler, context);
        }
 
        virtual Model::DescribeInsightOutcome DescribeInsight(const Model::DescribeInsightRequest& request) const;
 
        template<typename DescribeInsightRequestT = Model::DescribeInsightRequest>
        Model::DescribeInsightOutcomeCallable DescribeInsightCallable(const DescribeInsightRequestT& request) const
        {
            return SubmitCallable(&DevOpsGuruClient::DescribeInsight, request);
        }
 
        template<typename DescribeInsightRequestT = Model::DescribeInsightRequest>
        void DescribeInsightAsync(const DescribeInsightRequestT& request, const DescribeInsightResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DevOpsGuruClient::DescribeInsight, request, handler, context);
        }
 
        virtual Model::DescribeOrganizationHealthOutcome DescribeOrganizationHealth(const Model::DescribeOrganizationHealthRequest& request = {}) const;
 
        template<typename DescribeOrganizationHealthRequestT = Model::DescribeOrganizationHealthRequest>
        Model::DescribeOrganizationHealthOutcomeCallable DescribeOrganizationHealthCallable(const DescribeOrganizationHealthRequestT& request = {}) const
        {
            return SubmitCallable(&DevOpsGuruClient::DescribeOrganizationHealth, request);
        }
 
        template<typename DescribeOrganizationHealthRequestT = Model::DescribeOrganizationHealthRequest>
        void DescribeOrganizationHealthAsync(const DescribeOrganizationHealthResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeOrganizationHealthRequestT& request = {}) const
        {
            return SubmitAsync(&DevOpsGuruClient::DescribeOrganizationHealth, request, handler, context);
        }
 
        virtual Model::DescribeOrganizationOverviewOutcome DescribeOrganizationOverview(const Model::DescribeOrganizationOverviewRequest& request) const;
 
        template<typename DescribeOrganizationOverviewRequestT = Model::DescribeOrganizationOverviewRequest>
        Model::DescribeOrganizationOverviewOutcomeCallable DescribeOrganizationOverviewCallable(const DescribeOrganizationOverviewRequestT& request) const
        {
            return SubmitCallable(&DevOpsGuruClient::DescribeOrganizationOverview, request);
        }
 
        template<typename DescribeOrganizationOverviewRequestT = Model::DescribeOrganizationOverviewRequest>
        void DescribeOrganizationOverviewAsync(const DescribeOrganizationOverviewRequestT& request, const DescribeOrganizationOverviewResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DevOpsGuruClient::DescribeOrganizationOverview, request, handler, context);
        }
 
        virtual Model::DescribeOrganizationResourceCollectionHealthOutcome DescribeOrganizationResourceCollectionHealth(const Model::DescribeOrganizationResourceCollectionHealthRequest& request) const;
 
        template<typename DescribeOrganizationResourceCollectionHealthRequestT = Model::DescribeOrganizationResourceCollectionHealthRequest>
        Model::DescribeOrganizationResourceCollectionHealthOutcomeCallable DescribeOrganizationResourceCollectionHealthCallable(const DescribeOrganizationResourceCollectionHealthRequestT& request) const
        {
            return SubmitCallable(&DevOpsGuruClient::DescribeOrganizationResourceCollectionHealth, request);
        }
 
        template<typename DescribeOrganizationResourceCollectionHealthRequestT = Model::DescribeOrganizationResourceCollectionHealthRequest>
        void DescribeOrganizationResourceCollectionHealthAsync(const DescribeOrganizationResourceCollectionHealthRequestT& request, const DescribeOrganizationResourceCollectionHealthResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DevOpsGuruClient::DescribeOrganizationResourceCollectionHealth, request, handler, context);
        }
 
        virtual Model::DescribeResourceCollectionHealthOutcome DescribeResourceCollectionHealth(const Model::DescribeResourceCollectionHealthRequest& request) const;
 
        template<typename DescribeResourceCollectionHealthRequestT = Model::DescribeResourceCollectionHealthRequest>
        Model::DescribeResourceCollectionHealthOutcomeCallable DescribeResourceCollectionHealthCallable(const DescribeResourceCollectionHealthRequestT& request) const
        {
            return SubmitCallable(&DevOpsGuruClient::DescribeResourceCollectionHealth, request);
        }
 
        template<typename DescribeResourceCollectionHealthRequestT = Model::DescribeResourceCollectionHealthRequest>
        void DescribeResourceCollectionHealthAsync(const DescribeResourceCollectionHealthRequestT& request, const DescribeResourceCollectionHealthResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DevOpsGuruClient::DescribeResourceCollectionHealth, request, handler, context);
        }
 
        virtual Model::DescribeServiceIntegrationOutcome DescribeServiceIntegration(const Model::DescribeServiceIntegrationRequest& request = {}) const;
 
        template<typename DescribeServiceIntegrationRequestT = Model::DescribeServiceIntegrationRequest>
        Model::DescribeServiceIntegrationOutcomeCallable DescribeServiceIntegrationCallable(const DescribeServiceIntegrationRequestT& request = {}) const
        {
            return SubmitCallable(&DevOpsGuruClient::DescribeServiceIntegration, request);
        }
 
        template<typename DescribeServiceIntegrationRequestT = Model::DescribeServiceIntegrationRequest>
        void DescribeServiceIntegrationAsync(const DescribeServiceIntegrationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeServiceIntegrationRequestT& request = {}) const
        {
            return SubmitAsync(&DevOpsGuruClient::DescribeServiceIntegration, request, handler, context);
        }
 
        virtual Model::GetCostEstimationOutcome GetCostEstimation(const Model::GetCostEstimationRequest& request = {}) const;
 
        template<typename GetCostEstimationRequestT = Model::GetCostEstimationRequest>
        Model::GetCostEstimationOutcomeCallable GetCostEstimationCallable(const GetCostEstimationRequestT& request = {}) const
        {
            return SubmitCallable(&DevOpsGuruClient::GetCostEstimation, request);
        }
 
        template<typename GetCostEstimationRequestT = Model::GetCostEstimationRequest>
        void GetCostEstimationAsync(const GetCostEstimationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetCostEstimationRequestT& request = {}) const
        {
            return SubmitAsync(&DevOpsGuruClient::GetCostEstimation, request, handler, context);
        }
 
        virtual Model::GetResourceCollectionOutcome GetResourceCollection(const Model::GetResourceCollectionRequest& request) const;
 
        template<typename GetResourceCollectionRequestT = Model::GetResourceCollectionRequest>
        Model::GetResourceCollectionOutcomeCallable GetResourceCollectionCallable(const GetResourceCollectionRequestT& request) const
        {
            return SubmitCallable(&DevOpsGuruClient::GetResourceCollection, request);
        }
 
        template<typename GetResourceCollectionRequestT = Model::GetResourceCollectionRequest>
        void GetResourceCollectionAsync(const GetResourceCollectionRequestT& request, const GetResourceCollectionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DevOpsGuruClient::GetResourceCollection, request, handler, context);
        }
 
        virtual Model::ListAnomaliesForInsightOutcome ListAnomaliesForInsight(const Model::ListAnomaliesForInsightRequest& request) const;
 
        template<typename ListAnomaliesForInsightRequestT = Model::ListAnomaliesForInsightRequest>
        Model::ListAnomaliesForInsightOutcomeCallable ListAnomaliesForInsightCallable(const ListAnomaliesForInsightRequestT& request) const
        {
            return SubmitCallable(&DevOpsGuruClient::ListAnomaliesForInsight, request);
        }
 
        template<typename ListAnomaliesForInsightRequestT = Model::ListAnomaliesForInsightRequest>
        void ListAnomaliesForInsightAsync(const ListAnomaliesForInsightRequestT& request, const ListAnomaliesForInsightResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DevOpsGuruClient::ListAnomaliesForInsight, request, handler, context);
        }
 
        virtual Model::ListAnomalousLogGroupsOutcome ListAnomalousLogGroups(const Model::ListAnomalousLogGroupsRequest& request) const;
 
        template<typename ListAnomalousLogGroupsRequestT = Model::ListAnomalousLogGroupsRequest>
        Model::ListAnomalousLogGroupsOutcomeCallable ListAnomalousLogGroupsCallable(const ListAnomalousLogGroupsRequestT& request) const
        {
            return SubmitCallable(&DevOpsGuruClient::ListAnomalousLogGroups, request);
        }
 
        template<typename ListAnomalousLogGroupsRequestT = Model::ListAnomalousLogGroupsRequest>
        void ListAnomalousLogGroupsAsync(const ListAnomalousLogGroupsRequestT& request, const ListAnomalousLogGroupsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DevOpsGuruClient::ListAnomalousLogGroups, request, handler, context);
        }
 
        virtual Model::ListEventsOutcome ListEvents(const Model::ListEventsRequest& request) const;
 
        template<typename ListEventsRequestT = Model::ListEventsRequest>
        Model::ListEventsOutcomeCallable ListEventsCallable(const ListEventsRequestT& request) const
        {
            return SubmitCallable(&DevOpsGuruClient::ListEvents, request);
        }
 
        template<typename ListEventsRequestT = Model::ListEventsRequest>
        void ListEventsAsync(const ListEventsRequestT& request, const ListEventsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DevOpsGuruClient::ListEvents, request, handler, context);
        }
 
        virtual Model::ListInsightsOutcome ListInsights(const Model::ListInsightsRequest& request) const;
 
        template<typename ListInsightsRequestT = Model::ListInsightsRequest>
        Model::ListInsightsOutcomeCallable ListInsightsCallable(const ListInsightsRequestT& request) const
        {
            return SubmitCallable(&DevOpsGuruClient::ListInsights, request);
        }
 
        template<typename ListInsightsRequestT = Model::ListInsightsRequest>
        void ListInsightsAsync(const ListInsightsRequestT& request, const ListInsightsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DevOpsGuruClient::ListInsights, request, handler, context);
        }
 
        virtual Model::ListMonitoredResourcesOutcome ListMonitoredResources(const Model::ListMonitoredResourcesRequest& request = {}) const;
 
        template<typename ListMonitoredResourcesRequestT = Model::ListMonitoredResourcesRequest>
        Model::ListMonitoredResourcesOutcomeCallable ListMonitoredResourcesCallable(const ListMonitoredResourcesRequestT& request = {}) const
        {
            return SubmitCallable(&DevOpsGuruClient::ListMonitoredResources, request);
        }
 
        template<typename ListMonitoredResourcesRequestT = Model::ListMonitoredResourcesRequest>
        void ListMonitoredResourcesAsync(const ListMonitoredResourcesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListMonitoredResourcesRequestT& request = {}) const
        {
            return SubmitAsync(&DevOpsGuruClient::ListMonitoredResources, request, handler, context);
        }
 
        virtual Model::ListNotificationChannelsOutcome ListNotificationChannels(const Model::ListNotificationChannelsRequest& request = {}) const;
 
        template<typename ListNotificationChannelsRequestT = Model::ListNotificationChannelsRequest>
        Model::ListNotificationChannelsOutcomeCallable ListNotificationChannelsCallable(const ListNotificationChannelsRequestT& request = {}) const
        {
            return SubmitCallable(&DevOpsGuruClient::ListNotificationChannels, request);
        }
 
        template<typename ListNotificationChannelsRequestT = Model::ListNotificationChannelsRequest>
        void ListNotificationChannelsAsync(const ListNotificationChannelsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListNotificationChannelsRequestT& request = {}) const
        {
            return SubmitAsync(&DevOpsGuruClient::ListNotificationChannels, request, handler, context);
        }
 
        virtual Model::ListOrganizationInsightsOutcome ListOrganizationInsights(const Model::ListOrganizationInsightsRequest& request) const;
 
        template<typename ListOrganizationInsightsRequestT = Model::ListOrganizationInsightsRequest>
        Model::ListOrganizationInsightsOutcomeCallable ListOrganizationInsightsCallable(const ListOrganizationInsightsRequestT& request) const
        {
            return SubmitCallable(&DevOpsGuruClient::ListOrganizationInsights, request);
        }
 
        template<typename ListOrganizationInsightsRequestT = Model::ListOrganizationInsightsRequest>
        void ListOrganizationInsightsAsync(const ListOrganizationInsightsRequestT& request, const ListOrganizationInsightsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DevOpsGuruClient::ListOrganizationInsights, request, handler, context);
        }
 
        virtual Model::ListRecommendationsOutcome ListRecommendations(const Model::ListRecommendationsRequest& request) const;
 
        template<typename ListRecommendationsRequestT = Model::ListRecommendationsRequest>
        Model::ListRecommendationsOutcomeCallable ListRecommendationsCallable(const ListRecommendationsRequestT& request) const
        {
            return SubmitCallable(&DevOpsGuruClient::ListRecommendations, request);
        }
 
        template<typename ListRecommendationsRequestT = Model::ListRecommendationsRequest>
        void ListRecommendationsAsync(const ListRecommendationsRequestT& request, const ListRecommendationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DevOpsGuruClient::ListRecommendations, 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(&DevOpsGuruClient::PutFeedback, request);
        }
 
        template<typename PutFeedbackRequestT = Model::PutFeedbackRequest>
        void PutFeedbackAsync(const PutFeedbackResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const PutFeedbackRequestT& request = {}) const
        {
            return SubmitAsync(&DevOpsGuruClient::PutFeedback, request, handler, context);
        }
 
        virtual Model::RemoveNotificationChannelOutcome RemoveNotificationChannel(const Model::RemoveNotificationChannelRequest& request) const;
 
        template<typename RemoveNotificationChannelRequestT = Model::RemoveNotificationChannelRequest>
        Model::RemoveNotificationChannelOutcomeCallable RemoveNotificationChannelCallable(const RemoveNotificationChannelRequestT& request) const
        {
            return SubmitCallable(&DevOpsGuruClient::RemoveNotificationChannel, request);
        }
 
        template<typename RemoveNotificationChannelRequestT = Model::RemoveNotificationChannelRequest>
        void RemoveNotificationChannelAsync(const RemoveNotificationChannelRequestT& request, const RemoveNotificationChannelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DevOpsGuruClient::RemoveNotificationChannel, request, handler, context);
        }
 
        virtual Model::SearchInsightsOutcome SearchInsights(const Model::SearchInsightsRequest& request) const;
 
        template<typename SearchInsightsRequestT = Model::SearchInsightsRequest>
        Model::SearchInsightsOutcomeCallable SearchInsightsCallable(const SearchInsightsRequestT& request) const
        {
            return SubmitCallable(&DevOpsGuruClient::SearchInsights, request);
        }
 
        template<typename SearchInsightsRequestT = Model::SearchInsightsRequest>
        void SearchInsightsAsync(const SearchInsightsRequestT& request, const SearchInsightsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DevOpsGuruClient::SearchInsights, request, handler, context);
        }
 
        virtual Model::SearchOrganizationInsightsOutcome SearchOrganizationInsights(const Model::SearchOrganizationInsightsRequest& request) const;
 
        template<typename SearchOrganizationInsightsRequestT = Model::SearchOrganizationInsightsRequest>
        Model::SearchOrganizationInsightsOutcomeCallable SearchOrganizationInsightsCallable(const SearchOrganizationInsightsRequestT& request) const
        {
            return SubmitCallable(&DevOpsGuruClient::SearchOrganizationInsights, request);
        }
 
        template<typename SearchOrganizationInsightsRequestT = Model::SearchOrganizationInsightsRequest>
        void SearchOrganizationInsightsAsync(const SearchOrganizationInsightsRequestT& request, const SearchOrganizationInsightsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DevOpsGuruClient::SearchOrganizationInsights, request, handler, context);
        }
 
        virtual Model::StartCostEstimationOutcome StartCostEstimation(const Model::StartCostEstimationRequest& request) const;
 
        template<typename StartCostEstimationRequestT = Model::StartCostEstimationRequest>
        Model::StartCostEstimationOutcomeCallable StartCostEstimationCallable(const StartCostEstimationRequestT& request) const
        {
            return SubmitCallable(&DevOpsGuruClient::StartCostEstimation, request);
        }
 
        template<typename StartCostEstimationRequestT = Model::StartCostEstimationRequest>
        void StartCostEstimationAsync(const StartCostEstimationRequestT& request, const StartCostEstimationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DevOpsGuruClient::StartCostEstimation, request, handler, context);
        }
 
        virtual Model::UpdateEventSourcesConfigOutcome UpdateEventSourcesConfig(const Model::UpdateEventSourcesConfigRequest& request = {}) const;
 
        template<typename UpdateEventSourcesConfigRequestT = Model::UpdateEventSourcesConfigRequest>
        Model::UpdateEventSourcesConfigOutcomeCallable UpdateEventSourcesConfigCallable(const UpdateEventSourcesConfigRequestT& request = {}) const
        {
            return SubmitCallable(&DevOpsGuruClient::UpdateEventSourcesConfig, request);
        }
 
        template<typename UpdateEventSourcesConfigRequestT = Model::UpdateEventSourcesConfigRequest>
        void UpdateEventSourcesConfigAsync(const UpdateEventSourcesConfigResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const UpdateEventSourcesConfigRequestT& request = {}) const
        {
            return SubmitAsync(&DevOpsGuruClient::UpdateEventSourcesConfig, request, handler, context);
        }
 
        virtual Model::UpdateResourceCollectionOutcome UpdateResourceCollection(const Model::UpdateResourceCollectionRequest& request) const;
 
        template<typename UpdateResourceCollectionRequestT = Model::UpdateResourceCollectionRequest>
        Model::UpdateResourceCollectionOutcomeCallable UpdateResourceCollectionCallable(const UpdateResourceCollectionRequestT& request) const
        {
            return SubmitCallable(&DevOpsGuruClient::UpdateResourceCollection, request);
        }
 
        template<typename UpdateResourceCollectionRequestT = Model::UpdateResourceCollectionRequest>
        void UpdateResourceCollectionAsync(const UpdateResourceCollectionRequestT& request, const UpdateResourceCollectionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DevOpsGuruClient::UpdateResourceCollection, request, handler, context);
        }
 
        virtual Model::UpdateServiceIntegrationOutcome UpdateServiceIntegration(const Model::UpdateServiceIntegrationRequest& request) const;
 
        template<typename UpdateServiceIntegrationRequestT = Model::UpdateServiceIntegrationRequest>
        Model::UpdateServiceIntegrationOutcomeCallable UpdateServiceIntegrationCallable(const UpdateServiceIntegrationRequestT& request) const
        {
            return SubmitCallable(&DevOpsGuruClient::UpdateServiceIntegration, request);
        }
 
        template<typename UpdateServiceIntegrationRequestT = Model::UpdateServiceIntegrationRequest>
        void UpdateServiceIntegrationAsync(const UpdateServiceIntegrationRequestT& request, const UpdateServiceIntegrationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DevOpsGuruClient::UpdateServiceIntegration, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<DevOpsGuruEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<DevOpsGuruClient>;
      void init(const DevOpsGuruClientConfiguration& clientConfiguration);
 
      DevOpsGuruClientConfiguration m_clientConfiguration;
      std::shared_ptr<DevOpsGuruEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace DevOpsGuru
} // namespace Aws