AppMeshClient.h

 
#pragma once
#include <aws/appmesh/AppMesh_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/appmesh/AppMeshServiceClientModel.h>
 
namespace Aws
{
namespace AppMesh
{
  class AWS_APPMESH_API AppMeshClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<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);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<AppMeshEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<AppMeshClient>;
      void init(const AppMeshClientConfiguration& clientConfiguration);
 
      AppMeshClientConfiguration m_clientConfiguration;
      std::shared_ptr<AppMeshEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace AppMesh
} // namespace Aws