SnowballClient.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/snowball/SnowballPaginationBase.h>
#include <aws/snowball/SnowballServiceClientModel.h>
#include <aws/snowball/SnowballWaiter.h>
#include <aws/snowball/Snowball_EXPORTS.h>
 
namespace Aws {
namespace Snowball {
class AWS_SNOWBALL_API SnowballClient : public Aws::Client::AWSJsonClient,
                                        public Aws::Client::ClientWithAsyncTemplateMethods<SnowballClient>,
                                        public SnowballPaginationBase<SnowballClient>,
                                        public SnowballWaiter<SnowballClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef SnowballClientConfiguration ClientConfigurationType;
  typedef SnowballEndpointProvider EndpointProviderType;
 
  SnowballClient(const Aws::Snowball::SnowballClientConfiguration& clientConfiguration = Aws::Snowball::SnowballClientConfiguration(),
                 std::shared_ptr<SnowballEndpointProviderBase> endpointProvider = nullptr);
 
  SnowballClient(const Aws::Auth::AWSCredentials& credentials, std::shared_ptr<SnowballEndpointProviderBase> endpointProvider = nullptr,
                 const Aws::Snowball::SnowballClientConfiguration& clientConfiguration = Aws::Snowball::SnowballClientConfiguration());
 
  SnowballClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                 std::shared_ptr<SnowballEndpointProviderBase> endpointProvider = nullptr,
                 const Aws::Snowball::SnowballClientConfiguration& clientConfiguration = Aws::Snowball::SnowballClientConfiguration());
 
  /* Legacy constructors due deprecation */
  SnowballClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  SnowballClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  SnowballClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                 const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~SnowballClient();
 
  virtual Model::CancelClusterOutcome CancelCluster(const Model::CancelClusterRequest& request) const;
 
  template <typename CancelClusterRequestT = Model::CancelClusterRequest>
  Model::CancelClusterOutcomeCallable CancelClusterCallable(const CancelClusterRequestT& request) const {
    return SubmitCallable(&SnowballClient::CancelCluster, request);
  }
 
  template <typename CancelClusterRequestT = Model::CancelClusterRequest>
  void CancelClusterAsync(const CancelClusterRequestT& request, const CancelClusterResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SnowballClient::CancelCluster, request, handler, context);
  }
 
  virtual Model::CancelJobOutcome CancelJob(const Model::CancelJobRequest& request) const;
 
  template <typename CancelJobRequestT = Model::CancelJobRequest>
  Model::CancelJobOutcomeCallable CancelJobCallable(const CancelJobRequestT& request) const {
    return SubmitCallable(&SnowballClient::CancelJob, request);
  }
 
  template <typename CancelJobRequestT = Model::CancelJobRequest>
  void CancelJobAsync(const CancelJobRequestT& request, const CancelJobResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SnowballClient::CancelJob, request, handler, context);
  }
 
  virtual Model::CreateAddressOutcome CreateAddress(const Model::CreateAddressRequest& request) const;
 
  template <typename CreateAddressRequestT = Model::CreateAddressRequest>
  Model::CreateAddressOutcomeCallable CreateAddressCallable(const CreateAddressRequestT& request) const {
    return SubmitCallable(&SnowballClient::CreateAddress, request);
  }
 
  template <typename CreateAddressRequestT = Model::CreateAddressRequest>
  void CreateAddressAsync(const CreateAddressRequestT& request, const CreateAddressResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SnowballClient::CreateAddress, request, handler, context);
  }
 
  virtual Model::CreateClusterOutcome CreateCluster(const Model::CreateClusterRequest& request) const;
 
  template <typename CreateClusterRequestT = Model::CreateClusterRequest>
  Model::CreateClusterOutcomeCallable CreateClusterCallable(const CreateClusterRequestT& request) const {
    return SubmitCallable(&SnowballClient::CreateCluster, request);
  }
 
  template <typename CreateClusterRequestT = Model::CreateClusterRequest>
  void CreateClusterAsync(const CreateClusterRequestT& request, const CreateClusterResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SnowballClient::CreateCluster, request, handler, context);
  }
 
  virtual Model::CreateJobOutcome CreateJob(const Model::CreateJobRequest& request = {}) const;
 
  template <typename CreateJobRequestT = Model::CreateJobRequest>
  Model::CreateJobOutcomeCallable CreateJobCallable(const CreateJobRequestT& request = {}) const {
    return SubmitCallable(&SnowballClient::CreateJob, request);
  }
 
  template <typename CreateJobRequestT = Model::CreateJobRequest>
  void CreateJobAsync(const CreateJobResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                      const CreateJobRequestT& request = {}) const {
    return SubmitAsync(&SnowballClient::CreateJob, request, handler, context);
  }
 
  virtual Model::CreateLongTermPricingOutcome CreateLongTermPricing(const Model::CreateLongTermPricingRequest& request) const;
 
  template <typename CreateLongTermPricingRequestT = Model::CreateLongTermPricingRequest>
  Model::CreateLongTermPricingOutcomeCallable CreateLongTermPricingCallable(const CreateLongTermPricingRequestT& request) const {
    return SubmitCallable(&SnowballClient::CreateLongTermPricing, request);
  }
 
  template <typename CreateLongTermPricingRequestT = Model::CreateLongTermPricingRequest>
  void CreateLongTermPricingAsync(const CreateLongTermPricingRequestT& request, const CreateLongTermPricingResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SnowballClient::CreateLongTermPricing, request, handler, context);
  }
 
  virtual Model::CreateReturnShippingLabelOutcome CreateReturnShippingLabel(const Model::CreateReturnShippingLabelRequest& request) const;
 
  template <typename CreateReturnShippingLabelRequestT = Model::CreateReturnShippingLabelRequest>
  Model::CreateReturnShippingLabelOutcomeCallable CreateReturnShippingLabelCallable(
      const CreateReturnShippingLabelRequestT& request) const {
    return SubmitCallable(&SnowballClient::CreateReturnShippingLabel, request);
  }
 
  template <typename CreateReturnShippingLabelRequestT = Model::CreateReturnShippingLabelRequest>
  void CreateReturnShippingLabelAsync(const CreateReturnShippingLabelRequestT& request,
                                      const CreateReturnShippingLabelResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SnowballClient::CreateReturnShippingLabel, request, handler, context);
  }
 
  virtual Model::DescribeAddressOutcome DescribeAddress(const Model::DescribeAddressRequest& request) const;
 
  template <typename DescribeAddressRequestT = Model::DescribeAddressRequest>
  Model::DescribeAddressOutcomeCallable DescribeAddressCallable(const DescribeAddressRequestT& request) const {
    return SubmitCallable(&SnowballClient::DescribeAddress, request);
  }
 
  template <typename DescribeAddressRequestT = Model::DescribeAddressRequest>
  void DescribeAddressAsync(const DescribeAddressRequestT& request, const DescribeAddressResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SnowballClient::DescribeAddress, request, handler, context);
  }
 
  virtual Model::DescribeAddressesOutcome DescribeAddresses(const Model::DescribeAddressesRequest& request = {}) const;
 
  template <typename DescribeAddressesRequestT = Model::DescribeAddressesRequest>
  Model::DescribeAddressesOutcomeCallable DescribeAddressesCallable(const DescribeAddressesRequestT& request = {}) const {
    return SubmitCallable(&SnowballClient::DescribeAddresses, request);
  }
 
  template <typename DescribeAddressesRequestT = Model::DescribeAddressesRequest>
  void DescribeAddressesAsync(const DescribeAddressesResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                              const DescribeAddressesRequestT& request = {}) const {
    return SubmitAsync(&SnowballClient::DescribeAddresses, request, handler, context);
  }
 
  virtual Model::DescribeClusterOutcome DescribeCluster(const Model::DescribeClusterRequest& request) const;
 
  template <typename DescribeClusterRequestT = Model::DescribeClusterRequest>
  Model::DescribeClusterOutcomeCallable DescribeClusterCallable(const DescribeClusterRequestT& request) const {
    return SubmitCallable(&SnowballClient::DescribeCluster, request);
  }
 
  template <typename DescribeClusterRequestT = Model::DescribeClusterRequest>
  void DescribeClusterAsync(const DescribeClusterRequestT& request, const DescribeClusterResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SnowballClient::DescribeCluster, request, handler, context);
  }
 
  virtual Model::DescribeJobOutcome DescribeJob(const Model::DescribeJobRequest& request) const;
 
  template <typename DescribeJobRequestT = Model::DescribeJobRequest>
  Model::DescribeJobOutcomeCallable DescribeJobCallable(const DescribeJobRequestT& request) const {
    return SubmitCallable(&SnowballClient::DescribeJob, request);
  }
 
  template <typename DescribeJobRequestT = Model::DescribeJobRequest>
  void DescribeJobAsync(const DescribeJobRequestT& request, const DescribeJobResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SnowballClient::DescribeJob, request, handler, context);
  }
 
  virtual Model::DescribeReturnShippingLabelOutcome DescribeReturnShippingLabel(
      const Model::DescribeReturnShippingLabelRequest& request) const;
 
  template <typename DescribeReturnShippingLabelRequestT = Model::DescribeReturnShippingLabelRequest>
  Model::DescribeReturnShippingLabelOutcomeCallable DescribeReturnShippingLabelCallable(
      const DescribeReturnShippingLabelRequestT& request) const {
    return SubmitCallable(&SnowballClient::DescribeReturnShippingLabel, request);
  }
 
  template <typename DescribeReturnShippingLabelRequestT = Model::DescribeReturnShippingLabelRequest>
  void DescribeReturnShippingLabelAsync(const DescribeReturnShippingLabelRequestT& request,
                                        const DescribeReturnShippingLabelResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SnowballClient::DescribeReturnShippingLabel, request, handler, context);
  }
 
  virtual Model::GetJobManifestOutcome GetJobManifest(const Model::GetJobManifestRequest& request) const;
 
  template <typename GetJobManifestRequestT = Model::GetJobManifestRequest>
  Model::GetJobManifestOutcomeCallable GetJobManifestCallable(const GetJobManifestRequestT& request) const {
    return SubmitCallable(&SnowballClient::GetJobManifest, request);
  }
 
  template <typename GetJobManifestRequestT = Model::GetJobManifestRequest>
  void GetJobManifestAsync(const GetJobManifestRequestT& request, const GetJobManifestResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SnowballClient::GetJobManifest, request, handler, context);
  }
 
  virtual Model::GetJobUnlockCodeOutcome GetJobUnlockCode(const Model::GetJobUnlockCodeRequest& request) const;
 
  template <typename GetJobUnlockCodeRequestT = Model::GetJobUnlockCodeRequest>
  Model::GetJobUnlockCodeOutcomeCallable GetJobUnlockCodeCallable(const GetJobUnlockCodeRequestT& request) const {
    return SubmitCallable(&SnowballClient::GetJobUnlockCode, request);
  }
 
  template <typename GetJobUnlockCodeRequestT = Model::GetJobUnlockCodeRequest>
  void GetJobUnlockCodeAsync(const GetJobUnlockCodeRequestT& request, const GetJobUnlockCodeResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SnowballClient::GetJobUnlockCode, request, handler, context);
  }
 
  virtual Model::GetSnowballUsageOutcome GetSnowballUsage(const Model::GetSnowballUsageRequest& request = {}) const;
 
  template <typename GetSnowballUsageRequestT = Model::GetSnowballUsageRequest>
  Model::GetSnowballUsageOutcomeCallable GetSnowballUsageCallable(const GetSnowballUsageRequestT& request = {}) const {
    return SubmitCallable(&SnowballClient::GetSnowballUsage, request);
  }
 
  template <typename GetSnowballUsageRequestT = Model::GetSnowballUsageRequest>
  void GetSnowballUsageAsync(const GetSnowballUsageResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                             const GetSnowballUsageRequestT& request = {}) const {
    return SubmitAsync(&SnowballClient::GetSnowballUsage, request, handler, context);
  }
 
  virtual Model::GetSoftwareUpdatesOutcome GetSoftwareUpdates(const Model::GetSoftwareUpdatesRequest& request) const;
 
  template <typename GetSoftwareUpdatesRequestT = Model::GetSoftwareUpdatesRequest>
  Model::GetSoftwareUpdatesOutcomeCallable GetSoftwareUpdatesCallable(const GetSoftwareUpdatesRequestT& request) const {
    return SubmitCallable(&SnowballClient::GetSoftwareUpdates, request);
  }
 
  template <typename GetSoftwareUpdatesRequestT = Model::GetSoftwareUpdatesRequest>
  void GetSoftwareUpdatesAsync(const GetSoftwareUpdatesRequestT& request, const GetSoftwareUpdatesResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SnowballClient::GetSoftwareUpdates, request, handler, context);
  }
 
  virtual Model::ListClusterJobsOutcome ListClusterJobs(const Model::ListClusterJobsRequest& request) const;
 
  template <typename ListClusterJobsRequestT = Model::ListClusterJobsRequest>
  Model::ListClusterJobsOutcomeCallable ListClusterJobsCallable(const ListClusterJobsRequestT& request) const {
    return SubmitCallable(&SnowballClient::ListClusterJobs, request);
  }
 
  template <typename ListClusterJobsRequestT = Model::ListClusterJobsRequest>
  void ListClusterJobsAsync(const ListClusterJobsRequestT& request, const ListClusterJobsResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SnowballClient::ListClusterJobs, request, handler, context);
  }
 
  virtual Model::ListClustersOutcome ListClusters(const Model::ListClustersRequest& request = {}) const;
 
  template <typename ListClustersRequestT = Model::ListClustersRequest>
  Model::ListClustersOutcomeCallable ListClustersCallable(const ListClustersRequestT& request = {}) const {
    return SubmitCallable(&SnowballClient::ListClusters, request);
  }
 
  template <typename ListClustersRequestT = Model::ListClustersRequest>
  void ListClustersAsync(const ListClustersResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                         const ListClustersRequestT& request = {}) const {
    return SubmitAsync(&SnowballClient::ListClusters, request, handler, context);
  }
 
  virtual Model::ListCompatibleImagesOutcome ListCompatibleImages(const Model::ListCompatibleImagesRequest& request = {}) const;
 
  template <typename ListCompatibleImagesRequestT = Model::ListCompatibleImagesRequest>
  Model::ListCompatibleImagesOutcomeCallable ListCompatibleImagesCallable(const ListCompatibleImagesRequestT& request = {}) const {
    return SubmitCallable(&SnowballClient::ListCompatibleImages, request);
  }
 
  template <typename ListCompatibleImagesRequestT = Model::ListCompatibleImagesRequest>
  void ListCompatibleImagesAsync(const ListCompatibleImagesResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                 const ListCompatibleImagesRequestT& request = {}) const {
    return SubmitAsync(&SnowballClient::ListCompatibleImages, request, handler, context);
  }
 
  virtual Model::ListJobsOutcome ListJobs(const Model::ListJobsRequest& request = {}) const;
 
  template <typename ListJobsRequestT = Model::ListJobsRequest>
  Model::ListJobsOutcomeCallable ListJobsCallable(const ListJobsRequestT& request = {}) const {
    return SubmitCallable(&SnowballClient::ListJobs, request);
  }
 
  template <typename ListJobsRequestT = Model::ListJobsRequest>
  void ListJobsAsync(const ListJobsResponseReceivedHandler& handler,
                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                     const ListJobsRequestT& request = {}) const {
    return SubmitAsync(&SnowballClient::ListJobs, request, handler, context);
  }
 
  virtual Model::ListLongTermPricingOutcome ListLongTermPricing(const Model::ListLongTermPricingRequest& request = {}) const;
 
  template <typename ListLongTermPricingRequestT = Model::ListLongTermPricingRequest>
  Model::ListLongTermPricingOutcomeCallable ListLongTermPricingCallable(const ListLongTermPricingRequestT& request = {}) const {
    return SubmitCallable(&SnowballClient::ListLongTermPricing, request);
  }
 
  template <typename ListLongTermPricingRequestT = Model::ListLongTermPricingRequest>
  void ListLongTermPricingAsync(const ListLongTermPricingResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                const ListLongTermPricingRequestT& request = {}) const {
    return SubmitAsync(&SnowballClient::ListLongTermPricing, request, handler, context);
  }
 
  virtual Model::ListPickupLocationsOutcome ListPickupLocations(const Model::ListPickupLocationsRequest& request = {}) const;
 
  template <typename ListPickupLocationsRequestT = Model::ListPickupLocationsRequest>
  Model::ListPickupLocationsOutcomeCallable ListPickupLocationsCallable(const ListPickupLocationsRequestT& request = {}) const {
    return SubmitCallable(&SnowballClient::ListPickupLocations, request);
  }
 
  template <typename ListPickupLocationsRequestT = Model::ListPickupLocationsRequest>
  void ListPickupLocationsAsync(const ListPickupLocationsResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                const ListPickupLocationsRequestT& request = {}) const {
    return SubmitAsync(&SnowballClient::ListPickupLocations, request, handler, context);
  }
 
  virtual Model::ListServiceVersionsOutcome ListServiceVersions(const Model::ListServiceVersionsRequest& request) const;
 
  template <typename ListServiceVersionsRequestT = Model::ListServiceVersionsRequest>
  Model::ListServiceVersionsOutcomeCallable ListServiceVersionsCallable(const ListServiceVersionsRequestT& request) const {
    return SubmitCallable(&SnowballClient::ListServiceVersions, request);
  }
 
  template <typename ListServiceVersionsRequestT = Model::ListServiceVersionsRequest>
  void ListServiceVersionsAsync(const ListServiceVersionsRequestT& request, const ListServiceVersionsResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SnowballClient::ListServiceVersions, request, handler, context);
  }
 
  virtual Model::UpdateClusterOutcome UpdateCluster(const Model::UpdateClusterRequest& request) const;
 
  template <typename UpdateClusterRequestT = Model::UpdateClusterRequest>
  Model::UpdateClusterOutcomeCallable UpdateClusterCallable(const UpdateClusterRequestT& request) const {
    return SubmitCallable(&SnowballClient::UpdateCluster, request);
  }
 
  template <typename UpdateClusterRequestT = Model::UpdateClusterRequest>
  void UpdateClusterAsync(const UpdateClusterRequestT& request, const UpdateClusterResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SnowballClient::UpdateCluster, request, handler, context);
  }
 
  virtual Model::UpdateJobOutcome UpdateJob(const Model::UpdateJobRequest& request) const;
 
  template <typename UpdateJobRequestT = Model::UpdateJobRequest>
  Model::UpdateJobOutcomeCallable UpdateJobCallable(const UpdateJobRequestT& request) const {
    return SubmitCallable(&SnowballClient::UpdateJob, request);
  }
 
  template <typename UpdateJobRequestT = Model::UpdateJobRequest>
  void UpdateJobAsync(const UpdateJobRequestT& request, const UpdateJobResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SnowballClient::UpdateJob, request, handler, context);
  }
 
  virtual Model::UpdateJobShipmentStateOutcome UpdateJobShipmentState(const Model::UpdateJobShipmentStateRequest& request) const;
 
  template <typename UpdateJobShipmentStateRequestT = Model::UpdateJobShipmentStateRequest>
  Model::UpdateJobShipmentStateOutcomeCallable UpdateJobShipmentStateCallable(const UpdateJobShipmentStateRequestT& request) const {
    return SubmitCallable(&SnowballClient::UpdateJobShipmentState, request);
  }
 
  template <typename UpdateJobShipmentStateRequestT = Model::UpdateJobShipmentStateRequest>
  void UpdateJobShipmentStateAsync(const UpdateJobShipmentStateRequestT& request,
                                   const UpdateJobShipmentStateResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SnowballClient::UpdateJobShipmentState, request, handler, context);
  }
 
  virtual Model::UpdateLongTermPricingOutcome UpdateLongTermPricing(const Model::UpdateLongTermPricingRequest& request) const;
 
  template <typename UpdateLongTermPricingRequestT = Model::UpdateLongTermPricingRequest>
  Model::UpdateLongTermPricingOutcomeCallable UpdateLongTermPricingCallable(const UpdateLongTermPricingRequestT& request) const {
    return SubmitCallable(&SnowballClient::UpdateLongTermPricing, request);
  }
 
  template <typename UpdateLongTermPricingRequestT = Model::UpdateLongTermPricingRequest>
  void UpdateLongTermPricingAsync(const UpdateLongTermPricingRequestT& request, const UpdateLongTermPricingResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SnowballClient::UpdateLongTermPricing, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<SnowballEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<SnowballClient>;
  void init(const SnowballClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, SnowballError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request, Aws::Http::HttpMethod httpMethod) const;
 
  SnowballClientConfiguration m_clientConfiguration;
  std::shared_ptr<SnowballEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace Snowball
}  // namespace Aws