ApplicationSignalsClient.h

 
#pragma once
#include <aws/application-signals/ApplicationSignals_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-signals/ApplicationSignalsServiceClientModel.h>
 
namespace Aws
{
namespace ApplicationSignals
{
  class AWS_APPLICATIONSIGNALS_API ApplicationSignalsClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<ApplicationSignalsClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef ApplicationSignalsClientConfiguration ClientConfigurationType;
      typedef ApplicationSignalsEndpointProvider EndpointProviderType;
 
        ApplicationSignalsClient(const Aws::ApplicationSignals::ApplicationSignalsClientConfiguration& clientConfiguration = Aws::ApplicationSignals::ApplicationSignalsClientConfiguration(),
                                 std::shared_ptr<ApplicationSignalsEndpointProviderBase> endpointProvider = nullptr);
 
        ApplicationSignalsClient(const Aws::Auth::AWSCredentials& credentials,
                                 std::shared_ptr<ApplicationSignalsEndpointProviderBase> endpointProvider = nullptr,
                                 const Aws::ApplicationSignals::ApplicationSignalsClientConfiguration& clientConfiguration = Aws::ApplicationSignals::ApplicationSignalsClientConfiguration());
 
        ApplicationSignalsClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                                 std::shared_ptr<ApplicationSignalsEndpointProviderBase> endpointProvider = nullptr,
                                 const Aws::ApplicationSignals::ApplicationSignalsClientConfiguration& clientConfiguration = Aws::ApplicationSignals::ApplicationSignalsClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        ApplicationSignalsClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        ApplicationSignalsClient(const Aws::Auth::AWSCredentials& credentials,
                                 const Aws::Client::ClientConfiguration& clientConfiguration);
 
        ApplicationSignalsClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                                 const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~ApplicationSignalsClient();
 
        virtual Model::BatchGetServiceLevelObjectiveBudgetReportOutcome BatchGetServiceLevelObjectiveBudgetReport(const Model::BatchGetServiceLevelObjectiveBudgetReportRequest& request) const;
 
        template<typename BatchGetServiceLevelObjectiveBudgetReportRequestT = Model::BatchGetServiceLevelObjectiveBudgetReportRequest>
        Model::BatchGetServiceLevelObjectiveBudgetReportOutcomeCallable BatchGetServiceLevelObjectiveBudgetReportCallable(const BatchGetServiceLevelObjectiveBudgetReportRequestT& request) const
        {
            return SubmitCallable(&ApplicationSignalsClient::BatchGetServiceLevelObjectiveBudgetReport, request);
        }
 
        template<typename BatchGetServiceLevelObjectiveBudgetReportRequestT = Model::BatchGetServiceLevelObjectiveBudgetReportRequest>
        void BatchGetServiceLevelObjectiveBudgetReportAsync(const BatchGetServiceLevelObjectiveBudgetReportRequestT& request, const BatchGetServiceLevelObjectiveBudgetReportResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ApplicationSignalsClient::BatchGetServiceLevelObjectiveBudgetReport, request, handler, context);
        }
 
        virtual Model::BatchUpdateExclusionWindowsOutcome BatchUpdateExclusionWindows(const Model::BatchUpdateExclusionWindowsRequest& request) const;
 
        template<typename BatchUpdateExclusionWindowsRequestT = Model::BatchUpdateExclusionWindowsRequest>
        Model::BatchUpdateExclusionWindowsOutcomeCallable BatchUpdateExclusionWindowsCallable(const BatchUpdateExclusionWindowsRequestT& request) const
        {
            return SubmitCallable(&ApplicationSignalsClient::BatchUpdateExclusionWindows, request);
        }
 
        template<typename BatchUpdateExclusionWindowsRequestT = Model::BatchUpdateExclusionWindowsRequest>
        void BatchUpdateExclusionWindowsAsync(const BatchUpdateExclusionWindowsRequestT& request, const BatchUpdateExclusionWindowsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ApplicationSignalsClient::BatchUpdateExclusionWindows, request, handler, context);
        }
 
        virtual Model::CreateServiceLevelObjectiveOutcome CreateServiceLevelObjective(const Model::CreateServiceLevelObjectiveRequest& request) const;
 
        template<typename CreateServiceLevelObjectiveRequestT = Model::CreateServiceLevelObjectiveRequest>
        Model::CreateServiceLevelObjectiveOutcomeCallable CreateServiceLevelObjectiveCallable(const CreateServiceLevelObjectiveRequestT& request) const
        {
            return SubmitCallable(&ApplicationSignalsClient::CreateServiceLevelObjective, request);
        }
 
        template<typename CreateServiceLevelObjectiveRequestT = Model::CreateServiceLevelObjectiveRequest>
        void CreateServiceLevelObjectiveAsync(const CreateServiceLevelObjectiveRequestT& request, const CreateServiceLevelObjectiveResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ApplicationSignalsClient::CreateServiceLevelObjective, request, handler, context);
        }
 
        virtual Model::DeleteServiceLevelObjectiveOutcome DeleteServiceLevelObjective(const Model::DeleteServiceLevelObjectiveRequest& request) const;
 
        template<typename DeleteServiceLevelObjectiveRequestT = Model::DeleteServiceLevelObjectiveRequest>
        Model::DeleteServiceLevelObjectiveOutcomeCallable DeleteServiceLevelObjectiveCallable(const DeleteServiceLevelObjectiveRequestT& request) const
        {
            return SubmitCallable(&ApplicationSignalsClient::DeleteServiceLevelObjective, request);
        }
 
        template<typename DeleteServiceLevelObjectiveRequestT = Model::DeleteServiceLevelObjectiveRequest>
        void DeleteServiceLevelObjectiveAsync(const DeleteServiceLevelObjectiveRequestT& request, const DeleteServiceLevelObjectiveResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ApplicationSignalsClient::DeleteServiceLevelObjective, request, handler, context);
        }
 
        virtual Model::GetServiceOutcome GetService(const Model::GetServiceRequest& request) const;
 
        template<typename GetServiceRequestT = Model::GetServiceRequest>
        Model::GetServiceOutcomeCallable GetServiceCallable(const GetServiceRequestT& request) const
        {
            return SubmitCallable(&ApplicationSignalsClient::GetService, request);
        }
 
        template<typename GetServiceRequestT = Model::GetServiceRequest>
        void GetServiceAsync(const GetServiceRequestT& request, const GetServiceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ApplicationSignalsClient::GetService, request, handler, context);
        }
 
        virtual Model::GetServiceLevelObjectiveOutcome GetServiceLevelObjective(const Model::GetServiceLevelObjectiveRequest& request) const;
 
        template<typename GetServiceLevelObjectiveRequestT = Model::GetServiceLevelObjectiveRequest>
        Model::GetServiceLevelObjectiveOutcomeCallable GetServiceLevelObjectiveCallable(const GetServiceLevelObjectiveRequestT& request) const
        {
            return SubmitCallable(&ApplicationSignalsClient::GetServiceLevelObjective, request);
        }
 
        template<typename GetServiceLevelObjectiveRequestT = Model::GetServiceLevelObjectiveRequest>
        void GetServiceLevelObjectiveAsync(const GetServiceLevelObjectiveRequestT& request, const GetServiceLevelObjectiveResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ApplicationSignalsClient::GetServiceLevelObjective, request, handler, context);
        }
 
        virtual Model::ListServiceDependenciesOutcome ListServiceDependencies(const Model::ListServiceDependenciesRequest& request) const;
 
        template<typename ListServiceDependenciesRequestT = Model::ListServiceDependenciesRequest>
        Model::ListServiceDependenciesOutcomeCallable ListServiceDependenciesCallable(const ListServiceDependenciesRequestT& request) const
        {
            return SubmitCallable(&ApplicationSignalsClient::ListServiceDependencies, request);
        }
 
        template<typename ListServiceDependenciesRequestT = Model::ListServiceDependenciesRequest>
        void ListServiceDependenciesAsync(const ListServiceDependenciesRequestT& request, const ListServiceDependenciesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ApplicationSignalsClient::ListServiceDependencies, request, handler, context);
        }
 
        virtual Model::ListServiceDependentsOutcome ListServiceDependents(const Model::ListServiceDependentsRequest& request) const;
 
        template<typename ListServiceDependentsRequestT = Model::ListServiceDependentsRequest>
        Model::ListServiceDependentsOutcomeCallable ListServiceDependentsCallable(const ListServiceDependentsRequestT& request) const
        {
            return SubmitCallable(&ApplicationSignalsClient::ListServiceDependents, request);
        }
 
        template<typename ListServiceDependentsRequestT = Model::ListServiceDependentsRequest>
        void ListServiceDependentsAsync(const ListServiceDependentsRequestT& request, const ListServiceDependentsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ApplicationSignalsClient::ListServiceDependents, request, handler, context);
        }
 
        virtual Model::ListServiceLevelObjectiveExclusionWindowsOutcome ListServiceLevelObjectiveExclusionWindows(const Model::ListServiceLevelObjectiveExclusionWindowsRequest& request) const;
 
        template<typename ListServiceLevelObjectiveExclusionWindowsRequestT = Model::ListServiceLevelObjectiveExclusionWindowsRequest>
        Model::ListServiceLevelObjectiveExclusionWindowsOutcomeCallable ListServiceLevelObjectiveExclusionWindowsCallable(const ListServiceLevelObjectiveExclusionWindowsRequestT& request) const
        {
            return SubmitCallable(&ApplicationSignalsClient::ListServiceLevelObjectiveExclusionWindows, request);
        }
 
        template<typename ListServiceLevelObjectiveExclusionWindowsRequestT = Model::ListServiceLevelObjectiveExclusionWindowsRequest>
        void ListServiceLevelObjectiveExclusionWindowsAsync(const ListServiceLevelObjectiveExclusionWindowsRequestT& request, const ListServiceLevelObjectiveExclusionWindowsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ApplicationSignalsClient::ListServiceLevelObjectiveExclusionWindows, request, handler, context);
        }
 
        virtual Model::ListServiceLevelObjectivesOutcome ListServiceLevelObjectives(const Model::ListServiceLevelObjectivesRequest& request = {}) const;
 
        template<typename ListServiceLevelObjectivesRequestT = Model::ListServiceLevelObjectivesRequest>
        Model::ListServiceLevelObjectivesOutcomeCallable ListServiceLevelObjectivesCallable(const ListServiceLevelObjectivesRequestT& request = {}) const
        {
            return SubmitCallable(&ApplicationSignalsClient::ListServiceLevelObjectives, request);
        }
 
        template<typename ListServiceLevelObjectivesRequestT = Model::ListServiceLevelObjectivesRequest>
        void ListServiceLevelObjectivesAsync(const ListServiceLevelObjectivesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListServiceLevelObjectivesRequestT& request = {}) const
        {
            return SubmitAsync(&ApplicationSignalsClient::ListServiceLevelObjectives, request, handler, context);
        }
 
        virtual Model::ListServiceOperationsOutcome ListServiceOperations(const Model::ListServiceOperationsRequest& request) const;
 
        template<typename ListServiceOperationsRequestT = Model::ListServiceOperationsRequest>
        Model::ListServiceOperationsOutcomeCallable ListServiceOperationsCallable(const ListServiceOperationsRequestT& request) const
        {
            return SubmitCallable(&ApplicationSignalsClient::ListServiceOperations, request);
        }
 
        template<typename ListServiceOperationsRequestT = Model::ListServiceOperationsRequest>
        void ListServiceOperationsAsync(const ListServiceOperationsRequestT& request, const ListServiceOperationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ApplicationSignalsClient::ListServiceOperations, request, handler, context);
        }
 
        virtual Model::ListServicesOutcome ListServices(const Model::ListServicesRequest& request) const;
 
        template<typename ListServicesRequestT = Model::ListServicesRequest>
        Model::ListServicesOutcomeCallable ListServicesCallable(const ListServicesRequestT& request) const
        {
            return SubmitCallable(&ApplicationSignalsClient::ListServices, request);
        }
 
        template<typename ListServicesRequestT = Model::ListServicesRequest>
        void ListServicesAsync(const ListServicesRequestT& request, const ListServicesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ApplicationSignalsClient::ListServices, 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(&ApplicationSignalsClient::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(&ApplicationSignalsClient::ListTagsForResource, request, handler, context);
        }
 
        virtual Model::StartDiscoveryOutcome StartDiscovery(const Model::StartDiscoveryRequest& request = {}) const;
 
        template<typename StartDiscoveryRequestT = Model::StartDiscoveryRequest>
        Model::StartDiscoveryOutcomeCallable StartDiscoveryCallable(const StartDiscoveryRequestT& request = {}) const
        {
            return SubmitCallable(&ApplicationSignalsClient::StartDiscovery, request);
        }
 
        template<typename StartDiscoveryRequestT = Model::StartDiscoveryRequest>
        void StartDiscoveryAsync(const StartDiscoveryResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const StartDiscoveryRequestT& request = {}) const
        {
            return SubmitAsync(&ApplicationSignalsClient::StartDiscovery, 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(&ApplicationSignalsClient::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(&ApplicationSignalsClient::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(&ApplicationSignalsClient::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(&ApplicationSignalsClient::UntagResource, request, handler, context);
        }
 
        virtual Model::UpdateServiceLevelObjectiveOutcome UpdateServiceLevelObjective(const Model::UpdateServiceLevelObjectiveRequest& request) const;
 
        template<typename UpdateServiceLevelObjectiveRequestT = Model::UpdateServiceLevelObjectiveRequest>
        Model::UpdateServiceLevelObjectiveOutcomeCallable UpdateServiceLevelObjectiveCallable(const UpdateServiceLevelObjectiveRequestT& request) const
        {
            return SubmitCallable(&ApplicationSignalsClient::UpdateServiceLevelObjective, request);
        }
 
        template<typename UpdateServiceLevelObjectiveRequestT = Model::UpdateServiceLevelObjectiveRequest>
        void UpdateServiceLevelObjectiveAsync(const UpdateServiceLevelObjectiveRequestT& request, const UpdateServiceLevelObjectiveResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ApplicationSignalsClient::UpdateServiceLevelObjective, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<ApplicationSignalsEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<ApplicationSignalsClient>;
      void init(const ApplicationSignalsClientConfiguration& clientConfiguration);
 
      ApplicationSignalsClientConfiguration m_clientConfiguration;
      std::shared_ptr<ApplicationSignalsEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace ApplicationSignals
} // namespace Aws