ProtonClient.h

 
#pragma once
#include <aws/proton/Proton_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/proton/ProtonServiceClientModel.h>
 
namespace Aws
{
namespace Proton
{
  class AWS_PROTON_API ProtonClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<ProtonClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef ProtonClientConfiguration ClientConfigurationType;
      typedef ProtonEndpointProvider EndpointProviderType;
 
        ProtonClient(const Aws::Proton::ProtonClientConfiguration& clientConfiguration = Aws::Proton::ProtonClientConfiguration(),
                     std::shared_ptr<ProtonEndpointProviderBase> endpointProvider = nullptr);
 
        ProtonClient(const Aws::Auth::AWSCredentials& credentials,
                     std::shared_ptr<ProtonEndpointProviderBase> endpointProvider = nullptr,
                     const Aws::Proton::ProtonClientConfiguration& clientConfiguration = Aws::Proton::ProtonClientConfiguration());
 
        ProtonClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                     std::shared_ptr<ProtonEndpointProviderBase> endpointProvider = nullptr,
                     const Aws::Proton::ProtonClientConfiguration& clientConfiguration = Aws::Proton::ProtonClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        ProtonClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        ProtonClient(const Aws::Auth::AWSCredentials& credentials,
                     const Aws::Client::ClientConfiguration& clientConfiguration);
 
        ProtonClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                     const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~ProtonClient();
 
        virtual Model::AcceptEnvironmentAccountConnectionOutcome AcceptEnvironmentAccountConnection(const Model::AcceptEnvironmentAccountConnectionRequest& request) const;
 
        template<typename AcceptEnvironmentAccountConnectionRequestT = Model::AcceptEnvironmentAccountConnectionRequest>
        Model::AcceptEnvironmentAccountConnectionOutcomeCallable AcceptEnvironmentAccountConnectionCallable(const AcceptEnvironmentAccountConnectionRequestT& request) const
        {
            return SubmitCallable(&ProtonClient::AcceptEnvironmentAccountConnection, request);
        }
 
        template<typename AcceptEnvironmentAccountConnectionRequestT = Model::AcceptEnvironmentAccountConnectionRequest>
        void AcceptEnvironmentAccountConnectionAsync(const AcceptEnvironmentAccountConnectionRequestT& request, const AcceptEnvironmentAccountConnectionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ProtonClient::AcceptEnvironmentAccountConnection, request, handler, context);
        }
 
        virtual Model::CancelComponentDeploymentOutcome CancelComponentDeployment(const Model::CancelComponentDeploymentRequest& request) const;
 
        template<typename CancelComponentDeploymentRequestT = Model::CancelComponentDeploymentRequest>
        Model::CancelComponentDeploymentOutcomeCallable CancelComponentDeploymentCallable(const CancelComponentDeploymentRequestT& request) const
        {
            return SubmitCallable(&ProtonClient::CancelComponentDeployment, request);
        }
 
        template<typename CancelComponentDeploymentRequestT = Model::CancelComponentDeploymentRequest>
        void CancelComponentDeploymentAsync(const CancelComponentDeploymentRequestT& request, const CancelComponentDeploymentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ProtonClient::CancelComponentDeployment, request, handler, context);
        }
 
        virtual Model::CancelEnvironmentDeploymentOutcome CancelEnvironmentDeployment(const Model::CancelEnvironmentDeploymentRequest& request) const;
 
        template<typename CancelEnvironmentDeploymentRequestT = Model::CancelEnvironmentDeploymentRequest>
        Model::CancelEnvironmentDeploymentOutcomeCallable CancelEnvironmentDeploymentCallable(const CancelEnvironmentDeploymentRequestT& request) const
        {
            return SubmitCallable(&ProtonClient::CancelEnvironmentDeployment, request);
        }
 
        template<typename CancelEnvironmentDeploymentRequestT = Model::CancelEnvironmentDeploymentRequest>
        void CancelEnvironmentDeploymentAsync(const CancelEnvironmentDeploymentRequestT& request, const CancelEnvironmentDeploymentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ProtonClient::CancelEnvironmentDeployment, request, handler, context);
        }
 
        virtual Model::CancelServiceInstanceDeploymentOutcome CancelServiceInstanceDeployment(const Model::CancelServiceInstanceDeploymentRequest& request) const;
 
        template<typename CancelServiceInstanceDeploymentRequestT = Model::CancelServiceInstanceDeploymentRequest>
        Model::CancelServiceInstanceDeploymentOutcomeCallable CancelServiceInstanceDeploymentCallable(const CancelServiceInstanceDeploymentRequestT& request) const
        {
            return SubmitCallable(&ProtonClient::CancelServiceInstanceDeployment, request);
        }
 
        template<typename CancelServiceInstanceDeploymentRequestT = Model::CancelServiceInstanceDeploymentRequest>
        void CancelServiceInstanceDeploymentAsync(const CancelServiceInstanceDeploymentRequestT& request, const CancelServiceInstanceDeploymentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ProtonClient::CancelServiceInstanceDeployment, request, handler, context);
        }
 
        virtual Model::CancelServicePipelineDeploymentOutcome CancelServicePipelineDeployment(const Model::CancelServicePipelineDeploymentRequest& request) const;
 
        template<typename CancelServicePipelineDeploymentRequestT = Model::CancelServicePipelineDeploymentRequest>
        Model::CancelServicePipelineDeploymentOutcomeCallable CancelServicePipelineDeploymentCallable(const CancelServicePipelineDeploymentRequestT& request) const
        {
            return SubmitCallable(&ProtonClient::CancelServicePipelineDeployment, request);
        }
 
        template<typename CancelServicePipelineDeploymentRequestT = Model::CancelServicePipelineDeploymentRequest>
        void CancelServicePipelineDeploymentAsync(const CancelServicePipelineDeploymentRequestT& request, const CancelServicePipelineDeploymentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ProtonClient::CancelServicePipelineDeployment, request, handler, context);
        }
 
        virtual Model::CreateComponentOutcome CreateComponent(const Model::CreateComponentRequest& request) const;
 
        template<typename CreateComponentRequestT = Model::CreateComponentRequest>
        Model::CreateComponentOutcomeCallable CreateComponentCallable(const CreateComponentRequestT& request) const
        {
            return SubmitCallable(&ProtonClient::CreateComponent, request);
        }
 
        template<typename CreateComponentRequestT = Model::CreateComponentRequest>
        void CreateComponentAsync(const CreateComponentRequestT& request, const CreateComponentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ProtonClient::CreateComponent, request, handler, context);
        }
 
        virtual Model::CreateEnvironmentOutcome CreateEnvironment(const Model::CreateEnvironmentRequest& request) const;
 
        template<typename CreateEnvironmentRequestT = Model::CreateEnvironmentRequest>
        Model::CreateEnvironmentOutcomeCallable CreateEnvironmentCallable(const CreateEnvironmentRequestT& request) const
        {
            return SubmitCallable(&ProtonClient::CreateEnvironment, request);
        }
 
        template<typename CreateEnvironmentRequestT = Model::CreateEnvironmentRequest>
        void CreateEnvironmentAsync(const CreateEnvironmentRequestT& request, const CreateEnvironmentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ProtonClient::CreateEnvironment, request, handler, context);
        }
 
        virtual Model::CreateEnvironmentAccountConnectionOutcome CreateEnvironmentAccountConnection(const Model::CreateEnvironmentAccountConnectionRequest& request) const;
 
        template<typename CreateEnvironmentAccountConnectionRequestT = Model::CreateEnvironmentAccountConnectionRequest>
        Model::CreateEnvironmentAccountConnectionOutcomeCallable CreateEnvironmentAccountConnectionCallable(const CreateEnvironmentAccountConnectionRequestT& request) const
        {
            return SubmitCallable(&ProtonClient::CreateEnvironmentAccountConnection, request);
        }
 
        template<typename CreateEnvironmentAccountConnectionRequestT = Model::CreateEnvironmentAccountConnectionRequest>
        void CreateEnvironmentAccountConnectionAsync(const CreateEnvironmentAccountConnectionRequestT& request, const CreateEnvironmentAccountConnectionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ProtonClient::CreateEnvironmentAccountConnection, request, handler, context);
        }
 
        virtual Model::CreateEnvironmentTemplateOutcome CreateEnvironmentTemplate(const Model::CreateEnvironmentTemplateRequest& request) const;
 
        template<typename CreateEnvironmentTemplateRequestT = Model::CreateEnvironmentTemplateRequest>
        Model::CreateEnvironmentTemplateOutcomeCallable CreateEnvironmentTemplateCallable(const CreateEnvironmentTemplateRequestT& request) const
        {
            return SubmitCallable(&ProtonClient::CreateEnvironmentTemplate, request);
        }
 
        template<typename CreateEnvironmentTemplateRequestT = Model::CreateEnvironmentTemplateRequest>
        void CreateEnvironmentTemplateAsync(const CreateEnvironmentTemplateRequestT& request, const CreateEnvironmentTemplateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ProtonClient::CreateEnvironmentTemplate, request, handler, context);
        }
 
        virtual Model::CreateEnvironmentTemplateVersionOutcome CreateEnvironmentTemplateVersion(const Model::CreateEnvironmentTemplateVersionRequest& request) const;
 
        template<typename CreateEnvironmentTemplateVersionRequestT = Model::CreateEnvironmentTemplateVersionRequest>
        Model::CreateEnvironmentTemplateVersionOutcomeCallable CreateEnvironmentTemplateVersionCallable(const CreateEnvironmentTemplateVersionRequestT& request) const
        {
            return SubmitCallable(&ProtonClient::CreateEnvironmentTemplateVersion, request);
        }
 
        template<typename CreateEnvironmentTemplateVersionRequestT = Model::CreateEnvironmentTemplateVersionRequest>
        void CreateEnvironmentTemplateVersionAsync(const CreateEnvironmentTemplateVersionRequestT& request, const CreateEnvironmentTemplateVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ProtonClient::CreateEnvironmentTemplateVersion, request, handler, context);
        }
 
        virtual Model::CreateRepositoryOutcome CreateRepository(const Model::CreateRepositoryRequest& request) const;
 
        template<typename CreateRepositoryRequestT = Model::CreateRepositoryRequest>
        Model::CreateRepositoryOutcomeCallable CreateRepositoryCallable(const CreateRepositoryRequestT& request) const
        {
            return SubmitCallable(&ProtonClient::CreateRepository, request);
        }
 
        template<typename CreateRepositoryRequestT = Model::CreateRepositoryRequest>
        void CreateRepositoryAsync(const CreateRepositoryRequestT& request, const CreateRepositoryResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ProtonClient::CreateRepository, request, handler, context);
        }
 
        virtual Model::CreateServiceOutcome CreateService(const Model::CreateServiceRequest& request) const;
 
        template<typename CreateServiceRequestT = Model::CreateServiceRequest>
        Model::CreateServiceOutcomeCallable CreateServiceCallable(const CreateServiceRequestT& request) const
        {
            return SubmitCallable(&ProtonClient::CreateService, request);
        }
 
        template<typename CreateServiceRequestT = Model::CreateServiceRequest>
        void CreateServiceAsync(const CreateServiceRequestT& request, const CreateServiceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ProtonClient::CreateService, request, handler, context);
        }
 
        virtual Model::CreateServiceInstanceOutcome CreateServiceInstance(const Model::CreateServiceInstanceRequest& request) const;
 
        template<typename CreateServiceInstanceRequestT = Model::CreateServiceInstanceRequest>
        Model::CreateServiceInstanceOutcomeCallable CreateServiceInstanceCallable(const CreateServiceInstanceRequestT& request) const
        {
            return SubmitCallable(&ProtonClient::CreateServiceInstance, request);
        }
 
        template<typename CreateServiceInstanceRequestT = Model::CreateServiceInstanceRequest>
        void CreateServiceInstanceAsync(const CreateServiceInstanceRequestT& request, const CreateServiceInstanceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ProtonClient::CreateServiceInstance, request, handler, context);
        }
 
        virtual Model::CreateServiceSyncConfigOutcome CreateServiceSyncConfig(const Model::CreateServiceSyncConfigRequest& request) const;
 
        template<typename CreateServiceSyncConfigRequestT = Model::CreateServiceSyncConfigRequest>
        Model::CreateServiceSyncConfigOutcomeCallable CreateServiceSyncConfigCallable(const CreateServiceSyncConfigRequestT& request) const
        {
            return SubmitCallable(&ProtonClient::CreateServiceSyncConfig, request);
        }
 
        template<typename CreateServiceSyncConfigRequestT = Model::CreateServiceSyncConfigRequest>
        void CreateServiceSyncConfigAsync(const CreateServiceSyncConfigRequestT& request, const CreateServiceSyncConfigResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ProtonClient::CreateServiceSyncConfig, request, handler, context);
        }
 
        virtual Model::CreateServiceTemplateOutcome CreateServiceTemplate(const Model::CreateServiceTemplateRequest& request) const;
 
        template<typename CreateServiceTemplateRequestT = Model::CreateServiceTemplateRequest>
        Model::CreateServiceTemplateOutcomeCallable CreateServiceTemplateCallable(const CreateServiceTemplateRequestT& request) const
        {
            return SubmitCallable(&ProtonClient::CreateServiceTemplate, request);
        }
 
        template<typename CreateServiceTemplateRequestT = Model::CreateServiceTemplateRequest>
        void CreateServiceTemplateAsync(const CreateServiceTemplateRequestT& request, const CreateServiceTemplateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ProtonClient::CreateServiceTemplate, request, handler, context);
        }
 
        virtual Model::CreateServiceTemplateVersionOutcome CreateServiceTemplateVersion(const Model::CreateServiceTemplateVersionRequest& request) const;
 
        template<typename CreateServiceTemplateVersionRequestT = Model::CreateServiceTemplateVersionRequest>
        Model::CreateServiceTemplateVersionOutcomeCallable CreateServiceTemplateVersionCallable(const CreateServiceTemplateVersionRequestT& request) const
        {
            return SubmitCallable(&ProtonClient::CreateServiceTemplateVersion, request);
        }
 
        template<typename CreateServiceTemplateVersionRequestT = Model::CreateServiceTemplateVersionRequest>
        void CreateServiceTemplateVersionAsync(const CreateServiceTemplateVersionRequestT& request, const CreateServiceTemplateVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ProtonClient::CreateServiceTemplateVersion, request, handler, context);
        }
 
        virtual Model::CreateTemplateSyncConfigOutcome CreateTemplateSyncConfig(const Model::CreateTemplateSyncConfigRequest& request) const;
 
        template<typename CreateTemplateSyncConfigRequestT = Model::CreateTemplateSyncConfigRequest>
        Model::CreateTemplateSyncConfigOutcomeCallable CreateTemplateSyncConfigCallable(const CreateTemplateSyncConfigRequestT& request) const
        {
            return SubmitCallable(&ProtonClient::CreateTemplateSyncConfig, request);
        }
 
        template<typename CreateTemplateSyncConfigRequestT = Model::CreateTemplateSyncConfigRequest>
        void CreateTemplateSyncConfigAsync(const CreateTemplateSyncConfigRequestT& request, const CreateTemplateSyncConfigResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ProtonClient::CreateTemplateSyncConfig, request, handler, context);
        }
 
        virtual Model::DeleteComponentOutcome DeleteComponent(const Model::DeleteComponentRequest& request) const;
 
        template<typename DeleteComponentRequestT = Model::DeleteComponentRequest>
        Model::DeleteComponentOutcomeCallable DeleteComponentCallable(const DeleteComponentRequestT& request) const
        {
            return SubmitCallable(&ProtonClient::DeleteComponent, request);
        }
 
        template<typename DeleteComponentRequestT = Model::DeleteComponentRequest>
        void DeleteComponentAsync(const DeleteComponentRequestT& request, const DeleteComponentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ProtonClient::DeleteComponent, request, handler, context);
        }
 
        virtual Model::DeleteDeploymentOutcome DeleteDeployment(const Model::DeleteDeploymentRequest& request) const;
 
        template<typename DeleteDeploymentRequestT = Model::DeleteDeploymentRequest>
        Model::DeleteDeploymentOutcomeCallable DeleteDeploymentCallable(const DeleteDeploymentRequestT& request) const
        {
            return SubmitCallable(&ProtonClient::DeleteDeployment, request);
        }
 
        template<typename DeleteDeploymentRequestT = Model::DeleteDeploymentRequest>
        void DeleteDeploymentAsync(const DeleteDeploymentRequestT& request, const DeleteDeploymentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ProtonClient::DeleteDeployment, request, handler, context);
        }
 
        virtual Model::DeleteEnvironmentOutcome DeleteEnvironment(const Model::DeleteEnvironmentRequest& request) const;
 
        template<typename DeleteEnvironmentRequestT = Model::DeleteEnvironmentRequest>
        Model::DeleteEnvironmentOutcomeCallable DeleteEnvironmentCallable(const DeleteEnvironmentRequestT& request) const
        {
            return SubmitCallable(&ProtonClient::DeleteEnvironment, request);
        }
 
        template<typename DeleteEnvironmentRequestT = Model::DeleteEnvironmentRequest>
        void DeleteEnvironmentAsync(const DeleteEnvironmentRequestT& request, const DeleteEnvironmentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ProtonClient::DeleteEnvironment, request, handler, context);
        }
 
        virtual Model::DeleteEnvironmentAccountConnectionOutcome DeleteEnvironmentAccountConnection(const Model::DeleteEnvironmentAccountConnectionRequest& request) const;
 
        template<typename DeleteEnvironmentAccountConnectionRequestT = Model::DeleteEnvironmentAccountConnectionRequest>
        Model::DeleteEnvironmentAccountConnectionOutcomeCallable DeleteEnvironmentAccountConnectionCallable(const DeleteEnvironmentAccountConnectionRequestT& request) const
        {
            return SubmitCallable(&ProtonClient::DeleteEnvironmentAccountConnection, request);
        }
 
        template<typename DeleteEnvironmentAccountConnectionRequestT = Model::DeleteEnvironmentAccountConnectionRequest>
        void DeleteEnvironmentAccountConnectionAsync(const DeleteEnvironmentAccountConnectionRequestT& request, const DeleteEnvironmentAccountConnectionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ProtonClient::DeleteEnvironmentAccountConnection, request, handler, context);
        }
 
        virtual Model::DeleteEnvironmentTemplateOutcome DeleteEnvironmentTemplate(const Model::DeleteEnvironmentTemplateRequest& request) const;
 
        template<typename DeleteEnvironmentTemplateRequestT = Model::DeleteEnvironmentTemplateRequest>
        Model::DeleteEnvironmentTemplateOutcomeCallable DeleteEnvironmentTemplateCallable(const DeleteEnvironmentTemplateRequestT& request) const
        {
            return SubmitCallable(&ProtonClient::DeleteEnvironmentTemplate, request);
        }
 
        template<typename DeleteEnvironmentTemplateRequestT = Model::DeleteEnvironmentTemplateRequest>
        void DeleteEnvironmentTemplateAsync(const DeleteEnvironmentTemplateRequestT& request, const DeleteEnvironmentTemplateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ProtonClient::DeleteEnvironmentTemplate, request, handler, context);
        }
 
        virtual Model::DeleteEnvironmentTemplateVersionOutcome DeleteEnvironmentTemplateVersion(const Model::DeleteEnvironmentTemplateVersionRequest& request) const;
 
        template<typename DeleteEnvironmentTemplateVersionRequestT = Model::DeleteEnvironmentTemplateVersionRequest>
        Model::DeleteEnvironmentTemplateVersionOutcomeCallable DeleteEnvironmentTemplateVersionCallable(const DeleteEnvironmentTemplateVersionRequestT& request) const
        {
            return SubmitCallable(&ProtonClient::DeleteEnvironmentTemplateVersion, request);
        }
 
        template<typename DeleteEnvironmentTemplateVersionRequestT = Model::DeleteEnvironmentTemplateVersionRequest>
        void DeleteEnvironmentTemplateVersionAsync(const DeleteEnvironmentTemplateVersionRequestT& request, const DeleteEnvironmentTemplateVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ProtonClient::DeleteEnvironmentTemplateVersion, request, handler, context);
        }
 
        virtual Model::DeleteRepositoryOutcome DeleteRepository(const Model::DeleteRepositoryRequest& request) const;
 
        template<typename DeleteRepositoryRequestT = Model::DeleteRepositoryRequest>
        Model::DeleteRepositoryOutcomeCallable DeleteRepositoryCallable(const DeleteRepositoryRequestT& request) const
        {
            return SubmitCallable(&ProtonClient::DeleteRepository, request);
        }
 
        template<typename DeleteRepositoryRequestT = Model::DeleteRepositoryRequest>
        void DeleteRepositoryAsync(const DeleteRepositoryRequestT& request, const DeleteRepositoryResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ProtonClient::DeleteRepository, request, handler, context);
        }
 
        virtual Model::DeleteServiceOutcome DeleteService(const Model::DeleteServiceRequest& request) const;
 
        template<typename DeleteServiceRequestT = Model::DeleteServiceRequest>
        Model::DeleteServiceOutcomeCallable DeleteServiceCallable(const DeleteServiceRequestT& request) const
        {
            return SubmitCallable(&ProtonClient::DeleteService, request);
        }
 
        template<typename DeleteServiceRequestT = Model::DeleteServiceRequest>
        void DeleteServiceAsync(const DeleteServiceRequestT& request, const DeleteServiceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ProtonClient::DeleteService, request, handler, context);
        }
 
        virtual Model::DeleteServiceSyncConfigOutcome DeleteServiceSyncConfig(const Model::DeleteServiceSyncConfigRequest& request) const;
 
        template<typename DeleteServiceSyncConfigRequestT = Model::DeleteServiceSyncConfigRequest>
        Model::DeleteServiceSyncConfigOutcomeCallable DeleteServiceSyncConfigCallable(const DeleteServiceSyncConfigRequestT& request) const
        {
            return SubmitCallable(&ProtonClient::DeleteServiceSyncConfig, request);
        }
 
        template<typename DeleteServiceSyncConfigRequestT = Model::DeleteServiceSyncConfigRequest>
        void DeleteServiceSyncConfigAsync(const DeleteServiceSyncConfigRequestT& request, const DeleteServiceSyncConfigResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ProtonClient::DeleteServiceSyncConfig, request, handler, context);
        }
 
        virtual Model::DeleteServiceTemplateOutcome DeleteServiceTemplate(const Model::DeleteServiceTemplateRequest& request) const;
 
        template<typename DeleteServiceTemplateRequestT = Model::DeleteServiceTemplateRequest>
        Model::DeleteServiceTemplateOutcomeCallable DeleteServiceTemplateCallable(const DeleteServiceTemplateRequestT& request) const
        {
            return SubmitCallable(&ProtonClient::DeleteServiceTemplate, request);
        }
 
        template<typename DeleteServiceTemplateRequestT = Model::DeleteServiceTemplateRequest>
        void DeleteServiceTemplateAsync(const DeleteServiceTemplateRequestT& request, const DeleteServiceTemplateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ProtonClient::DeleteServiceTemplate, request, handler, context);
        }
 
        virtual Model::DeleteServiceTemplateVersionOutcome DeleteServiceTemplateVersion(const Model::DeleteServiceTemplateVersionRequest& request) const;
 
        template<typename DeleteServiceTemplateVersionRequestT = Model::DeleteServiceTemplateVersionRequest>
        Model::DeleteServiceTemplateVersionOutcomeCallable DeleteServiceTemplateVersionCallable(const DeleteServiceTemplateVersionRequestT& request) const
        {
            return SubmitCallable(&ProtonClient::DeleteServiceTemplateVersion, request);
        }
 
        template<typename DeleteServiceTemplateVersionRequestT = Model::DeleteServiceTemplateVersionRequest>
        void DeleteServiceTemplateVersionAsync(const DeleteServiceTemplateVersionRequestT& request, const DeleteServiceTemplateVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ProtonClient::DeleteServiceTemplateVersion, request, handler, context);
        }
 
        virtual Model::DeleteTemplateSyncConfigOutcome DeleteTemplateSyncConfig(const Model::DeleteTemplateSyncConfigRequest& request) const;
 
        template<typename DeleteTemplateSyncConfigRequestT = Model::DeleteTemplateSyncConfigRequest>
        Model::DeleteTemplateSyncConfigOutcomeCallable DeleteTemplateSyncConfigCallable(const DeleteTemplateSyncConfigRequestT& request) const
        {
            return SubmitCallable(&ProtonClient::DeleteTemplateSyncConfig, request);
        }
 
        template<typename DeleteTemplateSyncConfigRequestT = Model::DeleteTemplateSyncConfigRequest>
        void DeleteTemplateSyncConfigAsync(const DeleteTemplateSyncConfigRequestT& request, const DeleteTemplateSyncConfigResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ProtonClient::DeleteTemplateSyncConfig, request, handler, context);
        }
 
        virtual Model::GetAccountSettingsOutcome GetAccountSettings(const Model::GetAccountSettingsRequest& request = {}) const;
 
        template<typename GetAccountSettingsRequestT = Model::GetAccountSettingsRequest>
        Model::GetAccountSettingsOutcomeCallable GetAccountSettingsCallable(const GetAccountSettingsRequestT& request = {}) const
        {
            return SubmitCallable(&ProtonClient::GetAccountSettings, request);
        }
 
        template<typename GetAccountSettingsRequestT = Model::GetAccountSettingsRequest>
        void GetAccountSettingsAsync(const GetAccountSettingsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetAccountSettingsRequestT& request = {}) const
        {
            return SubmitAsync(&ProtonClient::GetAccountSettings, request, handler, context);
        }
 
        virtual Model::GetComponentOutcome GetComponent(const Model::GetComponentRequest& request) const;
 
        template<typename GetComponentRequestT = Model::GetComponentRequest>
        Model::GetComponentOutcomeCallable GetComponentCallable(const GetComponentRequestT& request) const
        {
            return SubmitCallable(&ProtonClient::GetComponent, request);
        }
 
        template<typename GetComponentRequestT = Model::GetComponentRequest>
        void GetComponentAsync(const GetComponentRequestT& request, const GetComponentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ProtonClient::GetComponent, request, handler, context);
        }
 
        virtual Model::GetDeploymentOutcome GetDeployment(const Model::GetDeploymentRequest& request) const;
 
        template<typename GetDeploymentRequestT = Model::GetDeploymentRequest>
        Model::GetDeploymentOutcomeCallable GetDeploymentCallable(const GetDeploymentRequestT& request) const
        {
            return SubmitCallable(&ProtonClient::GetDeployment, request);
        }
 
        template<typename GetDeploymentRequestT = Model::GetDeploymentRequest>
        void GetDeploymentAsync(const GetDeploymentRequestT& request, const GetDeploymentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ProtonClient::GetDeployment, request, handler, context);
        }
 
        virtual Model::GetEnvironmentOutcome GetEnvironment(const Model::GetEnvironmentRequest& request) const;
 
        template<typename GetEnvironmentRequestT = Model::GetEnvironmentRequest>
        Model::GetEnvironmentOutcomeCallable GetEnvironmentCallable(const GetEnvironmentRequestT& request) const
        {
            return SubmitCallable(&ProtonClient::GetEnvironment, request);
        }
 
        template<typename GetEnvironmentRequestT = Model::GetEnvironmentRequest>
        void GetEnvironmentAsync(const GetEnvironmentRequestT& request, const GetEnvironmentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ProtonClient::GetEnvironment, request, handler, context);
        }
 
        virtual Model::GetEnvironmentAccountConnectionOutcome GetEnvironmentAccountConnection(const Model::GetEnvironmentAccountConnectionRequest& request) const;
 
        template<typename GetEnvironmentAccountConnectionRequestT = Model::GetEnvironmentAccountConnectionRequest>
        Model::GetEnvironmentAccountConnectionOutcomeCallable GetEnvironmentAccountConnectionCallable(const GetEnvironmentAccountConnectionRequestT& request) const
        {
            return SubmitCallable(&ProtonClient::GetEnvironmentAccountConnection, request);
        }
 
        template<typename GetEnvironmentAccountConnectionRequestT = Model::GetEnvironmentAccountConnectionRequest>
        void GetEnvironmentAccountConnectionAsync(const GetEnvironmentAccountConnectionRequestT& request, const GetEnvironmentAccountConnectionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ProtonClient::GetEnvironmentAccountConnection, request, handler, context);
        }
 
        virtual Model::GetEnvironmentTemplateOutcome GetEnvironmentTemplate(const Model::GetEnvironmentTemplateRequest& request) const;
 
        template<typename GetEnvironmentTemplateRequestT = Model::GetEnvironmentTemplateRequest>
        Model::GetEnvironmentTemplateOutcomeCallable GetEnvironmentTemplateCallable(const GetEnvironmentTemplateRequestT& request) const
        {
            return SubmitCallable(&ProtonClient::GetEnvironmentTemplate, request);
        }
 
        template<typename GetEnvironmentTemplateRequestT = Model::GetEnvironmentTemplateRequest>
        void GetEnvironmentTemplateAsync(const GetEnvironmentTemplateRequestT& request, const GetEnvironmentTemplateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ProtonClient::GetEnvironmentTemplate, request, handler, context);
        }
 
        virtual Model::GetEnvironmentTemplateVersionOutcome GetEnvironmentTemplateVersion(const Model::GetEnvironmentTemplateVersionRequest& request) const;
 
        template<typename GetEnvironmentTemplateVersionRequestT = Model::GetEnvironmentTemplateVersionRequest>
        Model::GetEnvironmentTemplateVersionOutcomeCallable GetEnvironmentTemplateVersionCallable(const GetEnvironmentTemplateVersionRequestT& request) const
        {
            return SubmitCallable(&ProtonClient::GetEnvironmentTemplateVersion, request);
        }
 
        template<typename GetEnvironmentTemplateVersionRequestT = Model::GetEnvironmentTemplateVersionRequest>
        void GetEnvironmentTemplateVersionAsync(const GetEnvironmentTemplateVersionRequestT& request, const GetEnvironmentTemplateVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ProtonClient::GetEnvironmentTemplateVersion, request, handler, context);
        }
 
        virtual Model::GetRepositoryOutcome GetRepository(const Model::GetRepositoryRequest& request) const;
 
        template<typename GetRepositoryRequestT = Model::GetRepositoryRequest>
        Model::GetRepositoryOutcomeCallable GetRepositoryCallable(const GetRepositoryRequestT& request) const
        {
            return SubmitCallable(&ProtonClient::GetRepository, request);
        }
 
        template<typename GetRepositoryRequestT = Model::GetRepositoryRequest>
        void GetRepositoryAsync(const GetRepositoryRequestT& request, const GetRepositoryResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ProtonClient::GetRepository, request, handler, context);
        }
 
        virtual Model::GetRepositorySyncStatusOutcome GetRepositorySyncStatus(const Model::GetRepositorySyncStatusRequest& request) const;
 
        template<typename GetRepositorySyncStatusRequestT = Model::GetRepositorySyncStatusRequest>
        Model::GetRepositorySyncStatusOutcomeCallable GetRepositorySyncStatusCallable(const GetRepositorySyncStatusRequestT& request) const
        {
            return SubmitCallable(&ProtonClient::GetRepositorySyncStatus, request);
        }
 
        template<typename GetRepositorySyncStatusRequestT = Model::GetRepositorySyncStatusRequest>
        void GetRepositorySyncStatusAsync(const GetRepositorySyncStatusRequestT& request, const GetRepositorySyncStatusResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ProtonClient::GetRepositorySyncStatus, request, handler, context);
        }
 
        virtual Model::GetResourcesSummaryOutcome GetResourcesSummary(const Model::GetResourcesSummaryRequest& request = {}) const;
 
        template<typename GetResourcesSummaryRequestT = Model::GetResourcesSummaryRequest>
        Model::GetResourcesSummaryOutcomeCallable GetResourcesSummaryCallable(const GetResourcesSummaryRequestT& request = {}) const
        {
            return SubmitCallable(&ProtonClient::GetResourcesSummary, request);
        }
 
        template<typename GetResourcesSummaryRequestT = Model::GetResourcesSummaryRequest>
        void GetResourcesSummaryAsync(const GetResourcesSummaryResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetResourcesSummaryRequestT& request = {}) const
        {
            return SubmitAsync(&ProtonClient::GetResourcesSummary, request, handler, context);
        }
 
        virtual Model::GetServiceOutcome GetService(const Model::GetServiceRequest& request) const;
 
        template<typename GetServiceRequestT = Model::GetServiceRequest>
        Model::GetServiceOutcomeCallable GetServiceCallable(const GetServiceRequestT& request) const
        {
            return SubmitCallable(&ProtonClient::GetService, request);
        }
 
        template<typename GetServiceRequestT = Model::GetServiceRequest>
        void GetServiceAsync(const GetServiceRequestT& request, const GetServiceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ProtonClient::GetService, request, handler, context);
        }
 
        virtual Model::GetServiceInstanceOutcome GetServiceInstance(const Model::GetServiceInstanceRequest& request) const;
 
        template<typename GetServiceInstanceRequestT = Model::GetServiceInstanceRequest>
        Model::GetServiceInstanceOutcomeCallable GetServiceInstanceCallable(const GetServiceInstanceRequestT& request) const
        {
            return SubmitCallable(&ProtonClient::GetServiceInstance, request);
        }
 
        template<typename GetServiceInstanceRequestT = Model::GetServiceInstanceRequest>
        void GetServiceInstanceAsync(const GetServiceInstanceRequestT& request, const GetServiceInstanceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ProtonClient::GetServiceInstance, request, handler, context);
        }
 
        virtual Model::GetServiceInstanceSyncStatusOutcome GetServiceInstanceSyncStatus(const Model::GetServiceInstanceSyncStatusRequest& request) const;
 
        template<typename GetServiceInstanceSyncStatusRequestT = Model::GetServiceInstanceSyncStatusRequest>
        Model::GetServiceInstanceSyncStatusOutcomeCallable GetServiceInstanceSyncStatusCallable(const GetServiceInstanceSyncStatusRequestT& request) const
        {
            return SubmitCallable(&ProtonClient::GetServiceInstanceSyncStatus, request);
        }
 
        template<typename GetServiceInstanceSyncStatusRequestT = Model::GetServiceInstanceSyncStatusRequest>
        void GetServiceInstanceSyncStatusAsync(const GetServiceInstanceSyncStatusRequestT& request, const GetServiceInstanceSyncStatusResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ProtonClient::GetServiceInstanceSyncStatus, request, handler, context);
        }
 
        virtual Model::GetServiceSyncBlockerSummaryOutcome GetServiceSyncBlockerSummary(const Model::GetServiceSyncBlockerSummaryRequest& request) const;
 
        template<typename GetServiceSyncBlockerSummaryRequestT = Model::GetServiceSyncBlockerSummaryRequest>
        Model::GetServiceSyncBlockerSummaryOutcomeCallable GetServiceSyncBlockerSummaryCallable(const GetServiceSyncBlockerSummaryRequestT& request) const
        {
            return SubmitCallable(&ProtonClient::GetServiceSyncBlockerSummary, request);
        }
 
        template<typename GetServiceSyncBlockerSummaryRequestT = Model::GetServiceSyncBlockerSummaryRequest>
        void GetServiceSyncBlockerSummaryAsync(const GetServiceSyncBlockerSummaryRequestT& request, const GetServiceSyncBlockerSummaryResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ProtonClient::GetServiceSyncBlockerSummary, request, handler, context);
        }
 
        virtual Model::GetServiceSyncConfigOutcome GetServiceSyncConfig(const Model::GetServiceSyncConfigRequest& request) const;
 
        template<typename GetServiceSyncConfigRequestT = Model::GetServiceSyncConfigRequest>
        Model::GetServiceSyncConfigOutcomeCallable GetServiceSyncConfigCallable(const GetServiceSyncConfigRequestT& request) const
        {
            return SubmitCallable(&ProtonClient::GetServiceSyncConfig, request);
        }
 
        template<typename GetServiceSyncConfigRequestT = Model::GetServiceSyncConfigRequest>
        void GetServiceSyncConfigAsync(const GetServiceSyncConfigRequestT& request, const GetServiceSyncConfigResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ProtonClient::GetServiceSyncConfig, request, handler, context);
        }
 
        virtual Model::GetServiceTemplateOutcome GetServiceTemplate(const Model::GetServiceTemplateRequest& request) const;
 
        template<typename GetServiceTemplateRequestT = Model::GetServiceTemplateRequest>
        Model::GetServiceTemplateOutcomeCallable GetServiceTemplateCallable(const GetServiceTemplateRequestT& request) const
        {
            return SubmitCallable(&ProtonClient::GetServiceTemplate, request);
        }
 
        template<typename GetServiceTemplateRequestT = Model::GetServiceTemplateRequest>
        void GetServiceTemplateAsync(const GetServiceTemplateRequestT& request, const GetServiceTemplateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ProtonClient::GetServiceTemplate, request, handler, context);
        }
 
        virtual Model::GetServiceTemplateVersionOutcome GetServiceTemplateVersion(const Model::GetServiceTemplateVersionRequest& request) const;
 
        template<typename GetServiceTemplateVersionRequestT = Model::GetServiceTemplateVersionRequest>
        Model::GetServiceTemplateVersionOutcomeCallable GetServiceTemplateVersionCallable(const GetServiceTemplateVersionRequestT& request) const
        {
            return SubmitCallable(&ProtonClient::GetServiceTemplateVersion, request);
        }
 
        template<typename GetServiceTemplateVersionRequestT = Model::GetServiceTemplateVersionRequest>
        void GetServiceTemplateVersionAsync(const GetServiceTemplateVersionRequestT& request, const GetServiceTemplateVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ProtonClient::GetServiceTemplateVersion, request, handler, context);
        }
 
        virtual Model::GetTemplateSyncConfigOutcome GetTemplateSyncConfig(const Model::GetTemplateSyncConfigRequest& request) const;
 
        template<typename GetTemplateSyncConfigRequestT = Model::GetTemplateSyncConfigRequest>
        Model::GetTemplateSyncConfigOutcomeCallable GetTemplateSyncConfigCallable(const GetTemplateSyncConfigRequestT& request) const
        {
            return SubmitCallable(&ProtonClient::GetTemplateSyncConfig, request);
        }
 
        template<typename GetTemplateSyncConfigRequestT = Model::GetTemplateSyncConfigRequest>
        void GetTemplateSyncConfigAsync(const GetTemplateSyncConfigRequestT& request, const GetTemplateSyncConfigResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ProtonClient::GetTemplateSyncConfig, request, handler, context);
        }
 
        virtual Model::GetTemplateSyncStatusOutcome GetTemplateSyncStatus(const Model::GetTemplateSyncStatusRequest& request) const;
 
        template<typename GetTemplateSyncStatusRequestT = Model::GetTemplateSyncStatusRequest>
        Model::GetTemplateSyncStatusOutcomeCallable GetTemplateSyncStatusCallable(const GetTemplateSyncStatusRequestT& request) const
        {
            return SubmitCallable(&ProtonClient::GetTemplateSyncStatus, request);
        }
 
        template<typename GetTemplateSyncStatusRequestT = Model::GetTemplateSyncStatusRequest>
        void GetTemplateSyncStatusAsync(const GetTemplateSyncStatusRequestT& request, const GetTemplateSyncStatusResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ProtonClient::GetTemplateSyncStatus, request, handler, context);
        }
 
        virtual Model::ListComponentOutputsOutcome ListComponentOutputs(const Model::ListComponentOutputsRequest& request) const;
 
        template<typename ListComponentOutputsRequestT = Model::ListComponentOutputsRequest>
        Model::ListComponentOutputsOutcomeCallable ListComponentOutputsCallable(const ListComponentOutputsRequestT& request) const
        {
            return SubmitCallable(&ProtonClient::ListComponentOutputs, request);
        }
 
        template<typename ListComponentOutputsRequestT = Model::ListComponentOutputsRequest>
        void ListComponentOutputsAsync(const ListComponentOutputsRequestT& request, const ListComponentOutputsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ProtonClient::ListComponentOutputs, request, handler, context);
        }
 
        virtual Model::ListComponentProvisionedResourcesOutcome ListComponentProvisionedResources(const Model::ListComponentProvisionedResourcesRequest& request) const;
 
        template<typename ListComponentProvisionedResourcesRequestT = Model::ListComponentProvisionedResourcesRequest>
        Model::ListComponentProvisionedResourcesOutcomeCallable ListComponentProvisionedResourcesCallable(const ListComponentProvisionedResourcesRequestT& request) const
        {
            return SubmitCallable(&ProtonClient::ListComponentProvisionedResources, request);
        }
 
        template<typename ListComponentProvisionedResourcesRequestT = Model::ListComponentProvisionedResourcesRequest>
        void ListComponentProvisionedResourcesAsync(const ListComponentProvisionedResourcesRequestT& request, const ListComponentProvisionedResourcesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ProtonClient::ListComponentProvisionedResources, request, handler, context);
        }
 
        virtual Model::ListComponentsOutcome ListComponents(const Model::ListComponentsRequest& request = {}) const;
 
        template<typename ListComponentsRequestT = Model::ListComponentsRequest>
        Model::ListComponentsOutcomeCallable ListComponentsCallable(const ListComponentsRequestT& request = {}) const
        {
            return SubmitCallable(&ProtonClient::ListComponents, request);
        }
 
        template<typename ListComponentsRequestT = Model::ListComponentsRequest>
        void ListComponentsAsync(const ListComponentsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListComponentsRequestT& request = {}) const
        {
            return SubmitAsync(&ProtonClient::ListComponents, request, handler, context);
        }
 
        virtual Model::ListDeploymentsOutcome ListDeployments(const Model::ListDeploymentsRequest& request = {}) const;
 
        template<typename ListDeploymentsRequestT = Model::ListDeploymentsRequest>
        Model::ListDeploymentsOutcomeCallable ListDeploymentsCallable(const ListDeploymentsRequestT& request = {}) const
        {
            return SubmitCallable(&ProtonClient::ListDeployments, request);
        }
 
        template<typename ListDeploymentsRequestT = Model::ListDeploymentsRequest>
        void ListDeploymentsAsync(const ListDeploymentsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListDeploymentsRequestT& request = {}) const
        {
            return SubmitAsync(&ProtonClient::ListDeployments, request, handler, context);
        }
 
        virtual Model::ListEnvironmentAccountConnectionsOutcome ListEnvironmentAccountConnections(const Model::ListEnvironmentAccountConnectionsRequest& request) const;
 
        template<typename ListEnvironmentAccountConnectionsRequestT = Model::ListEnvironmentAccountConnectionsRequest>
        Model::ListEnvironmentAccountConnectionsOutcomeCallable ListEnvironmentAccountConnectionsCallable(const ListEnvironmentAccountConnectionsRequestT& request) const
        {
            return SubmitCallable(&ProtonClient::ListEnvironmentAccountConnections, request);
        }
 
        template<typename ListEnvironmentAccountConnectionsRequestT = Model::ListEnvironmentAccountConnectionsRequest>
        void ListEnvironmentAccountConnectionsAsync(const ListEnvironmentAccountConnectionsRequestT& request, const ListEnvironmentAccountConnectionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ProtonClient::ListEnvironmentAccountConnections, request, handler, context);
        }
 
        virtual Model::ListEnvironmentOutputsOutcome ListEnvironmentOutputs(const Model::ListEnvironmentOutputsRequest& request) const;
 
        template<typename ListEnvironmentOutputsRequestT = Model::ListEnvironmentOutputsRequest>
        Model::ListEnvironmentOutputsOutcomeCallable ListEnvironmentOutputsCallable(const ListEnvironmentOutputsRequestT& request) const
        {
            return SubmitCallable(&ProtonClient::ListEnvironmentOutputs, request);
        }
 
        template<typename ListEnvironmentOutputsRequestT = Model::ListEnvironmentOutputsRequest>
        void ListEnvironmentOutputsAsync(const ListEnvironmentOutputsRequestT& request, const ListEnvironmentOutputsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ProtonClient::ListEnvironmentOutputs, request, handler, context);
        }
 
        virtual Model::ListEnvironmentProvisionedResourcesOutcome ListEnvironmentProvisionedResources(const Model::ListEnvironmentProvisionedResourcesRequest& request) const;
 
        template<typename ListEnvironmentProvisionedResourcesRequestT = Model::ListEnvironmentProvisionedResourcesRequest>
        Model::ListEnvironmentProvisionedResourcesOutcomeCallable ListEnvironmentProvisionedResourcesCallable(const ListEnvironmentProvisionedResourcesRequestT& request) const
        {
            return SubmitCallable(&ProtonClient::ListEnvironmentProvisionedResources, request);
        }
 
        template<typename ListEnvironmentProvisionedResourcesRequestT = Model::ListEnvironmentProvisionedResourcesRequest>
        void ListEnvironmentProvisionedResourcesAsync(const ListEnvironmentProvisionedResourcesRequestT& request, const ListEnvironmentProvisionedResourcesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ProtonClient::ListEnvironmentProvisionedResources, request, handler, context);
        }
 
        virtual Model::ListEnvironmentTemplateVersionsOutcome ListEnvironmentTemplateVersions(const Model::ListEnvironmentTemplateVersionsRequest& request) const;
 
        template<typename ListEnvironmentTemplateVersionsRequestT = Model::ListEnvironmentTemplateVersionsRequest>
        Model::ListEnvironmentTemplateVersionsOutcomeCallable ListEnvironmentTemplateVersionsCallable(const ListEnvironmentTemplateVersionsRequestT& request) const
        {
            return SubmitCallable(&ProtonClient::ListEnvironmentTemplateVersions, request);
        }
 
        template<typename ListEnvironmentTemplateVersionsRequestT = Model::ListEnvironmentTemplateVersionsRequest>
        void ListEnvironmentTemplateVersionsAsync(const ListEnvironmentTemplateVersionsRequestT& request, const ListEnvironmentTemplateVersionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ProtonClient::ListEnvironmentTemplateVersions, request, handler, context);
        }
 
        virtual Model::ListEnvironmentTemplatesOutcome ListEnvironmentTemplates(const Model::ListEnvironmentTemplatesRequest& request = {}) const;
 
        template<typename ListEnvironmentTemplatesRequestT = Model::ListEnvironmentTemplatesRequest>
        Model::ListEnvironmentTemplatesOutcomeCallable ListEnvironmentTemplatesCallable(const ListEnvironmentTemplatesRequestT& request = {}) const
        {
            return SubmitCallable(&ProtonClient::ListEnvironmentTemplates, request);
        }
 
        template<typename ListEnvironmentTemplatesRequestT = Model::ListEnvironmentTemplatesRequest>
        void ListEnvironmentTemplatesAsync(const ListEnvironmentTemplatesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListEnvironmentTemplatesRequestT& request = {}) const
        {
            return SubmitAsync(&ProtonClient::ListEnvironmentTemplates, request, handler, context);
        }
 
        virtual Model::ListEnvironmentsOutcome ListEnvironments(const Model::ListEnvironmentsRequest& request = {}) const;
 
        template<typename ListEnvironmentsRequestT = Model::ListEnvironmentsRequest>
        Model::ListEnvironmentsOutcomeCallable ListEnvironmentsCallable(const ListEnvironmentsRequestT& request = {}) const
        {
            return SubmitCallable(&ProtonClient::ListEnvironments, request);
        }
 
        template<typename ListEnvironmentsRequestT = Model::ListEnvironmentsRequest>
        void ListEnvironmentsAsync(const ListEnvironmentsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListEnvironmentsRequestT& request = {}) const
        {
            return SubmitAsync(&ProtonClient::ListEnvironments, request, handler, context);
        }
 
        virtual Model::ListRepositoriesOutcome ListRepositories(const Model::ListRepositoriesRequest& request = {}) const;
 
        template<typename ListRepositoriesRequestT = Model::ListRepositoriesRequest>
        Model::ListRepositoriesOutcomeCallable ListRepositoriesCallable(const ListRepositoriesRequestT& request = {}) const
        {
            return SubmitCallable(&ProtonClient::ListRepositories, request);
        }
 
        template<typename ListRepositoriesRequestT = Model::ListRepositoriesRequest>
        void ListRepositoriesAsync(const ListRepositoriesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListRepositoriesRequestT& request = {}) const
        {
            return SubmitAsync(&ProtonClient::ListRepositories, request, handler, context);
        }
 
        virtual Model::ListRepositorySyncDefinitionsOutcome ListRepositorySyncDefinitions(const Model::ListRepositorySyncDefinitionsRequest& request) const;
 
        template<typename ListRepositorySyncDefinitionsRequestT = Model::ListRepositorySyncDefinitionsRequest>
        Model::ListRepositorySyncDefinitionsOutcomeCallable ListRepositorySyncDefinitionsCallable(const ListRepositorySyncDefinitionsRequestT& request) const
        {
            return SubmitCallable(&ProtonClient::ListRepositorySyncDefinitions, request);
        }
 
        template<typename ListRepositorySyncDefinitionsRequestT = Model::ListRepositorySyncDefinitionsRequest>
        void ListRepositorySyncDefinitionsAsync(const ListRepositorySyncDefinitionsRequestT& request, const ListRepositorySyncDefinitionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ProtonClient::ListRepositorySyncDefinitions, request, handler, context);
        }
 
        virtual Model::ListServiceInstanceOutputsOutcome ListServiceInstanceOutputs(const Model::ListServiceInstanceOutputsRequest& request) const;
 
        template<typename ListServiceInstanceOutputsRequestT = Model::ListServiceInstanceOutputsRequest>
        Model::ListServiceInstanceOutputsOutcomeCallable ListServiceInstanceOutputsCallable(const ListServiceInstanceOutputsRequestT& request) const
        {
            return SubmitCallable(&ProtonClient::ListServiceInstanceOutputs, request);
        }
 
        template<typename ListServiceInstanceOutputsRequestT = Model::ListServiceInstanceOutputsRequest>
        void ListServiceInstanceOutputsAsync(const ListServiceInstanceOutputsRequestT& request, const ListServiceInstanceOutputsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ProtonClient::ListServiceInstanceOutputs, request, handler, context);
        }
 
        virtual Model::ListServiceInstanceProvisionedResourcesOutcome ListServiceInstanceProvisionedResources(const Model::ListServiceInstanceProvisionedResourcesRequest& request) const;
 
        template<typename ListServiceInstanceProvisionedResourcesRequestT = Model::ListServiceInstanceProvisionedResourcesRequest>
        Model::ListServiceInstanceProvisionedResourcesOutcomeCallable ListServiceInstanceProvisionedResourcesCallable(const ListServiceInstanceProvisionedResourcesRequestT& request) const
        {
            return SubmitCallable(&ProtonClient::ListServiceInstanceProvisionedResources, request);
        }
 
        template<typename ListServiceInstanceProvisionedResourcesRequestT = Model::ListServiceInstanceProvisionedResourcesRequest>
        void ListServiceInstanceProvisionedResourcesAsync(const ListServiceInstanceProvisionedResourcesRequestT& request, const ListServiceInstanceProvisionedResourcesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ProtonClient::ListServiceInstanceProvisionedResources, request, handler, context);
        }
 
        virtual Model::ListServiceInstancesOutcome ListServiceInstances(const Model::ListServiceInstancesRequest& request = {}) const;
 
        template<typename ListServiceInstancesRequestT = Model::ListServiceInstancesRequest>
        Model::ListServiceInstancesOutcomeCallable ListServiceInstancesCallable(const ListServiceInstancesRequestT& request = {}) const
        {
            return SubmitCallable(&ProtonClient::ListServiceInstances, request);
        }
 
        template<typename ListServiceInstancesRequestT = Model::ListServiceInstancesRequest>
        void ListServiceInstancesAsync(const ListServiceInstancesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListServiceInstancesRequestT& request = {}) const
        {
            return SubmitAsync(&ProtonClient::ListServiceInstances, request, handler, context);
        }
 
        virtual Model::ListServicePipelineOutputsOutcome ListServicePipelineOutputs(const Model::ListServicePipelineOutputsRequest& request) const;
 
        template<typename ListServicePipelineOutputsRequestT = Model::ListServicePipelineOutputsRequest>
        Model::ListServicePipelineOutputsOutcomeCallable ListServicePipelineOutputsCallable(const ListServicePipelineOutputsRequestT& request) const
        {
            return SubmitCallable(&ProtonClient::ListServicePipelineOutputs, request);
        }
 
        template<typename ListServicePipelineOutputsRequestT = Model::ListServicePipelineOutputsRequest>
        void ListServicePipelineOutputsAsync(const ListServicePipelineOutputsRequestT& request, const ListServicePipelineOutputsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ProtonClient::ListServicePipelineOutputs, request, handler, context);
        }
 
        virtual Model::ListServicePipelineProvisionedResourcesOutcome ListServicePipelineProvisionedResources(const Model::ListServicePipelineProvisionedResourcesRequest& request) const;
 
        template<typename ListServicePipelineProvisionedResourcesRequestT = Model::ListServicePipelineProvisionedResourcesRequest>
        Model::ListServicePipelineProvisionedResourcesOutcomeCallable ListServicePipelineProvisionedResourcesCallable(const ListServicePipelineProvisionedResourcesRequestT& request) const
        {
            return SubmitCallable(&ProtonClient::ListServicePipelineProvisionedResources, request);
        }
 
        template<typename ListServicePipelineProvisionedResourcesRequestT = Model::ListServicePipelineProvisionedResourcesRequest>
        void ListServicePipelineProvisionedResourcesAsync(const ListServicePipelineProvisionedResourcesRequestT& request, const ListServicePipelineProvisionedResourcesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ProtonClient::ListServicePipelineProvisionedResources, request, handler, context);
        }
 
        virtual Model::ListServiceTemplateVersionsOutcome ListServiceTemplateVersions(const Model::ListServiceTemplateVersionsRequest& request) const;
 
        template<typename ListServiceTemplateVersionsRequestT = Model::ListServiceTemplateVersionsRequest>
        Model::ListServiceTemplateVersionsOutcomeCallable ListServiceTemplateVersionsCallable(const ListServiceTemplateVersionsRequestT& request) const
        {
            return SubmitCallable(&ProtonClient::ListServiceTemplateVersions, request);
        }
 
        template<typename ListServiceTemplateVersionsRequestT = Model::ListServiceTemplateVersionsRequest>
        void ListServiceTemplateVersionsAsync(const ListServiceTemplateVersionsRequestT& request, const ListServiceTemplateVersionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ProtonClient::ListServiceTemplateVersions, request, handler, context);
        }
 
        virtual Model::ListServiceTemplatesOutcome ListServiceTemplates(const Model::ListServiceTemplatesRequest& request = {}) const;
 
        template<typename ListServiceTemplatesRequestT = Model::ListServiceTemplatesRequest>
        Model::ListServiceTemplatesOutcomeCallable ListServiceTemplatesCallable(const ListServiceTemplatesRequestT& request = {}) const
        {
            return SubmitCallable(&ProtonClient::ListServiceTemplates, request);
        }
 
        template<typename ListServiceTemplatesRequestT = Model::ListServiceTemplatesRequest>
        void ListServiceTemplatesAsync(const ListServiceTemplatesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListServiceTemplatesRequestT& request = {}) const
        {
            return SubmitAsync(&ProtonClient::ListServiceTemplates, request, handler, context);
        }
 
        virtual Model::ListServicesOutcome ListServices(const Model::ListServicesRequest& request = {}) const;
 
        template<typename ListServicesRequestT = Model::ListServicesRequest>
        Model::ListServicesOutcomeCallable ListServicesCallable(const ListServicesRequestT& request = {}) const
        {
            return SubmitCallable(&ProtonClient::ListServices, request);
        }
 
        template<typename ListServicesRequestT = Model::ListServicesRequest>
        void ListServicesAsync(const ListServicesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListServicesRequestT& request = {}) const
        {
            return SubmitAsync(&ProtonClient::ListServices, 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(&ProtonClient::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(&ProtonClient::ListTagsForResource, request, handler, context);
        }
 
        virtual Model::NotifyResourceDeploymentStatusChangeOutcome NotifyResourceDeploymentStatusChange(const Model::NotifyResourceDeploymentStatusChangeRequest& request) const;
 
        template<typename NotifyResourceDeploymentStatusChangeRequestT = Model::NotifyResourceDeploymentStatusChangeRequest>
        Model::NotifyResourceDeploymentStatusChangeOutcomeCallable NotifyResourceDeploymentStatusChangeCallable(const NotifyResourceDeploymentStatusChangeRequestT& request) const
        {
            return SubmitCallable(&ProtonClient::NotifyResourceDeploymentStatusChange, request);
        }
 
        template<typename NotifyResourceDeploymentStatusChangeRequestT = Model::NotifyResourceDeploymentStatusChangeRequest>
        void NotifyResourceDeploymentStatusChangeAsync(const NotifyResourceDeploymentStatusChangeRequestT& request, const NotifyResourceDeploymentStatusChangeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ProtonClient::NotifyResourceDeploymentStatusChange, request, handler, context);
        }
 
        virtual Model::RejectEnvironmentAccountConnectionOutcome RejectEnvironmentAccountConnection(const Model::RejectEnvironmentAccountConnectionRequest& request) const;
 
        template<typename RejectEnvironmentAccountConnectionRequestT = Model::RejectEnvironmentAccountConnectionRequest>
        Model::RejectEnvironmentAccountConnectionOutcomeCallable RejectEnvironmentAccountConnectionCallable(const RejectEnvironmentAccountConnectionRequestT& request) const
        {
            return SubmitCallable(&ProtonClient::RejectEnvironmentAccountConnection, request);
        }
 
        template<typename RejectEnvironmentAccountConnectionRequestT = Model::RejectEnvironmentAccountConnectionRequest>
        void RejectEnvironmentAccountConnectionAsync(const RejectEnvironmentAccountConnectionRequestT& request, const RejectEnvironmentAccountConnectionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ProtonClient::RejectEnvironmentAccountConnection, 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(&ProtonClient::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(&ProtonClient::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(&ProtonClient::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(&ProtonClient::UntagResource, request, handler, context);
        }
 
        virtual Model::UpdateAccountSettingsOutcome UpdateAccountSettings(const Model::UpdateAccountSettingsRequest& request = {}) const;
 
        template<typename UpdateAccountSettingsRequestT = Model::UpdateAccountSettingsRequest>
        Model::UpdateAccountSettingsOutcomeCallable UpdateAccountSettingsCallable(const UpdateAccountSettingsRequestT& request = {}) const
        {
            return SubmitCallable(&ProtonClient::UpdateAccountSettings, request);
        }
 
        template<typename UpdateAccountSettingsRequestT = Model::UpdateAccountSettingsRequest>
        void UpdateAccountSettingsAsync(const UpdateAccountSettingsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const UpdateAccountSettingsRequestT& request = {}) const
        {
            return SubmitAsync(&ProtonClient::UpdateAccountSettings, request, handler, context);
        }
 
        virtual Model::UpdateComponentOutcome UpdateComponent(const Model::UpdateComponentRequest& request) const;
 
        template<typename UpdateComponentRequestT = Model::UpdateComponentRequest>
        Model::UpdateComponentOutcomeCallable UpdateComponentCallable(const UpdateComponentRequestT& request) const
        {
            return SubmitCallable(&ProtonClient::UpdateComponent, request);
        }
 
        template<typename UpdateComponentRequestT = Model::UpdateComponentRequest>
        void UpdateComponentAsync(const UpdateComponentRequestT& request, const UpdateComponentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ProtonClient::UpdateComponent, request, handler, context);
        }
 
        virtual Model::UpdateEnvironmentOutcome UpdateEnvironment(const Model::UpdateEnvironmentRequest& request) const;
 
        template<typename UpdateEnvironmentRequestT = Model::UpdateEnvironmentRequest>
        Model::UpdateEnvironmentOutcomeCallable UpdateEnvironmentCallable(const UpdateEnvironmentRequestT& request) const
        {
            return SubmitCallable(&ProtonClient::UpdateEnvironment, request);
        }
 
        template<typename UpdateEnvironmentRequestT = Model::UpdateEnvironmentRequest>
        void UpdateEnvironmentAsync(const UpdateEnvironmentRequestT& request, const UpdateEnvironmentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ProtonClient::UpdateEnvironment, request, handler, context);
        }
 
        virtual Model::UpdateEnvironmentAccountConnectionOutcome UpdateEnvironmentAccountConnection(const Model::UpdateEnvironmentAccountConnectionRequest& request) const;
 
        template<typename UpdateEnvironmentAccountConnectionRequestT = Model::UpdateEnvironmentAccountConnectionRequest>
        Model::UpdateEnvironmentAccountConnectionOutcomeCallable UpdateEnvironmentAccountConnectionCallable(const UpdateEnvironmentAccountConnectionRequestT& request) const
        {
            return SubmitCallable(&ProtonClient::UpdateEnvironmentAccountConnection, request);
        }
 
        template<typename UpdateEnvironmentAccountConnectionRequestT = Model::UpdateEnvironmentAccountConnectionRequest>
        void UpdateEnvironmentAccountConnectionAsync(const UpdateEnvironmentAccountConnectionRequestT& request, const UpdateEnvironmentAccountConnectionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ProtonClient::UpdateEnvironmentAccountConnection, request, handler, context);
        }
 
        virtual Model::UpdateEnvironmentTemplateOutcome UpdateEnvironmentTemplate(const Model::UpdateEnvironmentTemplateRequest& request) const;
 
        template<typename UpdateEnvironmentTemplateRequestT = Model::UpdateEnvironmentTemplateRequest>
        Model::UpdateEnvironmentTemplateOutcomeCallable UpdateEnvironmentTemplateCallable(const UpdateEnvironmentTemplateRequestT& request) const
        {
            return SubmitCallable(&ProtonClient::UpdateEnvironmentTemplate, request);
        }
 
        template<typename UpdateEnvironmentTemplateRequestT = Model::UpdateEnvironmentTemplateRequest>
        void UpdateEnvironmentTemplateAsync(const UpdateEnvironmentTemplateRequestT& request, const UpdateEnvironmentTemplateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ProtonClient::UpdateEnvironmentTemplate, request, handler, context);
        }
 
        virtual Model::UpdateEnvironmentTemplateVersionOutcome UpdateEnvironmentTemplateVersion(const Model::UpdateEnvironmentTemplateVersionRequest& request) const;
 
        template<typename UpdateEnvironmentTemplateVersionRequestT = Model::UpdateEnvironmentTemplateVersionRequest>
        Model::UpdateEnvironmentTemplateVersionOutcomeCallable UpdateEnvironmentTemplateVersionCallable(const UpdateEnvironmentTemplateVersionRequestT& request) const
        {
            return SubmitCallable(&ProtonClient::UpdateEnvironmentTemplateVersion, request);
        }
 
        template<typename UpdateEnvironmentTemplateVersionRequestT = Model::UpdateEnvironmentTemplateVersionRequest>
        void UpdateEnvironmentTemplateVersionAsync(const UpdateEnvironmentTemplateVersionRequestT& request, const UpdateEnvironmentTemplateVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ProtonClient::UpdateEnvironmentTemplateVersion, request, handler, context);
        }
 
        virtual Model::UpdateServiceOutcome UpdateService(const Model::UpdateServiceRequest& request) const;
 
        template<typename UpdateServiceRequestT = Model::UpdateServiceRequest>
        Model::UpdateServiceOutcomeCallable UpdateServiceCallable(const UpdateServiceRequestT& request) const
        {
            return SubmitCallable(&ProtonClient::UpdateService, request);
        }
 
        template<typename UpdateServiceRequestT = Model::UpdateServiceRequest>
        void UpdateServiceAsync(const UpdateServiceRequestT& request, const UpdateServiceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ProtonClient::UpdateService, request, handler, context);
        }
 
        virtual Model::UpdateServiceInstanceOutcome UpdateServiceInstance(const Model::UpdateServiceInstanceRequest& request) const;
 
        template<typename UpdateServiceInstanceRequestT = Model::UpdateServiceInstanceRequest>
        Model::UpdateServiceInstanceOutcomeCallable UpdateServiceInstanceCallable(const UpdateServiceInstanceRequestT& request) const
        {
            return SubmitCallable(&ProtonClient::UpdateServiceInstance, request);
        }
 
        template<typename UpdateServiceInstanceRequestT = Model::UpdateServiceInstanceRequest>
        void UpdateServiceInstanceAsync(const UpdateServiceInstanceRequestT& request, const UpdateServiceInstanceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ProtonClient::UpdateServiceInstance, request, handler, context);
        }
 
        virtual Model::UpdateServicePipelineOutcome UpdateServicePipeline(const Model::UpdateServicePipelineRequest& request) const;
 
        template<typename UpdateServicePipelineRequestT = Model::UpdateServicePipelineRequest>
        Model::UpdateServicePipelineOutcomeCallable UpdateServicePipelineCallable(const UpdateServicePipelineRequestT& request) const
        {
            return SubmitCallable(&ProtonClient::UpdateServicePipeline, request);
        }
 
        template<typename UpdateServicePipelineRequestT = Model::UpdateServicePipelineRequest>
        void UpdateServicePipelineAsync(const UpdateServicePipelineRequestT& request, const UpdateServicePipelineResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ProtonClient::UpdateServicePipeline, request, handler, context);
        }
 
        virtual Model::UpdateServiceSyncBlockerOutcome UpdateServiceSyncBlocker(const Model::UpdateServiceSyncBlockerRequest& request) const;
 
        template<typename UpdateServiceSyncBlockerRequestT = Model::UpdateServiceSyncBlockerRequest>
        Model::UpdateServiceSyncBlockerOutcomeCallable UpdateServiceSyncBlockerCallable(const UpdateServiceSyncBlockerRequestT& request) const
        {
            return SubmitCallable(&ProtonClient::UpdateServiceSyncBlocker, request);
        }
 
        template<typename UpdateServiceSyncBlockerRequestT = Model::UpdateServiceSyncBlockerRequest>
        void UpdateServiceSyncBlockerAsync(const UpdateServiceSyncBlockerRequestT& request, const UpdateServiceSyncBlockerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ProtonClient::UpdateServiceSyncBlocker, request, handler, context);
        }
 
        virtual Model::UpdateServiceSyncConfigOutcome UpdateServiceSyncConfig(const Model::UpdateServiceSyncConfigRequest& request) const;
 
        template<typename UpdateServiceSyncConfigRequestT = Model::UpdateServiceSyncConfigRequest>
        Model::UpdateServiceSyncConfigOutcomeCallable UpdateServiceSyncConfigCallable(const UpdateServiceSyncConfigRequestT& request) const
        {
            return SubmitCallable(&ProtonClient::UpdateServiceSyncConfig, request);
        }
 
        template<typename UpdateServiceSyncConfigRequestT = Model::UpdateServiceSyncConfigRequest>
        void UpdateServiceSyncConfigAsync(const UpdateServiceSyncConfigRequestT& request, const UpdateServiceSyncConfigResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ProtonClient::UpdateServiceSyncConfig, request, handler, context);
        }
 
        virtual Model::UpdateServiceTemplateOutcome UpdateServiceTemplate(const Model::UpdateServiceTemplateRequest& request) const;
 
        template<typename UpdateServiceTemplateRequestT = Model::UpdateServiceTemplateRequest>
        Model::UpdateServiceTemplateOutcomeCallable UpdateServiceTemplateCallable(const UpdateServiceTemplateRequestT& request) const
        {
            return SubmitCallable(&ProtonClient::UpdateServiceTemplate, request);
        }
 
        template<typename UpdateServiceTemplateRequestT = Model::UpdateServiceTemplateRequest>
        void UpdateServiceTemplateAsync(const UpdateServiceTemplateRequestT& request, const UpdateServiceTemplateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ProtonClient::UpdateServiceTemplate, request, handler, context);
        }
 
        virtual Model::UpdateServiceTemplateVersionOutcome UpdateServiceTemplateVersion(const Model::UpdateServiceTemplateVersionRequest& request) const;
 
        template<typename UpdateServiceTemplateVersionRequestT = Model::UpdateServiceTemplateVersionRequest>
        Model::UpdateServiceTemplateVersionOutcomeCallable UpdateServiceTemplateVersionCallable(const UpdateServiceTemplateVersionRequestT& request) const
        {
            return SubmitCallable(&ProtonClient::UpdateServiceTemplateVersion, request);
        }
 
        template<typename UpdateServiceTemplateVersionRequestT = Model::UpdateServiceTemplateVersionRequest>
        void UpdateServiceTemplateVersionAsync(const UpdateServiceTemplateVersionRequestT& request, const UpdateServiceTemplateVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ProtonClient::UpdateServiceTemplateVersion, request, handler, context);
        }
 
        virtual Model::UpdateTemplateSyncConfigOutcome UpdateTemplateSyncConfig(const Model::UpdateTemplateSyncConfigRequest& request) const;
 
        template<typename UpdateTemplateSyncConfigRequestT = Model::UpdateTemplateSyncConfigRequest>
        Model::UpdateTemplateSyncConfigOutcomeCallable UpdateTemplateSyncConfigCallable(const UpdateTemplateSyncConfigRequestT& request) const
        {
            return SubmitCallable(&ProtonClient::UpdateTemplateSyncConfig, request);
        }
 
        template<typename UpdateTemplateSyncConfigRequestT = Model::UpdateTemplateSyncConfigRequest>
        void UpdateTemplateSyncConfigAsync(const UpdateTemplateSyncConfigRequestT& request, const UpdateTemplateSyncConfigResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ProtonClient::UpdateTemplateSyncConfig, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<ProtonEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<ProtonClient>;
      void init(const ProtonClientConfiguration& clientConfiguration);
 
      ProtonClientConfiguration m_clientConfiguration;
      std::shared_ptr<ProtonEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace Proton
} // namespace Aws