AppMeshClient.h

 
#pragma once
#include <aws/appmesh/AppMeshPaginationBase.h>
#include <aws/appmesh/AppMeshServiceClientModel.h>
#include <aws/appmesh/AppMeshWaiter.h>
#include <aws/appmesh/AppMesh_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 AppMesh {
class AWS_APPMESH_API AppMeshClient : public Aws::Client::AWSJsonClient,
                                      public Aws::Client::ClientWithAsyncTemplateMethods<AppMeshClient>,
                                      public AppMeshPaginationBase<AppMeshClient>,
                                      public AppMeshWaiter<AppMeshClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef AppMeshClientConfiguration ClientConfigurationType;
  typedef AppMeshEndpointProvider EndpointProviderType;
 
  AppMeshClient(const Aws::AppMesh::AppMeshClientConfiguration& clientConfiguration = Aws::AppMesh::AppMeshClientConfiguration(),
                std::shared_ptr<AppMeshEndpointProviderBase> endpointProvider = nullptr);
 
  AppMeshClient(const Aws::Auth::AWSCredentials& credentials, std::shared_ptr<AppMeshEndpointProviderBase> endpointProvider = nullptr,
                const Aws::AppMesh::AppMeshClientConfiguration& clientConfiguration = Aws::AppMesh::AppMeshClientConfiguration());
 
  AppMeshClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                std::shared_ptr<AppMeshEndpointProviderBase> endpointProvider = nullptr,
                const Aws::AppMesh::AppMeshClientConfiguration& clientConfiguration = Aws::AppMesh::AppMeshClientConfiguration());
 
  /* Legacy constructors due deprecation */
  AppMeshClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  AppMeshClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  AppMeshClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~AppMeshClient();
 
  virtual Model::CreateGatewayRouteOutcome CreateGatewayRoute(const Model::CreateGatewayRouteRequest& request) const;
 
  template <typename CreateGatewayRouteRequestT = Model::CreateGatewayRouteRequest>
  Model::CreateGatewayRouteOutcomeCallable CreateGatewayRouteCallable(const CreateGatewayRouteRequestT& request) const {
    return SubmitCallable(&AppMeshClient::CreateGatewayRoute, request);
  }
 
  template <typename CreateGatewayRouteRequestT = Model::CreateGatewayRouteRequest>
  void CreateGatewayRouteAsync(const CreateGatewayRouteRequestT& request, const CreateGatewayRouteResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppMeshClient::CreateGatewayRoute, request, handler, context);
  }
 
  virtual Model::CreateMeshOutcome CreateMesh(const Model::CreateMeshRequest& request) const;
 
  template <typename CreateMeshRequestT = Model::CreateMeshRequest>
  Model::CreateMeshOutcomeCallable CreateMeshCallable(const CreateMeshRequestT& request) const {
    return SubmitCallable(&AppMeshClient::CreateMesh, request);
  }
 
  template <typename CreateMeshRequestT = Model::CreateMeshRequest>
  void CreateMeshAsync(const CreateMeshRequestT& request, const CreateMeshResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppMeshClient::CreateMesh, request, handler, context);
  }
 
  virtual Model::CreateRouteOutcome CreateRoute(const Model::CreateRouteRequest& request) const;
 
  template <typename CreateRouteRequestT = Model::CreateRouteRequest>
  Model::CreateRouteOutcomeCallable CreateRouteCallable(const CreateRouteRequestT& request) const {
    return SubmitCallable(&AppMeshClient::CreateRoute, request);
  }
 
  template <typename CreateRouteRequestT = Model::CreateRouteRequest>
  void CreateRouteAsync(const CreateRouteRequestT& request, const CreateRouteResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppMeshClient::CreateRoute, request, handler, context);
  }
 
  virtual Model::CreateVirtualGatewayOutcome CreateVirtualGateway(const Model::CreateVirtualGatewayRequest& request) const;
 
  template <typename CreateVirtualGatewayRequestT = Model::CreateVirtualGatewayRequest>
  Model::CreateVirtualGatewayOutcomeCallable CreateVirtualGatewayCallable(const CreateVirtualGatewayRequestT& request) const {
    return SubmitCallable(&AppMeshClient::CreateVirtualGateway, request);
  }
 
  template <typename CreateVirtualGatewayRequestT = Model::CreateVirtualGatewayRequest>
  void CreateVirtualGatewayAsync(const CreateVirtualGatewayRequestT& request, const CreateVirtualGatewayResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppMeshClient::CreateVirtualGateway, request, handler, context);
  }
 
  virtual Model::CreateVirtualNodeOutcome CreateVirtualNode(const Model::CreateVirtualNodeRequest& request) const;
 
  template <typename CreateVirtualNodeRequestT = Model::CreateVirtualNodeRequest>
  Model::CreateVirtualNodeOutcomeCallable CreateVirtualNodeCallable(const CreateVirtualNodeRequestT& request) const {
    return SubmitCallable(&AppMeshClient::CreateVirtualNode, request);
  }
 
  template <typename CreateVirtualNodeRequestT = Model::CreateVirtualNodeRequest>
  void CreateVirtualNodeAsync(const CreateVirtualNodeRequestT& request, const CreateVirtualNodeResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppMeshClient::CreateVirtualNode, request, handler, context);
  }
 
  virtual Model::CreateVirtualRouterOutcome CreateVirtualRouter(const Model::CreateVirtualRouterRequest& request) const;
 
  template <typename CreateVirtualRouterRequestT = Model::CreateVirtualRouterRequest>
  Model::CreateVirtualRouterOutcomeCallable CreateVirtualRouterCallable(const CreateVirtualRouterRequestT& request) const {
    return SubmitCallable(&AppMeshClient::CreateVirtualRouter, request);
  }
 
  template <typename CreateVirtualRouterRequestT = Model::CreateVirtualRouterRequest>
  void CreateVirtualRouterAsync(const CreateVirtualRouterRequestT& request, const CreateVirtualRouterResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppMeshClient::CreateVirtualRouter, request, handler, context);
  }
 
  virtual Model::CreateVirtualServiceOutcome CreateVirtualService(const Model::CreateVirtualServiceRequest& request) const;
 
  template <typename CreateVirtualServiceRequestT = Model::CreateVirtualServiceRequest>
  Model::CreateVirtualServiceOutcomeCallable CreateVirtualServiceCallable(const CreateVirtualServiceRequestT& request) const {
    return SubmitCallable(&AppMeshClient::CreateVirtualService, request);
  }
 
  template <typename CreateVirtualServiceRequestT = Model::CreateVirtualServiceRequest>
  void CreateVirtualServiceAsync(const CreateVirtualServiceRequestT& request, const CreateVirtualServiceResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppMeshClient::CreateVirtualService, request, handler, context);
  }
 
  virtual Model::DeleteGatewayRouteOutcome DeleteGatewayRoute(const Model::DeleteGatewayRouteRequest& request) const;
 
  template <typename DeleteGatewayRouteRequestT = Model::DeleteGatewayRouteRequest>
  Model::DeleteGatewayRouteOutcomeCallable DeleteGatewayRouteCallable(const DeleteGatewayRouteRequestT& request) const {
    return SubmitCallable(&AppMeshClient::DeleteGatewayRoute, request);
  }
 
  template <typename DeleteGatewayRouteRequestT = Model::DeleteGatewayRouteRequest>
  void DeleteGatewayRouteAsync(const DeleteGatewayRouteRequestT& request, const DeleteGatewayRouteResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppMeshClient::DeleteGatewayRoute, request, handler, context);
  }
 
  virtual Model::DeleteMeshOutcome DeleteMesh(const Model::DeleteMeshRequest& request) const;
 
  template <typename DeleteMeshRequestT = Model::DeleteMeshRequest>
  Model::DeleteMeshOutcomeCallable DeleteMeshCallable(const DeleteMeshRequestT& request) const {
    return SubmitCallable(&AppMeshClient::DeleteMesh, request);
  }
 
  template <typename DeleteMeshRequestT = Model::DeleteMeshRequest>
  void DeleteMeshAsync(const DeleteMeshRequestT& request, const DeleteMeshResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppMeshClient::DeleteMesh, request, handler, context);
  }
 
  virtual Model::DeleteRouteOutcome DeleteRoute(const Model::DeleteRouteRequest& request) const;
 
  template <typename DeleteRouteRequestT = Model::DeleteRouteRequest>
  Model::DeleteRouteOutcomeCallable DeleteRouteCallable(const DeleteRouteRequestT& request) const {
    return SubmitCallable(&AppMeshClient::DeleteRoute, request);
  }
 
  template <typename DeleteRouteRequestT = Model::DeleteRouteRequest>
  void DeleteRouteAsync(const DeleteRouteRequestT& request, const DeleteRouteResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppMeshClient::DeleteRoute, request, handler, context);
  }
 
  virtual Model::DeleteVirtualGatewayOutcome DeleteVirtualGateway(const Model::DeleteVirtualGatewayRequest& request) const;
 
  template <typename DeleteVirtualGatewayRequestT = Model::DeleteVirtualGatewayRequest>
  Model::DeleteVirtualGatewayOutcomeCallable DeleteVirtualGatewayCallable(const DeleteVirtualGatewayRequestT& request) const {
    return SubmitCallable(&AppMeshClient::DeleteVirtualGateway, request);
  }
 
  template <typename DeleteVirtualGatewayRequestT = Model::DeleteVirtualGatewayRequest>
  void DeleteVirtualGatewayAsync(const DeleteVirtualGatewayRequestT& request, const DeleteVirtualGatewayResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppMeshClient::DeleteVirtualGateway, request, handler, context);
  }
 
  virtual Model::DeleteVirtualNodeOutcome DeleteVirtualNode(const Model::DeleteVirtualNodeRequest& request) const;
 
  template <typename DeleteVirtualNodeRequestT = Model::DeleteVirtualNodeRequest>
  Model::DeleteVirtualNodeOutcomeCallable DeleteVirtualNodeCallable(const DeleteVirtualNodeRequestT& request) const {
    return SubmitCallable(&AppMeshClient::DeleteVirtualNode, request);
  }
 
  template <typename DeleteVirtualNodeRequestT = Model::DeleteVirtualNodeRequest>
  void DeleteVirtualNodeAsync(const DeleteVirtualNodeRequestT& request, const DeleteVirtualNodeResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppMeshClient::DeleteVirtualNode, request, handler, context);
  }
 
  virtual Model::DeleteVirtualRouterOutcome DeleteVirtualRouter(const Model::DeleteVirtualRouterRequest& request) const;
 
  template <typename DeleteVirtualRouterRequestT = Model::DeleteVirtualRouterRequest>
  Model::DeleteVirtualRouterOutcomeCallable DeleteVirtualRouterCallable(const DeleteVirtualRouterRequestT& request) const {
    return SubmitCallable(&AppMeshClient::DeleteVirtualRouter, request);
  }
 
  template <typename DeleteVirtualRouterRequestT = Model::DeleteVirtualRouterRequest>
  void DeleteVirtualRouterAsync(const DeleteVirtualRouterRequestT& request, const DeleteVirtualRouterResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppMeshClient::DeleteVirtualRouter, request, handler, context);
  }
 
  virtual Model::DeleteVirtualServiceOutcome DeleteVirtualService(const Model::DeleteVirtualServiceRequest& request) const;
 
  template <typename DeleteVirtualServiceRequestT = Model::DeleteVirtualServiceRequest>
  Model::DeleteVirtualServiceOutcomeCallable DeleteVirtualServiceCallable(const DeleteVirtualServiceRequestT& request) const {
    return SubmitCallable(&AppMeshClient::DeleteVirtualService, request);
  }
 
  template <typename DeleteVirtualServiceRequestT = Model::DeleteVirtualServiceRequest>
  void DeleteVirtualServiceAsync(const DeleteVirtualServiceRequestT& request, const DeleteVirtualServiceResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppMeshClient::DeleteVirtualService, request, handler, context);
  }
 
  virtual Model::DescribeGatewayRouteOutcome DescribeGatewayRoute(const Model::DescribeGatewayRouteRequest& request) const;
 
  template <typename DescribeGatewayRouteRequestT = Model::DescribeGatewayRouteRequest>
  Model::DescribeGatewayRouteOutcomeCallable DescribeGatewayRouteCallable(const DescribeGatewayRouteRequestT& request) const {
    return SubmitCallable(&AppMeshClient::DescribeGatewayRoute, request);
  }
 
  template <typename DescribeGatewayRouteRequestT = Model::DescribeGatewayRouteRequest>
  void DescribeGatewayRouteAsync(const DescribeGatewayRouteRequestT& request, const DescribeGatewayRouteResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppMeshClient::DescribeGatewayRoute, request, handler, context);
  }
 
  virtual Model::DescribeMeshOutcome DescribeMesh(const Model::DescribeMeshRequest& request) const;
 
  template <typename DescribeMeshRequestT = Model::DescribeMeshRequest>
  Model::DescribeMeshOutcomeCallable DescribeMeshCallable(const DescribeMeshRequestT& request) const {
    return SubmitCallable(&AppMeshClient::DescribeMesh, request);
  }
 
  template <typename DescribeMeshRequestT = Model::DescribeMeshRequest>
  void DescribeMeshAsync(const DescribeMeshRequestT& request, const DescribeMeshResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppMeshClient::DescribeMesh, request, handler, context);
  }
 
  virtual Model::DescribeRouteOutcome DescribeRoute(const Model::DescribeRouteRequest& request) const;
 
  template <typename DescribeRouteRequestT = Model::DescribeRouteRequest>
  Model::DescribeRouteOutcomeCallable DescribeRouteCallable(const DescribeRouteRequestT& request) const {
    return SubmitCallable(&AppMeshClient::DescribeRoute, request);
  }
 
  template <typename DescribeRouteRequestT = Model::DescribeRouteRequest>
  void DescribeRouteAsync(const DescribeRouteRequestT& request, const DescribeRouteResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppMeshClient::DescribeRoute, request, handler, context);
  }
 
  virtual Model::DescribeVirtualGatewayOutcome DescribeVirtualGateway(const Model::DescribeVirtualGatewayRequest& request) const;
 
  template <typename DescribeVirtualGatewayRequestT = Model::DescribeVirtualGatewayRequest>
  Model::DescribeVirtualGatewayOutcomeCallable DescribeVirtualGatewayCallable(const DescribeVirtualGatewayRequestT& request) const {
    return SubmitCallable(&AppMeshClient::DescribeVirtualGateway, request);
  }
 
  template <typename DescribeVirtualGatewayRequestT = Model::DescribeVirtualGatewayRequest>
  void DescribeVirtualGatewayAsync(const DescribeVirtualGatewayRequestT& request,
                                   const DescribeVirtualGatewayResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppMeshClient::DescribeVirtualGateway, request, handler, context);
  }
 
  virtual Model::DescribeVirtualNodeOutcome DescribeVirtualNode(const Model::DescribeVirtualNodeRequest& request) const;
 
  template <typename DescribeVirtualNodeRequestT = Model::DescribeVirtualNodeRequest>
  Model::DescribeVirtualNodeOutcomeCallable DescribeVirtualNodeCallable(const DescribeVirtualNodeRequestT& request) const {
    return SubmitCallable(&AppMeshClient::DescribeVirtualNode, request);
  }
 
  template <typename DescribeVirtualNodeRequestT = Model::DescribeVirtualNodeRequest>
  void DescribeVirtualNodeAsync(const DescribeVirtualNodeRequestT& request, const DescribeVirtualNodeResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppMeshClient::DescribeVirtualNode, request, handler, context);
  }
 
  virtual Model::DescribeVirtualRouterOutcome DescribeVirtualRouter(const Model::DescribeVirtualRouterRequest& request) const;
 
  template <typename DescribeVirtualRouterRequestT = Model::DescribeVirtualRouterRequest>
  Model::DescribeVirtualRouterOutcomeCallable DescribeVirtualRouterCallable(const DescribeVirtualRouterRequestT& request) const {
    return SubmitCallable(&AppMeshClient::DescribeVirtualRouter, request);
  }
 
  template <typename DescribeVirtualRouterRequestT = Model::DescribeVirtualRouterRequest>
  void DescribeVirtualRouterAsync(const DescribeVirtualRouterRequestT& request, const DescribeVirtualRouterResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppMeshClient::DescribeVirtualRouter, request, handler, context);
  }
 
  virtual Model::DescribeVirtualServiceOutcome DescribeVirtualService(const Model::DescribeVirtualServiceRequest& request) const;
 
  template <typename DescribeVirtualServiceRequestT = Model::DescribeVirtualServiceRequest>
  Model::DescribeVirtualServiceOutcomeCallable DescribeVirtualServiceCallable(const DescribeVirtualServiceRequestT& request) const {
    return SubmitCallable(&AppMeshClient::DescribeVirtualService, request);
  }
 
  template <typename DescribeVirtualServiceRequestT = Model::DescribeVirtualServiceRequest>
  void DescribeVirtualServiceAsync(const DescribeVirtualServiceRequestT& request,
                                   const DescribeVirtualServiceResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppMeshClient::DescribeVirtualService, request, handler, context);
  }
 
  virtual Model::ListGatewayRoutesOutcome ListGatewayRoutes(const Model::ListGatewayRoutesRequest& request) const;
 
  template <typename ListGatewayRoutesRequestT = Model::ListGatewayRoutesRequest>
  Model::ListGatewayRoutesOutcomeCallable ListGatewayRoutesCallable(const ListGatewayRoutesRequestT& request) const {
    return SubmitCallable(&AppMeshClient::ListGatewayRoutes, request);
  }
 
  template <typename ListGatewayRoutesRequestT = Model::ListGatewayRoutesRequest>
  void ListGatewayRoutesAsync(const ListGatewayRoutesRequestT& request, const ListGatewayRoutesResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppMeshClient::ListGatewayRoutes, request, handler, context);
  }
 
  virtual Model::ListMeshesOutcome ListMeshes(const Model::ListMeshesRequest& request = {}) const;
 
  template <typename ListMeshesRequestT = Model::ListMeshesRequest>
  Model::ListMeshesOutcomeCallable ListMeshesCallable(const ListMeshesRequestT& request = {}) const {
    return SubmitCallable(&AppMeshClient::ListMeshes, request);
  }
 
  template <typename ListMeshesRequestT = Model::ListMeshesRequest>
  void ListMeshesAsync(const ListMeshesResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                       const ListMeshesRequestT& request = {}) const {
    return SubmitAsync(&AppMeshClient::ListMeshes, request, handler, context);
  }
 
  virtual Model::ListRoutesOutcome ListRoutes(const Model::ListRoutesRequest& request) const;
 
  template <typename ListRoutesRequestT = Model::ListRoutesRequest>
  Model::ListRoutesOutcomeCallable ListRoutesCallable(const ListRoutesRequestT& request) const {
    return SubmitCallable(&AppMeshClient::ListRoutes, request);
  }
 
  template <typename ListRoutesRequestT = Model::ListRoutesRequest>
  void ListRoutesAsync(const ListRoutesRequestT& request, const ListRoutesResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppMeshClient::ListRoutes, 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(&AppMeshClient::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(&AppMeshClient::ListTagsForResource, request, handler, context);
  }
 
  virtual Model::ListVirtualGatewaysOutcome ListVirtualGateways(const Model::ListVirtualGatewaysRequest& request) const;
 
  template <typename ListVirtualGatewaysRequestT = Model::ListVirtualGatewaysRequest>
  Model::ListVirtualGatewaysOutcomeCallable ListVirtualGatewaysCallable(const ListVirtualGatewaysRequestT& request) const {
    return SubmitCallable(&AppMeshClient::ListVirtualGateways, request);
  }
 
  template <typename ListVirtualGatewaysRequestT = Model::ListVirtualGatewaysRequest>
  void ListVirtualGatewaysAsync(const ListVirtualGatewaysRequestT& request, const ListVirtualGatewaysResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppMeshClient::ListVirtualGateways, request, handler, context);
  }
 
  virtual Model::ListVirtualNodesOutcome ListVirtualNodes(const Model::ListVirtualNodesRequest& request) const;
 
  template <typename ListVirtualNodesRequestT = Model::ListVirtualNodesRequest>
  Model::ListVirtualNodesOutcomeCallable ListVirtualNodesCallable(const ListVirtualNodesRequestT& request) const {
    return SubmitCallable(&AppMeshClient::ListVirtualNodes, request);
  }
 
  template <typename ListVirtualNodesRequestT = Model::ListVirtualNodesRequest>
  void ListVirtualNodesAsync(const ListVirtualNodesRequestT& request, const ListVirtualNodesResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppMeshClient::ListVirtualNodes, request, handler, context);
  }
 
  virtual Model::ListVirtualRoutersOutcome ListVirtualRouters(const Model::ListVirtualRoutersRequest& request) const;
 
  template <typename ListVirtualRoutersRequestT = Model::ListVirtualRoutersRequest>
  Model::ListVirtualRoutersOutcomeCallable ListVirtualRoutersCallable(const ListVirtualRoutersRequestT& request) const {
    return SubmitCallable(&AppMeshClient::ListVirtualRouters, request);
  }
 
  template <typename ListVirtualRoutersRequestT = Model::ListVirtualRoutersRequest>
  void ListVirtualRoutersAsync(const ListVirtualRoutersRequestT& request, const ListVirtualRoutersResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppMeshClient::ListVirtualRouters, request, handler, context);
  }
 
  virtual Model::ListVirtualServicesOutcome ListVirtualServices(const Model::ListVirtualServicesRequest& request) const;
 
  template <typename ListVirtualServicesRequestT = Model::ListVirtualServicesRequest>
  Model::ListVirtualServicesOutcomeCallable ListVirtualServicesCallable(const ListVirtualServicesRequestT& request) const {
    return SubmitCallable(&AppMeshClient::ListVirtualServices, request);
  }
 
  template <typename ListVirtualServicesRequestT = Model::ListVirtualServicesRequest>
  void ListVirtualServicesAsync(const ListVirtualServicesRequestT& request, const ListVirtualServicesResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppMeshClient::ListVirtualServices, 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(&AppMeshClient::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(&AppMeshClient::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(&AppMeshClient::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(&AppMeshClient::UntagResource, request, handler, context);
  }
 
  virtual Model::UpdateGatewayRouteOutcome UpdateGatewayRoute(const Model::UpdateGatewayRouteRequest& request) const;
 
  template <typename UpdateGatewayRouteRequestT = Model::UpdateGatewayRouteRequest>
  Model::UpdateGatewayRouteOutcomeCallable UpdateGatewayRouteCallable(const UpdateGatewayRouteRequestT& request) const {
    return SubmitCallable(&AppMeshClient::UpdateGatewayRoute, request);
  }
 
  template <typename UpdateGatewayRouteRequestT = Model::UpdateGatewayRouteRequest>
  void UpdateGatewayRouteAsync(const UpdateGatewayRouteRequestT& request, const UpdateGatewayRouteResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppMeshClient::UpdateGatewayRoute, request, handler, context);
  }
 
  virtual Model::UpdateMeshOutcome UpdateMesh(const Model::UpdateMeshRequest& request) const;
 
  template <typename UpdateMeshRequestT = Model::UpdateMeshRequest>
  Model::UpdateMeshOutcomeCallable UpdateMeshCallable(const UpdateMeshRequestT& request) const {
    return SubmitCallable(&AppMeshClient::UpdateMesh, request);
  }
 
  template <typename UpdateMeshRequestT = Model::UpdateMeshRequest>
  void UpdateMeshAsync(const UpdateMeshRequestT& request, const UpdateMeshResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppMeshClient::UpdateMesh, request, handler, context);
  }
 
  virtual Model::UpdateRouteOutcome UpdateRoute(const Model::UpdateRouteRequest& request) const;
 
  template <typename UpdateRouteRequestT = Model::UpdateRouteRequest>
  Model::UpdateRouteOutcomeCallable UpdateRouteCallable(const UpdateRouteRequestT& request) const {
    return SubmitCallable(&AppMeshClient::UpdateRoute, request);
  }
 
  template <typename UpdateRouteRequestT = Model::UpdateRouteRequest>
  void UpdateRouteAsync(const UpdateRouteRequestT& request, const UpdateRouteResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppMeshClient::UpdateRoute, request, handler, context);
  }
 
  virtual Model::UpdateVirtualGatewayOutcome UpdateVirtualGateway(const Model::UpdateVirtualGatewayRequest& request) const;
 
  template <typename UpdateVirtualGatewayRequestT = Model::UpdateVirtualGatewayRequest>
  Model::UpdateVirtualGatewayOutcomeCallable UpdateVirtualGatewayCallable(const UpdateVirtualGatewayRequestT& request) const {
    return SubmitCallable(&AppMeshClient::UpdateVirtualGateway, request);
  }
 
  template <typename UpdateVirtualGatewayRequestT = Model::UpdateVirtualGatewayRequest>
  void UpdateVirtualGatewayAsync(const UpdateVirtualGatewayRequestT& request, const UpdateVirtualGatewayResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppMeshClient::UpdateVirtualGateway, request, handler, context);
  }
 
  virtual Model::UpdateVirtualNodeOutcome UpdateVirtualNode(const Model::UpdateVirtualNodeRequest& request) const;
 
  template <typename UpdateVirtualNodeRequestT = Model::UpdateVirtualNodeRequest>
  Model::UpdateVirtualNodeOutcomeCallable UpdateVirtualNodeCallable(const UpdateVirtualNodeRequestT& request) const {
    return SubmitCallable(&AppMeshClient::UpdateVirtualNode, request);
  }
 
  template <typename UpdateVirtualNodeRequestT = Model::UpdateVirtualNodeRequest>
  void UpdateVirtualNodeAsync(const UpdateVirtualNodeRequestT& request, const UpdateVirtualNodeResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppMeshClient::UpdateVirtualNode, request, handler, context);
  }
 
  virtual Model::UpdateVirtualRouterOutcome UpdateVirtualRouter(const Model::UpdateVirtualRouterRequest& request) const;
 
  template <typename UpdateVirtualRouterRequestT = Model::UpdateVirtualRouterRequest>
  Model::UpdateVirtualRouterOutcomeCallable UpdateVirtualRouterCallable(const UpdateVirtualRouterRequestT& request) const {
    return SubmitCallable(&AppMeshClient::UpdateVirtualRouter, request);
  }
 
  template <typename UpdateVirtualRouterRequestT = Model::UpdateVirtualRouterRequest>
  void UpdateVirtualRouterAsync(const UpdateVirtualRouterRequestT& request, const UpdateVirtualRouterResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppMeshClient::UpdateVirtualRouter, request, handler, context);
  }
 
  virtual Model::UpdateVirtualServiceOutcome UpdateVirtualService(const Model::UpdateVirtualServiceRequest& request) const;
 
  template <typename UpdateVirtualServiceRequestT = Model::UpdateVirtualServiceRequest>
  Model::UpdateVirtualServiceOutcomeCallable UpdateVirtualServiceCallable(const UpdateVirtualServiceRequestT& request) const {
    return SubmitCallable(&AppMeshClient::UpdateVirtualService, request);
  }
 
  template <typename UpdateVirtualServiceRequestT = Model::UpdateVirtualServiceRequest>
  void UpdateVirtualServiceAsync(const UpdateVirtualServiceRequestT& request, const UpdateVirtualServiceResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppMeshClient::UpdateVirtualService, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<AppMeshEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<AppMeshClient>;
  void init(const AppMeshClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, AppMeshError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request,
                                                const std::function<void(Aws::Endpoint::ResolveEndpointOutcome&)>& resolveUri,
                                                Aws::Http::HttpMethod httpMethod) const;
 
  AppMeshClientConfiguration m_clientConfiguration;
  std::shared_ptr<AppMeshEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace AppMesh
}  // namespace Aws