Travel Planner MCP Server

/** * Copyright 2020 Google LLC * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ export type RequestParams = ApiKeyParams | PremiumPlanParams; export interface ApiKeyParams { /** * You must include an API key with every API request. We strongly recommend that you restrict your API key. * Restrictions provide added security and help ensure only authorized requests are made with your API key. * * There are two restrictions. You should set both: * * Application restriction: Limits usage of the API key to either websites (HTTP referrers), * web servers (IP addresses), or mobile apps (Android apps or iOS apps). You can select only one * restriction from this category, based on the platform of the API or SDK (see GMP APIs by Platform). * * API restriction: Limits usage of the API key to one or more APIs or SDKs. Requests to an API or SDK * associated with the API key will be processed. Requests to an API or SDK not associated with the API * key will fail. */ key: string; } /** * The Google Maps Platform Premium Plan is no longer available for sign up or new customers. This option is * only provided for maintaining existing legacy applications that use client IDs. For new applications, * please use API keys. * @deprecated */ export interface PremiumPlanParams { /** project client ID */ client_id: string; /** project URL signing secret. Used to create the request signature */ client_secret: string; } export interface ResponseData { /** contains metadata on the request. See Status Codes below. */ status: Status; /** * When the top-level status code is other than `OK`, this field contains more detailed information * about the reasons behind the given status code. */ error_message: string; /** may contain a set of attributions about this listing which must be displayed to the user (some listings may not have attribution). */ html_attributions?: string[]; /** * contains a token that can be used to return up to 20 additional results. * A `next_page_token` will not be returned if there are no additional results to display. * The maximum number of results that can be returned is 60. * There is a short delay between when a `next_page_token` is issued, and when it will become valid. */ next_page_token?: string; } export enum Status { /** indicates the response contains a valid result. */ OK = "OK", /** indicates that the provided request was invalid. */ INVALID_REQUEST = "INVALID_REQUEST", /** * indicates that too many `waypoints` were provided in the request. For applications using the Directions API as a web service, * or the [directions service in the Maps JavaScript API](https://developers.google.com/maps/documentation/javascript/directions), * the maximum allowed number of `waypoints` is 23, plus the origin and destination. */ MAX_WAYPOINTS_EXCEEDED = "MAX_WAYPOINTS_EXCEEDED", /** * indicates the requested route is too long and cannot be processed. * This error occurs when more complex directions are returned. * Try reducing the number of waypoints, turns, or instructions. */ MAX_ROUTE_LENGTH_EXCEEDED = "MAX_ROUTE_LENGTH_EXCEEDED", /** * indicates any of the following: * - The API key is missing or invalid. * - Billing has not been enabled on your account. * - A self-imposed usage cap has been exceeded. * - The provided method of payment is no longer valid (for example, a credit card has expired). * See the [Maps FAQ](https://developers.google.com/maps/faq#over-limit-key-error) to learn how to fix this. */ OVER_DAILY_LIMIT = "OVER_DAILY_LIMIT", /** indicates the service has received too many requests from your application within the allowed time period. */ OVER_QUERY_LIMIT = "OVER_QUERY_LIMIT", /** indicates that the service denied use of the Distance Matrix service by your application. */ REQUEST_DENIED = "REQUEST_DENIED", /** indicates a Distance Matrix request could not be processed due to a server error. The request may succeed if you try again. */ UNKNOWN_ERROR = "UNKNOWN_ERROR", /** indicates that the request was successful but returned no results. */ ZERO_RESULTS = "ZERO_RESULTS", /** indicates that the referenced location (place_id) was not found in the Places database. */ NOT_FOUND = "NOT_FOUND", } export interface PlacePhoto { /** a string used to identify the photo when you perform a Photo request. */ photo_reference: string; /** the maximum height of the image. */ height: number; /** the maximum width of the image. */ width: number; /** contains any required attributions. This field will always be present, but may be empty. */ html_attributions: string[]; } export enum PlaceIdScope { /** * The place ID is recognised by your application only. * This is because your application added the place, and the place has not yet passed the moderation process. */ APP = "APP", /** The place ID is available to other applications and on Google Maps. */ GOOGLE = "GOOGLE", } export interface AlternativePlaceId { /** * The most likely reason for a place to have an alternative place ID is if your application adds a place and receives * an application-scoped place ID, then later receives a Google-scoped place ID after passing the moderation process. */ place_id: string; /** * The scope of an alternative place ID will always be `APP`, * indicating that the alternative place ID is recognised by your application only. */ scope: "APP"; } export enum PlaceInputType { textQuery = "textquery", phoneNumber = "phonenumber", } /** * Table 1: Types supported in place search and addition * * You can use the following values in the types filter for place searches and when adding a place. * * @see https://developers.google.com/places/web-service/supported_types#table1 */ export enum PlaceType1 { accounting = "accounting", /** indicates an airport. */ airport = "airport", amusement_park = "amusement_park", aquarium = "aquarium", art_gallery = "art_gallery", atm = "atm", bakery = "bakery", bank = "bank", bar = "bar", beauty_salon = "beauty_salon", bicycle_store = "bicycle_store", book_store = "book_store", bowling_alley = "bowling_alley", bus_station = "bus_station", cafe = "cafe", campground = "campground", car_dealer = "car_dealer", car_rental = "car_rental", car_repair = "car_repair", car_wash = "car_wash", casino = "casino", cemetery = "cemetery", church = "church", city_hall = "city_hall", clothing_store = "clothing_store", convenience_store = "convenience_store", courthouse = "courthouse", dentist = "dentist", department_store = "department_store", doctor = "doctor", drugstore = "drugstore", electrician = "electrician", electronics_store = "electronics_store", embassy = "embassy", fire_station = "fire_station", florist = "florist", funeral_home = "funeral_home", furniture_store = "furniture_store", gas_station = "gas_station", gym = "gym", hair_care = "hair_care", hardware_store = "hardware_store", hindu_temple = "hindu_temple", home_goods_store = "home_goods_store", hospital = "hospital", insurance_agency = "insurance_agency", jewelry_store = "jewelry_store", laundry = "laundry", lawyer = "lawyer", library = "library", light_rail_station = "light_rail_station", liquor_store = "liquor_store", local_government_office = "local_government_office", locksmith = "locksmith", lodging = "lodging", meal_delivery = "meal_delivery", meal_takeaway = "meal_takeaway", mosque = "mosque", movie_rental = "movie_rental", movie_theater = "movie_theater", moving_company = "moving_company", museum = "museum", night_club = "night_club", painter = "painter", /** indicates a named park. */ park = "park", parking = "parking", pet_store = "pet_store", pharmacy = "pharmacy", physiotherapist = "physiotherapist", plumber = "plumber", police = "police", post_office = "post_office", real_estate_agency = "real_estate_agency", restaurant = "restaurant", roofing_contractor = "roofing_contractor", rv_park = "rv_park", school = "school", secondary_school = "secondary_school", shoe_store = "shoe_store", shopping_mall = "shopping_mall", spa = "spa", stadium = "stadium", storage = "storage", store = "store", subway_station = "subway_station", supermarket = "supermarket", synagogue = "synagogue", taxi_stand = "taxi_stand", tourist_attraction = "tourist_attraction", train_station = "train_station", transit_station = "transit_station", travel_agency = "travel_agency", university = "university", veterinary_care = "veterinary_care", zoo = "zoo", } /** * Table 2: Additional types returned by the Places service * * The following types may be returned in the results of a place search, in addition to the types in table 1 above. * For more details on these types, refer to [Address Types](https://developers.google.com/maps/documentation/geocoding/intro#Types) * in Geocoding Responses. * * @see https://developers.google.com/places/web-service/supported_types#table2 */ export enum PlaceType2 { /** * indicates a first-order civil entity below the country level. Within the United States, these administrative levels are states. * Not all nations exhibit these administrative levels. In most cases, `administrative_area_level_1` short names will closely match * ISO 3166-2 subdivisions and other widely circulated lists; however this is not guaranteed as our geocoding results are based * on a variety of signals and location data. */ administrative_area_level_1 = "administrative_area_level_1", /** * indicates a second-order civil entity below the country level. Within the United States, these administrative levels are counties. * Not all nations exhibit these administrative levels. */ administrative_area_level_2 = "administrative_area_level_2", /** * indicates a third-order civil entity below the country level. This type indicates a minor civil division. * Not all nations exhibit these administrative levels. */ administrative_area_level_3 = "administrative_area_level_3", /** * indicates a fourth-order civil entity below the country level. This type indicates a minor civil division. * Not all nations exhibit these administrative levels. */ administrative_area_level_4 = "administrative_area_level_4", /** * indicates a fifth-order civil entity below the country level. This type indicates a minor civil division. * Not all nations exhibit these administrative levels. */ administrative_area_level_5 = "administrative_area_level_5", archipelago = "archipelago", /** indicates a commonly-used alternative name for the entity. */ colloquial_area = "colloquial_area", continent = "continent", /** indicates the national political entity, and is typically the highest order type returned by the Geocoder. */ country = "country", establishment = "establishment", finance = "finance", floor = "floor", food = "food", general_contractor = "general_contractor", geocode = "geocode", health = "health", /** indicates a major intersection, usually of two major roads. */ intersection = "intersection", landmark = "landmark", /** indicates an incorporated city or town political entity. */ locality = "locality", /** indicates a prominent natural feature. */ natural_feature = "natural_feature", /** indicates a named neighborhood */ neighborhood = "neighborhood", place_of_worship = "place_of_worship", plus_code = "plus_code", point_of_interest = "point_of_interest", /** indicates a political entity. Usually, this type indicates a polygon of some civil administration. */ political = "political", post_box = "post_box", /** indicates a postal code as used to address postal mail within the country. */ postal_code = "postal_code", postal_code_prefix = "postal_code_prefix", postal_code_suffix = "postal_code_suffix", postal_town = "postal_town", /** indicates a named location, usually a building or collection of buildings with a common name */ premise = "premise", room = "room", /** indicates a named route (such as "US 101"). */ route = "route", street_address = "street_address", street_number = "street_number", /** * indicates a first-order civil entity below a locality. For some locations may receive one of the additional types: * `sublocality_level_1` to `sublocality_level_5`. Each sublocality level is a civil entity. Larger numbers indicate a smaller * geographic area. */ sublocality = "sublocality", sublocality_level_1 = "sublocality_level_1", sublocality_level_2 = "sublocality_level_2", sublocality_level_3 = "sublocality_level_3", sublocality_level_4 = "sublocality_level_4", sublocality_level_5 = "sublocality_level_5", /** * indicates a first-order entity below a named location, usually a singular building within a collection of buildings with a * common name. */ subpremise = "subpremise", town_square = "town_square", } export interface PlaceReview { /** * contains a collection of `AspectRating` objects, each of which provides a rating of a single attribute of the establishment. * The first object in the collection is considered the primary aspect. */ aspects: AspectRating[]; /** the name of the user who submitted the review. Anonymous reviews are attributed to "A Google user". */ author_name: string; /** the URL to the user's Google Maps Local Guides profile, if available. */ author_url?: string; /** * an IETF language code indicating the language used in the user's review. * This field contains the main language tag only, and not the secondary tag indicating country or region. * For example, all the English reviews are tagged as 'en', and not 'en-AU' or 'en-UK' and so on. */ language: string; /** the URL to the user's profile photo, if available. */ profile_photo_url: string; /** the user's overall rating for this place. This is a whole number, ranging from 1 to 5. */ rating: number; /* The time since review in relative terms, for example '7 months ago' */ relative_time_description: string; /** * the user's review. When reviewing a location with Google Places, text reviews are considered optional. * Therefore, this field may by empty. Note that this field may include simple HTML markup. * For example, the entity reference `&amp;` may represent an ampersand character. */ text: string; /** the time that the review was submitted, measured in the number of seconds since since midnight, January 1, 1970 UTC. */ time: string; } export interface AspectRating { /** the name of the aspect that is being rated. */ type: AspectRatingType; /** the user's rating for this particular aspect, from 0 to 3. */ rating: number; } export enum AspectRatingType { appeal = "appeal", atmosphere = "atmosphere", decor = "decor", facilities = "facilities", food = "food", overall = "overall", quality = "quality", service = "service", } export type Place = Partial<PlaceData>; export interface PlaceData { /** * is an array containing the separate components applicable to this address. * * Note the following facts about the `address_components[]` array: * - The array of address components may contain more components than the `formatted_address`. * - The array does not necessarily include all the political entities that contain an address, * apart from those included in the `formatted_address`. To retrieve all the political entities * that contain a specific address, you should use reverse geocoding, passing the latitude/longitude * of the address as a parameter to the request. * - The format of the response is not guaranteed to remain the same between requests. * In particular, the number of `address_components` varies based on the address requested * and can change over time for the same address. A component can change position in the array. * The type of the component can change. A particular component may be missing in a later response. */ address_components: AddressComponent[]; /** * is a string containing the human-readable address of this place. * * Often this address is equivalent to the postal address. Note that some countries, such as the United Kingdom, * do not allow distribution of true postal addresses due to licensing restrictions. * * The formatted address is logically composed of one or more address components. * For example, the address "111 8th Avenue, New York, NY" consists of the following components: "111" * (the street number), "8th Avenue" (the route), "New York" (the city) and "NY" (the US state). * * Do not parse the formatted address programmatically. Instead you should use the individual address components, * which the API response includes in addition to the formatted address field. */ formatted_address: string; /** * contains the place's phone number in its local format. * For example, the `formatted_phone_number` for Google's Sydney, Australia office is `(02) 9374 4000`. */ formatted_phone_number: string; /** is a representation of the place's address in the [adr microformat](http://microformats.org/wiki/adr). */ adr_address: string; /** * Contains a summary of the place. A summary is comprised of a textual overview, and also includes the language code * for these if applicable. Summary text must be presented as-is and can not be modified or altered. */ editorial_summary: PlaceEditorialSummary; /** * contains the following information: * - `location`: contains the geocoded latitude,longitude value for this place. * - `viewport`: contains the preferred viewport when displaying this place on a map as a `LatLngBounds` if it is known. */ geometry: AddressGeometry; /** * is an encoded location reference, derived from latitude and longitude coordinates, that represents an area: * 1/8000th of a degree by 1/8000th of a degree (about 14m x 14m at the equator) or smaller. * Plus codes can be used as a replacement for street addresses in places where they do not exist * (where buildings are not numbered or streets are not named). * * The plus code is formatted as a global code and a compound code: * - `global_code` is a 4 character area code and 6 character or longer local code (849VCWC8+R9). * - `compound_code` is a 6 character or longer local code with an explicit location (CWC8+R9, Mountain View, CA, USA). * * Typically, both the global code and compound code are returned. * However, if the result is in a remote location (for example, an ocean or desert) only the global code may be returned. * * @see [Open Location Code](https://en.wikipedia.org/wiki/Open_Location_Code) * @see [plus codes](https://plus.codes/) */ plus_code: PlusCode; /** contains the URL of a suggested icon which may be displayed to the user when indicating this result on a map. */ icon: string; /** * The default HEX color code for the place's category. * @see https://developers.google.com/maps/documentation/places/web-service/icons */ icon_background_color: string; /** * The base URL for a non-colored icon, minus the file type extension (append `.svg` or `.png`). * @see https://developers.google.com/maps/documentation/places/web-service/icons */ icon_mask_base_uri: string; /** * contains the place's phone number in international format. * International format includes the country code, and is prefixed with the plus (+) sign. * For example, the `international_phone_number` for Google's Sydney, Australia office is `+61 2 9374 4000`. */ international_phone_number: string; /** * contains the human-readable name for the returned result. * For establishment results, this is usually the canonicalized business name. */ name: string; /** place opening hours. */ opening_hours: OpeningHours; /** * is a boolean flag indicating whether the place has permanently shut down (value `true`). * If the place is not permanently closed, the flag is absent from the response. This field is deprecated in favor of `business_status`. */ permanently_closed: boolean; /** * is a string indicating the operational status of the place, if it is a business. */ business_status: string; /** * an array of photo objects, each containing a reference to an image. * A Place Details request may return up to ten photos. * More information about place photos and how you can use the images in your application can be found in the Place Photos documentation. */ photos: PlacePhoto[]; /** * A textual identifier that uniquely identifies a place. * To retrieve information about the place, pass this identifier in the `placeId` field of a Places API request. */ place_id: string; /** * The price level of the place, on a scale of 0 to 4. * The exact amount indicated by a specific value will vary from region to region. * * Price levels are interpreted as follows: * - `0`: Free * - `1`: Inexpensive * - `2`: Moderate * - `3`: Expensive * - `4`: Very Expensive */ price_level: number; /** contains the place's rating, from 1.0 to 5.0, based on aggregated user reviews. */ rating: number; /** The total number of ratings from users */ user_ratings_total: number; /** * a JSON array of up to five reviews. If a `language` parameter was specified in the Place Details request, * the Places Service will bias the results to prefer reviews written in that language. */ reviews: PlaceReview[]; /** * contains an array of feature types describing the given result. * XML responses include multiple `<type>` elements if more than one type is assigned to the result. */ types: AddressType[]; /** * contains the URL of the official Google page for this place. * This will be the Google-owned page that contains the best available information about the place. * Applications must link to or embed this page on any screen that shows detailed results about the place to the user. */ url: string; /** * contains the number of minutes this place’s current timezone is offset from UTC. * For example, for places in Sydney, Australia during daylight saving time this would be 660 (+11 hours from UTC), * and for places in California outside of daylight saving time this would be -480 (-8 hours from UTC). */ utc_offset: number; /** * lists a simplified address for the place, including the street name, street number, and locality, * but not the province/state, postal code, or country. For example, Google's Sydney, Australia office * has a `vicinity` value of `48 Pirrama Road, Pyrmont`. */ vicinity: string; /** lists the authoritative website for this place, such as a business' homepage. */ website: string; } export type LatLngArray = [number, number]; export type LatLngString = string; export interface LatLngLiteral { lat: number; lng: number; } export interface LatLngLiteralVerbose { latitude: number; longitude: number; } /** * A latitude, longitude pair. The API methods accept either: * - a two-item array of [latitude, longitude]; * - a comma-separated string; * - an object with 'lat', 'lng' properties; or * - an object with 'latitude', 'longitude' properties. */ export type LatLng = | LatLngArray | LatLngString | LatLngLiteral | LatLngLiteralVerbose; /** The bounds parameter defines the latitude/longitude coordinates of the southwest and northeast corners of this bounding box. */ export interface LatLngBounds { northeast: LatLngLiteral; southwest: LatLngLiteral; } /** * By default the API will attempt to load the most appropriate language based on the users location or browser settings. * Some APIs allow you to explicitly set a language when you make a request * * @see https://developers.google.com/maps/faq#languagesupport */ export enum Language { /** Arabic */ ar = "ar", /** Belarusian */ be = "be", /** Bulgarian */ bg = "bg", /** Bengali */ bn = "bn", /** Catalan */ ca = "ca", /** Czech */ cs = "cs", /** Danish */ da = "da", /** German */ de = "de", /** Greek */ el = "el", /** English */ en = "en", /** English (Australian) */ en_Au = "en-Au", /** English (Great Britain) */ en_GB = "en-GB", /** Spanish */ es = "es", /** Basque */ eu = "eu", /** Farsi */ fa = "fa", /** Finnish */ fi = "fi", /** Filipino */ fil = "fil", /** French */ fr = "fr", /** Galician */ gl = "gl", /** Gujarati */ gu = "gu", /** Hindi */ hi = "hi", /** Croatian */ hr = "hr", /** Hungarian */ hu = "hu", /** Indonesian */ id = "id", /** Italian */ it = "it", /** Hebrew */ iw = "iw", /** Japanese */ ja = "ja", /** Kazakh */ kk = "kk", /** Kannada */ kn = "kn", /** Korean */ ko = "ko", /** Kyrgyz */ ky = "ky", /** Lithuanian */ lt = "lt", /** Latvian */ lv = "lv", /** Macedonian */ mk = "mk", /** Malayalam */ ml = "ml", /** Marathi */ mr = "mr", /** Burmese */ my = "my", /** Dutch */ nl = "nl", /** Norwegian */ no = "no", /** Punjabi */ pa = "pa", /** Polish */ pl = "pl", /** Portuguese */ pt = "pt", /** Portuguese (Brazil) */ pt_BR = "pt-BR", /** Portuguese (Portugal) */ pt_PT = "pt-PT", /** Romanian */ ro = "ro", /** Russian */ ru = "ru", /** Slovak */ sk = "sk", /** Slovenian */ sl = "sl", /** Albanian */ sq = "sq", /** Serbian */ sr = "sr", /** Swedish */ sv = "sv", /** Tamil */ ta = "ta", /** Telugu */ te = "te", /** Thai */ th = "th", /** Tagalog */ tl = "tl", /** Turkish */ tr = "tr", /** Ukrainian */ uk = "uk", /** Uzbek */ uz = "uz", /** Vietnamese */ vi = "vi", /** Chinese (Simlified) */ zh_CN = "zh-CN", /** Chinese (Traditional) */ zh_TW = "zh-TW", } /** * When you calculate directions, you may specify the transportation mode to use. * By default, directions are calculated as `driving` directions. * * **Note:** Both walking and bicycling directions may sometimes not include clear pedestrian or bicycling paths, * so these directions will return warnings in the returned result which you must display to the user. */ export enum TravelMode { /** (default) indicates standard driving directions using the road network. */ driving = "driving", /** requests walking directions via pedestrian paths & sidewalks (where available). */ walking = "walking", /** requests bicycling directions via bicycle paths & preferred streets (where available). */ bicycling = "bicycling", /** * requests directions via public transit routes (where available). * If you set the mode to transit, you can optionally specify either a departure_time or an arrival_time. * If neither time is specified, the departure_time defaults to now (that is, the departure time defaults to the current time). * You can also optionally include a transit_mode and/or a transit_routing_preference. */ transit = "transit", } export enum TravelRestriction { /** indicates that the calculated route should avoid toll roads/bridges. */ tolls = "tolls", /** indicates that the calculated route should avoid highways. */ highways = "highways", /** indicates that the calculated route should avoid ferries. */ ferries = "ferries", /** * indicates that the calculated route should avoid indoor steps for walking and transit directions. * Only requests that include an API key or a Google Maps APIs Premium Plan client ID will receive indoor steps by default. */ indoor = "indoor", } /** * Directions results contain text within distance fields that may be displayed to the user to indicate the distance of * a particular "step" of the route. By default, this text uses the unit system of the origin's country or region. */ export enum UnitSystem { /** specifies usage of the metric system. Textual distances are returned using kilometers and meters. */ metric = "metric", /** specifies usage of the Imperial (English) system. Textual distances are returned using miles and feet. */ imperial = "imperial", } export enum TrafficModel { /** * indicates that the returned `duration_in_traffic` should be the best estimate of travel time given what is known about * both historical traffic conditions and live traffic. Live traffic becomes more important the closer the `departure_time` is to now. */ best_guess = "best_guess", /** * indicates that the returned `duration_in_traffic` should be longer than the actual travel time on most days, * though occasional days with particularly bad traffic conditions may exceed this value. */ pessimistic = "pessimistic", /** * indicates that the returned `duration_in_traffic` should be shorter than the actual travel time on most days, * though occasional days with particularly good traffic conditions may be faster than this value. */ optimistic = "optimistic", } export enum TransitMode { /** indicates that the calculated route should prefer travel by bus. */ bus = "bus", /** indicates that the calculated route should prefer travel by subway. */ subway = "subway", /** indicates that the calculated route should prefer travel by train. */ train = "train", /** indicates that the calculated route should prefer travel by tram and light rail. */ tram = "tram", /** * indicates that the calculated route should prefer travel by train, tram, light rail, and subway. * This is equivalent to `transit_mode=train|tram|subway` */ rail = "rail", } export enum TransitRoutingPreference { /** indicates that the calculated route should prefer limited amounts of walking. */ less_walking = "less_walking", /** indicates that the calculated route should prefer a limited number of transfers. */ fewer_transfers = "fewer_transfers", } /** * The `status` field within the Directions response object contains the status of the request, and may contain debugging information * to help you track down why the Directions service failed. */ export enum DirectionsResponseStatus { /** indicates the response contains a valid `result`. */ OK = "OK", /** indicates at least one of the locations specified in the request's origin, destination, or waypoints could not be geocoded. */ NOT_FOUND = "NOT_FOUND", /** indicates no route could be found between the origin and destination. */ ZERO_RESULTS = "ZERO_RESULTS", /** * indicates that too many `waypoints` were provided in the request. For applications using the Directions API as a web service, * or the [directions service in the Maps JavaScript API](https://developers.google.com/maps/documentation/javascript/directions), * the maximum allowed number of `waypoints` is 23, plus the origin and destination. */ MAX_WAYPOINTS_EXCEEDED = "MAX_WAYPOINTS_EXCEEDED", /** * indicates the requested route is too long and cannot be processed. * This error occurs when more complex directions are returned. * Try reducing the number of waypoints, turns, or instructions. */ MAX_ROUTE_LENGTH_EXCEEDED = "MAX_ROUTE_LENGTH_EXCEEDED", /** indicates that the provided request was invalid. Common causes of this status include an invalid parameter or parameter value. */ INVALID_REQUEST = "INVALID_REQUEST", /** * indicates any of the following: * - The API key is missing or invalid. * - Billing has not been enabled on your account. * - A self-imposed usage cap has been exceeded. * - The provided method of payment is no longer valid (for example, a credit card has expired). * See the [Maps FAQ](https://developers.google.com/maps/faq#over-limit-key-error) to learn how to fix this. */ OVER_DAILY_LIMIT = "OVER_DAILY_LIMIT", /** indicates the service has received too many requests from your application within the allowed time period. */ OVER_QUERY_LIMIT = "OVER_QUERY_LIMIT", /** indicates that the service denied use of the directions service by your application. */ REQUEST_DENIED = "REQUEST_DENIED", /** indicates a directions request could not be processed due to a server error. The request may succeed if you try again. */ UNKNOWN_ERROR = "UNKNOWN_ERROR", } /** * The `status` field within the Directions response object contains the status of the request, and may contain debugging information * to help you track down why the Directions service failed. * @deprecated */ export enum DirectionsReponseStatus { /** indicates the response contains a valid `result`. */ OK = "OK", /** indicates at least one of the locations specified in the request's origin, destination, or waypoints could not be geocoded. */ NOT_FOUND = "NOT_FOUND", /** indicates no route could be found between the origin and destination. */ ZERO_RESULTS = "ZERO_RESULTS", /** * indicates that too many `waypoints` were provided in the request. For applications using the Directions API as a web service, * or the [directions service in the Maps JavaScript API](https://developers.google.com/maps/documentation/javascript/directions), * the maximum allowed number of `waypoints` is 23, plus the origin and destination. */ MAX_WAYPOINTS_EXCEEDED = "MAX_WAYPOINTS_EXCEEDED", /** * indicates the requested route is too long and cannot be processed. * This error occurs when more complex directions are returned. * Try reducing the number of waypoints, turns, or instructions. */ MAX_ROUTE_LENGTH_EXCEEDED = "MAX_ROUTE_LENGTH_EXCEEDED", /** indicates that the provided request was invalid. Common causes of this status include an invalid parameter or parameter value. */ INVALID_REQUEST = "INVALID_REQUEST", /** * indicates any of the following: * - The API key is missing or invalid. * - Billing has not been enabled on your account. * - A self-imposed usage cap has been exceeded. * - The provided method of payment is no longer valid (for example, a credit card has expired). * See the [Maps FAQ](https://developers.google.com/maps/faq#over-limit-key-error) to learn how to fix this. */ OVER_DAILY_LIMIT = "OVER_DAILY_LIMIT", /** indicates the service has received too many requests from your application within the allowed time period. */ OVER_QUERY_LIMIT = "OVER_QUERY_LIMIT", /** indicates that the service denied use of the directions service by your application. */ REQUEST_DENIED = "REQUEST_DENIED", /** indicates a directions request could not be processed due to a server error. The request may succeed if you try again. */ UNKNOWN_ERROR = "UNKNOWN_ERROR", } /** * Elements in the `geocoded_waypoints` array correspond, by their zero-based position, to the origin, * the waypoints in the order they are specified, and the destination. */ export interface GeocodedWaypoint { /** indicates the status code resulting from the geocoding operation. */ geocoder_status: GeocodedWaypointStatus; /** * indicates that the geocoder did not return an exact match for the original request, though it was able to match part of the * requested address. You may wish to examine the original request for misspellings and/or an incomplete address. * * Partial matches most often occur for street addresses that do not exist within the locality you pass in the request. * Partial matches may also be returned when a request matches two or more locations in the same locality. * For example, "21 Henr St, Bristol, UK" will return a partial match for both Henry Street and Henrietta Street. * Note that if a request includes a misspelled address component, the geocoding service may suggest an alternative address. * Suggestions triggered in this way will also be marked as a partial match. */ partial_match: boolean; /** unique identifier that can be used with other Google APIs. */ place_id: string; /** * indicates the *address type* of the geocoding result used for calculating directions. * * An empty list of types indicates there are no known types for the particular address component, for example, Lieu-dit in France. */ types: AddressType[]; } export enum GeocodedWaypointStatus { /** indicates that no errors occurred; the address was successfully parsed and at least one geocode was returned. */ OK = "OK", /** * indicates that the geocode was successful but returned no results. * This may occur if the geocoder was passed a non-existent `address`. */ ZERO_RESULTS = "ZERO_RESULTS", } export const AddressType = Object.assign({}, PlaceType1, PlaceType2); export type AddressType = PlaceType1 | PlaceType2; /** * This route may consist of one or more `legs` depending on whether any waypoints were specified. As well, the route also contains * copyright and warning information which must be displayed to the user in addition to the routing information. */ export interface DirectionsRoute { /** contains a short textual description for the route, suitable for naming and disambiguating the route from alternatives. */ summary: string; /** * contains an array which contains information about a leg of the route, between two locations within the given route. * A separate leg will be present for each waypoint or destination specified. * (A route with no waypoints will contain exactly one leg within the `legs` array.) * Each leg consists of a series of `steps`. */ legs: RouteLeg[]; /** * contains an array indicating the order of any waypoints in the calculated route. * This waypoints may be reordered if the request was passed `optimize:true` within its `waypoints` parameter. */ waypoint_order: number[]; /** * contains a single `points` object that holds an encoded polyline representation of the route. * This polyline is an approximate (smoothed) path of the resulting directions. */ overview_polyline: { points: string; }; /** contains the viewport bounding box of the `overview_polyline`. */ bounds: LatLngBounds; /** contains the copyrights text to be displayed for this route. You must handle and display this information yourself. */ copyrights: string; /** contains an array of warnings to be displayed when showing these directions. You must handle and display these warnings yourself. */ warnings: string[]; /** * If present, contains the total fare (that is, the total ticket costs) on this route. * This property is only returned for transit requests and only for routes where fare information is available for all transit legs. * * **Note:** The Directions API only returns fare information for requests that contain either an API key or a client ID * and digital signature. */ fare: TransitFare; /** * An array of LatLngs representing the entire course of this route. The path is simplified in order to make * it suitable in contexts where a small number of vertices is required (such as Static Maps API URLs). */ overview_path: LatLngLiteral[]; } export interface TransitFare { /** An [ISO 4217 currency code](https://en.wikipedia.org/wiki/ISO_4217) indicating the currency that the amount is expressed in. */ currency: string; /** The total fare amount, in the currency specified above. */ value: number; /** The total fare amount, formatted in the requested language. */ text: string; } /** * A single leg of the journey from the origin to the destination in the calculated route. * For routes that contain no waypoints, the route will consist of a single "leg," but for routes that define one or more waypoints, * the route will consist of one or more legs, corresponding to the specific legs of the journey. */ export interface RouteLeg { /** contains an array of steps denoting information about each separate step of the leg of the journey. */ steps: DirectionsStep[]; /** * indicates the total distance covered by this leg, as a field with the following elements. * * This field may be absent if the distance is unknown. */ distance: Distance; /** * indicates the total duration of this leg. * * This field may be absent if the duration is unknown. */ duration: Duration; /** * indicates the total duration of this leg. * This value is an estimate of the time in traffic based on current and historical traffic conditions. * See the `traffic_model` request parameter for the options you can use to request that the returned value is optimistic, pessimistic, * or a best-guess estimate. The duration in traffic is returned only if all of the following are true: * * - The request includes a valid API key, or a valid Google Maps APIs Premium Plan client ID and signature. * - The request does not include stopover waypoints. If the request includes waypoints, they must be prefixed with `via:` * to avoid stopovers. * - The request is specifically for driving directions—the `mode` parameter is set to `driving`. * - The request includes a `departure_time` parameter. * - Traffic conditions are available for the requested route. */ duration_in_traffic?: Duration; /** contains the estimated time of arrival for this leg. This property is only returned for transit directions. */ arrival_time: Time; /** * contains the estimated time of departure for this leg, specified as a `Time` object. * The `departure_time` is only available for transit directions. */ departure_time: Time; /** * contains the latitude/longitude coordinates of the origin of this leg. * Because the Directions API calculates directions between locations by using the nearest transportation option (usually a road) * at the start and end points, `start_location` may be different than the provided origin of this leg if, for example, * a road is not near the origin. */ start_location: LatLngLiteral; /** * contains the latitude/longitude coordinates of the given destination of this leg. * Because the Directions API calculates directions between locations by using the nearest transportation option (usually a road) * at the start and end points, `end_location` may be different than the provided destination of this leg if, for example, * a road is not near the destination. */ end_location: LatLngLiteral; /** contains the human-readable address (typically a street address) resulting from reverse geocoding the `start_location` of this leg. */ start_address: string; /** contains the human-readable address (typically a street address) from reverse geocoding the `end_location` of this leg. */ end_address: string; } /** * A step is the most atomic unit of a direction's route, containing a single step describing a specific, single instruction on the journey. * E.g. "Turn left at W. 4th St." The step not only describes the instruction but also contains distance and duration information relating to * how this step relates to the following step. For example, a step denoted as "Merge onto I-80 West" may contain a duration of * "37 miles" and "40 minutes," indicating that the next step is 37 miles/40 minutes from this step. * * When using the Directions API to search for transit directions, the steps array will include additional transit details in the form of * a `transit_details` array. If the directions include multiple modes of transportation, detailed directions will be provided for walking or * driving steps in an inner `steps` array. For example, a walking step will include directions from the start and end locations: * "Walk to Innes Ave & Fitch St". That step will include detailed walking directions for that route in the inner `steps` array, such as: * "Head north-west", "Turn left onto Arelious Walker", and "Turn left onto Innes Ave". */ export interface DirectionsStep { /** contains formatted instructions for this step, presented as an HTML text string. */ html_instructions: string; /** * contains the distance covered by this step until the next step. (See the discussion of this field in Directions Legs) * * This field may be undefined if the distance is unknown. */ distance: Distance; /** * contains the typical time required to perform the step, until the next step. (See the description in Directions Legs) * * This field may be undefined if the duration is unknown */ duration: Duration; /** contains the location of the starting point of this step, as a single set of `lat` and `lng` fields. */ start_location: LatLngLiteral; /** contains the location of the last point of this step, as a single set of `lat` and `lng` fields. */ end_location: LatLngLiteral; /** * contains the action to take for the current step (turn left, merge, straight, etc.). * This field is used to determine which icon to display. */ maneuver: Maneuver; /** * contains a single points object that holds an encoded polyline representation of the step. * This polyline is an approximate (smoothed) path of the step. */ polyline: { points: string; }; /** * contains detailed directions for walking or driving steps in transit directions. * Substeps are only available when `travel_mode` is set to "transit". * The inner `steps` array is of the same type as `steps`. */ steps: DirectionsStep; /** contains transit specific information. This field is only returned with travel_mode is set to "transit". */ transit_details: TransitDetails; /** contains the type of travel mode used. */ travel_mode: TravelMode; } export interface Distance { /** indicates the distance in meters. */ value: number; /** * contains a human-readable representation of the distance, displayed in units as used at the origin * (or as overridden within the `units` parameter in the request). * (For example, miles and feet will be used for any origin within the United States.) */ text: string; } export interface Duration { /** indicates the duration in seconds. */ value: number; /** contains a human-readable representation of the duration. */ text: string; } export interface Time { /** the time specified as a JavaScript `Date` object. */ value: Date; /** the time specified as a string. The time is displayed in the time zone of the transit stop. */ text: string; /** * contains the time zone of this station. The value is the name of the time zone as defined in the * [IANA Time Zone Database](http://www.iana.org/time-zones), e.g. "America/New_York". */ time_zone: string; } export enum Maneuver { turn_slight_left = "turn-slight-left", turn_sharp_left = "turn-sharp-left", uturn_left = "uturn-left", turn_left = "turn-left", turn_slight_right = "turn-slight-right", turn_sharp_right = "turn-sharp-right", uturn_right = "uturn-right", turn_right = "turn-right", straight = "straight", ramp_left = "ramp-left", ramp_right = "ramp-right", merge = "merge", fork_left = "fork-left", fork_right = "fork-right", ferry = "ferry", ferry_train = "ferry-train", roundabout_left = "roundabout-left", roundabout_right = "roundabout-right", } /** * Transit directions return additional information that is not relevant for other modes of transportation. * These additional properties are exposed through the `transit_details` object, returned as a field of an element in the `steps[]` array. * From the `TransitDetails` object you can access additional information about the transit stop, transit line and transit agency */ export interface TransitDetails { /** contains information about the stop for this part of the trip. */ arrival_stop: TransitStop; /** contains information about the station for this part of the trip. */ departure_stop: TransitStop; /** contain the arrival time for this leg of the journey. */ arrival_time: Time; /** contain the departure time for this leg of the journey. */ departure_time: Time; /** * specifies the direction in which to travel on this line, as it is marked on the vehicle or at the departure stop. * This will often be the terminus station. */ headsign: string; /** * specifies the expected number of seconds between departures from the same stop at this time. * For example, with a `headway` value of 600, you would expect a ten minute wait if you should miss your bus. */ headway: number; /** * contains the number of stops in this step, counting the arrival stop, but not the departure stop. * For example, if your directions involve leaving from Stop A, passing through stops B and C, and arriving at stop D, * `num_stops` will return 3. */ num_stops: number; /** contains information about the transit line used in this step. */ line: TransitLine; } export interface TransitStop { /** the name of the transit station/stop. eg. "Union Square". */ name: string; /** the location of the transit station/stop, represented as a `lat` and `lng` field. */ location: LatLngLiteral; } export interface TransitLine { /** contains the full name of this transit line. eg. "7 Avenue Express". */ name: string; /** contains the short name of this transit line. This will normally be a line number, such as "M7" or "355". */ short_name: string; /** contains the color commonly used in signage for this transit line. The color will be specified as a hex string such as: #FF0033. */ color: string; /** * is an array containing a single `TransitAgency` object. * The `TransitAgency` object provides information about the operator of the line */ agencies: TransitAgency[]; /** contains the URL for this transit line as provided by the transit agency. */ url: string; /** contains the URL for the icon associated with this line. */ icon: string; /** contains the color of text commonly used for signage of this line. The color will be specified as a hex string. */ text_color: string; /** contains the type of vehicle used on this line. */ vehicle: TransitVehicle; } /** You must display the names and URLs of the transit agencies servicing the trip results. */ export interface TransitAgency { /** contains the name of the transit agency. */ name: string; /** contains the phone number of the transit agency. */ phone: string; /** contains the URL for the transit agency. */ url: string; } export interface TransitVehicle { /** contains the name of the vehicle on this line. eg. "Subway.". */ name: string; /** contains the type of vehicle that runs on this line. */ type: VehicleType; /** contains the URL for an icon associated with this vehicle type. */ icon: string; /** contains the URL for the icon associated with this vehicle type, based on the local transport signage. */ local_icon: string; } /** @see https://developers.google.com/maps/documentation/directions/intro#VehicleType. */ export enum VehicleType { /** Rail. */ RAIL = "RAIL", /** Light rail transit. */ METRO_RAIL = "METRO_RAIL", /** Underground light rail. */ SUBWAY = "SUBWAY", /** Above ground light rail. */ TRAM = "TRAM", /** Monorail. */ MONORAIL = "MONORAIL", /** Heavy rail. */ HEAVY_RAIL = "HEAVY_RAIL", /** Commuter rail. */ COMMUTER_TRAIN = "COMMUTER_TRAIN", /** High speed train. */ HIGH_SPEED_TRAIN = "HIGH_SPEED_TRAIN", /** Bus. */ BUS = "BUS", /** Intercity bus. */ INTERCITY_BUS = "INTERCITY_BUS", /** Trolleybus. */ TROLLEYBUS = "TROLLEYBUS", /** Share taxi is a kind of bus with the ability to drop off and pick up passengers anywhere on its route. */ SHARE_TAXI = "SHARE_TAXI", /** Ferry. */ FERRY = "FERRY", /** A vehicle that operates on a cable, usually on the ground. Aerial cable cars may be of the type `GONDOLA_LIFT`. */ CABLE_CAR = "CABLE_CAR", /** An aerial cable car. */ GONDOLA_LIFT = "GONDOLA_LIFT", /** * A vehicle that is pulled up a steep incline by a cable. * A Funicular typically consists of two cars, with each car acting as a counterweight for the other. */ FUNICULAR = "FUNICULAR", /** All other vehicles will return this type. */ OTHER = "OTHER", } /** * When the Distance Matrix API returns results, it places them within a JSON `rows` array. * Even if no results are returned (such as when the origins and/or destinations don't exist), it still returns an empty array. * XML responses consist of zero or more `<row>` elements. * * Rows are ordered according to the values in the `origin` parameter of the request. * Each row corresponds to an origin, and each `element` within that row corresponds to a pairing of the origin with a `destination` value. * * Each `row` array contains one or more `element` entries, which in turn contain the information about a single origin-destination pairing. */ export interface DistanceMatrixRow { elements: DistanceMatrixRowElement[]; } /** The information about each origin-destination pairing is returned in an `element` entry. */ export interface DistanceMatrixRowElement { /** possible status codes */ status: Status; /** * The length of time it takes to travel this route, expressed in seconds (the `value` field) and as `text`. * The textual representation is localized according to the query's `language` parameter. */ duration: Duration; /** * The length of time it takes to travel this route, based on current and historical traffic conditions. * See the `traffic_model` request parameter for the options you can use to request that the returned value is * `optimistic`, `pessimistic`, or a `best-guess` estimate. The duration is expressed in seconds (the `value` field) and as `text`. * The textual representation is localized according to the query's `language` parameter. * The duration in traffic is returned only if all of the following are true: * - The request includes a `departure_time` parameter. * - The request includes a valid API key, or a valid Google Maps APIs Premium Plan client ID and signature. * - Traffic conditions are available for the requested route. * - The `mode` parameter is set to `driving`. */ duration_in_traffic: Duration; /** * The total distance of this route, expressed in meters (`value`) and as `text`. * The textual value uses the `unit` system specified with the unit parameter of the original request, or the origin's region. */ distance: Distance; /** * If present, contains the total fare (that is, the total ticket costs) on this route. * This property is only returned for transit requests and only for transit providers where fare information is available. */ fare: TransitFare; } export interface OpeningHours { /** is a boolean value indicating if the place is open at the current time. */ open_now: boolean; /** is an array of opening periods covering seven days, starting from Sunday, in chronological order. */ periods: OpeningPeriod[]; /** * is an array of seven strings representing the formatted opening hours for each day of the week. * If a `language` parameter was specified in the Place Details request, the Places Service will format * and localize the opening hours appropriately for that language. The ordering of the elements in this array * depends on the `language` parameter. Some languages start the week on Monday while others start on Sunday. */ weekday_text: string[]; } export interface OpeningPeriod { /** contains a pair of day and time objects describing when the place opens. */ open: OpeningHoursTime; /** * may contain a pair of day and time objects describing when the place closes. * **Note:** If a place is **always open**, the `close` section will be missing from the response. * Clients can rely on always-open being represented as an `open` period containing `day` with value 0 * and `time` with value 0000, and no `close`. */ close?: OpeningHoursTime; } export interface OpeningHoursTime { /** a number from 0–6, corresponding to the days of the week, starting on Sunday. For example, 2 means Tuesday. */ day: number; /** * may contain a time of day in 24-hour hhmm format. Values are in the range 0000–2359. The `time` * will be reported in the place's time zone. */ time?: string; } export interface GeocodeResult { /** * array indicates the type of the returned result. * This array contains a set of zero or more tags identifying the type of feature returned in the result. * For example, a geocode of "Chicago" returns "locality" which indicates that "Chicago" is a city, * and also returns "political" which indicates it is a political entity. */ types: AddressType[]; /** * is a string containing the human-readable address of this location. * * Often this address is equivalent to the postal address. Note that some countries, such as the United Kingdom, * do not allow distribution of true postal addresses due to licensing restrictions. * * The formatted address is logically composed of one or more address components. * For example, the address "111 8th Avenue, New York, NY" consists of the following components: "111" (the street number), * "8th Avenue" (the route), "New York" (the city) and "NY" (the US state). * * Do not parse the formatted address programmatically. Instead you should use the individual address components, * which the API response includes in addition to the formatted address field. */ formatted_address: string; /** * is an array containing the separate components applicable to this address. * * Note the following facts about the `address_components[]` array: * - The array of address components may contain more components than the `formatted_address`. * - The array does not necessarily include all the political entities that contain an address, * apart from those included in the `formatted_address`. To retrieve all the political entities that contain a specific address, * you should use reverse geocoding, passing the latitude/longitude of the address as a parameter to the request. * - The format of the response is not guaranteed to remain the same between requests. * In particular, the number of `address_components` varies based on the address requested and can change * over time for the same address. A component can change position in the array. * The type of the component can change. A particular component may be missing in a later response. */ address_components: AddressComponent[]; /** * is an array denoting all the localities contained in a postal code. * This is only present when the result is a postal code that contains multiple localities. */ postcode_localities: string[]; /** address geometry. */ geometry: AddressGeometry; /** * is an encoded location reference, derived from latitude and longitude coordinates, * that represents an area: 1/8000th of a degree by 1/8000th of a degree (about 14m x 14m at the equator) or smaller. * Plus codes can be used as a replacement for street addresses in places where they do not exist * (where buildings are not numbered or streets are not named). * * The plus code is formatted as a global code and a compound code: * - `global_code` is a 4 character area code and 6 character or longer local code (849VCWC8+R9). * - `compound_code` is a 6 character or longer local code with an explicit location (CWC8+R9, Mountain View, CA, USA). * Typically, both the global code and compound code are returned. However, if the result is in a remote location * (for example, an ocean or desert) only the global code may be returned. * * @see [Open Location Code](https://en.wikipedia.org/wiki/Open_Location_Code) * @see [plus codes](https://plus.codes/) */ plus_code: PlusCode; /** * indicates that the geocoder did not return an exact match for the original request, * though it was able to match part of the requested address. * You may wish to examine the original request for misspellings and/or an incomplete address. * * Partial matches most often occur for street addresses that do not exist within the locality you pass in the request. * Partial matches may also be returned when a request matches two or more locations in the same locality. * For example, "21 Henr St, Bristol, UK" will return a partial match for both Henry Street and Henrietta Street. * Note that if a request includes a misspelled address component, the geocoding service may suggest an alternative address. * Suggestions triggered in this way will also be marked as a partial match. */ partial_match: boolean; /** is a unique identifier that can be used with other Google APIs. */ place_id: string; } export enum GeocodingAddressComponentType { /** indicates the floor of a building address. */ floor = "floor", /** typically indicates a place that has not yet been categorized. */ establishment = "establishment", /** indicates a named point of interest. */ point_of_interest = "point_of_interest", /** indicates a parking lot or parking structure. */ parking = "parking", /** indicates a specific postal box. */ post_box = "post_box", /** indicates a grouping of geographic areas, such as locality and sublocality, used for mailing addresses in some countries. */ postal_town = "postal_town", /** indicates the room of a building address. */ room = "room", /** indicates the precise street number. */ street_number = "street_number", /** indicate the location of a bus. */ bus_station = "bus_station", /** indicate the location of a train. */ train_station = "train_station", /** indicate the location of a public transit stop. */ transit_station = "transit_station", } export interface AddressComponent { /** is an array indicating the *type* of the address component. */ types: Array<AddressType | GeocodingAddressComponentType>; /** is the full text description or name of the address component as returned by the Geocoder. */ long_name: string; /** * is an abbreviated textual name for the address component, if available. * For example, an address component for the state of Alaska may have a `long_name` of "Alaska" and a `short_name` of "AK" * using the 2-letter postal abbreviation. */ short_name: string; } export interface AddressGeometry { /** contains the geocoded latitude, longitude value. For normal address lookups, this field is typically the most important. */ location: LatLngLiteral; /** stores additional data about the specified location. */ location_type?: LocationType; /** * contains the recommended viewport for displaying the returned result, specified as two latitude, longitude values * defining the `southwest` and `northeast` corner of the viewport bounding box. * Generally the viewport is used to frame a result when displaying it to a user. */ viewport: LatLngBounds; /** * (optionally returned) stores the bounding box which can fully contain the returned result. * Note that these bounds may not match the recommended viewport. * (For example, San Francisco includes the [Farallon islands](https://en.wikipedia.org/wiki/Farallon_Islands), * which are technically part of the city, but probably should not be returned in the viewport.) */ bounds?: LatLngBounds; } export enum LocationType { /** * indicates that the returned result is a precise geocode for which we have location information * accurate down to street address precision */ ROOFTOP = "ROOFTOP", /** * indicates that the returned result reflects an approximation (usually on a road) interpolated between two precise points * (such as intersections). Interpolated results are generally returned when rooftop geocodes are unavailable for a street address. */ RANGE_INTERPOLATED = "RANGE_INTERPOLATED", /** * indicates that the returned result is the geometric center of a result such as a polyline * (for example, a street) or polygon (region). */ GEOMETRIC_CENTER = "GEOMETRIC_CENTER", /** indicates that the returned result is approximate. */ APPROXIMATE = "APPROXIMATE", } export interface PlaceEditorialSummary { /** The language of the previous fields. May not always be present. */ language?: string; /** A medium-length textual summary of the place. */ overview?: string; } export interface PlusCode { /** is a 4 character area code and 6 character or longer local code (849VCWC8+R9). */ global_code: string; /** is a 6 character or longer local code with an explicit location (CWC8+R9, Mountain View, CA, USA). */ compound_code: string; } export enum RadioType { lte = "lte", gsm = "gsm", cdma = "cdma", wcdma = "wcdma", } export interface CellTower { /** * Unique identifier of the cell. * On GSM, this is the Cell ID (CID); * CDMA networks use the Base Station ID (BID). * WCDMA networks use the UTRAN/GERAN Cell Identity (UC-Id), which is a 32-bit value concatenating the Radio Network Controller (RNC) * and Cell ID. Specifying only the 16-bit Cell ID value in WCDMA networks may return inaccurate results. */ cellId: number; /** The Location Area Code (LAC) for GSM and WCDMA networks. The Network ID (NID) for CDMA networks. */ locationAreaCode: number; /** The cell tower's Mobile Country Code (MCC). */ mobileCountryCode: number; /** The cell tower's Mobile Network Code. This is the MNC for GSM and WCDMA; CDMA uses the System ID (SID). */ mobileNetworkCode: number; /** The number of milliseconds since this cell was primary. If age is 0, the `cellId` represents a current measurement. */ age?: number; /** Radio signal strength measured in dBm. */ signalStrength?: number; /** The [timing advance](https://en.wikipedia.org/wiki/Timing_advance) value. */ timingAdvance?: number; } export interface WifiAccessPoint { /** The MAC address of the WiFi node. It's typically called a BSS, BSSID or MAC address. Separators must be `:` (colon). */ macAddress: string; /** The current signal strength measured in dBm. */ signalStrength?: number; /** The number of milliseconds since this access point was detected. */ age?: number; /** The channel over which the client is communicating with the acces. */ channel?: number; /** The current signal to noise ratio measured in dB. */ signalToNoiseRatio?: number; } export interface PredictionTerm { /** containing the text of the term. */ value: string; /** start position of this term in the description, measured in Unicode characters. */ offset: number; } export interface PredictionSubstring { /** location of the entered term. */ offset: number; /** length of the entered term. */ length: number; } export interface StructuredFormatting { /** contains the main text of a prediction, usually the name of the place. */ main_text: string; /** * contains an array with `offset` value and `length`. These describe the location of * the entered term in the prediction result text, so that the term can be highlighted if desired. */ main_text_matched_substrings: PredictionSubstring[]; /** contains the secondary text of a prediction, usually the location of the place. */ secondary_text: string; /** * contains an array with `offset` value and `length`. These describe the location of * the entered term in the prediction result secondary text, so that the term can be highlighted if desired. */ secondary_text_matched_substrings: PredictionSubstring[]; } export interface SnappedPoint { /** Contains a `latitude` and `longitude` value. */ location: LatLngLiteralVerbose; /** * An integer that indicates the corresponding value in the original request. * Each point in the request maps to at most two segmentsin the response: * - If there are no nearby roads, no segment is returned. * - If the nearest road is one-way, one segment is returned. * - If the nearest road is bidirectional, two segments are returned. */ originalIndex: number; /** * A unique identifier for a place. All place IDs returned by the Roads API correspond to road segments. * Place IDs can be used with other Google APIs, including the Places SDK and the Maps JavaScript API. * For example, if you need to get road names for the snapped points returned by the Roads API, * you can pass the `placeId` to the Places SDK or the Geocoding API. Within the Roads API, * you can pass the `placeId` in a speed limits request to determine the speed limit along that road segment. */ placeId: string; } /** * Represents a descriptor of an address. * * <p>Please see <a * href="https://mapsplatform.google.com/demos/address-descriptors/">Address * Descriptors</a> for more detail. */ export interface AddressDescriptor { // A ranked list of nearby landmarks. The most useful (recognizable and // nearby) landmarks are ranked first. landmarks: Landmark[]; // A ranked list of containing or adjacent areas. The most useful // (recognizable and precise) areas are ranked first. areas: Area[]; } interface Landmark { // The Place ID of the underlying establishment serving as the landmark. // Can be used to resolve more information about the landmark through Place // Details or Place Id Lookup. placeId: string; // The best name for the landmark. displayName: LocalizedText; // One or more values indicating the type of the returned result. Please see <a // href="https://developers.google.com/maps/documentation/places/web-service/supported_types">Types // </a> for more detail. types: string[]; // Defines the spatial relationship between the target location and the // landmark. spatialRelationship: SpatialRelationship; // The straight line distance between the target location and one of the // landmark's access points. straightLineDistanceMeters: number; // The travel distance along the road network between the target // location's closest point on a road, and the landmark's closest access // point on a road. This can be unpopulated if the landmark is disconnected // from the part of the road network the target is closest to OR if the // target location was not actually considered to be on the road network. travelDistanceMeters: number; } /** * An enum representing the relationship in space between the landmark and the target. */ enum SpatialRelationship { // This is the default relationship when nothing more specific below // applies. NEAR = "NEAR", // The landmark has a spatial geometry and the target is within its // bounds. WITHIN = "WITHIN", // The target is directly adjacent to the landmark or landmark's access // point. BESIDE = "BESIDE", // The target is directly opposite the landmark on the other side of the // road. ACROSS_THE_ROAD = "ACROSS_THE_ROAD", // On the same route as the landmark but not besides or across. DOWN_THE_ROAD = "DOWN_THE_ROAD", // Not on the same route as the landmark but a single 'turn' away. AROUND_THE_CORNER = "AROUND_THE_CORNER", // Close to the landmark's structure but further away from its access // point. BEHIND = "BEHIND", } interface Area { // The Place ID of the underlying area feature. Can be used to // resolve more information about the area through Place Details or // Place Id Lookup. placeId: string; // The best name for the area. displayName: LocalizedText; // Defines the spatial relationship between the target location and the // political region. containment: Containment; } /** * An enum representing the relationship in space between the area and the target. */ enum Containment { /** * Indicates an unknown containment returned by the server. */ CONTAINMENT_UNSPECIFIED = "CONTAINMENT_UNSPECIFIED", /** The target location is within the area region, close to the center. */ WITHIN = "WITHIN", /** The target location is within the area region, close to the edge. */ OUTSKIRTS = "OUTSKIRTS", /** The target location is outside the area region, but close by. */ NEAR = "NEAR", } /** * Localized variant of a text in a particular language. */ interface LocalizedText { // Localized string in the language corresponding to language_code below. text: string; // The text's BCP-47 language code, such as "en-US" or "sr-Latn". // // For more information, see // http://www.unicode.org/reports/tr35/#Unicode_locale_identifier. languageCode: string; }