/** * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. * SPDX-License-Identifier: Apache-2.0. */ #pragma once #include #include #include #include #include #include namespace Aws { namespace LocationService { /** *

"Suite of geospatial services including Maps, Places, Routes, Tracking, and * Geofencing"

*/ class AWS_LOCATIONSERVICE_API LocationServiceClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* SERVICE_NAME; static const char* ALLOCATION_TAG; typedef LocationServiceClientConfiguration ClientConfigurationType; typedef LocationServiceEndpointProvider EndpointProviderType; /** * Initializes client to use DefaultCredentialProviderChain, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ LocationServiceClient(const Aws::LocationService::LocationServiceClientConfiguration& clientConfiguration = Aws::LocationService::LocationServiceClientConfiguration(), std::shared_ptr endpointProvider = Aws::MakeShared(ALLOCATION_TAG)); /** * Initializes client to use SimpleAWSCredentialsProvider, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ LocationServiceClient(const Aws::Auth::AWSCredentials& credentials, std::shared_ptr endpointProvider = Aws::MakeShared(ALLOCATION_TAG), const Aws::LocationService::LocationServiceClientConfiguration& clientConfiguration = Aws::LocationService::LocationServiceClientConfiguration()); /** * Initializes client to use specified credentials provider with specified client config. If http client factory is not supplied, * the default http client factory will be used */ LocationServiceClient(const std::shared_ptr& credentialsProvider, std::shared_ptr endpointProvider = Aws::MakeShared(ALLOCATION_TAG), const Aws::LocationService::LocationServiceClientConfiguration& clientConfiguration = Aws::LocationService::LocationServiceClientConfiguration()); /* Legacy constructors due deprecation */ /** * Initializes client to use DefaultCredentialProviderChain, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ LocationServiceClient(const Aws::Client::ClientConfiguration& clientConfiguration); /** * Initializes client to use SimpleAWSCredentialsProvider, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ LocationServiceClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration); /** * Initializes client to use specified credentials provider with specified client config. If http client factory is not supplied, * the default http client factory will be used */ LocationServiceClient(const std::shared_ptr& credentialsProvider, const Aws::Client::ClientConfiguration& clientConfiguration); /* End of legacy constructors due deprecation */ virtual ~LocationServiceClient(); /** *

Creates an association between a geofence collection and a tracker resource. * This allows the tracker resource to communicate location data to the linked * geofence collection.

You can associate up to five geofence collections * to each tracker resource.

Currently not supported — Cross-account * configurations, such as creating associations between a tracker resource in one * account and a geofence collection in another account.

See * Also:

AWS * API Reference

*/ virtual Model::AssociateTrackerConsumerOutcome AssociateTrackerConsumer(const Model::AssociateTrackerConsumerRequest& request) const; /** * A Callable wrapper for AssociateTrackerConsumer that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AssociateTrackerConsumerOutcomeCallable AssociateTrackerConsumerCallable(const AssociateTrackerConsumerRequestT& request) const { return SubmitCallable(&LocationServiceClient::AssociateTrackerConsumer, request); } /** * An Async wrapper for AssociateTrackerConsumer that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AssociateTrackerConsumerAsync(const AssociateTrackerConsumerRequestT& request, const AssociateTrackerConsumerResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LocationServiceClient::AssociateTrackerConsumer, request, handler, context); } /** *

Deletes the position history of one or more devices from a tracker * resource.

See Also:

AWS * API Reference

*/ virtual Model::BatchDeleteDevicePositionHistoryOutcome BatchDeleteDevicePositionHistory(const Model::BatchDeleteDevicePositionHistoryRequest& request) const; /** * A Callable wrapper for BatchDeleteDevicePositionHistory that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::BatchDeleteDevicePositionHistoryOutcomeCallable BatchDeleteDevicePositionHistoryCallable(const BatchDeleteDevicePositionHistoryRequestT& request) const { return SubmitCallable(&LocationServiceClient::BatchDeleteDevicePositionHistory, request); } /** * An Async wrapper for BatchDeleteDevicePositionHistory that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void BatchDeleteDevicePositionHistoryAsync(const BatchDeleteDevicePositionHistoryRequestT& request, const BatchDeleteDevicePositionHistoryResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LocationServiceClient::BatchDeleteDevicePositionHistory, request, handler, context); } /** *

Deletes a batch of geofences from a geofence collection.

This * operation deletes the resource permanently.

See Also:

* AWS * API Reference

*/ virtual Model::BatchDeleteGeofenceOutcome BatchDeleteGeofence(const Model::BatchDeleteGeofenceRequest& request) const; /** * A Callable wrapper for BatchDeleteGeofence that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::BatchDeleteGeofenceOutcomeCallable BatchDeleteGeofenceCallable(const BatchDeleteGeofenceRequestT& request) const { return SubmitCallable(&LocationServiceClient::BatchDeleteGeofence, request); } /** * An Async wrapper for BatchDeleteGeofence that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void BatchDeleteGeofenceAsync(const BatchDeleteGeofenceRequestT& request, const BatchDeleteGeofenceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LocationServiceClient::BatchDeleteGeofence, request, handler, context); } /** *

Evaluates device positions against the geofence geometries from a given * geofence collection.

This operation always returns an empty response * because geofences are asynchronously evaluated. The evaluation determines if the * device has entered or exited a geofenced area, and then publishes one of the * following events to Amazon EventBridge:

  • ENTER if * Amazon Location determines that the tracked device has entered a geofenced * area.

  • EXIT if Amazon Location determines that * the tracked device has exited a geofenced area.

The * last geofence that a device was observed within is tracked for 30 days after the * most recent device position update.

Geofence evaluation * uses the given device position. It does not account for the optional * Accuracy of a DevicePositionUpdate.

*

The DeviceID is used as a string to represent the device. You do * not need to have a Tracker associated with the * DeviceID.

See Also:

AWS * API Reference

*/ virtual Model::BatchEvaluateGeofencesOutcome BatchEvaluateGeofences(const Model::BatchEvaluateGeofencesRequest& request) const; /** * A Callable wrapper for BatchEvaluateGeofences that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::BatchEvaluateGeofencesOutcomeCallable BatchEvaluateGeofencesCallable(const BatchEvaluateGeofencesRequestT& request) const { return SubmitCallable(&LocationServiceClient::BatchEvaluateGeofences, request); } /** * An Async wrapper for BatchEvaluateGeofences that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void BatchEvaluateGeofencesAsync(const BatchEvaluateGeofencesRequestT& request, const BatchEvaluateGeofencesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LocationServiceClient::BatchEvaluateGeofences, request, handler, context); } /** *

Lists the latest device positions for requested devices.

See * Also:

AWS * API Reference

*/ virtual Model::BatchGetDevicePositionOutcome BatchGetDevicePosition(const Model::BatchGetDevicePositionRequest& request) const; /** * A Callable wrapper for BatchGetDevicePosition that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::BatchGetDevicePositionOutcomeCallable BatchGetDevicePositionCallable(const BatchGetDevicePositionRequestT& request) const { return SubmitCallable(&LocationServiceClient::BatchGetDevicePosition, request); } /** * An Async wrapper for BatchGetDevicePosition that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void BatchGetDevicePositionAsync(const BatchGetDevicePositionRequestT& request, const BatchGetDevicePositionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LocationServiceClient::BatchGetDevicePosition, request, handler, context); } /** *

A batch request for storing geofence geometries into a given geofence * collection, or updates the geometry of an existing geofence if a geofence ID is * included in the request.

See Also:

AWS * API Reference

*/ virtual Model::BatchPutGeofenceOutcome BatchPutGeofence(const Model::BatchPutGeofenceRequest& request) const; /** * A Callable wrapper for BatchPutGeofence that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::BatchPutGeofenceOutcomeCallable BatchPutGeofenceCallable(const BatchPutGeofenceRequestT& request) const { return SubmitCallable(&LocationServiceClient::BatchPutGeofence, request); } /** * An Async wrapper for BatchPutGeofence that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void BatchPutGeofenceAsync(const BatchPutGeofenceRequestT& request, const BatchPutGeofenceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LocationServiceClient::BatchPutGeofence, request, handler, context); } /** *

Uploads position update data for one or more devices to a tracker resource * (up to 10 devices per batch). Amazon Location uses the data when it reports the * last known device position and position history. Amazon Location retains * location data for 30 days.

Position updates are handled based on * the PositionFiltering property of the tracker. When * PositionFiltering is set to TimeBased, updates are * evaluated against linked geofence collections, and location data is stored at a * maximum of one position per 30 second interval. If your update frequency is more * often than every 30 seconds, only one update per 30 seconds is stored for each * unique device ID.

When PositionFiltering is set to * DistanceBased filtering, location data is stored and evaluated * against linked geofence collections only if the device has moved more than 30 m * (98.4 ft).

When PositionFiltering is set to * AccuracyBased filtering, location data is stored and evaluated * against linked geofence collections only if the device has moved more than the * measured accuracy. For example, if two consecutive updates from a device have a * horizontal accuracy of 5 m and 10 m, the second update is neither stored or * evaluated if the device has moved less than 15 m. If * PositionFiltering is set to AccuracyBased filtering, * Amazon Location uses the default value { "Horizontal": 0} when * accuracy is not provided on a DevicePositionUpdate.

*

See Also:

AWS * API Reference

*/ virtual Model::BatchUpdateDevicePositionOutcome BatchUpdateDevicePosition(const Model::BatchUpdateDevicePositionRequest& request) const; /** * A Callable wrapper for BatchUpdateDevicePosition that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::BatchUpdateDevicePositionOutcomeCallable BatchUpdateDevicePositionCallable(const BatchUpdateDevicePositionRequestT& request) const { return SubmitCallable(&LocationServiceClient::BatchUpdateDevicePosition, request); } /** * An Async wrapper for BatchUpdateDevicePosition that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void BatchUpdateDevicePositionAsync(const BatchUpdateDevicePositionRequestT& request, const BatchUpdateDevicePositionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LocationServiceClient::BatchUpdateDevicePosition, request, handler, context); } /** *

Calculates * a route given the following required parameters: * DeparturePosition and DestinationPosition. Requires * that you first create * a route calculator resource.

By default, a request that doesn't * specify a departure time uses the best time of day to travel with the best * traffic conditions when calculating the route.

Additional options * include:

  • Specifying * a departure time using either DepartureTime or * DepartNow. This calculates a route based on predictive traffic data * at the given time.

    You can't specify both * DepartureTime and DepartNow in a single request. * Specifying both parameters returns a validation error.

  • *

    Specifying * a travel mode using TravelMode sets the transportation mode used to * calculate the routes. This also lets you specify additional route preferences in * CarModeOptions if traveling by Car, or * TruckModeOptions if traveling by Truck.

    *

    If you specify walking for the travel mode and your data * provider is Esri, the start and destination must be within 40km.

    *

See Also:

AWS * API Reference

*/ virtual Model::CalculateRouteOutcome CalculateRoute(const Model::CalculateRouteRequest& request) const; /** * A Callable wrapper for CalculateRoute that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CalculateRouteOutcomeCallable CalculateRouteCallable(const CalculateRouteRequestT& request) const { return SubmitCallable(&LocationServiceClient::CalculateRoute, request); } /** * An Async wrapper for CalculateRoute that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CalculateRouteAsync(const CalculateRouteRequestT& request, const CalculateRouteResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LocationServiceClient::CalculateRoute, request, handler, context); } /** *

* Calculates a route matrix given the following required parameters: * DeparturePositions and DestinationPositions. * CalculateRouteMatrix calculates routes and returns the travel time * and travel distance from each departure position to each destination position in * the request. For example, given departure positions A and B, and destination * positions X and Y, CalculateRouteMatrix will return time and * distance for routes from A to X, A to Y, B to X, and B to Y (in that order). The * number of results returned (and routes calculated) will be the number of * DeparturePositions times the number of * DestinationPositions.

Your account is charged for * each route calculated, not the number of requests.

Requires that * you first create * a route calculator resource.

By default, a request that doesn't * specify a departure time uses the best time of day to travel with the best * traffic conditions when calculating routes.

Additional options * include:

  • * Specifying a departure time using either DepartureTime or * DepartNow. This calculates routes based on predictive traffic data * at the given time.

    You can't specify both * DepartureTime and DepartNow in a single request. * Specifying both parameters returns a validation error.

  • *

    Specifying * a travel mode using TravelMode sets the transportation mode used to * calculate the routes. This also lets you specify additional route preferences in * CarModeOptions if traveling by Car, or * TruckModeOptions if traveling by Truck.

    • *

See Also:

AWS * API Reference

*/ virtual Model::CalculateRouteMatrixOutcome CalculateRouteMatrix(const Model::CalculateRouteMatrixRequest& request) const; /** * A Callable wrapper for CalculateRouteMatrix that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CalculateRouteMatrixOutcomeCallable CalculateRouteMatrixCallable(const CalculateRouteMatrixRequestT& request) const { return SubmitCallable(&LocationServiceClient::CalculateRouteMatrix, request); } /** * An Async wrapper for CalculateRouteMatrix that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CalculateRouteMatrixAsync(const CalculateRouteMatrixRequestT& request, const CalculateRouteMatrixResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LocationServiceClient::CalculateRouteMatrix, request, handler, context); } /** *

Creates a geofence collection, which manages and stores * geofences.

See Also:

AWS * API Reference

*/ virtual Model::CreateGeofenceCollectionOutcome CreateGeofenceCollection(const Model::CreateGeofenceCollectionRequest& request) const; /** * A Callable wrapper for CreateGeofenceCollection that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateGeofenceCollectionOutcomeCallable CreateGeofenceCollectionCallable(const CreateGeofenceCollectionRequestT& request) const { return SubmitCallable(&LocationServiceClient::CreateGeofenceCollection, request); } /** * An Async wrapper for CreateGeofenceCollection that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateGeofenceCollectionAsync(const CreateGeofenceCollectionRequestT& request, const CreateGeofenceCollectionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LocationServiceClient::CreateGeofenceCollection, request, handler, context); } /** *

Creates an API key resource in your Amazon Web Services account, which lets * you grant actions for Amazon Location resources to the API key bearer.

*

For more information, see Using * API keys.

See Also:

AWS * API Reference

*/ virtual Model::CreateKeyOutcome CreateKey(const Model::CreateKeyRequest& request) const; /** * A Callable wrapper for CreateKey that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateKeyOutcomeCallable CreateKeyCallable(const CreateKeyRequestT& request) const { return SubmitCallable(&LocationServiceClient::CreateKey, request); } /** * An Async wrapper for CreateKey that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateKeyAsync(const CreateKeyRequestT& request, const CreateKeyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LocationServiceClient::CreateKey, request, handler, context); } /** *

Creates a map resource in your Amazon Web Services account, which provides * map tiles of different styles sourced from global location data providers.

*

If your application is tracking or routing assets you use in your * business, such as delivery vehicles or employees, you must not use Esri as your * geolocation provider. See section 82 of the Amazon Web Services service terms * for more details.

See Also:

AWS * API Reference

*/ virtual Model::CreateMapOutcome CreateMap(const Model::CreateMapRequest& request) const; /** * A Callable wrapper for CreateMap that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateMapOutcomeCallable CreateMapCallable(const CreateMapRequestT& request) const { return SubmitCallable(&LocationServiceClient::CreateMap, request); } /** * An Async wrapper for CreateMap that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateMapAsync(const CreateMapRequestT& request, const CreateMapResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LocationServiceClient::CreateMap, request, handler, context); } /** *

Creates a place index resource in your Amazon Web Services account. Use a * place index resource to geocode addresses and other text queries by using the * SearchPlaceIndexForText operation, and reverse geocode coordinates * by using the SearchPlaceIndexForPosition operation, and enable * autosuggestions by using the SearchPlaceIndexForSuggestions * operation.

If your application is tracking or routing assets you * use in your business, such as delivery vehicles or employees, you must not use * Esri as your geolocation provider. See section 82 of the Amazon Web Services service terms * for more details.

See Also:

AWS * API Reference

*/ virtual Model::CreatePlaceIndexOutcome CreatePlaceIndex(const Model::CreatePlaceIndexRequest& request) const; /** * A Callable wrapper for CreatePlaceIndex that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreatePlaceIndexOutcomeCallable CreatePlaceIndexCallable(const CreatePlaceIndexRequestT& request) const { return SubmitCallable(&LocationServiceClient::CreatePlaceIndex, request); } /** * An Async wrapper for CreatePlaceIndex that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreatePlaceIndexAsync(const CreatePlaceIndexRequestT& request, const CreatePlaceIndexResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LocationServiceClient::CreatePlaceIndex, request, handler, context); } /** *

Creates a route calculator resource in your Amazon Web Services account.

*

You can send requests to a route calculator resource to estimate travel time, * distance, and get directions. A route calculator sources traffic and road * network data from your chosen data provider.

If your application * is tracking or routing assets you use in your business, such as delivery * vehicles or employees, you must not use Esri as your geolocation provider. See * section 82 of the Amazon Web * Services service terms for more details.

See Also:

* AWS * API Reference

*/ virtual Model::CreateRouteCalculatorOutcome CreateRouteCalculator(const Model::CreateRouteCalculatorRequest& request) const; /** * A Callable wrapper for CreateRouteCalculator that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateRouteCalculatorOutcomeCallable CreateRouteCalculatorCallable(const CreateRouteCalculatorRequestT& request) const { return SubmitCallable(&LocationServiceClient::CreateRouteCalculator, request); } /** * An Async wrapper for CreateRouteCalculator that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateRouteCalculatorAsync(const CreateRouteCalculatorRequestT& request, const CreateRouteCalculatorResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LocationServiceClient::CreateRouteCalculator, request, handler, context); } /** *

Creates a tracker resource in your Amazon Web Services account, which lets * you retrieve current and historical location of devices.

See * Also:

AWS * API Reference

*/ virtual Model::CreateTrackerOutcome CreateTracker(const Model::CreateTrackerRequest& request) const; /** * A Callable wrapper for CreateTracker that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateTrackerOutcomeCallable CreateTrackerCallable(const CreateTrackerRequestT& request) const { return SubmitCallable(&LocationServiceClient::CreateTracker, request); } /** * An Async wrapper for CreateTracker that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateTrackerAsync(const CreateTrackerRequestT& request, const CreateTrackerResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LocationServiceClient::CreateTracker, request, handler, context); } /** *

Deletes a geofence collection from your Amazon Web Services account.

*

This operation deletes the resource permanently. If the geofence * collection is the target of a tracker resource, the devices will no longer be * monitored.

See Also:

AWS * API Reference

*/ virtual Model::DeleteGeofenceCollectionOutcome DeleteGeofenceCollection(const Model::DeleteGeofenceCollectionRequest& request) const; /** * A Callable wrapper for DeleteGeofenceCollection that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteGeofenceCollectionOutcomeCallable DeleteGeofenceCollectionCallable(const DeleteGeofenceCollectionRequestT& request) const { return SubmitCallable(&LocationServiceClient::DeleteGeofenceCollection, request); } /** * An Async wrapper for DeleteGeofenceCollection that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteGeofenceCollectionAsync(const DeleteGeofenceCollectionRequestT& request, const DeleteGeofenceCollectionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LocationServiceClient::DeleteGeofenceCollection, request, handler, context); } /** *

Deletes the specified API key. The API key must have been deactivated more * than 90 days previously.

See Also:

AWS * API Reference

*/ virtual Model::DeleteKeyOutcome DeleteKey(const Model::DeleteKeyRequest& request) const; /** * A Callable wrapper for DeleteKey that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteKeyOutcomeCallable DeleteKeyCallable(const DeleteKeyRequestT& request) const { return SubmitCallable(&LocationServiceClient::DeleteKey, request); } /** * An Async wrapper for DeleteKey that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteKeyAsync(const DeleteKeyRequestT& request, const DeleteKeyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LocationServiceClient::DeleteKey, request, handler, context); } /** *

Deletes a map resource from your Amazon Web Services account.

*

This operation deletes the resource permanently. If the map is being used in * an application, the map may not render.

See Also:

AWS * API Reference

*/ virtual Model::DeleteMapOutcome DeleteMap(const Model::DeleteMapRequest& request) const; /** * A Callable wrapper for DeleteMap that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteMapOutcomeCallable DeleteMapCallable(const DeleteMapRequestT& request) const { return SubmitCallable(&LocationServiceClient::DeleteMap, request); } /** * An Async wrapper for DeleteMap that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteMapAsync(const DeleteMapRequestT& request, const DeleteMapResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LocationServiceClient::DeleteMap, request, handler, context); } /** *

Deletes a place index resource from your Amazon Web Services account.

*

This operation deletes the resource permanently.

See * Also:

AWS * API Reference

*/ virtual Model::DeletePlaceIndexOutcome DeletePlaceIndex(const Model::DeletePlaceIndexRequest& request) const; /** * A Callable wrapper for DeletePlaceIndex that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeletePlaceIndexOutcomeCallable DeletePlaceIndexCallable(const DeletePlaceIndexRequestT& request) const { return SubmitCallable(&LocationServiceClient::DeletePlaceIndex, request); } /** * An Async wrapper for DeletePlaceIndex that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeletePlaceIndexAsync(const DeletePlaceIndexRequestT& request, const DeletePlaceIndexResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LocationServiceClient::DeletePlaceIndex, request, handler, context); } /** *

Deletes a route calculator resource from your Amazon Web Services * account.

This operation deletes the resource permanently.

*

See Also:

AWS * API Reference

*/ virtual Model::DeleteRouteCalculatorOutcome DeleteRouteCalculator(const Model::DeleteRouteCalculatorRequest& request) const; /** * A Callable wrapper for DeleteRouteCalculator that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteRouteCalculatorOutcomeCallable DeleteRouteCalculatorCallable(const DeleteRouteCalculatorRequestT& request) const { return SubmitCallable(&LocationServiceClient::DeleteRouteCalculator, request); } /** * An Async wrapper for DeleteRouteCalculator that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteRouteCalculatorAsync(const DeleteRouteCalculatorRequestT& request, const DeleteRouteCalculatorResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LocationServiceClient::DeleteRouteCalculator, request, handler, context); } /** *

Deletes a tracker resource from your Amazon Web Services account.

*

This operation deletes the resource permanently. If the tracker resource is * in use, you may encounter an error. Make sure that the target resource isn't a * dependency for your applications.

See Also:

AWS * API Reference

*/ virtual Model::DeleteTrackerOutcome DeleteTracker(const Model::DeleteTrackerRequest& request) const; /** * A Callable wrapper for DeleteTracker that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteTrackerOutcomeCallable DeleteTrackerCallable(const DeleteTrackerRequestT& request) const { return SubmitCallable(&LocationServiceClient::DeleteTracker, request); } /** * An Async wrapper for DeleteTracker that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteTrackerAsync(const DeleteTrackerRequestT& request, const DeleteTrackerResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LocationServiceClient::DeleteTracker, request, handler, context); } /** *

Retrieves the geofence collection details.

See Also:

AWS * API Reference

*/ virtual Model::DescribeGeofenceCollectionOutcome DescribeGeofenceCollection(const Model::DescribeGeofenceCollectionRequest& request) const; /** * A Callable wrapper for DescribeGeofenceCollection that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeGeofenceCollectionOutcomeCallable DescribeGeofenceCollectionCallable(const DescribeGeofenceCollectionRequestT& request) const { return SubmitCallable(&LocationServiceClient::DescribeGeofenceCollection, request); } /** * An Async wrapper for DescribeGeofenceCollection that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeGeofenceCollectionAsync(const DescribeGeofenceCollectionRequestT& request, const DescribeGeofenceCollectionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LocationServiceClient::DescribeGeofenceCollection, request, handler, context); } /** *

Retrieves the API key resource details.

See Also:

AWS * API Reference

*/ virtual Model::DescribeKeyOutcome DescribeKey(const Model::DescribeKeyRequest& request) const; /** * A Callable wrapper for DescribeKey that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeKeyOutcomeCallable DescribeKeyCallable(const DescribeKeyRequestT& request) const { return SubmitCallable(&LocationServiceClient::DescribeKey, request); } /** * An Async wrapper for DescribeKey that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeKeyAsync(const DescribeKeyRequestT& request, const DescribeKeyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LocationServiceClient::DescribeKey, request, handler, context); } /** *

Retrieves the map resource details.

See Also:

AWS * API Reference

*/ virtual Model::DescribeMapOutcome DescribeMap(const Model::DescribeMapRequest& request) const; /** * A Callable wrapper for DescribeMap that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeMapOutcomeCallable DescribeMapCallable(const DescribeMapRequestT& request) const { return SubmitCallable(&LocationServiceClient::DescribeMap, request); } /** * An Async wrapper for DescribeMap that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeMapAsync(const DescribeMapRequestT& request, const DescribeMapResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LocationServiceClient::DescribeMap, request, handler, context); } /** *

Retrieves the place index resource details.

See Also:

AWS * API Reference

*/ virtual Model::DescribePlaceIndexOutcome DescribePlaceIndex(const Model::DescribePlaceIndexRequest& request) const; /** * A Callable wrapper for DescribePlaceIndex that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribePlaceIndexOutcomeCallable DescribePlaceIndexCallable(const DescribePlaceIndexRequestT& request) const { return SubmitCallable(&LocationServiceClient::DescribePlaceIndex, request); } /** * An Async wrapper for DescribePlaceIndex that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribePlaceIndexAsync(const DescribePlaceIndexRequestT& request, const DescribePlaceIndexResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LocationServiceClient::DescribePlaceIndex, request, handler, context); } /** *

Retrieves the route calculator resource details.

See Also:

* AWS * API Reference

*/ virtual Model::DescribeRouteCalculatorOutcome DescribeRouteCalculator(const Model::DescribeRouteCalculatorRequest& request) const; /** * A Callable wrapper for DescribeRouteCalculator that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeRouteCalculatorOutcomeCallable DescribeRouteCalculatorCallable(const DescribeRouteCalculatorRequestT& request) const { return SubmitCallable(&LocationServiceClient::DescribeRouteCalculator, request); } /** * An Async wrapper for DescribeRouteCalculator that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeRouteCalculatorAsync(const DescribeRouteCalculatorRequestT& request, const DescribeRouteCalculatorResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LocationServiceClient::DescribeRouteCalculator, request, handler, context); } /** *

Retrieves the tracker resource details.

See Also:

AWS * API Reference

*/ virtual Model::DescribeTrackerOutcome DescribeTracker(const Model::DescribeTrackerRequest& request) const; /** * A Callable wrapper for DescribeTracker that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeTrackerOutcomeCallable DescribeTrackerCallable(const DescribeTrackerRequestT& request) const { return SubmitCallable(&LocationServiceClient::DescribeTracker, request); } /** * An Async wrapper for DescribeTracker that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeTrackerAsync(const DescribeTrackerRequestT& request, const DescribeTrackerResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LocationServiceClient::DescribeTracker, request, handler, context); } /** *

Removes the association between a tracker resource and a geofence * collection.

Once you unlink a tracker resource from a geofence * collection, the tracker positions will no longer be automatically evaluated * against geofences.

See Also:

AWS * API Reference

*/ virtual Model::DisassociateTrackerConsumerOutcome DisassociateTrackerConsumer(const Model::DisassociateTrackerConsumerRequest& request) const; /** * A Callable wrapper for DisassociateTrackerConsumer that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DisassociateTrackerConsumerOutcomeCallable DisassociateTrackerConsumerCallable(const DisassociateTrackerConsumerRequestT& request) const { return SubmitCallable(&LocationServiceClient::DisassociateTrackerConsumer, request); } /** * An Async wrapper for DisassociateTrackerConsumer that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DisassociateTrackerConsumerAsync(const DisassociateTrackerConsumerRequestT& request, const DisassociateTrackerConsumerResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LocationServiceClient::DisassociateTrackerConsumer, request, handler, context); } /** *

Retrieves a device's most recent position according to its sample time.

*

Device positions are deleted after 30 days.

See * Also:

AWS * API Reference

*/ virtual Model::GetDevicePositionOutcome GetDevicePosition(const Model::GetDevicePositionRequest& request) const; /** * A Callable wrapper for GetDevicePosition that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetDevicePositionOutcomeCallable GetDevicePositionCallable(const GetDevicePositionRequestT& request) const { return SubmitCallable(&LocationServiceClient::GetDevicePosition, request); } /** * An Async wrapper for GetDevicePosition that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetDevicePositionAsync(const GetDevicePositionRequestT& request, const GetDevicePositionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LocationServiceClient::GetDevicePosition, request, handler, context); } /** *

Retrieves the device position history from a tracker resource within a * specified range of time.

Device positions are deleted after 30 * days.

See Also:

AWS * API Reference

*/ virtual Model::GetDevicePositionHistoryOutcome GetDevicePositionHistory(const Model::GetDevicePositionHistoryRequest& request) const; /** * A Callable wrapper for GetDevicePositionHistory that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetDevicePositionHistoryOutcomeCallable GetDevicePositionHistoryCallable(const GetDevicePositionHistoryRequestT& request) const { return SubmitCallable(&LocationServiceClient::GetDevicePositionHistory, request); } /** * An Async wrapper for GetDevicePositionHistory that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetDevicePositionHistoryAsync(const GetDevicePositionHistoryRequestT& request, const GetDevicePositionHistoryResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LocationServiceClient::GetDevicePositionHistory, request, handler, context); } /** *

Retrieves the geofence details from a geofence collection.

See * Also:

AWS * API Reference

*/ virtual Model::GetGeofenceOutcome GetGeofence(const Model::GetGeofenceRequest& request) const; /** * A Callable wrapper for GetGeofence that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetGeofenceOutcomeCallable GetGeofenceCallable(const GetGeofenceRequestT& request) const { return SubmitCallable(&LocationServiceClient::GetGeofence, request); } /** * An Async wrapper for GetGeofence that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetGeofenceAsync(const GetGeofenceRequestT& request, const GetGeofenceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LocationServiceClient::GetGeofence, request, handler, context); } /** *

Retrieves glyphs used to display labels on a map.

See Also:

* AWS * API Reference

*/ virtual Model::GetMapGlyphsOutcome GetMapGlyphs(const Model::GetMapGlyphsRequest& request) const; /** * A Callable wrapper for GetMapGlyphs that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetMapGlyphsOutcomeCallable GetMapGlyphsCallable(const GetMapGlyphsRequestT& request) const { return SubmitCallable(&LocationServiceClient::GetMapGlyphs, request); } /** * An Async wrapper for GetMapGlyphs that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetMapGlyphsAsync(const GetMapGlyphsRequestT& request, const GetMapGlyphsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LocationServiceClient::GetMapGlyphs, request, handler, context); } /** *

Retrieves the sprite sheet corresponding to a map resource. The sprite sheet * is a PNG image paired with a JSON document describing the offsets of individual * icons that will be displayed on a rendered map.

See Also:

AWS * API Reference

*/ virtual Model::GetMapSpritesOutcome GetMapSprites(const Model::GetMapSpritesRequest& request) const; /** * A Callable wrapper for GetMapSprites that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetMapSpritesOutcomeCallable GetMapSpritesCallable(const GetMapSpritesRequestT& request) const { return SubmitCallable(&LocationServiceClient::GetMapSprites, request); } /** * An Async wrapper for GetMapSprites that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetMapSpritesAsync(const GetMapSpritesRequestT& request, const GetMapSpritesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LocationServiceClient::GetMapSprites, request, handler, context); } /** *

Retrieves the map style descriptor from a map resource.

The style * descriptor contains specifications on how features render on a map. For example, * what data to display, what order to display the data in, and the style for the * data. Style descriptors follow the Mapbox Style Specification.

See * Also:

AWS * API Reference

*/ virtual Model::GetMapStyleDescriptorOutcome GetMapStyleDescriptor(const Model::GetMapStyleDescriptorRequest& request) const; /** * A Callable wrapper for GetMapStyleDescriptor that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetMapStyleDescriptorOutcomeCallable GetMapStyleDescriptorCallable(const GetMapStyleDescriptorRequestT& request) const { return SubmitCallable(&LocationServiceClient::GetMapStyleDescriptor, request); } /** * An Async wrapper for GetMapStyleDescriptor that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetMapStyleDescriptorAsync(const GetMapStyleDescriptorRequestT& request, const GetMapStyleDescriptorResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LocationServiceClient::GetMapStyleDescriptor, request, handler, context); } /** *

Retrieves a vector data tile from the map resource. Map tiles are used by * clients to render a map. they're addressed using a grid arrangement with an X * coordinate, Y coordinate, and Z (zoom) level.

The origin (0, 0) is the * top left of the map. Increasing the zoom level by 1 doubles both the X and Y * dimensions, so a tile containing data for the entire world at (0/0/0) will be * split into 4 tiles at zoom 1 (1/0/0, 1/0/1, 1/1/0, 1/1/1).

See * Also:

AWS * API Reference

*/ virtual Model::GetMapTileOutcome GetMapTile(const Model::GetMapTileRequest& request) const; /** * A Callable wrapper for GetMapTile that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetMapTileOutcomeCallable GetMapTileCallable(const GetMapTileRequestT& request) const { return SubmitCallable(&LocationServiceClient::GetMapTile, request); } /** * An Async wrapper for GetMapTile that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetMapTileAsync(const GetMapTileRequestT& request, const GetMapTileResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LocationServiceClient::GetMapTile, request, handler, context); } /** *

Finds a place by its unique ID. A PlaceId is returned by other * search operations.

A PlaceId is valid only if all of the following * are the same in the original search request and the call to * GetPlace.

  • Customer Amazon Web Services account

    *

  • Amazon Web Services Region

  • Data provider * specified in the place index resource

See * Also:

AWS * API Reference

*/ virtual Model::GetPlaceOutcome GetPlace(const Model::GetPlaceRequest& request) const; /** * A Callable wrapper for GetPlace that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetPlaceOutcomeCallable GetPlaceCallable(const GetPlaceRequestT& request) const { return SubmitCallable(&LocationServiceClient::GetPlace, request); } /** * An Async wrapper for GetPlace that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetPlaceAsync(const GetPlaceRequestT& request, const GetPlaceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LocationServiceClient::GetPlace, request, handler, context); } /** *

A batch request to retrieve all device positions.

See Also:

* AWS * API Reference

*/ virtual Model::ListDevicePositionsOutcome ListDevicePositions(const Model::ListDevicePositionsRequest& request) const; /** * A Callable wrapper for ListDevicePositions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListDevicePositionsOutcomeCallable ListDevicePositionsCallable(const ListDevicePositionsRequestT& request) const { return SubmitCallable(&LocationServiceClient::ListDevicePositions, request); } /** * An Async wrapper for ListDevicePositions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListDevicePositionsAsync(const ListDevicePositionsRequestT& request, const ListDevicePositionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LocationServiceClient::ListDevicePositions, request, handler, context); } /** *

Lists geofence collections in your Amazon Web Services account.

See * Also:

AWS * API Reference

*/ virtual Model::ListGeofenceCollectionsOutcome ListGeofenceCollections(const Model::ListGeofenceCollectionsRequest& request) const; /** * A Callable wrapper for ListGeofenceCollections that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListGeofenceCollectionsOutcomeCallable ListGeofenceCollectionsCallable(const ListGeofenceCollectionsRequestT& request) const { return SubmitCallable(&LocationServiceClient::ListGeofenceCollections, request); } /** * An Async wrapper for ListGeofenceCollections that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListGeofenceCollectionsAsync(const ListGeofenceCollectionsRequestT& request, const ListGeofenceCollectionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LocationServiceClient::ListGeofenceCollections, request, handler, context); } /** *

Lists geofences stored in a given geofence collection.

See * Also:

AWS * API Reference

*/ virtual Model::ListGeofencesOutcome ListGeofences(const Model::ListGeofencesRequest& request) const; /** * A Callable wrapper for ListGeofences that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListGeofencesOutcomeCallable ListGeofencesCallable(const ListGeofencesRequestT& request) const { return SubmitCallable(&LocationServiceClient::ListGeofences, request); } /** * An Async wrapper for ListGeofences that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListGeofencesAsync(const ListGeofencesRequestT& request, const ListGeofencesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LocationServiceClient::ListGeofences, request, handler, context); } /** *

Lists API key resources in your Amazon Web Services account.

See * Also:

AWS * API Reference

*/ virtual Model::ListKeysOutcome ListKeys(const Model::ListKeysRequest& request) const; /** * A Callable wrapper for ListKeys that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListKeysOutcomeCallable ListKeysCallable(const ListKeysRequestT& request) const { return SubmitCallable(&LocationServiceClient::ListKeys, request); } /** * An Async wrapper for ListKeys that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListKeysAsync(const ListKeysRequestT& request, const ListKeysResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LocationServiceClient::ListKeys, request, handler, context); } /** *

Lists map resources in your Amazon Web Services account.

See * Also:

AWS * API Reference

*/ virtual Model::ListMapsOutcome ListMaps(const Model::ListMapsRequest& request) const; /** * A Callable wrapper for ListMaps that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListMapsOutcomeCallable ListMapsCallable(const ListMapsRequestT& request) const { return SubmitCallable(&LocationServiceClient::ListMaps, request); } /** * An Async wrapper for ListMaps that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListMapsAsync(const ListMapsRequestT& request, const ListMapsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LocationServiceClient::ListMaps, request, handler, context); } /** *

Lists place index resources in your Amazon Web Services * account.

See Also:

AWS * API Reference

*/ virtual Model::ListPlaceIndexesOutcome ListPlaceIndexes(const Model::ListPlaceIndexesRequest& request) const; /** * A Callable wrapper for ListPlaceIndexes that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListPlaceIndexesOutcomeCallable ListPlaceIndexesCallable(const ListPlaceIndexesRequestT& request) const { return SubmitCallable(&LocationServiceClient::ListPlaceIndexes, request); } /** * An Async wrapper for ListPlaceIndexes that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListPlaceIndexesAsync(const ListPlaceIndexesRequestT& request, const ListPlaceIndexesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LocationServiceClient::ListPlaceIndexes, request, handler, context); } /** *

Lists route calculator resources in your Amazon Web Services * account.

See Also:

AWS * API Reference

*/ virtual Model::ListRouteCalculatorsOutcome ListRouteCalculators(const Model::ListRouteCalculatorsRequest& request) const; /** * A Callable wrapper for ListRouteCalculators that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListRouteCalculatorsOutcomeCallable ListRouteCalculatorsCallable(const ListRouteCalculatorsRequestT& request) const { return SubmitCallable(&LocationServiceClient::ListRouteCalculators, request); } /** * An Async wrapper for ListRouteCalculators that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListRouteCalculatorsAsync(const ListRouteCalculatorsRequestT& request, const ListRouteCalculatorsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LocationServiceClient::ListRouteCalculators, request, handler, context); } /** *

Returns a list of tags that are applied to the specified Amazon Location * resource.

See Also:

AWS * API Reference

*/ virtual Model::ListTagsForResourceOutcome ListTagsForResource(const Model::ListTagsForResourceRequest& request) const; /** * A Callable wrapper for ListTagsForResource that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListTagsForResourceOutcomeCallable ListTagsForResourceCallable(const ListTagsForResourceRequestT& request) const { return SubmitCallable(&LocationServiceClient::ListTagsForResource, request); } /** * An Async wrapper for ListTagsForResource that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListTagsForResourceAsync(const ListTagsForResourceRequestT& request, const ListTagsForResourceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LocationServiceClient::ListTagsForResource, request, handler, context); } /** *

Lists geofence collections currently associated to the given tracker * resource.

See Also:

AWS * API Reference

*/ virtual Model::ListTrackerConsumersOutcome ListTrackerConsumers(const Model::ListTrackerConsumersRequest& request) const; /** * A Callable wrapper for ListTrackerConsumers that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListTrackerConsumersOutcomeCallable ListTrackerConsumersCallable(const ListTrackerConsumersRequestT& request) const { return SubmitCallable(&LocationServiceClient::ListTrackerConsumers, request); } /** * An Async wrapper for ListTrackerConsumers that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListTrackerConsumersAsync(const ListTrackerConsumersRequestT& request, const ListTrackerConsumersResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LocationServiceClient::ListTrackerConsumers, request, handler, context); } /** *

Lists tracker resources in your Amazon Web Services account.

See * Also:

AWS * API Reference

*/ virtual Model::ListTrackersOutcome ListTrackers(const Model::ListTrackersRequest& request) const; /** * A Callable wrapper for ListTrackers that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListTrackersOutcomeCallable ListTrackersCallable(const ListTrackersRequestT& request) const { return SubmitCallable(&LocationServiceClient::ListTrackers, request); } /** * An Async wrapper for ListTrackers that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListTrackersAsync(const ListTrackersRequestT& request, const ListTrackersResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LocationServiceClient::ListTrackers, request, handler, context); } /** *

Stores a geofence geometry in a given geofence collection, or updates the * geometry of an existing geofence if a geofence ID is included in the request. *

See Also:

AWS * API Reference

*/ virtual Model::PutGeofenceOutcome PutGeofence(const Model::PutGeofenceRequest& request) const; /** * A Callable wrapper for PutGeofence that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutGeofenceOutcomeCallable PutGeofenceCallable(const PutGeofenceRequestT& request) const { return SubmitCallable(&LocationServiceClient::PutGeofence, request); } /** * An Async wrapper for PutGeofence that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutGeofenceAsync(const PutGeofenceRequestT& request, const PutGeofenceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LocationServiceClient::PutGeofence, request, handler, context); } /** *

Reverse geocodes a given coordinate and returns a legible address. Allows you * to search for Places or points of interest near a given position.

See * Also:

AWS * API Reference

*/ virtual Model::SearchPlaceIndexForPositionOutcome SearchPlaceIndexForPosition(const Model::SearchPlaceIndexForPositionRequest& request) const; /** * A Callable wrapper for SearchPlaceIndexForPosition that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::SearchPlaceIndexForPositionOutcomeCallable SearchPlaceIndexForPositionCallable(const SearchPlaceIndexForPositionRequestT& request) const { return SubmitCallable(&LocationServiceClient::SearchPlaceIndexForPosition, request); } /** * An Async wrapper for SearchPlaceIndexForPosition that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void SearchPlaceIndexForPositionAsync(const SearchPlaceIndexForPositionRequestT& request, const SearchPlaceIndexForPositionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LocationServiceClient::SearchPlaceIndexForPosition, request, handler, context); } /** *

Generates suggestions for addresses and points of interest based on partial * or misspelled free-form text. This operation is also known as autocomplete, * autosuggest, or fuzzy matching.

Optional parameters let you narrow your * search results by bounding box or country, or bias your search toward a specific * position on the globe.

You can search for suggested place names * near a specified position by using BiasPosition, or filter results * within a bounding box by using FilterBBox. These parameters are * mutually exclusive; using both BiasPosition and * FilterBBox in the same command returns an error.

*

See Also:

AWS * API Reference

*/ virtual Model::SearchPlaceIndexForSuggestionsOutcome SearchPlaceIndexForSuggestions(const Model::SearchPlaceIndexForSuggestionsRequest& request) const; /** * A Callable wrapper for SearchPlaceIndexForSuggestions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::SearchPlaceIndexForSuggestionsOutcomeCallable SearchPlaceIndexForSuggestionsCallable(const SearchPlaceIndexForSuggestionsRequestT& request) const { return SubmitCallable(&LocationServiceClient::SearchPlaceIndexForSuggestions, request); } /** * An Async wrapper for SearchPlaceIndexForSuggestions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void SearchPlaceIndexForSuggestionsAsync(const SearchPlaceIndexForSuggestionsRequestT& request, const SearchPlaceIndexForSuggestionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LocationServiceClient::SearchPlaceIndexForSuggestions, request, handler, context); } /** *

Geocodes free-form text, such as an address, name, city, or region to allow * you to search for Places or points of interest.

Optional parameters let * you narrow your search results by bounding box or country, or bias your search * toward a specific position on the globe.

You can search for places * near a given position using BiasPosition, or filter results within * a bounding box using FilterBBox. Providing both parameters * simultaneously returns an error.

Search results are returned in * order of highest to lowest relevance.

See Also:

AWS * API Reference

*/ virtual Model::SearchPlaceIndexForTextOutcome SearchPlaceIndexForText(const Model::SearchPlaceIndexForTextRequest& request) const; /** * A Callable wrapper for SearchPlaceIndexForText that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::SearchPlaceIndexForTextOutcomeCallable SearchPlaceIndexForTextCallable(const SearchPlaceIndexForTextRequestT& request) const { return SubmitCallable(&LocationServiceClient::SearchPlaceIndexForText, request); } /** * An Async wrapper for SearchPlaceIndexForText that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void SearchPlaceIndexForTextAsync(const SearchPlaceIndexForTextRequestT& request, const SearchPlaceIndexForTextResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LocationServiceClient::SearchPlaceIndexForText, request, handler, context); } /** *

Assigns one or more tags (key-value pairs) to the specified Amazon Location * Service resource.

Tags can help you organize and categorize your * resources. You can also use them to scope user permissions, by granting a user * permission to access or change only resources with certain tag values.

*

You can use the TagResource operation with an Amazon Location * Service resource that already has tags. If you specify a new tag key for the * resource, this tag is appended to the tags already associated with the resource. * If you specify a tag key that's already associated with the resource, the new * tag value that you specify replaces the previous value for that tag.

You * can associate up to 50 tags with a resource.

See Also:

AWS * API Reference

*/ virtual Model::TagResourceOutcome TagResource(const Model::TagResourceRequest& request) const; /** * A Callable wrapper for TagResource that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::TagResourceOutcomeCallable TagResourceCallable(const TagResourceRequestT& request) const { return SubmitCallable(&LocationServiceClient::TagResource, request); } /** * An Async wrapper for TagResource that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void TagResourceAsync(const TagResourceRequestT& request, const TagResourceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LocationServiceClient::TagResource, request, handler, context); } /** *

Removes one or more tags from the specified Amazon Location * resource.

See Also:

AWS * API Reference

*/ virtual Model::UntagResourceOutcome UntagResource(const Model::UntagResourceRequest& request) const; /** * A Callable wrapper for UntagResource that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UntagResourceOutcomeCallable UntagResourceCallable(const UntagResourceRequestT& request) const { return SubmitCallable(&LocationServiceClient::UntagResource, request); } /** * An Async wrapper for UntagResource that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UntagResourceAsync(const UntagResourceRequestT& request, const UntagResourceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LocationServiceClient::UntagResource, request, handler, context); } /** *

Updates the specified properties of a given geofence * collection.

See Also:

AWS * API Reference

*/ virtual Model::UpdateGeofenceCollectionOutcome UpdateGeofenceCollection(const Model::UpdateGeofenceCollectionRequest& request) const; /** * A Callable wrapper for UpdateGeofenceCollection that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateGeofenceCollectionOutcomeCallable UpdateGeofenceCollectionCallable(const UpdateGeofenceCollectionRequestT& request) const { return SubmitCallable(&LocationServiceClient::UpdateGeofenceCollection, request); } /** * An Async wrapper for UpdateGeofenceCollection that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateGeofenceCollectionAsync(const UpdateGeofenceCollectionRequestT& request, const UpdateGeofenceCollectionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LocationServiceClient::UpdateGeofenceCollection, request, handler, context); } /** *

Updates the specified properties of a given API key resource.

See * Also:

AWS * API Reference

*/ virtual Model::UpdateKeyOutcome UpdateKey(const Model::UpdateKeyRequest& request) const; /** * A Callable wrapper for UpdateKey that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateKeyOutcomeCallable UpdateKeyCallable(const UpdateKeyRequestT& request) const { return SubmitCallable(&LocationServiceClient::UpdateKey, request); } /** * An Async wrapper for UpdateKey that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateKeyAsync(const UpdateKeyRequestT& request, const UpdateKeyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LocationServiceClient::UpdateKey, request, handler, context); } /** *

Updates the specified properties of a given map resource.

See * Also:

AWS * API Reference

*/ virtual Model::UpdateMapOutcome UpdateMap(const Model::UpdateMapRequest& request) const; /** * A Callable wrapper for UpdateMap that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateMapOutcomeCallable UpdateMapCallable(const UpdateMapRequestT& request) const { return SubmitCallable(&LocationServiceClient::UpdateMap, request); } /** * An Async wrapper for UpdateMap that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateMapAsync(const UpdateMapRequestT& request, const UpdateMapResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LocationServiceClient::UpdateMap, request, handler, context); } /** *

Updates the specified properties of a given place index * resource.

See Also:

AWS * API Reference

*/ virtual Model::UpdatePlaceIndexOutcome UpdatePlaceIndex(const Model::UpdatePlaceIndexRequest& request) const; /** * A Callable wrapper for UpdatePlaceIndex that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdatePlaceIndexOutcomeCallable UpdatePlaceIndexCallable(const UpdatePlaceIndexRequestT& request) const { return SubmitCallable(&LocationServiceClient::UpdatePlaceIndex, request); } /** * An Async wrapper for UpdatePlaceIndex that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdatePlaceIndexAsync(const UpdatePlaceIndexRequestT& request, const UpdatePlaceIndexResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LocationServiceClient::UpdatePlaceIndex, request, handler, context); } /** *

Updates the specified properties for a given route calculator * resource.

See Also:

AWS * API Reference

*/ virtual Model::UpdateRouteCalculatorOutcome UpdateRouteCalculator(const Model::UpdateRouteCalculatorRequest& request) const; /** * A Callable wrapper for UpdateRouteCalculator that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateRouteCalculatorOutcomeCallable UpdateRouteCalculatorCallable(const UpdateRouteCalculatorRequestT& request) const { return SubmitCallable(&LocationServiceClient::UpdateRouteCalculator, request); } /** * An Async wrapper for UpdateRouteCalculator that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateRouteCalculatorAsync(const UpdateRouteCalculatorRequestT& request, const UpdateRouteCalculatorResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LocationServiceClient::UpdateRouteCalculator, request, handler, context); } /** *

Updates the specified properties of a given tracker resource.

See * Also:

AWS * API Reference

*/ virtual Model::UpdateTrackerOutcome UpdateTracker(const Model::UpdateTrackerRequest& request) const; /** * A Callable wrapper for UpdateTracker that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateTrackerOutcomeCallable UpdateTrackerCallable(const UpdateTrackerRequestT& request) const { return SubmitCallable(&LocationServiceClient::UpdateTracker, request); } /** * An Async wrapper for UpdateTracker that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateTrackerAsync(const UpdateTrackerRequestT& request, const UpdateTrackerResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LocationServiceClient::UpdateTracker, request, handler, context); } void OverrideEndpoint(const Aws::String& endpoint); std::shared_ptr& accessEndpointProvider(); private: friend class Aws::Client::ClientWithAsyncTemplateMethods; void init(const LocationServiceClientConfiguration& clientConfiguration); LocationServiceClientConfiguration m_clientConfiguration; std::shared_ptr m_executor; std::shared_ptr m_endpointProvider; }; } // namespace LocationService } // namespace Aws