GlobalAcceleratorClient.h

 
#pragma once
#include <aws/globalaccelerator/GlobalAccelerator_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/globalaccelerator/GlobalAcceleratorServiceClientModel.h>
 
namespace Aws
{
namespace GlobalAccelerator
{
  class AWS_GLOBALACCELERATOR_API GlobalAcceleratorClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<GlobalAcceleratorClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef GlobalAcceleratorClientConfiguration ClientConfigurationType;
      typedef GlobalAcceleratorEndpointProvider EndpointProviderType;
 
        GlobalAcceleratorClient(const Aws::GlobalAccelerator::GlobalAcceleratorClientConfiguration& clientConfiguration = Aws::GlobalAccelerator::GlobalAcceleratorClientConfiguration(),
                                std::shared_ptr<GlobalAcceleratorEndpointProviderBase> endpointProvider = nullptr);
 
        GlobalAcceleratorClient(const Aws::Auth::AWSCredentials& credentials,
                                std::shared_ptr<GlobalAcceleratorEndpointProviderBase> endpointProvider = nullptr,
                                const Aws::GlobalAccelerator::GlobalAcceleratorClientConfiguration& clientConfiguration = Aws::GlobalAccelerator::GlobalAcceleratorClientConfiguration());
 
        GlobalAcceleratorClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                                std::shared_ptr<GlobalAcceleratorEndpointProviderBase> endpointProvider = nullptr,
                                const Aws::GlobalAccelerator::GlobalAcceleratorClientConfiguration& clientConfiguration = Aws::GlobalAccelerator::GlobalAcceleratorClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        GlobalAcceleratorClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        GlobalAcceleratorClient(const Aws::Auth::AWSCredentials& credentials,
                                const Aws::Client::ClientConfiguration& clientConfiguration);
 
        GlobalAcceleratorClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                                const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~GlobalAcceleratorClient();
 
        virtual Model::AddCustomRoutingEndpointsOutcome AddCustomRoutingEndpoints(const Model::AddCustomRoutingEndpointsRequest& request) const;
 
        template<typename AddCustomRoutingEndpointsRequestT = Model::AddCustomRoutingEndpointsRequest>
        Model::AddCustomRoutingEndpointsOutcomeCallable AddCustomRoutingEndpointsCallable(const AddCustomRoutingEndpointsRequestT& request) const
        {
            return SubmitCallable(&GlobalAcceleratorClient::AddCustomRoutingEndpoints, request);
        }
 
        template<typename AddCustomRoutingEndpointsRequestT = Model::AddCustomRoutingEndpointsRequest>
        void AddCustomRoutingEndpointsAsync(const AddCustomRoutingEndpointsRequestT& request, const AddCustomRoutingEndpointsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlobalAcceleratorClient::AddCustomRoutingEndpoints, request, handler, context);
        }
 
        virtual Model::AddEndpointsOutcome AddEndpoints(const Model::AddEndpointsRequest& request) const;
 
        template<typename AddEndpointsRequestT = Model::AddEndpointsRequest>
        Model::AddEndpointsOutcomeCallable AddEndpointsCallable(const AddEndpointsRequestT& request) const
        {
            return SubmitCallable(&GlobalAcceleratorClient::AddEndpoints, request);
        }
 
        template<typename AddEndpointsRequestT = Model::AddEndpointsRequest>
        void AddEndpointsAsync(const AddEndpointsRequestT& request, const AddEndpointsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlobalAcceleratorClient::AddEndpoints, request, handler, context);
        }
 
        virtual Model::AdvertiseByoipCidrOutcome AdvertiseByoipCidr(const Model::AdvertiseByoipCidrRequest& request) const;
 
        template<typename AdvertiseByoipCidrRequestT = Model::AdvertiseByoipCidrRequest>
        Model::AdvertiseByoipCidrOutcomeCallable AdvertiseByoipCidrCallable(const AdvertiseByoipCidrRequestT& request) const
        {
            return SubmitCallable(&GlobalAcceleratorClient::AdvertiseByoipCidr, request);
        }
 
        template<typename AdvertiseByoipCidrRequestT = Model::AdvertiseByoipCidrRequest>
        void AdvertiseByoipCidrAsync(const AdvertiseByoipCidrRequestT& request, const AdvertiseByoipCidrResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlobalAcceleratorClient::AdvertiseByoipCidr, request, handler, context);
        }
 
        virtual Model::AllowCustomRoutingTrafficOutcome AllowCustomRoutingTraffic(const Model::AllowCustomRoutingTrafficRequest& request) const;
 
        template<typename AllowCustomRoutingTrafficRequestT = Model::AllowCustomRoutingTrafficRequest>
        Model::AllowCustomRoutingTrafficOutcomeCallable AllowCustomRoutingTrafficCallable(const AllowCustomRoutingTrafficRequestT& request) const
        {
            return SubmitCallable(&GlobalAcceleratorClient::AllowCustomRoutingTraffic, request);
        }
 
        template<typename AllowCustomRoutingTrafficRequestT = Model::AllowCustomRoutingTrafficRequest>
        void AllowCustomRoutingTrafficAsync(const AllowCustomRoutingTrafficRequestT& request, const AllowCustomRoutingTrafficResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlobalAcceleratorClient::AllowCustomRoutingTraffic, request, handler, context);
        }
 
        virtual Model::CreateAcceleratorOutcome CreateAccelerator(const Model::CreateAcceleratorRequest& request) const;
 
        template<typename CreateAcceleratorRequestT = Model::CreateAcceleratorRequest>
        Model::CreateAcceleratorOutcomeCallable CreateAcceleratorCallable(const CreateAcceleratorRequestT& request) const
        {
            return SubmitCallable(&GlobalAcceleratorClient::CreateAccelerator, request);
        }
 
        template<typename CreateAcceleratorRequestT = Model::CreateAcceleratorRequest>
        void CreateAcceleratorAsync(const CreateAcceleratorRequestT& request, const CreateAcceleratorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlobalAcceleratorClient::CreateAccelerator, request, handler, context);
        }
 
        virtual Model::CreateCrossAccountAttachmentOutcome CreateCrossAccountAttachment(const Model::CreateCrossAccountAttachmentRequest& request) const;
 
        template<typename CreateCrossAccountAttachmentRequestT = Model::CreateCrossAccountAttachmentRequest>
        Model::CreateCrossAccountAttachmentOutcomeCallable CreateCrossAccountAttachmentCallable(const CreateCrossAccountAttachmentRequestT& request) const
        {
            return SubmitCallable(&GlobalAcceleratorClient::CreateCrossAccountAttachment, request);
        }
 
        template<typename CreateCrossAccountAttachmentRequestT = Model::CreateCrossAccountAttachmentRequest>
        void CreateCrossAccountAttachmentAsync(const CreateCrossAccountAttachmentRequestT& request, const CreateCrossAccountAttachmentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlobalAcceleratorClient::CreateCrossAccountAttachment, request, handler, context);
        }
 
        virtual Model::CreateCustomRoutingAcceleratorOutcome CreateCustomRoutingAccelerator(const Model::CreateCustomRoutingAcceleratorRequest& request) const;
 
        template<typename CreateCustomRoutingAcceleratorRequestT = Model::CreateCustomRoutingAcceleratorRequest>
        Model::CreateCustomRoutingAcceleratorOutcomeCallable CreateCustomRoutingAcceleratorCallable(const CreateCustomRoutingAcceleratorRequestT& request) const
        {
            return SubmitCallable(&GlobalAcceleratorClient::CreateCustomRoutingAccelerator, request);
        }
 
        template<typename CreateCustomRoutingAcceleratorRequestT = Model::CreateCustomRoutingAcceleratorRequest>
        void CreateCustomRoutingAcceleratorAsync(const CreateCustomRoutingAcceleratorRequestT& request, const CreateCustomRoutingAcceleratorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlobalAcceleratorClient::CreateCustomRoutingAccelerator, request, handler, context);
        }
 
        virtual Model::CreateCustomRoutingEndpointGroupOutcome CreateCustomRoutingEndpointGroup(const Model::CreateCustomRoutingEndpointGroupRequest& request) const;
 
        template<typename CreateCustomRoutingEndpointGroupRequestT = Model::CreateCustomRoutingEndpointGroupRequest>
        Model::CreateCustomRoutingEndpointGroupOutcomeCallable CreateCustomRoutingEndpointGroupCallable(const CreateCustomRoutingEndpointGroupRequestT& request) const
        {
            return SubmitCallable(&GlobalAcceleratorClient::CreateCustomRoutingEndpointGroup, request);
        }
 
        template<typename CreateCustomRoutingEndpointGroupRequestT = Model::CreateCustomRoutingEndpointGroupRequest>
        void CreateCustomRoutingEndpointGroupAsync(const CreateCustomRoutingEndpointGroupRequestT& request, const CreateCustomRoutingEndpointGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlobalAcceleratorClient::CreateCustomRoutingEndpointGroup, request, handler, context);
        }
 
        virtual Model::CreateCustomRoutingListenerOutcome CreateCustomRoutingListener(const Model::CreateCustomRoutingListenerRequest& request) const;
 
        template<typename CreateCustomRoutingListenerRequestT = Model::CreateCustomRoutingListenerRequest>
        Model::CreateCustomRoutingListenerOutcomeCallable CreateCustomRoutingListenerCallable(const CreateCustomRoutingListenerRequestT& request) const
        {
            return SubmitCallable(&GlobalAcceleratorClient::CreateCustomRoutingListener, request);
        }
 
        template<typename CreateCustomRoutingListenerRequestT = Model::CreateCustomRoutingListenerRequest>
        void CreateCustomRoutingListenerAsync(const CreateCustomRoutingListenerRequestT& request, const CreateCustomRoutingListenerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlobalAcceleratorClient::CreateCustomRoutingListener, request, handler, context);
        }
 
        virtual Model::CreateEndpointGroupOutcome CreateEndpointGroup(const Model::CreateEndpointGroupRequest& request) const;
 
        template<typename CreateEndpointGroupRequestT = Model::CreateEndpointGroupRequest>
        Model::CreateEndpointGroupOutcomeCallable CreateEndpointGroupCallable(const CreateEndpointGroupRequestT& request) const
        {
            return SubmitCallable(&GlobalAcceleratorClient::CreateEndpointGroup, request);
        }
 
        template<typename CreateEndpointGroupRequestT = Model::CreateEndpointGroupRequest>
        void CreateEndpointGroupAsync(const CreateEndpointGroupRequestT& request, const CreateEndpointGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlobalAcceleratorClient::CreateEndpointGroup, request, handler, context);
        }
 
        virtual Model::CreateListenerOutcome CreateListener(const Model::CreateListenerRequest& request) const;
 
        template<typename CreateListenerRequestT = Model::CreateListenerRequest>
        Model::CreateListenerOutcomeCallable CreateListenerCallable(const CreateListenerRequestT& request) const
        {
            return SubmitCallable(&GlobalAcceleratorClient::CreateListener, request);
        }
 
        template<typename CreateListenerRequestT = Model::CreateListenerRequest>
        void CreateListenerAsync(const CreateListenerRequestT& request, const CreateListenerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlobalAcceleratorClient::CreateListener, request, handler, context);
        }
 
        virtual Model::DeleteAcceleratorOutcome DeleteAccelerator(const Model::DeleteAcceleratorRequest& request) const;
 
        template<typename DeleteAcceleratorRequestT = Model::DeleteAcceleratorRequest>
        Model::DeleteAcceleratorOutcomeCallable DeleteAcceleratorCallable(const DeleteAcceleratorRequestT& request) const
        {
            return SubmitCallable(&GlobalAcceleratorClient::DeleteAccelerator, request);
        }
 
        template<typename DeleteAcceleratorRequestT = Model::DeleteAcceleratorRequest>
        void DeleteAcceleratorAsync(const DeleteAcceleratorRequestT& request, const DeleteAcceleratorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlobalAcceleratorClient::DeleteAccelerator, request, handler, context);
        }
 
        virtual Model::DeleteCrossAccountAttachmentOutcome DeleteCrossAccountAttachment(const Model::DeleteCrossAccountAttachmentRequest& request) const;
 
        template<typename DeleteCrossAccountAttachmentRequestT = Model::DeleteCrossAccountAttachmentRequest>
        Model::DeleteCrossAccountAttachmentOutcomeCallable DeleteCrossAccountAttachmentCallable(const DeleteCrossAccountAttachmentRequestT& request) const
        {
            return SubmitCallable(&GlobalAcceleratorClient::DeleteCrossAccountAttachment, request);
        }
 
        template<typename DeleteCrossAccountAttachmentRequestT = Model::DeleteCrossAccountAttachmentRequest>
        void DeleteCrossAccountAttachmentAsync(const DeleteCrossAccountAttachmentRequestT& request, const DeleteCrossAccountAttachmentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlobalAcceleratorClient::DeleteCrossAccountAttachment, request, handler, context);
        }
 
        virtual Model::DeleteCustomRoutingAcceleratorOutcome DeleteCustomRoutingAccelerator(const Model::DeleteCustomRoutingAcceleratorRequest& request) const;
 
        template<typename DeleteCustomRoutingAcceleratorRequestT = Model::DeleteCustomRoutingAcceleratorRequest>
        Model::DeleteCustomRoutingAcceleratorOutcomeCallable DeleteCustomRoutingAcceleratorCallable(const DeleteCustomRoutingAcceleratorRequestT& request) const
        {
            return SubmitCallable(&GlobalAcceleratorClient::DeleteCustomRoutingAccelerator, request);
        }
 
        template<typename DeleteCustomRoutingAcceleratorRequestT = Model::DeleteCustomRoutingAcceleratorRequest>
        void DeleteCustomRoutingAcceleratorAsync(const DeleteCustomRoutingAcceleratorRequestT& request, const DeleteCustomRoutingAcceleratorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlobalAcceleratorClient::DeleteCustomRoutingAccelerator, request, handler, context);
        }
 
        virtual Model::DeleteCustomRoutingEndpointGroupOutcome DeleteCustomRoutingEndpointGroup(const Model::DeleteCustomRoutingEndpointGroupRequest& request) const;
 
        template<typename DeleteCustomRoutingEndpointGroupRequestT = Model::DeleteCustomRoutingEndpointGroupRequest>
        Model::DeleteCustomRoutingEndpointGroupOutcomeCallable DeleteCustomRoutingEndpointGroupCallable(const DeleteCustomRoutingEndpointGroupRequestT& request) const
        {
            return SubmitCallable(&GlobalAcceleratorClient::DeleteCustomRoutingEndpointGroup, request);
        }
 
        template<typename DeleteCustomRoutingEndpointGroupRequestT = Model::DeleteCustomRoutingEndpointGroupRequest>
        void DeleteCustomRoutingEndpointGroupAsync(const DeleteCustomRoutingEndpointGroupRequestT& request, const DeleteCustomRoutingEndpointGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlobalAcceleratorClient::DeleteCustomRoutingEndpointGroup, request, handler, context);
        }
 
        virtual Model::DeleteCustomRoutingListenerOutcome DeleteCustomRoutingListener(const Model::DeleteCustomRoutingListenerRequest& request) const;
 
        template<typename DeleteCustomRoutingListenerRequestT = Model::DeleteCustomRoutingListenerRequest>
        Model::DeleteCustomRoutingListenerOutcomeCallable DeleteCustomRoutingListenerCallable(const DeleteCustomRoutingListenerRequestT& request) const
        {
            return SubmitCallable(&GlobalAcceleratorClient::DeleteCustomRoutingListener, request);
        }
 
        template<typename DeleteCustomRoutingListenerRequestT = Model::DeleteCustomRoutingListenerRequest>
        void DeleteCustomRoutingListenerAsync(const DeleteCustomRoutingListenerRequestT& request, const DeleteCustomRoutingListenerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlobalAcceleratorClient::DeleteCustomRoutingListener, request, handler, context);
        }
 
        virtual Model::DeleteEndpointGroupOutcome DeleteEndpointGroup(const Model::DeleteEndpointGroupRequest& request) const;
 
        template<typename DeleteEndpointGroupRequestT = Model::DeleteEndpointGroupRequest>
        Model::DeleteEndpointGroupOutcomeCallable DeleteEndpointGroupCallable(const DeleteEndpointGroupRequestT& request) const
        {
            return SubmitCallable(&GlobalAcceleratorClient::DeleteEndpointGroup, request);
        }
 
        template<typename DeleteEndpointGroupRequestT = Model::DeleteEndpointGroupRequest>
        void DeleteEndpointGroupAsync(const DeleteEndpointGroupRequestT& request, const DeleteEndpointGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlobalAcceleratorClient::DeleteEndpointGroup, request, handler, context);
        }
 
        virtual Model::DeleteListenerOutcome DeleteListener(const Model::DeleteListenerRequest& request) const;
 
        template<typename DeleteListenerRequestT = Model::DeleteListenerRequest>
        Model::DeleteListenerOutcomeCallable DeleteListenerCallable(const DeleteListenerRequestT& request) const
        {
            return SubmitCallable(&GlobalAcceleratorClient::DeleteListener, request);
        }
 
        template<typename DeleteListenerRequestT = Model::DeleteListenerRequest>
        void DeleteListenerAsync(const DeleteListenerRequestT& request, const DeleteListenerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlobalAcceleratorClient::DeleteListener, request, handler, context);
        }
 
        virtual Model::DenyCustomRoutingTrafficOutcome DenyCustomRoutingTraffic(const Model::DenyCustomRoutingTrafficRequest& request) const;
 
        template<typename DenyCustomRoutingTrafficRequestT = Model::DenyCustomRoutingTrafficRequest>
        Model::DenyCustomRoutingTrafficOutcomeCallable DenyCustomRoutingTrafficCallable(const DenyCustomRoutingTrafficRequestT& request) const
        {
            return SubmitCallable(&GlobalAcceleratorClient::DenyCustomRoutingTraffic, request);
        }
 
        template<typename DenyCustomRoutingTrafficRequestT = Model::DenyCustomRoutingTrafficRequest>
        void DenyCustomRoutingTrafficAsync(const DenyCustomRoutingTrafficRequestT& request, const DenyCustomRoutingTrafficResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlobalAcceleratorClient::DenyCustomRoutingTraffic, request, handler, context);
        }
 
        virtual Model::DeprovisionByoipCidrOutcome DeprovisionByoipCidr(const Model::DeprovisionByoipCidrRequest& request) const;
 
        template<typename DeprovisionByoipCidrRequestT = Model::DeprovisionByoipCidrRequest>
        Model::DeprovisionByoipCidrOutcomeCallable DeprovisionByoipCidrCallable(const DeprovisionByoipCidrRequestT& request) const
        {
            return SubmitCallable(&GlobalAcceleratorClient::DeprovisionByoipCidr, request);
        }
 
        template<typename DeprovisionByoipCidrRequestT = Model::DeprovisionByoipCidrRequest>
        void DeprovisionByoipCidrAsync(const DeprovisionByoipCidrRequestT& request, const DeprovisionByoipCidrResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlobalAcceleratorClient::DeprovisionByoipCidr, request, handler, context);
        }
 
        virtual Model::DescribeAcceleratorOutcome DescribeAccelerator(const Model::DescribeAcceleratorRequest& request) const;
 
        template<typename DescribeAcceleratorRequestT = Model::DescribeAcceleratorRequest>
        Model::DescribeAcceleratorOutcomeCallable DescribeAcceleratorCallable(const DescribeAcceleratorRequestT& request) const
        {
            return SubmitCallable(&GlobalAcceleratorClient::DescribeAccelerator, request);
        }
 
        template<typename DescribeAcceleratorRequestT = Model::DescribeAcceleratorRequest>
        void DescribeAcceleratorAsync(const DescribeAcceleratorRequestT& request, const DescribeAcceleratorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlobalAcceleratorClient::DescribeAccelerator, request, handler, context);
        }
 
        virtual Model::DescribeAcceleratorAttributesOutcome DescribeAcceleratorAttributes(const Model::DescribeAcceleratorAttributesRequest& request) const;
 
        template<typename DescribeAcceleratorAttributesRequestT = Model::DescribeAcceleratorAttributesRequest>
        Model::DescribeAcceleratorAttributesOutcomeCallable DescribeAcceleratorAttributesCallable(const DescribeAcceleratorAttributesRequestT& request) const
        {
            return SubmitCallable(&GlobalAcceleratorClient::DescribeAcceleratorAttributes, request);
        }
 
        template<typename DescribeAcceleratorAttributesRequestT = Model::DescribeAcceleratorAttributesRequest>
        void DescribeAcceleratorAttributesAsync(const DescribeAcceleratorAttributesRequestT& request, const DescribeAcceleratorAttributesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlobalAcceleratorClient::DescribeAcceleratorAttributes, request, handler, context);
        }
 
        virtual Model::DescribeCrossAccountAttachmentOutcome DescribeCrossAccountAttachment(const Model::DescribeCrossAccountAttachmentRequest& request) const;
 
        template<typename DescribeCrossAccountAttachmentRequestT = Model::DescribeCrossAccountAttachmentRequest>
        Model::DescribeCrossAccountAttachmentOutcomeCallable DescribeCrossAccountAttachmentCallable(const DescribeCrossAccountAttachmentRequestT& request) const
        {
            return SubmitCallable(&GlobalAcceleratorClient::DescribeCrossAccountAttachment, request);
        }
 
        template<typename DescribeCrossAccountAttachmentRequestT = Model::DescribeCrossAccountAttachmentRequest>
        void DescribeCrossAccountAttachmentAsync(const DescribeCrossAccountAttachmentRequestT& request, const DescribeCrossAccountAttachmentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlobalAcceleratorClient::DescribeCrossAccountAttachment, request, handler, context);
        }
 
        virtual Model::DescribeCustomRoutingAcceleratorOutcome DescribeCustomRoutingAccelerator(const Model::DescribeCustomRoutingAcceleratorRequest& request) const;
 
        template<typename DescribeCustomRoutingAcceleratorRequestT = Model::DescribeCustomRoutingAcceleratorRequest>
        Model::DescribeCustomRoutingAcceleratorOutcomeCallable DescribeCustomRoutingAcceleratorCallable(const DescribeCustomRoutingAcceleratorRequestT& request) const
        {
            return SubmitCallable(&GlobalAcceleratorClient::DescribeCustomRoutingAccelerator, request);
        }
 
        template<typename DescribeCustomRoutingAcceleratorRequestT = Model::DescribeCustomRoutingAcceleratorRequest>
        void DescribeCustomRoutingAcceleratorAsync(const DescribeCustomRoutingAcceleratorRequestT& request, const DescribeCustomRoutingAcceleratorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlobalAcceleratorClient::DescribeCustomRoutingAccelerator, request, handler, context);
        }
 
        virtual Model::DescribeCustomRoutingAcceleratorAttributesOutcome DescribeCustomRoutingAcceleratorAttributes(const Model::DescribeCustomRoutingAcceleratorAttributesRequest& request) const;
 
        template<typename DescribeCustomRoutingAcceleratorAttributesRequestT = Model::DescribeCustomRoutingAcceleratorAttributesRequest>
        Model::DescribeCustomRoutingAcceleratorAttributesOutcomeCallable DescribeCustomRoutingAcceleratorAttributesCallable(const DescribeCustomRoutingAcceleratorAttributesRequestT& request) const
        {
            return SubmitCallable(&GlobalAcceleratorClient::DescribeCustomRoutingAcceleratorAttributes, request);
        }
 
        template<typename DescribeCustomRoutingAcceleratorAttributesRequestT = Model::DescribeCustomRoutingAcceleratorAttributesRequest>
        void DescribeCustomRoutingAcceleratorAttributesAsync(const DescribeCustomRoutingAcceleratorAttributesRequestT& request, const DescribeCustomRoutingAcceleratorAttributesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlobalAcceleratorClient::DescribeCustomRoutingAcceleratorAttributes, request, handler, context);
        }
 
        virtual Model::DescribeCustomRoutingEndpointGroupOutcome DescribeCustomRoutingEndpointGroup(const Model::DescribeCustomRoutingEndpointGroupRequest& request) const;
 
        template<typename DescribeCustomRoutingEndpointGroupRequestT = Model::DescribeCustomRoutingEndpointGroupRequest>
        Model::DescribeCustomRoutingEndpointGroupOutcomeCallable DescribeCustomRoutingEndpointGroupCallable(const DescribeCustomRoutingEndpointGroupRequestT& request) const
        {
            return SubmitCallable(&GlobalAcceleratorClient::DescribeCustomRoutingEndpointGroup, request);
        }
 
        template<typename DescribeCustomRoutingEndpointGroupRequestT = Model::DescribeCustomRoutingEndpointGroupRequest>
        void DescribeCustomRoutingEndpointGroupAsync(const DescribeCustomRoutingEndpointGroupRequestT& request, const DescribeCustomRoutingEndpointGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlobalAcceleratorClient::DescribeCustomRoutingEndpointGroup, request, handler, context);
        }
 
        virtual Model::DescribeCustomRoutingListenerOutcome DescribeCustomRoutingListener(const Model::DescribeCustomRoutingListenerRequest& request) const;
 
        template<typename DescribeCustomRoutingListenerRequestT = Model::DescribeCustomRoutingListenerRequest>
        Model::DescribeCustomRoutingListenerOutcomeCallable DescribeCustomRoutingListenerCallable(const DescribeCustomRoutingListenerRequestT& request) const
        {
            return SubmitCallable(&GlobalAcceleratorClient::DescribeCustomRoutingListener, request);
        }
 
        template<typename DescribeCustomRoutingListenerRequestT = Model::DescribeCustomRoutingListenerRequest>
        void DescribeCustomRoutingListenerAsync(const DescribeCustomRoutingListenerRequestT& request, const DescribeCustomRoutingListenerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlobalAcceleratorClient::DescribeCustomRoutingListener, request, handler, context);
        }
 
        virtual Model::DescribeEndpointGroupOutcome DescribeEndpointGroup(const Model::DescribeEndpointGroupRequest& request) const;
 
        template<typename DescribeEndpointGroupRequestT = Model::DescribeEndpointGroupRequest>
        Model::DescribeEndpointGroupOutcomeCallable DescribeEndpointGroupCallable(const DescribeEndpointGroupRequestT& request) const
        {
            return SubmitCallable(&GlobalAcceleratorClient::DescribeEndpointGroup, request);
        }
 
        template<typename DescribeEndpointGroupRequestT = Model::DescribeEndpointGroupRequest>
        void DescribeEndpointGroupAsync(const DescribeEndpointGroupRequestT& request, const DescribeEndpointGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlobalAcceleratorClient::DescribeEndpointGroup, request, handler, context);
        }
 
        virtual Model::DescribeListenerOutcome DescribeListener(const Model::DescribeListenerRequest& request) const;
 
        template<typename DescribeListenerRequestT = Model::DescribeListenerRequest>
        Model::DescribeListenerOutcomeCallable DescribeListenerCallable(const DescribeListenerRequestT& request) const
        {
            return SubmitCallable(&GlobalAcceleratorClient::DescribeListener, request);
        }
 
        template<typename DescribeListenerRequestT = Model::DescribeListenerRequest>
        void DescribeListenerAsync(const DescribeListenerRequestT& request, const DescribeListenerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlobalAcceleratorClient::DescribeListener, request, handler, context);
        }
 
        virtual Model::ListAcceleratorsOutcome ListAccelerators(const Model::ListAcceleratorsRequest& request = {}) const;
 
        template<typename ListAcceleratorsRequestT = Model::ListAcceleratorsRequest>
        Model::ListAcceleratorsOutcomeCallable ListAcceleratorsCallable(const ListAcceleratorsRequestT& request = {}) const
        {
            return SubmitCallable(&GlobalAcceleratorClient::ListAccelerators, request);
        }
 
        template<typename ListAcceleratorsRequestT = Model::ListAcceleratorsRequest>
        void ListAcceleratorsAsync(const ListAcceleratorsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListAcceleratorsRequestT& request = {}) const
        {
            return SubmitAsync(&GlobalAcceleratorClient::ListAccelerators, request, handler, context);
        }
 
        virtual Model::ListByoipCidrsOutcome ListByoipCidrs(const Model::ListByoipCidrsRequest& request = {}) const;
 
        template<typename ListByoipCidrsRequestT = Model::ListByoipCidrsRequest>
        Model::ListByoipCidrsOutcomeCallable ListByoipCidrsCallable(const ListByoipCidrsRequestT& request = {}) const
        {
            return SubmitCallable(&GlobalAcceleratorClient::ListByoipCidrs, request);
        }
 
        template<typename ListByoipCidrsRequestT = Model::ListByoipCidrsRequest>
        void ListByoipCidrsAsync(const ListByoipCidrsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListByoipCidrsRequestT& request = {}) const
        {
            return SubmitAsync(&GlobalAcceleratorClient::ListByoipCidrs, request, handler, context);
        }
 
        virtual Model::ListCrossAccountAttachmentsOutcome ListCrossAccountAttachments(const Model::ListCrossAccountAttachmentsRequest& request = {}) const;
 
        template<typename ListCrossAccountAttachmentsRequestT = Model::ListCrossAccountAttachmentsRequest>
        Model::ListCrossAccountAttachmentsOutcomeCallable ListCrossAccountAttachmentsCallable(const ListCrossAccountAttachmentsRequestT& request = {}) const
        {
            return SubmitCallable(&GlobalAcceleratorClient::ListCrossAccountAttachments, request);
        }
 
        template<typename ListCrossAccountAttachmentsRequestT = Model::ListCrossAccountAttachmentsRequest>
        void ListCrossAccountAttachmentsAsync(const ListCrossAccountAttachmentsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListCrossAccountAttachmentsRequestT& request = {}) const
        {
            return SubmitAsync(&GlobalAcceleratorClient::ListCrossAccountAttachments, request, handler, context);
        }
 
        virtual Model::ListCrossAccountResourceAccountsOutcome ListCrossAccountResourceAccounts(const Model::ListCrossAccountResourceAccountsRequest& request = {}) const;
 
        template<typename ListCrossAccountResourceAccountsRequestT = Model::ListCrossAccountResourceAccountsRequest>
        Model::ListCrossAccountResourceAccountsOutcomeCallable ListCrossAccountResourceAccountsCallable(const ListCrossAccountResourceAccountsRequestT& request = {}) const
        {
            return SubmitCallable(&GlobalAcceleratorClient::ListCrossAccountResourceAccounts, request);
        }
 
        template<typename ListCrossAccountResourceAccountsRequestT = Model::ListCrossAccountResourceAccountsRequest>
        void ListCrossAccountResourceAccountsAsync(const ListCrossAccountResourceAccountsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListCrossAccountResourceAccountsRequestT& request = {}) const
        {
            return SubmitAsync(&GlobalAcceleratorClient::ListCrossAccountResourceAccounts, request, handler, context);
        }
 
        virtual Model::ListCrossAccountResourcesOutcome ListCrossAccountResources(const Model::ListCrossAccountResourcesRequest& request) const;
 
        template<typename ListCrossAccountResourcesRequestT = Model::ListCrossAccountResourcesRequest>
        Model::ListCrossAccountResourcesOutcomeCallable ListCrossAccountResourcesCallable(const ListCrossAccountResourcesRequestT& request) const
        {
            return SubmitCallable(&GlobalAcceleratorClient::ListCrossAccountResources, request);
        }
 
        template<typename ListCrossAccountResourcesRequestT = Model::ListCrossAccountResourcesRequest>
        void ListCrossAccountResourcesAsync(const ListCrossAccountResourcesRequestT& request, const ListCrossAccountResourcesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlobalAcceleratorClient::ListCrossAccountResources, request, handler, context);
        }
 
        virtual Model::ListCustomRoutingAcceleratorsOutcome ListCustomRoutingAccelerators(const Model::ListCustomRoutingAcceleratorsRequest& request = {}) const;
 
        template<typename ListCustomRoutingAcceleratorsRequestT = Model::ListCustomRoutingAcceleratorsRequest>
        Model::ListCustomRoutingAcceleratorsOutcomeCallable ListCustomRoutingAcceleratorsCallable(const ListCustomRoutingAcceleratorsRequestT& request = {}) const
        {
            return SubmitCallable(&GlobalAcceleratorClient::ListCustomRoutingAccelerators, request);
        }
 
        template<typename ListCustomRoutingAcceleratorsRequestT = Model::ListCustomRoutingAcceleratorsRequest>
        void ListCustomRoutingAcceleratorsAsync(const ListCustomRoutingAcceleratorsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListCustomRoutingAcceleratorsRequestT& request = {}) const
        {
            return SubmitAsync(&GlobalAcceleratorClient::ListCustomRoutingAccelerators, request, handler, context);
        }
 
        virtual Model::ListCustomRoutingEndpointGroupsOutcome ListCustomRoutingEndpointGroups(const Model::ListCustomRoutingEndpointGroupsRequest& request) const;
 
        template<typename ListCustomRoutingEndpointGroupsRequestT = Model::ListCustomRoutingEndpointGroupsRequest>
        Model::ListCustomRoutingEndpointGroupsOutcomeCallable ListCustomRoutingEndpointGroupsCallable(const ListCustomRoutingEndpointGroupsRequestT& request) const
        {
            return SubmitCallable(&GlobalAcceleratorClient::ListCustomRoutingEndpointGroups, request);
        }
 
        template<typename ListCustomRoutingEndpointGroupsRequestT = Model::ListCustomRoutingEndpointGroupsRequest>
        void ListCustomRoutingEndpointGroupsAsync(const ListCustomRoutingEndpointGroupsRequestT& request, const ListCustomRoutingEndpointGroupsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlobalAcceleratorClient::ListCustomRoutingEndpointGroups, request, handler, context);
        }
 
        virtual Model::ListCustomRoutingListenersOutcome ListCustomRoutingListeners(const Model::ListCustomRoutingListenersRequest& request) const;
 
        template<typename ListCustomRoutingListenersRequestT = Model::ListCustomRoutingListenersRequest>
        Model::ListCustomRoutingListenersOutcomeCallable ListCustomRoutingListenersCallable(const ListCustomRoutingListenersRequestT& request) const
        {
            return SubmitCallable(&GlobalAcceleratorClient::ListCustomRoutingListeners, request);
        }
 
        template<typename ListCustomRoutingListenersRequestT = Model::ListCustomRoutingListenersRequest>
        void ListCustomRoutingListenersAsync(const ListCustomRoutingListenersRequestT& request, const ListCustomRoutingListenersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlobalAcceleratorClient::ListCustomRoutingListeners, request, handler, context);
        }
 
        virtual Model::ListCustomRoutingPortMappingsOutcome ListCustomRoutingPortMappings(const Model::ListCustomRoutingPortMappingsRequest& request) const;
 
        template<typename ListCustomRoutingPortMappingsRequestT = Model::ListCustomRoutingPortMappingsRequest>
        Model::ListCustomRoutingPortMappingsOutcomeCallable ListCustomRoutingPortMappingsCallable(const ListCustomRoutingPortMappingsRequestT& request) const
        {
            return SubmitCallable(&GlobalAcceleratorClient::ListCustomRoutingPortMappings, request);
        }
 
        template<typename ListCustomRoutingPortMappingsRequestT = Model::ListCustomRoutingPortMappingsRequest>
        void ListCustomRoutingPortMappingsAsync(const ListCustomRoutingPortMappingsRequestT& request, const ListCustomRoutingPortMappingsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlobalAcceleratorClient::ListCustomRoutingPortMappings, request, handler, context);
        }
 
        virtual Model::ListCustomRoutingPortMappingsByDestinationOutcome ListCustomRoutingPortMappingsByDestination(const Model::ListCustomRoutingPortMappingsByDestinationRequest& request) const;
 
        template<typename ListCustomRoutingPortMappingsByDestinationRequestT = Model::ListCustomRoutingPortMappingsByDestinationRequest>
        Model::ListCustomRoutingPortMappingsByDestinationOutcomeCallable ListCustomRoutingPortMappingsByDestinationCallable(const ListCustomRoutingPortMappingsByDestinationRequestT& request) const
        {
            return SubmitCallable(&GlobalAcceleratorClient::ListCustomRoutingPortMappingsByDestination, request);
        }
 
        template<typename ListCustomRoutingPortMappingsByDestinationRequestT = Model::ListCustomRoutingPortMappingsByDestinationRequest>
        void ListCustomRoutingPortMappingsByDestinationAsync(const ListCustomRoutingPortMappingsByDestinationRequestT& request, const ListCustomRoutingPortMappingsByDestinationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlobalAcceleratorClient::ListCustomRoutingPortMappingsByDestination, request, handler, context);
        }
 
        virtual Model::ListEndpointGroupsOutcome ListEndpointGroups(const Model::ListEndpointGroupsRequest& request) const;
 
        template<typename ListEndpointGroupsRequestT = Model::ListEndpointGroupsRequest>
        Model::ListEndpointGroupsOutcomeCallable ListEndpointGroupsCallable(const ListEndpointGroupsRequestT& request) const
        {
            return SubmitCallable(&GlobalAcceleratorClient::ListEndpointGroups, request);
        }
 
        template<typename ListEndpointGroupsRequestT = Model::ListEndpointGroupsRequest>
        void ListEndpointGroupsAsync(const ListEndpointGroupsRequestT& request, const ListEndpointGroupsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlobalAcceleratorClient::ListEndpointGroups, request, handler, context);
        }
 
        virtual Model::ListListenersOutcome ListListeners(const Model::ListListenersRequest& request) const;
 
        template<typename ListListenersRequestT = Model::ListListenersRequest>
        Model::ListListenersOutcomeCallable ListListenersCallable(const ListListenersRequestT& request) const
        {
            return SubmitCallable(&GlobalAcceleratorClient::ListListeners, request);
        }
 
        template<typename ListListenersRequestT = Model::ListListenersRequest>
        void ListListenersAsync(const ListListenersRequestT& request, const ListListenersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlobalAcceleratorClient::ListListeners, 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(&GlobalAcceleratorClient::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(&GlobalAcceleratorClient::ListTagsForResource, request, handler, context);
        }
 
        virtual Model::ProvisionByoipCidrOutcome ProvisionByoipCidr(const Model::ProvisionByoipCidrRequest& request) const;
 
        template<typename ProvisionByoipCidrRequestT = Model::ProvisionByoipCidrRequest>
        Model::ProvisionByoipCidrOutcomeCallable ProvisionByoipCidrCallable(const ProvisionByoipCidrRequestT& request) const
        {
            return SubmitCallable(&GlobalAcceleratorClient::ProvisionByoipCidr, request);
        }
 
        template<typename ProvisionByoipCidrRequestT = Model::ProvisionByoipCidrRequest>
        void ProvisionByoipCidrAsync(const ProvisionByoipCidrRequestT& request, const ProvisionByoipCidrResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlobalAcceleratorClient::ProvisionByoipCidr, request, handler, context);
        }
 
        virtual Model::RemoveCustomRoutingEndpointsOutcome RemoveCustomRoutingEndpoints(const Model::RemoveCustomRoutingEndpointsRequest& request) const;
 
        template<typename RemoveCustomRoutingEndpointsRequestT = Model::RemoveCustomRoutingEndpointsRequest>
        Model::RemoveCustomRoutingEndpointsOutcomeCallable RemoveCustomRoutingEndpointsCallable(const RemoveCustomRoutingEndpointsRequestT& request) const
        {
            return SubmitCallable(&GlobalAcceleratorClient::RemoveCustomRoutingEndpoints, request);
        }
 
        template<typename RemoveCustomRoutingEndpointsRequestT = Model::RemoveCustomRoutingEndpointsRequest>
        void RemoveCustomRoutingEndpointsAsync(const RemoveCustomRoutingEndpointsRequestT& request, const RemoveCustomRoutingEndpointsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlobalAcceleratorClient::RemoveCustomRoutingEndpoints, request, handler, context);
        }
 
        virtual Model::RemoveEndpointsOutcome RemoveEndpoints(const Model::RemoveEndpointsRequest& request) const;
 
        template<typename RemoveEndpointsRequestT = Model::RemoveEndpointsRequest>
        Model::RemoveEndpointsOutcomeCallable RemoveEndpointsCallable(const RemoveEndpointsRequestT& request) const
        {
            return SubmitCallable(&GlobalAcceleratorClient::RemoveEndpoints, request);
        }
 
        template<typename RemoveEndpointsRequestT = Model::RemoveEndpointsRequest>
        void RemoveEndpointsAsync(const RemoveEndpointsRequestT& request, const RemoveEndpointsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlobalAcceleratorClient::RemoveEndpoints, 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(&GlobalAcceleratorClient::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(&GlobalAcceleratorClient::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(&GlobalAcceleratorClient::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(&GlobalAcceleratorClient::UntagResource, request, handler, context);
        }
 
        virtual Model::UpdateAcceleratorOutcome UpdateAccelerator(const Model::UpdateAcceleratorRequest& request) const;
 
        template<typename UpdateAcceleratorRequestT = Model::UpdateAcceleratorRequest>
        Model::UpdateAcceleratorOutcomeCallable UpdateAcceleratorCallable(const UpdateAcceleratorRequestT& request) const
        {
            return SubmitCallable(&GlobalAcceleratorClient::UpdateAccelerator, request);
        }
 
        template<typename UpdateAcceleratorRequestT = Model::UpdateAcceleratorRequest>
        void UpdateAcceleratorAsync(const UpdateAcceleratorRequestT& request, const UpdateAcceleratorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlobalAcceleratorClient::UpdateAccelerator, request, handler, context);
        }
 
        virtual Model::UpdateAcceleratorAttributesOutcome UpdateAcceleratorAttributes(const Model::UpdateAcceleratorAttributesRequest& request) const;
 
        template<typename UpdateAcceleratorAttributesRequestT = Model::UpdateAcceleratorAttributesRequest>
        Model::UpdateAcceleratorAttributesOutcomeCallable UpdateAcceleratorAttributesCallable(const UpdateAcceleratorAttributesRequestT& request) const
        {
            return SubmitCallable(&GlobalAcceleratorClient::UpdateAcceleratorAttributes, request);
        }
 
        template<typename UpdateAcceleratorAttributesRequestT = Model::UpdateAcceleratorAttributesRequest>
        void UpdateAcceleratorAttributesAsync(const UpdateAcceleratorAttributesRequestT& request, const UpdateAcceleratorAttributesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlobalAcceleratorClient::UpdateAcceleratorAttributes, request, handler, context);
        }
 
        virtual Model::UpdateCrossAccountAttachmentOutcome UpdateCrossAccountAttachment(const Model::UpdateCrossAccountAttachmentRequest& request) const;
 
        template<typename UpdateCrossAccountAttachmentRequestT = Model::UpdateCrossAccountAttachmentRequest>
        Model::UpdateCrossAccountAttachmentOutcomeCallable UpdateCrossAccountAttachmentCallable(const UpdateCrossAccountAttachmentRequestT& request) const
        {
            return SubmitCallable(&GlobalAcceleratorClient::UpdateCrossAccountAttachment, request);
        }
 
        template<typename UpdateCrossAccountAttachmentRequestT = Model::UpdateCrossAccountAttachmentRequest>
        void UpdateCrossAccountAttachmentAsync(const UpdateCrossAccountAttachmentRequestT& request, const UpdateCrossAccountAttachmentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlobalAcceleratorClient::UpdateCrossAccountAttachment, request, handler, context);
        }
 
        virtual Model::UpdateCustomRoutingAcceleratorOutcome UpdateCustomRoutingAccelerator(const Model::UpdateCustomRoutingAcceleratorRequest& request) const;
 
        template<typename UpdateCustomRoutingAcceleratorRequestT = Model::UpdateCustomRoutingAcceleratorRequest>
        Model::UpdateCustomRoutingAcceleratorOutcomeCallable UpdateCustomRoutingAcceleratorCallable(const UpdateCustomRoutingAcceleratorRequestT& request) const
        {
            return SubmitCallable(&GlobalAcceleratorClient::UpdateCustomRoutingAccelerator, request);
        }
 
        template<typename UpdateCustomRoutingAcceleratorRequestT = Model::UpdateCustomRoutingAcceleratorRequest>
        void UpdateCustomRoutingAcceleratorAsync(const UpdateCustomRoutingAcceleratorRequestT& request, const UpdateCustomRoutingAcceleratorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlobalAcceleratorClient::UpdateCustomRoutingAccelerator, request, handler, context);
        }
 
        virtual Model::UpdateCustomRoutingAcceleratorAttributesOutcome UpdateCustomRoutingAcceleratorAttributes(const Model::UpdateCustomRoutingAcceleratorAttributesRequest& request) const;
 
        template<typename UpdateCustomRoutingAcceleratorAttributesRequestT = Model::UpdateCustomRoutingAcceleratorAttributesRequest>
        Model::UpdateCustomRoutingAcceleratorAttributesOutcomeCallable UpdateCustomRoutingAcceleratorAttributesCallable(const UpdateCustomRoutingAcceleratorAttributesRequestT& request) const
        {
            return SubmitCallable(&GlobalAcceleratorClient::UpdateCustomRoutingAcceleratorAttributes, request);
        }
 
        template<typename UpdateCustomRoutingAcceleratorAttributesRequestT = Model::UpdateCustomRoutingAcceleratorAttributesRequest>
        void UpdateCustomRoutingAcceleratorAttributesAsync(const UpdateCustomRoutingAcceleratorAttributesRequestT& request, const UpdateCustomRoutingAcceleratorAttributesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlobalAcceleratorClient::UpdateCustomRoutingAcceleratorAttributes, request, handler, context);
        }
 
        virtual Model::UpdateCustomRoutingListenerOutcome UpdateCustomRoutingListener(const Model::UpdateCustomRoutingListenerRequest& request) const;
 
        template<typename UpdateCustomRoutingListenerRequestT = Model::UpdateCustomRoutingListenerRequest>
        Model::UpdateCustomRoutingListenerOutcomeCallable UpdateCustomRoutingListenerCallable(const UpdateCustomRoutingListenerRequestT& request) const
        {
            return SubmitCallable(&GlobalAcceleratorClient::UpdateCustomRoutingListener, request);
        }
 
        template<typename UpdateCustomRoutingListenerRequestT = Model::UpdateCustomRoutingListenerRequest>
        void UpdateCustomRoutingListenerAsync(const UpdateCustomRoutingListenerRequestT& request, const UpdateCustomRoutingListenerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlobalAcceleratorClient::UpdateCustomRoutingListener, request, handler, context);
        }
 
        virtual Model::UpdateEndpointGroupOutcome UpdateEndpointGroup(const Model::UpdateEndpointGroupRequest& request) const;
 
        template<typename UpdateEndpointGroupRequestT = Model::UpdateEndpointGroupRequest>
        Model::UpdateEndpointGroupOutcomeCallable UpdateEndpointGroupCallable(const UpdateEndpointGroupRequestT& request) const
        {
            return SubmitCallable(&GlobalAcceleratorClient::UpdateEndpointGroup, request);
        }
 
        template<typename UpdateEndpointGroupRequestT = Model::UpdateEndpointGroupRequest>
        void UpdateEndpointGroupAsync(const UpdateEndpointGroupRequestT& request, const UpdateEndpointGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlobalAcceleratorClient::UpdateEndpointGroup, request, handler, context);
        }
 
        virtual Model::UpdateListenerOutcome UpdateListener(const Model::UpdateListenerRequest& request) const;
 
        template<typename UpdateListenerRequestT = Model::UpdateListenerRequest>
        Model::UpdateListenerOutcomeCallable UpdateListenerCallable(const UpdateListenerRequestT& request) const
        {
            return SubmitCallable(&GlobalAcceleratorClient::UpdateListener, request);
        }
 
        template<typename UpdateListenerRequestT = Model::UpdateListenerRequest>
        void UpdateListenerAsync(const UpdateListenerRequestT& request, const UpdateListenerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlobalAcceleratorClient::UpdateListener, request, handler, context);
        }
 
        virtual Model::WithdrawByoipCidrOutcome WithdrawByoipCidr(const Model::WithdrawByoipCidrRequest& request) const;
 
        template<typename WithdrawByoipCidrRequestT = Model::WithdrawByoipCidrRequest>
        Model::WithdrawByoipCidrOutcomeCallable WithdrawByoipCidrCallable(const WithdrawByoipCidrRequestT& request) const
        {
            return SubmitCallable(&GlobalAcceleratorClient::WithdrawByoipCidr, request);
        }
 
        template<typename WithdrawByoipCidrRequestT = Model::WithdrawByoipCidrRequest>
        void WithdrawByoipCidrAsync(const WithdrawByoipCidrRequestT& request, const WithdrawByoipCidrResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlobalAcceleratorClient::WithdrawByoipCidr, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<GlobalAcceleratorEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<GlobalAcceleratorClient>;
      void init(const GlobalAcceleratorClientConfiguration& clientConfiguration);
 
      GlobalAcceleratorClientConfiguration m_clientConfiguration;
      std::shared_ptr<GlobalAcceleratorEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace GlobalAccelerator
} // namespace Aws