ApplicationInsightsClient.h

 
#pragma once
#include <aws/application-insights/ApplicationInsights_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/application-insights/ApplicationInsightsServiceClientModel.h>
 
namespace Aws
{
namespace ApplicationInsights
{
  class AWS_APPLICATIONINSIGHTS_API ApplicationInsightsClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<ApplicationInsightsClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef ApplicationInsightsClientConfiguration ClientConfigurationType;
      typedef ApplicationInsightsEndpointProvider EndpointProviderType;
 
        ApplicationInsightsClient(const Aws::ApplicationInsights::ApplicationInsightsClientConfiguration& clientConfiguration = Aws::ApplicationInsights::ApplicationInsightsClientConfiguration(),
                                  std::shared_ptr<ApplicationInsightsEndpointProviderBase> endpointProvider = nullptr);
 
        ApplicationInsightsClient(const Aws::Auth::AWSCredentials& credentials,
                                  std::shared_ptr<ApplicationInsightsEndpointProviderBase> endpointProvider = nullptr,
                                  const Aws::ApplicationInsights::ApplicationInsightsClientConfiguration& clientConfiguration = Aws::ApplicationInsights::ApplicationInsightsClientConfiguration());
 
        ApplicationInsightsClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                                  std::shared_ptr<ApplicationInsightsEndpointProviderBase> endpointProvider = nullptr,
                                  const Aws::ApplicationInsights::ApplicationInsightsClientConfiguration& clientConfiguration = Aws::ApplicationInsights::ApplicationInsightsClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        ApplicationInsightsClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        ApplicationInsightsClient(const Aws::Auth::AWSCredentials& credentials,
                                  const Aws::Client::ClientConfiguration& clientConfiguration);
 
        ApplicationInsightsClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                                  const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~ApplicationInsightsClient();
 
        virtual Model::AddWorkloadOutcome AddWorkload(const Model::AddWorkloadRequest& request) const;
 
        template<typename AddWorkloadRequestT = Model::AddWorkloadRequest>
        Model::AddWorkloadOutcomeCallable AddWorkloadCallable(const AddWorkloadRequestT& request) const
        {
            return SubmitCallable(&ApplicationInsightsClient::AddWorkload, request);
        }
 
        template<typename AddWorkloadRequestT = Model::AddWorkloadRequest>
        void AddWorkloadAsync(const AddWorkloadRequestT& request, const AddWorkloadResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ApplicationInsightsClient::AddWorkload, request, handler, context);
        }
 
        virtual Model::CreateApplicationOutcome CreateApplication(const Model::CreateApplicationRequest& request = {}) const;
 
        template<typename CreateApplicationRequestT = Model::CreateApplicationRequest>
        Model::CreateApplicationOutcomeCallable CreateApplicationCallable(const CreateApplicationRequestT& request = {}) const
        {
            return SubmitCallable(&ApplicationInsightsClient::CreateApplication, request);
        }
 
        template<typename CreateApplicationRequestT = Model::CreateApplicationRequest>
        void CreateApplicationAsync(const CreateApplicationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const CreateApplicationRequestT& request = {}) const
        {
            return SubmitAsync(&ApplicationInsightsClient::CreateApplication, request, handler, context);
        }
 
        virtual Model::CreateComponentOutcome CreateComponent(const Model::CreateComponentRequest& request) const;
 
        template<typename CreateComponentRequestT = Model::CreateComponentRequest>
        Model::CreateComponentOutcomeCallable CreateComponentCallable(const CreateComponentRequestT& request) const
        {
            return SubmitCallable(&ApplicationInsightsClient::CreateComponent, request);
        }
 
        template<typename CreateComponentRequestT = Model::CreateComponentRequest>
        void CreateComponentAsync(const CreateComponentRequestT& request, const CreateComponentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ApplicationInsightsClient::CreateComponent, request, handler, context);
        }
 
        virtual Model::CreateLogPatternOutcome CreateLogPattern(const Model::CreateLogPatternRequest& request) const;
 
        template<typename CreateLogPatternRequestT = Model::CreateLogPatternRequest>
        Model::CreateLogPatternOutcomeCallable CreateLogPatternCallable(const CreateLogPatternRequestT& request) const
        {
            return SubmitCallable(&ApplicationInsightsClient::CreateLogPattern, request);
        }
 
        template<typename CreateLogPatternRequestT = Model::CreateLogPatternRequest>
        void CreateLogPatternAsync(const CreateLogPatternRequestT& request, const CreateLogPatternResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ApplicationInsightsClient::CreateLogPattern, request, handler, context);
        }
 
        virtual Model::DeleteApplicationOutcome DeleteApplication(const Model::DeleteApplicationRequest& request) const;
 
        template<typename DeleteApplicationRequestT = Model::DeleteApplicationRequest>
        Model::DeleteApplicationOutcomeCallable DeleteApplicationCallable(const DeleteApplicationRequestT& request) const
        {
            return SubmitCallable(&ApplicationInsightsClient::DeleteApplication, request);
        }
 
        template<typename DeleteApplicationRequestT = Model::DeleteApplicationRequest>
        void DeleteApplicationAsync(const DeleteApplicationRequestT& request, const DeleteApplicationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ApplicationInsightsClient::DeleteApplication, request, handler, context);
        }
 
        virtual Model::DeleteComponentOutcome DeleteComponent(const Model::DeleteComponentRequest& request) const;
 
        template<typename DeleteComponentRequestT = Model::DeleteComponentRequest>
        Model::DeleteComponentOutcomeCallable DeleteComponentCallable(const DeleteComponentRequestT& request) const
        {
            return SubmitCallable(&ApplicationInsightsClient::DeleteComponent, request);
        }
 
        template<typename DeleteComponentRequestT = Model::DeleteComponentRequest>
        void DeleteComponentAsync(const DeleteComponentRequestT& request, const DeleteComponentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ApplicationInsightsClient::DeleteComponent, request, handler, context);
        }
 
        virtual Model::DeleteLogPatternOutcome DeleteLogPattern(const Model::DeleteLogPatternRequest& request) const;
 
        template<typename DeleteLogPatternRequestT = Model::DeleteLogPatternRequest>
        Model::DeleteLogPatternOutcomeCallable DeleteLogPatternCallable(const DeleteLogPatternRequestT& request) const
        {
            return SubmitCallable(&ApplicationInsightsClient::DeleteLogPattern, request);
        }
 
        template<typename DeleteLogPatternRequestT = Model::DeleteLogPatternRequest>
        void DeleteLogPatternAsync(const DeleteLogPatternRequestT& request, const DeleteLogPatternResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ApplicationInsightsClient::DeleteLogPattern, request, handler, context);
        }
 
        virtual Model::DescribeApplicationOutcome DescribeApplication(const Model::DescribeApplicationRequest& request) const;
 
        template<typename DescribeApplicationRequestT = Model::DescribeApplicationRequest>
        Model::DescribeApplicationOutcomeCallable DescribeApplicationCallable(const DescribeApplicationRequestT& request) const
        {
            return SubmitCallable(&ApplicationInsightsClient::DescribeApplication, request);
        }
 
        template<typename DescribeApplicationRequestT = Model::DescribeApplicationRequest>
        void DescribeApplicationAsync(const DescribeApplicationRequestT& request, const DescribeApplicationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ApplicationInsightsClient::DescribeApplication, request, handler, context);
        }
 
        virtual Model::DescribeComponentOutcome DescribeComponent(const Model::DescribeComponentRequest& request) const;
 
        template<typename DescribeComponentRequestT = Model::DescribeComponentRequest>
        Model::DescribeComponentOutcomeCallable DescribeComponentCallable(const DescribeComponentRequestT& request) const
        {
            return SubmitCallable(&ApplicationInsightsClient::DescribeComponent, request);
        }
 
        template<typename DescribeComponentRequestT = Model::DescribeComponentRequest>
        void DescribeComponentAsync(const DescribeComponentRequestT& request, const DescribeComponentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ApplicationInsightsClient::DescribeComponent, request, handler, context);
        }
 
        virtual Model::DescribeComponentConfigurationOutcome DescribeComponentConfiguration(const Model::DescribeComponentConfigurationRequest& request) const;
 
        template<typename DescribeComponentConfigurationRequestT = Model::DescribeComponentConfigurationRequest>
        Model::DescribeComponentConfigurationOutcomeCallable DescribeComponentConfigurationCallable(const DescribeComponentConfigurationRequestT& request) const
        {
            return SubmitCallable(&ApplicationInsightsClient::DescribeComponentConfiguration, request);
        }
 
        template<typename DescribeComponentConfigurationRequestT = Model::DescribeComponentConfigurationRequest>
        void DescribeComponentConfigurationAsync(const DescribeComponentConfigurationRequestT& request, const DescribeComponentConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ApplicationInsightsClient::DescribeComponentConfiguration, request, handler, context);
        }
 
        virtual Model::DescribeComponentConfigurationRecommendationOutcome DescribeComponentConfigurationRecommendation(const Model::DescribeComponentConfigurationRecommendationRequest& request) const;
 
        template<typename DescribeComponentConfigurationRecommendationRequestT = Model::DescribeComponentConfigurationRecommendationRequest>
        Model::DescribeComponentConfigurationRecommendationOutcomeCallable DescribeComponentConfigurationRecommendationCallable(const DescribeComponentConfigurationRecommendationRequestT& request) const
        {
            return SubmitCallable(&ApplicationInsightsClient::DescribeComponentConfigurationRecommendation, request);
        }
 
        template<typename DescribeComponentConfigurationRecommendationRequestT = Model::DescribeComponentConfigurationRecommendationRequest>
        void DescribeComponentConfigurationRecommendationAsync(const DescribeComponentConfigurationRecommendationRequestT& request, const DescribeComponentConfigurationRecommendationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ApplicationInsightsClient::DescribeComponentConfigurationRecommendation, request, handler, context);
        }
 
        virtual Model::DescribeLogPatternOutcome DescribeLogPattern(const Model::DescribeLogPatternRequest& request) const;
 
        template<typename DescribeLogPatternRequestT = Model::DescribeLogPatternRequest>
        Model::DescribeLogPatternOutcomeCallable DescribeLogPatternCallable(const DescribeLogPatternRequestT& request) const
        {
            return SubmitCallable(&ApplicationInsightsClient::DescribeLogPattern, request);
        }
 
        template<typename DescribeLogPatternRequestT = Model::DescribeLogPatternRequest>
        void DescribeLogPatternAsync(const DescribeLogPatternRequestT& request, const DescribeLogPatternResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ApplicationInsightsClient::DescribeLogPattern, request, handler, context);
        }
 
        virtual Model::DescribeObservationOutcome DescribeObservation(const Model::DescribeObservationRequest& request) const;
 
        template<typename DescribeObservationRequestT = Model::DescribeObservationRequest>
        Model::DescribeObservationOutcomeCallable DescribeObservationCallable(const DescribeObservationRequestT& request) const
        {
            return SubmitCallable(&ApplicationInsightsClient::DescribeObservation, request);
        }
 
        template<typename DescribeObservationRequestT = Model::DescribeObservationRequest>
        void DescribeObservationAsync(const DescribeObservationRequestT& request, const DescribeObservationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ApplicationInsightsClient::DescribeObservation, request, handler, context);
        }
 
        virtual Model::DescribeProblemOutcome DescribeProblem(const Model::DescribeProblemRequest& request) const;
 
        template<typename DescribeProblemRequestT = Model::DescribeProblemRequest>
        Model::DescribeProblemOutcomeCallable DescribeProblemCallable(const DescribeProblemRequestT& request) const
        {
            return SubmitCallable(&ApplicationInsightsClient::DescribeProblem, request);
        }
 
        template<typename DescribeProblemRequestT = Model::DescribeProblemRequest>
        void DescribeProblemAsync(const DescribeProblemRequestT& request, const DescribeProblemResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ApplicationInsightsClient::DescribeProblem, request, handler, context);
        }
 
        virtual Model::DescribeProblemObservationsOutcome DescribeProblemObservations(const Model::DescribeProblemObservationsRequest& request) const;
 
        template<typename DescribeProblemObservationsRequestT = Model::DescribeProblemObservationsRequest>
        Model::DescribeProblemObservationsOutcomeCallable DescribeProblemObservationsCallable(const DescribeProblemObservationsRequestT& request) const
        {
            return SubmitCallable(&ApplicationInsightsClient::DescribeProblemObservations, request);
        }
 
        template<typename DescribeProblemObservationsRequestT = Model::DescribeProblemObservationsRequest>
        void DescribeProblemObservationsAsync(const DescribeProblemObservationsRequestT& request, const DescribeProblemObservationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ApplicationInsightsClient::DescribeProblemObservations, request, handler, context);
        }
 
        virtual Model::DescribeWorkloadOutcome DescribeWorkload(const Model::DescribeWorkloadRequest& request) const;
 
        template<typename DescribeWorkloadRequestT = Model::DescribeWorkloadRequest>
        Model::DescribeWorkloadOutcomeCallable DescribeWorkloadCallable(const DescribeWorkloadRequestT& request) const
        {
            return SubmitCallable(&ApplicationInsightsClient::DescribeWorkload, request);
        }
 
        template<typename DescribeWorkloadRequestT = Model::DescribeWorkloadRequest>
        void DescribeWorkloadAsync(const DescribeWorkloadRequestT& request, const DescribeWorkloadResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ApplicationInsightsClient::DescribeWorkload, request, handler, context);
        }
 
        virtual Model::ListApplicationsOutcome ListApplications(const Model::ListApplicationsRequest& request = {}) const;
 
        template<typename ListApplicationsRequestT = Model::ListApplicationsRequest>
        Model::ListApplicationsOutcomeCallable ListApplicationsCallable(const ListApplicationsRequestT& request = {}) const
        {
            return SubmitCallable(&ApplicationInsightsClient::ListApplications, request);
        }
 
        template<typename ListApplicationsRequestT = Model::ListApplicationsRequest>
        void ListApplicationsAsync(const ListApplicationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListApplicationsRequestT& request = {}) const
        {
            return SubmitAsync(&ApplicationInsightsClient::ListApplications, request, handler, context);
        }
 
        virtual Model::ListComponentsOutcome ListComponents(const Model::ListComponentsRequest& request) const;
 
        template<typename ListComponentsRequestT = Model::ListComponentsRequest>
        Model::ListComponentsOutcomeCallable ListComponentsCallable(const ListComponentsRequestT& request) const
        {
            return SubmitCallable(&ApplicationInsightsClient::ListComponents, request);
        }
 
        template<typename ListComponentsRequestT = Model::ListComponentsRequest>
        void ListComponentsAsync(const ListComponentsRequestT& request, const ListComponentsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ApplicationInsightsClient::ListComponents, request, handler, context);
        }
 
        virtual Model::ListConfigurationHistoryOutcome ListConfigurationHistory(const Model::ListConfigurationHistoryRequest& request = {}) const;
 
        template<typename ListConfigurationHistoryRequestT = Model::ListConfigurationHistoryRequest>
        Model::ListConfigurationHistoryOutcomeCallable ListConfigurationHistoryCallable(const ListConfigurationHistoryRequestT& request = {}) const
        {
            return SubmitCallable(&ApplicationInsightsClient::ListConfigurationHistory, request);
        }
 
        template<typename ListConfigurationHistoryRequestT = Model::ListConfigurationHistoryRequest>
        void ListConfigurationHistoryAsync(const ListConfigurationHistoryResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListConfigurationHistoryRequestT& request = {}) const
        {
            return SubmitAsync(&ApplicationInsightsClient::ListConfigurationHistory, request, handler, context);
        }
 
        virtual Model::ListLogPatternSetsOutcome ListLogPatternSets(const Model::ListLogPatternSetsRequest& request) const;
 
        template<typename ListLogPatternSetsRequestT = Model::ListLogPatternSetsRequest>
        Model::ListLogPatternSetsOutcomeCallable ListLogPatternSetsCallable(const ListLogPatternSetsRequestT& request) const
        {
            return SubmitCallable(&ApplicationInsightsClient::ListLogPatternSets, request);
        }
 
        template<typename ListLogPatternSetsRequestT = Model::ListLogPatternSetsRequest>
        void ListLogPatternSetsAsync(const ListLogPatternSetsRequestT& request, const ListLogPatternSetsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ApplicationInsightsClient::ListLogPatternSets, request, handler, context);
        }
 
        virtual Model::ListLogPatternsOutcome ListLogPatterns(const Model::ListLogPatternsRequest& request) const;
 
        template<typename ListLogPatternsRequestT = Model::ListLogPatternsRequest>
        Model::ListLogPatternsOutcomeCallable ListLogPatternsCallable(const ListLogPatternsRequestT& request) const
        {
            return SubmitCallable(&ApplicationInsightsClient::ListLogPatterns, request);
        }
 
        template<typename ListLogPatternsRequestT = Model::ListLogPatternsRequest>
        void ListLogPatternsAsync(const ListLogPatternsRequestT& request, const ListLogPatternsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ApplicationInsightsClient::ListLogPatterns, request, handler, context);
        }
 
        virtual Model::ListProblemsOutcome ListProblems(const Model::ListProblemsRequest& request = {}) const;
 
        template<typename ListProblemsRequestT = Model::ListProblemsRequest>
        Model::ListProblemsOutcomeCallable ListProblemsCallable(const ListProblemsRequestT& request = {}) const
        {
            return SubmitCallable(&ApplicationInsightsClient::ListProblems, request);
        }
 
        template<typename ListProblemsRequestT = Model::ListProblemsRequest>
        void ListProblemsAsync(const ListProblemsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListProblemsRequestT& request = {}) const
        {
            return SubmitAsync(&ApplicationInsightsClient::ListProblems, 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(&ApplicationInsightsClient::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(&ApplicationInsightsClient::ListTagsForResource, request, handler, context);
        }
 
        virtual Model::ListWorkloadsOutcome ListWorkloads(const Model::ListWorkloadsRequest& request) const;
 
        template<typename ListWorkloadsRequestT = Model::ListWorkloadsRequest>
        Model::ListWorkloadsOutcomeCallable ListWorkloadsCallable(const ListWorkloadsRequestT& request) const
        {
            return SubmitCallable(&ApplicationInsightsClient::ListWorkloads, request);
        }
 
        template<typename ListWorkloadsRequestT = Model::ListWorkloadsRequest>
        void ListWorkloadsAsync(const ListWorkloadsRequestT& request, const ListWorkloadsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ApplicationInsightsClient::ListWorkloads, request, handler, context);
        }
 
        virtual Model::RemoveWorkloadOutcome RemoveWorkload(const Model::RemoveWorkloadRequest& request) const;
 
        template<typename RemoveWorkloadRequestT = Model::RemoveWorkloadRequest>
        Model::RemoveWorkloadOutcomeCallable RemoveWorkloadCallable(const RemoveWorkloadRequestT& request) const
        {
            return SubmitCallable(&ApplicationInsightsClient::RemoveWorkload, request);
        }
 
        template<typename RemoveWorkloadRequestT = Model::RemoveWorkloadRequest>
        void RemoveWorkloadAsync(const RemoveWorkloadRequestT& request, const RemoveWorkloadResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ApplicationInsightsClient::RemoveWorkload, 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(&ApplicationInsightsClient::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(&ApplicationInsightsClient::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(&ApplicationInsightsClient::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(&ApplicationInsightsClient::UntagResource, request, handler, context);
        }
 
        virtual Model::UpdateApplicationOutcome UpdateApplication(const Model::UpdateApplicationRequest& request) const;
 
        template<typename UpdateApplicationRequestT = Model::UpdateApplicationRequest>
        Model::UpdateApplicationOutcomeCallable UpdateApplicationCallable(const UpdateApplicationRequestT& request) const
        {
            return SubmitCallable(&ApplicationInsightsClient::UpdateApplication, request);
        }
 
        template<typename UpdateApplicationRequestT = Model::UpdateApplicationRequest>
        void UpdateApplicationAsync(const UpdateApplicationRequestT& request, const UpdateApplicationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ApplicationInsightsClient::UpdateApplication, request, handler, context);
        }
 
        virtual Model::UpdateComponentOutcome UpdateComponent(const Model::UpdateComponentRequest& request) const;
 
        template<typename UpdateComponentRequestT = Model::UpdateComponentRequest>
        Model::UpdateComponentOutcomeCallable UpdateComponentCallable(const UpdateComponentRequestT& request) const
        {
            return SubmitCallable(&ApplicationInsightsClient::UpdateComponent, request);
        }
 
        template<typename UpdateComponentRequestT = Model::UpdateComponentRequest>
        void UpdateComponentAsync(const UpdateComponentRequestT& request, const UpdateComponentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ApplicationInsightsClient::UpdateComponent, request, handler, context);
        }
 
        virtual Model::UpdateComponentConfigurationOutcome UpdateComponentConfiguration(const Model::UpdateComponentConfigurationRequest& request) const;
 
        template<typename UpdateComponentConfigurationRequestT = Model::UpdateComponentConfigurationRequest>
        Model::UpdateComponentConfigurationOutcomeCallable UpdateComponentConfigurationCallable(const UpdateComponentConfigurationRequestT& request) const
        {
            return SubmitCallable(&ApplicationInsightsClient::UpdateComponentConfiguration, request);
        }
 
        template<typename UpdateComponentConfigurationRequestT = Model::UpdateComponentConfigurationRequest>
        void UpdateComponentConfigurationAsync(const UpdateComponentConfigurationRequestT& request, const UpdateComponentConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ApplicationInsightsClient::UpdateComponentConfiguration, request, handler, context);
        }
 
        virtual Model::UpdateLogPatternOutcome UpdateLogPattern(const Model::UpdateLogPatternRequest& request) const;
 
        template<typename UpdateLogPatternRequestT = Model::UpdateLogPatternRequest>
        Model::UpdateLogPatternOutcomeCallable UpdateLogPatternCallable(const UpdateLogPatternRequestT& request) const
        {
            return SubmitCallable(&ApplicationInsightsClient::UpdateLogPattern, request);
        }
 
        template<typename UpdateLogPatternRequestT = Model::UpdateLogPatternRequest>
        void UpdateLogPatternAsync(const UpdateLogPatternRequestT& request, const UpdateLogPatternResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ApplicationInsightsClient::UpdateLogPattern, request, handler, context);
        }
 
        virtual Model::UpdateProblemOutcome UpdateProblem(const Model::UpdateProblemRequest& request) const;
 
        template<typename UpdateProblemRequestT = Model::UpdateProblemRequest>
        Model::UpdateProblemOutcomeCallable UpdateProblemCallable(const UpdateProblemRequestT& request) const
        {
            return SubmitCallable(&ApplicationInsightsClient::UpdateProblem, request);
        }
 
        template<typename UpdateProblemRequestT = Model::UpdateProblemRequest>
        void UpdateProblemAsync(const UpdateProblemRequestT& request, const UpdateProblemResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ApplicationInsightsClient::UpdateProblem, request, handler, context);
        }
 
        virtual Model::UpdateWorkloadOutcome UpdateWorkload(const Model::UpdateWorkloadRequest& request) const;
 
        template<typename UpdateWorkloadRequestT = Model::UpdateWorkloadRequest>
        Model::UpdateWorkloadOutcomeCallable UpdateWorkloadCallable(const UpdateWorkloadRequestT& request) const
        {
            return SubmitCallable(&ApplicationInsightsClient::UpdateWorkload, request);
        }
 
        template<typename UpdateWorkloadRequestT = Model::UpdateWorkloadRequest>
        void UpdateWorkloadAsync(const UpdateWorkloadRequestT& request, const UpdateWorkloadResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ApplicationInsightsClient::UpdateWorkload, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<ApplicationInsightsEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<ApplicationInsightsClient>;
      void init(const ApplicationInsightsClientConfiguration& clientConfiguration);
 
      ApplicationInsightsClientConfiguration m_clientConfiguration;
      std::shared_ptr<ApplicationInsightsEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace ApplicationInsights
} // namespace Aws