AmplifyBackendClient.h

 
#pragma once
#include <aws/amplifybackend/AmplifyBackend_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/amplifybackend/AmplifyBackendServiceClientModel.h>
 
namespace Aws
{
namespace AmplifyBackend
{
  class AWS_AMPLIFYBACKEND_API AmplifyBackendClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<AmplifyBackendClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef AmplifyBackendClientConfiguration ClientConfigurationType;
      typedef AmplifyBackendEndpointProvider EndpointProviderType;
 
        AmplifyBackendClient(const Aws::AmplifyBackend::AmplifyBackendClientConfiguration& clientConfiguration = Aws::AmplifyBackend::AmplifyBackendClientConfiguration(),
                             std::shared_ptr<AmplifyBackendEndpointProviderBase> endpointProvider = nullptr);
 
        AmplifyBackendClient(const Aws::Auth::AWSCredentials& credentials,
                             std::shared_ptr<AmplifyBackendEndpointProviderBase> endpointProvider = nullptr,
                             const Aws::AmplifyBackend::AmplifyBackendClientConfiguration& clientConfiguration = Aws::AmplifyBackend::AmplifyBackendClientConfiguration());
 
        AmplifyBackendClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                             std::shared_ptr<AmplifyBackendEndpointProviderBase> endpointProvider = nullptr,
                             const Aws::AmplifyBackend::AmplifyBackendClientConfiguration& clientConfiguration = Aws::AmplifyBackend::AmplifyBackendClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        AmplifyBackendClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        AmplifyBackendClient(const Aws::Auth::AWSCredentials& credentials,
                             const Aws::Client::ClientConfiguration& clientConfiguration);
 
        AmplifyBackendClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                             const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~AmplifyBackendClient();
 
        virtual Model::CloneBackendOutcome CloneBackend(const Model::CloneBackendRequest& request) const;
 
        template<typename CloneBackendRequestT = Model::CloneBackendRequest>
        Model::CloneBackendOutcomeCallable CloneBackendCallable(const CloneBackendRequestT& request) const
        {
            return SubmitCallable(&AmplifyBackendClient::CloneBackend, request);
        }
 
        template<typename CloneBackendRequestT = Model::CloneBackendRequest>
        void CloneBackendAsync(const CloneBackendRequestT& request, const CloneBackendResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AmplifyBackendClient::CloneBackend, request, handler, context);
        }
 
        virtual Model::CreateBackendOutcome CreateBackend(const Model::CreateBackendRequest& request) const;
 
        template<typename CreateBackendRequestT = Model::CreateBackendRequest>
        Model::CreateBackendOutcomeCallable CreateBackendCallable(const CreateBackendRequestT& request) const
        {
            return SubmitCallable(&AmplifyBackendClient::CreateBackend, request);
        }
 
        template<typename CreateBackendRequestT = Model::CreateBackendRequest>
        void CreateBackendAsync(const CreateBackendRequestT& request, const CreateBackendResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AmplifyBackendClient::CreateBackend, request, handler, context);
        }
 
        virtual Model::CreateBackendAPIOutcome CreateBackendAPI(const Model::CreateBackendAPIRequest& request) const;
 
        template<typename CreateBackendAPIRequestT = Model::CreateBackendAPIRequest>
        Model::CreateBackendAPIOutcomeCallable CreateBackendAPICallable(const CreateBackendAPIRequestT& request) const
        {
            return SubmitCallable(&AmplifyBackendClient::CreateBackendAPI, request);
        }
 
        template<typename CreateBackendAPIRequestT = Model::CreateBackendAPIRequest>
        void CreateBackendAPIAsync(const CreateBackendAPIRequestT& request, const CreateBackendAPIResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AmplifyBackendClient::CreateBackendAPI, request, handler, context);
        }
 
        virtual Model::CreateBackendAuthOutcome CreateBackendAuth(const Model::CreateBackendAuthRequest& request) const;
 
        template<typename CreateBackendAuthRequestT = Model::CreateBackendAuthRequest>
        Model::CreateBackendAuthOutcomeCallable CreateBackendAuthCallable(const CreateBackendAuthRequestT& request) const
        {
            return SubmitCallable(&AmplifyBackendClient::CreateBackendAuth, request);
        }
 
        template<typename CreateBackendAuthRequestT = Model::CreateBackendAuthRequest>
        void CreateBackendAuthAsync(const CreateBackendAuthRequestT& request, const CreateBackendAuthResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AmplifyBackendClient::CreateBackendAuth, request, handler, context);
        }
 
        virtual Model::CreateBackendConfigOutcome CreateBackendConfig(const Model::CreateBackendConfigRequest& request) const;
 
        template<typename CreateBackendConfigRequestT = Model::CreateBackendConfigRequest>
        Model::CreateBackendConfigOutcomeCallable CreateBackendConfigCallable(const CreateBackendConfigRequestT& request) const
        {
            return SubmitCallable(&AmplifyBackendClient::CreateBackendConfig, request);
        }
 
        template<typename CreateBackendConfigRequestT = Model::CreateBackendConfigRequest>
        void CreateBackendConfigAsync(const CreateBackendConfigRequestT& request, const CreateBackendConfigResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AmplifyBackendClient::CreateBackendConfig, request, handler, context);
        }
 
        virtual Model::CreateBackendStorageOutcome CreateBackendStorage(const Model::CreateBackendStorageRequest& request) const;
 
        template<typename CreateBackendStorageRequestT = Model::CreateBackendStorageRequest>
        Model::CreateBackendStorageOutcomeCallable CreateBackendStorageCallable(const CreateBackendStorageRequestT& request) const
        {
            return SubmitCallable(&AmplifyBackendClient::CreateBackendStorage, request);
        }
 
        template<typename CreateBackendStorageRequestT = Model::CreateBackendStorageRequest>
        void CreateBackendStorageAsync(const CreateBackendStorageRequestT& request, const CreateBackendStorageResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AmplifyBackendClient::CreateBackendStorage, request, handler, context);
        }
 
        virtual Model::CreateTokenOutcome CreateToken(const Model::CreateTokenRequest& request) const;
 
        template<typename CreateTokenRequestT = Model::CreateTokenRequest>
        Model::CreateTokenOutcomeCallable CreateTokenCallable(const CreateTokenRequestT& request) const
        {
            return SubmitCallable(&AmplifyBackendClient::CreateToken, request);
        }
 
        template<typename CreateTokenRequestT = Model::CreateTokenRequest>
        void CreateTokenAsync(const CreateTokenRequestT& request, const CreateTokenResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AmplifyBackendClient::CreateToken, request, handler, context);
        }
 
        virtual Model::DeleteBackendOutcome DeleteBackend(const Model::DeleteBackendRequest& request) const;
 
        template<typename DeleteBackendRequestT = Model::DeleteBackendRequest>
        Model::DeleteBackendOutcomeCallable DeleteBackendCallable(const DeleteBackendRequestT& request) const
        {
            return SubmitCallable(&AmplifyBackendClient::DeleteBackend, request);
        }
 
        template<typename DeleteBackendRequestT = Model::DeleteBackendRequest>
        void DeleteBackendAsync(const DeleteBackendRequestT& request, const DeleteBackendResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AmplifyBackendClient::DeleteBackend, request, handler, context);
        }
 
        virtual Model::DeleteBackendAPIOutcome DeleteBackendAPI(const Model::DeleteBackendAPIRequest& request) const;
 
        template<typename DeleteBackendAPIRequestT = Model::DeleteBackendAPIRequest>
        Model::DeleteBackendAPIOutcomeCallable DeleteBackendAPICallable(const DeleteBackendAPIRequestT& request) const
        {
            return SubmitCallable(&AmplifyBackendClient::DeleteBackendAPI, request);
        }
 
        template<typename DeleteBackendAPIRequestT = Model::DeleteBackendAPIRequest>
        void DeleteBackendAPIAsync(const DeleteBackendAPIRequestT& request, const DeleteBackendAPIResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AmplifyBackendClient::DeleteBackendAPI, request, handler, context);
        }
 
        virtual Model::DeleteBackendAuthOutcome DeleteBackendAuth(const Model::DeleteBackendAuthRequest& request) const;
 
        template<typename DeleteBackendAuthRequestT = Model::DeleteBackendAuthRequest>
        Model::DeleteBackendAuthOutcomeCallable DeleteBackendAuthCallable(const DeleteBackendAuthRequestT& request) const
        {
            return SubmitCallable(&AmplifyBackendClient::DeleteBackendAuth, request);
        }
 
        template<typename DeleteBackendAuthRequestT = Model::DeleteBackendAuthRequest>
        void DeleteBackendAuthAsync(const DeleteBackendAuthRequestT& request, const DeleteBackendAuthResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AmplifyBackendClient::DeleteBackendAuth, request, handler, context);
        }
 
        virtual Model::DeleteBackendStorageOutcome DeleteBackendStorage(const Model::DeleteBackendStorageRequest& request) const;
 
        template<typename DeleteBackendStorageRequestT = Model::DeleteBackendStorageRequest>
        Model::DeleteBackendStorageOutcomeCallable DeleteBackendStorageCallable(const DeleteBackendStorageRequestT& request) const
        {
            return SubmitCallable(&AmplifyBackendClient::DeleteBackendStorage, request);
        }
 
        template<typename DeleteBackendStorageRequestT = Model::DeleteBackendStorageRequest>
        void DeleteBackendStorageAsync(const DeleteBackendStorageRequestT& request, const DeleteBackendStorageResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AmplifyBackendClient::DeleteBackendStorage, request, handler, context);
        }
 
        virtual Model::DeleteTokenOutcome DeleteToken(const Model::DeleteTokenRequest& request) const;
 
        template<typename DeleteTokenRequestT = Model::DeleteTokenRequest>
        Model::DeleteTokenOutcomeCallable DeleteTokenCallable(const DeleteTokenRequestT& request) const
        {
            return SubmitCallable(&AmplifyBackendClient::DeleteToken, request);
        }
 
        template<typename DeleteTokenRequestT = Model::DeleteTokenRequest>
        void DeleteTokenAsync(const DeleteTokenRequestT& request, const DeleteTokenResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AmplifyBackendClient::DeleteToken, request, handler, context);
        }
 
        virtual Model::GenerateBackendAPIModelsOutcome GenerateBackendAPIModels(const Model::GenerateBackendAPIModelsRequest& request) const;
 
        template<typename GenerateBackendAPIModelsRequestT = Model::GenerateBackendAPIModelsRequest>
        Model::GenerateBackendAPIModelsOutcomeCallable GenerateBackendAPIModelsCallable(const GenerateBackendAPIModelsRequestT& request) const
        {
            return SubmitCallable(&AmplifyBackendClient::GenerateBackendAPIModels, request);
        }
 
        template<typename GenerateBackendAPIModelsRequestT = Model::GenerateBackendAPIModelsRequest>
        void GenerateBackendAPIModelsAsync(const GenerateBackendAPIModelsRequestT& request, const GenerateBackendAPIModelsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AmplifyBackendClient::GenerateBackendAPIModels, request, handler, context);
        }
 
        virtual Model::GetBackendOutcome GetBackend(const Model::GetBackendRequest& request) const;
 
        template<typename GetBackendRequestT = Model::GetBackendRequest>
        Model::GetBackendOutcomeCallable GetBackendCallable(const GetBackendRequestT& request) const
        {
            return SubmitCallable(&AmplifyBackendClient::GetBackend, request);
        }
 
        template<typename GetBackendRequestT = Model::GetBackendRequest>
        void GetBackendAsync(const GetBackendRequestT& request, const GetBackendResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AmplifyBackendClient::GetBackend, request, handler, context);
        }
 
        virtual Model::GetBackendAPIOutcome GetBackendAPI(const Model::GetBackendAPIRequest& request) const;
 
        template<typename GetBackendAPIRequestT = Model::GetBackendAPIRequest>
        Model::GetBackendAPIOutcomeCallable GetBackendAPICallable(const GetBackendAPIRequestT& request) const
        {
            return SubmitCallable(&AmplifyBackendClient::GetBackendAPI, request);
        }
 
        template<typename GetBackendAPIRequestT = Model::GetBackendAPIRequest>
        void GetBackendAPIAsync(const GetBackendAPIRequestT& request, const GetBackendAPIResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AmplifyBackendClient::GetBackendAPI, request, handler, context);
        }
 
        virtual Model::GetBackendAPIModelsOutcome GetBackendAPIModels(const Model::GetBackendAPIModelsRequest& request) const;
 
        template<typename GetBackendAPIModelsRequestT = Model::GetBackendAPIModelsRequest>
        Model::GetBackendAPIModelsOutcomeCallable GetBackendAPIModelsCallable(const GetBackendAPIModelsRequestT& request) const
        {
            return SubmitCallable(&AmplifyBackendClient::GetBackendAPIModels, request);
        }
 
        template<typename GetBackendAPIModelsRequestT = Model::GetBackendAPIModelsRequest>
        void GetBackendAPIModelsAsync(const GetBackendAPIModelsRequestT& request, const GetBackendAPIModelsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AmplifyBackendClient::GetBackendAPIModels, request, handler, context);
        }
 
        virtual Model::GetBackendAuthOutcome GetBackendAuth(const Model::GetBackendAuthRequest& request) const;
 
        template<typename GetBackendAuthRequestT = Model::GetBackendAuthRequest>
        Model::GetBackendAuthOutcomeCallable GetBackendAuthCallable(const GetBackendAuthRequestT& request) const
        {
            return SubmitCallable(&AmplifyBackendClient::GetBackendAuth, request);
        }
 
        template<typename GetBackendAuthRequestT = Model::GetBackendAuthRequest>
        void GetBackendAuthAsync(const GetBackendAuthRequestT& request, const GetBackendAuthResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AmplifyBackendClient::GetBackendAuth, request, handler, context);
        }
 
        virtual Model::GetBackendJobOutcome GetBackendJob(const Model::GetBackendJobRequest& request) const;
 
        template<typename GetBackendJobRequestT = Model::GetBackendJobRequest>
        Model::GetBackendJobOutcomeCallable GetBackendJobCallable(const GetBackendJobRequestT& request) const
        {
            return SubmitCallable(&AmplifyBackendClient::GetBackendJob, request);
        }
 
        template<typename GetBackendJobRequestT = Model::GetBackendJobRequest>
        void GetBackendJobAsync(const GetBackendJobRequestT& request, const GetBackendJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AmplifyBackendClient::GetBackendJob, request, handler, context);
        }
 
        virtual Model::GetBackendStorageOutcome GetBackendStorage(const Model::GetBackendStorageRequest& request) const;
 
        template<typename GetBackendStorageRequestT = Model::GetBackendStorageRequest>
        Model::GetBackendStorageOutcomeCallable GetBackendStorageCallable(const GetBackendStorageRequestT& request) const
        {
            return SubmitCallable(&AmplifyBackendClient::GetBackendStorage, request);
        }
 
        template<typename GetBackendStorageRequestT = Model::GetBackendStorageRequest>
        void GetBackendStorageAsync(const GetBackendStorageRequestT& request, const GetBackendStorageResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AmplifyBackendClient::GetBackendStorage, request, handler, context);
        }
 
        virtual Model::GetTokenOutcome GetToken(const Model::GetTokenRequest& request) const;
 
        template<typename GetTokenRequestT = Model::GetTokenRequest>
        Model::GetTokenOutcomeCallable GetTokenCallable(const GetTokenRequestT& request) const
        {
            return SubmitCallable(&AmplifyBackendClient::GetToken, request);
        }
 
        template<typename GetTokenRequestT = Model::GetTokenRequest>
        void GetTokenAsync(const GetTokenRequestT& request, const GetTokenResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AmplifyBackendClient::GetToken, request, handler, context);
        }
 
        virtual Model::ImportBackendAuthOutcome ImportBackendAuth(const Model::ImportBackendAuthRequest& request) const;
 
        template<typename ImportBackendAuthRequestT = Model::ImportBackendAuthRequest>
        Model::ImportBackendAuthOutcomeCallable ImportBackendAuthCallable(const ImportBackendAuthRequestT& request) const
        {
            return SubmitCallable(&AmplifyBackendClient::ImportBackendAuth, request);
        }
 
        template<typename ImportBackendAuthRequestT = Model::ImportBackendAuthRequest>
        void ImportBackendAuthAsync(const ImportBackendAuthRequestT& request, const ImportBackendAuthResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AmplifyBackendClient::ImportBackendAuth, request, handler, context);
        }
 
        virtual Model::ImportBackendStorageOutcome ImportBackendStorage(const Model::ImportBackendStorageRequest& request) const;
 
        template<typename ImportBackendStorageRequestT = Model::ImportBackendStorageRequest>
        Model::ImportBackendStorageOutcomeCallable ImportBackendStorageCallable(const ImportBackendStorageRequestT& request) const
        {
            return SubmitCallable(&AmplifyBackendClient::ImportBackendStorage, request);
        }
 
        template<typename ImportBackendStorageRequestT = Model::ImportBackendStorageRequest>
        void ImportBackendStorageAsync(const ImportBackendStorageRequestT& request, const ImportBackendStorageResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AmplifyBackendClient::ImportBackendStorage, request, handler, context);
        }
 
        virtual Model::ListBackendJobsOutcome ListBackendJobs(const Model::ListBackendJobsRequest& request) const;
 
        template<typename ListBackendJobsRequestT = Model::ListBackendJobsRequest>
        Model::ListBackendJobsOutcomeCallable ListBackendJobsCallable(const ListBackendJobsRequestT& request) const
        {
            return SubmitCallable(&AmplifyBackendClient::ListBackendJobs, request);
        }
 
        template<typename ListBackendJobsRequestT = Model::ListBackendJobsRequest>
        void ListBackendJobsAsync(const ListBackendJobsRequestT& request, const ListBackendJobsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AmplifyBackendClient::ListBackendJobs, request, handler, context);
        }
 
        virtual Model::ListS3BucketsOutcome ListS3Buckets(const Model::ListS3BucketsRequest& request = {}) const;
 
        template<typename ListS3BucketsRequestT = Model::ListS3BucketsRequest>
        Model::ListS3BucketsOutcomeCallable ListS3BucketsCallable(const ListS3BucketsRequestT& request = {}) const
        {
            return SubmitCallable(&AmplifyBackendClient::ListS3Buckets, request);
        }
 
        template<typename ListS3BucketsRequestT = Model::ListS3BucketsRequest>
        void ListS3BucketsAsync(const ListS3BucketsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListS3BucketsRequestT& request = {}) const
        {
            return SubmitAsync(&AmplifyBackendClient::ListS3Buckets, request, handler, context);
        }
 
        virtual Model::RemoveAllBackendsOutcome RemoveAllBackends(const Model::RemoveAllBackendsRequest& request) const;
 
        template<typename RemoveAllBackendsRequestT = Model::RemoveAllBackendsRequest>
        Model::RemoveAllBackendsOutcomeCallable RemoveAllBackendsCallable(const RemoveAllBackendsRequestT& request) const
        {
            return SubmitCallable(&AmplifyBackendClient::RemoveAllBackends, request);
        }
 
        template<typename RemoveAllBackendsRequestT = Model::RemoveAllBackendsRequest>
        void RemoveAllBackendsAsync(const RemoveAllBackendsRequestT& request, const RemoveAllBackendsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AmplifyBackendClient::RemoveAllBackends, request, handler, context);
        }
 
        virtual Model::RemoveBackendConfigOutcome RemoveBackendConfig(const Model::RemoveBackendConfigRequest& request) const;
 
        template<typename RemoveBackendConfigRequestT = Model::RemoveBackendConfigRequest>
        Model::RemoveBackendConfigOutcomeCallable RemoveBackendConfigCallable(const RemoveBackendConfigRequestT& request) const
        {
            return SubmitCallable(&AmplifyBackendClient::RemoveBackendConfig, request);
        }
 
        template<typename RemoveBackendConfigRequestT = Model::RemoveBackendConfigRequest>
        void RemoveBackendConfigAsync(const RemoveBackendConfigRequestT& request, const RemoveBackendConfigResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AmplifyBackendClient::RemoveBackendConfig, request, handler, context);
        }
 
        virtual Model::UpdateBackendAPIOutcome UpdateBackendAPI(const Model::UpdateBackendAPIRequest& request) const;
 
        template<typename UpdateBackendAPIRequestT = Model::UpdateBackendAPIRequest>
        Model::UpdateBackendAPIOutcomeCallable UpdateBackendAPICallable(const UpdateBackendAPIRequestT& request) const
        {
            return SubmitCallable(&AmplifyBackendClient::UpdateBackendAPI, request);
        }
 
        template<typename UpdateBackendAPIRequestT = Model::UpdateBackendAPIRequest>
        void UpdateBackendAPIAsync(const UpdateBackendAPIRequestT& request, const UpdateBackendAPIResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AmplifyBackendClient::UpdateBackendAPI, request, handler, context);
        }
 
        virtual Model::UpdateBackendAuthOutcome UpdateBackendAuth(const Model::UpdateBackendAuthRequest& request) const;
 
        template<typename UpdateBackendAuthRequestT = Model::UpdateBackendAuthRequest>
        Model::UpdateBackendAuthOutcomeCallable UpdateBackendAuthCallable(const UpdateBackendAuthRequestT& request) const
        {
            return SubmitCallable(&AmplifyBackendClient::UpdateBackendAuth, request);
        }
 
        template<typename UpdateBackendAuthRequestT = Model::UpdateBackendAuthRequest>
        void UpdateBackendAuthAsync(const UpdateBackendAuthRequestT& request, const UpdateBackendAuthResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AmplifyBackendClient::UpdateBackendAuth, request, handler, context);
        }
 
        virtual Model::UpdateBackendConfigOutcome UpdateBackendConfig(const Model::UpdateBackendConfigRequest& request) const;
 
        template<typename UpdateBackendConfigRequestT = Model::UpdateBackendConfigRequest>
        Model::UpdateBackendConfigOutcomeCallable UpdateBackendConfigCallable(const UpdateBackendConfigRequestT& request) const
        {
            return SubmitCallable(&AmplifyBackendClient::UpdateBackendConfig, request);
        }
 
        template<typename UpdateBackendConfigRequestT = Model::UpdateBackendConfigRequest>
        void UpdateBackendConfigAsync(const UpdateBackendConfigRequestT& request, const UpdateBackendConfigResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AmplifyBackendClient::UpdateBackendConfig, request, handler, context);
        }
 
        virtual Model::UpdateBackendJobOutcome UpdateBackendJob(const Model::UpdateBackendJobRequest& request) const;
 
        template<typename UpdateBackendJobRequestT = Model::UpdateBackendJobRequest>
        Model::UpdateBackendJobOutcomeCallable UpdateBackendJobCallable(const UpdateBackendJobRequestT& request) const
        {
            return SubmitCallable(&AmplifyBackendClient::UpdateBackendJob, request);
        }
 
        template<typename UpdateBackendJobRequestT = Model::UpdateBackendJobRequest>
        void UpdateBackendJobAsync(const UpdateBackendJobRequestT& request, const UpdateBackendJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AmplifyBackendClient::UpdateBackendJob, request, handler, context);
        }
 
        virtual Model::UpdateBackendStorageOutcome UpdateBackendStorage(const Model::UpdateBackendStorageRequest& request) const;
 
        template<typename UpdateBackendStorageRequestT = Model::UpdateBackendStorageRequest>
        Model::UpdateBackendStorageOutcomeCallable UpdateBackendStorageCallable(const UpdateBackendStorageRequestT& request) const
        {
            return SubmitCallable(&AmplifyBackendClient::UpdateBackendStorage, request);
        }
 
        template<typename UpdateBackendStorageRequestT = Model::UpdateBackendStorageRequest>
        void UpdateBackendStorageAsync(const UpdateBackendStorageRequestT& request, const UpdateBackendStorageResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AmplifyBackendClient::UpdateBackendStorage, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<AmplifyBackendEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<AmplifyBackendClient>;
      void init(const AmplifyBackendClientConfiguration& clientConfiguration);
 
      AmplifyBackendClientConfiguration m_clientConfiguration;
      std::shared_ptr<AmplifyBackendEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace AmplifyBackend
} // namespace Aws