SnowballClient.h

 
#pragma once
#include <aws/snowball/Snowball_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/snowball/SnowballServiceClientModel.h>
 
namespace Aws
{
namespace Snowball
{
  class AWS_SNOWBALL_API SnowballClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<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);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<SnowballEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<SnowballClient>;
      void init(const SnowballClientConfiguration& clientConfiguration);
 
      SnowballClientConfiguration m_clientConfiguration;
      std::shared_ptr<SnowballEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace Snowball
} // namespace Aws