AmplifyClient.h

 
#pragma once
#include <aws/amplify/AmplifyServiceClientModel.h>
#include <aws/amplify/Amplify_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 Amplify {
class AWS_AMPLIFY_API AmplifyClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<AmplifyClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef AmplifyClientConfiguration ClientConfigurationType;
  typedef AmplifyEndpointProvider EndpointProviderType;
 
  AmplifyClient(const Aws::Amplify::AmplifyClientConfiguration& clientConfiguration = Aws::Amplify::AmplifyClientConfiguration(),
                std::shared_ptr<AmplifyEndpointProviderBase> endpointProvider = nullptr);
 
  AmplifyClient(const Aws::Auth::AWSCredentials& credentials, std::shared_ptr<AmplifyEndpointProviderBase> endpointProvider = nullptr,
                const Aws::Amplify::AmplifyClientConfiguration& clientConfiguration = Aws::Amplify::AmplifyClientConfiguration());
 
  AmplifyClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                std::shared_ptr<AmplifyEndpointProviderBase> endpointProvider = nullptr,
                const Aws::Amplify::AmplifyClientConfiguration& clientConfiguration = Aws::Amplify::AmplifyClientConfiguration());
 
  /* Legacy constructors due deprecation */
  AmplifyClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  AmplifyClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  AmplifyClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~AmplifyClient();
 
  virtual Model::CreateAppOutcome CreateApp(const Model::CreateAppRequest& request) const;
 
  template <typename CreateAppRequestT = Model::CreateAppRequest>
  Model::CreateAppOutcomeCallable CreateAppCallable(const CreateAppRequestT& request) const {
    return SubmitCallable(&AmplifyClient::CreateApp, request);
  }
 
  template <typename CreateAppRequestT = Model::CreateAppRequest>
  void CreateAppAsync(const CreateAppRequestT& request, const CreateAppResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AmplifyClient::CreateApp, request, handler, context);
  }
 
  virtual Model::CreateBackendEnvironmentOutcome CreateBackendEnvironment(const Model::CreateBackendEnvironmentRequest& request) const;
 
  template <typename CreateBackendEnvironmentRequestT = Model::CreateBackendEnvironmentRequest>
  Model::CreateBackendEnvironmentOutcomeCallable CreateBackendEnvironmentCallable(const CreateBackendEnvironmentRequestT& request) const {
    return SubmitCallable(&AmplifyClient::CreateBackendEnvironment, request);
  }
 
  template <typename CreateBackendEnvironmentRequestT = Model::CreateBackendEnvironmentRequest>
  void CreateBackendEnvironmentAsync(const CreateBackendEnvironmentRequestT& request,
                                     const CreateBackendEnvironmentResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AmplifyClient::CreateBackendEnvironment, request, handler, context);
  }
 
  virtual Model::CreateBranchOutcome CreateBranch(const Model::CreateBranchRequest& request) const;
 
  template <typename CreateBranchRequestT = Model::CreateBranchRequest>
  Model::CreateBranchOutcomeCallable CreateBranchCallable(const CreateBranchRequestT& request) const {
    return SubmitCallable(&AmplifyClient::CreateBranch, request);
  }
 
  template <typename CreateBranchRequestT = Model::CreateBranchRequest>
  void CreateBranchAsync(const CreateBranchRequestT& request, const CreateBranchResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AmplifyClient::CreateBranch, request, handler, context);
  }
 
  virtual Model::CreateDeploymentOutcome CreateDeployment(const Model::CreateDeploymentRequest& request) const;
 
  template <typename CreateDeploymentRequestT = Model::CreateDeploymentRequest>
  Model::CreateDeploymentOutcomeCallable CreateDeploymentCallable(const CreateDeploymentRequestT& request) const {
    return SubmitCallable(&AmplifyClient::CreateDeployment, request);
  }
 
  template <typename CreateDeploymentRequestT = Model::CreateDeploymentRequest>
  void CreateDeploymentAsync(const CreateDeploymentRequestT& request, const CreateDeploymentResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AmplifyClient::CreateDeployment, request, handler, context);
  }
 
  virtual Model::CreateDomainAssociationOutcome CreateDomainAssociation(const Model::CreateDomainAssociationRequest& request) const;
 
  template <typename CreateDomainAssociationRequestT = Model::CreateDomainAssociationRequest>
  Model::CreateDomainAssociationOutcomeCallable CreateDomainAssociationCallable(const CreateDomainAssociationRequestT& request) const {
    return SubmitCallable(&AmplifyClient::CreateDomainAssociation, request);
  }
 
  template <typename CreateDomainAssociationRequestT = Model::CreateDomainAssociationRequest>
  void CreateDomainAssociationAsync(const CreateDomainAssociationRequestT& request,
                                    const CreateDomainAssociationResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AmplifyClient::CreateDomainAssociation, request, handler, context);
  }
 
  virtual Model::CreateWebhookOutcome CreateWebhook(const Model::CreateWebhookRequest& request) const;
 
  template <typename CreateWebhookRequestT = Model::CreateWebhookRequest>
  Model::CreateWebhookOutcomeCallable CreateWebhookCallable(const CreateWebhookRequestT& request) const {
    return SubmitCallable(&AmplifyClient::CreateWebhook, request);
  }
 
  template <typename CreateWebhookRequestT = Model::CreateWebhookRequest>
  void CreateWebhookAsync(const CreateWebhookRequestT& request, const CreateWebhookResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AmplifyClient::CreateWebhook, request, handler, context);
  }
 
  virtual Model::DeleteAppOutcome DeleteApp(const Model::DeleteAppRequest& request) const;
 
  template <typename DeleteAppRequestT = Model::DeleteAppRequest>
  Model::DeleteAppOutcomeCallable DeleteAppCallable(const DeleteAppRequestT& request) const {
    return SubmitCallable(&AmplifyClient::DeleteApp, request);
  }
 
  template <typename DeleteAppRequestT = Model::DeleteAppRequest>
  void DeleteAppAsync(const DeleteAppRequestT& request, const DeleteAppResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AmplifyClient::DeleteApp, request, handler, context);
  }
 
  virtual Model::DeleteBackendEnvironmentOutcome DeleteBackendEnvironment(const Model::DeleteBackendEnvironmentRequest& request) const;
 
  template <typename DeleteBackendEnvironmentRequestT = Model::DeleteBackendEnvironmentRequest>
  Model::DeleteBackendEnvironmentOutcomeCallable DeleteBackendEnvironmentCallable(const DeleteBackendEnvironmentRequestT& request) const {
    return SubmitCallable(&AmplifyClient::DeleteBackendEnvironment, request);
  }
 
  template <typename DeleteBackendEnvironmentRequestT = Model::DeleteBackendEnvironmentRequest>
  void DeleteBackendEnvironmentAsync(const DeleteBackendEnvironmentRequestT& request,
                                     const DeleteBackendEnvironmentResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AmplifyClient::DeleteBackendEnvironment, request, handler, context);
  }
 
  virtual Model::DeleteBranchOutcome DeleteBranch(const Model::DeleteBranchRequest& request) const;
 
  template <typename DeleteBranchRequestT = Model::DeleteBranchRequest>
  Model::DeleteBranchOutcomeCallable DeleteBranchCallable(const DeleteBranchRequestT& request) const {
    return SubmitCallable(&AmplifyClient::DeleteBranch, request);
  }
 
  template <typename DeleteBranchRequestT = Model::DeleteBranchRequest>
  void DeleteBranchAsync(const DeleteBranchRequestT& request, const DeleteBranchResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AmplifyClient::DeleteBranch, request, handler, context);
  }
 
  virtual Model::DeleteDomainAssociationOutcome DeleteDomainAssociation(const Model::DeleteDomainAssociationRequest& request) const;
 
  template <typename DeleteDomainAssociationRequestT = Model::DeleteDomainAssociationRequest>
  Model::DeleteDomainAssociationOutcomeCallable DeleteDomainAssociationCallable(const DeleteDomainAssociationRequestT& request) const {
    return SubmitCallable(&AmplifyClient::DeleteDomainAssociation, request);
  }
 
  template <typename DeleteDomainAssociationRequestT = Model::DeleteDomainAssociationRequest>
  void DeleteDomainAssociationAsync(const DeleteDomainAssociationRequestT& request,
                                    const DeleteDomainAssociationResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AmplifyClient::DeleteDomainAssociation, request, handler, context);
  }
 
  virtual Model::DeleteJobOutcome DeleteJob(const Model::DeleteJobRequest& request) const;
 
  template <typename DeleteJobRequestT = Model::DeleteJobRequest>
  Model::DeleteJobOutcomeCallable DeleteJobCallable(const DeleteJobRequestT& request) const {
    return SubmitCallable(&AmplifyClient::DeleteJob, request);
  }
 
  template <typename DeleteJobRequestT = Model::DeleteJobRequest>
  void DeleteJobAsync(const DeleteJobRequestT& request, const DeleteJobResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AmplifyClient::DeleteJob, request, handler, context);
  }
 
  virtual Model::DeleteWebhookOutcome DeleteWebhook(const Model::DeleteWebhookRequest& request) const;
 
  template <typename DeleteWebhookRequestT = Model::DeleteWebhookRequest>
  Model::DeleteWebhookOutcomeCallable DeleteWebhookCallable(const DeleteWebhookRequestT& request) const {
    return SubmitCallable(&AmplifyClient::DeleteWebhook, request);
  }
 
  template <typename DeleteWebhookRequestT = Model::DeleteWebhookRequest>
  void DeleteWebhookAsync(const DeleteWebhookRequestT& request, const DeleteWebhookResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AmplifyClient::DeleteWebhook, request, handler, context);
  }
 
  virtual Model::GenerateAccessLogsOutcome GenerateAccessLogs(const Model::GenerateAccessLogsRequest& request) const;
 
  template <typename GenerateAccessLogsRequestT = Model::GenerateAccessLogsRequest>
  Model::GenerateAccessLogsOutcomeCallable GenerateAccessLogsCallable(const GenerateAccessLogsRequestT& request) const {
    return SubmitCallable(&AmplifyClient::GenerateAccessLogs, request);
  }
 
  template <typename GenerateAccessLogsRequestT = Model::GenerateAccessLogsRequest>
  void GenerateAccessLogsAsync(const GenerateAccessLogsRequestT& request, const GenerateAccessLogsResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AmplifyClient::GenerateAccessLogs, request, handler, context);
  }
 
  virtual Model::GetAppOutcome GetApp(const Model::GetAppRequest& request) const;
 
  template <typename GetAppRequestT = Model::GetAppRequest>
  Model::GetAppOutcomeCallable GetAppCallable(const GetAppRequestT& request) const {
    return SubmitCallable(&AmplifyClient::GetApp, request);
  }
 
  template <typename GetAppRequestT = Model::GetAppRequest>
  void GetAppAsync(const GetAppRequestT& request, const GetAppResponseReceivedHandler& handler,
                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AmplifyClient::GetApp, request, handler, context);
  }
 
  virtual Model::GetArtifactUrlOutcome GetArtifactUrl(const Model::GetArtifactUrlRequest& request) const;
 
  template <typename GetArtifactUrlRequestT = Model::GetArtifactUrlRequest>
  Model::GetArtifactUrlOutcomeCallable GetArtifactUrlCallable(const GetArtifactUrlRequestT& request) const {
    return SubmitCallable(&AmplifyClient::GetArtifactUrl, request);
  }
 
  template <typename GetArtifactUrlRequestT = Model::GetArtifactUrlRequest>
  void GetArtifactUrlAsync(const GetArtifactUrlRequestT& request, const GetArtifactUrlResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AmplifyClient::GetArtifactUrl, request, handler, context);
  }
 
  virtual Model::GetBackendEnvironmentOutcome GetBackendEnvironment(const Model::GetBackendEnvironmentRequest& request) const;
 
  template <typename GetBackendEnvironmentRequestT = Model::GetBackendEnvironmentRequest>
  Model::GetBackendEnvironmentOutcomeCallable GetBackendEnvironmentCallable(const GetBackendEnvironmentRequestT& request) const {
    return SubmitCallable(&AmplifyClient::GetBackendEnvironment, request);
  }
 
  template <typename GetBackendEnvironmentRequestT = Model::GetBackendEnvironmentRequest>
  void GetBackendEnvironmentAsync(const GetBackendEnvironmentRequestT& request, const GetBackendEnvironmentResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AmplifyClient::GetBackendEnvironment, request, handler, context);
  }
 
  virtual Model::GetBranchOutcome GetBranch(const Model::GetBranchRequest& request) const;
 
  template <typename GetBranchRequestT = Model::GetBranchRequest>
  Model::GetBranchOutcomeCallable GetBranchCallable(const GetBranchRequestT& request) const {
    return SubmitCallable(&AmplifyClient::GetBranch, request);
  }
 
  template <typename GetBranchRequestT = Model::GetBranchRequest>
  void GetBranchAsync(const GetBranchRequestT& request, const GetBranchResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AmplifyClient::GetBranch, request, handler, context);
  }
 
  virtual Model::GetDomainAssociationOutcome GetDomainAssociation(const Model::GetDomainAssociationRequest& request) const;
 
  template <typename GetDomainAssociationRequestT = Model::GetDomainAssociationRequest>
  Model::GetDomainAssociationOutcomeCallable GetDomainAssociationCallable(const GetDomainAssociationRequestT& request) const {
    return SubmitCallable(&AmplifyClient::GetDomainAssociation, request);
  }
 
  template <typename GetDomainAssociationRequestT = Model::GetDomainAssociationRequest>
  void GetDomainAssociationAsync(const GetDomainAssociationRequestT& request, const GetDomainAssociationResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AmplifyClient::GetDomainAssociation, request, handler, context);
  }
 
  virtual Model::GetJobOutcome GetJob(const Model::GetJobRequest& request) const;
 
  template <typename GetJobRequestT = Model::GetJobRequest>
  Model::GetJobOutcomeCallable GetJobCallable(const GetJobRequestT& request) const {
    return SubmitCallable(&AmplifyClient::GetJob, request);
  }
 
  template <typename GetJobRequestT = Model::GetJobRequest>
  void GetJobAsync(const GetJobRequestT& request, const GetJobResponseReceivedHandler& handler,
                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AmplifyClient::GetJob, request, handler, context);
  }
 
  virtual Model::GetWebhookOutcome GetWebhook(const Model::GetWebhookRequest& request) const;
 
  template <typename GetWebhookRequestT = Model::GetWebhookRequest>
  Model::GetWebhookOutcomeCallable GetWebhookCallable(const GetWebhookRequestT& request) const {
    return SubmitCallable(&AmplifyClient::GetWebhook, request);
  }
 
  template <typename GetWebhookRequestT = Model::GetWebhookRequest>
  void GetWebhookAsync(const GetWebhookRequestT& request, const GetWebhookResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AmplifyClient::GetWebhook, request, handler, context);
  }
 
  virtual Model::ListAppsOutcome ListApps(const Model::ListAppsRequest& request = {}) const;
 
  template <typename ListAppsRequestT = Model::ListAppsRequest>
  Model::ListAppsOutcomeCallable ListAppsCallable(const ListAppsRequestT& request = {}) const {
    return SubmitCallable(&AmplifyClient::ListApps, request);
  }
 
  template <typename ListAppsRequestT = Model::ListAppsRequest>
  void ListAppsAsync(const ListAppsResponseReceivedHandler& handler,
                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                     const ListAppsRequestT& request = {}) const {
    return SubmitAsync(&AmplifyClient::ListApps, request, handler, context);
  }
 
  virtual Model::ListArtifactsOutcome ListArtifacts(const Model::ListArtifactsRequest& request) const;
 
  template <typename ListArtifactsRequestT = Model::ListArtifactsRequest>
  Model::ListArtifactsOutcomeCallable ListArtifactsCallable(const ListArtifactsRequestT& request) const {
    return SubmitCallable(&AmplifyClient::ListArtifacts, request);
  }
 
  template <typename ListArtifactsRequestT = Model::ListArtifactsRequest>
  void ListArtifactsAsync(const ListArtifactsRequestT& request, const ListArtifactsResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AmplifyClient::ListArtifacts, request, handler, context);
  }
 
  virtual Model::ListBackendEnvironmentsOutcome ListBackendEnvironments(const Model::ListBackendEnvironmentsRequest& request) const;
 
  template <typename ListBackendEnvironmentsRequestT = Model::ListBackendEnvironmentsRequest>
  Model::ListBackendEnvironmentsOutcomeCallable ListBackendEnvironmentsCallable(const ListBackendEnvironmentsRequestT& request) const {
    return SubmitCallable(&AmplifyClient::ListBackendEnvironments, request);
  }
 
  template <typename ListBackendEnvironmentsRequestT = Model::ListBackendEnvironmentsRequest>
  void ListBackendEnvironmentsAsync(const ListBackendEnvironmentsRequestT& request,
                                    const ListBackendEnvironmentsResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AmplifyClient::ListBackendEnvironments, request, handler, context);
  }
 
  virtual Model::ListBranchesOutcome ListBranches(const Model::ListBranchesRequest& request) const;
 
  template <typename ListBranchesRequestT = Model::ListBranchesRequest>
  Model::ListBranchesOutcomeCallable ListBranchesCallable(const ListBranchesRequestT& request) const {
    return SubmitCallable(&AmplifyClient::ListBranches, request);
  }
 
  template <typename ListBranchesRequestT = Model::ListBranchesRequest>
  void ListBranchesAsync(const ListBranchesRequestT& request, const ListBranchesResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AmplifyClient::ListBranches, request, handler, context);
  }
 
  virtual Model::ListDomainAssociationsOutcome ListDomainAssociations(const Model::ListDomainAssociationsRequest& request) const;
 
  template <typename ListDomainAssociationsRequestT = Model::ListDomainAssociationsRequest>
  Model::ListDomainAssociationsOutcomeCallable ListDomainAssociationsCallable(const ListDomainAssociationsRequestT& request) const {
    return SubmitCallable(&AmplifyClient::ListDomainAssociations, request);
  }
 
  template <typename ListDomainAssociationsRequestT = Model::ListDomainAssociationsRequest>
  void ListDomainAssociationsAsync(const ListDomainAssociationsRequestT& request,
                                   const ListDomainAssociationsResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AmplifyClient::ListDomainAssociations, 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(&AmplifyClient::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(&AmplifyClient::ListJobs, request, handler, context);
  }
 
  virtual Model::ListTagsForResourceOutcome ListTagsForResource(const Model::ListTagsForResourceRequest& request) const;
 
  template <typename ListTagsForResourceRequestT = Model::ListTagsForResourceRequest>
  Model::ListTagsForResourceOutcomeCallable ListTagsForResourceCallable(const ListTagsForResourceRequestT& request) const {
    return SubmitCallable(&AmplifyClient::ListTagsForResource, request);
  }
 
  template <typename ListTagsForResourceRequestT = Model::ListTagsForResourceRequest>
  void ListTagsForResourceAsync(const ListTagsForResourceRequestT& request, const ListTagsForResourceResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AmplifyClient::ListTagsForResource, request, handler, context);
  }
 
  virtual Model::ListWebhooksOutcome ListWebhooks(const Model::ListWebhooksRequest& request) const;
 
  template <typename ListWebhooksRequestT = Model::ListWebhooksRequest>
  Model::ListWebhooksOutcomeCallable ListWebhooksCallable(const ListWebhooksRequestT& request) const {
    return SubmitCallable(&AmplifyClient::ListWebhooks, request);
  }
 
  template <typename ListWebhooksRequestT = Model::ListWebhooksRequest>
  void ListWebhooksAsync(const ListWebhooksRequestT& request, const ListWebhooksResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AmplifyClient::ListWebhooks, request, handler, context);
  }
 
  virtual Model::StartDeploymentOutcome StartDeployment(const Model::StartDeploymentRequest& request) const;
 
  template <typename StartDeploymentRequestT = Model::StartDeploymentRequest>
  Model::StartDeploymentOutcomeCallable StartDeploymentCallable(const StartDeploymentRequestT& request) const {
    return SubmitCallable(&AmplifyClient::StartDeployment, request);
  }
 
  template <typename StartDeploymentRequestT = Model::StartDeploymentRequest>
  void StartDeploymentAsync(const StartDeploymentRequestT& request, const StartDeploymentResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AmplifyClient::StartDeployment, request, handler, context);
  }
 
  virtual Model::StartJobOutcome StartJob(const Model::StartJobRequest& request) const;
 
  template <typename StartJobRequestT = Model::StartJobRequest>
  Model::StartJobOutcomeCallable StartJobCallable(const StartJobRequestT& request) const {
    return SubmitCallable(&AmplifyClient::StartJob, request);
  }
 
  template <typename StartJobRequestT = Model::StartJobRequest>
  void StartJobAsync(const StartJobRequestT& request, const StartJobResponseReceivedHandler& handler,
                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AmplifyClient::StartJob, request, handler, context);
  }
 
  virtual Model::StopJobOutcome StopJob(const Model::StopJobRequest& request) const;
 
  template <typename StopJobRequestT = Model::StopJobRequest>
  Model::StopJobOutcomeCallable StopJobCallable(const StopJobRequestT& request) const {
    return SubmitCallable(&AmplifyClient::StopJob, request);
  }
 
  template <typename StopJobRequestT = Model::StopJobRequest>
  void StopJobAsync(const StopJobRequestT& request, const StopJobResponseReceivedHandler& handler,
                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AmplifyClient::StopJob, request, handler, context);
  }
 
  virtual Model::TagResourceOutcome TagResource(const Model::TagResourceRequest& request) const;
 
  template <typename TagResourceRequestT = Model::TagResourceRequest>
  Model::TagResourceOutcomeCallable TagResourceCallable(const TagResourceRequestT& request) const {
    return SubmitCallable(&AmplifyClient::TagResource, request);
  }
 
  template <typename TagResourceRequestT = Model::TagResourceRequest>
  void TagResourceAsync(const TagResourceRequestT& request, const TagResourceResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AmplifyClient::TagResource, request, handler, context);
  }
 
  virtual Model::UntagResourceOutcome UntagResource(const Model::UntagResourceRequest& request) const;
 
  template <typename UntagResourceRequestT = Model::UntagResourceRequest>
  Model::UntagResourceOutcomeCallable UntagResourceCallable(const UntagResourceRequestT& request) const {
    return SubmitCallable(&AmplifyClient::UntagResource, request);
  }
 
  template <typename UntagResourceRequestT = Model::UntagResourceRequest>
  void UntagResourceAsync(const UntagResourceRequestT& request, const UntagResourceResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AmplifyClient::UntagResource, request, handler, context);
  }
 
  virtual Model::UpdateAppOutcome UpdateApp(const Model::UpdateAppRequest& request) const;
 
  template <typename UpdateAppRequestT = Model::UpdateAppRequest>
  Model::UpdateAppOutcomeCallable UpdateAppCallable(const UpdateAppRequestT& request) const {
    return SubmitCallable(&AmplifyClient::UpdateApp, request);
  }
 
  template <typename UpdateAppRequestT = Model::UpdateAppRequest>
  void UpdateAppAsync(const UpdateAppRequestT& request, const UpdateAppResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AmplifyClient::UpdateApp, request, handler, context);
  }
 
  virtual Model::UpdateBranchOutcome UpdateBranch(const Model::UpdateBranchRequest& request) const;
 
  template <typename UpdateBranchRequestT = Model::UpdateBranchRequest>
  Model::UpdateBranchOutcomeCallable UpdateBranchCallable(const UpdateBranchRequestT& request) const {
    return SubmitCallable(&AmplifyClient::UpdateBranch, request);
  }
 
  template <typename UpdateBranchRequestT = Model::UpdateBranchRequest>
  void UpdateBranchAsync(const UpdateBranchRequestT& request, const UpdateBranchResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AmplifyClient::UpdateBranch, request, handler, context);
  }
 
  virtual Model::UpdateDomainAssociationOutcome UpdateDomainAssociation(const Model::UpdateDomainAssociationRequest& request) const;
 
  template <typename UpdateDomainAssociationRequestT = Model::UpdateDomainAssociationRequest>
  Model::UpdateDomainAssociationOutcomeCallable UpdateDomainAssociationCallable(const UpdateDomainAssociationRequestT& request) const {
    return SubmitCallable(&AmplifyClient::UpdateDomainAssociation, request);
  }
 
  template <typename UpdateDomainAssociationRequestT = Model::UpdateDomainAssociationRequest>
  void UpdateDomainAssociationAsync(const UpdateDomainAssociationRequestT& request,
                                    const UpdateDomainAssociationResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AmplifyClient::UpdateDomainAssociation, request, handler, context);
  }
 
  virtual Model::UpdateWebhookOutcome UpdateWebhook(const Model::UpdateWebhookRequest& request) const;
 
  template <typename UpdateWebhookRequestT = Model::UpdateWebhookRequest>
  Model::UpdateWebhookOutcomeCallable UpdateWebhookCallable(const UpdateWebhookRequestT& request) const {
    return SubmitCallable(&AmplifyClient::UpdateWebhook, request);
  }
 
  template <typename UpdateWebhookRequestT = Model::UpdateWebhookRequest>
  void UpdateWebhookAsync(const UpdateWebhookRequestT& request, const UpdateWebhookResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AmplifyClient::UpdateWebhook, request, handler, context);
  }
 
  void OverrideEndpoint(const Aws::String& endpoint);
  std::shared_ptr<AmplifyEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<AmplifyClient>;
  void init(const AmplifyClientConfiguration& clientConfiguration);
 
  AmplifyClientConfiguration m_clientConfiguration;
  std::shared_ptr<AmplifyEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace Amplify
}  // namespace Aws