@aws-sdk/client-geo-places 3.683.0

package/dist-types/ts3.4/models/models_0.d.ts

@@ -0,0 +1,786 @@
+import { ExceptionOptionType as __ExceptionOptionType } from "@smithy/smithy-client";
+import { GeoPlacesServiceException as __BaseException } from "./GeoPlacesServiceException";
+export declare class AccessDeniedException extends __BaseException {
+  readonly name: "AccessDeniedException";
+  readonly $fault: "client";
+  Message: string | undefined;
+  constructor(
+    opts: __ExceptionOptionType<AccessDeniedException, __BaseException>
+  );
+}
+export interface AccessPoint {
+  Position?: number[];
+}
+export interface Category {
+  Id: string | undefined;
+  Name: string | undefined;
+  LocalizedName?: string;
+  Primary?: boolean;
+}
+export interface AccessRestriction {
+  Restricted?: boolean;
+  Categories?: Category[];
+}
+export interface Country {
+  Code2?: string;
+  Code3?: string;
+  Name?: string;
+}
+export interface Region {
+  Code?: string;
+  Name?: string;
+}
+export declare const TypePlacement: {
+  readonly AFTER_BASE_NAME: "AfterBaseName";
+  readonly BEFORE_BASE_NAME: "BeforeBaseName";
+};
+export type TypePlacement = (typeof TypePlacement)[keyof typeof TypePlacement];
+export interface StreetComponents {
+  BaseName?: string;
+  Type?: string;
+  TypePlacement?: TypePlacement;
+  TypeSeparator?: string;
+  Prefix?: string;
+  Suffix?: string;
+  Direction?: string;
+  Language?: string;
+}
+export interface SubRegion {
+  Code?: string;
+  Name?: string;
+}
+export interface Address {
+  Label?: string;
+  Country?: Country;
+  Region?: Region;
+  SubRegion?: SubRegion;
+  Locality?: string;
+  District?: string;
+  SubDistrict?: string;
+  PostalCode?: string;
+  Block?: string;
+  SubBlock?: string;
+  Intersection?: string[];
+  Street?: string;
+  StreetComponents?: StreetComponents[];
+  AddressNumber?: string;
+  Building?: string;
+}
+export interface AddressComponentMatchScores {
+  Country?: number;
+  Region?: number;
+  SubRegion?: number;
+  Locality?: number;
+  District?: number;
+  SubDistrict?: number;
+  PostalCode?: number;
+  Block?: number;
+  SubBlock?: number;
+  Intersection?: number[];
+  AddressNumber?: number;
+  Building?: number;
+}
+export interface PhonemeTranscription {
+  Value?: string;
+  Language?: string;
+  Preferred?: boolean;
+}
+export interface AddressComponentPhonemes {
+  Country?: PhonemeTranscription[];
+  Region?: PhonemeTranscription[];
+  SubRegion?: PhonemeTranscription[];
+  Locality?: PhonemeTranscription[];
+  District?: PhonemeTranscription[];
+  SubDistrict?: PhonemeTranscription[];
+  Block?: PhonemeTranscription[];
+  SubBlock?: PhonemeTranscription[];
+  Street?: PhonemeTranscription[];
+}
+export declare const AutocompleteAdditionalFeature: {
+  readonly CORE: "Core";
+};
+export type AutocompleteAdditionalFeature =
+  (typeof AutocompleteAdditionalFeature)[keyof typeof AutocompleteAdditionalFeature];
+export interface FilterCircle {
+  Center: number[] | undefined;
+  Radius: number | undefined;
+}
+export declare const AutocompleteFilterPlaceType: {
+  readonly LOCALITY: "Locality";
+  readonly POSTAL_CODE: "PostalCode";
+};
+export type AutocompleteFilterPlaceType =
+  (typeof AutocompleteFilterPlaceType)[keyof typeof AutocompleteFilterPlaceType];
+export interface AutocompleteFilter {
+  BoundingBox?: number[];
+  Circle?: FilterCircle;
+  IncludeCountries?: string[];
+  IncludePlaceTypes?: AutocompleteFilterPlaceType[];
+}
+export declare const AutocompleteIntendedUse: {
+  readonly SINGLE_USE: "SingleUse";
+};
+export type AutocompleteIntendedUse =
+  (typeof AutocompleteIntendedUse)[keyof typeof AutocompleteIntendedUse];
+export declare const PostalCodeMode: {
+  readonly ENUMERATE_SPANNED_LOCALITIES: "EnumerateSpannedLocalities";
+  readonly MERGE_ALL_SPANNED_LOCALITIES: "MergeAllSpannedLocalities";
+};
+export type PostalCodeMode =
+  (typeof PostalCodeMode)[keyof typeof PostalCodeMode];
+export interface AutocompleteRequest {
+  QueryText: string | undefined;
+  MaxResults?: number;
+  BiasPosition?: number[];
+  Filter?: AutocompleteFilter;
+  PostalCodeMode?: PostalCodeMode;
+  AdditionalFeatures?: AutocompleteAdditionalFeature[];
+  Language?: string;
+  PoliticalView?: string;
+  IntendedUse?: AutocompleteIntendedUse;
+  Key?: string;
+}
+export interface Highlight {
+  StartIndex?: number;
+  EndIndex?: number;
+  Value?: string;
+}
+export interface CountryHighlights {
+  Code?: Highlight[];
+  Name?: Highlight[];
+}
+export interface RegionHighlights {
+  Code?: Highlight[];
+  Name?: Highlight[];
+}
+export interface SubRegionHighlights {
+  Code?: Highlight[];
+  Name?: Highlight[];
+}
+export interface AutocompleteAddressHighlights {
+  Label?: Highlight[];
+  Country?: CountryHighlights;
+  Region?: RegionHighlights;
+  SubRegion?: SubRegionHighlights;
+  Locality?: Highlight[];
+  District?: Highlight[];
+  SubDistrict?: Highlight[];
+  Street?: Highlight[];
+  Block?: Highlight[];
+  SubBlock?: Highlight[];
+  Intersection?: Highlight[][];
+  PostalCode?: Highlight[];
+  AddressNumber?: Highlight[];
+  Building?: Highlight[];
+}
+export interface AutocompleteHighlights {
+  Title?: Highlight[];
+  Address?: AutocompleteAddressHighlights;
+}
+export declare const PlaceType: {
+  readonly BLOCK: "Block";
+  readonly COUNTRY: "Country";
+  readonly DISTRICT: "District";
+  readonly INTERPOLATED_ADDRESS: "InterpolatedAddress";
+  readonly INTERSECTION: "Intersection";
+  readonly LOCALITY: "Locality";
+  readonly POINT_ADDRESS: "PointAddress";
+  readonly POINT_OF_INTEREST: "PointOfInterest";
+  readonly POSTAL_CODE: "PostalCode";
+  readonly REGION: "Region";
+  readonly STREET: "Street";
+  readonly SUB_BLOCK: "SubBlock";
+  readonly SUB_DISTRICT: "SubDistrict";
+  readonly SUB_REGION: "SubRegion";
+};
+export type PlaceType = (typeof PlaceType)[keyof typeof PlaceType];
+export interface AutocompleteResultItem {
+  PlaceId: string | undefined;
+  PlaceType: PlaceType | undefined;
+  Title: string | undefined;
+  Address?: Address;
+  Distance?: number;
+  Language?: string;
+  PoliticalView?: string;
+  Highlights?: AutocompleteHighlights;
+}
+export interface AutocompleteResponse {
+  PricingBucket: string | undefined;
+  ResultItems?: AutocompleteResultItem[];
+}
+export declare class InternalServerException extends __BaseException {
+  readonly name: "InternalServerException";
+  readonly $fault: "server";
+  $retryable: {};
+  Message: string | undefined;
+  constructor(
+    opts: __ExceptionOptionType<InternalServerException, __BaseException>
+  );
+}
+export declare class ThrottlingException extends __BaseException {
+  readonly name: "ThrottlingException";
+  readonly $fault: "client";
+  $retryable: {};
+  Message: string | undefined;
+  constructor(
+    opts: __ExceptionOptionType<ThrottlingException, __BaseException>
+  );
+}
+export interface ValidationExceptionField {
+  Name: string | undefined;
+  Message: string | undefined;
+}
+export declare const ValidationExceptionReason: {
+  readonly CANNOT_PARSE: "CannotParse";
+  readonly FIELD_VALIDATION_FAILED: "FieldValidationFailed";
+  readonly MISSING: "Missing";
+  readonly OTHER: "Other";
+  readonly UNKNOWN_FIELD: "UnknownField";
+  readonly UNKNOWN_OPERATION: "UnknownOperation";
+};
+export type ValidationExceptionReason =
+  (typeof ValidationExceptionReason)[keyof typeof ValidationExceptionReason];
+export declare class ValidationException extends __BaseException {
+  readonly name: "ValidationException";
+  readonly $fault: "client";
+  Message: string | undefined;
+  Reason: ValidationExceptionReason | undefined;
+  FieldList: ValidationExceptionField[] | undefined;
+  constructor(
+    opts: __ExceptionOptionType<ValidationException, __BaseException>
+  );
+}
+export interface BusinessChain {
+  Name?: string;
+  Id?: string;
+}
+export interface ComponentMatchScores {
+  Title?: number;
+  Address?: AddressComponentMatchScores;
+}
+export interface ContactDetails {
+  Label?: string;
+  Value?: string;
+  Categories?: Category[];
+}
+export interface Contacts {
+  Phones?: ContactDetails[];
+  Faxes?: ContactDetails[];
+  Websites?: ContactDetails[];
+  Emails?: ContactDetails[];
+}
+export interface FoodType {
+  LocalizedName: string | undefined;
+  Id?: string;
+  Primary?: boolean;
+}
+export declare const GeocodeAdditionalFeature: {
+  readonly ACCESS: "Access";
+  readonly TIME_ZONE: "TimeZone";
+};
+export type GeocodeAdditionalFeature =
+  (typeof GeocodeAdditionalFeature)[keyof typeof GeocodeAdditionalFeature];
+export declare const GeocodeFilterPlaceType: {
+  readonly INTERPOLATED_ADDRESS: "InterpolatedAddress";
+  readonly INTERSECTION: "Intersection";
+  readonly LOCALITY: "Locality";
+  readonly POINT_ADDRESS: "PointAddress";
+  readonly POSTAL_CODE: "PostalCode";
+  readonly STREET: "Street";
+};
+export type GeocodeFilterPlaceType =
+  (typeof GeocodeFilterPlaceType)[keyof typeof GeocodeFilterPlaceType];
+export interface GeocodeFilter {
+  IncludeCountries?: string[];
+  IncludePlaceTypes?: GeocodeFilterPlaceType[];
+}
+export declare const GeocodeIntendedUse: {
+  readonly SINGLE_USE: "SingleUse";
+  readonly STORAGE: "Storage";
+};
+export type GeocodeIntendedUse =
+  (typeof GeocodeIntendedUse)[keyof typeof GeocodeIntendedUse];
+export interface GeocodeQueryComponents {
+  Country?: string;
+  Region?: string;
+  SubRegion?: string;
+  Locality?: string;
+  District?: string;
+  Street?: string;
+  AddressNumber?: string;
+  PostalCode?: string;
+}
+export interface GeocodeRequest {
+  QueryText?: string;
+  QueryComponents?: GeocodeQueryComponents;
+  MaxResults?: number;
+  BiasPosition?: number[];
+  Filter?: GeocodeFilter;
+  AdditionalFeatures?: GeocodeAdditionalFeature[];
+  Language?: string;
+  PoliticalView?: string;
+  IntendedUse?: GeocodeIntendedUse;
+  Key?: string;
+}
+export interface MatchScoreDetails {
+  Overall?: number;
+  Components?: ComponentMatchScores;
+}
+export declare const PostalAuthority: {
+  readonly USPS: "Usps";
+};
+export type PostalAuthority =
+  (typeof PostalAuthority)[keyof typeof PostalAuthority];
+export declare const PostalCodeType: {
+  readonly USPS_ZIP: "UspsZip";
+  readonly USPS_ZIP_PLUS_4: "UspsZipPlus4";
+};
+export type PostalCodeType =
+  (typeof PostalCodeType)[keyof typeof PostalCodeType];
+export declare const ZipClassificationCode: {
+  readonly MILITARY: "Military";
+  readonly POST_OFFICE_BOXES: "PostOfficeBoxes";
+  readonly UNIQUE: "Unique";
+};
+export type ZipClassificationCode =
+  (typeof ZipClassificationCode)[keyof typeof ZipClassificationCode];
+export interface UspsZip {
+  ZipClassificationCode?: ZipClassificationCode;
+}
+export declare const RecordTypeCode: {
+  readonly FIRM: "Firm";
+  readonly GENERAL: "General";
+  readonly HIGH_RISE: "HighRise";
+  readonly POST_OFFICE_BOX: "PostOfficeBox";
+  readonly RURAL: "Rural";
+  readonly STREET: "Street";
+};
+export type RecordTypeCode =
+  (typeof RecordTypeCode)[keyof typeof RecordTypeCode];
+export interface UspsZipPlus4 {
+  RecordTypeCode?: RecordTypeCode;
+}
+export interface PostalCodeDetails {
+  PostalCode?: string;
+  PostalAuthority?: PostalAuthority;
+  PostalCodeType?: PostalCodeType;
+  UspsZip?: UspsZip;
+  UspsZipPlus4?: UspsZipPlus4;
+}
+export interface TimeZone {
+  Name: string | undefined;
+  Offset?: string;
+  OffsetSeconds?: number;
+}
+export interface GeocodeResultItem {
+  PlaceId: string | undefined;
+  PlaceType: PlaceType | undefined;
+  Title: string | undefined;
+  Address?: Address;
+  AddressNumberCorrected?: boolean;
+  PostalCodeDetails?: PostalCodeDetails[];
+  Position?: number[];
+  Distance?: number;
+  MapView?: number[];
+  Categories?: Category[];
+  FoodTypes?: FoodType[];
+  AccessPoints?: AccessPoint[];
+  TimeZone?: TimeZone;
+  PoliticalView?: string;
+  MatchScores?: MatchScoreDetails;
+}
+export interface GeocodeResponse {
+  PricingBucket: string | undefined;
+  ResultItems?: GeocodeResultItem[];
+}
+export declare const GetPlaceAdditionalFeature: {
+  readonly ACCESS: "Access";
+  readonly CONTACT: "Contact";
+  readonly PHONEMES: "Phonemes";
+  readonly TIME_ZONE: "TimeZone";
+};
+export type GetPlaceAdditionalFeature =
+  (typeof GetPlaceAdditionalFeature)[keyof typeof GetPlaceAdditionalFeature];
+export declare const GetPlaceIntendedUse: {
+  readonly SINGLE_USE: "SingleUse";
+  readonly STORAGE: "Storage";
+};
+export type GetPlaceIntendedUse =
+  (typeof GetPlaceIntendedUse)[keyof typeof GetPlaceIntendedUse];
+export interface GetPlaceRequest {
+  PlaceId: string | undefined;
+  AdditionalFeatures?: GetPlaceAdditionalFeature[];
+  Language?: string;
+  PoliticalView?: string;
+  IntendedUse?: GetPlaceIntendedUse;
+  Key?: string;
+}
+export interface OpeningHoursComponents {
+  OpenTime?: string;
+  OpenDuration?: string;
+  Recurrence?: string;
+}
+export interface OpeningHours {
+  Display?: string[];
+  OpenNow?: boolean;
+  Components?: OpeningHoursComponents[];
+  Categories?: Category[];
+}
+export interface PhonemeDetails {
+  Title?: PhonemeTranscription[];
+  Address?: AddressComponentPhonemes;
+}
+export interface GetPlaceResponse {
+  PlaceId: string | undefined;
+  PlaceType: PlaceType | undefined;
+  Title: string | undefined;
+  PricingBucket: string | undefined;
+  Address?: Address;
+  AddressNumberCorrected?: boolean;
+  PostalCodeDetails?: PostalCodeDetails[];
+  Position?: number[];
+  MapView?: number[];
+  Categories?: Category[];
+  FoodTypes?: FoodType[];
+  BusinessChains?: BusinessChain[];
+  Contacts?: Contacts;
+  OpeningHours?: OpeningHours[];
+  AccessPoints?: AccessPoint[];
+  AccessRestrictions?: AccessRestriction[];
+  TimeZone?: TimeZone;
+  PoliticalView?: string;
+  Phonemes?: PhonemeDetails;
+}
+export declare const ReverseGeocodeAdditionalFeature: {
+  readonly ACCESS: "Access";
+  readonly TIME_ZONE: "TimeZone";
+};
+export type ReverseGeocodeAdditionalFeature =
+  (typeof ReverseGeocodeAdditionalFeature)[keyof typeof ReverseGeocodeAdditionalFeature];
+export declare const ReverseGeocodeFilterPlaceType: {
+  readonly INTERPOLATED_ADDRESS: "InterpolatedAddress";
+  readonly INTERSECTION: "Intersection";
+  readonly LOCALITY: "Locality";
+  readonly POINT_ADDRESS: "PointAddress";
+  readonly STREET: "Street";
+};
+export type ReverseGeocodeFilterPlaceType =
+  (typeof ReverseGeocodeFilterPlaceType)[keyof typeof ReverseGeocodeFilterPlaceType];
+export interface ReverseGeocodeFilter {
+  IncludePlaceTypes?: ReverseGeocodeFilterPlaceType[];
+}
+export declare const ReverseGeocodeIntendedUse: {
+  readonly SINGLE_USE: "SingleUse";
+  readonly STORAGE: "Storage";
+};
+export type ReverseGeocodeIntendedUse =
+  (typeof ReverseGeocodeIntendedUse)[keyof typeof ReverseGeocodeIntendedUse];
+export interface ReverseGeocodeRequest {
+  QueryPosition: number[] | undefined;
+  QueryRadius?: number;
+  MaxResults?: number;
+  Filter?: ReverseGeocodeFilter;
+  AdditionalFeatures?: ReverseGeocodeAdditionalFeature[];
+  Language?: string;
+  PoliticalView?: string;
+  IntendedUse?: ReverseGeocodeIntendedUse;
+  Key?: string;
+}
+export interface ReverseGeocodeResultItem {
+  PlaceId: string | undefined;
+  PlaceType: PlaceType | undefined;
+  Title: string | undefined;
+  Address?: Address;
+  AddressNumberCorrected?: boolean;
+  PostalCodeDetails?: PostalCodeDetails[];
+  Position?: number[];
+  Distance?: number;
+  MapView?: number[];
+  Categories?: Category[];
+  FoodTypes?: FoodType[];
+  AccessPoints?: AccessPoint[];
+  TimeZone?: TimeZone;
+  PoliticalView?: string;
+}
+export interface ReverseGeocodeResponse {
+  PricingBucket: string | undefined;
+  ResultItems?: ReverseGeocodeResultItem[];
+}
+export declare const SearchNearbyAdditionalFeature: {
+  readonly ACCESS: "Access";
+  readonly CONTACT: "Contact";
+  readonly PHONEMES: "Phonemes";
+  readonly TIME_ZONE: "TimeZone";
+};
+export type SearchNearbyAdditionalFeature =
+  (typeof SearchNearbyAdditionalFeature)[keyof typeof SearchNearbyAdditionalFeature];
+export interface SearchNearbyFilter {
+  BoundingBox?: number[];
+  IncludeCountries?: string[];
+  IncludeCategories?: string[];
+  ExcludeCategories?: string[];
+  IncludeBusinessChains?: string[];
+  ExcludeBusinessChains?: string[];
+  IncludeFoodTypes?: string[];
+  ExcludeFoodTypes?: string[];
+}
+export declare const SearchNearbyIntendedUse: {
+  readonly SINGLE_USE: "SingleUse";
+  readonly STORAGE: "Storage";
+};
+export type SearchNearbyIntendedUse =
+  (typeof SearchNearbyIntendedUse)[keyof typeof SearchNearbyIntendedUse];
+export interface SearchNearbyRequest {
+  QueryPosition: number[] | undefined;
+  QueryRadius?: number;
+  MaxResults?: number;
+  Filter?: SearchNearbyFilter;
+  AdditionalFeatures?: SearchNearbyAdditionalFeature[];
+  Language?: string;
+  PoliticalView?: string;
+  IntendedUse?: SearchNearbyIntendedUse;
+  NextToken?: string;
+  Key?: string;
+}
+export interface SearchNearbyResultItem {
+  PlaceId: string | undefined;
+  PlaceType: PlaceType | undefined;
+  Title: string | undefined;
+  Address?: Address;
+  AddressNumberCorrected?: boolean;
+  Position?: number[];
+  Distance?: number;
+  MapView?: number[];
+  Categories?: Category[];
+  FoodTypes?: FoodType[];
+  BusinessChains?: BusinessChain[];
+  Contacts?: Contacts;
+  OpeningHours?: OpeningHours[];
+  AccessPoints?: AccessPoint[];
+  AccessRestrictions?: AccessRestriction[];
+  TimeZone?: TimeZone;
+  PoliticalView?: string;
+  Phonemes?: PhonemeDetails;
+}
+export interface SearchNearbyResponse {
+  PricingBucket: string | undefined;
+  ResultItems?: SearchNearbyResultItem[];
+  NextToken?: string;
+}
+export declare const SearchTextAdditionalFeature: {
+  readonly ACCESS: "Access";
+  readonly CONTACT: "Contact";
+  readonly PHONEMES: "Phonemes";
+  readonly TIME_ZONE: "TimeZone";
+};
+export type SearchTextAdditionalFeature =
+  (typeof SearchTextAdditionalFeature)[keyof typeof SearchTextAdditionalFeature];
+export interface SearchTextFilter {
+  BoundingBox?: number[];
+  Circle?: FilterCircle;
+  IncludeCountries?: string[];
+}
+export declare const SearchTextIntendedUse: {
+  readonly SINGLE_USE: "SingleUse";
+  readonly STORAGE: "Storage";
+};
+export type SearchTextIntendedUse =
+  (typeof SearchTextIntendedUse)[keyof typeof SearchTextIntendedUse];
+export interface SearchTextRequest {
+  QueryText?: string;
+  QueryId?: string;
+  MaxResults?: number;
+  BiasPosition?: number[];
+  Filter?: SearchTextFilter;
+  AdditionalFeatures?: SearchTextAdditionalFeature[];
+  Language?: string;
+  PoliticalView?: string;
+  IntendedUse?: SearchTextIntendedUse;
+  NextToken?: string;
+  Key?: string;
+}
+export interface SearchTextResultItem {
+  PlaceId: string | undefined;
+  PlaceType: PlaceType | undefined;
+  Title: string | undefined;
+  Address?: Address;
+  AddressNumberCorrected?: boolean;
+  Position?: number[];
+  Distance?: number;
+  MapView?: number[];
+  Categories?: Category[];
+  FoodTypes?: FoodType[];
+  BusinessChains?: BusinessChain[];
+  Contacts?: Contacts;
+  OpeningHours?: OpeningHours[];
+  AccessPoints?: AccessPoint[];
+  AccessRestrictions?: AccessRestriction[];
+  TimeZone?: TimeZone;
+  PoliticalView?: string;
+  Phonemes?: PhonemeDetails;
+}
+export interface SearchTextResponse {
+  PricingBucket: string | undefined;
+  ResultItems?: SearchTextResultItem[];
+  NextToken?: string;
+}
+export declare const SuggestAdditionalFeature: {
+  readonly ACCESS: "Access";
+  readonly CORE: "Core";
+  readonly PHONEMES: "Phonemes";
+  readonly TIME_ZONE: "TimeZone";
+};
+export type SuggestAdditionalFeature =
+  (typeof SuggestAdditionalFeature)[keyof typeof SuggestAdditionalFeature];
+export interface SuggestFilter {
+  BoundingBox?: number[];
+  Circle?: FilterCircle;
+  IncludeCountries?: string[];
+}
+export declare const SuggestIntendedUse: {
+  readonly SINGLE_USE: "SingleUse";
+};
+export type SuggestIntendedUse =
+  (typeof SuggestIntendedUse)[keyof typeof SuggestIntendedUse];
+export interface SuggestRequest {
+  QueryText: string | undefined;
+  MaxResults?: number;
+  MaxQueryRefinements?: number;
+  BiasPosition?: number[];
+  Filter?: SuggestFilter;
+  AdditionalFeatures?: SuggestAdditionalFeature[];
+  Language?: string;
+  PoliticalView?: string;
+  IntendedUse?: SuggestIntendedUse;
+  Key?: string;
+}
+export interface QueryRefinement {
+  RefinedTerm: string | undefined;
+  OriginalTerm: string | undefined;
+  StartIndex: number | undefined;
+  EndIndex: number | undefined;
+}
+export interface SuggestAddressHighlights {
+  Label?: Highlight[];
+}
+export interface SuggestHighlights {
+  Title?: Highlight[];
+  Address?: SuggestAddressHighlights;
+}
+export interface SuggestPlaceResult {
+  PlaceId?: string;
+  PlaceType?: PlaceType;
+  Address?: Address;
+  Position?: number[];
+  Distance?: number;
+  MapView?: number[];
+  Categories?: Category[];
+  FoodTypes?: FoodType[];
+  BusinessChains?: BusinessChain[];
+  AccessPoints?: AccessPoint[];
+  AccessRestrictions?: AccessRestriction[];
+  TimeZone?: TimeZone;
+  PoliticalView?: string;
+  Phonemes?: PhonemeDetails;
+}
+export declare const QueryType: {
+  readonly BUSINESS_CHAIN: "BusinessChain";
+  readonly CATEGORY: "Category";
+};
+export type QueryType = (typeof QueryType)[keyof typeof QueryType];
+export interface SuggestQueryResult {
+  QueryId?: string;
+  QueryType?: QueryType;
+}
+export declare const SuggestResultItemType: {
+  readonly PLACE: "Place";
+  readonly QUERY: "Query";
+};
+export type SuggestResultItemType =
+  (typeof SuggestResultItemType)[keyof typeof SuggestResultItemType];
+export interface SuggestResultItem {
+  Title: string | undefined;
+  SuggestResultItemType: SuggestResultItemType | undefined;
+  Place?: SuggestPlaceResult;
+  Query?: SuggestQueryResult;
+  Highlights?: SuggestHighlights;
+}
+export interface SuggestResponse {
+  PricingBucket: string | undefined;
+  ResultItems?: SuggestResultItem[];
+  QueryRefinements?: QueryRefinement[];
+}
+export declare const AccessPointFilterSensitiveLog: (obj: AccessPoint) => any;
+export declare const FilterCircleFilterSensitiveLog: (obj: FilterCircle) => any;
+export declare const AutocompleteFilterFilterSensitiveLog: (
+  obj: AutocompleteFilter
+) => any;
+export declare const AutocompleteRequestFilterSensitiveLog: (
+  obj: AutocompleteRequest
+) => any;
+export declare const GeocodeQueryComponentsFilterSensitiveLog: (
+  obj: GeocodeQueryComponents
+) => any;
+export declare const GeocodeRequestFilterSensitiveLog: (
+  obj: GeocodeRequest
+) => any;
+export declare const GeocodeResultItemFilterSensitiveLog: (
+  obj: GeocodeResultItem
+) => any;
+export declare const GeocodeResponseFilterSensitiveLog: (
+  obj: GeocodeResponse
+) => any;
+export declare const GetPlaceRequestFilterSensitiveLog: (
+  obj: GetPlaceRequest
+) => any;
+export declare const GetPlaceResponseFilterSensitiveLog: (
+  obj: GetPlaceResponse
+) => any;
+export declare const ReverseGeocodeRequestFilterSensitiveLog: (
+  obj: ReverseGeocodeRequest
+) => any;
+export declare const ReverseGeocodeResultItemFilterSensitiveLog: (
+  obj: ReverseGeocodeResultItem
+) => any;
+export declare const ReverseGeocodeResponseFilterSensitiveLog: (
+  obj: ReverseGeocodeResponse
+) => any;
+export declare const SearchNearbyFilterFilterSensitiveLog: (
+  obj: SearchNearbyFilter
+) => any;
+export declare const SearchNearbyRequestFilterSensitiveLog: (
+  obj: SearchNearbyRequest
+) => any;
+export declare const SearchNearbyResultItemFilterSensitiveLog: (
+  obj: SearchNearbyResultItem
+) => any;
+export declare const SearchNearbyResponseFilterSensitiveLog: (
+  obj: SearchNearbyResponse
+) => any;
+export declare const SearchTextFilterFilterSensitiveLog: (
+  obj: SearchTextFilter
+) => any;
+export declare const SearchTextRequestFilterSensitiveLog: (
+  obj: SearchTextRequest
+) => any;
+export declare const SearchTextResultItemFilterSensitiveLog: (
+  obj: SearchTextResultItem
+) => any;
+export declare const SearchTextResponseFilterSensitiveLog: (
+  obj: SearchTextResponse
+) => any;
+export declare const SuggestFilterFilterSensitiveLog: (
+  obj: SuggestFilter
+) => any;
+export declare const SuggestRequestFilterSensitiveLog: (
+  obj: SuggestRequest
+) => any;
+export declare const SuggestPlaceResultFilterSensitiveLog: (
+  obj: SuggestPlaceResult
+) => any;
+export declare const SuggestResultItemFilterSensitiveLog: (
+  obj: SuggestResultItem
+) => any;
+export declare const SuggestResponseFilterSensitiveLog: (
+  obj: SuggestResponse
+) => any;