AppRunnerClient.h

 
#pragma once
#include <aws/apprunner/AppRunner_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/apprunner/AppRunnerServiceClientModel.h>
 
namespace Aws
{
namespace AppRunner
{
  class AWS_APPRUNNER_API AppRunnerClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<AppRunnerClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef AppRunnerClientConfiguration ClientConfigurationType;
      typedef AppRunnerEndpointProvider EndpointProviderType;
 
        AppRunnerClient(const Aws::AppRunner::AppRunnerClientConfiguration& clientConfiguration = Aws::AppRunner::AppRunnerClientConfiguration(),
                        std::shared_ptr<AppRunnerEndpointProviderBase> endpointProvider = nullptr);
 
        AppRunnerClient(const Aws::Auth::AWSCredentials& credentials,
                        std::shared_ptr<AppRunnerEndpointProviderBase> endpointProvider = nullptr,
                        const Aws::AppRunner::AppRunnerClientConfiguration& clientConfiguration = Aws::AppRunner::AppRunnerClientConfiguration());
 
        AppRunnerClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                        std::shared_ptr<AppRunnerEndpointProviderBase> endpointProvider = nullptr,
                        const Aws::AppRunner::AppRunnerClientConfiguration& clientConfiguration = Aws::AppRunner::AppRunnerClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        AppRunnerClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        AppRunnerClient(const Aws::Auth::AWSCredentials& credentials,
                        const Aws::Client::ClientConfiguration& clientConfiguration);
 
        AppRunnerClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                        const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~AppRunnerClient();
 
        virtual Model::AssociateCustomDomainOutcome AssociateCustomDomain(const Model::AssociateCustomDomainRequest& request) const;
 
        template<typename AssociateCustomDomainRequestT = Model::AssociateCustomDomainRequest>
        Model::AssociateCustomDomainOutcomeCallable AssociateCustomDomainCallable(const AssociateCustomDomainRequestT& request) const
        {
            return SubmitCallable(&AppRunnerClient::AssociateCustomDomain, request);
        }
 
        template<typename AssociateCustomDomainRequestT = Model::AssociateCustomDomainRequest>
        void AssociateCustomDomainAsync(const AssociateCustomDomainRequestT& request, const AssociateCustomDomainResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AppRunnerClient::AssociateCustomDomain, request, handler, context);
        }
 
        virtual Model::CreateAutoScalingConfigurationOutcome CreateAutoScalingConfiguration(const Model::CreateAutoScalingConfigurationRequest& request) const;
 
        template<typename CreateAutoScalingConfigurationRequestT = Model::CreateAutoScalingConfigurationRequest>
        Model::CreateAutoScalingConfigurationOutcomeCallable CreateAutoScalingConfigurationCallable(const CreateAutoScalingConfigurationRequestT& request) const
        {
            return SubmitCallable(&AppRunnerClient::CreateAutoScalingConfiguration, request);
        }
 
        template<typename CreateAutoScalingConfigurationRequestT = Model::CreateAutoScalingConfigurationRequest>
        void CreateAutoScalingConfigurationAsync(const CreateAutoScalingConfigurationRequestT& request, const CreateAutoScalingConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AppRunnerClient::CreateAutoScalingConfiguration, request, handler, context);
        }
 
        virtual Model::CreateConnectionOutcome CreateConnection(const Model::CreateConnectionRequest& request) const;
 
        template<typename CreateConnectionRequestT = Model::CreateConnectionRequest>
        Model::CreateConnectionOutcomeCallable CreateConnectionCallable(const CreateConnectionRequestT& request) const
        {
            return SubmitCallable(&AppRunnerClient::CreateConnection, request);
        }
 
        template<typename CreateConnectionRequestT = Model::CreateConnectionRequest>
        void CreateConnectionAsync(const CreateConnectionRequestT& request, const CreateConnectionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AppRunnerClient::CreateConnection, request, handler, context);
        }
 
        virtual Model::CreateObservabilityConfigurationOutcome CreateObservabilityConfiguration(const Model::CreateObservabilityConfigurationRequest& request) const;
 
        template<typename CreateObservabilityConfigurationRequestT = Model::CreateObservabilityConfigurationRequest>
        Model::CreateObservabilityConfigurationOutcomeCallable CreateObservabilityConfigurationCallable(const CreateObservabilityConfigurationRequestT& request) const
        {
            return SubmitCallable(&AppRunnerClient::CreateObservabilityConfiguration, request);
        }
 
        template<typename CreateObservabilityConfigurationRequestT = Model::CreateObservabilityConfigurationRequest>
        void CreateObservabilityConfigurationAsync(const CreateObservabilityConfigurationRequestT& request, const CreateObservabilityConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AppRunnerClient::CreateObservabilityConfiguration, 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(&AppRunnerClient::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(&AppRunnerClient::CreateService, request, handler, context);
        }
 
        virtual Model::CreateVpcConnectorOutcome CreateVpcConnector(const Model::CreateVpcConnectorRequest& request) const;
 
        template<typename CreateVpcConnectorRequestT = Model::CreateVpcConnectorRequest>
        Model::CreateVpcConnectorOutcomeCallable CreateVpcConnectorCallable(const CreateVpcConnectorRequestT& request) const
        {
            return SubmitCallable(&AppRunnerClient::CreateVpcConnector, request);
        }
 
        template<typename CreateVpcConnectorRequestT = Model::CreateVpcConnectorRequest>
        void CreateVpcConnectorAsync(const CreateVpcConnectorRequestT& request, const CreateVpcConnectorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AppRunnerClient::CreateVpcConnector, request, handler, context);
        }
 
        virtual Model::CreateVpcIngressConnectionOutcome CreateVpcIngressConnection(const Model::CreateVpcIngressConnectionRequest& request) const;
 
        template<typename CreateVpcIngressConnectionRequestT = Model::CreateVpcIngressConnectionRequest>
        Model::CreateVpcIngressConnectionOutcomeCallable CreateVpcIngressConnectionCallable(const CreateVpcIngressConnectionRequestT& request) const
        {
            return SubmitCallable(&AppRunnerClient::CreateVpcIngressConnection, request);
        }
 
        template<typename CreateVpcIngressConnectionRequestT = Model::CreateVpcIngressConnectionRequest>
        void CreateVpcIngressConnectionAsync(const CreateVpcIngressConnectionRequestT& request, const CreateVpcIngressConnectionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AppRunnerClient::CreateVpcIngressConnection, request, handler, context);
        }
 
        virtual Model::DeleteAutoScalingConfigurationOutcome DeleteAutoScalingConfiguration(const Model::DeleteAutoScalingConfigurationRequest& request) const;
 
        template<typename DeleteAutoScalingConfigurationRequestT = Model::DeleteAutoScalingConfigurationRequest>
        Model::DeleteAutoScalingConfigurationOutcomeCallable DeleteAutoScalingConfigurationCallable(const DeleteAutoScalingConfigurationRequestT& request) const
        {
            return SubmitCallable(&AppRunnerClient::DeleteAutoScalingConfiguration, request);
        }
 
        template<typename DeleteAutoScalingConfigurationRequestT = Model::DeleteAutoScalingConfigurationRequest>
        void DeleteAutoScalingConfigurationAsync(const DeleteAutoScalingConfigurationRequestT& request, const DeleteAutoScalingConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AppRunnerClient::DeleteAutoScalingConfiguration, request, handler, context);
        }
 
        virtual Model::DeleteConnectionOutcome DeleteConnection(const Model::DeleteConnectionRequest& request) const;
 
        template<typename DeleteConnectionRequestT = Model::DeleteConnectionRequest>
        Model::DeleteConnectionOutcomeCallable DeleteConnectionCallable(const DeleteConnectionRequestT& request) const
        {
            return SubmitCallable(&AppRunnerClient::DeleteConnection, request);
        }
 
        template<typename DeleteConnectionRequestT = Model::DeleteConnectionRequest>
        void DeleteConnectionAsync(const DeleteConnectionRequestT& request, const DeleteConnectionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AppRunnerClient::DeleteConnection, request, handler, context);
        }
 
        virtual Model::DeleteObservabilityConfigurationOutcome DeleteObservabilityConfiguration(const Model::DeleteObservabilityConfigurationRequest& request) const;
 
        template<typename DeleteObservabilityConfigurationRequestT = Model::DeleteObservabilityConfigurationRequest>
        Model::DeleteObservabilityConfigurationOutcomeCallable DeleteObservabilityConfigurationCallable(const DeleteObservabilityConfigurationRequestT& request) const
        {
            return SubmitCallable(&AppRunnerClient::DeleteObservabilityConfiguration, request);
        }
 
        template<typename DeleteObservabilityConfigurationRequestT = Model::DeleteObservabilityConfigurationRequest>
        void DeleteObservabilityConfigurationAsync(const DeleteObservabilityConfigurationRequestT& request, const DeleteObservabilityConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AppRunnerClient::DeleteObservabilityConfiguration, 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(&AppRunnerClient::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(&AppRunnerClient::DeleteService, request, handler, context);
        }
 
        virtual Model::DeleteVpcConnectorOutcome DeleteVpcConnector(const Model::DeleteVpcConnectorRequest& request) const;
 
        template<typename DeleteVpcConnectorRequestT = Model::DeleteVpcConnectorRequest>
        Model::DeleteVpcConnectorOutcomeCallable DeleteVpcConnectorCallable(const DeleteVpcConnectorRequestT& request) const
        {
            return SubmitCallable(&AppRunnerClient::DeleteVpcConnector, request);
        }
 
        template<typename DeleteVpcConnectorRequestT = Model::DeleteVpcConnectorRequest>
        void DeleteVpcConnectorAsync(const DeleteVpcConnectorRequestT& request, const DeleteVpcConnectorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AppRunnerClient::DeleteVpcConnector, request, handler, context);
        }
 
        virtual Model::DeleteVpcIngressConnectionOutcome DeleteVpcIngressConnection(const Model::DeleteVpcIngressConnectionRequest& request) const;
 
        template<typename DeleteVpcIngressConnectionRequestT = Model::DeleteVpcIngressConnectionRequest>
        Model::DeleteVpcIngressConnectionOutcomeCallable DeleteVpcIngressConnectionCallable(const DeleteVpcIngressConnectionRequestT& request) const
        {
            return SubmitCallable(&AppRunnerClient::DeleteVpcIngressConnection, request);
        }
 
        template<typename DeleteVpcIngressConnectionRequestT = Model::DeleteVpcIngressConnectionRequest>
        void DeleteVpcIngressConnectionAsync(const DeleteVpcIngressConnectionRequestT& request, const DeleteVpcIngressConnectionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AppRunnerClient::DeleteVpcIngressConnection, request, handler, context);
        }
 
        virtual Model::DescribeAutoScalingConfigurationOutcome DescribeAutoScalingConfiguration(const Model::DescribeAutoScalingConfigurationRequest& request) const;
 
        template<typename DescribeAutoScalingConfigurationRequestT = Model::DescribeAutoScalingConfigurationRequest>
        Model::DescribeAutoScalingConfigurationOutcomeCallable DescribeAutoScalingConfigurationCallable(const DescribeAutoScalingConfigurationRequestT& request) const
        {
            return SubmitCallable(&AppRunnerClient::DescribeAutoScalingConfiguration, request);
        }
 
        template<typename DescribeAutoScalingConfigurationRequestT = Model::DescribeAutoScalingConfigurationRequest>
        void DescribeAutoScalingConfigurationAsync(const DescribeAutoScalingConfigurationRequestT& request, const DescribeAutoScalingConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AppRunnerClient::DescribeAutoScalingConfiguration, request, handler, context);
        }
 
        virtual Model::DescribeCustomDomainsOutcome DescribeCustomDomains(const Model::DescribeCustomDomainsRequest& request) const;
 
        template<typename DescribeCustomDomainsRequestT = Model::DescribeCustomDomainsRequest>
        Model::DescribeCustomDomainsOutcomeCallable DescribeCustomDomainsCallable(const DescribeCustomDomainsRequestT& request) const
        {
            return SubmitCallable(&AppRunnerClient::DescribeCustomDomains, request);
        }
 
        template<typename DescribeCustomDomainsRequestT = Model::DescribeCustomDomainsRequest>
        void DescribeCustomDomainsAsync(const DescribeCustomDomainsRequestT& request, const DescribeCustomDomainsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AppRunnerClient::DescribeCustomDomains, request, handler, context);
        }
 
        virtual Model::DescribeObservabilityConfigurationOutcome DescribeObservabilityConfiguration(const Model::DescribeObservabilityConfigurationRequest& request) const;
 
        template<typename DescribeObservabilityConfigurationRequestT = Model::DescribeObservabilityConfigurationRequest>
        Model::DescribeObservabilityConfigurationOutcomeCallable DescribeObservabilityConfigurationCallable(const DescribeObservabilityConfigurationRequestT& request) const
        {
            return SubmitCallable(&AppRunnerClient::DescribeObservabilityConfiguration, request);
        }
 
        template<typename DescribeObservabilityConfigurationRequestT = Model::DescribeObservabilityConfigurationRequest>
        void DescribeObservabilityConfigurationAsync(const DescribeObservabilityConfigurationRequestT& request, const DescribeObservabilityConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AppRunnerClient::DescribeObservabilityConfiguration, request, handler, context);
        }
 
        virtual Model::DescribeServiceOutcome DescribeService(const Model::DescribeServiceRequest& request) const;
 
        template<typename DescribeServiceRequestT = Model::DescribeServiceRequest>
        Model::DescribeServiceOutcomeCallable DescribeServiceCallable(const DescribeServiceRequestT& request) const
        {
            return SubmitCallable(&AppRunnerClient::DescribeService, request);
        }
 
        template<typename DescribeServiceRequestT = Model::DescribeServiceRequest>
        void DescribeServiceAsync(const DescribeServiceRequestT& request, const DescribeServiceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AppRunnerClient::DescribeService, request, handler, context);
        }
 
        virtual Model::DescribeVpcConnectorOutcome DescribeVpcConnector(const Model::DescribeVpcConnectorRequest& request) const;
 
        template<typename DescribeVpcConnectorRequestT = Model::DescribeVpcConnectorRequest>
        Model::DescribeVpcConnectorOutcomeCallable DescribeVpcConnectorCallable(const DescribeVpcConnectorRequestT& request) const
        {
            return SubmitCallable(&AppRunnerClient::DescribeVpcConnector, request);
        }
 
        template<typename DescribeVpcConnectorRequestT = Model::DescribeVpcConnectorRequest>
        void DescribeVpcConnectorAsync(const DescribeVpcConnectorRequestT& request, const DescribeVpcConnectorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AppRunnerClient::DescribeVpcConnector, request, handler, context);
        }
 
        virtual Model::DescribeVpcIngressConnectionOutcome DescribeVpcIngressConnection(const Model::DescribeVpcIngressConnectionRequest& request) const;
 
        template<typename DescribeVpcIngressConnectionRequestT = Model::DescribeVpcIngressConnectionRequest>
        Model::DescribeVpcIngressConnectionOutcomeCallable DescribeVpcIngressConnectionCallable(const DescribeVpcIngressConnectionRequestT& request) const
        {
            return SubmitCallable(&AppRunnerClient::DescribeVpcIngressConnection, request);
        }
 
        template<typename DescribeVpcIngressConnectionRequestT = Model::DescribeVpcIngressConnectionRequest>
        void DescribeVpcIngressConnectionAsync(const DescribeVpcIngressConnectionRequestT& request, const DescribeVpcIngressConnectionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AppRunnerClient::DescribeVpcIngressConnection, request, handler, context);
        }
 
        virtual Model::DisassociateCustomDomainOutcome DisassociateCustomDomain(const Model::DisassociateCustomDomainRequest& request) const;
 
        template<typename DisassociateCustomDomainRequestT = Model::DisassociateCustomDomainRequest>
        Model::DisassociateCustomDomainOutcomeCallable DisassociateCustomDomainCallable(const DisassociateCustomDomainRequestT& request) const
        {
            return SubmitCallable(&AppRunnerClient::DisassociateCustomDomain, request);
        }
 
        template<typename DisassociateCustomDomainRequestT = Model::DisassociateCustomDomainRequest>
        void DisassociateCustomDomainAsync(const DisassociateCustomDomainRequestT& request, const DisassociateCustomDomainResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AppRunnerClient::DisassociateCustomDomain, request, handler, context);
        }
 
        virtual Model::ListAutoScalingConfigurationsOutcome ListAutoScalingConfigurations(const Model::ListAutoScalingConfigurationsRequest& request = {}) const;
 
        template<typename ListAutoScalingConfigurationsRequestT = Model::ListAutoScalingConfigurationsRequest>
        Model::ListAutoScalingConfigurationsOutcomeCallable ListAutoScalingConfigurationsCallable(const ListAutoScalingConfigurationsRequestT& request = {}) const
        {
            return SubmitCallable(&AppRunnerClient::ListAutoScalingConfigurations, request);
        }
 
        template<typename ListAutoScalingConfigurationsRequestT = Model::ListAutoScalingConfigurationsRequest>
        void ListAutoScalingConfigurationsAsync(const ListAutoScalingConfigurationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListAutoScalingConfigurationsRequestT& request = {}) const
        {
            return SubmitAsync(&AppRunnerClient::ListAutoScalingConfigurations, request, handler, context);
        }
 
        virtual Model::ListConnectionsOutcome ListConnections(const Model::ListConnectionsRequest& request = {}) const;
 
        template<typename ListConnectionsRequestT = Model::ListConnectionsRequest>
        Model::ListConnectionsOutcomeCallable ListConnectionsCallable(const ListConnectionsRequestT& request = {}) const
        {
            return SubmitCallable(&AppRunnerClient::ListConnections, request);
        }
 
        template<typename ListConnectionsRequestT = Model::ListConnectionsRequest>
        void ListConnectionsAsync(const ListConnectionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListConnectionsRequestT& request = {}) const
        {
            return SubmitAsync(&AppRunnerClient::ListConnections, request, handler, context);
        }
 
        virtual Model::ListObservabilityConfigurationsOutcome ListObservabilityConfigurations(const Model::ListObservabilityConfigurationsRequest& request = {}) const;
 
        template<typename ListObservabilityConfigurationsRequestT = Model::ListObservabilityConfigurationsRequest>
        Model::ListObservabilityConfigurationsOutcomeCallable ListObservabilityConfigurationsCallable(const ListObservabilityConfigurationsRequestT& request = {}) const
        {
            return SubmitCallable(&AppRunnerClient::ListObservabilityConfigurations, request);
        }
 
        template<typename ListObservabilityConfigurationsRequestT = Model::ListObservabilityConfigurationsRequest>
        void ListObservabilityConfigurationsAsync(const ListObservabilityConfigurationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListObservabilityConfigurationsRequestT& request = {}) const
        {
            return SubmitAsync(&AppRunnerClient::ListObservabilityConfigurations, request, handler, context);
        }
 
        virtual Model::ListOperationsOutcome ListOperations(const Model::ListOperationsRequest& request) const;
 
        template<typename ListOperationsRequestT = Model::ListOperationsRequest>
        Model::ListOperationsOutcomeCallable ListOperationsCallable(const ListOperationsRequestT& request) const
        {
            return SubmitCallable(&AppRunnerClient::ListOperations, request);
        }
 
        template<typename ListOperationsRequestT = Model::ListOperationsRequest>
        void ListOperationsAsync(const ListOperationsRequestT& request, const ListOperationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AppRunnerClient::ListOperations, 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(&AppRunnerClient::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(&AppRunnerClient::ListServices, request, handler, context);
        }
 
        virtual Model::ListServicesForAutoScalingConfigurationOutcome ListServicesForAutoScalingConfiguration(const Model::ListServicesForAutoScalingConfigurationRequest& request) const;
 
        template<typename ListServicesForAutoScalingConfigurationRequestT = Model::ListServicesForAutoScalingConfigurationRequest>
        Model::ListServicesForAutoScalingConfigurationOutcomeCallable ListServicesForAutoScalingConfigurationCallable(const ListServicesForAutoScalingConfigurationRequestT& request) const
        {
            return SubmitCallable(&AppRunnerClient::ListServicesForAutoScalingConfiguration, request);
        }
 
        template<typename ListServicesForAutoScalingConfigurationRequestT = Model::ListServicesForAutoScalingConfigurationRequest>
        void ListServicesForAutoScalingConfigurationAsync(const ListServicesForAutoScalingConfigurationRequestT& request, const ListServicesForAutoScalingConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AppRunnerClient::ListServicesForAutoScalingConfiguration, 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(&AppRunnerClient::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(&AppRunnerClient::ListTagsForResource, request, handler, context);
        }
 
        virtual Model::ListVpcConnectorsOutcome ListVpcConnectors(const Model::ListVpcConnectorsRequest& request = {}) const;
 
        template<typename ListVpcConnectorsRequestT = Model::ListVpcConnectorsRequest>
        Model::ListVpcConnectorsOutcomeCallable ListVpcConnectorsCallable(const ListVpcConnectorsRequestT& request = {}) const
        {
            return SubmitCallable(&AppRunnerClient::ListVpcConnectors, request);
        }
 
        template<typename ListVpcConnectorsRequestT = Model::ListVpcConnectorsRequest>
        void ListVpcConnectorsAsync(const ListVpcConnectorsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListVpcConnectorsRequestT& request = {}) const
        {
            return SubmitAsync(&AppRunnerClient::ListVpcConnectors, request, handler, context);
        }
 
        virtual Model::ListVpcIngressConnectionsOutcome ListVpcIngressConnections(const Model::ListVpcIngressConnectionsRequest& request = {}) const;
 
        template<typename ListVpcIngressConnectionsRequestT = Model::ListVpcIngressConnectionsRequest>
        Model::ListVpcIngressConnectionsOutcomeCallable ListVpcIngressConnectionsCallable(const ListVpcIngressConnectionsRequestT& request = {}) const
        {
            return SubmitCallable(&AppRunnerClient::ListVpcIngressConnections, request);
        }
 
        template<typename ListVpcIngressConnectionsRequestT = Model::ListVpcIngressConnectionsRequest>
        void ListVpcIngressConnectionsAsync(const ListVpcIngressConnectionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListVpcIngressConnectionsRequestT& request = {}) const
        {
            return SubmitAsync(&AppRunnerClient::ListVpcIngressConnections, request, handler, context);
        }
 
        virtual Model::PauseServiceOutcome PauseService(const Model::PauseServiceRequest& request) const;
 
        template<typename PauseServiceRequestT = Model::PauseServiceRequest>
        Model::PauseServiceOutcomeCallable PauseServiceCallable(const PauseServiceRequestT& request) const
        {
            return SubmitCallable(&AppRunnerClient::PauseService, request);
        }
 
        template<typename PauseServiceRequestT = Model::PauseServiceRequest>
        void PauseServiceAsync(const PauseServiceRequestT& request, const PauseServiceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AppRunnerClient::PauseService, request, handler, context);
        }
 
        virtual Model::ResumeServiceOutcome ResumeService(const Model::ResumeServiceRequest& request) const;
 
        template<typename ResumeServiceRequestT = Model::ResumeServiceRequest>
        Model::ResumeServiceOutcomeCallable ResumeServiceCallable(const ResumeServiceRequestT& request) const
        {
            return SubmitCallable(&AppRunnerClient::ResumeService, request);
        }
 
        template<typename ResumeServiceRequestT = Model::ResumeServiceRequest>
        void ResumeServiceAsync(const ResumeServiceRequestT& request, const ResumeServiceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AppRunnerClient::ResumeService, 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(&AppRunnerClient::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(&AppRunnerClient::StartDeployment, 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(&AppRunnerClient::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(&AppRunnerClient::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(&AppRunnerClient::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(&AppRunnerClient::UntagResource, request, handler, context);
        }
 
        virtual Model::UpdateDefaultAutoScalingConfigurationOutcome UpdateDefaultAutoScalingConfiguration(const Model::UpdateDefaultAutoScalingConfigurationRequest& request) const;
 
        template<typename UpdateDefaultAutoScalingConfigurationRequestT = Model::UpdateDefaultAutoScalingConfigurationRequest>
        Model::UpdateDefaultAutoScalingConfigurationOutcomeCallable UpdateDefaultAutoScalingConfigurationCallable(const UpdateDefaultAutoScalingConfigurationRequestT& request) const
        {
            return SubmitCallable(&AppRunnerClient::UpdateDefaultAutoScalingConfiguration, request);
        }
 
        template<typename UpdateDefaultAutoScalingConfigurationRequestT = Model::UpdateDefaultAutoScalingConfigurationRequest>
        void UpdateDefaultAutoScalingConfigurationAsync(const UpdateDefaultAutoScalingConfigurationRequestT& request, const UpdateDefaultAutoScalingConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AppRunnerClient::UpdateDefaultAutoScalingConfiguration, 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(&AppRunnerClient::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(&AppRunnerClient::UpdateService, request, handler, context);
        }
 
        virtual Model::UpdateVpcIngressConnectionOutcome UpdateVpcIngressConnection(const Model::UpdateVpcIngressConnectionRequest& request) const;
 
        template<typename UpdateVpcIngressConnectionRequestT = Model::UpdateVpcIngressConnectionRequest>
        Model::UpdateVpcIngressConnectionOutcomeCallable UpdateVpcIngressConnectionCallable(const UpdateVpcIngressConnectionRequestT& request) const
        {
            return SubmitCallable(&AppRunnerClient::UpdateVpcIngressConnection, request);
        }
 
        template<typename UpdateVpcIngressConnectionRequestT = Model::UpdateVpcIngressConnectionRequest>
        void UpdateVpcIngressConnectionAsync(const UpdateVpcIngressConnectionRequestT& request, const UpdateVpcIngressConnectionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AppRunnerClient::UpdateVpcIngressConnection, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<AppRunnerEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<AppRunnerClient>;
      void init(const AppRunnerClientConfiguration& clientConfiguration);
 
      AppRunnerClientConfiguration m_clientConfiguration;
      std::shared_ptr<AppRunnerEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace AppRunner
} // namespace Aws