Module types 

Data structures used by operation inputs/outputs.

Modules

builders

Builders

error

Error types that Amazon Location Service Places V2 can respond with.

Structs

AccessPoint

Position of the access point represented by longitude and latitude for a vehicle.

AccessRestriction

Indicates if the access location is restricted. Index correlates to that of an access point and indicates if access through this point has some form of restriction.

Address

The place address.

AddressComponentMatchScores

Indicates how well the entire input matches the returned. It is equal to 1 if all input tokens are recognized and matched.

AddressComponentPhonemes

How to pronounce the various components of the address or place.

AutocompleteAddressHighlights

Describes how the parts of the response element matched the input query by returning the sections of the response which matched to input query terms.

AutocompleteFilter

Autocomplete structure which contains a set of inclusion/exclusion properties that results must possess in order to be returned as a result.

AutocompleteHighlights

Describes how the parts of the response element matched the input query by returning the sections of the response which matched to input query terms.

AutocompleteResultItem

A result matching the input query text.

BusinessChain

A businesschain is a chain of businesses that belong to the same brand. For example 7-11.

Category

Category of the Place returned.

ComponentMatchScores

Indicates how well the returned title and address components matches the input TextQuery. For each component a score is provied with 1 indicating all tokens were matched and 0 indicating no tokens were matched.

ContactDetails

Details related to contacts.

Contacts

A list of potential contact methods for the result/place.

Country

The alpha-2 or alpha-3 character code for the country that the results will be present in.

CountryHighlights

Indicates the starting and ending index of the country in the text query that match the found title.

FilterCircle

The Circle that all results must be in.

FoodType

List of Food types offered by this result.

GeocodeFilter

Geocode structure which contains a set of inclusion/exclusion properties that results must possess in order to be returned as a result.

GeocodeParsedQuery

Parsed components in the provided QueryText.

GeocodeParsedQueryAddressComponents

Parsed address components in the provided QueryText.

GeocodeQueryComponents

A structured free text query allows you to search for places by the name or text representation of specific properties of the place.

GeocodeResultItem

The Geocoded result.

Highlight

Indicates the starting and ending index of the text query that match the found title.

Intersection

All Intersections that are near the provided address.

MatchScoreDetails

Details related to the match score.

OpeningHours

List of opening hours objects.

OpeningHoursComponents

Components of the opening hours object.

ParsedQueryComponent

Parsed components in the provided QueryText.

ParsedQuerySecondaryAddressComponent

Information about a secondary address component parsed from the query text.

PhonemeDetails

The phoneme details.

PhonemeTranscription

How to pronounce the various components of the address or place.

PostalCodeDetails

Contains details about the postal code of the place or result.

QueryRefinement

Suggestions for refining individual query terms. Suggestions are returned as objects which note the term, suggested replacement, and its index in the query.

Region

The region or state results should be to be present in.

Example: North Rhine-Westphalia.

RegionHighlights

Indicates the starting and ending index of the region in the text query that match the found title.

RelatedPlace

Place that is related to the result item.

ReverseGeocodeFilter

The included place types.

ReverseGeocodeResultItem

The returned location from the Reverse Geocode action.

SearchNearbyFilter

SearchNearby structure which contains a set of inclusion/exclusion properties that results must possess in order to be returned as a result.

SearchNearbyResultItem

The search results of nearby places.

SearchTextFilter

SearchText structure which contains a set of inclusion/exclusion properties that results must possess in order to be returned as a result.

SearchTextResultItem

The text search result.

SecondaryAddressComponent

Components that correspond to secondary identifiers on an address. The only component type supported currently is Unit.

SecondaryAddressComponentMatchScore

Match score for a secondary address component in the result.

StreetComponents

Components of a street.

SubRegion

The sub-region.

SubRegionHighlights

Indicates the starting and ending index of the sub-region in the text query that match the found title.

SuggestAddressHighlights

Describes how the parts of the textQuery matched the input query by returning the sections of the response which matched to textQuery terms.

SuggestFilter

SuggestFilter structure which contains a set of inclusion/exclusion properties that results must possess in order to be returned as a result.

SuggestHighlights

Describes how the parts of the textQuery matched the input query by returning the sections of the response which matched to textQuery terms.

SuggestPlaceResult

The suggested place results.

SuggestQueryResult

The suggested query results.

SuggestResultItem

The resulting item from the suggested query.

TimeZone

The time zone in which the place is located.

UspsZip

The USPS zip code.

UspsZipPlus4

The USPS zip+4 code.

ValidationExceptionField

The input fails to satisfy the constraints specified by the Amazon Location service.

Enums

AutocompleteAdditionalFeature

When writing a match expression against AutocompleteAdditionalFeature, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

AutocompleteFilterPlaceType

When writing a match expression against AutocompleteFilterPlaceType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

AutocompleteIntendedUse

When writing a match expression against AutocompleteIntendedUse, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

GeocodeAdditionalFeature

When writing a match expression against GeocodeAdditionalFeature, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

GeocodeFilterPlaceType

When writing a match expression against GeocodeFilterPlaceType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

GeocodeIntendedUse

When writing a match expression against GeocodeIntendedUse, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

GetPlaceAdditionalFeature

When writing a match expression against GetPlaceAdditionalFeature, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

GetPlaceIntendedUse

When writing a match expression against GetPlaceIntendedUse, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

PlaceType

When writing a match expression against PlaceType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

PostalAuthority

When writing a match expression against PostalAuthority, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

PostalCodeMode

When writing a match expression against PostalCodeMode, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

PostalCodeType

When writing a match expression against PostalCodeType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

QueryType

When writing a match expression against QueryType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

RecordTypeCode

When writing a match expression against RecordTypeCode, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

ReverseGeocodeAdditionalFeature

When writing a match expression against ReverseGeocodeAdditionalFeature, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

ReverseGeocodeFilterPlaceType

When writing a match expression against ReverseGeocodeFilterPlaceType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

ReverseGeocodeIntendedUse

When writing a match expression against ReverseGeocodeIntendedUse, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

SearchNearbyAdditionalFeature

When writing a match expression against SearchNearbyAdditionalFeature, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

SearchNearbyIntendedUse

When writing a match expression against SearchNearbyIntendedUse, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

SearchTextAdditionalFeature

When writing a match expression against SearchTextAdditionalFeature, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

SearchTextIntendedUse

When writing a match expression against SearchTextIntendedUse, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

SuggestAdditionalFeature

When writing a match expression against SuggestAdditionalFeature, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

SuggestIntendedUse

When writing a match expression against SuggestIntendedUse, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

SuggestResultItemType

When writing a match expression against SuggestResultItemType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

TypePlacement

When writing a match expression against TypePlacement, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

ValidationExceptionReason

When writing a match expression against ValidationExceptionReason, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

ZipClassificationCode

When writing a match expression against ZipClassificationCode, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.