GlacierClient.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/glacier/GlacierPaginationBase.h>
#include <aws/glacier/GlacierServiceClientModel.h>
#include <aws/glacier/GlacierWaiter.h>
#include <aws/glacier/Glacier_EXPORTS.h>
 
namespace Aws {
namespace Glacier {
class AWS_GLACIER_API GlacierClient : public Aws::Client::AWSJsonClient,
                                      public Aws::Client::ClientWithAsyncTemplateMethods<GlacierClient>,
                                      public GlacierPaginationBase<GlacierClient>,
                                      public GlacierWaiter<GlacierClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef GlacierClientConfiguration ClientConfigurationType;
  typedef GlacierEndpointProvider EndpointProviderType;
 
  GlacierClient(const Aws::Glacier::GlacierClientConfiguration& clientConfiguration = Aws::Glacier::GlacierClientConfiguration(),
                std::shared_ptr<GlacierEndpointProviderBase> endpointProvider = nullptr);
 
  GlacierClient(const Aws::Auth::AWSCredentials& credentials, std::shared_ptr<GlacierEndpointProviderBase> endpointProvider = nullptr,
                const Aws::Glacier::GlacierClientConfiguration& clientConfiguration = Aws::Glacier::GlacierClientConfiguration());
 
  GlacierClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                std::shared_ptr<GlacierEndpointProviderBase> endpointProvider = nullptr,
                const Aws::Glacier::GlacierClientConfiguration& clientConfiguration = Aws::Glacier::GlacierClientConfiguration());
 
  /* Legacy constructors due deprecation */
  GlacierClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  GlacierClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  GlacierClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~GlacierClient();
 
  virtual Model::AbortMultipartUploadOutcome AbortMultipartUpload(const Model::AbortMultipartUploadRequest& request) const;
 
  template <typename AbortMultipartUploadRequestT = Model::AbortMultipartUploadRequest>
  Model::AbortMultipartUploadOutcomeCallable AbortMultipartUploadCallable(const AbortMultipartUploadRequestT& request) const {
    return SubmitCallable(&GlacierClient::AbortMultipartUpload, request);
  }
 
  template <typename AbortMultipartUploadRequestT = Model::AbortMultipartUploadRequest>
  void AbortMultipartUploadAsync(const AbortMultipartUploadRequestT& request, const AbortMultipartUploadResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GlacierClient::AbortMultipartUpload, request, handler, context);
  }
 
  virtual Model::AbortVaultLockOutcome AbortVaultLock(const Model::AbortVaultLockRequest& request) const;
 
  template <typename AbortVaultLockRequestT = Model::AbortVaultLockRequest>
  Model::AbortVaultLockOutcomeCallable AbortVaultLockCallable(const AbortVaultLockRequestT& request) const {
    return SubmitCallable(&GlacierClient::AbortVaultLock, request);
  }
 
  template <typename AbortVaultLockRequestT = Model::AbortVaultLockRequest>
  void AbortVaultLockAsync(const AbortVaultLockRequestT& request, const AbortVaultLockResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GlacierClient::AbortVaultLock, request, handler, context);
  }
 
  virtual Model::AddTagsToVaultOutcome AddTagsToVault(const Model::AddTagsToVaultRequest& request) const;
 
  template <typename AddTagsToVaultRequestT = Model::AddTagsToVaultRequest>
  Model::AddTagsToVaultOutcomeCallable AddTagsToVaultCallable(const AddTagsToVaultRequestT& request) const {
    return SubmitCallable(&GlacierClient::AddTagsToVault, request);
  }
 
  template <typename AddTagsToVaultRequestT = Model::AddTagsToVaultRequest>
  void AddTagsToVaultAsync(const AddTagsToVaultRequestT& request, const AddTagsToVaultResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GlacierClient::AddTagsToVault, request, handler, context);
  }
 
  virtual Model::CompleteMultipartUploadOutcome CompleteMultipartUpload(const Model::CompleteMultipartUploadRequest& request) const;
 
  template <typename CompleteMultipartUploadRequestT = Model::CompleteMultipartUploadRequest>
  Model::CompleteMultipartUploadOutcomeCallable CompleteMultipartUploadCallable(const CompleteMultipartUploadRequestT& request) const {
    return SubmitCallable(&GlacierClient::CompleteMultipartUpload, request);
  }
 
  template <typename CompleteMultipartUploadRequestT = Model::CompleteMultipartUploadRequest>
  void CompleteMultipartUploadAsync(const CompleteMultipartUploadRequestT& request,
                                    const CompleteMultipartUploadResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GlacierClient::CompleteMultipartUpload, request, handler, context);
  }
 
  virtual Model::CompleteVaultLockOutcome CompleteVaultLock(const Model::CompleteVaultLockRequest& request) const;
 
  template <typename CompleteVaultLockRequestT = Model::CompleteVaultLockRequest>
  Model::CompleteVaultLockOutcomeCallable CompleteVaultLockCallable(const CompleteVaultLockRequestT& request) const {
    return SubmitCallable(&GlacierClient::CompleteVaultLock, request);
  }
 
  template <typename CompleteVaultLockRequestT = Model::CompleteVaultLockRequest>
  void CompleteVaultLockAsync(const CompleteVaultLockRequestT& request, const CompleteVaultLockResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GlacierClient::CompleteVaultLock, request, handler, context);
  }
 
  virtual Model::CreateVaultOutcome CreateVault(const Model::CreateVaultRequest& request) const;
 
  template <typename CreateVaultRequestT = Model::CreateVaultRequest>
  Model::CreateVaultOutcomeCallable CreateVaultCallable(const CreateVaultRequestT& request) const {
    return SubmitCallable(&GlacierClient::CreateVault, request);
  }
 
  template <typename CreateVaultRequestT = Model::CreateVaultRequest>
  void CreateVaultAsync(const CreateVaultRequestT& request, const CreateVaultResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GlacierClient::CreateVault, request, handler, context);
  }
 
  virtual Model::DeleteArchiveOutcome DeleteArchive(const Model::DeleteArchiveRequest& request) const;
 
  template <typename DeleteArchiveRequestT = Model::DeleteArchiveRequest>
  Model::DeleteArchiveOutcomeCallable DeleteArchiveCallable(const DeleteArchiveRequestT& request) const {
    return SubmitCallable(&GlacierClient::DeleteArchive, request);
  }
 
  template <typename DeleteArchiveRequestT = Model::DeleteArchiveRequest>
  void DeleteArchiveAsync(const DeleteArchiveRequestT& request, const DeleteArchiveResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GlacierClient::DeleteArchive, request, handler, context);
  }
 
  virtual Model::DeleteVaultOutcome DeleteVault(const Model::DeleteVaultRequest& request) const;
 
  template <typename DeleteVaultRequestT = Model::DeleteVaultRequest>
  Model::DeleteVaultOutcomeCallable DeleteVaultCallable(const DeleteVaultRequestT& request) const {
    return SubmitCallable(&GlacierClient::DeleteVault, request);
  }
 
  template <typename DeleteVaultRequestT = Model::DeleteVaultRequest>
  void DeleteVaultAsync(const DeleteVaultRequestT& request, const DeleteVaultResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GlacierClient::DeleteVault, request, handler, context);
  }
 
  virtual Model::DeleteVaultAccessPolicyOutcome DeleteVaultAccessPolicy(const Model::DeleteVaultAccessPolicyRequest& request) const;
 
  template <typename DeleteVaultAccessPolicyRequestT = Model::DeleteVaultAccessPolicyRequest>
  Model::DeleteVaultAccessPolicyOutcomeCallable DeleteVaultAccessPolicyCallable(const DeleteVaultAccessPolicyRequestT& request) const {
    return SubmitCallable(&GlacierClient::DeleteVaultAccessPolicy, request);
  }
 
  template <typename DeleteVaultAccessPolicyRequestT = Model::DeleteVaultAccessPolicyRequest>
  void DeleteVaultAccessPolicyAsync(const DeleteVaultAccessPolicyRequestT& request,
                                    const DeleteVaultAccessPolicyResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GlacierClient::DeleteVaultAccessPolicy, request, handler, context);
  }
 
  virtual Model::DeleteVaultNotificationsOutcome DeleteVaultNotifications(const Model::DeleteVaultNotificationsRequest& request) const;
 
  template <typename DeleteVaultNotificationsRequestT = Model::DeleteVaultNotificationsRequest>
  Model::DeleteVaultNotificationsOutcomeCallable DeleteVaultNotificationsCallable(const DeleteVaultNotificationsRequestT& request) const {
    return SubmitCallable(&GlacierClient::DeleteVaultNotifications, request);
  }
 
  template <typename DeleteVaultNotificationsRequestT = Model::DeleteVaultNotificationsRequest>
  void DeleteVaultNotificationsAsync(const DeleteVaultNotificationsRequestT& request,
                                     const DeleteVaultNotificationsResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GlacierClient::DeleteVaultNotifications, 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(&GlacierClient::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(&GlacierClient::DescribeJob, request, handler, context);
  }
 
  virtual Model::DescribeVaultOutcome DescribeVault(const Model::DescribeVaultRequest& request) const;
 
  template <typename DescribeVaultRequestT = Model::DescribeVaultRequest>
  Model::DescribeVaultOutcomeCallable DescribeVaultCallable(const DescribeVaultRequestT& request) const {
    return SubmitCallable(&GlacierClient::DescribeVault, request);
  }
 
  template <typename DescribeVaultRequestT = Model::DescribeVaultRequest>
  void DescribeVaultAsync(const DescribeVaultRequestT& request, const DescribeVaultResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GlacierClient::DescribeVault, request, handler, context);
  }
 
  virtual Model::GetDataRetrievalPolicyOutcome GetDataRetrievalPolicy(const Model::GetDataRetrievalPolicyRequest& request) const;
 
  template <typename GetDataRetrievalPolicyRequestT = Model::GetDataRetrievalPolicyRequest>
  Model::GetDataRetrievalPolicyOutcomeCallable GetDataRetrievalPolicyCallable(const GetDataRetrievalPolicyRequestT& request) const {
    return SubmitCallable(&GlacierClient::GetDataRetrievalPolicy, request);
  }
 
  template <typename GetDataRetrievalPolicyRequestT = Model::GetDataRetrievalPolicyRequest>
  void GetDataRetrievalPolicyAsync(const GetDataRetrievalPolicyRequestT& request,
                                   const GetDataRetrievalPolicyResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GlacierClient::GetDataRetrievalPolicy, request, handler, context);
  }
 
  virtual Model::GetJobOutputOutcome GetJobOutput(const Model::GetJobOutputRequest& request) const;
 
  template <typename GetJobOutputRequestT = Model::GetJobOutputRequest>
  Model::GetJobOutputOutcomeCallable GetJobOutputCallable(const GetJobOutputRequestT& request) const {
    return SubmitCallable(&GlacierClient::GetJobOutput, request);
  }
 
  template <typename GetJobOutputRequestT = Model::GetJobOutputRequest>
  void GetJobOutputAsync(const GetJobOutputRequestT& request, const GetJobOutputResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GlacierClient::GetJobOutput, request, handler, context);
  }
 
  virtual Model::GetVaultAccessPolicyOutcome GetVaultAccessPolicy(const Model::GetVaultAccessPolicyRequest& request) const;
 
  template <typename GetVaultAccessPolicyRequestT = Model::GetVaultAccessPolicyRequest>
  Model::GetVaultAccessPolicyOutcomeCallable GetVaultAccessPolicyCallable(const GetVaultAccessPolicyRequestT& request) const {
    return SubmitCallable(&GlacierClient::GetVaultAccessPolicy, request);
  }
 
  template <typename GetVaultAccessPolicyRequestT = Model::GetVaultAccessPolicyRequest>
  void GetVaultAccessPolicyAsync(const GetVaultAccessPolicyRequestT& request, const GetVaultAccessPolicyResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GlacierClient::GetVaultAccessPolicy, request, handler, context);
  }
 
  virtual Model::GetVaultLockOutcome GetVaultLock(const Model::GetVaultLockRequest& request) const;
 
  template <typename GetVaultLockRequestT = Model::GetVaultLockRequest>
  Model::GetVaultLockOutcomeCallable GetVaultLockCallable(const GetVaultLockRequestT& request) const {
    return SubmitCallable(&GlacierClient::GetVaultLock, request);
  }
 
  template <typename GetVaultLockRequestT = Model::GetVaultLockRequest>
  void GetVaultLockAsync(const GetVaultLockRequestT& request, const GetVaultLockResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GlacierClient::GetVaultLock, request, handler, context);
  }
 
  virtual Model::GetVaultNotificationsOutcome GetVaultNotifications(const Model::GetVaultNotificationsRequest& request) const;
 
  template <typename GetVaultNotificationsRequestT = Model::GetVaultNotificationsRequest>
  Model::GetVaultNotificationsOutcomeCallable GetVaultNotificationsCallable(const GetVaultNotificationsRequestT& request) const {
    return SubmitCallable(&GlacierClient::GetVaultNotifications, request);
  }
 
  template <typename GetVaultNotificationsRequestT = Model::GetVaultNotificationsRequest>
  void GetVaultNotificationsAsync(const GetVaultNotificationsRequestT& request, const GetVaultNotificationsResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GlacierClient::GetVaultNotifications, request, handler, context);
  }
 
  virtual Model::InitiateJobOutcome InitiateJob(const Model::InitiateJobRequest& request) const;
 
  template <typename InitiateJobRequestT = Model::InitiateJobRequest>
  Model::InitiateJobOutcomeCallable InitiateJobCallable(const InitiateJobRequestT& request) const {
    return SubmitCallable(&GlacierClient::InitiateJob, request);
  }
 
  template <typename InitiateJobRequestT = Model::InitiateJobRequest>
  void InitiateJobAsync(const InitiateJobRequestT& request, const InitiateJobResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GlacierClient::InitiateJob, request, handler, context);
  }
 
  virtual Model::InitiateMultipartUploadOutcome InitiateMultipartUpload(const Model::InitiateMultipartUploadRequest& request) const;
 
  template <typename InitiateMultipartUploadRequestT = Model::InitiateMultipartUploadRequest>
  Model::InitiateMultipartUploadOutcomeCallable InitiateMultipartUploadCallable(const InitiateMultipartUploadRequestT& request) const {
    return SubmitCallable(&GlacierClient::InitiateMultipartUpload, request);
  }
 
  template <typename InitiateMultipartUploadRequestT = Model::InitiateMultipartUploadRequest>
  void InitiateMultipartUploadAsync(const InitiateMultipartUploadRequestT& request,
                                    const InitiateMultipartUploadResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GlacierClient::InitiateMultipartUpload, request, handler, context);
  }
 
  virtual Model::InitiateVaultLockOutcome InitiateVaultLock(const Model::InitiateVaultLockRequest& request) const;
 
  template <typename InitiateVaultLockRequestT = Model::InitiateVaultLockRequest>
  Model::InitiateVaultLockOutcomeCallable InitiateVaultLockCallable(const InitiateVaultLockRequestT& request) const {
    return SubmitCallable(&GlacierClient::InitiateVaultLock, request);
  }
 
  template <typename InitiateVaultLockRequestT = Model::InitiateVaultLockRequest>
  void InitiateVaultLockAsync(const InitiateVaultLockRequestT& request, const InitiateVaultLockResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GlacierClient::InitiateVaultLock, 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(&GlacierClient::ListJobs, request);
  }
 
  template <typename ListJobsRequestT = Model::ListJobsRequest>
  void ListJobsAsync(const ListJobsRequestT& request, const ListJobsResponseReceivedHandler& handler,
                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GlacierClient::ListJobs, request, handler, context);
  }
 
  virtual Model::ListMultipartUploadsOutcome ListMultipartUploads(const Model::ListMultipartUploadsRequest& request) const;
 
  template <typename ListMultipartUploadsRequestT = Model::ListMultipartUploadsRequest>
  Model::ListMultipartUploadsOutcomeCallable ListMultipartUploadsCallable(const ListMultipartUploadsRequestT& request) const {
    return SubmitCallable(&GlacierClient::ListMultipartUploads, request);
  }
 
  template <typename ListMultipartUploadsRequestT = Model::ListMultipartUploadsRequest>
  void ListMultipartUploadsAsync(const ListMultipartUploadsRequestT& request, const ListMultipartUploadsResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GlacierClient::ListMultipartUploads, request, handler, context);
  }
 
  virtual Model::ListPartsOutcome ListParts(const Model::ListPartsRequest& request) const;
 
  template <typename ListPartsRequestT = Model::ListPartsRequest>
  Model::ListPartsOutcomeCallable ListPartsCallable(const ListPartsRequestT& request) const {
    return SubmitCallable(&GlacierClient::ListParts, request);
  }
 
  template <typename ListPartsRequestT = Model::ListPartsRequest>
  void ListPartsAsync(const ListPartsRequestT& request, const ListPartsResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GlacierClient::ListParts, request, handler, context);
  }
 
  virtual Model::ListProvisionedCapacityOutcome ListProvisionedCapacity(const Model::ListProvisionedCapacityRequest& request) const;
 
  template <typename ListProvisionedCapacityRequestT = Model::ListProvisionedCapacityRequest>
  Model::ListProvisionedCapacityOutcomeCallable ListProvisionedCapacityCallable(const ListProvisionedCapacityRequestT& request) const {
    return SubmitCallable(&GlacierClient::ListProvisionedCapacity, request);
  }
 
  template <typename ListProvisionedCapacityRequestT = Model::ListProvisionedCapacityRequest>
  void ListProvisionedCapacityAsync(const ListProvisionedCapacityRequestT& request,
                                    const ListProvisionedCapacityResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GlacierClient::ListProvisionedCapacity, request, handler, context);
  }
 
  virtual Model::ListTagsForVaultOutcome ListTagsForVault(const Model::ListTagsForVaultRequest& request) const;
 
  template <typename ListTagsForVaultRequestT = Model::ListTagsForVaultRequest>
  Model::ListTagsForVaultOutcomeCallable ListTagsForVaultCallable(const ListTagsForVaultRequestT& request) const {
    return SubmitCallable(&GlacierClient::ListTagsForVault, request);
  }
 
  template <typename ListTagsForVaultRequestT = Model::ListTagsForVaultRequest>
  void ListTagsForVaultAsync(const ListTagsForVaultRequestT& request, const ListTagsForVaultResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GlacierClient::ListTagsForVault, request, handler, context);
  }
 
  virtual Model::ListVaultsOutcome ListVaults(const Model::ListVaultsRequest& request) const;
 
  template <typename ListVaultsRequestT = Model::ListVaultsRequest>
  Model::ListVaultsOutcomeCallable ListVaultsCallable(const ListVaultsRequestT& request) const {
    return SubmitCallable(&GlacierClient::ListVaults, request);
  }
 
  template <typename ListVaultsRequestT = Model::ListVaultsRequest>
  void ListVaultsAsync(const ListVaultsRequestT& request, const ListVaultsResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GlacierClient::ListVaults, request, handler, context);
  }
 
  virtual Model::PurchaseProvisionedCapacityOutcome PurchaseProvisionedCapacity(
      const Model::PurchaseProvisionedCapacityRequest& request) const;
 
  template <typename PurchaseProvisionedCapacityRequestT = Model::PurchaseProvisionedCapacityRequest>
  Model::PurchaseProvisionedCapacityOutcomeCallable PurchaseProvisionedCapacityCallable(
      const PurchaseProvisionedCapacityRequestT& request) const {
    return SubmitCallable(&GlacierClient::PurchaseProvisionedCapacity, request);
  }
 
  template <typename PurchaseProvisionedCapacityRequestT = Model::PurchaseProvisionedCapacityRequest>
  void PurchaseProvisionedCapacityAsync(const PurchaseProvisionedCapacityRequestT& request,
                                        const PurchaseProvisionedCapacityResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GlacierClient::PurchaseProvisionedCapacity, request, handler, context);
  }
 
  virtual Model::RemoveTagsFromVaultOutcome RemoveTagsFromVault(const Model::RemoveTagsFromVaultRequest& request) const;
 
  template <typename RemoveTagsFromVaultRequestT = Model::RemoveTagsFromVaultRequest>
  Model::RemoveTagsFromVaultOutcomeCallable RemoveTagsFromVaultCallable(const RemoveTagsFromVaultRequestT& request) const {
    return SubmitCallable(&GlacierClient::RemoveTagsFromVault, request);
  }
 
  template <typename RemoveTagsFromVaultRequestT = Model::RemoveTagsFromVaultRequest>
  void RemoveTagsFromVaultAsync(const RemoveTagsFromVaultRequestT& request, const RemoveTagsFromVaultResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GlacierClient::RemoveTagsFromVault, request, handler, context);
  }
 
  virtual Model::SetDataRetrievalPolicyOutcome SetDataRetrievalPolicy(const Model::SetDataRetrievalPolicyRequest& request) const;
 
  template <typename SetDataRetrievalPolicyRequestT = Model::SetDataRetrievalPolicyRequest>
  Model::SetDataRetrievalPolicyOutcomeCallable SetDataRetrievalPolicyCallable(const SetDataRetrievalPolicyRequestT& request) const {
    return SubmitCallable(&GlacierClient::SetDataRetrievalPolicy, request);
  }
 
  template <typename SetDataRetrievalPolicyRequestT = Model::SetDataRetrievalPolicyRequest>
  void SetDataRetrievalPolicyAsync(const SetDataRetrievalPolicyRequestT& request,
                                   const SetDataRetrievalPolicyResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GlacierClient::SetDataRetrievalPolicy, request, handler, context);
  }
 
  virtual Model::SetVaultAccessPolicyOutcome SetVaultAccessPolicy(const Model::SetVaultAccessPolicyRequest& request) const;
 
  template <typename SetVaultAccessPolicyRequestT = Model::SetVaultAccessPolicyRequest>
  Model::SetVaultAccessPolicyOutcomeCallable SetVaultAccessPolicyCallable(const SetVaultAccessPolicyRequestT& request) const {
    return SubmitCallable(&GlacierClient::SetVaultAccessPolicy, request);
  }
 
  template <typename SetVaultAccessPolicyRequestT = Model::SetVaultAccessPolicyRequest>
  void SetVaultAccessPolicyAsync(const SetVaultAccessPolicyRequestT& request, const SetVaultAccessPolicyResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GlacierClient::SetVaultAccessPolicy, request, handler, context);
  }
 
  virtual Model::SetVaultNotificationsOutcome SetVaultNotifications(const Model::SetVaultNotificationsRequest& request) const;
 
  template <typename SetVaultNotificationsRequestT = Model::SetVaultNotificationsRequest>
  Model::SetVaultNotificationsOutcomeCallable SetVaultNotificationsCallable(const SetVaultNotificationsRequestT& request) const {
    return SubmitCallable(&GlacierClient::SetVaultNotifications, request);
  }
 
  template <typename SetVaultNotificationsRequestT = Model::SetVaultNotificationsRequest>
  void SetVaultNotificationsAsync(const SetVaultNotificationsRequestT& request, const SetVaultNotificationsResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GlacierClient::SetVaultNotifications, request, handler, context);
  }
 
  virtual Model::UploadArchiveOutcome UploadArchive(const Model::UploadArchiveRequest& request) const;
 
  template <typename UploadArchiveRequestT = Model::UploadArchiveRequest>
  Model::UploadArchiveOutcomeCallable UploadArchiveCallable(const UploadArchiveRequestT& request) const {
    return SubmitCallable(&GlacierClient::UploadArchive, request);
  }
 
  template <typename UploadArchiveRequestT = Model::UploadArchiveRequest>
  void UploadArchiveAsync(const UploadArchiveRequestT& request, const UploadArchiveResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GlacierClient::UploadArchive, request, handler, context);
  }
 
  virtual Model::UploadMultipartPartOutcome UploadMultipartPart(const Model::UploadMultipartPartRequest& request) const;
 
  template <typename UploadMultipartPartRequestT = Model::UploadMultipartPartRequest>
  Model::UploadMultipartPartOutcomeCallable UploadMultipartPartCallable(const UploadMultipartPartRequestT& request) const {
    return SubmitCallable(&GlacierClient::UploadMultipartPart, request);
  }
 
  template <typename UploadMultipartPartRequestT = Model::UploadMultipartPartRequest>
  void UploadMultipartPartAsync(const UploadMultipartPartRequestT& request, const UploadMultipartPartResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GlacierClient::UploadMultipartPart, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<GlacierEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<GlacierClient>;
  void init(const GlacierClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, GlacierError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request,
                                                const std::function<void(Aws::Endpoint::ResolveEndpointOutcome&)>& resolveUri,
                                                Aws::Http::HttpMethod httpMethod) const;
 
  GlacierClientConfiguration m_clientConfiguration;
  std::shared_ptr<GlacierEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace Glacier
}  // namespace Aws