HealthClient.h

 
#pragma once
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/health/HealthPaginationBase.h>
#include <aws/health/HealthServiceClientModel.h>
#include <aws/health/HealthWaiter.h>
#include <aws/health/Health_EXPORTS.h>
 
namespace Aws {
namespace Health {
class AWS_HEALTH_API HealthClient : public Aws::Client::AWSJsonClient,
                                    public Aws::Client::ClientWithAsyncTemplateMethods<HealthClient>,
                                    public HealthPaginationBase<HealthClient>,
                                    public HealthWaiter<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);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<HealthEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<HealthClient>;
  void init(const HealthClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, HealthError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request, Aws::Http::HttpMethod httpMethod) const;
 
  HealthClientConfiguration m_clientConfiguration;
  std::shared_ptr<HealthEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace Health
}  // namespace Aws