LocationServiceClient.h

 
#pragma once
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/location/LocationServicePaginationBase.h>
#include <aws/location/LocationServiceServiceClientModel.h>
#include <aws/location/LocationServiceWaiter.h>
#include <aws/location/LocationService_EXPORTS.h>
 
namespace Aws {
namespace LocationService {
class AWS_LOCATIONSERVICE_API LocationServiceClient : public Aws::Client::AWSJsonClient,
                                                      public Aws::Client::ClientWithAsyncTemplateMethods<LocationServiceClient>,
                                                      public LocationServicePaginationBase<LocationServiceClient>,
                                                      public LocationServiceWaiter<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);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<LocationServiceEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<LocationServiceClient>;
  void init(const LocationServiceClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, LocationServiceError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request,
                                                const std::function<void(Aws::Endpoint::ResolveEndpointOutcome&)>& resolveUri,
                                                Aws::Http::HttpMethod httpMethod) const;
 
  LocationServiceClientConfiguration m_clientConfiguration;
  std::shared_ptr<LocationServiceEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace LocationService
}  // namespace Aws