InternetMonitorClient.h

 
#pragma once
#include <aws/internetmonitor/InternetMonitor_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/internetmonitor/InternetMonitorServiceClientModel.h>
 
namespace Aws
{
namespace InternetMonitor
{
  class AWS_INTERNETMONITOR_API InternetMonitorClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<InternetMonitorClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef InternetMonitorClientConfiguration ClientConfigurationType;
      typedef InternetMonitorEndpointProvider EndpointProviderType;
 
        InternetMonitorClient(const Aws::InternetMonitor::InternetMonitorClientConfiguration& clientConfiguration = Aws::InternetMonitor::InternetMonitorClientConfiguration(),
                              std::shared_ptr<InternetMonitorEndpointProviderBase> endpointProvider = nullptr);
 
        InternetMonitorClient(const Aws::Auth::AWSCredentials& credentials,
                              std::shared_ptr<InternetMonitorEndpointProviderBase> endpointProvider = nullptr,
                              const Aws::InternetMonitor::InternetMonitorClientConfiguration& clientConfiguration = Aws::InternetMonitor::InternetMonitorClientConfiguration());
 
        InternetMonitorClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                              std::shared_ptr<InternetMonitorEndpointProviderBase> endpointProvider = nullptr,
                              const Aws::InternetMonitor::InternetMonitorClientConfiguration& clientConfiguration = Aws::InternetMonitor::InternetMonitorClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        InternetMonitorClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        InternetMonitorClient(const Aws::Auth::AWSCredentials& credentials,
                              const Aws::Client::ClientConfiguration& clientConfiguration);
 
        InternetMonitorClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                              const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~InternetMonitorClient();
 
        virtual Model::CreateMonitorOutcome CreateMonitor(const Model::CreateMonitorRequest& request) const;
 
        template<typename CreateMonitorRequestT = Model::CreateMonitorRequest>
        Model::CreateMonitorOutcomeCallable CreateMonitorCallable(const CreateMonitorRequestT& request) const
        {
            return SubmitCallable(&InternetMonitorClient::CreateMonitor, request);
        }
 
        template<typename CreateMonitorRequestT = Model::CreateMonitorRequest>
        void CreateMonitorAsync(const CreateMonitorRequestT& request, const CreateMonitorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&InternetMonitorClient::CreateMonitor, request, handler, context);
        }
 
        virtual Model::DeleteMonitorOutcome DeleteMonitor(const Model::DeleteMonitorRequest& request) const;
 
        template<typename DeleteMonitorRequestT = Model::DeleteMonitorRequest>
        Model::DeleteMonitorOutcomeCallable DeleteMonitorCallable(const DeleteMonitorRequestT& request) const
        {
            return SubmitCallable(&InternetMonitorClient::DeleteMonitor, request);
        }
 
        template<typename DeleteMonitorRequestT = Model::DeleteMonitorRequest>
        void DeleteMonitorAsync(const DeleteMonitorRequestT& request, const DeleteMonitorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&InternetMonitorClient::DeleteMonitor, request, handler, context);
        }
 
        virtual Model::GetHealthEventOutcome GetHealthEvent(const Model::GetHealthEventRequest& request) const;
 
        template<typename GetHealthEventRequestT = Model::GetHealthEventRequest>
        Model::GetHealthEventOutcomeCallable GetHealthEventCallable(const GetHealthEventRequestT& request) const
        {
            return SubmitCallable(&InternetMonitorClient::GetHealthEvent, request);
        }
 
        template<typename GetHealthEventRequestT = Model::GetHealthEventRequest>
        void GetHealthEventAsync(const GetHealthEventRequestT& request, const GetHealthEventResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&InternetMonitorClient::GetHealthEvent, request, handler, context);
        }
 
        virtual Model::GetInternetEventOutcome GetInternetEvent(const Model::GetInternetEventRequest& request) const;
 
        template<typename GetInternetEventRequestT = Model::GetInternetEventRequest>
        Model::GetInternetEventOutcomeCallable GetInternetEventCallable(const GetInternetEventRequestT& request) const
        {
            return SubmitCallable(&InternetMonitorClient::GetInternetEvent, request);
        }
 
        template<typename GetInternetEventRequestT = Model::GetInternetEventRequest>
        void GetInternetEventAsync(const GetInternetEventRequestT& request, const GetInternetEventResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&InternetMonitorClient::GetInternetEvent, request, handler, context);
        }
 
        virtual Model::GetMonitorOutcome GetMonitor(const Model::GetMonitorRequest& request) const;
 
        template<typename GetMonitorRequestT = Model::GetMonitorRequest>
        Model::GetMonitorOutcomeCallable GetMonitorCallable(const GetMonitorRequestT& request) const
        {
            return SubmitCallable(&InternetMonitorClient::GetMonitor, request);
        }
 
        template<typename GetMonitorRequestT = Model::GetMonitorRequest>
        void GetMonitorAsync(const GetMonitorRequestT& request, const GetMonitorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&InternetMonitorClient::GetMonitor, request, handler, context);
        }
 
        virtual Model::GetQueryResultsOutcome GetQueryResults(const Model::GetQueryResultsRequest& request) const;
 
        template<typename GetQueryResultsRequestT = Model::GetQueryResultsRequest>
        Model::GetQueryResultsOutcomeCallable GetQueryResultsCallable(const GetQueryResultsRequestT& request) const
        {
            return SubmitCallable(&InternetMonitorClient::GetQueryResults, request);
        }
 
        template<typename GetQueryResultsRequestT = Model::GetQueryResultsRequest>
        void GetQueryResultsAsync(const GetQueryResultsRequestT& request, const GetQueryResultsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&InternetMonitorClient::GetQueryResults, request, handler, context);
        }
 
        virtual Model::GetQueryStatusOutcome GetQueryStatus(const Model::GetQueryStatusRequest& request) const;
 
        template<typename GetQueryStatusRequestT = Model::GetQueryStatusRequest>
        Model::GetQueryStatusOutcomeCallable GetQueryStatusCallable(const GetQueryStatusRequestT& request) const
        {
            return SubmitCallable(&InternetMonitorClient::GetQueryStatus, request);
        }
 
        template<typename GetQueryStatusRequestT = Model::GetQueryStatusRequest>
        void GetQueryStatusAsync(const GetQueryStatusRequestT& request, const GetQueryStatusResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&InternetMonitorClient::GetQueryStatus, request, handler, context);
        }
 
        virtual Model::ListHealthEventsOutcome ListHealthEvents(const Model::ListHealthEventsRequest& request) const;
 
        template<typename ListHealthEventsRequestT = Model::ListHealthEventsRequest>
        Model::ListHealthEventsOutcomeCallable ListHealthEventsCallable(const ListHealthEventsRequestT& request) const
        {
            return SubmitCallable(&InternetMonitorClient::ListHealthEvents, request);
        }
 
        template<typename ListHealthEventsRequestT = Model::ListHealthEventsRequest>
        void ListHealthEventsAsync(const ListHealthEventsRequestT& request, const ListHealthEventsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&InternetMonitorClient::ListHealthEvents, request, handler, context);
        }
 
        virtual Model::ListInternetEventsOutcome ListInternetEvents(const Model::ListInternetEventsRequest& request = {}) const;
 
        template<typename ListInternetEventsRequestT = Model::ListInternetEventsRequest>
        Model::ListInternetEventsOutcomeCallable ListInternetEventsCallable(const ListInternetEventsRequestT& request = {}) const
        {
            return SubmitCallable(&InternetMonitorClient::ListInternetEvents, request);
        }
 
        template<typename ListInternetEventsRequestT = Model::ListInternetEventsRequest>
        void ListInternetEventsAsync(const ListInternetEventsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListInternetEventsRequestT& request = {}) const
        {
            return SubmitAsync(&InternetMonitorClient::ListInternetEvents, request, handler, context);
        }
 
        virtual Model::ListMonitorsOutcome ListMonitors(const Model::ListMonitorsRequest& request = {}) const;
 
        template<typename ListMonitorsRequestT = Model::ListMonitorsRequest>
        Model::ListMonitorsOutcomeCallable ListMonitorsCallable(const ListMonitorsRequestT& request = {}) const
        {
            return SubmitCallable(&InternetMonitorClient::ListMonitors, request);
        }
 
        template<typename ListMonitorsRequestT = Model::ListMonitorsRequest>
        void ListMonitorsAsync(const ListMonitorsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListMonitorsRequestT& request = {}) const
        {
            return SubmitAsync(&InternetMonitorClient::ListMonitors, 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(&InternetMonitorClient::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(&InternetMonitorClient::ListTagsForResource, request, handler, context);
        }
 
        virtual Model::StartQueryOutcome StartQuery(const Model::StartQueryRequest& request) const;
 
        template<typename StartQueryRequestT = Model::StartQueryRequest>
        Model::StartQueryOutcomeCallable StartQueryCallable(const StartQueryRequestT& request) const
        {
            return SubmitCallable(&InternetMonitorClient::StartQuery, request);
        }
 
        template<typename StartQueryRequestT = Model::StartQueryRequest>
        void StartQueryAsync(const StartQueryRequestT& request, const StartQueryResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&InternetMonitorClient::StartQuery, request, handler, context);
        }
 
        virtual Model::StopQueryOutcome StopQuery(const Model::StopQueryRequest& request) const;
 
        template<typename StopQueryRequestT = Model::StopQueryRequest>
        Model::StopQueryOutcomeCallable StopQueryCallable(const StopQueryRequestT& request) const
        {
            return SubmitCallable(&InternetMonitorClient::StopQuery, request);
        }
 
        template<typename StopQueryRequestT = Model::StopQueryRequest>
        void StopQueryAsync(const StopQueryRequestT& request, const StopQueryResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&InternetMonitorClient::StopQuery, 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(&InternetMonitorClient::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(&InternetMonitorClient::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(&InternetMonitorClient::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(&InternetMonitorClient::UntagResource, request, handler, context);
        }
 
        virtual Model::UpdateMonitorOutcome UpdateMonitor(const Model::UpdateMonitorRequest& request) const;
 
        template<typename UpdateMonitorRequestT = Model::UpdateMonitorRequest>
        Model::UpdateMonitorOutcomeCallable UpdateMonitorCallable(const UpdateMonitorRequestT& request) const
        {
            return SubmitCallable(&InternetMonitorClient::UpdateMonitor, request);
        }
 
        template<typename UpdateMonitorRequestT = Model::UpdateMonitorRequest>
        void UpdateMonitorAsync(const UpdateMonitorRequestT& request, const UpdateMonitorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&InternetMonitorClient::UpdateMonitor, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<InternetMonitorEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<InternetMonitorClient>;
      void init(const InternetMonitorClientConfiguration& clientConfiguration);
 
      InternetMonitorClientConfiguration m_clientConfiguration;
      std::shared_ptr<InternetMonitorEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace InternetMonitor
} // namespace Aws