GlacierClient.h

 
#pragma once
#include <aws/glacier/Glacier_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/glacier/GlacierServiceClientModel.h>
 
namespace Aws
{
namespace Glacier
{
  class AWS_GLACIER_API GlacierClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<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);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<GlacierEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<GlacierClient>;
      void init(const GlacierClientConfiguration& clientConfiguration);
 
      GlacierClientConfiguration m_clientConfiguration;
      std::shared_ptr<GlacierEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace Glacier
} // namespace Aws