PricingPlanManagerClient.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/pricing-plan-manager/PricingPlanManagerPaginationBase.h>
#include <aws/pricing-plan-manager/PricingPlanManagerServiceClientModel.h>
#include <aws/pricing-plan-manager/PricingPlanManagerWaiter.h>
#include <aws/pricing-plan-manager/PricingPlanManager_EXPORTS.h>
 
namespace Aws {
namespace PricingPlanManager {
class AWS_PRICINGPLANMANAGER_API PricingPlanManagerClient : public Aws::Client::AWSJsonClient,
                                                            public Aws::Client::ClientWithAsyncTemplateMethods<PricingPlanManagerClient>,
                                                            public PricingPlanManagerPaginationBase<PricingPlanManagerClient>,
                                                            public PricingPlanManagerWaiter<PricingPlanManagerClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef PricingPlanManagerClientConfiguration ClientConfigurationType;
  typedef PricingPlanManagerEndpointProvider EndpointProviderType;
 
  PricingPlanManagerClient(const Aws::PricingPlanManager::PricingPlanManagerClientConfiguration& clientConfiguration =
                               Aws::PricingPlanManager::PricingPlanManagerClientConfiguration(),
                           std::shared_ptr<PricingPlanManagerEndpointProviderBase> endpointProvider = nullptr);
 
  PricingPlanManagerClient(const Aws::Auth::AWSCredentials& credentials,
                           std::shared_ptr<PricingPlanManagerEndpointProviderBase> endpointProvider = nullptr,
                           const Aws::PricingPlanManager::PricingPlanManagerClientConfiguration& clientConfiguration =
                               Aws::PricingPlanManager::PricingPlanManagerClientConfiguration());
 
  PricingPlanManagerClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                           std::shared_ptr<PricingPlanManagerEndpointProviderBase> endpointProvider = nullptr,
                           const Aws::PricingPlanManager::PricingPlanManagerClientConfiguration& clientConfiguration =
                               Aws::PricingPlanManager::PricingPlanManagerClientConfiguration());
 
  /* Legacy constructors due deprecation */
  PricingPlanManagerClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  PricingPlanManagerClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  PricingPlanManagerClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                           const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~PricingPlanManagerClient();
 
  virtual Model::ApprovePaidSubscriptionOutcome ApprovePaidSubscription(const Model::ApprovePaidSubscriptionRequest& request) const;
 
  template <typename ApprovePaidSubscriptionRequestT = Model::ApprovePaidSubscriptionRequest>
  Model::ApprovePaidSubscriptionOutcomeCallable ApprovePaidSubscriptionCallable(const ApprovePaidSubscriptionRequestT& request) const {
    return SubmitCallable(&PricingPlanManagerClient::ApprovePaidSubscription, request);
  }
 
  template <typename ApprovePaidSubscriptionRequestT = Model::ApprovePaidSubscriptionRequest>
  void ApprovePaidSubscriptionAsync(const ApprovePaidSubscriptionRequestT& request,
                                    const ApprovePaidSubscriptionResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PricingPlanManagerClient::ApprovePaidSubscription, request, handler, context);
  }
 
  virtual Model::AssociateResourcesToSubscriptionOutcome AssociateResourcesToSubscription(
      const Model::AssociateResourcesToSubscriptionRequest& request) const;
 
  template <typename AssociateResourcesToSubscriptionRequestT = Model::AssociateResourcesToSubscriptionRequest>
  Model::AssociateResourcesToSubscriptionOutcomeCallable AssociateResourcesToSubscriptionCallable(
      const AssociateResourcesToSubscriptionRequestT& request) const {
    return SubmitCallable(&PricingPlanManagerClient::AssociateResourcesToSubscription, request);
  }
 
  template <typename AssociateResourcesToSubscriptionRequestT = Model::AssociateResourcesToSubscriptionRequest>
  void AssociateResourcesToSubscriptionAsync(const AssociateResourcesToSubscriptionRequestT& request,
                                             const AssociateResourcesToSubscriptionResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PricingPlanManagerClient::AssociateResourcesToSubscription, request, handler, context);
  }
 
  virtual Model::CancelSubscriptionOutcome CancelSubscription(const Model::CancelSubscriptionRequest& request) const;
 
  template <typename CancelSubscriptionRequestT = Model::CancelSubscriptionRequest>
  Model::CancelSubscriptionOutcomeCallable CancelSubscriptionCallable(const CancelSubscriptionRequestT& request) const {
    return SubmitCallable(&PricingPlanManagerClient::CancelSubscription, request);
  }
 
  template <typename CancelSubscriptionRequestT = Model::CancelSubscriptionRequest>
  void CancelSubscriptionAsync(const CancelSubscriptionRequestT& request, const CancelSubscriptionResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PricingPlanManagerClient::CancelSubscription, request, handler, context);
  }
 
  virtual Model::CancelSubscriptionChangeOutcome CancelSubscriptionChange(const Model::CancelSubscriptionChangeRequest& request) const;
 
  template <typename CancelSubscriptionChangeRequestT = Model::CancelSubscriptionChangeRequest>
  Model::CancelSubscriptionChangeOutcomeCallable CancelSubscriptionChangeCallable(const CancelSubscriptionChangeRequestT& request) const {
    return SubmitCallable(&PricingPlanManagerClient::CancelSubscriptionChange, request);
  }
 
  template <typename CancelSubscriptionChangeRequestT = Model::CancelSubscriptionChangeRequest>
  void CancelSubscriptionChangeAsync(const CancelSubscriptionChangeRequestT& request,
                                     const CancelSubscriptionChangeResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PricingPlanManagerClient::CancelSubscriptionChange, request, handler, context);
  }
 
  virtual Model::CreateSubscriptionOutcome CreateSubscription(const Model::CreateSubscriptionRequest& request) const;
 
  template <typename CreateSubscriptionRequestT = Model::CreateSubscriptionRequest>
  Model::CreateSubscriptionOutcomeCallable CreateSubscriptionCallable(const CreateSubscriptionRequestT& request) const {
    return SubmitCallable(&PricingPlanManagerClient::CreateSubscription, request);
  }
 
  template <typename CreateSubscriptionRequestT = Model::CreateSubscriptionRequest>
  void CreateSubscriptionAsync(const CreateSubscriptionRequestT& request, const CreateSubscriptionResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PricingPlanManagerClient::CreateSubscription, request, handler, context);
  }
 
  virtual Model::DisassociateResourcesFromSubscriptionOutcome DisassociateResourcesFromSubscription(
      const Model::DisassociateResourcesFromSubscriptionRequest& request) const;
 
  template <typename DisassociateResourcesFromSubscriptionRequestT = Model::DisassociateResourcesFromSubscriptionRequest>
  Model::DisassociateResourcesFromSubscriptionOutcomeCallable DisassociateResourcesFromSubscriptionCallable(
      const DisassociateResourcesFromSubscriptionRequestT& request) const {
    return SubmitCallable(&PricingPlanManagerClient::DisassociateResourcesFromSubscription, request);
  }
 
  template <typename DisassociateResourcesFromSubscriptionRequestT = Model::DisassociateResourcesFromSubscriptionRequest>
  void DisassociateResourcesFromSubscriptionAsync(const DisassociateResourcesFromSubscriptionRequestT& request,
                                                  const DisassociateResourcesFromSubscriptionResponseReceivedHandler& handler,
                                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PricingPlanManagerClient::DisassociateResourcesFromSubscription, request, handler, context);
  }
 
  virtual Model::GetSubscriptionOutcome GetSubscription(const Model::GetSubscriptionRequest& request) const;
 
  template <typename GetSubscriptionRequestT = Model::GetSubscriptionRequest>
  Model::GetSubscriptionOutcomeCallable GetSubscriptionCallable(const GetSubscriptionRequestT& request) const {
    return SubmitCallable(&PricingPlanManagerClient::GetSubscription, request);
  }
 
  template <typename GetSubscriptionRequestT = Model::GetSubscriptionRequest>
  void GetSubscriptionAsync(const GetSubscriptionRequestT& request, const GetSubscriptionResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PricingPlanManagerClient::GetSubscription, request, handler, context);
  }
 
  virtual Model::ListSubscriptionsOutcome ListSubscriptions(const Model::ListSubscriptionsRequest& request = {}) const;
 
  template <typename ListSubscriptionsRequestT = Model::ListSubscriptionsRequest>
  Model::ListSubscriptionsOutcomeCallable ListSubscriptionsCallable(const ListSubscriptionsRequestT& request = {}) const {
    return SubmitCallable(&PricingPlanManagerClient::ListSubscriptions, request);
  }
 
  template <typename ListSubscriptionsRequestT = Model::ListSubscriptionsRequest>
  void ListSubscriptionsAsync(const ListSubscriptionsResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                              const ListSubscriptionsRequestT& request = {}) const {
    return SubmitAsync(&PricingPlanManagerClient::ListSubscriptions, request, handler, context);
  }
 
  virtual Model::UpdateSubscriptionOutcome UpdateSubscription(const Model::UpdateSubscriptionRequest& request) const;
 
  template <typename UpdateSubscriptionRequestT = Model::UpdateSubscriptionRequest>
  Model::UpdateSubscriptionOutcomeCallable UpdateSubscriptionCallable(const UpdateSubscriptionRequestT& request) const {
    return SubmitCallable(&PricingPlanManagerClient::UpdateSubscription, request);
  }
 
  template <typename UpdateSubscriptionRequestT = Model::UpdateSubscriptionRequest>
  void UpdateSubscriptionAsync(const UpdateSubscriptionRequestT& request, const UpdateSubscriptionResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PricingPlanManagerClient::UpdateSubscription, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<PricingPlanManagerEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<PricingPlanManagerClient>;
  void init(const PricingPlanManagerClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, PricingPlanManagerError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request,
                                                const std::function<void(Aws::Endpoint::ResolveEndpointOutcome&)>& resolveUri,
                                                Aws::Http::HttpMethod httpMethod) const;
 
  PricingPlanManagerClientConfiguration m_clientConfiguration;
  std::shared_ptr<PricingPlanManagerEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace PricingPlanManager
}  // namespace Aws