AutoScalingPlansClient.h

 
#pragma once
#include <aws/autoscaling-plans/AutoScalingPlansPaginationBase.h>
#include <aws/autoscaling-plans/AutoScalingPlansServiceClientModel.h>
#include <aws/autoscaling-plans/AutoScalingPlansWaiter.h>
#include <aws/autoscaling-plans/AutoScalingPlans_EXPORTS.h>
#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>
 
namespace Aws {
namespace AutoScalingPlans {
class AWS_AUTOSCALINGPLANS_API AutoScalingPlansClient : public Aws::Client::AWSJsonClient,
                                                        public Aws::Client::ClientWithAsyncTemplateMethods<AutoScalingPlansClient>,
                                                        public AutoScalingPlansPaginationBase<AutoScalingPlansClient>,
                                                        public AutoScalingPlansWaiter<AutoScalingPlansClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef AutoScalingPlansClientConfiguration ClientConfigurationType;
  typedef AutoScalingPlansEndpointProvider EndpointProviderType;
 
  AutoScalingPlansClient(const Aws::AutoScalingPlans::AutoScalingPlansClientConfiguration& clientConfiguration =
                             Aws::AutoScalingPlans::AutoScalingPlansClientConfiguration(),
                         std::shared_ptr<AutoScalingPlansEndpointProviderBase> endpointProvider = nullptr);
 
  AutoScalingPlansClient(const Aws::Auth::AWSCredentials& credentials,
                         std::shared_ptr<AutoScalingPlansEndpointProviderBase> endpointProvider = nullptr,
                         const Aws::AutoScalingPlans::AutoScalingPlansClientConfiguration& clientConfiguration =
                             Aws::AutoScalingPlans::AutoScalingPlansClientConfiguration());
 
  AutoScalingPlansClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                         std::shared_ptr<AutoScalingPlansEndpointProviderBase> endpointProvider = nullptr,
                         const Aws::AutoScalingPlans::AutoScalingPlansClientConfiguration& clientConfiguration =
                             Aws::AutoScalingPlans::AutoScalingPlansClientConfiguration());
 
  /* Legacy constructors due deprecation */
  AutoScalingPlansClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  AutoScalingPlansClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  AutoScalingPlansClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                         const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~AutoScalingPlansClient();
 
  virtual Model::CreateScalingPlanOutcome CreateScalingPlan(const Model::CreateScalingPlanRequest& request) const;
 
  template <typename CreateScalingPlanRequestT = Model::CreateScalingPlanRequest>
  Model::CreateScalingPlanOutcomeCallable CreateScalingPlanCallable(const CreateScalingPlanRequestT& request) const {
    return SubmitCallable(&AutoScalingPlansClient::CreateScalingPlan, request);
  }
 
  template <typename CreateScalingPlanRequestT = Model::CreateScalingPlanRequest>
  void CreateScalingPlanAsync(const CreateScalingPlanRequestT& request, const CreateScalingPlanResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AutoScalingPlansClient::CreateScalingPlan, request, handler, context);
  }
 
  virtual Model::DeleteScalingPlanOutcome DeleteScalingPlan(const Model::DeleteScalingPlanRequest& request) const;
 
  template <typename DeleteScalingPlanRequestT = Model::DeleteScalingPlanRequest>
  Model::DeleteScalingPlanOutcomeCallable DeleteScalingPlanCallable(const DeleteScalingPlanRequestT& request) const {
    return SubmitCallable(&AutoScalingPlansClient::DeleteScalingPlan, request);
  }
 
  template <typename DeleteScalingPlanRequestT = Model::DeleteScalingPlanRequest>
  void DeleteScalingPlanAsync(const DeleteScalingPlanRequestT& request, const DeleteScalingPlanResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AutoScalingPlansClient::DeleteScalingPlan, request, handler, context);
  }
 
  virtual Model::DescribeScalingPlanResourcesOutcome DescribeScalingPlanResources(
      const Model::DescribeScalingPlanResourcesRequest& request) const;
 
  template <typename DescribeScalingPlanResourcesRequestT = Model::DescribeScalingPlanResourcesRequest>
  Model::DescribeScalingPlanResourcesOutcomeCallable DescribeScalingPlanResourcesCallable(
      const DescribeScalingPlanResourcesRequestT& request) const {
    return SubmitCallable(&AutoScalingPlansClient::DescribeScalingPlanResources, request);
  }
 
  template <typename DescribeScalingPlanResourcesRequestT = Model::DescribeScalingPlanResourcesRequest>
  void DescribeScalingPlanResourcesAsync(const DescribeScalingPlanResourcesRequestT& request,
                                         const DescribeScalingPlanResourcesResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AutoScalingPlansClient::DescribeScalingPlanResources, request, handler, context);
  }
 
  virtual Model::DescribeScalingPlansOutcome DescribeScalingPlans(const Model::DescribeScalingPlansRequest& request = {}) const;
 
  template <typename DescribeScalingPlansRequestT = Model::DescribeScalingPlansRequest>
  Model::DescribeScalingPlansOutcomeCallable DescribeScalingPlansCallable(const DescribeScalingPlansRequestT& request = {}) const {
    return SubmitCallable(&AutoScalingPlansClient::DescribeScalingPlans, request);
  }
 
  template <typename DescribeScalingPlansRequestT = Model::DescribeScalingPlansRequest>
  void DescribeScalingPlansAsync(const DescribeScalingPlansResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                 const DescribeScalingPlansRequestT& request = {}) const {
    return SubmitAsync(&AutoScalingPlansClient::DescribeScalingPlans, request, handler, context);
  }
 
  virtual Model::GetScalingPlanResourceForecastDataOutcome GetScalingPlanResourceForecastData(
      const Model::GetScalingPlanResourceForecastDataRequest& request) const;
 
  template <typename GetScalingPlanResourceForecastDataRequestT = Model::GetScalingPlanResourceForecastDataRequest>
  Model::GetScalingPlanResourceForecastDataOutcomeCallable GetScalingPlanResourceForecastDataCallable(
      const GetScalingPlanResourceForecastDataRequestT& request) const {
    return SubmitCallable(&AutoScalingPlansClient::GetScalingPlanResourceForecastData, request);
  }
 
  template <typename GetScalingPlanResourceForecastDataRequestT = Model::GetScalingPlanResourceForecastDataRequest>
  void GetScalingPlanResourceForecastDataAsync(const GetScalingPlanResourceForecastDataRequestT& request,
                                               const GetScalingPlanResourceForecastDataResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AutoScalingPlansClient::GetScalingPlanResourceForecastData, request, handler, context);
  }
 
  virtual Model::UpdateScalingPlanOutcome UpdateScalingPlan(const Model::UpdateScalingPlanRequest& request) const;
 
  template <typename UpdateScalingPlanRequestT = Model::UpdateScalingPlanRequest>
  Model::UpdateScalingPlanOutcomeCallable UpdateScalingPlanCallable(const UpdateScalingPlanRequestT& request) const {
    return SubmitCallable(&AutoScalingPlansClient::UpdateScalingPlan, request);
  }
 
  template <typename UpdateScalingPlanRequestT = Model::UpdateScalingPlanRequest>
  void UpdateScalingPlanAsync(const UpdateScalingPlanRequestT& request, const UpdateScalingPlanResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AutoScalingPlansClient::UpdateScalingPlan, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<AutoScalingPlansEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<AutoScalingPlansClient>;
  void init(const AutoScalingPlansClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, AutoScalingPlansError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request, Aws::Http::HttpMethod httpMethod) const;
 
  AutoScalingPlansClientConfiguration m_clientConfiguration;
  std::shared_ptr<AutoScalingPlansEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace AutoScalingPlans
}  // namespace Aws