AppRunnerClient.h

 
#pragma once
#include <aws/apprunner/AppRunnerPaginationBase.h>
#include <aws/apprunner/AppRunnerServiceClientModel.h>
#include <aws/apprunner/AppRunnerWaiter.h>
#include <aws/apprunner/AppRunner_EXPORTS.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/utils/json/JsonSerializer.h>
 
namespace Aws {
namespace AppRunner {
class AWS_APPRUNNER_API AppRunnerClient : public Aws::Client::AWSJsonClient,
                                          public Aws::Client::ClientWithAsyncTemplateMethods<AppRunnerClient>,
                                          public AppRunnerPaginationBase<AppRunnerClient>,
                                          public AppRunnerWaiter<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);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<AppRunnerEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<AppRunnerClient>;
  void init(const AppRunnerClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, AppRunnerError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request, Aws::Http::HttpMethod httpMethod) const;
 
  AppRunnerClientConfiguration m_clientConfiguration;
  std::shared_ptr<AppRunnerEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace AppRunner
}  // namespace Aws