types

package
v1.1.1 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Mar 4, 2025 License: Apache-2.0 Imports: 3 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type AccessDeniedException 

type AccessDeniedException struct {
	Message *string

	ErrorCodeOverride *string
	// contains filtered or unexported fields
}

You don't have sufficient access to perform this action.

func (*AccessDeniedException) Error 

func (e *AccessDeniedException) Error() string

func (*AccessDeniedException) ErrorCode 

func (e *AccessDeniedException) ErrorCode() string

func (*AccessDeniedException) ErrorFault 

func (e *AccessDeniedException) ErrorFault() smithy.ErrorFault

func (*AccessDeniedException) ErrorMessage 

func (e *AccessDeniedException) ErrorMessage() string

type AccessPoint 

type AccessPoint struct {

	// The position, in longitude and latitude.
	Position []float64
	// contains filtered or unexported fields
}

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

type AccessRestriction 

type AccessRestriction struct {

	// Categories of results that results must belong too.
	Categories []Category

	// The restriction.
	Restricted *bool
	// contains filtered or unexported fields
}

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.

type Address 

type Address struct {

	// The number that identifies an address within a street.
	AddressNumber *string

	// Name of the block.
	//
	// Example: Sunny Mansion 203 block: 2 Chome
	Block *string

	// The name of the building at the address.
	Building *string

	// The country component of the address.
	Country *Country

	// The district or division of a locality associated with this address.
	District *string

	// Name of the streets in the intersection.
	//
	// Example: ["Friedrichstraße","Unter den Linden"]
	Intersection []string

	// Assembled address value built out of the address components, according to the
	// regional postal rules. This is the correctly formatted address.
	Label *string

	// The locality or city of the address.
	//
	// Example: Vancouver .
	Locality *string

	// An alphanumeric string included in a postal address to facilitate mail sorting,
	// such as post code, postcode, or ZIP code, for which the result should posses.
	PostalCode *string

	// The region or state results should be present in.
	//
	// Example: North Rhine-Westphalia .
	Region *Region

	// The name of the street results should be present in.
	Street *string

	// Components of the street.
	//
	// Example: Younge from the "Younge street".
	StreetComponents []StreetComponents

	// Name of sub-block.
	//
	// Example: Sunny Mansion 203 sub-block: 4
	SubBlock *string

	// A subdivision of a district.
	//
	// Example: Minden-Lübbecke .
	SubDistrict *string

	// The sub-region or county for which results should be present in.
	SubRegion *SubRegion
	// contains filtered or unexported fields
}

The place address.

type AddressComponentMatchScores 

type AddressComponentMatchScores struct {

	// The house number or address results should have.
	AddressNumber float64

	// Name of the block.
	//
	// Example: Sunny Mansion 203 block: 2 Chome
	Block float64

	// The name of the building at the address.
	Building float64

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

	// The district or division of a city the results should be present in.
	District float64

	// Name of the streets in the intersection.
	//
	// Example: ["Friedrichstraße","Unter den Linden"]
	Intersection []float64

	// The city or locality results should be present in.
	//
	// Example: Vancouver .
	Locality float64

	// An alphanumeric string included in a postal address to facilitate mail sorting,
	// such as post code, postcode, or ZIP code, for which the result should posses.
	PostalCode float64

	// The region or state results should be to be present in.
	//
	// Example: North Rhine-Westphalia .
	Region float64

	// Name of sub-block.
	//
	// Example: Sunny Mansion 203 sub-block: 4
	SubBlock float64

	// A subdivision of a district.
	//
	// Example: Minden-Lübbecke
	SubDistrict float64

	// The sub-region or county for which results should be present in.
	SubRegion float64
	// contains filtered or unexported fields
}

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

type AddressComponentPhonemes 

type AddressComponentPhonemes struct {

	// How to pronounce the name of the block.
	Block []PhonemeTranscription

	// The alpha-2 or alpha-3 character code for the country that the results will be
	// present in.
	Country []PhonemeTranscription

	// How to pronounce the district or division of a city results should be present
	// in.
	District []PhonemeTranscription

	// How to pronounce the city or locality results should be present in.
	//
	// Example: Vancouver .
	Locality []PhonemeTranscription

	// How to pronounce the region or state results should be to be present in.
	Region []PhonemeTranscription

	// How to pronounce the name of the street results should be present in.
	Street []PhonemeTranscription

	// How to pronounce the name of the sub-block.
	SubBlock []PhonemeTranscription

	// How to pronounce the sub-district or division of a city results should be
	// present in.
	SubDistrict []PhonemeTranscription

	// How to pronounce the sub-region or county for which results should be present
	// in.
	SubRegion []PhonemeTranscription
	// contains filtered or unexported fields
}

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

type AutocompleteAdditionalFeature 

type AutocompleteAdditionalFeature string
const (
	AutocompleteAdditionalFeatureCore AutocompleteAdditionalFeature = "Core"
)

Enum values for AutocompleteAdditionalFeature

func (AutocompleteAdditionalFeature) Values 

func (AutocompleteAdditionalFeature) Values() []AutocompleteAdditionalFeature

Values returns all known values for AutocompleteAdditionalFeature. Note that this can be expanded in the future, and so it is only as up to date as the client.

The ordering of this slice is not guaranteed to be stable across updates.

type AutocompleteAddressHighlights 

type AutocompleteAddressHighlights struct {

	// The house number or address results should have.
	AddressNumber []Highlight

	// Name of the block. Example: Sunny Mansion 203 block: 2 Chome
	Block []Highlight

	// The name of the building at the address.
	Building []Highlight

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

	// The district or division of a city the results should be present in.
	District []Highlight

	// Name of the streets in the intersection. For example: e.g.
	// ["Friedrichstraße","Unter den Linden"]
	Intersection [][]Highlight

	// Indicates the starting and ending indexes for result items where they are
	// identified to match the input query. This should be used to provide emphasis to
	// output display to make selecting the correct result from a list easier for end
	// users.
	Label []Highlight

	// The city or locality results should be present in.
	//
	// Example: Vancouver .
	Locality []Highlight

	// An alphanumeric string included in a postal address to facilitate mail sorting,
	// such as post code, postcode, or ZIP code for which the result should posses.
	PostalCode []Highlight

	// The region or state results should be to be present in.
	//
	// Example: North Rhine-Westphalia .
	Region *RegionHighlights

	// The name of the street results should be present in.
	Street []Highlight

	// Name of sub-block. Example Sunny Mansion 203 sub-block: 4
	SubBlock []Highlight

	// Indicates the starting and ending index of the title in the text query that
	// match the found title.
	SubDistrict []Highlight

	// The sub-region or county for which results should be present in.
	SubRegion *SubRegionHighlights
	// contains filtered or unexported fields
}

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.

type AutocompleteFilter 

type AutocompleteFilter struct {

	// The bounding box enclosing the geometric shape (area or line) that an
	// individual result covers.
	//
	// The bounding box formed is defined as a set 4 coordinates: [{westward lng},
	// {southern lat}, {eastward lng}, {northern lat}]
	BoundingBox []float64

	// The Circle that all results must be in.
	Circle *FilterCircle

	//  A list of countries that all results must be in. Countries are represented by
	// either their alpha-2 or alpha-3 character codes.
	IncludeCountries []string

	// The included place types.
	IncludePlaceTypes []AutocompleteFilterPlaceType
	// contains filtered or unexported fields
}

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

type AutocompleteFilterPlaceType 

type AutocompleteFilterPlaceType string
const (
	AutocompleteFilterPlaceTypeLocality   AutocompleteFilterPlaceType = "Locality"
	AutocompleteFilterPlaceTypePostalCode AutocompleteFilterPlaceType = "PostalCode"
)

Enum values for AutocompleteFilterPlaceType

func (AutocompleteFilterPlaceType) Values 

func (AutocompleteFilterPlaceType) Values() []AutocompleteFilterPlaceType

Values returns all known values for AutocompleteFilterPlaceType. Note that this can be expanded in the future, and so it is only as up to date as the client.

The ordering of this slice is not guaranteed to be stable across updates.

type AutocompleteHighlights 

type AutocompleteHighlights struct {

	// Describes how part of the result address match the input query.
	Address *AutocompleteAddressHighlights

	// Indicates where the title field in the result matches the input query.
	Title []Highlight
	// contains filtered or unexported fields
}

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.

type AutocompleteIntendedUse 

type AutocompleteIntendedUse string
const (
	// Indicates that results of the operation are for single use, e.g., displaying
	// results on a map or presenting options to users.
	AutocompleteIntendedUseSingleUse AutocompleteIntendedUse = "SingleUse"
)

Enum values for AutocompleteIntendedUse

func (AutocompleteIntendedUse) Values 

func (AutocompleteIntendedUse) Values() []AutocompleteIntendedUse

Values returns all known values for AutocompleteIntendedUse. Note that this can be expanded in the future, and so it is only as up to date as the client.

The ordering of this slice is not guaranteed to be stable across updates.

type AutocompleteResultItem 

type AutocompleteResultItem struct {

	// The PlaceId of the place associated with this result. This can be used to look
	// up additional details about the result via GetPlace.
	//
	// This member is required.
	PlaceId *string

	// PlaceType describes the type of result entry returned.
	//
	// This member is required.
	PlaceType PlaceType

	// A formatted string for display when presenting this result to an end user.
	//
	// This member is required.
	Title *string

	// The address associated with this result.
	Address *Address

	// The distance in meters between the center of the search area and this result.
	// Useful to evaluate how far away from the original bias position the result is.
	Distance int64

	// Indicates the starting and ending index of the place in the text query that
	// match the found title.
	Highlights *AutocompleteHighlights

	// A list of [BCP 47] compliant language codes for the results to be rendered in. If there
	// is no data for the result in the requested language, data will be returned in
	// the default language for the entry.
	//
	// [BCP 47]: https://en.wikipedia.org/wiki/IETF_language_tag
	Language *string

	// The alpha-2 or alpha-3 character code for the political view of a country. The
	// political view applies to the results of the request to represent unresolved
	// territorial claims through the point of view of the specified country.
	PoliticalView *string
	// contains filtered or unexported fields
}

A result matching the input query text.

type BusinessChain 

type BusinessChain struct {

	// The Business Chain Id.
	Id *string

	// The business chain name.
	Name *string
	// contains filtered or unexported fields
}

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

type Category 

type Category struct {

	// The category ID.
	//
	// This member is required.
	Id *string

	// The category name.
	//
	// This member is required.
	Name *string

	// Localized name of the category type.
	LocalizedName *string

	// Boolean which indicates if this category is the primary offered by the place.
	Primary *bool
	// contains filtered or unexported fields
}

Category of the Place returned.

type ComponentMatchScores 

type ComponentMatchScores struct {

	// The place's address.
	Address *AddressComponentMatchScores

	// Indicates the starting and ending index of the title in the text query that
	// match the found title.
	Title float64
	// contains filtered or unexported fields
}

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

type ContactDetails 

type ContactDetails struct {

	// Categories of results that results must belong too.
	Categories []Category

	// The contact's label.
	Label *string

	// The contact's value.
	Value *string
	// contains filtered or unexported fields
}

Details related to contacts.

type Contacts 

type Contacts struct {

	// List of emails for contacts of the result.
	Emails []ContactDetails

	// List of fax addresses for the result contact.
	Faxes []ContactDetails

	// List of phone numbers for the results contact.
	Phones []ContactDetails

	// List of website URLs that belong to the result.
	Websites []ContactDetails
	// contains filtered or unexported fields
}

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

type Country 

type Country struct {

	// Country, represented by its alpha 2-character code.
	Code2 *string

	// Country, represented by its alpha t-character code.
	Code3 *string

	// Name of the country.
	Name *string
	// contains filtered or unexported fields
}

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

type CountryHighlights 

type CountryHighlights struct {

	// Indicates the starting and ending index of the country code in the text query
	// that match the found title.
	Code []Highlight

	// Indicates the starting and ending index of the country code in the text query
	// that match the found title.
	Name []Highlight
	// contains filtered or unexported fields
}

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

type FilterCircle 

type FilterCircle struct {

	// The center position, in longitude and latitude, of the FilterCircle .
	//
	// This member is required.
	Center []float64

	// The radius, in meters, of the FilterCircle .
	//
	// This member is required.
	Radius *int64
	// contains filtered or unexported fields
}

The Circle that all results must be in.

type FoodType 

type FoodType struct {

	// Localized name of the food type.
	//
	// This member is required.
	LocalizedName *string

	// The Food Type Id.
	Id *string

	// Boolean which indicates if this food type is the primary offered by the place.
	// For example, if a location serves fast food, but also dessert, he primary would
	// likely be fast food.
	Primary *bool
	// contains filtered or unexported fields
}

List of Food types offered by this result.

type GeocodeAdditionalFeature 

type GeocodeAdditionalFeature string
const (
	GeocodeAdditionalFeatureTimeZone GeocodeAdditionalFeature = "TimeZone"
	GeocodeAdditionalFeatureAccess   GeocodeAdditionalFeature = "Access"
)

Enum values for GeocodeAdditionalFeature

func (GeocodeAdditionalFeature) Values 

func (GeocodeAdditionalFeature) Values() []GeocodeAdditionalFeature

Values returns all known values for GeocodeAdditionalFeature. Note that this can be expanded in the future, and so it is only as up to date as the client.

The ordering of this slice is not guaranteed to be stable across updates.

type GeocodeFilter 

type GeocodeFilter struct {

	//  A list of countries that all results must be in. Countries are represented by
	// either their alpha-2 or alpha-3 character codes.
	IncludeCountries []string

	// The included place types.
	IncludePlaceTypes []GeocodeFilterPlaceType
	// contains filtered or unexported fields
}

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

type GeocodeFilterPlaceType 

type GeocodeFilterPlaceType string
const (
	GeocodeFilterPlaceTypeLocality            GeocodeFilterPlaceType = "Locality"
	GeocodeFilterPlaceTypePostalCode          GeocodeFilterPlaceType = "PostalCode"
	GeocodeFilterPlaceTypeIntersection        GeocodeFilterPlaceType = "Intersection"
	GeocodeFilterPlaceTypeStreet              GeocodeFilterPlaceType = "Street"
	GeocodeFilterPlaceTypePointAddress        GeocodeFilterPlaceType = "PointAddress"
	GeocodeFilterPlaceTypeInterpolatedAddress GeocodeFilterPlaceType = "InterpolatedAddress"
)

Enum values for GeocodeFilterPlaceType

func (GeocodeFilterPlaceType) Values 

func (GeocodeFilterPlaceType) Values() []GeocodeFilterPlaceType

Values returns all known values for GeocodeFilterPlaceType. Note that this can be expanded in the future, and so it is only as up to date as the client.

The ordering of this slice is not guaranteed to be stable across updates.

type GeocodeIntendedUse 

type GeocodeIntendedUse string
const (
	// Indicates that results of the operation are for single use, e.g., displaying
	// results on a map or presenting options to users.
	GeocodeIntendedUseSingleUse GeocodeIntendedUse = "SingleUse"
	// Indicates that results of the operation may be stored locally.
	GeocodeIntendedUseStorage GeocodeIntendedUse = "Storage"
)

Enum values for GeocodeIntendedUse

func (GeocodeIntendedUse) Values 

func (GeocodeIntendedUse) Values() []GeocodeIntendedUse

Values returns all known values for GeocodeIntendedUse. Note that this can be expanded in the future, and so it is only as up to date as the client.

The ordering of this slice is not guaranteed to be stable across updates.

type GeocodeQueryComponents 

type GeocodeQueryComponents struct {

	// The house number or address results should have.
	AddressNumber *string

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

	// The district or division of a city the results should be present in.
	District *string

	// City or locality results should be present in.
	//
	// Example: Vancouver .
	Locality *string

	// An alphanumeric string included in a postal address to facilitate mail sorting,
	// such as post code, postcode, or ZIP code for which the result should posses.
	PostalCode *string

	// The region or state results should be to be present in.
	//
	// Example: North Rhine-Westphalia .
	Region *string

	// The name of the street results should be present in.
	Street *string

	// The sub-region or county for which results should be present in.
	SubRegion *string
	// contains filtered or unexported fields
}

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

type GeocodeResultItem 

type GeocodeResultItem struct {

	// The PlaceId of the place you wish to receive the information for.
	//
	// This member is required.
	PlaceId *string

	// A PlaceType is a category that the result place must belong to.
	//
	// This member is required.
	PlaceType PlaceType

	// The localized display name of this result item based on request parameter
	// language .
	//
	// This member is required.
	Title *string

	// Position of the access point represent by longitude and latitude.
	AccessPoints []AccessPoint

	// The place's address.
	Address *Address

	// Boolean indicating if the address provided has been corrected.
	AddressNumberCorrected *bool

	// Categories of results that results must belong to.
	Categories []Category

	// The distance in meters from the QueryPosition.
	Distance int64

	// List of food types offered by this result.
	FoodTypes []FoodType

	// The bounding box enclosing the geometric shape (area or line) that an
	// individual result covers.
	//
	// The bounding box formed is defined as a set 4 coordinates: [{westward lng},
	// {southern lat}, {eastward lng}, {northern lat}]
	MapView []float64

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

	// The alpha-2 or alpha-3 character code for the political view of a country. The
	// political view applies to the results of the request to represent unresolved
	// territorial claims through the point of view of the specified country.
	PoliticalView *string

	// The position in longitude and latitude.
	Position []float64

	// Contains details about the postal code of the place/result.
	PostalCodeDetails []PostalCodeDetails

	// The time zone in which the place is located.
	TimeZone *TimeZone
	// contains filtered or unexported fields
}

The Geocoded result.

type GetPlaceAdditionalFeature 

type GetPlaceAdditionalFeature string
const (
	GetPlaceAdditionalFeatureTimeZone GetPlaceAdditionalFeature = "TimeZone"
	GetPlaceAdditionalFeaturePhonemes GetPlaceAdditionalFeature = "Phonemes"
	GetPlaceAdditionalFeatureAccess   GetPlaceAdditionalFeature = "Access"
	GetPlaceAdditionalFeatureContact  GetPlaceAdditionalFeature = "Contact"
)

Enum values for GetPlaceAdditionalFeature

func (GetPlaceAdditionalFeature) Values 

func (GetPlaceAdditionalFeature) Values() []GetPlaceAdditionalFeature

Values returns all known values for GetPlaceAdditionalFeature. Note that this can be expanded in the future, and so it is only as up to date as the client.

The ordering of this slice is not guaranteed to be stable across updates.

type GetPlaceIntendedUse 

type GetPlaceIntendedUse string
const (
	// Indicates that results of the operation are for single use, e.g., displaying
	// results on a map or presenting options to users.
	GetPlaceIntendedUseSingleUse GetPlaceIntendedUse = "SingleUse"
	// Indicates that results of the operation may be stored locally.
	GetPlaceIntendedUseStorage GetPlaceIntendedUse = "Storage"
)

Enum values for GetPlaceIntendedUse

func (GetPlaceIntendedUse) Values 

func (GetPlaceIntendedUse) Values() []GetPlaceIntendedUse

Values returns all known values for GetPlaceIntendedUse. Note that this can be expanded in the future, and so it is only as up to date as the client.

The ordering of this slice is not guaranteed to be stable across updates.

type Highlight 

type Highlight struct {

	// End index of the highlight.
	EndIndex *int32

	// Start index of the highlight.
	StartIndex *int32

	// The highlight's value.
	Value *string
	// contains filtered or unexported fields
}

Describes how parts of the result response match the input query.

type InternalServerException 

type InternalServerException struct {
	Message *string

	ErrorCodeOverride *string
	// contains filtered or unexported fields
}

The request processing has failed because of an unknown error, exception or failure.

func (*InternalServerException) Error 

func (e *InternalServerException) Error() string

func (*InternalServerException) ErrorCode 

func (e *InternalServerException) ErrorCode() string

func (*InternalServerException) ErrorFault 

func (e *InternalServerException) ErrorFault() smithy.ErrorFault

func (*InternalServerException) ErrorMessage 

func (e *InternalServerException) ErrorMessage() string

type MatchScoreDetails 

type MatchScoreDetails struct {

	// Indicates how well the component input matches the returned. It is equal to 1
	// if all input tokens are recognized and matched.
	Components *ComponentMatchScores

	// Indicates how well the entire input matches the returned. It is equal to 1 if
	// all input tokens are recognized and matched.
	Overall float64
	// contains filtered or unexported fields
}

Details related to the match score.

type OpeningHours 

type OpeningHours struct {

	// Categories of results that results must belong too.
	Categories []Category

	// Components of the opening hours object.
	Components []OpeningHoursComponents

	// List of opening hours in the format they are displayed in. This can vary by
	// result and in most cases represents how the result uniquely formats their
	// opening hours.
	Display []string

	// Boolean which indicates if the result/place is currently open.
	OpenNow *bool
	// contains filtered or unexported fields
}

List of opening hours objects.

type OpeningHoursComponents 

type OpeningHoursComponents struct {

	// String which represents the duration of the opening period, such as "PT12H00M" .
	OpenDuration *string

	// String which represents the opening hours, such as "T070000" .
	OpenTime *string

	// Days or periods when the provided opening hours are in affect.
	//
	// Example: FREQ:DAILY;BYDAY:MO,TU,WE,TH,SU
	Recurrence *string
	// contains filtered or unexported fields
}

Components of the opening hours object.

type PhonemeDetails 

type PhonemeDetails struct {

	// How to pronounce the address.
	Address *AddressComponentPhonemes

	// List of PhonemeTranscription . See PhonemeTranscription for fields.
	Title []PhonemeTranscription
	// contains filtered or unexported fields
}

The phoneme details.

type PhonemeTranscription 

type PhonemeTranscription struct {

	// A list of [BCP 47] compliant language codes for the results to be rendered in. If there
	// is no data for the result in the requested language, data will be returned in
	// the default language for the entry.
	//
	// [BCP 47]: https://en.wikipedia.org/wiki/IETF_language_tag
	Language *string

	// Boolean which indicates if it the preferred pronunciation.
	Preferred *bool

	// Value which indicates how to pronounce the value.
	Value *string
	// contains filtered or unexported fields
}

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

type PlaceType 

type PlaceType string
const (
	PlaceTypeCountry             PlaceType = "Country"
	PlaceTypeRegion              PlaceType = "Region"
	PlaceTypeSubRegion           PlaceType = "SubRegion"
	PlaceTypeLocality            PlaceType = "Locality"
	PlaceTypeDistrict            PlaceType = "District"
	PlaceTypeSubDistrict         PlaceType = "SubDistrict"
	PlaceTypePostalCode          PlaceType = "PostalCode"
	PlaceTypeBlock               PlaceType = "Block"
	PlaceTypeSubBlock            PlaceType = "SubBlock"
	PlaceTypeIntersection        PlaceType = "Intersection"
	PlaceTypeStreet              PlaceType = "Street"
	PlaceTypePointOfInterest     PlaceType = "PointOfInterest"
	PlaceTypePointAddress        PlaceType = "PointAddress"
	PlaceTypeInterpolatedAddress PlaceType = "InterpolatedAddress"
)

Enum values for PlaceType

func (PlaceType) Values 

func (PlaceType) Values() []PlaceType

Values returns all known values for PlaceType. Note that this can be expanded in the future, and so it is only as up to date as the client.

The ordering of this slice is not guaranteed to be stable across updates.

type PostalAuthority 

type PostalAuthority string
const (
	PostalAuthorityUsps PostalAuthority = "Usps"
)

Enum values for PostalAuthority

func (PostalAuthority) Values 

func (PostalAuthority) Values() []PostalAuthority

Values returns all known values for PostalAuthority. Note that this can be expanded in the future, and so it is only as up to date as the client.

The ordering of this slice is not guaranteed to be stable across updates.

type PostalCodeDetails 

type PostalCodeDetails struct {

	// The postal authority or entity. This could be a governmental authority, a
	// regulatory authority, or a designated postal operator.
	PostalAuthority PostalAuthority

	// An alphanumeric string included in a postal address to facilitate mail sorting,
	// such as post code, postcode, or ZIP code for which the result should posses.
	PostalCode *string

	// The postal code type.
	PostalCodeType PostalCodeType

	// The ZIP Classification Code, or in other words what type of postal code is it.
	UspsZip *UspsZip

	// The USPS ZIP+4 Record Type Code.
	UspsZipPlus4 *UspsZipPlus4
	// contains filtered or unexported fields
}

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

type PostalCodeMode 

type PostalCodeMode string
const (
	PostalCodeModeMergeAllSpannedLocalities  PostalCodeMode = "MergeAllSpannedLocalities"
	PostalCodeModeEnumerateSpannedLocalities PostalCodeMode = "EnumerateSpannedLocalities"
)

Enum values for PostalCodeMode

func (PostalCodeMode) Values 

func (PostalCodeMode) Values() []PostalCodeMode

Values returns all known values for PostalCodeMode. Note that this can be expanded in the future, and so it is only as up to date as the client.

The ordering of this slice is not guaranteed to be stable across updates.

type PostalCodeType 

type PostalCodeType string
const (
	PostalCodeTypeUspsZip      PostalCodeType = "UspsZip"
	PostalCodeTypeUspsZipPlus4 PostalCodeType = "UspsZipPlus4"
)

Enum values for PostalCodeType

func (PostalCodeType) Values 

func (PostalCodeType) Values() []PostalCodeType

Values returns all known values for PostalCodeType. Note that this can be expanded in the future, and so it is only as up to date as the client.

The ordering of this slice is not guaranteed to be stable across updates.

type QueryRefinement 

type QueryRefinement struct {

	// End index of the parsed query.
	//
	// This member is required.
	EndIndex *int32

	// The sub-string of the original query that is replaced by this query term.
	//
	// This member is required.
	OriginalTerm *string

	// The term that will be suggested to the user.
	//
	// This member is required.
	RefinedTerm *string

	// Start index of the parsed component.
	//
	// This member is required.
	StartIndex *int32
	// contains filtered or unexported fields
}

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

type QueryType 

type QueryType string
const (
	QueryTypeCategory      QueryType = "Category"
	QueryTypeBusinessChain QueryType = "BusinessChain"
)

Enum values for QueryType

func (QueryType) Values 

func (QueryType) Values() []QueryType

Values returns all known values for QueryType. Note that this can be expanded in the future, and so it is only as up to date as the client.

The ordering of this slice is not guaranteed to be stable across updates.

type RecordTypeCode 

type RecordTypeCode string
const (
	RecordTypeCodeFirm          RecordTypeCode = "Firm"
	RecordTypeCodeGeneral       RecordTypeCode = "General"
	RecordTypeCodeHighRise      RecordTypeCode = "HighRise"
	RecordTypeCodePostOfficeBox RecordTypeCode = "PostOfficeBox"
	RecordTypeCodeRural         RecordTypeCode = "Rural"
	RecordTypeCodeStreet        RecordTypeCode = "Street"
)

Enum values for RecordTypeCode

func (RecordTypeCode) Values 

func (RecordTypeCode) Values() []RecordTypeCode

Values returns all known values for RecordTypeCode. Note that this can be expanded in the future, and so it is only as up to date as the client.

The ordering of this slice is not guaranteed to be stable across updates.

type Region 

type Region struct {

	// Abbreviated code for a the state, province or region of the country.
	//
	// Example: BC .
	Code *string

	// Name for a the state, province, or region of the country.
	//
	// Example: British Columbia .
	Name *string
	// contains filtered or unexported fields
}

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

Example: North Rhine-Westphalia .

type RegionHighlights 

type RegionHighlights struct {

	// Indicates the starting and ending index of the region in the text query that
	// match the found title.
	Code []Highlight

	// Indicates the starting and ending index of the region name in the text query
	// that match the found title.
	Name []Highlight
	// contains filtered or unexported fields
}

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

type ReverseGeocodeAdditionalFeature 

type ReverseGeocodeAdditionalFeature string
const (
	ReverseGeocodeAdditionalFeatureTimeZone ReverseGeocodeAdditionalFeature = "TimeZone"
	ReverseGeocodeAdditionalFeatureAccess   ReverseGeocodeAdditionalFeature = "Access"
)

Enum values for ReverseGeocodeAdditionalFeature

func (ReverseGeocodeAdditionalFeature) Values 

func (ReverseGeocodeAdditionalFeature) Values() []ReverseGeocodeAdditionalFeature

Values returns all known values for ReverseGeocodeAdditionalFeature. Note that this can be expanded in the future, and so it is only as up to date as the client.

The ordering of this slice is not guaranteed to be stable across updates.

type ReverseGeocodeFilter 

type ReverseGeocodeFilter struct {

	// The included place types.
	IncludePlaceTypes []ReverseGeocodeFilterPlaceType
	// contains filtered or unexported fields
}

The included place types.

type ReverseGeocodeFilterPlaceType 

type ReverseGeocodeFilterPlaceType string
const (
	ReverseGeocodeFilterPlaceTypeLocality            ReverseGeocodeFilterPlaceType = "Locality"
	ReverseGeocodeFilterPlaceTypeIntersection        ReverseGeocodeFilterPlaceType = "Intersection"
	ReverseGeocodeFilterPlaceTypeStreet              ReverseGeocodeFilterPlaceType = "Street"
	ReverseGeocodeFilterPlaceTypePointAddress        ReverseGeocodeFilterPlaceType = "PointAddress"
	ReverseGeocodeFilterPlaceTypeInterpolatedAddress ReverseGeocodeFilterPlaceType = "InterpolatedAddress"
)

Enum values for ReverseGeocodeFilterPlaceType

func (ReverseGeocodeFilterPlaceType) Values 

func (ReverseGeocodeFilterPlaceType) Values() []ReverseGeocodeFilterPlaceType

Values returns all known values for ReverseGeocodeFilterPlaceType. Note that this can be expanded in the future, and so it is only as up to date as the client.

The ordering of this slice is not guaranteed to be stable across updates.

type ReverseGeocodeIntendedUse 

type ReverseGeocodeIntendedUse string
const (
	// Indicates that results of the operation are for single use, e.g., displaying
	// results on a map or presenting options to users.
	ReverseGeocodeIntendedUseSingleUse ReverseGeocodeIntendedUse = "SingleUse"
	// Indicates that results of the operation may be stored locally.
	ReverseGeocodeIntendedUseStorage ReverseGeocodeIntendedUse = "Storage"
)

Enum values for ReverseGeocodeIntendedUse

func (ReverseGeocodeIntendedUse) Values 

func (ReverseGeocodeIntendedUse) Values() []ReverseGeocodeIntendedUse

Values returns all known values for ReverseGeocodeIntendedUse. Note that this can be expanded in the future, and so it is only as up to date as the client.

The ordering of this slice is not guaranteed to be stable across updates.

type ReverseGeocodeResultItem 

type ReverseGeocodeResultItem struct {

	// The PlaceId of the place you wish to receive the information for.
	//
	// This member is required.
	PlaceId *string

	// A PlaceType is a category that the result place must belong to.
	//
	// This member is required.
	PlaceType PlaceType

	// The localized display name of this result item based on request parameter
	// language .
	//
	// This member is required.
	Title *string

	// Position of the access point represent by longitude and latitude.
	AccessPoints []AccessPoint

	// The place's address.
	Address *Address

	// Boolean indicating if the address provided has been corrected.
	AddressNumberCorrected *bool

	// Categories of results that results must belong to.
	Categories []Category

	// The distance in meters from the QueryPosition.
	Distance int64

	// List of food types offered by this result.
	FoodTypes []FoodType

	// The bounding box enclosing the geometric shape (area or line) that an
	// individual result covers.
	//
	// The bounding box formed is defined as a set 4 coordinates: [{westward lng},
	// {southern lat}, {eastward lng}, {northern lat}]
	MapView []float64

	// The alpha-2 or alpha-3 character code for the political view of a country. The
	// political view applies to the results of the request to represent unresolved
	// territorial claims through the point of view of the specified country.
	PoliticalView *string

	// The position in longitude and latitude.
	Position []float64

	// Contains details about the postal code of the place/result.
	PostalCodeDetails []PostalCodeDetails

	// The time zone in which the place is located.
	TimeZone *TimeZone
	// contains filtered or unexported fields
}

The returned location from the Reverse Geocode action.

type SearchNearbyAdditionalFeature 

type SearchNearbyAdditionalFeature string
const (
	SearchNearbyAdditionalFeatureTimeZone SearchNearbyAdditionalFeature = "TimeZone"
	SearchNearbyAdditionalFeaturePhonemes SearchNearbyAdditionalFeature = "Phonemes"
	SearchNearbyAdditionalFeatureAccess   SearchNearbyAdditionalFeature = "Access"
	SearchNearbyAdditionalFeatureContact  SearchNearbyAdditionalFeature = "Contact"
)

Enum values for SearchNearbyAdditionalFeature

func (SearchNearbyAdditionalFeature) Values 

func (SearchNearbyAdditionalFeature) Values() []SearchNearbyAdditionalFeature

Values returns all known values for SearchNearbyAdditionalFeature. Note that this can be expanded in the future, and so it is only as up to date as the client.

The ordering of this slice is not guaranteed to be stable across updates.

type SearchNearbyFilter 

type SearchNearbyFilter struct {

	// The bounding box enclosing the geometric shape (area or line) that an
	// individual result covers.
	//
	// The bounding box formed is defined as a set 4 coordinates: [{westward lng},
	// {southern lat}, {eastward lng}, {northern lat}]
	BoundingBox []float64

	// The Business Chains associated with the place.
	ExcludeBusinessChains []string

	// Categories of results that results are excluded from.
	ExcludeCategories []string

	// Food types that results are excluded from.
	ExcludeFoodTypes []string

	// The Business Chains associated with the place.
	IncludeBusinessChains []string

	// Categories of results that results must belong too.
	IncludeCategories []string

	// A list of countries that all results must be in. Countries are represented by
	// either their alpha-2 or alpha-3 character codes.
	IncludeCountries []string

	// Food types that results are included from.
	IncludeFoodTypes []string
	// contains filtered or unexported fields
}

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

type SearchNearbyIntendedUse 

type SearchNearbyIntendedUse string
const (
	// Indicates that results of the operation are for single use, e.g., displaying
	// results on a map or presenting options to users.
	SearchNearbyIntendedUseSingleUse SearchNearbyIntendedUse = "SingleUse"
	// Indicates that results of the operation may be stored locally.
	SearchNearbyIntendedUseStorage SearchNearbyIntendedUse = "Storage"
)

Enum values for SearchNearbyIntendedUse

func (SearchNearbyIntendedUse) Values 

func (SearchNearbyIntendedUse) Values() []SearchNearbyIntendedUse

Values returns all known values for SearchNearbyIntendedUse. Note that this can be expanded in the future, and so it is only as up to date as the client.

The ordering of this slice is not guaranteed to be stable across updates.

type SearchNearbyResultItem 

type SearchNearbyResultItem struct {

	// The PlaceId of the place you wish to receive the information for.
	//
	// This member is required.
	PlaceId *string

	// A PlaceType is a category that the result place must belong to.
	//
	// This member is required.
	PlaceType PlaceType

	// The item's title.
	//
	// This member is required.
	Title *string

	// Position of the access point represent by longitude and latitude.
	AccessPoints []AccessPoint

	// Indicates known access restrictions on a vehicle access point. The index
	// correlates to an access point and indicates if access through this point has
	// some form of restriction.
	AccessRestrictions []AccessRestriction

	// The place's address.
	Address *Address

	// Boolean indicating if the address provided has been corrected.
	AddressNumberCorrected *bool

	// The Business Chains associated with the place.
	BusinessChains []BusinessChain

	// Categories of results that results must belong to.
	Categories []Category

	// List of potential contact methods for the result/place.
	Contacts *Contacts

	// The distance in meters from the QueryPosition.
	Distance int64

	// List of food types offered by this result.
	FoodTypes []FoodType

	// The bounding box enclosing the geometric shape (area or line) that an
	// individual result covers.
	//
	// The bounding box formed is defined as a set 4 coordinates: [{westward lng},
	// {southern lat}, {eastward lng}, {northern lat}]
	MapView []float64

	// List of opening hours objects.
	OpeningHours []OpeningHours

	// How the various components of the result's address are pronounced in various
	// languages.
	Phonemes *PhonemeDetails

	// The alpha-2 or alpha-3 character code for the political view of a country. The
	// political view applies to the results of the request to represent unresolved
	// territorial claims through the point of view of the specified country.
	PoliticalView *string

	// The position in longitude and latitude.
	Position []float64

	// The time zone in which the place is located.
	TimeZone *TimeZone
	// contains filtered or unexported fields
}

The search results of nearby places.

type SearchTextAdditionalFeature 

type SearchTextAdditionalFeature string
const (
	SearchTextAdditionalFeatureTimeZone SearchTextAdditionalFeature = "TimeZone"
	SearchTextAdditionalFeaturePhonemes SearchTextAdditionalFeature = "Phonemes"
	SearchTextAdditionalFeatureAccess   SearchTextAdditionalFeature = "Access"
	SearchTextAdditionalFeatureContact  SearchTextAdditionalFeature = "Contact"
)

Enum values for SearchTextAdditionalFeature

func (SearchTextAdditionalFeature) Values 

func (SearchTextAdditionalFeature) Values() []SearchTextAdditionalFeature

Values returns all known values for SearchTextAdditionalFeature. Note that this can be expanded in the future, and so it is only as up to date as the client.

The ordering of this slice is not guaranteed to be stable across updates.

type SearchTextFilter 

type SearchTextFilter struct {

	// The bounding box enclosing the geometric shape (area or line) that an
	// individual result covers.
	//
	// The bounding box formed is defined as a set 4 coordinates: [{westward lng},
	// {southern lat}, {eastward lng}, {northern lat}]
	BoundingBox []float64

	// The Circle that all results must be in.
	Circle *FilterCircle

	//  A list of countries that all results must be in. Countries are represented by
	// either their alpha-2 or alpha-3 character codes.
	IncludeCountries []string
	// contains filtered or unexported fields
}

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

type SearchTextIntendedUse 

type SearchTextIntendedUse string
const (
	// Indicates that results of the operation are for single use, e.g., displaying
	// results on a map or presenting options to users.
	SearchTextIntendedUseSingleUse SearchTextIntendedUse = "SingleUse"
	// Indicates that results of the operation may be stored locally.
	SearchTextIntendedUseStorage SearchTextIntendedUse = "Storage"
)

Enum values for SearchTextIntendedUse

func (SearchTextIntendedUse) Values 

func (SearchTextIntendedUse) Values() []SearchTextIntendedUse

Values returns all known values for SearchTextIntendedUse. Note that this can be expanded in the future, and so it is only as up to date as the client.

The ordering of this slice is not guaranteed to be stable across updates.

type SearchTextResultItem 

type SearchTextResultItem struct {

	// The PlaceId of the place you wish to receive the information for.
	//
	// This member is required.
	PlaceId *string

	// A PlaceType is a category that the result place must belong to.
	//
	// This member is required.
	PlaceType PlaceType

	// The item's title.
	//
	// This member is required.
	Title *string

	// Position of the access point represent by longitude and latitude.
	AccessPoints []AccessPoint

	// Indicates known access restrictions on a vehicle access point. The index
	// correlates to an access point and indicates if access through this point has
	// some form of restriction.
	AccessRestrictions []AccessRestriction

	// The place's address.
	Address *Address

	// Boolean indicating if the address provided has been corrected.
	AddressNumberCorrected *bool

	// The Business Chains associated with the place.
	BusinessChains []BusinessChain

	// Categories of results that results must belong to.
	Categories []Category

	// List of potential contact methods for the result/place.
	Contacts *Contacts

	// The distance in meters from the QueryPosition.
	Distance int64

	// List of food types offered by this result.
	FoodTypes []FoodType

	// The bounding box enclosing the geometric shape (area or line) that an
	// individual result covers.
	//
	// The bounding box formed is defined as a set 4 coordinates: [{westward lng},
	// {southern lat}, {eastward lng}, {northern lat}]
	MapView []float64

	// List of opening hours objects.
	OpeningHours []OpeningHours

	// How the various components of the result's address are pronounced in various
	// languages.
	Phonemes *PhonemeDetails

	// The alpha-2 or alpha-3 character code for the political view of a country. The
	// political view applies to the results of the request to represent unresolved
	// territorial claims through the point of view of the specified country.
	PoliticalView *string

	// The position, in longitude and latitude.
	Position []float64

	// The time zone in which the place is located.
	TimeZone *TimeZone
	// contains filtered or unexported fields
}

The text search result.

type StreetComponents 

type StreetComponents struct {

	// Base name part of the street name.
	//
	// Example: Younge from the “Younge street".
	BaseName *string

	// Indicates the official directional identifiers assigned to highways.
	Direction *string

	// A [BCP 47] compliant language codes for the results to be rendered in. If there is no
	// data for the result in the requested language, data will be returned in the
	// default language for the entry.
	//
	// [BCP 47]: https://en.wikipedia.org/wiki/IETF_language_tag
	Language *string

	// A prefix is a directional identifier that precedes, but is not included in, the
	// base name of a road.
	//
	// Example: E for East.
	Prefix *string

	// A suffix is a directional identifier that follows, but is not included in, the
	// base name of a road.
	//
	// Example W for West.
	Suffix *string

	// Street type part of the street name.
	//
	// Example: “avenue" .
	Type *string

	// Defines if the street type is before or after the base name.
	TypePlacement TypePlacement

	// What character(s) separates the string from its type.
	TypeSeparator *string
	// contains filtered or unexported fields
}

Components of a street.

type SubRegion 

type SubRegion struct {

	// Abbreviated code for the county or sub-region.
	Code *string

	// Name for the county or sub-region.
	Name *string
	// contains filtered or unexported fields
}

The sub-region.

type SubRegionHighlights 

type SubRegionHighlights struct {

	// Indicates the starting and ending index of the sub-region in the text query
	// that match the found title.
	Code []Highlight

	// Indicates the starting and ending index of the name in the text query that
	// match the found title.
	Name []Highlight
	// contains filtered or unexported fields
}

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

type SuggestAdditionalFeature 

type SuggestAdditionalFeature string
const (
	SuggestAdditionalFeatureCore     SuggestAdditionalFeature = "Core"
	SuggestAdditionalFeatureTimeZone SuggestAdditionalFeature = "TimeZone"
	SuggestAdditionalFeaturePhonemes SuggestAdditionalFeature = "Phonemes"
	SuggestAdditionalFeatureAccess   SuggestAdditionalFeature = "Access"
)

Enum values for SuggestAdditionalFeature

func (SuggestAdditionalFeature) Values 

func (SuggestAdditionalFeature) Values() []SuggestAdditionalFeature

Values returns all known values for SuggestAdditionalFeature. Note that this can be expanded in the future, and so it is only as up to date as the client.

The ordering of this slice is not guaranteed to be stable across updates.

type SuggestAddressHighlights 

type SuggestAddressHighlights struct {

	// Indicates the starting and ending indexes of the places in the result which
	// were identified to match the textQuery. This result is useful for providing
	// emphasis to results where the user query directly matched to make selecting the
	// correct result from a list easier for an end user.
	Label []Highlight
	// contains filtered or unexported fields
}

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

type SuggestFilter 

type SuggestFilter struct {

	// The bounding box enclosing the geometric shape (area or line) that an
	// individual result covers.
	//
	// The bounding box formed is defined as a set 4 coordinates: [{westward lng},
	// {southern lat}, {eastward lng}, {northern lat}]
	BoundingBox []float64

	// The Circle that all results must be in.
	Circle *FilterCircle

	//  A list of countries that all results must be in. Countries are represented by
	// either their alpha-2 or alpha-3 character codes.
	IncludeCountries []string
	// contains filtered or unexported fields
}

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

type SuggestHighlights 

type SuggestHighlights struct {

	// The place's address.
	Address *SuggestAddressHighlights

	// Indicates the starting and ending index of the title in the text query that
	// match the found title.
	Title []Highlight
	// contains filtered or unexported fields
}

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

type SuggestIntendedUse 

type SuggestIntendedUse string
const (
	// Indicates that results of the operation are for single use, e.g., displaying
	// results on a map or presenting options to users.
	SuggestIntendedUseSingleUse SuggestIntendedUse = "SingleUse"
)

Enum values for SuggestIntendedUse

func (SuggestIntendedUse) Values 

func (SuggestIntendedUse) Values() []SuggestIntendedUse

Values returns all known values for SuggestIntendedUse. Note that this can be expanded in the future, and so it is only as up to date as the client.

The ordering of this slice is not guaranteed to be stable across updates.

type SuggestPlaceResult 

type SuggestPlaceResult struct {

	// Position of the access point represent by longitude and latitude.
	AccessPoints []AccessPoint

	// Indicates known access restrictions on a vehicle access point. The index
	// correlates to an access point and indicates if access through this point has
	// some form of restriction.
	AccessRestrictions []AccessRestriction

	// The place's address.
	Address *Address

	// The Business Chains associated with the place.
	BusinessChains []BusinessChain

	// Categories of results that results must belong to.
	Categories []Category

	// The distance in meters from the QueryPosition.
	Distance int64

	// List of food types offered by this result.
	FoodTypes []FoodType

	// The bounding box enclosing the geometric shape (area or line) that an
	// individual result covers.
	//
	// The bounding box formed is defined as a set 4 coordinates: [{westward lng},
	// {southern lat}, {eastward lng}, {northern lat}]
	MapView []float64

	// How the various components of the result's address are pronounced in various
	// languages.
	Phonemes *PhonemeDetails

	// The PlaceId of the place you wish to receive the information for.
	PlaceId *string

	// A PlaceType is a category that the result place must belong to.
	PlaceType PlaceType

	// The alpha-2 or alpha-3 character code for the political view of a country. The
	// political view applies to the results of the request to represent unresolved
	// territorial claims through the point of view of the specified country.
	PoliticalView *string

	// The position, in longitude and latitude.
	Position []float64

	// The time zone in which the place is located.
	TimeZone *TimeZone
	// contains filtered or unexported fields
}

The suggested place results.

type SuggestQueryResult 

type SuggestQueryResult struct {

	// QueryId can be used to complete a follow up query through the SearchText API.
	// The QueryId retains context from the original Suggest request such as filters,
	// political view and language. See the SearchText API documentation for more
	// details [SearchText API docs].
	//
	// [SearchText API docs]: https://docs.aws.amazon.com/latest/APIReference/API_geoplaces_SearchText.html
	QueryId *string

	// The query type. Category qeuries will search for places which have an entry
	// matching the given category, for example "doctor office". BusinessChain queries
	// will search for instances of a given business.
	QueryType QueryType
	// contains filtered or unexported fields
}

The suggested query results.

type SuggestResultItem 

type SuggestResultItem struct {

	// The result type. Place results represent the final result for a point of
	// interest, Query results represent a follow up query which can be completed
	// through the SearchText operation.
	//
	// This member is required.
	SuggestResultItemType SuggestResultItemType

	// The display title that should be used when presenting this option to the end
	// user.
	//
	// This member is required.
	Title *string

	// 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.
	Highlights *SuggestHighlights

	// The suggested place by its unique ID.
	Place *SuggestPlaceResult

	// The suggested query results.
	Query *SuggestQueryResult
	// contains filtered or unexported fields
}

The resulting item from the suggested query.

type SuggestResultItemType 

type SuggestResultItemType string
const (
	SuggestResultItemTypePlace SuggestResultItemType = "Place"
	SuggestResultItemTypeQuery SuggestResultItemType = "Query"
)

Enum values for SuggestResultItemType

func (SuggestResultItemType) Values 

func (SuggestResultItemType) Values() []SuggestResultItemType

Values returns all known values for SuggestResultItemType. Note that this can be expanded in the future, and so it is only as up to date as the client.

The ordering of this slice is not guaranteed to be stable across updates.

type ThrottlingException 

type ThrottlingException struct {
	Message *string

	ErrorCodeOverride *string
	// contains filtered or unexported fields
}

The request was denied due to request throttling.

func (*ThrottlingException) Error 

func (e *ThrottlingException) Error() string

func (*ThrottlingException) ErrorCode 

func (e *ThrottlingException) ErrorCode() string

func (*ThrottlingException) ErrorFault 

func (e *ThrottlingException) ErrorFault() smithy.ErrorFault

func (*ThrottlingException) ErrorMessage 

func (e *ThrottlingException) ErrorMessage() string

type TimeZone 

type TimeZone struct {

	// The time zone name.
	//
	// This member is required.
	Name *string

	// Time zone offset of the timezone from UTC.
	Offset *string

	// The offset of the time zone from UTC, in seconds.
	OffsetSeconds int64
	// contains filtered or unexported fields
}

The time zone in which the place is located.

type TypePlacement 

type TypePlacement string
const (
	TypePlacementBeforeBaseName TypePlacement = "BeforeBaseName"
	TypePlacementAfterBaseName  TypePlacement = "AfterBaseName"
)

Enum values for TypePlacement

func (TypePlacement) Values 

func (TypePlacement) Values() []TypePlacement

Values returns all known values for TypePlacement. Note that this can be expanded in the future, and so it is only as up to date as the client.

The ordering of this slice is not guaranteed to be stable across updates.

type UspsZip 

type UspsZip struct {

	// The ZIP Classification Code, or in other words what type of postal code is it.
	ZipClassificationCode ZipClassificationCode
	// contains filtered or unexported fields
}

The USPS zip code.

type UspsZipPlus4 

type UspsZipPlus4 struct {

	// The USPS ZIP+4 Record Type Code.
	RecordTypeCode RecordTypeCode
	// contains filtered or unexported fields
}

The USPS zip+4 code.

type ValidationException 

type ValidationException struct {
	Message *string

	ErrorCodeOverride *string

	Reason    ValidationExceptionReason
	FieldList []ValidationExceptionField
	// contains filtered or unexported fields
}

The input fails to satisfy the constraints specified by an AWS service.

func (*ValidationException) Error 

func (e *ValidationException) Error() string

func (*ValidationException) ErrorCode 

func (e *ValidationException) ErrorCode() string

func (*ValidationException) ErrorFault 

func (e *ValidationException) ErrorFault() smithy.ErrorFault

func (*ValidationException) ErrorMessage 

func (e *ValidationException) ErrorMessage() string

type ValidationExceptionField 

type ValidationExceptionField struct {

	// The error message.
	//
	// This member is required.
	Message *string

	// The name of the resource.
	//
	// This member is required.
	Name *string
	// contains filtered or unexported fields
}

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

type ValidationExceptionReason 

type ValidationExceptionReason string
const (
	// No such operation is supported.
	ValidationExceptionReasonUnknownOperation ValidationExceptionReason = "UnknownOperation"
	// The required input is missing.
	ValidationExceptionReasonMissing ValidationExceptionReason = "Missing"
	// The input cannot be parsed. For example a required JSON document, ARN
	// identifier, date value, or numeric field cannot be parsed.
	ValidationExceptionReasonCannotParse ValidationExceptionReason = "CannotParse"
	// The input is present and parsable, but it is otherwise invalid. For example, a
	// required numeric argument is outside the allowed range.
	ValidationExceptionReasonFieldValidationFailed ValidationExceptionReason = "FieldValidationFailed"
	// The input is invalid but no more specific reason is applicable.
	ValidationExceptionReasonOther ValidationExceptionReason = "Other"
	// No such field is supported.
	ValidationExceptionReasonUnknownField ValidationExceptionReason = "UnknownField"
)

Enum values for ValidationExceptionReason

func (ValidationExceptionReason) Values 

func (ValidationExceptionReason) Values() []ValidationExceptionReason

Values returns all known values for ValidationExceptionReason. Note that this can be expanded in the future, and so it is only as up to date as the client.

The ordering of this slice is not guaranteed to be stable across updates.

type ZipClassificationCode 

type ZipClassificationCode string
const (
	ZipClassificationCodeMilitary        ZipClassificationCode = "Military"
	ZipClassificationCodePostOfficeBoxes ZipClassificationCode = "PostOfficeBoxes"
	ZipClassificationCodeUnique          ZipClassificationCode = "Unique"
)

Enum values for ZipClassificationCode

func (ZipClassificationCode) Values 

func (ZipClassificationCode) Values() []ZipClassificationCode

Values returns all known values for ZipClassificationCode. Note that this can be expanded in the future, and so it is only as up to date as the client.

The ordering of this slice is not guaranteed to be stable across updates.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.
JackTT - Gopher 🇻🇳