AmplifyClient.h

 
#pragma once
#include <aws/amplify/Amplify_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/amplify/AmplifyServiceClientModel.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