HealthClient.h

 
#pragma once
#include <aws/health/Health_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/health/HealthServiceClientModel.h>
 
namespace Aws
{
namespace Health
{
  class AWS_HEALTH_API HealthClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<HealthClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef HealthClientConfiguration ClientConfigurationType;
      typedef HealthEndpointProvider EndpointProviderType;
 
        HealthClient(const Aws::Health::HealthClientConfiguration& clientConfiguration = Aws::Health::HealthClientConfiguration(),
                     std::shared_ptr<HealthEndpointProviderBase> endpointProvider = nullptr);
 
        HealthClient(const Aws::Auth::AWSCredentials& credentials,
                     std::shared_ptr<HealthEndpointProviderBase> endpointProvider = nullptr,
                     const Aws::Health::HealthClientConfiguration& clientConfiguration = Aws::Health::HealthClientConfiguration());
 
        HealthClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                     std::shared_ptr<HealthEndpointProviderBase> endpointProvider = nullptr,
                     const Aws::Health::HealthClientConfiguration& clientConfiguration = Aws::Health::HealthClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        HealthClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        HealthClient(const Aws::Auth::AWSCredentials& credentials,
                     const Aws::Client::ClientConfiguration& clientConfiguration);
 
        HealthClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                     const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~HealthClient();
 
        virtual Model::DescribeAffectedAccountsForOrganizationOutcome DescribeAffectedAccountsForOrganization(const Model::DescribeAffectedAccountsForOrganizationRequest& request) const;
 
        template<typename DescribeAffectedAccountsForOrganizationRequestT = Model::DescribeAffectedAccountsForOrganizationRequest>
        Model::DescribeAffectedAccountsForOrganizationOutcomeCallable DescribeAffectedAccountsForOrganizationCallable(const DescribeAffectedAccountsForOrganizationRequestT& request) const
        {
            return SubmitCallable(&HealthClient::DescribeAffectedAccountsForOrganization, request);
        }
 
        template<typename DescribeAffectedAccountsForOrganizationRequestT = Model::DescribeAffectedAccountsForOrganizationRequest>
        void DescribeAffectedAccountsForOrganizationAsync(const DescribeAffectedAccountsForOrganizationRequestT& request, const DescribeAffectedAccountsForOrganizationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&HealthClient::DescribeAffectedAccountsForOrganization, request, handler, context);
        }
 
        virtual Model::DescribeAffectedEntitiesOutcome DescribeAffectedEntities(const Model::DescribeAffectedEntitiesRequest& request) const;
 
        template<typename DescribeAffectedEntitiesRequestT = Model::DescribeAffectedEntitiesRequest>
        Model::DescribeAffectedEntitiesOutcomeCallable DescribeAffectedEntitiesCallable(const DescribeAffectedEntitiesRequestT& request) const
        {
            return SubmitCallable(&HealthClient::DescribeAffectedEntities, request);
        }
 
        template<typename DescribeAffectedEntitiesRequestT = Model::DescribeAffectedEntitiesRequest>
        void DescribeAffectedEntitiesAsync(const DescribeAffectedEntitiesRequestT& request, const DescribeAffectedEntitiesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&HealthClient::DescribeAffectedEntities, request, handler, context);
        }
 
        virtual Model::DescribeAffectedEntitiesForOrganizationOutcome DescribeAffectedEntitiesForOrganization(const Model::DescribeAffectedEntitiesForOrganizationRequest& request = {}) const;
 
        template<typename DescribeAffectedEntitiesForOrganizationRequestT = Model::DescribeAffectedEntitiesForOrganizationRequest>
        Model::DescribeAffectedEntitiesForOrganizationOutcomeCallable DescribeAffectedEntitiesForOrganizationCallable(const DescribeAffectedEntitiesForOrganizationRequestT& request = {}) const
        {
            return SubmitCallable(&HealthClient::DescribeAffectedEntitiesForOrganization, request);
        }
 
        template<typename DescribeAffectedEntitiesForOrganizationRequestT = Model::DescribeAffectedEntitiesForOrganizationRequest>
        void DescribeAffectedEntitiesForOrganizationAsync(const DescribeAffectedEntitiesForOrganizationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeAffectedEntitiesForOrganizationRequestT& request = {}) const
        {
            return SubmitAsync(&HealthClient::DescribeAffectedEntitiesForOrganization, request, handler, context);
        }
 
        virtual Model::DescribeEntityAggregatesOutcome DescribeEntityAggregates(const Model::DescribeEntityAggregatesRequest& request = {}) const;
 
        template<typename DescribeEntityAggregatesRequestT = Model::DescribeEntityAggregatesRequest>
        Model::DescribeEntityAggregatesOutcomeCallable DescribeEntityAggregatesCallable(const DescribeEntityAggregatesRequestT& request = {}) const
        {
            return SubmitCallable(&HealthClient::DescribeEntityAggregates, request);
        }
 
        template<typename DescribeEntityAggregatesRequestT = Model::DescribeEntityAggregatesRequest>
        void DescribeEntityAggregatesAsync(const DescribeEntityAggregatesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeEntityAggregatesRequestT& request = {}) const
        {
            return SubmitAsync(&HealthClient::DescribeEntityAggregates, request, handler, context);
        }
 
        virtual Model::DescribeEntityAggregatesForOrganizationOutcome DescribeEntityAggregatesForOrganization(const Model::DescribeEntityAggregatesForOrganizationRequest& request) const;
 
        template<typename DescribeEntityAggregatesForOrganizationRequestT = Model::DescribeEntityAggregatesForOrganizationRequest>
        Model::DescribeEntityAggregatesForOrganizationOutcomeCallable DescribeEntityAggregatesForOrganizationCallable(const DescribeEntityAggregatesForOrganizationRequestT& request) const
        {
            return SubmitCallable(&HealthClient::DescribeEntityAggregatesForOrganization, request);
        }
 
        template<typename DescribeEntityAggregatesForOrganizationRequestT = Model::DescribeEntityAggregatesForOrganizationRequest>
        void DescribeEntityAggregatesForOrganizationAsync(const DescribeEntityAggregatesForOrganizationRequestT& request, const DescribeEntityAggregatesForOrganizationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&HealthClient::DescribeEntityAggregatesForOrganization, request, handler, context);
        }
 
        virtual Model::DescribeEventAggregatesOutcome DescribeEventAggregates(const Model::DescribeEventAggregatesRequest& request) const;
 
        template<typename DescribeEventAggregatesRequestT = Model::DescribeEventAggregatesRequest>
        Model::DescribeEventAggregatesOutcomeCallable DescribeEventAggregatesCallable(const DescribeEventAggregatesRequestT& request) const
        {
            return SubmitCallable(&HealthClient::DescribeEventAggregates, request);
        }
 
        template<typename DescribeEventAggregatesRequestT = Model::DescribeEventAggregatesRequest>
        void DescribeEventAggregatesAsync(const DescribeEventAggregatesRequestT& request, const DescribeEventAggregatesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&HealthClient::DescribeEventAggregates, request, handler, context);
        }
 
        virtual Model::DescribeEventDetailsOutcome DescribeEventDetails(const Model::DescribeEventDetailsRequest& request) const;
 
        template<typename DescribeEventDetailsRequestT = Model::DescribeEventDetailsRequest>
        Model::DescribeEventDetailsOutcomeCallable DescribeEventDetailsCallable(const DescribeEventDetailsRequestT& request) const
        {
            return SubmitCallable(&HealthClient::DescribeEventDetails, request);
        }
 
        template<typename DescribeEventDetailsRequestT = Model::DescribeEventDetailsRequest>
        void DescribeEventDetailsAsync(const DescribeEventDetailsRequestT& request, const DescribeEventDetailsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&HealthClient::DescribeEventDetails, request, handler, context);
        }
 
        virtual Model::DescribeEventDetailsForOrganizationOutcome DescribeEventDetailsForOrganization(const Model::DescribeEventDetailsForOrganizationRequest& request) const;
 
        template<typename DescribeEventDetailsForOrganizationRequestT = Model::DescribeEventDetailsForOrganizationRequest>
        Model::DescribeEventDetailsForOrganizationOutcomeCallable DescribeEventDetailsForOrganizationCallable(const DescribeEventDetailsForOrganizationRequestT& request) const
        {
            return SubmitCallable(&HealthClient::DescribeEventDetailsForOrganization, request);
        }
 
        template<typename DescribeEventDetailsForOrganizationRequestT = Model::DescribeEventDetailsForOrganizationRequest>
        void DescribeEventDetailsForOrganizationAsync(const DescribeEventDetailsForOrganizationRequestT& request, const DescribeEventDetailsForOrganizationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&HealthClient::DescribeEventDetailsForOrganization, request, handler, context);
        }
 
        virtual Model::DescribeEventTypesOutcome DescribeEventTypes(const Model::DescribeEventTypesRequest& request = {}) const;
 
        template<typename DescribeEventTypesRequestT = Model::DescribeEventTypesRequest>
        Model::DescribeEventTypesOutcomeCallable DescribeEventTypesCallable(const DescribeEventTypesRequestT& request = {}) const
        {
            return SubmitCallable(&HealthClient::DescribeEventTypes, request);
        }
 
        template<typename DescribeEventTypesRequestT = Model::DescribeEventTypesRequest>
        void DescribeEventTypesAsync(const DescribeEventTypesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeEventTypesRequestT& request = {}) const
        {
            return SubmitAsync(&HealthClient::DescribeEventTypes, request, handler, context);
        }
 
        virtual Model::DescribeEventsOutcome DescribeEvents(const Model::DescribeEventsRequest& request = {}) const;
 
        template<typename DescribeEventsRequestT = Model::DescribeEventsRequest>
        Model::DescribeEventsOutcomeCallable DescribeEventsCallable(const DescribeEventsRequestT& request = {}) const
        {
            return SubmitCallable(&HealthClient::DescribeEvents, request);
        }
 
        template<typename DescribeEventsRequestT = Model::DescribeEventsRequest>
        void DescribeEventsAsync(const DescribeEventsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeEventsRequestT& request = {}) const
        {
            return SubmitAsync(&HealthClient::DescribeEvents, request, handler, context);
        }
 
        virtual Model::DescribeEventsForOrganizationOutcome DescribeEventsForOrganization(const Model::DescribeEventsForOrganizationRequest& request = {}) const;
 
        template<typename DescribeEventsForOrganizationRequestT = Model::DescribeEventsForOrganizationRequest>
        Model::DescribeEventsForOrganizationOutcomeCallable DescribeEventsForOrganizationCallable(const DescribeEventsForOrganizationRequestT& request = {}) const
        {
            return SubmitCallable(&HealthClient::DescribeEventsForOrganization, request);
        }
 
        template<typename DescribeEventsForOrganizationRequestT = Model::DescribeEventsForOrganizationRequest>
        void DescribeEventsForOrganizationAsync(const DescribeEventsForOrganizationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeEventsForOrganizationRequestT& request = {}) const
        {
            return SubmitAsync(&HealthClient::DescribeEventsForOrganization, request, handler, context);
        }
 
        virtual Model::DescribeHealthServiceStatusForOrganizationOutcome DescribeHealthServiceStatusForOrganization(const Model::DescribeHealthServiceStatusForOrganizationRequest& request = {}) const;
 
        template<typename DescribeHealthServiceStatusForOrganizationRequestT = Model::DescribeHealthServiceStatusForOrganizationRequest>
        Model::DescribeHealthServiceStatusForOrganizationOutcomeCallable DescribeHealthServiceStatusForOrganizationCallable(const DescribeHealthServiceStatusForOrganizationRequestT& request = {}) const
        {
            return SubmitCallable(&HealthClient::DescribeHealthServiceStatusForOrganization, request);
        }
 
        template<typename DescribeHealthServiceStatusForOrganizationRequestT = Model::DescribeHealthServiceStatusForOrganizationRequest>
        void DescribeHealthServiceStatusForOrganizationAsync(const DescribeHealthServiceStatusForOrganizationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeHealthServiceStatusForOrganizationRequestT& request = {}) const
        {
            return SubmitAsync(&HealthClient::DescribeHealthServiceStatusForOrganization, request, handler, context);
        }
 
        virtual Model::DisableHealthServiceAccessForOrganizationOutcome DisableHealthServiceAccessForOrganization(const Model::DisableHealthServiceAccessForOrganizationRequest& request = {}) const;
 
        template<typename DisableHealthServiceAccessForOrganizationRequestT = Model::DisableHealthServiceAccessForOrganizationRequest>
        Model::DisableHealthServiceAccessForOrganizationOutcomeCallable DisableHealthServiceAccessForOrganizationCallable(const DisableHealthServiceAccessForOrganizationRequestT& request = {}) const
        {
            return SubmitCallable(&HealthClient::DisableHealthServiceAccessForOrganization, request);
        }
 
        template<typename DisableHealthServiceAccessForOrganizationRequestT = Model::DisableHealthServiceAccessForOrganizationRequest>
        void DisableHealthServiceAccessForOrganizationAsync(const DisableHealthServiceAccessForOrganizationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DisableHealthServiceAccessForOrganizationRequestT& request = {}) const
        {
            return SubmitAsync(&HealthClient::DisableHealthServiceAccessForOrganization, request, handler, context);
        }
 
        virtual Model::EnableHealthServiceAccessForOrganizationOutcome EnableHealthServiceAccessForOrganization(const Model::EnableHealthServiceAccessForOrganizationRequest& request = {}) const;
 
        template<typename EnableHealthServiceAccessForOrganizationRequestT = Model::EnableHealthServiceAccessForOrganizationRequest>
        Model::EnableHealthServiceAccessForOrganizationOutcomeCallable EnableHealthServiceAccessForOrganizationCallable(const EnableHealthServiceAccessForOrganizationRequestT& request = {}) const
        {
            return SubmitCallable(&HealthClient::EnableHealthServiceAccessForOrganization, request);
        }
 
        template<typename EnableHealthServiceAccessForOrganizationRequestT = Model::EnableHealthServiceAccessForOrganizationRequest>
        void EnableHealthServiceAccessForOrganizationAsync(const EnableHealthServiceAccessForOrganizationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const EnableHealthServiceAccessForOrganizationRequestT& request = {}) const
        {
            return SubmitAsync(&HealthClient::EnableHealthServiceAccessForOrganization, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<HealthEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<HealthClient>;
      void init(const HealthClientConfiguration& clientConfiguration);
 
      HealthClientConfiguration m_clientConfiguration;
      std::shared_ptr<HealthEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace Health
} // namespace Aws