AmplifyBackendClient.h

 
#pragma once
#include <aws/amplifybackend/AmplifyBackendServiceClientModel.h>
#include <aws/amplifybackend/AmplifyBackend_EXPORTS.h>
#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>
 
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