NetworkManagerClient.h

 
#pragma once
#include <aws/networkmanager/NetworkManager_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/networkmanager/NetworkManagerServiceClientModel.h>
 
namespace Aws
{
namespace NetworkManager
{
  class AWS_NETWORKMANAGER_API NetworkManagerClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<NetworkManagerClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef NetworkManagerClientConfiguration ClientConfigurationType;
      typedef NetworkManagerEndpointProvider EndpointProviderType;
 
        NetworkManagerClient(const Aws::NetworkManager::NetworkManagerClientConfiguration& clientConfiguration = Aws::NetworkManager::NetworkManagerClientConfiguration(),
                             std::shared_ptr<NetworkManagerEndpointProviderBase> endpointProvider = nullptr);
 
        NetworkManagerClient(const Aws::Auth::AWSCredentials& credentials,
                             std::shared_ptr<NetworkManagerEndpointProviderBase> endpointProvider = nullptr,
                             const Aws::NetworkManager::NetworkManagerClientConfiguration& clientConfiguration = Aws::NetworkManager::NetworkManagerClientConfiguration());
 
        NetworkManagerClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                             std::shared_ptr<NetworkManagerEndpointProviderBase> endpointProvider = nullptr,
                             const Aws::NetworkManager::NetworkManagerClientConfiguration& clientConfiguration = Aws::NetworkManager::NetworkManagerClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        NetworkManagerClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        NetworkManagerClient(const Aws::Auth::AWSCredentials& credentials,
                             const Aws::Client::ClientConfiguration& clientConfiguration);
 
        NetworkManagerClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                             const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~NetworkManagerClient();
 
        virtual Model::AcceptAttachmentOutcome AcceptAttachment(const Model::AcceptAttachmentRequest& request) const;
 
        template<typename AcceptAttachmentRequestT = Model::AcceptAttachmentRequest>
        Model::AcceptAttachmentOutcomeCallable AcceptAttachmentCallable(const AcceptAttachmentRequestT& request) const
        {
            return SubmitCallable(&NetworkManagerClient::AcceptAttachment, request);
        }
 
        template<typename AcceptAttachmentRequestT = Model::AcceptAttachmentRequest>
        void AcceptAttachmentAsync(const AcceptAttachmentRequestT& request, const AcceptAttachmentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&NetworkManagerClient::AcceptAttachment, request, handler, context);
        }
 
        virtual Model::AssociateConnectPeerOutcome AssociateConnectPeer(const Model::AssociateConnectPeerRequest& request) const;
 
        template<typename AssociateConnectPeerRequestT = Model::AssociateConnectPeerRequest>
        Model::AssociateConnectPeerOutcomeCallable AssociateConnectPeerCallable(const AssociateConnectPeerRequestT& request) const
        {
            return SubmitCallable(&NetworkManagerClient::AssociateConnectPeer, request);
        }
 
        template<typename AssociateConnectPeerRequestT = Model::AssociateConnectPeerRequest>
        void AssociateConnectPeerAsync(const AssociateConnectPeerRequestT& request, const AssociateConnectPeerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&NetworkManagerClient::AssociateConnectPeer, request, handler, context);
        }
 
        virtual Model::AssociateCustomerGatewayOutcome AssociateCustomerGateway(const Model::AssociateCustomerGatewayRequest& request) const;
 
        template<typename AssociateCustomerGatewayRequestT = Model::AssociateCustomerGatewayRequest>
        Model::AssociateCustomerGatewayOutcomeCallable AssociateCustomerGatewayCallable(const AssociateCustomerGatewayRequestT& request) const
        {
            return SubmitCallable(&NetworkManagerClient::AssociateCustomerGateway, request);
        }
 
        template<typename AssociateCustomerGatewayRequestT = Model::AssociateCustomerGatewayRequest>
        void AssociateCustomerGatewayAsync(const AssociateCustomerGatewayRequestT& request, const AssociateCustomerGatewayResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&NetworkManagerClient::AssociateCustomerGateway, request, handler, context);
        }
 
        virtual Model::AssociateLinkOutcome AssociateLink(const Model::AssociateLinkRequest& request) const;
 
        template<typename AssociateLinkRequestT = Model::AssociateLinkRequest>
        Model::AssociateLinkOutcomeCallable AssociateLinkCallable(const AssociateLinkRequestT& request) const
        {
            return SubmitCallable(&NetworkManagerClient::AssociateLink, request);
        }
 
        template<typename AssociateLinkRequestT = Model::AssociateLinkRequest>
        void AssociateLinkAsync(const AssociateLinkRequestT& request, const AssociateLinkResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&NetworkManagerClient::AssociateLink, request, handler, context);
        }
 
        virtual Model::AssociateTransitGatewayConnectPeerOutcome AssociateTransitGatewayConnectPeer(const Model::AssociateTransitGatewayConnectPeerRequest& request) const;
 
        template<typename AssociateTransitGatewayConnectPeerRequestT = Model::AssociateTransitGatewayConnectPeerRequest>
        Model::AssociateTransitGatewayConnectPeerOutcomeCallable AssociateTransitGatewayConnectPeerCallable(const AssociateTransitGatewayConnectPeerRequestT& request) const
        {
            return SubmitCallable(&NetworkManagerClient::AssociateTransitGatewayConnectPeer, request);
        }
 
        template<typename AssociateTransitGatewayConnectPeerRequestT = Model::AssociateTransitGatewayConnectPeerRequest>
        void AssociateTransitGatewayConnectPeerAsync(const AssociateTransitGatewayConnectPeerRequestT& request, const AssociateTransitGatewayConnectPeerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&NetworkManagerClient::AssociateTransitGatewayConnectPeer, request, handler, context);
        }
 
        virtual Model::CreateConnectAttachmentOutcome CreateConnectAttachment(const Model::CreateConnectAttachmentRequest& request) const;
 
        template<typename CreateConnectAttachmentRequestT = Model::CreateConnectAttachmentRequest>
        Model::CreateConnectAttachmentOutcomeCallable CreateConnectAttachmentCallable(const CreateConnectAttachmentRequestT& request) const
        {
            return SubmitCallable(&NetworkManagerClient::CreateConnectAttachment, request);
        }
 
        template<typename CreateConnectAttachmentRequestT = Model::CreateConnectAttachmentRequest>
        void CreateConnectAttachmentAsync(const CreateConnectAttachmentRequestT& request, const CreateConnectAttachmentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&NetworkManagerClient::CreateConnectAttachment, request, handler, context);
        }
 
        virtual Model::CreateConnectPeerOutcome CreateConnectPeer(const Model::CreateConnectPeerRequest& request) const;
 
        template<typename CreateConnectPeerRequestT = Model::CreateConnectPeerRequest>
        Model::CreateConnectPeerOutcomeCallable CreateConnectPeerCallable(const CreateConnectPeerRequestT& request) const
        {
            return SubmitCallable(&NetworkManagerClient::CreateConnectPeer, request);
        }
 
        template<typename CreateConnectPeerRequestT = Model::CreateConnectPeerRequest>
        void CreateConnectPeerAsync(const CreateConnectPeerRequestT& request, const CreateConnectPeerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&NetworkManagerClient::CreateConnectPeer, 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(&NetworkManagerClient::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(&NetworkManagerClient::CreateConnection, request, handler, context);
        }
 
        virtual Model::CreateCoreNetworkOutcome CreateCoreNetwork(const Model::CreateCoreNetworkRequest& request) const;
 
        template<typename CreateCoreNetworkRequestT = Model::CreateCoreNetworkRequest>
        Model::CreateCoreNetworkOutcomeCallable CreateCoreNetworkCallable(const CreateCoreNetworkRequestT& request) const
        {
            return SubmitCallable(&NetworkManagerClient::CreateCoreNetwork, request);
        }
 
        template<typename CreateCoreNetworkRequestT = Model::CreateCoreNetworkRequest>
        void CreateCoreNetworkAsync(const CreateCoreNetworkRequestT& request, const CreateCoreNetworkResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&NetworkManagerClient::CreateCoreNetwork, request, handler, context);
        }
 
        virtual Model::CreateDeviceOutcome CreateDevice(const Model::CreateDeviceRequest& request) const;
 
        template<typename CreateDeviceRequestT = Model::CreateDeviceRequest>
        Model::CreateDeviceOutcomeCallable CreateDeviceCallable(const CreateDeviceRequestT& request) const
        {
            return SubmitCallable(&NetworkManagerClient::CreateDevice, request);
        }
 
        template<typename CreateDeviceRequestT = Model::CreateDeviceRequest>
        void CreateDeviceAsync(const CreateDeviceRequestT& request, const CreateDeviceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&NetworkManagerClient::CreateDevice, request, handler, context);
        }
 
        virtual Model::CreateGlobalNetworkOutcome CreateGlobalNetwork(const Model::CreateGlobalNetworkRequest& request = {}) const;
 
        template<typename CreateGlobalNetworkRequestT = Model::CreateGlobalNetworkRequest>
        Model::CreateGlobalNetworkOutcomeCallable CreateGlobalNetworkCallable(const CreateGlobalNetworkRequestT& request = {}) const
        {
            return SubmitCallable(&NetworkManagerClient::CreateGlobalNetwork, request);
        }
 
        template<typename CreateGlobalNetworkRequestT = Model::CreateGlobalNetworkRequest>
        void CreateGlobalNetworkAsync(const CreateGlobalNetworkResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const CreateGlobalNetworkRequestT& request = {}) const
        {
            return SubmitAsync(&NetworkManagerClient::CreateGlobalNetwork, request, handler, context);
        }
 
        virtual Model::CreateLinkOutcome CreateLink(const Model::CreateLinkRequest& request) const;
 
        template<typename CreateLinkRequestT = Model::CreateLinkRequest>
        Model::CreateLinkOutcomeCallable CreateLinkCallable(const CreateLinkRequestT& request) const
        {
            return SubmitCallable(&NetworkManagerClient::CreateLink, request);
        }
 
        template<typename CreateLinkRequestT = Model::CreateLinkRequest>
        void CreateLinkAsync(const CreateLinkRequestT& request, const CreateLinkResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&NetworkManagerClient::CreateLink, request, handler, context);
        }
 
        virtual Model::CreateSiteOutcome CreateSite(const Model::CreateSiteRequest& request) const;
 
        template<typename CreateSiteRequestT = Model::CreateSiteRequest>
        Model::CreateSiteOutcomeCallable CreateSiteCallable(const CreateSiteRequestT& request) const
        {
            return SubmitCallable(&NetworkManagerClient::CreateSite, request);
        }
 
        template<typename CreateSiteRequestT = Model::CreateSiteRequest>
        void CreateSiteAsync(const CreateSiteRequestT& request, const CreateSiteResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&NetworkManagerClient::CreateSite, request, handler, context);
        }
 
        virtual Model::CreateSiteToSiteVpnAttachmentOutcome CreateSiteToSiteVpnAttachment(const Model::CreateSiteToSiteVpnAttachmentRequest& request) const;
 
        template<typename CreateSiteToSiteVpnAttachmentRequestT = Model::CreateSiteToSiteVpnAttachmentRequest>
        Model::CreateSiteToSiteVpnAttachmentOutcomeCallable CreateSiteToSiteVpnAttachmentCallable(const CreateSiteToSiteVpnAttachmentRequestT& request) const
        {
            return SubmitCallable(&NetworkManagerClient::CreateSiteToSiteVpnAttachment, request);
        }
 
        template<typename CreateSiteToSiteVpnAttachmentRequestT = Model::CreateSiteToSiteVpnAttachmentRequest>
        void CreateSiteToSiteVpnAttachmentAsync(const CreateSiteToSiteVpnAttachmentRequestT& request, const CreateSiteToSiteVpnAttachmentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&NetworkManagerClient::CreateSiteToSiteVpnAttachment, request, handler, context);
        }
 
        virtual Model::CreateTransitGatewayPeeringOutcome CreateTransitGatewayPeering(const Model::CreateTransitGatewayPeeringRequest& request) const;
 
        template<typename CreateTransitGatewayPeeringRequestT = Model::CreateTransitGatewayPeeringRequest>
        Model::CreateTransitGatewayPeeringOutcomeCallable CreateTransitGatewayPeeringCallable(const CreateTransitGatewayPeeringRequestT& request) const
        {
            return SubmitCallable(&NetworkManagerClient::CreateTransitGatewayPeering, request);
        }
 
        template<typename CreateTransitGatewayPeeringRequestT = Model::CreateTransitGatewayPeeringRequest>
        void CreateTransitGatewayPeeringAsync(const CreateTransitGatewayPeeringRequestT& request, const CreateTransitGatewayPeeringResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&NetworkManagerClient::CreateTransitGatewayPeering, request, handler, context);
        }
 
        virtual Model::CreateTransitGatewayRouteTableAttachmentOutcome CreateTransitGatewayRouteTableAttachment(const Model::CreateTransitGatewayRouteTableAttachmentRequest& request) const;
 
        template<typename CreateTransitGatewayRouteTableAttachmentRequestT = Model::CreateTransitGatewayRouteTableAttachmentRequest>
        Model::CreateTransitGatewayRouteTableAttachmentOutcomeCallable CreateTransitGatewayRouteTableAttachmentCallable(const CreateTransitGatewayRouteTableAttachmentRequestT& request) const
        {
            return SubmitCallable(&NetworkManagerClient::CreateTransitGatewayRouteTableAttachment, request);
        }
 
        template<typename CreateTransitGatewayRouteTableAttachmentRequestT = Model::CreateTransitGatewayRouteTableAttachmentRequest>
        void CreateTransitGatewayRouteTableAttachmentAsync(const CreateTransitGatewayRouteTableAttachmentRequestT& request, const CreateTransitGatewayRouteTableAttachmentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&NetworkManagerClient::CreateTransitGatewayRouteTableAttachment, request, handler, context);
        }
 
        virtual Model::CreateVpcAttachmentOutcome CreateVpcAttachment(const Model::CreateVpcAttachmentRequest& request) const;
 
        template<typename CreateVpcAttachmentRequestT = Model::CreateVpcAttachmentRequest>
        Model::CreateVpcAttachmentOutcomeCallable CreateVpcAttachmentCallable(const CreateVpcAttachmentRequestT& request) const
        {
            return SubmitCallable(&NetworkManagerClient::CreateVpcAttachment, request);
        }
 
        template<typename CreateVpcAttachmentRequestT = Model::CreateVpcAttachmentRequest>
        void CreateVpcAttachmentAsync(const CreateVpcAttachmentRequestT& request, const CreateVpcAttachmentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&NetworkManagerClient::CreateVpcAttachment, request, handler, context);
        }
 
        virtual Model::DeleteAttachmentOutcome DeleteAttachment(const Model::DeleteAttachmentRequest& request) const;
 
        template<typename DeleteAttachmentRequestT = Model::DeleteAttachmentRequest>
        Model::DeleteAttachmentOutcomeCallable DeleteAttachmentCallable(const DeleteAttachmentRequestT& request) const
        {
            return SubmitCallable(&NetworkManagerClient::DeleteAttachment, request);
        }
 
        template<typename DeleteAttachmentRequestT = Model::DeleteAttachmentRequest>
        void DeleteAttachmentAsync(const DeleteAttachmentRequestT& request, const DeleteAttachmentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&NetworkManagerClient::DeleteAttachment, request, handler, context);
        }
 
        virtual Model::DeleteConnectPeerOutcome DeleteConnectPeer(const Model::DeleteConnectPeerRequest& request) const;
 
        template<typename DeleteConnectPeerRequestT = Model::DeleteConnectPeerRequest>
        Model::DeleteConnectPeerOutcomeCallable DeleteConnectPeerCallable(const DeleteConnectPeerRequestT& request) const
        {
            return SubmitCallable(&NetworkManagerClient::DeleteConnectPeer, request);
        }
 
        template<typename DeleteConnectPeerRequestT = Model::DeleteConnectPeerRequest>
        void DeleteConnectPeerAsync(const DeleteConnectPeerRequestT& request, const DeleteConnectPeerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&NetworkManagerClient::DeleteConnectPeer, 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(&NetworkManagerClient::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(&NetworkManagerClient::DeleteConnection, request, handler, context);
        }
 
        virtual Model::DeleteCoreNetworkOutcome DeleteCoreNetwork(const Model::DeleteCoreNetworkRequest& request) const;
 
        template<typename DeleteCoreNetworkRequestT = Model::DeleteCoreNetworkRequest>
        Model::DeleteCoreNetworkOutcomeCallable DeleteCoreNetworkCallable(const DeleteCoreNetworkRequestT& request) const
        {
            return SubmitCallable(&NetworkManagerClient::DeleteCoreNetwork, request);
        }
 
        template<typename DeleteCoreNetworkRequestT = Model::DeleteCoreNetworkRequest>
        void DeleteCoreNetworkAsync(const DeleteCoreNetworkRequestT& request, const DeleteCoreNetworkResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&NetworkManagerClient::DeleteCoreNetwork, request, handler, context);
        }
 
        virtual Model::DeleteCoreNetworkPolicyVersionOutcome DeleteCoreNetworkPolicyVersion(const Model::DeleteCoreNetworkPolicyVersionRequest& request) const;
 
        template<typename DeleteCoreNetworkPolicyVersionRequestT = Model::DeleteCoreNetworkPolicyVersionRequest>
        Model::DeleteCoreNetworkPolicyVersionOutcomeCallable DeleteCoreNetworkPolicyVersionCallable(const DeleteCoreNetworkPolicyVersionRequestT& request) const
        {
            return SubmitCallable(&NetworkManagerClient::DeleteCoreNetworkPolicyVersion, request);
        }
 
        template<typename DeleteCoreNetworkPolicyVersionRequestT = Model::DeleteCoreNetworkPolicyVersionRequest>
        void DeleteCoreNetworkPolicyVersionAsync(const DeleteCoreNetworkPolicyVersionRequestT& request, const DeleteCoreNetworkPolicyVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&NetworkManagerClient::DeleteCoreNetworkPolicyVersion, request, handler, context);
        }
 
        virtual Model::DeleteDeviceOutcome DeleteDevice(const Model::DeleteDeviceRequest& request) const;
 
        template<typename DeleteDeviceRequestT = Model::DeleteDeviceRequest>
        Model::DeleteDeviceOutcomeCallable DeleteDeviceCallable(const DeleteDeviceRequestT& request) const
        {
            return SubmitCallable(&NetworkManagerClient::DeleteDevice, request);
        }
 
        template<typename DeleteDeviceRequestT = Model::DeleteDeviceRequest>
        void DeleteDeviceAsync(const DeleteDeviceRequestT& request, const DeleteDeviceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&NetworkManagerClient::DeleteDevice, request, handler, context);
        }
 
        virtual Model::DeleteGlobalNetworkOutcome DeleteGlobalNetwork(const Model::DeleteGlobalNetworkRequest& request) const;
 
        template<typename DeleteGlobalNetworkRequestT = Model::DeleteGlobalNetworkRequest>
        Model::DeleteGlobalNetworkOutcomeCallable DeleteGlobalNetworkCallable(const DeleteGlobalNetworkRequestT& request) const
        {
            return SubmitCallable(&NetworkManagerClient::DeleteGlobalNetwork, request);
        }
 
        template<typename DeleteGlobalNetworkRequestT = Model::DeleteGlobalNetworkRequest>
        void DeleteGlobalNetworkAsync(const DeleteGlobalNetworkRequestT& request, const DeleteGlobalNetworkResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&NetworkManagerClient::DeleteGlobalNetwork, request, handler, context);
        }
 
        virtual Model::DeleteLinkOutcome DeleteLink(const Model::DeleteLinkRequest& request) const;
 
        template<typename DeleteLinkRequestT = Model::DeleteLinkRequest>
        Model::DeleteLinkOutcomeCallable DeleteLinkCallable(const DeleteLinkRequestT& request) const
        {
            return SubmitCallable(&NetworkManagerClient::DeleteLink, request);
        }
 
        template<typename DeleteLinkRequestT = Model::DeleteLinkRequest>
        void DeleteLinkAsync(const DeleteLinkRequestT& request, const DeleteLinkResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&NetworkManagerClient::DeleteLink, request, handler, context);
        }
 
        virtual Model::DeletePeeringOutcome DeletePeering(const Model::DeletePeeringRequest& request) const;
 
        template<typename DeletePeeringRequestT = Model::DeletePeeringRequest>
        Model::DeletePeeringOutcomeCallable DeletePeeringCallable(const DeletePeeringRequestT& request) const
        {
            return SubmitCallable(&NetworkManagerClient::DeletePeering, request);
        }
 
        template<typename DeletePeeringRequestT = Model::DeletePeeringRequest>
        void DeletePeeringAsync(const DeletePeeringRequestT& request, const DeletePeeringResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&NetworkManagerClient::DeletePeering, request, handler, context);
        }
 
        virtual Model::DeleteResourcePolicyOutcome DeleteResourcePolicy(const Model::DeleteResourcePolicyRequest& request) const;
 
        template<typename DeleteResourcePolicyRequestT = Model::DeleteResourcePolicyRequest>
        Model::DeleteResourcePolicyOutcomeCallable DeleteResourcePolicyCallable(const DeleteResourcePolicyRequestT& request) const
        {
            return SubmitCallable(&NetworkManagerClient::DeleteResourcePolicy, request);
        }
 
        template<typename DeleteResourcePolicyRequestT = Model::DeleteResourcePolicyRequest>
        void DeleteResourcePolicyAsync(const DeleteResourcePolicyRequestT& request, const DeleteResourcePolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&NetworkManagerClient::DeleteResourcePolicy, request, handler, context);
        }
 
        virtual Model::DeleteSiteOutcome DeleteSite(const Model::DeleteSiteRequest& request) const;
 
        template<typename DeleteSiteRequestT = Model::DeleteSiteRequest>
        Model::DeleteSiteOutcomeCallable DeleteSiteCallable(const DeleteSiteRequestT& request) const
        {
            return SubmitCallable(&NetworkManagerClient::DeleteSite, request);
        }
 
        template<typename DeleteSiteRequestT = Model::DeleteSiteRequest>
        void DeleteSiteAsync(const DeleteSiteRequestT& request, const DeleteSiteResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&NetworkManagerClient::DeleteSite, request, handler, context);
        }
 
        virtual Model::DeregisterTransitGatewayOutcome DeregisterTransitGateway(const Model::DeregisterTransitGatewayRequest& request) const;
 
        template<typename DeregisterTransitGatewayRequestT = Model::DeregisterTransitGatewayRequest>
        Model::DeregisterTransitGatewayOutcomeCallable DeregisterTransitGatewayCallable(const DeregisterTransitGatewayRequestT& request) const
        {
            return SubmitCallable(&NetworkManagerClient::DeregisterTransitGateway, request);
        }
 
        template<typename DeregisterTransitGatewayRequestT = Model::DeregisterTransitGatewayRequest>
        void DeregisterTransitGatewayAsync(const DeregisterTransitGatewayRequestT& request, const DeregisterTransitGatewayResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&NetworkManagerClient::DeregisterTransitGateway, request, handler, context);
        }
 
        virtual Model::DescribeGlobalNetworksOutcome DescribeGlobalNetworks(const Model::DescribeGlobalNetworksRequest& request = {}) const;
 
        template<typename DescribeGlobalNetworksRequestT = Model::DescribeGlobalNetworksRequest>
        Model::DescribeGlobalNetworksOutcomeCallable DescribeGlobalNetworksCallable(const DescribeGlobalNetworksRequestT& request = {}) const
        {
            return SubmitCallable(&NetworkManagerClient::DescribeGlobalNetworks, request);
        }
 
        template<typename DescribeGlobalNetworksRequestT = Model::DescribeGlobalNetworksRequest>
        void DescribeGlobalNetworksAsync(const DescribeGlobalNetworksResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeGlobalNetworksRequestT& request = {}) const
        {
            return SubmitAsync(&NetworkManagerClient::DescribeGlobalNetworks, request, handler, context);
        }
 
        virtual Model::DisassociateConnectPeerOutcome DisassociateConnectPeer(const Model::DisassociateConnectPeerRequest& request) const;
 
        template<typename DisassociateConnectPeerRequestT = Model::DisassociateConnectPeerRequest>
        Model::DisassociateConnectPeerOutcomeCallable DisassociateConnectPeerCallable(const DisassociateConnectPeerRequestT& request) const
        {
            return SubmitCallable(&NetworkManagerClient::DisassociateConnectPeer, request);
        }
 
        template<typename DisassociateConnectPeerRequestT = Model::DisassociateConnectPeerRequest>
        void DisassociateConnectPeerAsync(const DisassociateConnectPeerRequestT& request, const DisassociateConnectPeerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&NetworkManagerClient::DisassociateConnectPeer, request, handler, context);
        }
 
        virtual Model::DisassociateCustomerGatewayOutcome DisassociateCustomerGateway(const Model::DisassociateCustomerGatewayRequest& request) const;
 
        template<typename DisassociateCustomerGatewayRequestT = Model::DisassociateCustomerGatewayRequest>
        Model::DisassociateCustomerGatewayOutcomeCallable DisassociateCustomerGatewayCallable(const DisassociateCustomerGatewayRequestT& request) const
        {
            return SubmitCallable(&NetworkManagerClient::DisassociateCustomerGateway, request);
        }
 
        template<typename DisassociateCustomerGatewayRequestT = Model::DisassociateCustomerGatewayRequest>
        void DisassociateCustomerGatewayAsync(const DisassociateCustomerGatewayRequestT& request, const DisassociateCustomerGatewayResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&NetworkManagerClient::DisassociateCustomerGateway, request, handler, context);
        }
 
        virtual Model::DisassociateLinkOutcome DisassociateLink(const Model::DisassociateLinkRequest& request) const;
 
        template<typename DisassociateLinkRequestT = Model::DisassociateLinkRequest>
        Model::DisassociateLinkOutcomeCallable DisassociateLinkCallable(const DisassociateLinkRequestT& request) const
        {
            return SubmitCallable(&NetworkManagerClient::DisassociateLink, request);
        }
 
        template<typename DisassociateLinkRequestT = Model::DisassociateLinkRequest>
        void DisassociateLinkAsync(const DisassociateLinkRequestT& request, const DisassociateLinkResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&NetworkManagerClient::DisassociateLink, request, handler, context);
        }
 
        virtual Model::DisassociateTransitGatewayConnectPeerOutcome DisassociateTransitGatewayConnectPeer(const Model::DisassociateTransitGatewayConnectPeerRequest& request) const;
 
        template<typename DisassociateTransitGatewayConnectPeerRequestT = Model::DisassociateTransitGatewayConnectPeerRequest>
        Model::DisassociateTransitGatewayConnectPeerOutcomeCallable DisassociateTransitGatewayConnectPeerCallable(const DisassociateTransitGatewayConnectPeerRequestT& request) const
        {
            return SubmitCallable(&NetworkManagerClient::DisassociateTransitGatewayConnectPeer, request);
        }
 
        template<typename DisassociateTransitGatewayConnectPeerRequestT = Model::DisassociateTransitGatewayConnectPeerRequest>
        void DisassociateTransitGatewayConnectPeerAsync(const DisassociateTransitGatewayConnectPeerRequestT& request, const DisassociateTransitGatewayConnectPeerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&NetworkManagerClient::DisassociateTransitGatewayConnectPeer, request, handler, context);
        }
 
        virtual Model::ExecuteCoreNetworkChangeSetOutcome ExecuteCoreNetworkChangeSet(const Model::ExecuteCoreNetworkChangeSetRequest& request) const;
 
        template<typename ExecuteCoreNetworkChangeSetRequestT = Model::ExecuteCoreNetworkChangeSetRequest>
        Model::ExecuteCoreNetworkChangeSetOutcomeCallable ExecuteCoreNetworkChangeSetCallable(const ExecuteCoreNetworkChangeSetRequestT& request) const
        {
            return SubmitCallable(&NetworkManagerClient::ExecuteCoreNetworkChangeSet, request);
        }
 
        template<typename ExecuteCoreNetworkChangeSetRequestT = Model::ExecuteCoreNetworkChangeSetRequest>
        void ExecuteCoreNetworkChangeSetAsync(const ExecuteCoreNetworkChangeSetRequestT& request, const ExecuteCoreNetworkChangeSetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&NetworkManagerClient::ExecuteCoreNetworkChangeSet, request, handler, context);
        }
 
        virtual Model::GetConnectAttachmentOutcome GetConnectAttachment(const Model::GetConnectAttachmentRequest& request) const;
 
        template<typename GetConnectAttachmentRequestT = Model::GetConnectAttachmentRequest>
        Model::GetConnectAttachmentOutcomeCallable GetConnectAttachmentCallable(const GetConnectAttachmentRequestT& request) const
        {
            return SubmitCallable(&NetworkManagerClient::GetConnectAttachment, request);
        }
 
        template<typename GetConnectAttachmentRequestT = Model::GetConnectAttachmentRequest>
        void GetConnectAttachmentAsync(const GetConnectAttachmentRequestT& request, const GetConnectAttachmentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&NetworkManagerClient::GetConnectAttachment, request, handler, context);
        }
 
        virtual Model::GetConnectPeerOutcome GetConnectPeer(const Model::GetConnectPeerRequest& request) const;
 
        template<typename GetConnectPeerRequestT = Model::GetConnectPeerRequest>
        Model::GetConnectPeerOutcomeCallable GetConnectPeerCallable(const GetConnectPeerRequestT& request) const
        {
            return SubmitCallable(&NetworkManagerClient::GetConnectPeer, request);
        }
 
        template<typename GetConnectPeerRequestT = Model::GetConnectPeerRequest>
        void GetConnectPeerAsync(const GetConnectPeerRequestT& request, const GetConnectPeerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&NetworkManagerClient::GetConnectPeer, request, handler, context);
        }
 
        virtual Model::GetConnectPeerAssociationsOutcome GetConnectPeerAssociations(const Model::GetConnectPeerAssociationsRequest& request) const;
 
        template<typename GetConnectPeerAssociationsRequestT = Model::GetConnectPeerAssociationsRequest>
        Model::GetConnectPeerAssociationsOutcomeCallable GetConnectPeerAssociationsCallable(const GetConnectPeerAssociationsRequestT& request) const
        {
            return SubmitCallable(&NetworkManagerClient::GetConnectPeerAssociations, request);
        }
 
        template<typename GetConnectPeerAssociationsRequestT = Model::GetConnectPeerAssociationsRequest>
        void GetConnectPeerAssociationsAsync(const GetConnectPeerAssociationsRequestT& request, const GetConnectPeerAssociationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&NetworkManagerClient::GetConnectPeerAssociations, request, handler, context);
        }
 
        virtual Model::GetConnectionsOutcome GetConnections(const Model::GetConnectionsRequest& request) const;
 
        template<typename GetConnectionsRequestT = Model::GetConnectionsRequest>
        Model::GetConnectionsOutcomeCallable GetConnectionsCallable(const GetConnectionsRequestT& request) const
        {
            return SubmitCallable(&NetworkManagerClient::GetConnections, request);
        }
 
        template<typename GetConnectionsRequestT = Model::GetConnectionsRequest>
        void GetConnectionsAsync(const GetConnectionsRequestT& request, const GetConnectionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&NetworkManagerClient::GetConnections, request, handler, context);
        }
 
        virtual Model::GetCoreNetworkOutcome GetCoreNetwork(const Model::GetCoreNetworkRequest& request) const;
 
        template<typename GetCoreNetworkRequestT = Model::GetCoreNetworkRequest>
        Model::GetCoreNetworkOutcomeCallable GetCoreNetworkCallable(const GetCoreNetworkRequestT& request) const
        {
            return SubmitCallable(&NetworkManagerClient::GetCoreNetwork, request);
        }
 
        template<typename GetCoreNetworkRequestT = Model::GetCoreNetworkRequest>
        void GetCoreNetworkAsync(const GetCoreNetworkRequestT& request, const GetCoreNetworkResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&NetworkManagerClient::GetCoreNetwork, request, handler, context);
        }
 
        virtual Model::GetCoreNetworkChangeEventsOutcome GetCoreNetworkChangeEvents(const Model::GetCoreNetworkChangeEventsRequest& request) const;
 
        template<typename GetCoreNetworkChangeEventsRequestT = Model::GetCoreNetworkChangeEventsRequest>
        Model::GetCoreNetworkChangeEventsOutcomeCallable GetCoreNetworkChangeEventsCallable(const GetCoreNetworkChangeEventsRequestT& request) const
        {
            return SubmitCallable(&NetworkManagerClient::GetCoreNetworkChangeEvents, request);
        }
 
        template<typename GetCoreNetworkChangeEventsRequestT = Model::GetCoreNetworkChangeEventsRequest>
        void GetCoreNetworkChangeEventsAsync(const GetCoreNetworkChangeEventsRequestT& request, const GetCoreNetworkChangeEventsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&NetworkManagerClient::GetCoreNetworkChangeEvents, request, handler, context);
        }
 
        virtual Model::GetCoreNetworkChangeSetOutcome GetCoreNetworkChangeSet(const Model::GetCoreNetworkChangeSetRequest& request) const;
 
        template<typename GetCoreNetworkChangeSetRequestT = Model::GetCoreNetworkChangeSetRequest>
        Model::GetCoreNetworkChangeSetOutcomeCallable GetCoreNetworkChangeSetCallable(const GetCoreNetworkChangeSetRequestT& request) const
        {
            return SubmitCallable(&NetworkManagerClient::GetCoreNetworkChangeSet, request);
        }
 
        template<typename GetCoreNetworkChangeSetRequestT = Model::GetCoreNetworkChangeSetRequest>
        void GetCoreNetworkChangeSetAsync(const GetCoreNetworkChangeSetRequestT& request, const GetCoreNetworkChangeSetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&NetworkManagerClient::GetCoreNetworkChangeSet, request, handler, context);
        }
 
        virtual Model::GetCoreNetworkPolicyOutcome GetCoreNetworkPolicy(const Model::GetCoreNetworkPolicyRequest& request) const;
 
        template<typename GetCoreNetworkPolicyRequestT = Model::GetCoreNetworkPolicyRequest>
        Model::GetCoreNetworkPolicyOutcomeCallable GetCoreNetworkPolicyCallable(const GetCoreNetworkPolicyRequestT& request) const
        {
            return SubmitCallable(&NetworkManagerClient::GetCoreNetworkPolicy, request);
        }
 
        template<typename GetCoreNetworkPolicyRequestT = Model::GetCoreNetworkPolicyRequest>
        void GetCoreNetworkPolicyAsync(const GetCoreNetworkPolicyRequestT& request, const GetCoreNetworkPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&NetworkManagerClient::GetCoreNetworkPolicy, request, handler, context);
        }
 
        virtual Model::GetCustomerGatewayAssociationsOutcome GetCustomerGatewayAssociations(const Model::GetCustomerGatewayAssociationsRequest& request) const;
 
        template<typename GetCustomerGatewayAssociationsRequestT = Model::GetCustomerGatewayAssociationsRequest>
        Model::GetCustomerGatewayAssociationsOutcomeCallable GetCustomerGatewayAssociationsCallable(const GetCustomerGatewayAssociationsRequestT& request) const
        {
            return SubmitCallable(&NetworkManagerClient::GetCustomerGatewayAssociations, request);
        }
 
        template<typename GetCustomerGatewayAssociationsRequestT = Model::GetCustomerGatewayAssociationsRequest>
        void GetCustomerGatewayAssociationsAsync(const GetCustomerGatewayAssociationsRequestT& request, const GetCustomerGatewayAssociationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&NetworkManagerClient::GetCustomerGatewayAssociations, request, handler, context);
        }
 
        virtual Model::GetDevicesOutcome GetDevices(const Model::GetDevicesRequest& request) const;
 
        template<typename GetDevicesRequestT = Model::GetDevicesRequest>
        Model::GetDevicesOutcomeCallable GetDevicesCallable(const GetDevicesRequestT& request) const
        {
            return SubmitCallable(&NetworkManagerClient::GetDevices, request);
        }
 
        template<typename GetDevicesRequestT = Model::GetDevicesRequest>
        void GetDevicesAsync(const GetDevicesRequestT& request, const GetDevicesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&NetworkManagerClient::GetDevices, request, handler, context);
        }
 
        virtual Model::GetLinkAssociationsOutcome GetLinkAssociations(const Model::GetLinkAssociationsRequest& request) const;
 
        template<typename GetLinkAssociationsRequestT = Model::GetLinkAssociationsRequest>
        Model::GetLinkAssociationsOutcomeCallable GetLinkAssociationsCallable(const GetLinkAssociationsRequestT& request) const
        {
            return SubmitCallable(&NetworkManagerClient::GetLinkAssociations, request);
        }
 
        template<typename GetLinkAssociationsRequestT = Model::GetLinkAssociationsRequest>
        void GetLinkAssociationsAsync(const GetLinkAssociationsRequestT& request, const GetLinkAssociationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&NetworkManagerClient::GetLinkAssociations, request, handler, context);
        }
 
        virtual Model::GetLinksOutcome GetLinks(const Model::GetLinksRequest& request) const;
 
        template<typename GetLinksRequestT = Model::GetLinksRequest>
        Model::GetLinksOutcomeCallable GetLinksCallable(const GetLinksRequestT& request) const
        {
            return SubmitCallable(&NetworkManagerClient::GetLinks, request);
        }
 
        template<typename GetLinksRequestT = Model::GetLinksRequest>
        void GetLinksAsync(const GetLinksRequestT& request, const GetLinksResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&NetworkManagerClient::GetLinks, request, handler, context);
        }
 
        virtual Model::GetNetworkResourceCountsOutcome GetNetworkResourceCounts(const Model::GetNetworkResourceCountsRequest& request) const;
 
        template<typename GetNetworkResourceCountsRequestT = Model::GetNetworkResourceCountsRequest>
        Model::GetNetworkResourceCountsOutcomeCallable GetNetworkResourceCountsCallable(const GetNetworkResourceCountsRequestT& request) const
        {
            return SubmitCallable(&NetworkManagerClient::GetNetworkResourceCounts, request);
        }
 
        template<typename GetNetworkResourceCountsRequestT = Model::GetNetworkResourceCountsRequest>
        void GetNetworkResourceCountsAsync(const GetNetworkResourceCountsRequestT& request, const GetNetworkResourceCountsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&NetworkManagerClient::GetNetworkResourceCounts, request, handler, context);
        }
 
        virtual Model::GetNetworkResourceRelationshipsOutcome GetNetworkResourceRelationships(const Model::GetNetworkResourceRelationshipsRequest& request) const;
 
        template<typename GetNetworkResourceRelationshipsRequestT = Model::GetNetworkResourceRelationshipsRequest>
        Model::GetNetworkResourceRelationshipsOutcomeCallable GetNetworkResourceRelationshipsCallable(const GetNetworkResourceRelationshipsRequestT& request) const
        {
            return SubmitCallable(&NetworkManagerClient::GetNetworkResourceRelationships, request);
        }
 
        template<typename GetNetworkResourceRelationshipsRequestT = Model::GetNetworkResourceRelationshipsRequest>
        void GetNetworkResourceRelationshipsAsync(const GetNetworkResourceRelationshipsRequestT& request, const GetNetworkResourceRelationshipsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&NetworkManagerClient::GetNetworkResourceRelationships, request, handler, context);
        }
 
        virtual Model::GetNetworkResourcesOutcome GetNetworkResources(const Model::GetNetworkResourcesRequest& request) const;
 
        template<typename GetNetworkResourcesRequestT = Model::GetNetworkResourcesRequest>
        Model::GetNetworkResourcesOutcomeCallable GetNetworkResourcesCallable(const GetNetworkResourcesRequestT& request) const
        {
            return SubmitCallable(&NetworkManagerClient::GetNetworkResources, request);
        }
 
        template<typename GetNetworkResourcesRequestT = Model::GetNetworkResourcesRequest>
        void GetNetworkResourcesAsync(const GetNetworkResourcesRequestT& request, const GetNetworkResourcesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&NetworkManagerClient::GetNetworkResources, request, handler, context);
        }
 
        virtual Model::GetNetworkRoutesOutcome GetNetworkRoutes(const Model::GetNetworkRoutesRequest& request) const;
 
        template<typename GetNetworkRoutesRequestT = Model::GetNetworkRoutesRequest>
        Model::GetNetworkRoutesOutcomeCallable GetNetworkRoutesCallable(const GetNetworkRoutesRequestT& request) const
        {
            return SubmitCallable(&NetworkManagerClient::GetNetworkRoutes, request);
        }
 
        template<typename GetNetworkRoutesRequestT = Model::GetNetworkRoutesRequest>
        void GetNetworkRoutesAsync(const GetNetworkRoutesRequestT& request, const GetNetworkRoutesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&NetworkManagerClient::GetNetworkRoutes, request, handler, context);
        }
 
        virtual Model::GetNetworkTelemetryOutcome GetNetworkTelemetry(const Model::GetNetworkTelemetryRequest& request) const;
 
        template<typename GetNetworkTelemetryRequestT = Model::GetNetworkTelemetryRequest>
        Model::GetNetworkTelemetryOutcomeCallable GetNetworkTelemetryCallable(const GetNetworkTelemetryRequestT& request) const
        {
            return SubmitCallable(&NetworkManagerClient::GetNetworkTelemetry, request);
        }
 
        template<typename GetNetworkTelemetryRequestT = Model::GetNetworkTelemetryRequest>
        void GetNetworkTelemetryAsync(const GetNetworkTelemetryRequestT& request, const GetNetworkTelemetryResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&NetworkManagerClient::GetNetworkTelemetry, request, handler, context);
        }
 
        virtual Model::GetResourcePolicyOutcome GetResourcePolicy(const Model::GetResourcePolicyRequest& request) const;
 
        template<typename GetResourcePolicyRequestT = Model::GetResourcePolicyRequest>
        Model::GetResourcePolicyOutcomeCallable GetResourcePolicyCallable(const GetResourcePolicyRequestT& request) const
        {
            return SubmitCallable(&NetworkManagerClient::GetResourcePolicy, request);
        }
 
        template<typename GetResourcePolicyRequestT = Model::GetResourcePolicyRequest>
        void GetResourcePolicyAsync(const GetResourcePolicyRequestT& request, const GetResourcePolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&NetworkManagerClient::GetResourcePolicy, request, handler, context);
        }
 
        virtual Model::GetRouteAnalysisOutcome GetRouteAnalysis(const Model::GetRouteAnalysisRequest& request) const;
 
        template<typename GetRouteAnalysisRequestT = Model::GetRouteAnalysisRequest>
        Model::GetRouteAnalysisOutcomeCallable GetRouteAnalysisCallable(const GetRouteAnalysisRequestT& request) const
        {
            return SubmitCallable(&NetworkManagerClient::GetRouteAnalysis, request);
        }
 
        template<typename GetRouteAnalysisRequestT = Model::GetRouteAnalysisRequest>
        void GetRouteAnalysisAsync(const GetRouteAnalysisRequestT& request, const GetRouteAnalysisResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&NetworkManagerClient::GetRouteAnalysis, request, handler, context);
        }
 
        virtual Model::GetSiteToSiteVpnAttachmentOutcome GetSiteToSiteVpnAttachment(const Model::GetSiteToSiteVpnAttachmentRequest& request) const;
 
        template<typename GetSiteToSiteVpnAttachmentRequestT = Model::GetSiteToSiteVpnAttachmentRequest>
        Model::GetSiteToSiteVpnAttachmentOutcomeCallable GetSiteToSiteVpnAttachmentCallable(const GetSiteToSiteVpnAttachmentRequestT& request) const
        {
            return SubmitCallable(&NetworkManagerClient::GetSiteToSiteVpnAttachment, request);
        }
 
        template<typename GetSiteToSiteVpnAttachmentRequestT = Model::GetSiteToSiteVpnAttachmentRequest>
        void GetSiteToSiteVpnAttachmentAsync(const GetSiteToSiteVpnAttachmentRequestT& request, const GetSiteToSiteVpnAttachmentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&NetworkManagerClient::GetSiteToSiteVpnAttachment, request, handler, context);
        }
 
        virtual Model::GetSitesOutcome GetSites(const Model::GetSitesRequest& request) const;
 
        template<typename GetSitesRequestT = Model::GetSitesRequest>
        Model::GetSitesOutcomeCallable GetSitesCallable(const GetSitesRequestT& request) const
        {
            return SubmitCallable(&NetworkManagerClient::GetSites, request);
        }
 
        template<typename GetSitesRequestT = Model::GetSitesRequest>
        void GetSitesAsync(const GetSitesRequestT& request, const GetSitesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&NetworkManagerClient::GetSites, request, handler, context);
        }
 
        virtual Model::GetTransitGatewayConnectPeerAssociationsOutcome GetTransitGatewayConnectPeerAssociations(const Model::GetTransitGatewayConnectPeerAssociationsRequest& request) const;
 
        template<typename GetTransitGatewayConnectPeerAssociationsRequestT = Model::GetTransitGatewayConnectPeerAssociationsRequest>
        Model::GetTransitGatewayConnectPeerAssociationsOutcomeCallable GetTransitGatewayConnectPeerAssociationsCallable(const GetTransitGatewayConnectPeerAssociationsRequestT& request) const
        {
            return SubmitCallable(&NetworkManagerClient::GetTransitGatewayConnectPeerAssociations, request);
        }
 
        template<typename GetTransitGatewayConnectPeerAssociationsRequestT = Model::GetTransitGatewayConnectPeerAssociationsRequest>
        void GetTransitGatewayConnectPeerAssociationsAsync(const GetTransitGatewayConnectPeerAssociationsRequestT& request, const GetTransitGatewayConnectPeerAssociationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&NetworkManagerClient::GetTransitGatewayConnectPeerAssociations, request, handler, context);
        }
 
        virtual Model::GetTransitGatewayPeeringOutcome GetTransitGatewayPeering(const Model::GetTransitGatewayPeeringRequest& request) const;
 
        template<typename GetTransitGatewayPeeringRequestT = Model::GetTransitGatewayPeeringRequest>
        Model::GetTransitGatewayPeeringOutcomeCallable GetTransitGatewayPeeringCallable(const GetTransitGatewayPeeringRequestT& request) const
        {
            return SubmitCallable(&NetworkManagerClient::GetTransitGatewayPeering, request);
        }
 
        template<typename GetTransitGatewayPeeringRequestT = Model::GetTransitGatewayPeeringRequest>
        void GetTransitGatewayPeeringAsync(const GetTransitGatewayPeeringRequestT& request, const GetTransitGatewayPeeringResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&NetworkManagerClient::GetTransitGatewayPeering, request, handler, context);
        }
 
        virtual Model::GetTransitGatewayRegistrationsOutcome GetTransitGatewayRegistrations(const Model::GetTransitGatewayRegistrationsRequest& request) const;
 
        template<typename GetTransitGatewayRegistrationsRequestT = Model::GetTransitGatewayRegistrationsRequest>
        Model::GetTransitGatewayRegistrationsOutcomeCallable GetTransitGatewayRegistrationsCallable(const GetTransitGatewayRegistrationsRequestT& request) const
        {
            return SubmitCallable(&NetworkManagerClient::GetTransitGatewayRegistrations, request);
        }
 
        template<typename GetTransitGatewayRegistrationsRequestT = Model::GetTransitGatewayRegistrationsRequest>
        void GetTransitGatewayRegistrationsAsync(const GetTransitGatewayRegistrationsRequestT& request, const GetTransitGatewayRegistrationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&NetworkManagerClient::GetTransitGatewayRegistrations, request, handler, context);
        }
 
        virtual Model::GetTransitGatewayRouteTableAttachmentOutcome GetTransitGatewayRouteTableAttachment(const Model::GetTransitGatewayRouteTableAttachmentRequest& request) const;
 
        template<typename GetTransitGatewayRouteTableAttachmentRequestT = Model::GetTransitGatewayRouteTableAttachmentRequest>
        Model::GetTransitGatewayRouteTableAttachmentOutcomeCallable GetTransitGatewayRouteTableAttachmentCallable(const GetTransitGatewayRouteTableAttachmentRequestT& request) const
        {
            return SubmitCallable(&NetworkManagerClient::GetTransitGatewayRouteTableAttachment, request);
        }
 
        template<typename GetTransitGatewayRouteTableAttachmentRequestT = Model::GetTransitGatewayRouteTableAttachmentRequest>
        void GetTransitGatewayRouteTableAttachmentAsync(const GetTransitGatewayRouteTableAttachmentRequestT& request, const GetTransitGatewayRouteTableAttachmentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&NetworkManagerClient::GetTransitGatewayRouteTableAttachment, request, handler, context);
        }
 
        virtual Model::GetVpcAttachmentOutcome GetVpcAttachment(const Model::GetVpcAttachmentRequest& request) const;
 
        template<typename GetVpcAttachmentRequestT = Model::GetVpcAttachmentRequest>
        Model::GetVpcAttachmentOutcomeCallable GetVpcAttachmentCallable(const GetVpcAttachmentRequestT& request) const
        {
            return SubmitCallable(&NetworkManagerClient::GetVpcAttachment, request);
        }
 
        template<typename GetVpcAttachmentRequestT = Model::GetVpcAttachmentRequest>
        void GetVpcAttachmentAsync(const GetVpcAttachmentRequestT& request, const GetVpcAttachmentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&NetworkManagerClient::GetVpcAttachment, request, handler, context);
        }
 
        virtual Model::ListAttachmentsOutcome ListAttachments(const Model::ListAttachmentsRequest& request = {}) const;
 
        template<typename ListAttachmentsRequestT = Model::ListAttachmentsRequest>
        Model::ListAttachmentsOutcomeCallable ListAttachmentsCallable(const ListAttachmentsRequestT& request = {}) const
        {
            return SubmitCallable(&NetworkManagerClient::ListAttachments, request);
        }
 
        template<typename ListAttachmentsRequestT = Model::ListAttachmentsRequest>
        void ListAttachmentsAsync(const ListAttachmentsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListAttachmentsRequestT& request = {}) const
        {
            return SubmitAsync(&NetworkManagerClient::ListAttachments, request, handler, context);
        }
 
        virtual Model::ListConnectPeersOutcome ListConnectPeers(const Model::ListConnectPeersRequest& request = {}) const;
 
        template<typename ListConnectPeersRequestT = Model::ListConnectPeersRequest>
        Model::ListConnectPeersOutcomeCallable ListConnectPeersCallable(const ListConnectPeersRequestT& request = {}) const
        {
            return SubmitCallable(&NetworkManagerClient::ListConnectPeers, request);
        }
 
        template<typename ListConnectPeersRequestT = Model::ListConnectPeersRequest>
        void ListConnectPeersAsync(const ListConnectPeersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListConnectPeersRequestT& request = {}) const
        {
            return SubmitAsync(&NetworkManagerClient::ListConnectPeers, request, handler, context);
        }
 
        virtual Model::ListCoreNetworkPolicyVersionsOutcome ListCoreNetworkPolicyVersions(const Model::ListCoreNetworkPolicyVersionsRequest& request) const;
 
        template<typename ListCoreNetworkPolicyVersionsRequestT = Model::ListCoreNetworkPolicyVersionsRequest>
        Model::ListCoreNetworkPolicyVersionsOutcomeCallable ListCoreNetworkPolicyVersionsCallable(const ListCoreNetworkPolicyVersionsRequestT& request) const
        {
            return SubmitCallable(&NetworkManagerClient::ListCoreNetworkPolicyVersions, request);
        }
 
        template<typename ListCoreNetworkPolicyVersionsRequestT = Model::ListCoreNetworkPolicyVersionsRequest>
        void ListCoreNetworkPolicyVersionsAsync(const ListCoreNetworkPolicyVersionsRequestT& request, const ListCoreNetworkPolicyVersionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&NetworkManagerClient::ListCoreNetworkPolicyVersions, request, handler, context);
        }
 
        virtual Model::ListCoreNetworksOutcome ListCoreNetworks(const Model::ListCoreNetworksRequest& request = {}) const;
 
        template<typename ListCoreNetworksRequestT = Model::ListCoreNetworksRequest>
        Model::ListCoreNetworksOutcomeCallable ListCoreNetworksCallable(const ListCoreNetworksRequestT& request = {}) const
        {
            return SubmitCallable(&NetworkManagerClient::ListCoreNetworks, request);
        }
 
        template<typename ListCoreNetworksRequestT = Model::ListCoreNetworksRequest>
        void ListCoreNetworksAsync(const ListCoreNetworksResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListCoreNetworksRequestT& request = {}) const
        {
            return SubmitAsync(&NetworkManagerClient::ListCoreNetworks, request, handler, context);
        }
 
        virtual Model::ListOrganizationServiceAccessStatusOutcome ListOrganizationServiceAccessStatus(const Model::ListOrganizationServiceAccessStatusRequest& request = {}) const;
 
        template<typename ListOrganizationServiceAccessStatusRequestT = Model::ListOrganizationServiceAccessStatusRequest>
        Model::ListOrganizationServiceAccessStatusOutcomeCallable ListOrganizationServiceAccessStatusCallable(const ListOrganizationServiceAccessStatusRequestT& request = {}) const
        {
            return SubmitCallable(&NetworkManagerClient::ListOrganizationServiceAccessStatus, request);
        }
 
        template<typename ListOrganizationServiceAccessStatusRequestT = Model::ListOrganizationServiceAccessStatusRequest>
        void ListOrganizationServiceAccessStatusAsync(const ListOrganizationServiceAccessStatusResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListOrganizationServiceAccessStatusRequestT& request = {}) const
        {
            return SubmitAsync(&NetworkManagerClient::ListOrganizationServiceAccessStatus, request, handler, context);
        }
 
        virtual Model::ListPeeringsOutcome ListPeerings(const Model::ListPeeringsRequest& request = {}) const;
 
        template<typename ListPeeringsRequestT = Model::ListPeeringsRequest>
        Model::ListPeeringsOutcomeCallable ListPeeringsCallable(const ListPeeringsRequestT& request = {}) const
        {
            return SubmitCallable(&NetworkManagerClient::ListPeerings, request);
        }
 
        template<typename ListPeeringsRequestT = Model::ListPeeringsRequest>
        void ListPeeringsAsync(const ListPeeringsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListPeeringsRequestT& request = {}) const
        {
            return SubmitAsync(&NetworkManagerClient::ListPeerings, 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(&NetworkManagerClient::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(&NetworkManagerClient::ListTagsForResource, request, handler, context);
        }
 
        virtual Model::PutCoreNetworkPolicyOutcome PutCoreNetworkPolicy(const Model::PutCoreNetworkPolicyRequest& request) const;
 
        template<typename PutCoreNetworkPolicyRequestT = Model::PutCoreNetworkPolicyRequest>
        Model::PutCoreNetworkPolicyOutcomeCallable PutCoreNetworkPolicyCallable(const PutCoreNetworkPolicyRequestT& request) const
        {
            return SubmitCallable(&NetworkManagerClient::PutCoreNetworkPolicy, request);
        }
 
        template<typename PutCoreNetworkPolicyRequestT = Model::PutCoreNetworkPolicyRequest>
        void PutCoreNetworkPolicyAsync(const PutCoreNetworkPolicyRequestT& request, const PutCoreNetworkPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&NetworkManagerClient::PutCoreNetworkPolicy, request, handler, context);
        }
 
        virtual Model::PutResourcePolicyOutcome PutResourcePolicy(const Model::PutResourcePolicyRequest& request) const;
 
        template<typename PutResourcePolicyRequestT = Model::PutResourcePolicyRequest>
        Model::PutResourcePolicyOutcomeCallable PutResourcePolicyCallable(const PutResourcePolicyRequestT& request) const
        {
            return SubmitCallable(&NetworkManagerClient::PutResourcePolicy, request);
        }
 
        template<typename PutResourcePolicyRequestT = Model::PutResourcePolicyRequest>
        void PutResourcePolicyAsync(const PutResourcePolicyRequestT& request, const PutResourcePolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&NetworkManagerClient::PutResourcePolicy, request, handler, context);
        }
 
        virtual Model::RegisterTransitGatewayOutcome RegisterTransitGateway(const Model::RegisterTransitGatewayRequest& request) const;
 
        template<typename RegisterTransitGatewayRequestT = Model::RegisterTransitGatewayRequest>
        Model::RegisterTransitGatewayOutcomeCallable RegisterTransitGatewayCallable(const RegisterTransitGatewayRequestT& request) const
        {
            return SubmitCallable(&NetworkManagerClient::RegisterTransitGateway, request);
        }
 
        template<typename RegisterTransitGatewayRequestT = Model::RegisterTransitGatewayRequest>
        void RegisterTransitGatewayAsync(const RegisterTransitGatewayRequestT& request, const RegisterTransitGatewayResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&NetworkManagerClient::RegisterTransitGateway, request, handler, context);
        }
 
        virtual Model::RejectAttachmentOutcome RejectAttachment(const Model::RejectAttachmentRequest& request) const;
 
        template<typename RejectAttachmentRequestT = Model::RejectAttachmentRequest>
        Model::RejectAttachmentOutcomeCallable RejectAttachmentCallable(const RejectAttachmentRequestT& request) const
        {
            return SubmitCallable(&NetworkManagerClient::RejectAttachment, request);
        }
 
        template<typename RejectAttachmentRequestT = Model::RejectAttachmentRequest>
        void RejectAttachmentAsync(const RejectAttachmentRequestT& request, const RejectAttachmentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&NetworkManagerClient::RejectAttachment, request, handler, context);
        }
 
        virtual Model::RestoreCoreNetworkPolicyVersionOutcome RestoreCoreNetworkPolicyVersion(const Model::RestoreCoreNetworkPolicyVersionRequest& request) const;
 
        template<typename RestoreCoreNetworkPolicyVersionRequestT = Model::RestoreCoreNetworkPolicyVersionRequest>
        Model::RestoreCoreNetworkPolicyVersionOutcomeCallable RestoreCoreNetworkPolicyVersionCallable(const RestoreCoreNetworkPolicyVersionRequestT& request) const
        {
            return SubmitCallable(&NetworkManagerClient::RestoreCoreNetworkPolicyVersion, request);
        }
 
        template<typename RestoreCoreNetworkPolicyVersionRequestT = Model::RestoreCoreNetworkPolicyVersionRequest>
        void RestoreCoreNetworkPolicyVersionAsync(const RestoreCoreNetworkPolicyVersionRequestT& request, const RestoreCoreNetworkPolicyVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&NetworkManagerClient::RestoreCoreNetworkPolicyVersion, request, handler, context);
        }
 
        virtual Model::StartOrganizationServiceAccessUpdateOutcome StartOrganizationServiceAccessUpdate(const Model::StartOrganizationServiceAccessUpdateRequest& request) const;
 
        template<typename StartOrganizationServiceAccessUpdateRequestT = Model::StartOrganizationServiceAccessUpdateRequest>
        Model::StartOrganizationServiceAccessUpdateOutcomeCallable StartOrganizationServiceAccessUpdateCallable(const StartOrganizationServiceAccessUpdateRequestT& request) const
        {
            return SubmitCallable(&NetworkManagerClient::StartOrganizationServiceAccessUpdate, request);
        }
 
        template<typename StartOrganizationServiceAccessUpdateRequestT = Model::StartOrganizationServiceAccessUpdateRequest>
        void StartOrganizationServiceAccessUpdateAsync(const StartOrganizationServiceAccessUpdateRequestT& request, const StartOrganizationServiceAccessUpdateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&NetworkManagerClient::StartOrganizationServiceAccessUpdate, request, handler, context);
        }
 
        virtual Model::StartRouteAnalysisOutcome StartRouteAnalysis(const Model::StartRouteAnalysisRequest& request) const;
 
        template<typename StartRouteAnalysisRequestT = Model::StartRouteAnalysisRequest>
        Model::StartRouteAnalysisOutcomeCallable StartRouteAnalysisCallable(const StartRouteAnalysisRequestT& request) const
        {
            return SubmitCallable(&NetworkManagerClient::StartRouteAnalysis, request);
        }
 
        template<typename StartRouteAnalysisRequestT = Model::StartRouteAnalysisRequest>
        void StartRouteAnalysisAsync(const StartRouteAnalysisRequestT& request, const StartRouteAnalysisResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&NetworkManagerClient::StartRouteAnalysis, 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(&NetworkManagerClient::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(&NetworkManagerClient::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(&NetworkManagerClient::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(&NetworkManagerClient::UntagResource, request, handler, context);
        }
 
        virtual Model::UpdateConnectionOutcome UpdateConnection(const Model::UpdateConnectionRequest& request) const;
 
        template<typename UpdateConnectionRequestT = Model::UpdateConnectionRequest>
        Model::UpdateConnectionOutcomeCallable UpdateConnectionCallable(const UpdateConnectionRequestT& request) const
        {
            return SubmitCallable(&NetworkManagerClient::UpdateConnection, request);
        }
 
        template<typename UpdateConnectionRequestT = Model::UpdateConnectionRequest>
        void UpdateConnectionAsync(const UpdateConnectionRequestT& request, const UpdateConnectionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&NetworkManagerClient::UpdateConnection, request, handler, context);
        }
 
        virtual Model::UpdateCoreNetworkOutcome UpdateCoreNetwork(const Model::UpdateCoreNetworkRequest& request) const;
 
        template<typename UpdateCoreNetworkRequestT = Model::UpdateCoreNetworkRequest>
        Model::UpdateCoreNetworkOutcomeCallable UpdateCoreNetworkCallable(const UpdateCoreNetworkRequestT& request) const
        {
            return SubmitCallable(&NetworkManagerClient::UpdateCoreNetwork, request);
        }
 
        template<typename UpdateCoreNetworkRequestT = Model::UpdateCoreNetworkRequest>
        void UpdateCoreNetworkAsync(const UpdateCoreNetworkRequestT& request, const UpdateCoreNetworkResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&NetworkManagerClient::UpdateCoreNetwork, request, handler, context);
        }
 
        virtual Model::UpdateDeviceOutcome UpdateDevice(const Model::UpdateDeviceRequest& request) const;
 
        template<typename UpdateDeviceRequestT = Model::UpdateDeviceRequest>
        Model::UpdateDeviceOutcomeCallable UpdateDeviceCallable(const UpdateDeviceRequestT& request) const
        {
            return SubmitCallable(&NetworkManagerClient::UpdateDevice, request);
        }
 
        template<typename UpdateDeviceRequestT = Model::UpdateDeviceRequest>
        void UpdateDeviceAsync(const UpdateDeviceRequestT& request, const UpdateDeviceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&NetworkManagerClient::UpdateDevice, request, handler, context);
        }
 
        virtual Model::UpdateGlobalNetworkOutcome UpdateGlobalNetwork(const Model::UpdateGlobalNetworkRequest& request) const;
 
        template<typename UpdateGlobalNetworkRequestT = Model::UpdateGlobalNetworkRequest>
        Model::UpdateGlobalNetworkOutcomeCallable UpdateGlobalNetworkCallable(const UpdateGlobalNetworkRequestT& request) const
        {
            return SubmitCallable(&NetworkManagerClient::UpdateGlobalNetwork, request);
        }
 
        template<typename UpdateGlobalNetworkRequestT = Model::UpdateGlobalNetworkRequest>
        void UpdateGlobalNetworkAsync(const UpdateGlobalNetworkRequestT& request, const UpdateGlobalNetworkResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&NetworkManagerClient::UpdateGlobalNetwork, request, handler, context);
        }
 
        virtual Model::UpdateLinkOutcome UpdateLink(const Model::UpdateLinkRequest& request) const;
 
        template<typename UpdateLinkRequestT = Model::UpdateLinkRequest>
        Model::UpdateLinkOutcomeCallable UpdateLinkCallable(const UpdateLinkRequestT& request) const
        {
            return SubmitCallable(&NetworkManagerClient::UpdateLink, request);
        }
 
        template<typename UpdateLinkRequestT = Model::UpdateLinkRequest>
        void UpdateLinkAsync(const UpdateLinkRequestT& request, const UpdateLinkResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&NetworkManagerClient::UpdateLink, request, handler, context);
        }
 
        virtual Model::UpdateNetworkResourceMetadataOutcome UpdateNetworkResourceMetadata(const Model::UpdateNetworkResourceMetadataRequest& request) const;
 
        template<typename UpdateNetworkResourceMetadataRequestT = Model::UpdateNetworkResourceMetadataRequest>
        Model::UpdateNetworkResourceMetadataOutcomeCallable UpdateNetworkResourceMetadataCallable(const UpdateNetworkResourceMetadataRequestT& request) const
        {
            return SubmitCallable(&NetworkManagerClient::UpdateNetworkResourceMetadata, request);
        }
 
        template<typename UpdateNetworkResourceMetadataRequestT = Model::UpdateNetworkResourceMetadataRequest>
        void UpdateNetworkResourceMetadataAsync(const UpdateNetworkResourceMetadataRequestT& request, const UpdateNetworkResourceMetadataResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&NetworkManagerClient::UpdateNetworkResourceMetadata, request, handler, context);
        }
 
        virtual Model::UpdateSiteOutcome UpdateSite(const Model::UpdateSiteRequest& request) const;
 
        template<typename UpdateSiteRequestT = Model::UpdateSiteRequest>
        Model::UpdateSiteOutcomeCallable UpdateSiteCallable(const UpdateSiteRequestT& request) const
        {
            return SubmitCallable(&NetworkManagerClient::UpdateSite, request);
        }
 
        template<typename UpdateSiteRequestT = Model::UpdateSiteRequest>
        void UpdateSiteAsync(const UpdateSiteRequestT& request, const UpdateSiteResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&NetworkManagerClient::UpdateSite, request, handler, context);
        }
 
        virtual Model::UpdateVpcAttachmentOutcome UpdateVpcAttachment(const Model::UpdateVpcAttachmentRequest& request) const;
 
        template<typename UpdateVpcAttachmentRequestT = Model::UpdateVpcAttachmentRequest>
        Model::UpdateVpcAttachmentOutcomeCallable UpdateVpcAttachmentCallable(const UpdateVpcAttachmentRequestT& request) const
        {
            return SubmitCallable(&NetworkManagerClient::UpdateVpcAttachment, request);
        }
 
        template<typename UpdateVpcAttachmentRequestT = Model::UpdateVpcAttachmentRequest>
        void UpdateVpcAttachmentAsync(const UpdateVpcAttachmentRequestT& request, const UpdateVpcAttachmentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&NetworkManagerClient::UpdateVpcAttachment, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<NetworkManagerEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<NetworkManagerClient>;
      void init(const NetworkManagerClientConfiguration& clientConfiguration);
 
      NetworkManagerClientConfiguration m_clientConfiguration;
      std::shared_ptr<NetworkManagerEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace NetworkManager
} // namespace Aws