LocationServiceClient.h

 
#pragma once
#include <aws/location/LocationService_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/location/LocationServiceServiceClientModel.h>
 
namespace Aws
{
namespace LocationService
{
  class AWS_LOCATIONSERVICE_API LocationServiceClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<LocationServiceClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef LocationServiceClientConfiguration ClientConfigurationType;
      typedef LocationServiceEndpointProvider EndpointProviderType;
 
        LocationServiceClient(const Aws::LocationService::LocationServiceClientConfiguration& clientConfiguration = Aws::LocationService::LocationServiceClientConfiguration(),
                              std::shared_ptr<LocationServiceEndpointProviderBase> endpointProvider = nullptr);
 
        LocationServiceClient(const Aws::Auth::AWSCredentials& credentials,
                              std::shared_ptr<LocationServiceEndpointProviderBase> endpointProvider = nullptr,
                              const Aws::LocationService::LocationServiceClientConfiguration& clientConfiguration = Aws::LocationService::LocationServiceClientConfiguration());
 
        LocationServiceClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                              std::shared_ptr<LocationServiceEndpointProviderBase> endpointProvider = nullptr,
                              const Aws::LocationService::LocationServiceClientConfiguration& clientConfiguration = Aws::LocationService::LocationServiceClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        LocationServiceClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        LocationServiceClient(const Aws::Auth::AWSCredentials& credentials,
                              const Aws::Client::ClientConfiguration& clientConfiguration);
 
        LocationServiceClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                              const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~LocationServiceClient();
 
        virtual Model::AssociateTrackerConsumerOutcome AssociateTrackerConsumer(const Model::AssociateTrackerConsumerRequest& request) const;
 
        template<typename AssociateTrackerConsumerRequestT = Model::AssociateTrackerConsumerRequest>
        Model::AssociateTrackerConsumerOutcomeCallable AssociateTrackerConsumerCallable(const AssociateTrackerConsumerRequestT& request) const
        {
            return SubmitCallable(&LocationServiceClient::AssociateTrackerConsumer, request);
        }
 
        template<typename AssociateTrackerConsumerRequestT = Model::AssociateTrackerConsumerRequest>
        void AssociateTrackerConsumerAsync(const AssociateTrackerConsumerRequestT& request, const AssociateTrackerConsumerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LocationServiceClient::AssociateTrackerConsumer, request, handler, context);
        }
 
        virtual Model::BatchDeleteDevicePositionHistoryOutcome BatchDeleteDevicePositionHistory(const Model::BatchDeleteDevicePositionHistoryRequest& request) const;
 
        template<typename BatchDeleteDevicePositionHistoryRequestT = Model::BatchDeleteDevicePositionHistoryRequest>
        Model::BatchDeleteDevicePositionHistoryOutcomeCallable BatchDeleteDevicePositionHistoryCallable(const BatchDeleteDevicePositionHistoryRequestT& request) const
        {
            return SubmitCallable(&LocationServiceClient::BatchDeleteDevicePositionHistory, request);
        }
 
        template<typename BatchDeleteDevicePositionHistoryRequestT = Model::BatchDeleteDevicePositionHistoryRequest>
        void BatchDeleteDevicePositionHistoryAsync(const BatchDeleteDevicePositionHistoryRequestT& request, const BatchDeleteDevicePositionHistoryResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LocationServiceClient::BatchDeleteDevicePositionHistory, request, handler, context);
        }
 
        virtual Model::BatchDeleteGeofenceOutcome BatchDeleteGeofence(const Model::BatchDeleteGeofenceRequest& request) const;
 
        template<typename BatchDeleteGeofenceRequestT = Model::BatchDeleteGeofenceRequest>
        Model::BatchDeleteGeofenceOutcomeCallable BatchDeleteGeofenceCallable(const BatchDeleteGeofenceRequestT& request) const
        {
            return SubmitCallable(&LocationServiceClient::BatchDeleteGeofence, request);
        }
 
        template<typename BatchDeleteGeofenceRequestT = Model::BatchDeleteGeofenceRequest>
        void BatchDeleteGeofenceAsync(const BatchDeleteGeofenceRequestT& request, const BatchDeleteGeofenceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LocationServiceClient::BatchDeleteGeofence, request, handler, context);
        }
 
        virtual Model::BatchEvaluateGeofencesOutcome BatchEvaluateGeofences(const Model::BatchEvaluateGeofencesRequest& request) const;
 
        template<typename BatchEvaluateGeofencesRequestT = Model::BatchEvaluateGeofencesRequest>
        Model::BatchEvaluateGeofencesOutcomeCallable BatchEvaluateGeofencesCallable(const BatchEvaluateGeofencesRequestT& request) const
        {
            return SubmitCallable(&LocationServiceClient::BatchEvaluateGeofences, request);
        }
 
        template<typename BatchEvaluateGeofencesRequestT = Model::BatchEvaluateGeofencesRequest>
        void BatchEvaluateGeofencesAsync(const BatchEvaluateGeofencesRequestT& request, const BatchEvaluateGeofencesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LocationServiceClient::BatchEvaluateGeofences, request, handler, context);
        }
 
        virtual Model::BatchGetDevicePositionOutcome BatchGetDevicePosition(const Model::BatchGetDevicePositionRequest& request) const;
 
        template<typename BatchGetDevicePositionRequestT = Model::BatchGetDevicePositionRequest>
        Model::BatchGetDevicePositionOutcomeCallable BatchGetDevicePositionCallable(const BatchGetDevicePositionRequestT& request) const
        {
            return SubmitCallable(&LocationServiceClient::BatchGetDevicePosition, request);
        }
 
        template<typename BatchGetDevicePositionRequestT = Model::BatchGetDevicePositionRequest>
        void BatchGetDevicePositionAsync(const BatchGetDevicePositionRequestT& request, const BatchGetDevicePositionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LocationServiceClient::BatchGetDevicePosition, request, handler, context);
        }
 
        virtual Model::BatchPutGeofenceOutcome BatchPutGeofence(const Model::BatchPutGeofenceRequest& request) const;
 
        template<typename BatchPutGeofenceRequestT = Model::BatchPutGeofenceRequest>
        Model::BatchPutGeofenceOutcomeCallable BatchPutGeofenceCallable(const BatchPutGeofenceRequestT& request) const
        {
            return SubmitCallable(&LocationServiceClient::BatchPutGeofence, request);
        }
 
        template<typename BatchPutGeofenceRequestT = Model::BatchPutGeofenceRequest>
        void BatchPutGeofenceAsync(const BatchPutGeofenceRequestT& request, const BatchPutGeofenceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LocationServiceClient::BatchPutGeofence, request, handler, context);
        }
 
        virtual Model::BatchUpdateDevicePositionOutcome BatchUpdateDevicePosition(const Model::BatchUpdateDevicePositionRequest& request) const;
 
        template<typename BatchUpdateDevicePositionRequestT = Model::BatchUpdateDevicePositionRequest>
        Model::BatchUpdateDevicePositionOutcomeCallable BatchUpdateDevicePositionCallable(const BatchUpdateDevicePositionRequestT& request) const
        {
            return SubmitCallable(&LocationServiceClient::BatchUpdateDevicePosition, request);
        }
 
        template<typename BatchUpdateDevicePositionRequestT = Model::BatchUpdateDevicePositionRequest>
        void BatchUpdateDevicePositionAsync(const BatchUpdateDevicePositionRequestT& request, const BatchUpdateDevicePositionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LocationServiceClient::BatchUpdateDevicePosition, request, handler, context);
        }
 
        virtual Model::CalculateRouteOutcome CalculateRoute(const Model::CalculateRouteRequest& request) const;
 
        template<typename CalculateRouteRequestT = Model::CalculateRouteRequest>
        Model::CalculateRouteOutcomeCallable CalculateRouteCallable(const CalculateRouteRequestT& request) const
        {
            return SubmitCallable(&LocationServiceClient::CalculateRoute, request);
        }
 
        template<typename CalculateRouteRequestT = Model::CalculateRouteRequest>
        void CalculateRouteAsync(const CalculateRouteRequestT& request, const CalculateRouteResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LocationServiceClient::CalculateRoute, request, handler, context);
        }
 
        virtual Model::CalculateRouteMatrixOutcome CalculateRouteMatrix(const Model::CalculateRouteMatrixRequest& request) const;
 
        template<typename CalculateRouteMatrixRequestT = Model::CalculateRouteMatrixRequest>
        Model::CalculateRouteMatrixOutcomeCallable CalculateRouteMatrixCallable(const CalculateRouteMatrixRequestT& request) const
        {
            return SubmitCallable(&LocationServiceClient::CalculateRouteMatrix, request);
        }
 
        template<typename CalculateRouteMatrixRequestT = Model::CalculateRouteMatrixRequest>
        void CalculateRouteMatrixAsync(const CalculateRouteMatrixRequestT& request, const CalculateRouteMatrixResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LocationServiceClient::CalculateRouteMatrix, request, handler, context);
        }
 
        virtual Model::CreateGeofenceCollectionOutcome CreateGeofenceCollection(const Model::CreateGeofenceCollectionRequest& request) const;
 
        template<typename CreateGeofenceCollectionRequestT = Model::CreateGeofenceCollectionRequest>
        Model::CreateGeofenceCollectionOutcomeCallable CreateGeofenceCollectionCallable(const CreateGeofenceCollectionRequestT& request) const
        {
            return SubmitCallable(&LocationServiceClient::CreateGeofenceCollection, request);
        }
 
        template<typename CreateGeofenceCollectionRequestT = Model::CreateGeofenceCollectionRequest>
        void CreateGeofenceCollectionAsync(const CreateGeofenceCollectionRequestT& request, const CreateGeofenceCollectionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LocationServiceClient::CreateGeofenceCollection, request, handler, context);
        }
 
        virtual Model::CreateKeyOutcome CreateKey(const Model::CreateKeyRequest& request) const;
 
        template<typename CreateKeyRequestT = Model::CreateKeyRequest>
        Model::CreateKeyOutcomeCallable CreateKeyCallable(const CreateKeyRequestT& request) const
        {
            return SubmitCallable(&LocationServiceClient::CreateKey, request);
        }
 
        template<typename CreateKeyRequestT = Model::CreateKeyRequest>
        void CreateKeyAsync(const CreateKeyRequestT& request, const CreateKeyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LocationServiceClient::CreateKey, request, handler, context);
        }
 
        virtual Model::CreateMapOutcome CreateMap(const Model::CreateMapRequest& request) const;
 
        template<typename CreateMapRequestT = Model::CreateMapRequest>
        Model::CreateMapOutcomeCallable CreateMapCallable(const CreateMapRequestT& request) const
        {
            return SubmitCallable(&LocationServiceClient::CreateMap, request);
        }
 
        template<typename CreateMapRequestT = Model::CreateMapRequest>
        void CreateMapAsync(const CreateMapRequestT& request, const CreateMapResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LocationServiceClient::CreateMap, request, handler, context);
        }
 
        virtual Model::CreatePlaceIndexOutcome CreatePlaceIndex(const Model::CreatePlaceIndexRequest& request) const;
 
        template<typename CreatePlaceIndexRequestT = Model::CreatePlaceIndexRequest>
        Model::CreatePlaceIndexOutcomeCallable CreatePlaceIndexCallable(const CreatePlaceIndexRequestT& request) const
        {
            return SubmitCallable(&LocationServiceClient::CreatePlaceIndex, request);
        }
 
        template<typename CreatePlaceIndexRequestT = Model::CreatePlaceIndexRequest>
        void CreatePlaceIndexAsync(const CreatePlaceIndexRequestT& request, const CreatePlaceIndexResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LocationServiceClient::CreatePlaceIndex, request, handler, context);
        }
 
        virtual Model::CreateRouteCalculatorOutcome CreateRouteCalculator(const Model::CreateRouteCalculatorRequest& request) const;
 
        template<typename CreateRouteCalculatorRequestT = Model::CreateRouteCalculatorRequest>
        Model::CreateRouteCalculatorOutcomeCallable CreateRouteCalculatorCallable(const CreateRouteCalculatorRequestT& request) const
        {
            return SubmitCallable(&LocationServiceClient::CreateRouteCalculator, request);
        }
 
        template<typename CreateRouteCalculatorRequestT = Model::CreateRouteCalculatorRequest>
        void CreateRouteCalculatorAsync(const CreateRouteCalculatorRequestT& request, const CreateRouteCalculatorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LocationServiceClient::CreateRouteCalculator, request, handler, context);
        }
 
        virtual Model::CreateTrackerOutcome CreateTracker(const Model::CreateTrackerRequest& request) const;
 
        template<typename CreateTrackerRequestT = Model::CreateTrackerRequest>
        Model::CreateTrackerOutcomeCallable CreateTrackerCallable(const CreateTrackerRequestT& request) const
        {
            return SubmitCallable(&LocationServiceClient::CreateTracker, request);
        }
 
        template<typename CreateTrackerRequestT = Model::CreateTrackerRequest>
        void CreateTrackerAsync(const CreateTrackerRequestT& request, const CreateTrackerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LocationServiceClient::CreateTracker, request, handler, context);
        }
 
        virtual Model::DeleteGeofenceCollectionOutcome DeleteGeofenceCollection(const Model::DeleteGeofenceCollectionRequest& request) const;
 
        template<typename DeleteGeofenceCollectionRequestT = Model::DeleteGeofenceCollectionRequest>
        Model::DeleteGeofenceCollectionOutcomeCallable DeleteGeofenceCollectionCallable(const DeleteGeofenceCollectionRequestT& request) const
        {
            return SubmitCallable(&LocationServiceClient::DeleteGeofenceCollection, request);
        }
 
        template<typename DeleteGeofenceCollectionRequestT = Model::DeleteGeofenceCollectionRequest>
        void DeleteGeofenceCollectionAsync(const DeleteGeofenceCollectionRequestT& request, const DeleteGeofenceCollectionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LocationServiceClient::DeleteGeofenceCollection, request, handler, context);
        }
 
        virtual Model::DeleteKeyOutcome DeleteKey(const Model::DeleteKeyRequest& request) const;
 
        template<typename DeleteKeyRequestT = Model::DeleteKeyRequest>
        Model::DeleteKeyOutcomeCallable DeleteKeyCallable(const DeleteKeyRequestT& request) const
        {
            return SubmitCallable(&LocationServiceClient::DeleteKey, request);
        }
 
        template<typename DeleteKeyRequestT = Model::DeleteKeyRequest>
        void DeleteKeyAsync(const DeleteKeyRequestT& request, const DeleteKeyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LocationServiceClient::DeleteKey, request, handler, context);
        }
 
        virtual Model::DeleteMapOutcome DeleteMap(const Model::DeleteMapRequest& request) const;
 
        template<typename DeleteMapRequestT = Model::DeleteMapRequest>
        Model::DeleteMapOutcomeCallable DeleteMapCallable(const DeleteMapRequestT& request) const
        {
            return SubmitCallable(&LocationServiceClient::DeleteMap, request);
        }
 
        template<typename DeleteMapRequestT = Model::DeleteMapRequest>
        void DeleteMapAsync(const DeleteMapRequestT& request, const DeleteMapResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LocationServiceClient::DeleteMap, request, handler, context);
        }
 
        virtual Model::DeletePlaceIndexOutcome DeletePlaceIndex(const Model::DeletePlaceIndexRequest& request) const;
 
        template<typename DeletePlaceIndexRequestT = Model::DeletePlaceIndexRequest>
        Model::DeletePlaceIndexOutcomeCallable DeletePlaceIndexCallable(const DeletePlaceIndexRequestT& request) const
        {
            return SubmitCallable(&LocationServiceClient::DeletePlaceIndex, request);
        }
 
        template<typename DeletePlaceIndexRequestT = Model::DeletePlaceIndexRequest>
        void DeletePlaceIndexAsync(const DeletePlaceIndexRequestT& request, const DeletePlaceIndexResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LocationServiceClient::DeletePlaceIndex, request, handler, context);
        }
 
        virtual Model::DeleteRouteCalculatorOutcome DeleteRouteCalculator(const Model::DeleteRouteCalculatorRequest& request) const;
 
        template<typename DeleteRouteCalculatorRequestT = Model::DeleteRouteCalculatorRequest>
        Model::DeleteRouteCalculatorOutcomeCallable DeleteRouteCalculatorCallable(const DeleteRouteCalculatorRequestT& request) const
        {
            return SubmitCallable(&LocationServiceClient::DeleteRouteCalculator, request);
        }
 
        template<typename DeleteRouteCalculatorRequestT = Model::DeleteRouteCalculatorRequest>
        void DeleteRouteCalculatorAsync(const DeleteRouteCalculatorRequestT& request, const DeleteRouteCalculatorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LocationServiceClient::DeleteRouteCalculator, request, handler, context);
        }
 
        virtual Model::DeleteTrackerOutcome DeleteTracker(const Model::DeleteTrackerRequest& request) const;
 
        template<typename DeleteTrackerRequestT = Model::DeleteTrackerRequest>
        Model::DeleteTrackerOutcomeCallable DeleteTrackerCallable(const DeleteTrackerRequestT& request) const
        {
            return SubmitCallable(&LocationServiceClient::DeleteTracker, request);
        }
 
        template<typename DeleteTrackerRequestT = Model::DeleteTrackerRequest>
        void DeleteTrackerAsync(const DeleteTrackerRequestT& request, const DeleteTrackerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LocationServiceClient::DeleteTracker, request, handler, context);
        }
 
        virtual Model::DescribeGeofenceCollectionOutcome DescribeGeofenceCollection(const Model::DescribeGeofenceCollectionRequest& request) const;
 
        template<typename DescribeGeofenceCollectionRequestT = Model::DescribeGeofenceCollectionRequest>
        Model::DescribeGeofenceCollectionOutcomeCallable DescribeGeofenceCollectionCallable(const DescribeGeofenceCollectionRequestT& request) const
        {
            return SubmitCallable(&LocationServiceClient::DescribeGeofenceCollection, request);
        }
 
        template<typename DescribeGeofenceCollectionRequestT = Model::DescribeGeofenceCollectionRequest>
        void DescribeGeofenceCollectionAsync(const DescribeGeofenceCollectionRequestT& request, const DescribeGeofenceCollectionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LocationServiceClient::DescribeGeofenceCollection, request, handler, context);
        }
 
        virtual Model::DescribeKeyOutcome DescribeKey(const Model::DescribeKeyRequest& request) const;
 
        template<typename DescribeKeyRequestT = Model::DescribeKeyRequest>
        Model::DescribeKeyOutcomeCallable DescribeKeyCallable(const DescribeKeyRequestT& request) const
        {
            return SubmitCallable(&LocationServiceClient::DescribeKey, request);
        }
 
        template<typename DescribeKeyRequestT = Model::DescribeKeyRequest>
        void DescribeKeyAsync(const DescribeKeyRequestT& request, const DescribeKeyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LocationServiceClient::DescribeKey, request, handler, context);
        }
 
        virtual Model::DescribeMapOutcome DescribeMap(const Model::DescribeMapRequest& request) const;
 
        template<typename DescribeMapRequestT = Model::DescribeMapRequest>
        Model::DescribeMapOutcomeCallable DescribeMapCallable(const DescribeMapRequestT& request) const
        {
            return SubmitCallable(&LocationServiceClient::DescribeMap, request);
        }
 
        template<typename DescribeMapRequestT = Model::DescribeMapRequest>
        void DescribeMapAsync(const DescribeMapRequestT& request, const DescribeMapResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LocationServiceClient::DescribeMap, request, handler, context);
        }
 
        virtual Model::DescribePlaceIndexOutcome DescribePlaceIndex(const Model::DescribePlaceIndexRequest& request) const;
 
        template<typename DescribePlaceIndexRequestT = Model::DescribePlaceIndexRequest>
        Model::DescribePlaceIndexOutcomeCallable DescribePlaceIndexCallable(const DescribePlaceIndexRequestT& request) const
        {
            return SubmitCallable(&LocationServiceClient::DescribePlaceIndex, request);
        }
 
        template<typename DescribePlaceIndexRequestT = Model::DescribePlaceIndexRequest>
        void DescribePlaceIndexAsync(const DescribePlaceIndexRequestT& request, const DescribePlaceIndexResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LocationServiceClient::DescribePlaceIndex, request, handler, context);
        }
 
        virtual Model::DescribeRouteCalculatorOutcome DescribeRouteCalculator(const Model::DescribeRouteCalculatorRequest& request) const;
 
        template<typename DescribeRouteCalculatorRequestT = Model::DescribeRouteCalculatorRequest>
        Model::DescribeRouteCalculatorOutcomeCallable DescribeRouteCalculatorCallable(const DescribeRouteCalculatorRequestT& request) const
        {
            return SubmitCallable(&LocationServiceClient::DescribeRouteCalculator, request);
        }
 
        template<typename DescribeRouteCalculatorRequestT = Model::DescribeRouteCalculatorRequest>
        void DescribeRouteCalculatorAsync(const DescribeRouteCalculatorRequestT& request, const DescribeRouteCalculatorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LocationServiceClient::DescribeRouteCalculator, request, handler, context);
        }
 
        virtual Model::DescribeTrackerOutcome DescribeTracker(const Model::DescribeTrackerRequest& request) const;
 
        template<typename DescribeTrackerRequestT = Model::DescribeTrackerRequest>
        Model::DescribeTrackerOutcomeCallable DescribeTrackerCallable(const DescribeTrackerRequestT& request) const
        {
            return SubmitCallable(&LocationServiceClient::DescribeTracker, request);
        }
 
        template<typename DescribeTrackerRequestT = Model::DescribeTrackerRequest>
        void DescribeTrackerAsync(const DescribeTrackerRequestT& request, const DescribeTrackerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LocationServiceClient::DescribeTracker, request, handler, context);
        }
 
        virtual Model::DisassociateTrackerConsumerOutcome DisassociateTrackerConsumer(const Model::DisassociateTrackerConsumerRequest& request) const;
 
        template<typename DisassociateTrackerConsumerRequestT = Model::DisassociateTrackerConsumerRequest>
        Model::DisassociateTrackerConsumerOutcomeCallable DisassociateTrackerConsumerCallable(const DisassociateTrackerConsumerRequestT& request) const
        {
            return SubmitCallable(&LocationServiceClient::DisassociateTrackerConsumer, request);
        }
 
        template<typename DisassociateTrackerConsumerRequestT = Model::DisassociateTrackerConsumerRequest>
        void DisassociateTrackerConsumerAsync(const DisassociateTrackerConsumerRequestT& request, const DisassociateTrackerConsumerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LocationServiceClient::DisassociateTrackerConsumer, request, handler, context);
        }
 
        virtual Model::ForecastGeofenceEventsOutcome ForecastGeofenceEvents(const Model::ForecastGeofenceEventsRequest& request) const;
 
        template<typename ForecastGeofenceEventsRequestT = Model::ForecastGeofenceEventsRequest>
        Model::ForecastGeofenceEventsOutcomeCallable ForecastGeofenceEventsCallable(const ForecastGeofenceEventsRequestT& request) const
        {
            return SubmitCallable(&LocationServiceClient::ForecastGeofenceEvents, request);
        }
 
        template<typename ForecastGeofenceEventsRequestT = Model::ForecastGeofenceEventsRequest>
        void ForecastGeofenceEventsAsync(const ForecastGeofenceEventsRequestT& request, const ForecastGeofenceEventsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LocationServiceClient::ForecastGeofenceEvents, request, handler, context);
        }
 
        virtual Model::GetDevicePositionOutcome GetDevicePosition(const Model::GetDevicePositionRequest& request) const;
 
        template<typename GetDevicePositionRequestT = Model::GetDevicePositionRequest>
        Model::GetDevicePositionOutcomeCallable GetDevicePositionCallable(const GetDevicePositionRequestT& request) const
        {
            return SubmitCallable(&LocationServiceClient::GetDevicePosition, request);
        }
 
        template<typename GetDevicePositionRequestT = Model::GetDevicePositionRequest>
        void GetDevicePositionAsync(const GetDevicePositionRequestT& request, const GetDevicePositionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LocationServiceClient::GetDevicePosition, request, handler, context);
        }
 
        virtual Model::GetDevicePositionHistoryOutcome GetDevicePositionHistory(const Model::GetDevicePositionHistoryRequest& request) const;
 
        template<typename GetDevicePositionHistoryRequestT = Model::GetDevicePositionHistoryRequest>
        Model::GetDevicePositionHistoryOutcomeCallable GetDevicePositionHistoryCallable(const GetDevicePositionHistoryRequestT& request) const
        {
            return SubmitCallable(&LocationServiceClient::GetDevicePositionHistory, request);
        }
 
        template<typename GetDevicePositionHistoryRequestT = Model::GetDevicePositionHistoryRequest>
        void GetDevicePositionHistoryAsync(const GetDevicePositionHistoryRequestT& request, const GetDevicePositionHistoryResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LocationServiceClient::GetDevicePositionHistory, request, handler, context);
        }
 
        virtual Model::GetGeofenceOutcome GetGeofence(const Model::GetGeofenceRequest& request) const;
 
        template<typename GetGeofenceRequestT = Model::GetGeofenceRequest>
        Model::GetGeofenceOutcomeCallable GetGeofenceCallable(const GetGeofenceRequestT& request) const
        {
            return SubmitCallable(&LocationServiceClient::GetGeofence, request);
        }
 
        template<typename GetGeofenceRequestT = Model::GetGeofenceRequest>
        void GetGeofenceAsync(const GetGeofenceRequestT& request, const GetGeofenceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LocationServiceClient::GetGeofence, request, handler, context);
        }
 
        virtual Model::GetMapGlyphsOutcome GetMapGlyphs(const Model::GetMapGlyphsRequest& request) const;
 
        template<typename GetMapGlyphsRequestT = Model::GetMapGlyphsRequest>
        Model::GetMapGlyphsOutcomeCallable GetMapGlyphsCallable(const GetMapGlyphsRequestT& request) const
        {
            return SubmitCallable(&LocationServiceClient::GetMapGlyphs, request);
        }
 
        template<typename GetMapGlyphsRequestT = Model::GetMapGlyphsRequest>
        void GetMapGlyphsAsync(const GetMapGlyphsRequestT& request, const GetMapGlyphsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LocationServiceClient::GetMapGlyphs, request, handler, context);
        }
 
        virtual Model::GetMapSpritesOutcome GetMapSprites(const Model::GetMapSpritesRequest& request) const;
 
        template<typename GetMapSpritesRequestT = Model::GetMapSpritesRequest>
        Model::GetMapSpritesOutcomeCallable GetMapSpritesCallable(const GetMapSpritesRequestT& request) const
        {
            return SubmitCallable(&LocationServiceClient::GetMapSprites, request);
        }
 
        template<typename GetMapSpritesRequestT = Model::GetMapSpritesRequest>
        void GetMapSpritesAsync(const GetMapSpritesRequestT& request, const GetMapSpritesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LocationServiceClient::GetMapSprites, request, handler, context);
        }
 
        virtual Model::GetMapStyleDescriptorOutcome GetMapStyleDescriptor(const Model::GetMapStyleDescriptorRequest& request) const;
 
        template<typename GetMapStyleDescriptorRequestT = Model::GetMapStyleDescriptorRequest>
        Model::GetMapStyleDescriptorOutcomeCallable GetMapStyleDescriptorCallable(const GetMapStyleDescriptorRequestT& request) const
        {
            return SubmitCallable(&LocationServiceClient::GetMapStyleDescriptor, request);
        }
 
        template<typename GetMapStyleDescriptorRequestT = Model::GetMapStyleDescriptorRequest>
        void GetMapStyleDescriptorAsync(const GetMapStyleDescriptorRequestT& request, const GetMapStyleDescriptorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LocationServiceClient::GetMapStyleDescriptor, request, handler, context);
        }
 
        virtual Model::GetMapTileOutcome GetMapTile(const Model::GetMapTileRequest& request) const;
 
        template<typename GetMapTileRequestT = Model::GetMapTileRequest>
        Model::GetMapTileOutcomeCallable GetMapTileCallable(const GetMapTileRequestT& request) const
        {
            return SubmitCallable(&LocationServiceClient::GetMapTile, request);
        }
 
        template<typename GetMapTileRequestT = Model::GetMapTileRequest>
        void GetMapTileAsync(const GetMapTileRequestT& request, const GetMapTileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LocationServiceClient::GetMapTile, request, handler, context);
        }
 
        virtual Model::GetPlaceOutcome GetPlace(const Model::GetPlaceRequest& request) const;
 
        template<typename GetPlaceRequestT = Model::GetPlaceRequest>
        Model::GetPlaceOutcomeCallable GetPlaceCallable(const GetPlaceRequestT& request) const
        {
            return SubmitCallable(&LocationServiceClient::GetPlace, request);
        }
 
        template<typename GetPlaceRequestT = Model::GetPlaceRequest>
        void GetPlaceAsync(const GetPlaceRequestT& request, const GetPlaceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LocationServiceClient::GetPlace, request, handler, context);
        }
 
        virtual Model::ListDevicePositionsOutcome ListDevicePositions(const Model::ListDevicePositionsRequest& request) const;
 
        template<typename ListDevicePositionsRequestT = Model::ListDevicePositionsRequest>
        Model::ListDevicePositionsOutcomeCallable ListDevicePositionsCallable(const ListDevicePositionsRequestT& request) const
        {
            return SubmitCallable(&LocationServiceClient::ListDevicePositions, request);
        }
 
        template<typename ListDevicePositionsRequestT = Model::ListDevicePositionsRequest>
        void ListDevicePositionsAsync(const ListDevicePositionsRequestT& request, const ListDevicePositionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LocationServiceClient::ListDevicePositions, request, handler, context);
        }
 
        virtual Model::ListGeofenceCollectionsOutcome ListGeofenceCollections(const Model::ListGeofenceCollectionsRequest& request = {}) const;
 
        template<typename ListGeofenceCollectionsRequestT = Model::ListGeofenceCollectionsRequest>
        Model::ListGeofenceCollectionsOutcomeCallable ListGeofenceCollectionsCallable(const ListGeofenceCollectionsRequestT& request = {}) const
        {
            return SubmitCallable(&LocationServiceClient::ListGeofenceCollections, request);
        }
 
        template<typename ListGeofenceCollectionsRequestT = Model::ListGeofenceCollectionsRequest>
        void ListGeofenceCollectionsAsync(const ListGeofenceCollectionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListGeofenceCollectionsRequestT& request = {}) const
        {
            return SubmitAsync(&LocationServiceClient::ListGeofenceCollections, request, handler, context);
        }
 
        virtual Model::ListGeofencesOutcome ListGeofences(const Model::ListGeofencesRequest& request) const;
 
        template<typename ListGeofencesRequestT = Model::ListGeofencesRequest>
        Model::ListGeofencesOutcomeCallable ListGeofencesCallable(const ListGeofencesRequestT& request) const
        {
            return SubmitCallable(&LocationServiceClient::ListGeofences, request);
        }
 
        template<typename ListGeofencesRequestT = Model::ListGeofencesRequest>
        void ListGeofencesAsync(const ListGeofencesRequestT& request, const ListGeofencesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LocationServiceClient::ListGeofences, request, handler, context);
        }
 
        virtual Model::ListKeysOutcome ListKeys(const Model::ListKeysRequest& request = {}) const;
 
        template<typename ListKeysRequestT = Model::ListKeysRequest>
        Model::ListKeysOutcomeCallable ListKeysCallable(const ListKeysRequestT& request = {}) const
        {
            return SubmitCallable(&LocationServiceClient::ListKeys, request);
        }
 
        template<typename ListKeysRequestT = Model::ListKeysRequest>
        void ListKeysAsync(const ListKeysResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListKeysRequestT& request = {}) const
        {
            return SubmitAsync(&LocationServiceClient::ListKeys, request, handler, context);
        }
 
        virtual Model::ListMapsOutcome ListMaps(const Model::ListMapsRequest& request = {}) const;
 
        template<typename ListMapsRequestT = Model::ListMapsRequest>
        Model::ListMapsOutcomeCallable ListMapsCallable(const ListMapsRequestT& request = {}) const
        {
            return SubmitCallable(&LocationServiceClient::ListMaps, request);
        }
 
        template<typename ListMapsRequestT = Model::ListMapsRequest>
        void ListMapsAsync(const ListMapsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListMapsRequestT& request = {}) const
        {
            return SubmitAsync(&LocationServiceClient::ListMaps, request, handler, context);
        }
 
        virtual Model::ListPlaceIndexesOutcome ListPlaceIndexes(const Model::ListPlaceIndexesRequest& request = {}) const;
 
        template<typename ListPlaceIndexesRequestT = Model::ListPlaceIndexesRequest>
        Model::ListPlaceIndexesOutcomeCallable ListPlaceIndexesCallable(const ListPlaceIndexesRequestT& request = {}) const
        {
            return SubmitCallable(&LocationServiceClient::ListPlaceIndexes, request);
        }
 
        template<typename ListPlaceIndexesRequestT = Model::ListPlaceIndexesRequest>
        void ListPlaceIndexesAsync(const ListPlaceIndexesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListPlaceIndexesRequestT& request = {}) const
        {
            return SubmitAsync(&LocationServiceClient::ListPlaceIndexes, request, handler, context);
        }
 
        virtual Model::ListRouteCalculatorsOutcome ListRouteCalculators(const Model::ListRouteCalculatorsRequest& request = {}) const;
 
        template<typename ListRouteCalculatorsRequestT = Model::ListRouteCalculatorsRequest>
        Model::ListRouteCalculatorsOutcomeCallable ListRouteCalculatorsCallable(const ListRouteCalculatorsRequestT& request = {}) const
        {
            return SubmitCallable(&LocationServiceClient::ListRouteCalculators, request);
        }
 
        template<typename ListRouteCalculatorsRequestT = Model::ListRouteCalculatorsRequest>
        void ListRouteCalculatorsAsync(const ListRouteCalculatorsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListRouteCalculatorsRequestT& request = {}) const
        {
            return SubmitAsync(&LocationServiceClient::ListRouteCalculators, 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(&LocationServiceClient::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(&LocationServiceClient::ListTagsForResource, request, handler, context);
        }
 
        virtual Model::ListTrackerConsumersOutcome ListTrackerConsumers(const Model::ListTrackerConsumersRequest& request) const;
 
        template<typename ListTrackerConsumersRequestT = Model::ListTrackerConsumersRequest>
        Model::ListTrackerConsumersOutcomeCallable ListTrackerConsumersCallable(const ListTrackerConsumersRequestT& request) const
        {
            return SubmitCallable(&LocationServiceClient::ListTrackerConsumers, request);
        }
 
        template<typename ListTrackerConsumersRequestT = Model::ListTrackerConsumersRequest>
        void ListTrackerConsumersAsync(const ListTrackerConsumersRequestT& request, const ListTrackerConsumersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LocationServiceClient::ListTrackerConsumers, request, handler, context);
        }
 
        virtual Model::ListTrackersOutcome ListTrackers(const Model::ListTrackersRequest& request = {}) const;
 
        template<typename ListTrackersRequestT = Model::ListTrackersRequest>
        Model::ListTrackersOutcomeCallable ListTrackersCallable(const ListTrackersRequestT& request = {}) const
        {
            return SubmitCallable(&LocationServiceClient::ListTrackers, request);
        }
 
        template<typename ListTrackersRequestT = Model::ListTrackersRequest>
        void ListTrackersAsync(const ListTrackersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListTrackersRequestT& request = {}) const
        {
            return SubmitAsync(&LocationServiceClient::ListTrackers, request, handler, context);
        }
 
        virtual Model::PutGeofenceOutcome PutGeofence(const Model::PutGeofenceRequest& request) const;
 
        template<typename PutGeofenceRequestT = Model::PutGeofenceRequest>
        Model::PutGeofenceOutcomeCallable PutGeofenceCallable(const PutGeofenceRequestT& request) const
        {
            return SubmitCallable(&LocationServiceClient::PutGeofence, request);
        }
 
        template<typename PutGeofenceRequestT = Model::PutGeofenceRequest>
        void PutGeofenceAsync(const PutGeofenceRequestT& request, const PutGeofenceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LocationServiceClient::PutGeofence, request, handler, context);
        }
 
        virtual Model::SearchPlaceIndexForPositionOutcome SearchPlaceIndexForPosition(const Model::SearchPlaceIndexForPositionRequest& request) const;
 
        template<typename SearchPlaceIndexForPositionRequestT = Model::SearchPlaceIndexForPositionRequest>
        Model::SearchPlaceIndexForPositionOutcomeCallable SearchPlaceIndexForPositionCallable(const SearchPlaceIndexForPositionRequestT& request) const
        {
            return SubmitCallable(&LocationServiceClient::SearchPlaceIndexForPosition, request);
        }
 
        template<typename SearchPlaceIndexForPositionRequestT = Model::SearchPlaceIndexForPositionRequest>
        void SearchPlaceIndexForPositionAsync(const SearchPlaceIndexForPositionRequestT& request, const SearchPlaceIndexForPositionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LocationServiceClient::SearchPlaceIndexForPosition, request, handler, context);
        }
 
        virtual Model::SearchPlaceIndexForSuggestionsOutcome SearchPlaceIndexForSuggestions(const Model::SearchPlaceIndexForSuggestionsRequest& request) const;
 
        template<typename SearchPlaceIndexForSuggestionsRequestT = Model::SearchPlaceIndexForSuggestionsRequest>
        Model::SearchPlaceIndexForSuggestionsOutcomeCallable SearchPlaceIndexForSuggestionsCallable(const SearchPlaceIndexForSuggestionsRequestT& request) const
        {
            return SubmitCallable(&LocationServiceClient::SearchPlaceIndexForSuggestions, request);
        }
 
        template<typename SearchPlaceIndexForSuggestionsRequestT = Model::SearchPlaceIndexForSuggestionsRequest>
        void SearchPlaceIndexForSuggestionsAsync(const SearchPlaceIndexForSuggestionsRequestT& request, const SearchPlaceIndexForSuggestionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LocationServiceClient::SearchPlaceIndexForSuggestions, request, handler, context);
        }
 
        virtual Model::SearchPlaceIndexForTextOutcome SearchPlaceIndexForText(const Model::SearchPlaceIndexForTextRequest& request) const;
 
        template<typename SearchPlaceIndexForTextRequestT = Model::SearchPlaceIndexForTextRequest>
        Model::SearchPlaceIndexForTextOutcomeCallable SearchPlaceIndexForTextCallable(const SearchPlaceIndexForTextRequestT& request) const
        {
            return SubmitCallable(&LocationServiceClient::SearchPlaceIndexForText, request);
        }
 
        template<typename SearchPlaceIndexForTextRequestT = Model::SearchPlaceIndexForTextRequest>
        void SearchPlaceIndexForTextAsync(const SearchPlaceIndexForTextRequestT& request, const SearchPlaceIndexForTextResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LocationServiceClient::SearchPlaceIndexForText, 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(&LocationServiceClient::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(&LocationServiceClient::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(&LocationServiceClient::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(&LocationServiceClient::UntagResource, request, handler, context);
        }
 
        virtual Model::UpdateGeofenceCollectionOutcome UpdateGeofenceCollection(const Model::UpdateGeofenceCollectionRequest& request) const;
 
        template<typename UpdateGeofenceCollectionRequestT = Model::UpdateGeofenceCollectionRequest>
        Model::UpdateGeofenceCollectionOutcomeCallable UpdateGeofenceCollectionCallable(const UpdateGeofenceCollectionRequestT& request) const
        {
            return SubmitCallable(&LocationServiceClient::UpdateGeofenceCollection, request);
        }
 
        template<typename UpdateGeofenceCollectionRequestT = Model::UpdateGeofenceCollectionRequest>
        void UpdateGeofenceCollectionAsync(const UpdateGeofenceCollectionRequestT& request, const UpdateGeofenceCollectionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LocationServiceClient::UpdateGeofenceCollection, request, handler, context);
        }
 
        virtual Model::UpdateKeyOutcome UpdateKey(const Model::UpdateKeyRequest& request) const;
 
        template<typename UpdateKeyRequestT = Model::UpdateKeyRequest>
        Model::UpdateKeyOutcomeCallable UpdateKeyCallable(const UpdateKeyRequestT& request) const
        {
            return SubmitCallable(&LocationServiceClient::UpdateKey, request);
        }
 
        template<typename UpdateKeyRequestT = Model::UpdateKeyRequest>
        void UpdateKeyAsync(const UpdateKeyRequestT& request, const UpdateKeyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LocationServiceClient::UpdateKey, request, handler, context);
        }
 
        virtual Model::UpdateMapOutcome UpdateMap(const Model::UpdateMapRequest& request) const;
 
        template<typename UpdateMapRequestT = Model::UpdateMapRequest>
        Model::UpdateMapOutcomeCallable UpdateMapCallable(const UpdateMapRequestT& request) const
        {
            return SubmitCallable(&LocationServiceClient::UpdateMap, request);
        }
 
        template<typename UpdateMapRequestT = Model::UpdateMapRequest>
        void UpdateMapAsync(const UpdateMapRequestT& request, const UpdateMapResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LocationServiceClient::UpdateMap, request, handler, context);
        }
 
        virtual Model::UpdatePlaceIndexOutcome UpdatePlaceIndex(const Model::UpdatePlaceIndexRequest& request) const;
 
        template<typename UpdatePlaceIndexRequestT = Model::UpdatePlaceIndexRequest>
        Model::UpdatePlaceIndexOutcomeCallable UpdatePlaceIndexCallable(const UpdatePlaceIndexRequestT& request) const
        {
            return SubmitCallable(&LocationServiceClient::UpdatePlaceIndex, request);
        }
 
        template<typename UpdatePlaceIndexRequestT = Model::UpdatePlaceIndexRequest>
        void UpdatePlaceIndexAsync(const UpdatePlaceIndexRequestT& request, const UpdatePlaceIndexResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LocationServiceClient::UpdatePlaceIndex, request, handler, context);
        }
 
        virtual Model::UpdateRouteCalculatorOutcome UpdateRouteCalculator(const Model::UpdateRouteCalculatorRequest& request) const;
 
        template<typename UpdateRouteCalculatorRequestT = Model::UpdateRouteCalculatorRequest>
        Model::UpdateRouteCalculatorOutcomeCallable UpdateRouteCalculatorCallable(const UpdateRouteCalculatorRequestT& request) const
        {
            return SubmitCallable(&LocationServiceClient::UpdateRouteCalculator, request);
        }
 
        template<typename UpdateRouteCalculatorRequestT = Model::UpdateRouteCalculatorRequest>
        void UpdateRouteCalculatorAsync(const UpdateRouteCalculatorRequestT& request, const UpdateRouteCalculatorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LocationServiceClient::UpdateRouteCalculator, request, handler, context);
        }
 
        virtual Model::UpdateTrackerOutcome UpdateTracker(const Model::UpdateTrackerRequest& request) const;
 
        template<typename UpdateTrackerRequestT = Model::UpdateTrackerRequest>
        Model::UpdateTrackerOutcomeCallable UpdateTrackerCallable(const UpdateTrackerRequestT& request) const
        {
            return SubmitCallable(&LocationServiceClient::UpdateTracker, request);
        }
 
        template<typename UpdateTrackerRequestT = Model::UpdateTrackerRequest>
        void UpdateTrackerAsync(const UpdateTrackerRequestT& request, const UpdateTrackerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LocationServiceClient::UpdateTracker, request, handler, context);
        }
 
        virtual Model::VerifyDevicePositionOutcome VerifyDevicePosition(const Model::VerifyDevicePositionRequest& request) const;
 
        template<typename VerifyDevicePositionRequestT = Model::VerifyDevicePositionRequest>
        Model::VerifyDevicePositionOutcomeCallable VerifyDevicePositionCallable(const VerifyDevicePositionRequestT& request) const
        {
            return SubmitCallable(&LocationServiceClient::VerifyDevicePosition, request);
        }
 
        template<typename VerifyDevicePositionRequestT = Model::VerifyDevicePositionRequest>
        void VerifyDevicePositionAsync(const VerifyDevicePositionRequestT& request, const VerifyDevicePositionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LocationServiceClient::VerifyDevicePosition, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<LocationServiceEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<LocationServiceClient>;
      void init(const LocationServiceClientConfiguration& clientConfiguration);
 
      LocationServiceClientConfiguration m_clientConfiguration;
      std::shared_ptr<LocationServiceEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace LocationService
} // namespace Aws