// Copyright 2022 Luca Casonato. All rights reserved. MIT license.
/**
 * Places API (New) Client for Deno
 * ================================
 * 
 * 
 * 
 * Docs: https://mapsplatform.google.com/maps-products/#places-section
 * Source: https://googleapis.deno.dev/v1/places:v1.ts
 */

import { auth, CredentialsClient, GoogleAuth, request } from "/_/base@v1/mod.ts";
export { auth, GoogleAuth };
export type { CredentialsClient };

export class Places {
  #client: CredentialsClient | undefined;
  #baseUrl: string;

  constructor(client?: CredentialsClient, baseUrl: string = "https://places.googleapis.com/") {
    this.#client = client;
    this.#baseUrl = baseUrl;
  }

  /**
   * Returns predictions for the given input.
   *
   */
  async placesAutocomplete(req: GoogleMapsPlacesV1AutocompletePlacesRequest): Promise<GoogleMapsPlacesV1AutocompletePlacesResponse> {
    const url = new URL(`${this.#baseUrl}v1/places:autocomplete`);
    const body = JSON.stringify(req);
    const data = await request(url.href, {
      client: this.#client,
      method: "POST",
      body,
    });
    return data as GoogleMapsPlacesV1AutocompletePlacesResponse;
  }

  /**
   * Get the details of a place based on its resource name, which is a string
   * in the `places/{place_id}` format.
   *
   * @param name Required. The resource name of a place, in the `places/{place_id}` format.
   */
  async placesGet(name: string, opts: PlacesGetOptions = {}): Promise<GoogleMapsPlacesV1Place> {
    const url = new URL(`${this.#baseUrl}v1/${ name }`);
    if (opts.languageCode !== undefined) {
      url.searchParams.append("languageCode", String(opts.languageCode));
    }
    if (opts.regionCode !== undefined) {
      url.searchParams.append("regionCode", String(opts.regionCode));
    }
    if (opts.sessionToken !== undefined) {
      url.searchParams.append("sessionToken", String(opts.sessionToken));
    }
    const data = await request(url.href, {
      client: this.#client,
      method: "GET",
    });
    return deserializeGoogleMapsPlacesV1Place(data);
  }

  /**
   * Get a photo media with a photo reference string.
   *
   * @param name Required. The resource name of a photo media in the format: `places/{place_id}/photos/{photo_reference}/media`. The resource name of a photo as returned in a Place object's `photos.name` field comes with the format `places/{place_id}/photos/{photo_reference}`. You need to append `/media` at the end of the photo resource to get the photo media resource name.
   */
  async placesPhotosGetMedia(name: string, opts: PlacesPhotosGetMediaOptions = {}): Promise<GoogleMapsPlacesV1PhotoMedia> {
    const url = new URL(`${this.#baseUrl}v1/${ name }`);
    if (opts.maxHeightPx !== undefined) {
      url.searchParams.append("maxHeightPx", String(opts.maxHeightPx));
    }
    if (opts.maxWidthPx !== undefined) {
      url.searchParams.append("maxWidthPx", String(opts.maxWidthPx));
    }
    if (opts.skipHttpRedirect !== undefined) {
      url.searchParams.append("skipHttpRedirect", String(opts.skipHttpRedirect));
    }
    const data = await request(url.href, {
      client: this.#client,
      method: "GET",
    });
    return data as GoogleMapsPlacesV1PhotoMedia;
  }

  /**
   * Search for places near locations.
   *
   */
  async placesSearchNearby(req: GoogleMapsPlacesV1SearchNearbyRequest): Promise<GoogleMapsPlacesV1SearchNearbyResponse> {
    const url = new URL(`${this.#baseUrl}v1/places:searchNearby`);
    const body = JSON.stringify(req);
    const data = await request(url.href, {
      client: this.#client,
      method: "POST",
      body,
    });
    return deserializeGoogleMapsPlacesV1SearchNearbyResponse(data);
  }

  /**
   * Text query based place search.
   *
   */
  async placesSearchText(req: GoogleMapsPlacesV1SearchTextRequest): Promise<GoogleMapsPlacesV1SearchTextResponse> {
    const url = new URL(`${this.#baseUrl}v1/places:searchText`);
    const body = JSON.stringify(req);
    const data = await request(url.href, {
      client: this.#client,
      method: "POST",
      body,
    });
    return deserializeGoogleMapsPlacesV1SearchTextResponse(data);
  }
}

/**
 * A latitude-longitude viewport, represented as two diagonally opposite `low`
 * and `high` points. A viewport is considered a closed region, i.e. it includes
 * its boundary. The latitude bounds must range between -90 to 90 degrees
 * inclusive, and the longitude bounds must range between -180 to 180 degrees
 * inclusive. Various cases include: - If `low` = `high`, the viewport consists
 * of that single point. - If `low.longitude` > `high.longitude`, the longitude
 * range is inverted (the viewport crosses the 180 degree longitude line). - If
 * `low.longitude` = -180 degrees and `high.longitude` = 180 degrees, the
 * viewport includes all longitudes. - If `low.longitude` = 180 degrees and
 * `high.longitude` = -180 degrees, the longitude range is empty. - If
 * `low.latitude` > `high.latitude`, the latitude range is empty. Both `low` and
 * `high` must be populated, and the represented box cannot be empty (as
 * specified by the definitions above). An empty viewport will result in an
 * error. For example, this viewport fully encloses New York City: { "low": {
 * "latitude": 40.477398, "longitude": -74.259087 }, "high": { "latitude":
 * 40.91618, "longitude": -73.70018 } }
 */
export interface GoogleGeoTypeViewport {
  /**
   * Required. The high point of the viewport.
   */
  high?: GoogleTypeLatLng;
  /**
   * Required. The low point of the viewport.
   */
  low?: GoogleTypeLatLng;
}

/**
 * A relational description of a location. Includes a ranked set of nearby
 * landmarks and precise containing areas and their relationship to the target
 * location.
 */
export interface GoogleMapsPlacesV1AddressDescriptor {
  /**
   * A ranked list of containing or adjacent areas. The most recognizable and
   * precise areas are ranked first.
   */
  areas?: GoogleMapsPlacesV1AddressDescriptorArea[];
  /**
   * A ranked list of nearby landmarks. The most recognizable and nearby
   * landmarks are ranked first.
   */
  landmarks?: GoogleMapsPlacesV1AddressDescriptorLandmark[];
}

/**
 * Area information and the area's relationship with the target location. Areas
 * includes precise sublocality, neighborhoods, and large compounds that are
 * useful for describing a location.
 */
export interface GoogleMapsPlacesV1AddressDescriptorArea {
  /**
   * Defines the spatial relationship between the target location and the area.
   */
  containment?:  | "CONTAINMENT_UNSPECIFIED" | "WITHIN" | "OUTSKIRTS" | "NEAR";
  /**
   * The area's display name.
   */
  displayName?: GoogleTypeLocalizedText;
  /**
   * The area's resource name.
   */
  name?: string;
  /**
   * The area's place id.
   */
  placeId?: string;
}

/**
 * Basic landmark information and the landmark's relationship with the target
 * location. Landmarks are prominent places that can be used to describe a
 * location.
 */
export interface GoogleMapsPlacesV1AddressDescriptorLandmark {
  /**
   * The landmark's display name.
   */
  displayName?: GoogleTypeLocalizedText;
  /**
   * The landmark's resource name.
   */
  name?: string;
  /**
   * The landmark's place id.
   */
  placeId?: string;
  /**
   * Defines the spatial relationship between the target location and the
   * landmark.
   */
  spatialRelationship?:  | "NEAR" | "WITHIN" | "BESIDE" | "ACROSS_THE_ROAD" | "DOWN_THE_ROAD" | "AROUND_THE_CORNER" | "BEHIND";
  /**
   * The straight line distance, in meters, between the center point of the
   * target and the center point of the landmark. In some situations, this value
   * can be longer than `travel_distance_meters`.
   */
  straightLineDistanceMeters?: number;
  /**
   * The travel distance, in meters, along the road network from the target to
   * the landmark, if known. This value does not take into account the mode of
   * transportation, such as walking, driving, or biking.
   */
  travelDistanceMeters?: number;
  /**
   * A set of type tags for this landmark. For a complete list of possible
   * values, see
   * https://developers.google.com/maps/documentation/places/web-service/place-types.
   */
  types?: string[];
}

/**
 * Information about the author of the UGC data. Used in Photo, and Review.
 */
export interface GoogleMapsPlacesV1AuthorAttribution {
  /**
   * Name of the author of the Photo or Review.
   */
  displayName?: string;
  /**
   * Profile photo URI of the author of the Photo or Review.
   */
  photoUri?: string;
  /**
   * URI of the author of the Photo or Review.
   */
  uri?: string;
}

/**
 * Request proto for AutocompletePlaces.
 */
export interface GoogleMapsPlacesV1AutocompletePlacesRequest {
  /**
   * Optional. Included primary Place type (for example, "restaurant" or
   * "gas_station") in Place Types
   * (https://developers.google.com/maps/documentation/places/web-service/place-types),
   * or only `(regions)`, or only `(cities)`. A Place is only returned if its
   * primary type is included in this list. Up to 5 values can be specified. If
   * no types are specified, all Place types are returned.
   */
  includedPrimaryTypes?: string[];
  /**
   * Optional. Only include results in the specified regions, specified as up
   * to 15 CLDR two-character region codes. An empty set will not restrict the
   * results. If both `location_restriction` and `included_region_codes` are
   * set, the results will be located in the area of intersection.
   */
  includedRegionCodes?: string[];
  /**
   * Optional. Include pure service area businesses if the field is set to
   * true. Pure service area business is a business that visits or delivers to
   * customers directly but does not serve customers at their business address.
   * For example, businesses like cleaning services or plumbers. Those
   * businesses do not have a physical address or location on Google Maps.
   * Places will not return fields including `location`, `plus_code`, and other
   * location related fields for these businesses.
   */
  includePureServiceAreaBusinesses?: boolean;
  /**
   * Optional. If true, the response will include both Place and query
   * predictions. Otherwise the response will only return Place predictions.
   */
  includeQueryPredictions?: boolean;
  /**
   * Required. The text string on which to search.
   */
  input?: string;
  /**
   * Optional. A zero-based Unicode character offset of `input` indicating the
   * cursor position in `input`. The cursor position may influence what
   * predictions are returned. If empty, defaults to the length of `input`.
   */
  inputOffset?: number;
  /**
   * Optional. The language in which to return results. Defaults to en-US. The
   * results may be in mixed languages if the language used in `input` is
   * different from `language_code` or if the returned Place does not have a
   * translation from the local language to `language_code`.
   */
  languageCode?: string;
  /**
   * Optional. Bias results to a specified location. At most one of
   * `location_bias` or `location_restriction` should be set. If neither are
   * set, the results will be biased by IP address, meaning the IP address will
   * be mapped to an imprecise location and used as a biasing signal.
   */
  locationBias?: GoogleMapsPlacesV1AutocompletePlacesRequestLocationBias;
  /**
   * Optional. Restrict results to a specified location. At most one of
   * `location_bias` or `location_restriction` should be set. If neither are
   * set, the results will be biased by IP address, meaning the IP address will
   * be mapped to an imprecise location and used as a biasing signal.
   */
  locationRestriction?: GoogleMapsPlacesV1AutocompletePlacesRequestLocationRestriction;
  /**
   * Optional. The origin point from which to calculate geodesic distance to
   * the destination (returned as `distance_meters`). If this value is omitted,
   * geodesic distance will not be returned.
   */
  origin?: GoogleTypeLatLng;
  /**
   * Optional. The region code, specified as a CLDR two-character region code.
   * This affects address formatting, result ranking, and may influence what
   * results are returned. This does not restrict results to the specified
   * region. To restrict results to a region, use `region_code_restriction`.
   */
  regionCode?: string;
  /**
   * Optional. A string which identifies an Autocomplete session for billing
   * purposes. Must be a URL and filename safe base64 string with at most 36
   * ASCII characters in length. Otherwise an INVALID_ARGUMENT error is
   * returned. The session begins when the user starts typing a query, and
   * concludes when they select a place and a call to Place Details or Address
   * Validation is made. Each session can have multiple queries, followed by one
   * Place Details or Address Validation request. The credentials used for each
   * request within a session must belong to the same Google Cloud Console
   * project. Once a session has concluded, the token is no longer valid; your
   * app must generate a fresh token for each session. If the `session_token`
   * parameter is omitted, or if you reuse a session token, the session is
   * charged as if no session token was provided (each request is billed
   * separately). We recommend the following guidelines: * Use session tokens
   * for all Place Autocomplete calls. * Generate a fresh token for each
   * session. Using a version 4 UUID is recommended. * Ensure that the
   * credentials used for all Place Autocomplete, Place Details, and Address
   * Validation requests within a session belong to the same Cloud Console
   * project. * Be sure to pass a unique session token for each new session.
   * Using the same token for more than one session will result in each request
   * being billed individually.
   */
  sessionToken?: string;
}

/**
 * The region to search. The results may be biased around the specified region.
 */
export interface GoogleMapsPlacesV1AutocompletePlacesRequestLocationBias {
  /**
   * A circle defined by a center point and radius.
   */
  circle?: GoogleMapsPlacesV1Circle;
  /**
   * A viewport defined by a northeast and a southwest corner.
   */
  rectangle?: GoogleGeoTypeViewport;
}

/**
 * The region to search. The results will be restricted to the specified
 * region.
 */
export interface GoogleMapsPlacesV1AutocompletePlacesRequestLocationRestriction {
  /**
   * A circle defined by a center point and radius.
   */
  circle?: GoogleMapsPlacesV1Circle;
  /**
   * A viewport defined by a northeast and a southwest corner.
   */
  rectangle?: GoogleGeoTypeViewport;
}

/**
 * Response proto for AutocompletePlaces.
 */
export interface GoogleMapsPlacesV1AutocompletePlacesResponse {
  /**
   * Contains a list of suggestions, ordered in descending order of relevance.
   */
  suggestions?: GoogleMapsPlacesV1AutocompletePlacesResponseSuggestion[];
}

/**
 * An Autocomplete suggestion result.
 */
export interface GoogleMapsPlacesV1AutocompletePlacesResponseSuggestion {
  /**
   * A prediction for a Place.
   */
  placePrediction?: GoogleMapsPlacesV1AutocompletePlacesResponseSuggestionPlacePrediction;
  /**
   * A prediction for a query.
   */
  queryPrediction?: GoogleMapsPlacesV1AutocompletePlacesResponseSuggestionQueryPrediction;
}

/**
 * Text representing a Place or query prediction. The text may be used as is or
 * formatted.
 */
export interface GoogleMapsPlacesV1AutocompletePlacesResponseSuggestionFormattableText {
  /**
   * A list of string ranges identifying where the input request matched in
   * `text`. The ranges can be used to format specific parts of `text`. The
   * substrings may not be exact matches of `input` if the matching was
   * determined by criteria other than string matching (for example, spell
   * corrections or transliterations). These values are Unicode character
   * offsets of `text`. The ranges are guaranteed to be ordered in increasing
   * offset values.
   */
  matches?: GoogleMapsPlacesV1AutocompletePlacesResponseSuggestionStringRange[];
  /**
   * Text that may be used as is or formatted with `matches`.
   */
  text?: string;
}

/**
 * Prediction results for a Place Autocomplete prediction.
 */
export interface GoogleMapsPlacesV1AutocompletePlacesResponseSuggestionPlacePrediction {
  /**
   * The length of the geodesic in meters from `origin` if `origin` is
   * specified. Certain predictions such as routes may not populate this field.
   */
  distanceMeters?: number;
  /**
   * The resource name of the suggested Place. This name can be used in other
   * APIs that accept Place names.
   */
  place?: string;
  /**
   * The unique identifier of the suggested Place. This identifier can be used
   * in other APIs that accept Place IDs.
   */
  placeId?: string;
  /**
   * A breakdown of the Place prediction into main text containing the name of
   * the Place and secondary text containing additional disambiguating features
   * (such as a city or region). `structured_format` is recommended for
   * developers who wish to show two separate, but related, UI elements.
   * Developers who wish to show a single UI element may want to use `text`
   * instead. They are two different ways to represent a Place prediction. Users
   * should not try to parse `structured_format` into `text` or vice versa.
   */
  structuredFormat?: GoogleMapsPlacesV1AutocompletePlacesResponseSuggestionStructuredFormat;
  /**
   * Contains the human-readable name for the returned result. For
   * establishment results, this is usually the business name and address.
   * `text` is recommended for developers who wish to show a single UI element.
   * Developers who wish to show two separate, but related, UI elements may want
   * to use `structured_format` instead. They are two different ways to
   * represent a Place prediction. Users should not try to parse
   * `structured_format` into `text` or vice versa. This text may be different
   * from the `display_name` returned by GetPlace. May be in mixed languages if
   * the request `input` and `language_code` are in different languages or if
   * the Place does not have a translation from the local language to
   * `language_code`.
   */
  text?: GoogleMapsPlacesV1AutocompletePlacesResponseSuggestionFormattableText;
  /**
   * List of types that apply to this Place from Table A or Table B in
   * https://developers.google.com/maps/documentation/places/web-service/place-types.
   * A type is a categorization of a Place. Places with shared types will share
   * similar characteristics.
   */
  types?: string[];
}

/**
 * Prediction results for a Query Autocomplete prediction.
 */
export interface GoogleMapsPlacesV1AutocompletePlacesResponseSuggestionQueryPrediction {
  /**
   * A breakdown of the query prediction into main text containing the query
   * and secondary text containing additional disambiguating features (such as a
   * city or region). `structured_format` is recommended for developers who wish
   * to show two separate, but related, UI elements. Developers who wish to show
   * a single UI element may want to use `text` instead. They are two different
   * ways to represent a query prediction. Users should not try to parse
   * `structured_format` into `text` or vice versa.
   */
  structuredFormat?: GoogleMapsPlacesV1AutocompletePlacesResponseSuggestionStructuredFormat;
  /**
   * The predicted text. This text does not represent a Place, but rather a
   * text query that could be used in a search endpoint (for example, Text
   * Search). `text` is recommended for developers who wish to show a single UI
   * element. Developers who wish to show two separate, but related, UI elements
   * may want to use `structured_format` instead. They are two different ways to
   * represent a query prediction. Users should not try to parse
   * `structured_format` into `text` or vice versa. May be in mixed languages if
   * the request `input` and `language_code` are in different languages or if
   * part of the query does not have a translation from the local language to
   * `language_code`.
   */
  text?: GoogleMapsPlacesV1AutocompletePlacesResponseSuggestionFormattableText;
}

/**
 * Identifies a substring within a given text.
 */
export interface GoogleMapsPlacesV1AutocompletePlacesResponseSuggestionStringRange {
  /**
   * Zero-based offset of the last Unicode character (exclusive).
   */
  endOffset?: number;
  /**
   * Zero-based offset of the first Unicode character of the string
   * (inclusive).
   */
  startOffset?: number;
}

/**
 * Contains a breakdown of a Place or query prediction into main text and
 * secondary text. For Place predictions, the main text contains the specific
 * name of the Place. For query predictions, the main text contains the query.
 * The secondary text contains additional disambiguating features (such as a
 * city or region) to further identify the Place or refine the query.
 */
export interface GoogleMapsPlacesV1AutocompletePlacesResponseSuggestionStructuredFormat {
  /**
   * Represents the name of the Place or query.
   */
  mainText?: GoogleMapsPlacesV1AutocompletePlacesResponseSuggestionFormattableText;
  /**
   * Represents additional disambiguating features (such as a city or region)
   * to further identify the Place or refine the query.
   */
  secondaryText?: GoogleMapsPlacesV1AutocompletePlacesResponseSuggestionFormattableText;
}

/**
 * Circle with a LatLng as center and radius.
 */
export interface GoogleMapsPlacesV1Circle {
  /**
   * Required. Center latitude and longitude. The range of latitude must be
   * within [-90.0, 90.0]. The range of the longitude must be within [-180.0,
   * 180.0].
   */
  center?: GoogleTypeLatLng;
  /**
   * Required. Radius measured in meters. The radius must be within [0.0,
   * 50000.0].
   */
  radius?: number;
}

/**
 * A block of content that can be served individually.
 */
export interface GoogleMapsPlacesV1ContentBlock {
  /**
   * Content related to the topic.
   */
  content?: GoogleTypeLocalizedText;
  /**
   * Experimental: See
   * https://developers.google.com/maps/documentation/places/web-service/experimental/places-generative
   * for more details. References that are related to this block of content.
   */
  references?: GoogleMapsPlacesV1References;
  /**
   * The topic of the content, for example "overview" or "restaurant".
   */
  topic?: string;
}

function serializeGoogleMapsPlacesV1ContentBlock(data: any): GoogleMapsPlacesV1ContentBlock {
  return {
    ...data,
    references: data["references"] !== undefined ? serializeGoogleMapsPlacesV1References(data["references"]) : undefined,
  };
}

function deserializeGoogleMapsPlacesV1ContentBlock(data: any): GoogleMapsPlacesV1ContentBlock {
  return {
    ...data,
    references: data["references"] !== undefined ? deserializeGoogleMapsPlacesV1References(data["references"]) : undefined,
  };
}

/**
 * Experimental: See
 * https://developers.google.com/maps/documentation/places/web-service/experimental/places-generative
 * for more details. Content that is contextual to the place query.
 */
export interface GoogleMapsPlacesV1ContextualContent {
  /**
   * Experimental: See
   * https://developers.google.com/maps/documentation/places/web-service/experimental/places-generative
   * for more details. Justifications for the place.
   */
  justifications?: GoogleMapsPlacesV1ContextualContentJustification[];
  /**
   * Information (including references) about photos of this place, contexual
   * to the place query.
   */
  photos?: GoogleMapsPlacesV1Photo[];
  /**
   * List of reviews about this place, contexual to the place query.
   */
  reviews?: GoogleMapsPlacesV1Review[];
}

function serializeGoogleMapsPlacesV1ContextualContent(data: any): GoogleMapsPlacesV1ContextualContent {
  return {
    ...data,
    justifications: data["justifications"] !== undefined ? data["justifications"].map((item: any) => (serializeGoogleMapsPlacesV1ContextualContentJustification(item))) : undefined,
    reviews: data["reviews"] !== undefined ? data["reviews"].map((item: any) => (serializeGoogleMapsPlacesV1Review(item))) : undefined,
  };
}

function deserializeGoogleMapsPlacesV1ContextualContent(data: any): GoogleMapsPlacesV1ContextualContent {
  return {
    ...data,
    justifications: data["justifications"] !== undefined ? data["justifications"].map((item: any) => (deserializeGoogleMapsPlacesV1ContextualContentJustification(item))) : undefined,
    reviews: data["reviews"] !== undefined ? data["reviews"].map((item: any) => (deserializeGoogleMapsPlacesV1Review(item))) : undefined,
  };
}

/**
 * Experimental: See
 * https://developers.google.com/maps/documentation/places/web-service/experimental/places-generative
 * for more details. Justifications for the place. Justifications answers the
 * question of why a place could interest an end user.
 */
export interface GoogleMapsPlacesV1ContextualContentJustification {
  /**
   * Experimental: See
   * https://developers.google.com/maps/documentation/places/web-service/experimental/places-generative
   * for more details.
   */
  businessAvailabilityAttributesJustification?: GoogleMapsPlacesV1ContextualContentJustificationBusinessAvailabilityAttributesJustification;
  /**
   * Experimental: See
   * https://developers.google.com/maps/documentation/places/web-service/experimental/places-generative
   * for more details.
   */
  reviewJustification?: GoogleMapsPlacesV1ContextualContentJustificationReviewJustification;
}

function serializeGoogleMapsPlacesV1ContextualContentJustification(data: any): GoogleMapsPlacesV1ContextualContentJustification {
  return {
    ...data,
    reviewJustification: data["reviewJustification"] !== undefined ? serializeGoogleMapsPlacesV1ContextualContentJustificationReviewJustification(data["reviewJustification"]) : undefined,
  };
}

function deserializeGoogleMapsPlacesV1ContextualContentJustification(data: any): GoogleMapsPlacesV1ContextualContentJustification {
  return {
    ...data,
    reviewJustification: data["reviewJustification"] !== undefined ? deserializeGoogleMapsPlacesV1ContextualContentJustificationReviewJustification(data["reviewJustification"]) : undefined,
  };
}

/**
 * Experimental: See
 * https://developers.google.com/maps/documentation/places/web-service/experimental/places-generative
 * for more details. BusinessAvailabilityAttributes justifications. This shows
 * some attributes a business has that could interest an end user.
 */
export interface GoogleMapsPlacesV1ContextualContentJustificationBusinessAvailabilityAttributesJustification {
  /**
   * If a place provides delivery.
   */
  delivery?: boolean;
  /**
   * If a place provides dine-in.
   */
  dineIn?: boolean;
  /**
   * If a place provides takeout.
   */
  takeout?: boolean;
}

/**
 * Experimental: See
 * https://developers.google.com/maps/documentation/places/web-service/experimental/places-generative
 * for more details. User review justifications. This highlights a section of
 * the user review that would interest an end user. For instance, if the search
 * query is "firewood pizza", the review justification highlights the text
 * relevant to the search query.
 */
export interface GoogleMapsPlacesV1ContextualContentJustificationReviewJustification {
  highlightedText?: GoogleMapsPlacesV1ContextualContentJustificationReviewJustificationHighlightedText;
  /**
   * The review that the highlighted text is generated from.
   */
  review?: GoogleMapsPlacesV1Review;
}

function serializeGoogleMapsPlacesV1ContextualContentJustificationReviewJustification(data: any): GoogleMapsPlacesV1ContextualContentJustificationReviewJustification {
  return {
    ...data,
    review: data["review"] !== undefined ? serializeGoogleMapsPlacesV1Review(data["review"]) : undefined,
  };
}

function deserializeGoogleMapsPlacesV1ContextualContentJustificationReviewJustification(data: any): GoogleMapsPlacesV1ContextualContentJustificationReviewJustification {
  return {
    ...data,
    review: data["review"] !== undefined ? deserializeGoogleMapsPlacesV1Review(data["review"]) : undefined,
  };
}

/**
 * The text highlighted by the justification. This is a subset of the review
 * itself. The exact word to highlight is marked by the HighlightedTextRange.
 * There could be several words in the text being highlighted.
 */
export interface GoogleMapsPlacesV1ContextualContentJustificationReviewJustificationHighlightedText {
  /**
   * The list of the ranges of the highlighted text.
   */
  highlightedTextRanges?: GoogleMapsPlacesV1ContextualContentJustificationReviewJustificationHighlightedTextHighlightedTextRange[];
  text?: string;
}

/**
 * The range of highlighted text.
 */
export interface GoogleMapsPlacesV1ContextualContentJustificationReviewJustificationHighlightedTextHighlightedTextRange {
  endIndex?: number;
  startIndex?: number;
}

/**
 * Information about the EV Charge Station hosted in Place. Terminology follows
 * https://afdc.energy.gov/fuels/electricity_infrastructure.html One port could
 * charge one car at a time. One port has one or more connectors. One station
 * has one or more ports.
 */
export interface GoogleMapsPlacesV1EVChargeOptions {
  /**
   * A list of EV charging connector aggregations that contain connectors of
   * the same type and same charge rate.
   */
  connectorAggregation?: GoogleMapsPlacesV1EVChargeOptionsConnectorAggregation[];
  /**
   * Number of connectors at this station. However, because some ports can have
   * multiple connectors but only be able to charge one car at a time (e.g.) the
   * number of connectors may be greater than the total number of cars which can
   * charge simultaneously.
   */
  connectorCount?: number;
}

function serializeGoogleMapsPlacesV1EVChargeOptions(data: any): GoogleMapsPlacesV1EVChargeOptions {
  return {
    ...data,
    connectorAggregation: data["connectorAggregation"] !== undefined ? data["connectorAggregation"].map((item: any) => (serializeGoogleMapsPlacesV1EVChargeOptionsConnectorAggregation(item))) : undefined,
  };
}

function deserializeGoogleMapsPlacesV1EVChargeOptions(data: any): GoogleMapsPlacesV1EVChargeOptions {
  return {
    ...data,
    connectorAggregation: data["connectorAggregation"] !== undefined ? data["connectorAggregation"].map((item: any) => (deserializeGoogleMapsPlacesV1EVChargeOptionsConnectorAggregation(item))) : undefined,
  };
}

/**
 * EV charging information grouped by [type, max_charge_rate_kw]. Shows EV
 * charge aggregation of connectors that have the same type and max charge rate
 * in kw.
 */
export interface GoogleMapsPlacesV1EVChargeOptionsConnectorAggregation {
  /**
   * The timestamp when the connector availability information in this
   * aggregation was last updated.
   */
  availabilityLastUpdateTime?: Date;
  /**
   * Number of connectors in this aggregation that are currently available.
   */
  availableCount?: number;
  /**
   * Number of connectors in this aggregation.
   */
  count?: number;
  /**
   * The static max charging rate in kw of each connector in the aggregation.
   */
  maxChargeRateKw?: number;
  /**
   * Number of connectors in this aggregation that are currently out of
   * service.
   */
  outOfServiceCount?: number;
  /**
   * The connector type of this aggregation.
   */
  type?:  | "EV_CONNECTOR_TYPE_UNSPECIFIED" | "EV_CONNECTOR_TYPE_OTHER" | "EV_CONNECTOR_TYPE_J1772" | "EV_CONNECTOR_TYPE_TYPE_2" | "EV_CONNECTOR_TYPE_CHADEMO" | "EV_CONNECTOR_TYPE_CCS_COMBO_1" | "EV_CONNECTOR_TYPE_CCS_COMBO_2" | "EV_CONNECTOR_TYPE_TESLA" | "EV_CONNECTOR_TYPE_UNSPECIFIED_GB_T" | "EV_CONNECTOR_TYPE_UNSPECIFIED_WALL_OUTLET";
}

function serializeGoogleMapsPlacesV1EVChargeOptionsConnectorAggregation(data: any): GoogleMapsPlacesV1EVChargeOptionsConnectorAggregation {
  return {
    ...data,
    availabilityLastUpdateTime: data["availabilityLastUpdateTime"] !== undefined ? data["availabilityLastUpdateTime"].toISOString() : undefined,
  };
}

function deserializeGoogleMapsPlacesV1EVChargeOptionsConnectorAggregation(data: any): GoogleMapsPlacesV1EVChargeOptionsConnectorAggregation {
  return {
    ...data,
    availabilityLastUpdateTime: data["availabilityLastUpdateTime"] !== undefined ? new Date(data["availabilityLastUpdateTime"]) : undefined,
  };
}

/**
 * The most recent information about fuel options in a gas station. This
 * information is updated regularly.
 */
export interface GoogleMapsPlacesV1FuelOptions {
  /**
   * The last known fuel price for each type of fuel this station has. There is
   * one entry per fuel type this station has. Order is not important.
   */
  fuelPrices?: GoogleMapsPlacesV1FuelOptionsFuelPrice[];
}

function serializeGoogleMapsPlacesV1FuelOptions(data: any): GoogleMapsPlacesV1FuelOptions {
  return {
    ...data,
    fuelPrices: data["fuelPrices"] !== undefined ? data["fuelPrices"].map((item: any) => (serializeGoogleMapsPlacesV1FuelOptionsFuelPrice(item))) : undefined,
  };
}

function deserializeGoogleMapsPlacesV1FuelOptions(data: any): GoogleMapsPlacesV1FuelOptions {
  return {
    ...data,
    fuelPrices: data["fuelPrices"] !== undefined ? data["fuelPrices"].map((item: any) => (deserializeGoogleMapsPlacesV1FuelOptionsFuelPrice(item))) : undefined,
  };
}

/**
 * Fuel price information for a given type.
 */
export interface GoogleMapsPlacesV1FuelOptionsFuelPrice {
  /**
   * The price of the fuel.
   */
  price?: GoogleTypeMoney;
  /**
   * The type of fuel.
   */
  type?:  | "FUEL_TYPE_UNSPECIFIED" | "DIESEL" | "REGULAR_UNLEADED" | "MIDGRADE" | "PREMIUM" | "SP91" | "SP91_E10" | "SP92" | "SP95" | "SP95_E10" | "SP98" | "SP99" | "SP100" | "LPG" | "E80" | "E85" | "METHANE" | "BIO_DIESEL" | "TRUCK_DIESEL";
  /**
   * The time the fuel price was last updated.
   */
  updateTime?: Date;
}

function serializeGoogleMapsPlacesV1FuelOptionsFuelPrice(data: any): GoogleMapsPlacesV1FuelOptionsFuelPrice {
  return {
    ...data,
    price: data["price"] !== undefined ? serializeGoogleTypeMoney(data["price"]) : undefined,
    updateTime: data["updateTime"] !== undefined ? data["updateTime"].toISOString() : undefined,
  };
}

function deserializeGoogleMapsPlacesV1FuelOptionsFuelPrice(data: any): GoogleMapsPlacesV1FuelOptionsFuelPrice {
  return {
    ...data,
    price: data["price"] !== undefined ? deserializeGoogleTypeMoney(data["price"]) : undefined,
    updateTime: data["updateTime"] !== undefined ? new Date(data["updateTime"]) : undefined,
  };
}

/**
 * Information about a photo of a place.
 */
export interface GoogleMapsPlacesV1Photo {
  /**
   * This photo's authors.
   */
  authorAttributions?: GoogleMapsPlacesV1AuthorAttribution[];
  /**
   * A link where users can flag a problem with the photo.
   */
  flagContentUri?: string;
  /**
   * A link to show the photo on Google Maps.
   */
  googleMapsUri?: string;
  /**
   * The maximum available height, in pixels.
   */
  heightPx?: number;
  /**
   * Identifier. A reference representing this place photo which may be used to
   * look up this place photo again (also called the API "resource" name:
   * `places/{place_id}/photos/{photo}`).
   */
  name?: string;
  /**
   * The maximum available width, in pixels.
   */
  widthPx?: number;
}

/**
 * A photo media from Places API.
 */
export interface GoogleMapsPlacesV1PhotoMedia {
  /**
   * The resource name of a photo media in the format:
   * `places/{place_id}/photos/{photo_reference}/media`.
   */
  name?: string;
  /**
   * A short-lived uri that can be used to render the photo.
   */
  photoUri?: string;
}

/**
 * All the information representing a Place.
 */
export interface GoogleMapsPlacesV1Place {
  /**
   * Information about the accessibility options a place offers.
   */
  accessibilityOptions?: GoogleMapsPlacesV1PlaceAccessibilityOptions;
  /**
   * Repeated components for each locality level. 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.
   */
  addressComponents?: GoogleMapsPlacesV1PlaceAddressComponent[];
  /**
   * The address descriptor of the place. Address descriptors include
   * additional information that help describe a location using landmarks and
   * areas. See address descriptor regional coverage in
   * https://developers.google.com/maps/documentation/geocoding/address-descriptors/coverage.
   */
  addressDescriptor?: GoogleMapsPlacesV1AddressDescriptor;
  /**
   * The place's address in adr microformat: http://microformats.org/wiki/adr.
   */
  adrFormatAddress?: string;
  /**
   * Place allows dogs.
   */
  allowsDogs?: boolean;
  /**
   * Experimental: See
   * https://developers.google.com/maps/documentation/places/web-service/experimental/places-generative
   * for more details. AI-generated summary of the area that the place is in.
   */
  areaSummary?: GoogleMapsPlacesV1PlaceAreaSummary;
  /**
   * A set of data provider that must be shown with this result.
   */
  attributions?: GoogleMapsPlacesV1PlaceAttribution[];
  /**
   * The business status for the place.
   */
  businessStatus?:  | "BUSINESS_STATUS_UNSPECIFIED" | "OPERATIONAL" | "CLOSED_TEMPORARILY" | "CLOSED_PERMANENTLY";
  /**
   * List of places in which the current place is located.
   */
  containingPlaces?: GoogleMapsPlacesV1PlaceContainingPlace[];
  /**
   * Specifies if the business supports curbside pickup.
   */
  curbsidePickup?: boolean;
  /**
   * The hours of operation for the next seven days (including today). The time
   * period starts at midnight on the date of the request and ends at 11:59 pm
   * six days later. This field includes the special_days subfield of all hours,
   * set for dates that have exceptional hours.
   */
  currentOpeningHours?: GoogleMapsPlacesV1PlaceOpeningHours;
  /**
   * Contains an array of entries for the next seven days including information
   * about secondary hours of a business. Secondary hours are different from a
   * business's main hours. For example, a restaurant can specify drive through
   * hours or delivery hours as its secondary hours. This field populates the
   * type subfield, which draws from a predefined list of opening hours types
   * (such as DRIVE_THROUGH, PICKUP, or TAKEOUT) based on the types of the
   * place. This field includes the special_days subfield of all hours, set for
   * dates that have exceptional hours.
   */
  currentSecondaryOpeningHours?: GoogleMapsPlacesV1PlaceOpeningHours[];
  /**
   * Specifies if the business supports delivery.
   */
  delivery?: boolean;
  /**
   * Specifies if the business supports indoor or outdoor seating options.
   */
  dineIn?: boolean;
  /**
   * The localized name of the place, suitable as a short human-readable
   * description. For example, "Google Sydney", "Starbucks", "Pyrmont", etc.
   */
  displayName?: GoogleTypeLocalizedText;
  /**
   * 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.
   */
  editorialSummary?: GoogleTypeLocalizedText;
  /**
   * Information of ev charging options.
   */
  evChargeOptions?: GoogleMapsPlacesV1EVChargeOptions;
  /**
   * A full, human-readable address for this place.
   */
  formattedAddress?: string;
  /**
   * The most recent information about fuel options in a gas station. This
   * information is updated regularly.
   */
  fuelOptions?: GoogleMapsPlacesV1FuelOptions;
  /**
   * Experimental: See
   * https://developers.google.com/maps/documentation/places/web-service/experimental/places-generative
   * for more details. AI-generated summary of the place.
   */
  generativeSummary?: GoogleMapsPlacesV1PlaceGenerativeSummary;
  /**
   * Place is good for children.
   */
  goodForChildren?: boolean;
  /**
   * Place accommodates groups.
   */
  goodForGroups?: boolean;
  /**
   * Place is suitable for watching sports.
   */
  goodForWatchingSports?: boolean;
  /**
   * Links to trigger different Google Maps actions.
   */
  googleMapsLinks?: GoogleMapsPlacesV1PlaceGoogleMapsLinks;
  /**
   * A URL providing more information about this place.
   */
  googleMapsUri?: string;
  /**
   * Background color for icon_mask in hex format, e.g. #909CE1.
   */
  iconBackgroundColor?: string;
  /**
   * A truncated URL to an icon mask. User can access different icon type by
   * appending type suffix to the end (eg, ".svg" or ".png").
   */
  iconMaskBaseUri?: string;
  /**
   * The unique identifier of a place.
   */
  id?: string;
  /**
   * A human-readable phone number for the place, in international format.
   */
  internationalPhoneNumber?: string;
  /**
   * Place provides live music.
   */
  liveMusic?: boolean;
  /**
   * The position of this place.
   */
  location?: GoogleTypeLatLng;
  /**
   * Place has a children's menu.
   */
  menuForChildren?: boolean;
  /**
   * This Place's resource name, in `places/{place_id}` format. Can be used to
   * look up the Place.
   */
  name?: string;
  /**
   * A human-readable phone number for the place, in national format.
   */
  nationalPhoneNumber?: string;
  /**
   * Place provides outdoor seating.
   */
  outdoorSeating?: boolean;
  /**
   * Options of parking provided by the place.
   */
  parkingOptions?: GoogleMapsPlacesV1PlaceParkingOptions;
  /**
   * Payment options the place accepts. If a payment option data is not
   * available, the payment option field will be unset.
   */
  paymentOptions?: GoogleMapsPlacesV1PlacePaymentOptions;
  /**
   * Information (including references) about photos of this place. A maximum
   * of 10 photos can be returned.
   */
  photos?: GoogleMapsPlacesV1Photo[];
  /**
   * Plus code of the place location lat/long.
   */
  plusCode?: GoogleMapsPlacesV1PlacePlusCode;
  /**
   * Price level of the place.
   */
  priceLevel?:  | "PRICE_LEVEL_UNSPECIFIED" | "PRICE_LEVEL_FREE" | "PRICE_LEVEL_INEXPENSIVE" | "PRICE_LEVEL_MODERATE" | "PRICE_LEVEL_EXPENSIVE" | "PRICE_LEVEL_VERY_EXPENSIVE";
  /**
   * The price range associated with a Place.
   */
  priceRange?: GoogleMapsPlacesV1PriceRange;
  /**
   * The primary type of the given result. This type must one of the Places API
   * supported types. For example, "restaurant", "cafe", "airport", etc. A place
   * can only have a single primary type. For the complete list of possible
   * values, see Table A and Table B at
   * https://developers.google.com/maps/documentation/places/web-service/place-types
   */
  primaryType?: string;
  /**
   * The display name of the primary type, localized to the request language if
   * applicable. For the complete list of possible values, see Table A and Table
   * B at
   * https://developers.google.com/maps/documentation/places/web-service/place-types
   */
  primaryTypeDisplayName?: GoogleTypeLocalizedText;
  /**
   * Indicates whether the place is a pure service area business. Pure service
   * area business is a business that visits or delivers to customers directly
   * but does not serve customers at their business address. For example,
   * businesses like cleaning services or plumbers. Those businesses may not
   * have a physical address or location on Google Maps.
   */
  pureServiceAreaBusiness?: boolean;
  /**
   * A rating between 1.0 and 5.0, based on user reviews of this place.
   */
  rating?: number;
  /**
   * The regular hours of operation. Note that if a place is always open (24
   * hours), the `close` field will not be set. Clients can rely on always open
   * (24 hours) being represented as an `open` period containing day with value
   * `0`, hour with value `0`, and minute with value `0`.
   */
  regularOpeningHours?: GoogleMapsPlacesV1PlaceOpeningHours;
  /**
   * Contains an array of entries for information about regular secondary hours
   * of a business. Secondary hours are different from a business's main hours.
   * For example, a restaurant can specify drive through hours or delivery hours
   * as its secondary hours. This field populates the type subfield, which draws
   * from a predefined list of opening hours types (such as DRIVE_THROUGH,
   * PICKUP, or TAKEOUT) based on the types of the place.
   */
  regularSecondaryOpeningHours?: GoogleMapsPlacesV1PlaceOpeningHours[];
  /**
   * Specifies if the place supports reservations.
   */
  reservable?: boolean;
  /**
   * Place has restroom.
   */
  restroom?: boolean;
  /**
   * List of reviews about this place, sorted by relevance. A maximum of 5
   * reviews can be returned.
   */
  reviews?: GoogleMapsPlacesV1Review[];
  /**
   * Specifies if the place serves beer.
   */
  servesBeer?: boolean;
  /**
   * Specifies if the place serves breakfast.
   */
  servesBreakfast?: boolean;
  /**
   * Specifies if the place serves brunch.
   */
  servesBrunch?: boolean;
  /**
   * Place serves cocktails.
   */
  servesCocktails?: boolean;
  /**
   * Place serves coffee.
   */
  servesCoffee?: boolean;
  /**
   * Place serves dessert.
   */
  servesDessert?: boolean;
  /**
   * Specifies if the place serves dinner.
   */
  servesDinner?: boolean;
  /**
   * Specifies if the place serves lunch.
   */
  servesLunch?: boolean;
  /**
   * Specifies if the place serves vegetarian food.
   */
  servesVegetarianFood?: boolean;
  /**
   * Specifies if the place serves wine.
   */
  servesWine?: boolean;
  /**
   * A short, human-readable address for this place.
   */
  shortFormattedAddress?: string;
  /**
   * A list of sub destinations related to the place.
   */
  subDestinations?: GoogleMapsPlacesV1PlaceSubDestination[];
  /**
   * Specifies if the business supports takeout.
   */
  takeout?: boolean;
  /**
   * A set of type tags for this result. For example, "political" and
   * "locality". For the complete list of possible values, see Table A and Table
   * B at
   * https://developers.google.com/maps/documentation/places/web-service/place-types
   */
  types?: string[];
  /**
   * The total number of reviews (with or without text) for this place.
   */
  userRatingCount?: number;
  /**
   * Number of minutes this place's timezone is currently offset from UTC. This
   * is expressed in minutes to support timezones that are offset by fractions
   * of an hour, e.g. X hours and 15 minutes.
   */
  utcOffsetMinutes?: number;
  /**
   * A viewport suitable for displaying the place on an average-sized map. This
   * viewport should not be used as the physical boundary or the service area of
   * the business.
   */
  viewport?: GoogleGeoTypeViewport;
  /**
   * The authoritative website for this place, e.g. a business' homepage. Note
   * that for places that are part of a chain (e.g. an IKEA store), this will
   * usually be the website for the individual store, not the overall chain.
   */
  websiteUri?: string;
}

function serializeGoogleMapsPlacesV1Place(data: any): GoogleMapsPlacesV1Place {
  return {
    ...data,
    areaSummary: data["areaSummary"] !== undefined ? serializeGoogleMapsPlacesV1PlaceAreaSummary(data["areaSummary"]) : undefined,
    currentOpeningHours: data["currentOpeningHours"] !== undefined ? serializeGoogleMapsPlacesV1PlaceOpeningHours(data["currentOpeningHours"]) : undefined,
    currentSecondaryOpeningHours: data["currentSecondaryOpeningHours"] !== undefined ? data["currentSecondaryOpeningHours"].map((item: any) => (serializeGoogleMapsPlacesV1PlaceOpeningHours(item))) : undefined,
    evChargeOptions: data["evChargeOptions"] !== undefined ? serializeGoogleMapsPlacesV1EVChargeOptions(data["evChargeOptions"]) : undefined,
    fuelOptions: data["fuelOptions"] !== undefined ? serializeGoogleMapsPlacesV1FuelOptions(data["fuelOptions"]) : undefined,
    generativeSummary: data["generativeSummary"] !== undefined ? serializeGoogleMapsPlacesV1PlaceGenerativeSummary(data["generativeSummary"]) : undefined,
    priceRange: data["priceRange"] !== undefined ? serializeGoogleMapsPlacesV1PriceRange(data["priceRange"]) : undefined,
    regularOpeningHours: data["regularOpeningHours"] !== undefined ? serializeGoogleMapsPlacesV1PlaceOpeningHours(data["regularOpeningHours"]) : undefined,
    regularSecondaryOpeningHours: data["regularSecondaryOpeningHours"] !== undefined ? data["regularSecondaryOpeningHours"].map((item: any) => (serializeGoogleMapsPlacesV1PlaceOpeningHours(item))) : undefined,
    reviews: data["reviews"] !== undefined ? data["reviews"].map((item: any) => (serializeGoogleMapsPlacesV1Review(item))) : undefined,
  };
}

function deserializeGoogleMapsPlacesV1Place(data: any): GoogleMapsPlacesV1Place {
  return {
    ...data,
    areaSummary: data["areaSummary"] !== undefined ? deserializeGoogleMapsPlacesV1PlaceAreaSummary(data["areaSummary"]) : undefined,
    currentOpeningHours: data["currentOpeningHours"] !== undefined ? deserializeGoogleMapsPlacesV1PlaceOpeningHours(data["currentOpeningHours"]) : undefined,
    currentSecondaryOpeningHours: data["currentSecondaryOpeningHours"] !== undefined ? data["currentSecondaryOpeningHours"].map((item: any) => (deserializeGoogleMapsPlacesV1PlaceOpeningHours(item))) : undefined,
    evChargeOptions: data["evChargeOptions"] !== undefined ? deserializeGoogleMapsPlacesV1EVChargeOptions(data["evChargeOptions"]) : undefined,
    fuelOptions: data["fuelOptions"] !== undefined ? deserializeGoogleMapsPlacesV1FuelOptions(data["fuelOptions"]) : undefined,
    generativeSummary: data["generativeSummary"] !== undefined ? deserializeGoogleMapsPlacesV1PlaceGenerativeSummary(data["generativeSummary"]) : undefined,
    priceRange: data["priceRange"] !== undefined ? deserializeGoogleMapsPlacesV1PriceRange(data["priceRange"]) : undefined,
    regularOpeningHours: data["regularOpeningHours"] !== undefined ? deserializeGoogleMapsPlacesV1PlaceOpeningHours(data["regularOpeningHours"]) : undefined,
    regularSecondaryOpeningHours: data["regularSecondaryOpeningHours"] !== undefined ? data["regularSecondaryOpeningHours"].map((item: any) => (deserializeGoogleMapsPlacesV1PlaceOpeningHours(item))) : undefined,
    reviews: data["reviews"] !== undefined ? data["reviews"].map((item: any) => (deserializeGoogleMapsPlacesV1Review(item))) : undefined,
  };
}

/**
 * Information about the accessibility options a place offers.
 */
export interface GoogleMapsPlacesV1PlaceAccessibilityOptions {
  /**
   * Places has wheelchair accessible entrance.
   */
  wheelchairAccessibleEntrance?: boolean;
  /**
   * Place offers wheelchair accessible parking.
   */
  wheelchairAccessibleParking?: boolean;
  /**
   * Place has wheelchair accessible restroom.
   */
  wheelchairAccessibleRestroom?: boolean;
  /**
   * Place has wheelchair accessible seating.
   */
  wheelchairAccessibleSeating?: boolean;
}

/**
 * The structured components that form the formatted address, if this
 * information is available.
 */
export interface GoogleMapsPlacesV1PlaceAddressComponent {
  /**
   * The language used to format this components, in CLDR notation.
   */
  languageCode?: string;
  /**
   * The full text description or name of the address component. For example,
   * an address component for the country Australia may have a long_name of
   * "Australia".
   */
  longText?: string;
  /**
   * An abbreviated textual name for the address component, if available. For
   * example, an address component for the country of Australia may have a
   * short_name of "AU".
   */
  shortText?: string;
  /**
   * An array indicating the type(s) of the address component.
   */
  types?: string[];
}

/**
 * Experimental: See
 * https://developers.google.com/maps/documentation/places/web-service/experimental/places-generative
 * for more details. AI-generated summary of the area that the place is in.
 */
export interface GoogleMapsPlacesV1PlaceAreaSummary {
  /**
   * Content blocks that compose the area summary. Each block has a separate
   * topic about the area.
   */
  contentBlocks?: GoogleMapsPlacesV1ContentBlock[];
  /**
   * A link where users can flag a problem with the summary.
   */
  flagContentUri?: string;
}

function serializeGoogleMapsPlacesV1PlaceAreaSummary(data: any): GoogleMapsPlacesV1PlaceAreaSummary {
  return {
    ...data,
    contentBlocks: data["contentBlocks"] !== undefined ? data["contentBlocks"].map((item: any) => (serializeGoogleMapsPlacesV1ContentBlock(item))) : undefined,
  };
}

function deserializeGoogleMapsPlacesV1PlaceAreaSummary(data: any): GoogleMapsPlacesV1PlaceAreaSummary {
  return {
    ...data,
    contentBlocks: data["contentBlocks"] !== undefined ? data["contentBlocks"].map((item: any) => (deserializeGoogleMapsPlacesV1ContentBlock(item))) : undefined,
  };
}

/**
 * Information about data providers of this place.
 */
export interface GoogleMapsPlacesV1PlaceAttribution {
  /**
   * Name of the Place's data provider.
   */
  provider?: string;
  /**
   * URI to the Place's data provider.
   */
  providerUri?: string;
}

/**
 * Info about the place in which this place is located.
 */
export interface GoogleMapsPlacesV1PlaceContainingPlace {
  /**
   * The place id of the place in which this place is located.
   */
  id?: string;
  /**
   * The resource name of the place in which this place is located.
   */
  name?: string;
}

/**
 * Experimental: See
 * https://developers.google.com/maps/documentation/places/web-service/experimental/places-generative
 * for more details. AI-generated summary of the place.
 */
export interface GoogleMapsPlacesV1PlaceGenerativeSummary {
  /**
   * The detailed description of the place.
   */
  description?: GoogleTypeLocalizedText;
  /**
   * A link where users can flag a problem with the description summary.
   */
  descriptionFlagContentUri?: string;
  /**
   * The overview of the place.
   */
  overview?: GoogleTypeLocalizedText;
  /**
   * A link where users can flag a problem with the overview summary.
   */
  overviewFlagContentUri?: string;
  /**
   * References that are used to generate the summary description.
   */
  references?: GoogleMapsPlacesV1References;
}

function serializeGoogleMapsPlacesV1PlaceGenerativeSummary(data: any): GoogleMapsPlacesV1PlaceGenerativeSummary {
  return {
    ...data,
    references: data["references"] !== undefined ? serializeGoogleMapsPlacesV1References(data["references"]) : undefined,
  };
}

function deserializeGoogleMapsPlacesV1PlaceGenerativeSummary(data: any): GoogleMapsPlacesV1PlaceGenerativeSummary {
  return {
    ...data,
    references: data["references"] !== undefined ? deserializeGoogleMapsPlacesV1References(data["references"]) : undefined,
  };
}

/**
 * Links to trigger different Google Maps actions.
 */
export interface GoogleMapsPlacesV1PlaceGoogleMapsLinks {
  /**
   * A link to show the directions to the place. The link only populates the
   * destination location and uses the default travel mode `DRIVE`.
   */
  directionsUri?: string;
  /**
   * A link to show photos of this place. This link is currently not supported
   * on Google Maps Mobile and only works on the web version of Google Maps.
   */
  photosUri?: string;
  /**
   * A link to show this place.
   */
  placeUri?: string;
  /**
   * A link to show reviews of this place. This link is currently not supported
   * on Google Maps Mobile and only works on the web version of Google Maps.
   */
  reviewsUri?: string;
  /**
   * A link to write a review for this place. This link is currently not
   * supported on Google Maps Mobile and only works on the web version of Google
   * Maps.
   */
  writeAReviewUri?: string;
}

/**
 * Information about business hour of the place.
 */
export interface GoogleMapsPlacesV1PlaceOpeningHours {
  /**
   * The next time the current opening hours period ends up to 7 days in the
   * future. This field is only populated if the opening hours period is active
   * at the time of serving the request.
   */
  nextCloseTime?: Date;
  /**
   * The next time the current opening hours period starts up to 7 days in the
   * future. This field is only populated if the opening hours period is not
   * active at the time of serving the request.
   */
  nextOpenTime?: Date;
  /**
   * Whether the opening hours period is currently active. For regular opening
   * hours and current opening hours, this field means whether the place is
   * open. For secondary opening hours and current secondary opening hours, this
   * field means whether the secondary hours of this place is active.
   */
  openNow?: boolean;
  /**
   * The periods that this place is open during the week. The periods are in
   * chronological order, starting with Sunday in the place-local timezone. An
   * empty (but not absent) value indicates a place that is never open, e.g.
   * because it is closed temporarily for renovations.
   */
  periods?: GoogleMapsPlacesV1PlaceOpeningHoursPeriod[];
  /**
   * A type string used to identify the type of secondary hours.
   */
  secondaryHoursType?:  | "SECONDARY_HOURS_TYPE_UNSPECIFIED" | "DRIVE_THROUGH" | "HAPPY_HOUR" | "DELIVERY" | "TAKEOUT" | "KITCHEN" | "BREAKFAST" | "LUNCH" | "DINNER" | "BRUNCH" | "PICKUP" | "ACCESS" | "SENIOR_HOURS" | "ONLINE_SERVICE_HOURS";
  /**
   * Structured information for special days that fall within the period that
   * the returned opening hours cover. Special days are days that could impact
   * the business hours of a place, e.g. Christmas day. Set for
   * current_opening_hours and current_secondary_opening_hours if there are
   * exceptional hours.
   */
  specialDays?: GoogleMapsPlacesV1PlaceOpeningHoursSpecialDay[];
  /**
   * Localized strings describing the opening hours of this place, one string
   * for each day of the week. Will be empty if the hours are unknown or could
   * not be converted to localized text. Example: "Sun: 18:00–06:00"
   */
  weekdayDescriptions?: string[];
}

function serializeGoogleMapsPlacesV1PlaceOpeningHours(data: any): GoogleMapsPlacesV1PlaceOpeningHours {
  return {
    ...data,
    nextCloseTime: data["nextCloseTime"] !== undefined ? data["nextCloseTime"].toISOString() : undefined,
    nextOpenTime: data["nextOpenTime"] !== undefined ? data["nextOpenTime"].toISOString() : undefined,
  };
}

function deserializeGoogleMapsPlacesV1PlaceOpeningHours(data: any): GoogleMapsPlacesV1PlaceOpeningHours {
  return {
    ...data,
    nextCloseTime: data["nextCloseTime"] !== undefined ? new Date(data["nextCloseTime"]) : undefined,
    nextOpenTime: data["nextOpenTime"] !== undefined ? new Date(data["nextOpenTime"]) : undefined,
  };
}

/**
 * A period the place remains in open_now status.
 */
export interface GoogleMapsPlacesV1PlaceOpeningHoursPeriod {
  /**
   * The time that the place starts to be closed.
   */
  close?: GoogleMapsPlacesV1PlaceOpeningHoursPeriodPoint;
  /**
   * The time that the place starts to be open.
   */
  open?: GoogleMapsPlacesV1PlaceOpeningHoursPeriodPoint;
}

/**
 * Status changing points.
 */
export interface GoogleMapsPlacesV1PlaceOpeningHoursPeriodPoint {
  /**
   * Date in the local timezone for the place.
   */
  date?: GoogleTypeDate;
  /**
   * A day of the week, as an integer in the range 0-6. 0 is Sunday, 1 is
   * Monday, etc.
   */
  day?: number;
  /**
   * The hour in 24 hour format. Ranges from 0 to 23.
   */
  hour?: number;
  /**
   * The minute. Ranges from 0 to 59.
   */
  minute?: number;
  /**
   * Whether or not this endpoint was truncated. Truncation occurs when the
   * real hours are outside the times we are willing to return hours between, so
   * we truncate the hours back to these boundaries. This ensures that at most
   * 24 * 7 hours from midnight of the day of the request are returned.
   */
  truncated?: boolean;
}

/**
 * Structured information for special days that fall within the period that the
 * returned opening hours cover. Special days are days that could impact the
 * business hours of a place, e.g. Christmas day.
 */
export interface GoogleMapsPlacesV1PlaceOpeningHoursSpecialDay {
  /**
   * The date of this special day.
   */
  date?: GoogleTypeDate;
}

/**
 * Information about parking options for the place. A parking lot could support
 * more than one option at the same time.
 */
export interface GoogleMapsPlacesV1PlaceParkingOptions {
  /**
   * Place offers free garage parking.
   */
  freeGarageParking?: boolean;
  /**
   * Place offers free parking lots.
   */
  freeParkingLot?: boolean;
  /**
   * Place offers free street parking.
   */
  freeStreetParking?: boolean;
  /**
   * Place offers paid garage parking.
   */
  paidGarageParking?: boolean;
  /**
   * Place offers paid parking lots.
   */
  paidParkingLot?: boolean;
  /**
   * Place offers paid street parking.
   */
  paidStreetParking?: boolean;
  /**
   * Place offers valet parking.
   */
  valetParking?: boolean;
}

/**
 * Payment options the place accepts.
 */
export interface GoogleMapsPlacesV1PlacePaymentOptions {
  /**
   * Place accepts cash only as payment. Places with this attribute may still
   * accept other payment methods.
   */
  acceptsCashOnly?: boolean;
  /**
   * Place accepts credit cards as payment.
   */
  acceptsCreditCards?: boolean;
  /**
   * Place accepts debit cards as payment.
   */
  acceptsDebitCards?: boolean;
  /**
   * Place accepts NFC payments.
   */
  acceptsNfc?: boolean;
}

/**
 * Plus code (http://plus.codes) is a location reference with two formats:
 * global code defining a 14mx14m (1/8000th of a degree) or smaller rectangle,
 * and compound code, replacing the prefix with a reference location.
 */
export interface GoogleMapsPlacesV1PlacePlusCode {
  /**
   * Place's compound code, such as "33GV+HQ, Ramberg, Norway", containing the
   * suffix of the global code and replacing the prefix with a formatted name of
   * a reference entity.
   */
  compoundCode?: string;
  /**
   * Place's global (full) code, such as "9FWM33GV+HQ", representing an 1/8000
   * by 1/8000 degree area (~14 by 14 meters).
   */
  globalCode?: string;
}

/**
 * Place resource name and id of sub destinations that relate to the place. For
 * example, different terminals are different destinations of an airport.
 */
export interface GoogleMapsPlacesV1PlaceSubDestination {
  /**
   * The place id of the sub destination.
   */
  id?: string;
  /**
   * The resource name of the sub destination.
   */
  name?: string;
}

/**
 * A route polyline. Only supports an [encoded
 * polyline](https://developers.google.com/maps/documentation/utilities/polylinealgorithm),
 * which can be passed as a string and includes compression with minimal
 * lossiness. This is the Routes API default output.
 */
export interface GoogleMapsPlacesV1Polyline {
  /**
   * An [encoded
   * polyline](https://developers.google.com/maps/documentation/utilities/polylinealgorithm),
   * as returned by the [Routes API by
   * default](https://developers.google.com/maps/documentation/routes/reference/rest/v2/TopLevel/computeRoutes#polylineencoding).
   * See the
   * [encoder](https://developers.google.com/maps/documentation/utilities/polylineutility)
   * and
   * [decoder](https://developers.google.com/maps/documentation/routes/polylinedecoder)
   * tools.
   */
  encodedPolyline?: string;
}

/**
 * The price range associated with a Place. `end_price` could be unset, which
 * indicates a range without upper bound (e.g. "More than $100").
 */
export interface GoogleMapsPlacesV1PriceRange {
  /**
   * The high end of the price range (exclusive). Price should be lower than
   * this amount.
   */
  endPrice?: GoogleTypeMoney;
  /**
   * The low end of the price range (inclusive). Price should be at or above
   * this amount.
   */
  startPrice?: GoogleTypeMoney;
}

function serializeGoogleMapsPlacesV1PriceRange(data: any): GoogleMapsPlacesV1PriceRange {
  return {
    ...data,
    endPrice: data["endPrice"] !== undefined ? serializeGoogleTypeMoney(data["endPrice"]) : undefined,
    startPrice: data["startPrice"] !== undefined ? serializeGoogleTypeMoney(data["startPrice"]) : undefined,
  };
}

function deserializeGoogleMapsPlacesV1PriceRange(data: any): GoogleMapsPlacesV1PriceRange {
  return {
    ...data,
    endPrice: data["endPrice"] !== undefined ? deserializeGoogleTypeMoney(data["endPrice"]) : undefined,
    startPrice: data["startPrice"] !== undefined ? deserializeGoogleTypeMoney(data["startPrice"]) : undefined,
  };
}

/**
 * Experimental: See
 * https://developers.google.com/maps/documentation/places/web-service/experimental/places-generative
 * for more details. Reference that the generative content is related to.
 */
export interface GoogleMapsPlacesV1References {
  /**
   * The list of resource names of the referenced places. This name can be used
   * in other APIs that accept Place resource names.
   */
  places?: string[];
  /**
   * Reviews that serve as references.
   */
  reviews?: GoogleMapsPlacesV1Review[];
}

function serializeGoogleMapsPlacesV1References(data: any): GoogleMapsPlacesV1References {
  return {
    ...data,
    reviews: data["reviews"] !== undefined ? data["reviews"].map((item: any) => (serializeGoogleMapsPlacesV1Review(item))) : undefined,
  };
}

function deserializeGoogleMapsPlacesV1References(data: any): GoogleMapsPlacesV1References {
  return {
    ...data,
    reviews: data["reviews"] !== undefined ? data["reviews"].map((item: any) => (deserializeGoogleMapsPlacesV1Review(item))) : undefined,
  };
}

/**
 * Information about a review of a place.
 */
export interface GoogleMapsPlacesV1Review {
  /**
   * This review's author.
   */
  authorAttribution?: GoogleMapsPlacesV1AuthorAttribution;
  /**
   * A link where users can flag a problem with the review.
   */
  flagContentUri?: string;
  /**
   * A link to show the review on Google Maps.
   */
  googleMapsUri?: string;
  /**
   * A reference representing this place review which may be used to look up
   * this place review again (also called the API "resource" name:
   * `places/{place_id}/reviews/{review}`).
   */
  name?: string;
  /**
   * The review text in its original language.
   */
  originalText?: GoogleTypeLocalizedText;
  /**
   * Timestamp for the review.
   */
  publishTime?: Date;
  /**
   * A number between 1.0 and 5.0, also called the number of stars.
   */
  rating?: number;
  /**
   * A string of formatted recent time, expressing the review time relative to
   * the current time in a form appropriate for the language and country.
   */
  relativePublishTimeDescription?: string;
  /**
   * The localized text of the review.
   */
  text?: GoogleTypeLocalizedText;
}

function serializeGoogleMapsPlacesV1Review(data: any): GoogleMapsPlacesV1Review {
  return {
    ...data,
    publishTime: data["publishTime"] !== undefined ? data["publishTime"].toISOString() : undefined,
  };
}

function deserializeGoogleMapsPlacesV1Review(data: any): GoogleMapsPlacesV1Review {
  return {
    ...data,
    publishTime: data["publishTime"] !== undefined ? new Date(data["publishTime"]) : undefined,
  };
}

/**
 * Encapsulates a set of optional conditions to satisfy when calculating the
 * routes.
 */
export interface GoogleMapsPlacesV1RouteModifiers {
  /**
   * Optional. When set to true, avoids ferries where reasonable, giving
   * preference to routes not containing ferries. Applies only to the `DRIVE`
   * and `TWO_WHEELER` `TravelMode`.
   */
  avoidFerries?: boolean;
  /**
   * Optional. When set to true, avoids highways where reasonable, giving
   * preference to routes not containing highways. Applies only to the `DRIVE`
   * and `TWO_WHEELER` `TravelMode`.
   */
  avoidHighways?: boolean;
  /**
   * Optional. When set to true, avoids navigating indoors where reasonable,
   * giving preference to routes not containing indoor navigation. Applies only
   * to the `WALK` `TravelMode`.
   */
  avoidIndoor?: boolean;
  /**
   * Optional. When set to true, avoids toll roads where reasonable, giving
   * preference to routes not containing toll roads. Applies only to the `DRIVE`
   * and `TWO_WHEELER` `TravelMode`.
   */
  avoidTolls?: boolean;
}

/**
 * Parameters to configure the routing calculations to the places in the
 * response, both along a route (where result ranking will be influenced) and
 * for calculating travel times on results.
 */
export interface GoogleMapsPlacesV1RoutingParameters {
  /**
   * Optional. An explicit routing origin that overrides the origin defined in
   * the polyline. By default, the polyline origin is used.
   */
  origin?: GoogleTypeLatLng;
  /**
   * Optional. The route modifiers.
   */
  routeModifiers?: GoogleMapsPlacesV1RouteModifiers;
  /**
   * Optional. Specifies how to compute the routing summaries. The server
   * attempts to use the selected routing preference to compute the route. The
   * traffic aware routing preference is only available for the `DRIVE` or
   * `TWO_WHEELER` `travelMode`.
   */
  routingPreference?:  | "ROUTING_PREFERENCE_UNSPECIFIED" | "TRAFFIC_UNAWARE" | "TRAFFIC_AWARE" | "TRAFFIC_AWARE_OPTIMAL";
  /**
   * Optional. The travel mode.
   */
  travelMode?:  | "TRAVEL_MODE_UNSPECIFIED" | "DRIVE" | "BICYCLE" | "WALK" | "TWO_WHEELER";
}

/**
 * The duration and distance from the routing origin to a place in the
 * response, and a second leg from that place to the destination, if requested.
 * **Note:** Adding `routingSummaries` in the field mask without also including
 * either the `routingParameters.origin` parameter or the
 * `searchAlongRouteParameters.polyline.encodedPolyline` parameter in the
 * request causes an error.
 */
export interface GoogleMapsPlacesV1RoutingSummary {
  /**
   * A link to show directions on Google Maps using the waypoints from the
   * given routing summary. The route generated by this link is not guaranteed
   * to be the same as the route used to generate the routing summary. The link
   * uses information provided in the request, from fields including
   * `routingParameters` and `searchAlongRouteParameters` when applicable, to
   * generate the directions link.
   */
  directionsUri?: string;
  /**
   * The legs of the trip. When you calculate travel duration and distance from
   * a set origin, `legs` contains a single leg containing the duration and
   * distance from the origin to the destination. When you do a search along
   * route, `legs` contains two legs: one from the origin to place, and one from
   * the place to the destination.
   */
  legs?: GoogleMapsPlacesV1RoutingSummaryLeg[];
}

function serializeGoogleMapsPlacesV1RoutingSummary(data: any): GoogleMapsPlacesV1RoutingSummary {
  return {
    ...data,
    legs: data["legs"] !== undefined ? data["legs"].map((item: any) => (serializeGoogleMapsPlacesV1RoutingSummaryLeg(item))) : undefined,
  };
}

function deserializeGoogleMapsPlacesV1RoutingSummary(data: any): GoogleMapsPlacesV1RoutingSummary {
  return {
    ...data,
    legs: data["legs"] !== undefined ? data["legs"].map((item: any) => (deserializeGoogleMapsPlacesV1RoutingSummaryLeg(item))) : undefined,
  };
}

/**
 * A leg is a single portion of a journey from one location to another.
 */
export interface GoogleMapsPlacesV1RoutingSummaryLeg {
  /**
   * The distance of this leg of the trip.
   */
  distanceMeters?: number;
  /**
   * The time it takes to complete this leg of the trip.
   */
  duration?: number /* Duration */;
}

function serializeGoogleMapsPlacesV1RoutingSummaryLeg(data: any): GoogleMapsPlacesV1RoutingSummaryLeg {
  return {
    ...data,
    duration: data["duration"] !== undefined ? data["duration"] : undefined,
  };
}

function deserializeGoogleMapsPlacesV1RoutingSummaryLeg(data: any): GoogleMapsPlacesV1RoutingSummaryLeg {
  return {
    ...data,
    duration: data["duration"] !== undefined ? data["duration"] : undefined,
  };
}

/**
 * Request proto for Search Nearby.
 */
export interface GoogleMapsPlacesV1SearchNearbyRequest {
  /**
   * Excluded primary Place type (e.g. "restaurant" or "gas_station") from
   * https://developers.google.com/maps/documentation/places/web-service/place-types.
   * Up to 50 types from [Table
   * A](https://developers.google.com/maps/documentation/places/web-service/place-types#table-a)
   * may be specified. If there are any conflicting primary types, i.e. a type
   * appears in both included_primary_types and excluded_primary_types, an
   * INVALID_ARGUMENT error is returned. If a Place type is specified with
   * multiple type restrictions, only places that satisfy all of the
   * restrictions are returned. For example, if we have {included_types =
   * ["restaurant"], excluded_primary_types = ["restaurant"]}, the returned
   * places provide "restaurant" related services but do not operate primarily
   * as "restaurants".
   */
  excludedPrimaryTypes?: string[];
  /**
   * Excluded Place type (eg, "restaurant" or "gas_station") from
   * https://developers.google.com/maps/documentation/places/web-service/place-types.
   * Up to 50 types from [Table
   * A](https://developers.google.com/maps/documentation/places/web-service/place-types#table-a)
   * may be specified. If the client provides both included_types (e.g.
   * restaurant) and excluded_types (e.g. cafe), then the response should
   * include places that are restaurant but not cafe. The response includes
   * places that match at least one of the included_types and none of the
   * excluded_types. If there are any conflicting types, i.e. a type appears in
   * both included_types and excluded_types, an INVALID_ARGUMENT error is
   * returned. If a Place type is specified with multiple type restrictions,
   * only places that satisfy all of the restrictions are returned. For example,
   * if we have {included_types = ["restaurant"], excluded_primary_types =
   * ["restaurant"]}, the returned places provide "restaurant" related services
   * but do not operate primarily as "restaurants".
   */
  excludedTypes?: string[];
  /**
   * Included primary Place type (e.g. "restaurant" or "gas_station") from
   * https://developers.google.com/maps/documentation/places/web-service/place-types.
   * A place can only have a single primary type from the supported types table
   * associated with it. Up to 50 types from [Table
   * A](https://developers.google.com/maps/documentation/places/web-service/place-types#table-a)
   * may be specified. If there are any conflicting primary types, i.e. a type
   * appears in both included_primary_types and excluded_primary_types, an
   * INVALID_ARGUMENT error is returned. If a Place type is specified with
   * multiple type restrictions, only places that satisfy all of the
   * restrictions are returned. For example, if we have {included_types =
   * ["restaurant"], excluded_primary_types = ["restaurant"]}, the returned
   * places provide "restaurant" related services but do not operate primarily
   * as "restaurants".
   */
  includedPrimaryTypes?: string[];
  /**
   * Included Place type (eg, "restaurant" or "gas_station") from
   * https://developers.google.com/maps/documentation/places/web-service/place-types.
   * Up to 50 types from [Table
   * A](https://developers.google.com/maps/documentation/places/web-service/place-types#table-a)
   * may be specified. If there are any conflicting types, i.e. a type appears
   * in both included_types and excluded_types, an INVALID_ARGUMENT error is
   * returned. If a Place type is specified with multiple type restrictions,
   * only places that satisfy all of the restrictions are returned. For example,
   * if we have {included_types = ["restaurant"], excluded_primary_types =
   * ["restaurant"]}, the returned places provide "restaurant" related services
   * but do not operate primarily as "restaurants".
   */
  includedTypes?: string[];
  /**
   * Place details will be displayed with the preferred language if available.
   * If the language code is unspecified or unrecognized, place details of any
   * language may be returned, with a preference for English if such details
   * exist. Current list of supported languages:
   * https://developers.google.com/maps/faq#languagesupport.
   */
  languageCode?: string;
  /**
   * Required. The region to search.
   */
  locationRestriction?: GoogleMapsPlacesV1SearchNearbyRequestLocationRestriction;
  /**
   * Maximum number of results to return. It must be between 1 and 20
   * (default), inclusively. If the number is unset, it falls back to the upper
   * limit. If the number is set to negative or exceeds the upper limit, an
   * INVALID_ARGUMENT error is returned.
   */
  maxResultCount?: number;
  /**
   * How results will be ranked in the response.
   */
  rankPreference?:  | "RANK_PREFERENCE_UNSPECIFIED" | "DISTANCE" | "POPULARITY";
  /**
   * The Unicode country/region code (CLDR) of the location where the request
   * is coming from. This parameter is used to display the place details, like
   * region-specific place name, if available. The parameter can affect results
   * based on applicable law. For more information, see
   * https://www.unicode.org/cldr/charts/latest/supplemental/territory_language_information.html.
   * Note that 3-digit region codes are not currently supported.
   */
  regionCode?: string;
  /**
   * Optional. Parameters that affect the routing to the search results.
   */
  routingParameters?: GoogleMapsPlacesV1RoutingParameters;
}

/**
 * The region to search.
 */
export interface GoogleMapsPlacesV1SearchNearbyRequestLocationRestriction {
  /**
   * A circle defined by center point and radius.
   */
  circle?: GoogleMapsPlacesV1Circle;
}

/**
 * Response proto for Search Nearby.
 */
export interface GoogleMapsPlacesV1SearchNearbyResponse {
  /**
   * A list of places that meets user's requirements like places types, number
   * of places and specific location restriction.
   */
  places?: GoogleMapsPlacesV1Place[];
  /**
   * A list of routing summaries where each entry associates to the
   * corresponding place in the same index in the `places` field. If the routing
   * summary is not available for one of the places, it will contain an empty
   * entry. This list should have as many entries as the list of places if
   * requested.
   */
  routingSummaries?: GoogleMapsPlacesV1RoutingSummary[];
}

function serializeGoogleMapsPlacesV1SearchNearbyResponse(data: any): GoogleMapsPlacesV1SearchNearbyResponse {
  return {
    ...data,
    places: data["places"] !== undefined ? data["places"].map((item: any) => (serializeGoogleMapsPlacesV1Place(item))) : undefined,
    routingSummaries: data["routingSummaries"] !== undefined ? data["routingSummaries"].map((item: any) => (serializeGoogleMapsPlacesV1RoutingSummary(item))) : undefined,
  };
}

function deserializeGoogleMapsPlacesV1SearchNearbyResponse(data: any): GoogleMapsPlacesV1SearchNearbyResponse {
  return {
    ...data,
    places: data["places"] !== undefined ? data["places"].map((item: any) => (deserializeGoogleMapsPlacesV1Place(item))) : undefined,
    routingSummaries: data["routingSummaries"] !== undefined ? data["routingSummaries"].map((item: any) => (deserializeGoogleMapsPlacesV1RoutingSummary(item))) : undefined,
  };
}

/**
 * Request proto for SearchText.
 */
export interface GoogleMapsPlacesV1SearchTextRequest {
  /**
   * Optional. Set the searchable EV options of a place search request.
   */
  evOptions?: GoogleMapsPlacesV1SearchTextRequestEVOptions;
  /**
   * The requested place type. Full list of types supported:
   * https://developers.google.com/maps/documentation/places/web-service/place-types.
   * Only support one included type.
   */
  includedType?: string;
  /**
   * Optional. Include pure service area businesses if the field is set to
   * true. Pure service area business is a business that visits or delivers to
   * customers directly but does not serve customers at their business address.
   * For example, businesses like cleaning services or plumbers. Those
   * businesses do not have a physical address or location on Google Maps.
   * Places will not return fields including `location`, `plus_code`, and other
   * location related fields for these businesses.
   */
  includePureServiceAreaBusinesses?: boolean;
  /**
   * Place details will be displayed with the preferred language if available.
   * If the language code is unspecified or unrecognized, place details of any
   * language may be returned, with a preference for English if such details
   * exist. Current list of supported languages:
   * https://developers.google.com/maps/faq#languagesupport.
   */
  languageCode?: string;
  /**
   * The region to search. This location serves as a bias which means results
   * around given location might be returned. Cannot be set along with
   * location_restriction.
   */
  locationBias?: GoogleMapsPlacesV1SearchTextRequestLocationBias;
  /**
   * The region to search. This location serves as a restriction which means
   * results outside given location will not be returned. Cannot be set along
   * with location_bias.
   */
  locationRestriction?: GoogleMapsPlacesV1SearchTextRequestLocationRestriction;
  /**
   * Deprecated: Use `page_size` instead. The maximum number of results per
   * page that can be returned. If the number of available results is larger
   * than `max_result_count`, a `next_page_token` is returned which can be
   * passed to `page_token` to get the next page of results in subsequent
   * requests. If 0 or no value is provided, a default of 20 is used. The
   * maximum value is 20; values above 20 will be coerced to 20. Negative values
   * will return an INVALID_ARGUMENT error. If both `max_result_count` and
   * `page_size` are specified, `max_result_count` will be ignored.
   */
  maxResultCount?: number;
  /**
   * Filter out results whose average user rating is strictly less than this
   * limit. A valid value must be a float between 0 and 5 (inclusively) at a 0.5
   * cadence i.e. [0, 0.5, 1.0, ... , 5.0] inclusively. The input rating will
   * round up to the nearest 0.5(ceiling). For instance, a rating of 0.6 will
   * eliminate all results with a less than 1.0 rating.
   */
  minRating?: number;
  /**
   * Used to restrict the search to places that are currently open. The default
   * is false.
   */
  openNow?: boolean;
  /**
   * Optional. The maximum number of results per page that can be returned. If
   * the number of available results is larger than `page_size`, a
   * `next_page_token` is returned which can be passed to `page_token` to get
   * the next page of results in subsequent requests. If 0 or no value is
   * provided, a default of 20 is used. The maximum value is 20; values above 20
   * will be set to 20. Negative values will return an INVALID_ARGUMENT error.
   * If both `max_result_count` and `page_size` are specified,
   * `max_result_count` will be ignored.
   */
  pageSize?: number;
  /**
   * Optional. A page token, received from a previous TextSearch call. Provide
   * this to retrieve the subsequent page. When paginating, all parameters other
   * than `page_token`, `page_size`, and `max_result_count` provided to
   * TextSearch must match the initial call that provided the page token.
   * Otherwise an INVALID_ARGUMENT error is returned.
   */
  pageToken?: string;
  /**
   * Used to restrict the search to places that are marked as certain price
   * levels. Users can choose any combinations of price levels. Default to
   * select all price levels.
   */
  priceLevels?:  | "PRICE_LEVEL_UNSPECIFIED" | "PRICE_LEVEL_FREE" | "PRICE_LEVEL_INEXPENSIVE" | "PRICE_LEVEL_MODERATE" | "PRICE_LEVEL_EXPENSIVE" | "PRICE_LEVEL_VERY_EXPENSIVE"[];
  /**
   * How results will be ranked in the response.
   */
  rankPreference?:  | "RANK_PREFERENCE_UNSPECIFIED" | "DISTANCE" | "RELEVANCE";
  /**
   * The Unicode country/region code (CLDR) of the location where the request
   * is coming from. This parameter is used to display the place details, like
   * region-specific place name, if available. The parameter can affect results
   * based on applicable law. For more information, see
   * https://www.unicode.org/cldr/charts/latest/supplemental/territory_language_information.html.
   * Note that 3-digit region codes are not currently supported.
   */
  regionCode?: string;
  /**
   * Optional. Additional parameters for routing to results.
   */
  routingParameters?: GoogleMapsPlacesV1RoutingParameters;
  /**
   * Optional. Additional parameters proto for searching along a route.
   */
  searchAlongRouteParameters?: GoogleMapsPlacesV1SearchTextRequestSearchAlongRouteParameters;
  /**
   * Used to set strict type filtering for included_type. If set to true, only
   * results of the same type will be returned. Default to false.
   */
  strictTypeFiltering?: boolean;
  /**
   * Required. The text query for textual search.
   */
  textQuery?: string;
}

/**
 * Searchable EV options of a place search request.
 */
export interface GoogleMapsPlacesV1SearchTextRequestEVOptions {
  /**
   * Optional. The list of preferred EV connector types. A place that does not
   * support any of the listed connector types is filtered out.
   */
  connectorTypes?:  | "EV_CONNECTOR_TYPE_UNSPECIFIED" | "EV_CONNECTOR_TYPE_OTHER" | "EV_CONNECTOR_TYPE_J1772" | "EV_CONNECTOR_TYPE_TYPE_2" | "EV_CONNECTOR_TYPE_CHADEMO" | "EV_CONNECTOR_TYPE_CCS_COMBO_1" | "EV_CONNECTOR_TYPE_CCS_COMBO_2" | "EV_CONNECTOR_TYPE_TESLA" | "EV_CONNECTOR_TYPE_UNSPECIFIED_GB_T" | "EV_CONNECTOR_TYPE_UNSPECIFIED_WALL_OUTLET"[];
  /**
   * Optional. Minimum required charging rate in kilowatts. A place with a
   * charging rate less than the specified rate is filtered out.
   */
  minimumChargingRateKw?: number;
}

/**
 * The region to search. This location serves as a bias which means results
 * around given location might be returned.
 */
export interface GoogleMapsPlacesV1SearchTextRequestLocationBias {
  /**
   * A circle defined by center point and radius.
   */
  circle?: GoogleMapsPlacesV1Circle;
  /**
   * A rectangle box defined by northeast and southwest corner.
   * `rectangle.high()` must be the northeast point of the rectangle viewport.
   * `rectangle.low()` must be the southwest point of the rectangle viewport.
   * `rectangle.low().latitude()` cannot be greater than
   * `rectangle.high().latitude()`. This will result in an empty latitude range.
   * A rectangle viewport cannot be wider than 180 degrees.
   */
  rectangle?: GoogleGeoTypeViewport;
}

/**
 * The region to search. This location serves as a restriction which means
 * results outside given location will not be returned.
 */
export interface GoogleMapsPlacesV1SearchTextRequestLocationRestriction {
  /**
   * A rectangle box defined by northeast and southwest corner.
   * `rectangle.high()` must be the northeast point of the rectangle viewport.
   * `rectangle.low()` must be the southwest point of the rectangle viewport.
   * `rectangle.low().latitude()` cannot be greater than
   * `rectangle.high().latitude()`. This will result in an empty latitude range.
   * A rectangle viewport cannot be wider than 180 degrees.
   */
  rectangle?: GoogleGeoTypeViewport;
}

/**
 * Specifies a precalculated polyline from the [Routes
 * API](https://developers.google.com/maps/documentation/routes) defining the
 * route to search. Searching along a route is similar to using the
 * `locationBias` or `locationRestriction` request option to bias the search
 * results. However, while the `locationBias` and `locationRestriction` options
 * let you specify a region to bias the search results, this option lets you
 * bias the results along a trip route. Results are not guaranteed to be along
 * the route provided, but rather are ranked within the search area defined by
 * the polyline and, optionally, by the `locationBias` or `locationRestriction`
 * based on minimal detour times from origin to destination. The results might
 * be along an alternate route, especially if the provided polyline does not
 * define an optimal route from origin to destination.
 */
export interface GoogleMapsPlacesV1SearchTextRequestSearchAlongRouteParameters {
  /**
   * Required. The route polyline.
   */
  polyline?: GoogleMapsPlacesV1Polyline;
}

/**
 * Response proto for SearchText.
 */
export interface GoogleMapsPlacesV1SearchTextResponse {
  /**
   * Experimental: See
   * https://developers.google.com/maps/documentation/places/web-service/experimental/places-generative
   * for more details. A list of contextual contents where each entry associates
   * to the corresponding place in the same index in the places field. The
   * contents that are relevant to the `text_query` in the request are
   * preferred. If the contextual content is not available for one of the
   * places, it will return non-contextual content. It will be empty only when
   * the content is unavailable for this place. This list will have as many
   * entries as the list of places if requested.
   */
  contextualContents?: GoogleMapsPlacesV1ContextualContent[];
  /**
   * A token that can be sent as `page_token` to retrieve the next page. If
   * this field is omitted or empty, there are no subsequent pages.
   */
  nextPageToken?: string;
  /**
   * A list of places that meet the user's text search criteria.
   */
  places?: GoogleMapsPlacesV1Place[];
  /**
   * A list of routing summaries where each entry associates to the
   * corresponding place in the same index in the `places` field. If the routing
   * summary is not available for one of the places, it will contain an empty
   * entry. This list will have as many entries as the list of places if
   * requested.
   */
  routingSummaries?: GoogleMapsPlacesV1RoutingSummary[];
  /**
   * A link allows the user to search with the same text query as specified in
   * the request on Google Maps.
   */
  searchUri?: string;
}

function serializeGoogleMapsPlacesV1SearchTextResponse(data: any): GoogleMapsPlacesV1SearchTextResponse {
  return {
    ...data,
    contextualContents: data["contextualContents"] !== undefined ? data["contextualContents"].map((item: any) => (serializeGoogleMapsPlacesV1ContextualContent(item))) : undefined,
    places: data["places"] !== undefined ? data["places"].map((item: any) => (serializeGoogleMapsPlacesV1Place(item))) : undefined,
    routingSummaries: data["routingSummaries"] !== undefined ? data["routingSummaries"].map((item: any) => (serializeGoogleMapsPlacesV1RoutingSummary(item))) : undefined,
  };
}

function deserializeGoogleMapsPlacesV1SearchTextResponse(data: any): GoogleMapsPlacesV1SearchTextResponse {
  return {
    ...data,
    contextualContents: data["contextualContents"] !== undefined ? data["contextualContents"].map((item: any) => (deserializeGoogleMapsPlacesV1ContextualContent(item))) : undefined,
    places: data["places"] !== undefined ? data["places"].map((item: any) => (deserializeGoogleMapsPlacesV1Place(item))) : undefined,
    routingSummaries: data["routingSummaries"] !== undefined ? data["routingSummaries"].map((item: any) => (deserializeGoogleMapsPlacesV1RoutingSummary(item))) : undefined,
  };
}

/**
 * Represents a whole or partial calendar date, such as a birthday. The time of
 * day and time zone are either specified elsewhere or are insignificant. The
 * date is relative to the Gregorian Calendar. This can represent one of the
 * following: * A full date, with non-zero year, month, and day values. * A
 * month and day, with a zero year (for example, an anniversary). * A year on
 * its own, with a zero month and a zero day. * A year and month, with a zero
 * day (for example, a credit card expiration date). Related types: *
 * google.type.TimeOfDay * google.type.DateTime * google.protobuf.Timestamp
 */
export interface GoogleTypeDate {
  /**
   * Day of a month. Must be from 1 to 31 and valid for the year and month, or
   * 0 to specify a year by itself or a year and month where the day isn't
   * significant.
   */
  day?: number;
  /**
   * Month of a year. Must be from 1 to 12, or 0 to specify a year without a
   * month and day.
   */
  month?: number;
  /**
   * Year of the date. Must be from 1 to 9999, or 0 to specify a date without a
   * year.
   */
  year?: number;
}

/**
 * An object that represents a latitude/longitude pair. This is expressed as a
 * pair of doubles to represent degrees latitude and degrees longitude. Unless
 * specified otherwise, this object must conform to the WGS84 standard. Values
 * must be within normalized ranges.
 */
export interface GoogleTypeLatLng {
  /**
   * The latitude in degrees. It must be in the range [-90.0, +90.0].
   */
  latitude?: number;
  /**
   * The longitude in degrees. It must be in the range [-180.0, +180.0].
   */
  longitude?: number;
}

/**
 * Localized variant of a text in a particular language.
 */
export interface GoogleTypeLocalizedText {
  /**
   * 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;
  /**
   * Localized string in the language corresponding to language_code below.
   */
  text?: string;
}

/**
 * Represents an amount of money with its currency type.
 */
export interface GoogleTypeMoney {
  /**
   * The three-letter currency code defined in ISO 4217.
   */
  currencyCode?: string;
  /**
   * Number of nano (10^-9) units of the amount. The value must be between
   * -999,999,999 and +999,999,999 inclusive. If `units` is positive, `nanos`
   * must be positive or zero. If `units` is zero, `nanos` can be positive,
   * zero, or negative. If `units` is negative, `nanos` must be negative or
   * zero. For example $-1.75 is represented as `units`=-1 and
   * `nanos`=-750,000,000.
   */
  nanos?: number;
  /**
   * The whole units of the amount. For example if `currencyCode` is `"USD"`,
   * then 1 unit is one US dollar.
   */
  units?: bigint;
}

function serializeGoogleTypeMoney(data: any): GoogleTypeMoney {
  return {
    ...data,
    units: data["units"] !== undefined ? String(data["units"]) : undefined,
  };
}

function deserializeGoogleTypeMoney(data: any): GoogleTypeMoney {
  return {
    ...data,
    units: data["units"] !== undefined ? BigInt(data["units"]) : undefined,
  };
}

/**
 * Additional options for Places#placesGet.
 */
export interface PlacesGetOptions {
  /**
   * Optional. Place details will be displayed with the preferred language if
   * available. Current list of supported languages:
   * https://developers.google.com/maps/faq#languagesupport.
   */
  languageCode?: string;
  /**
   * Optional. The Unicode country/region code (CLDR) of the location where the
   * request is coming from. This parameter is used to display the place
   * details, like region-specific place name, if available. The parameter can
   * affect results based on applicable law. For more information, see
   * https://www.unicode.org/cldr/charts/latest/supplemental/territory_language_information.html.
   * Note that 3-digit region codes are not currently supported.
   */
  regionCode?: string;
  /**
   * Optional. A string which identifies an Autocomplete session for billing
   * purposes. Must be a URL and filename safe base64 string with at most 36
   * ASCII characters in length. Otherwise an INVALID_ARGUMENT error is
   * returned. The session begins when the user starts typing a query, and
   * concludes when they select a place and a call to Place Details or Address
   * Validation is made. Each session can have multiple queries, followed by one
   * Place Details or Address Validation request. The credentials used for each
   * request within a session must belong to the same Google Cloud Console
   * project. Once a session has concluded, the token is no longer valid; your
   * app must generate a fresh token for each session. If the `session_token`
   * parameter is omitted, or if you reuse a session token, the session is
   * charged as if no session token was provided (each request is billed
   * separately). We recommend the following guidelines: * Use session tokens
   * for all Place Autocomplete calls. * Generate a fresh token for each
   * session. Using a version 4 UUID is recommended. * Ensure that the
   * credentials used for all Place Autocomplete, Place Details, and Address
   * Validation requests within a session belong to the same Cloud Console
   * project. * Be sure to pass a unique session token for each new session.
   * Using the same token for more than one session will result in each request
   * being billed individually.
   */
  sessionToken?: string;
}

/**
 * Additional options for Places#placesPhotosGetMedia.
 */
export interface PlacesPhotosGetMediaOptions {
  /**
   * Optional. Specifies the maximum desired height, in pixels, of the image.
   * If the image is smaller than the values specified, the original image will
   * be returned. If the image is larger in either dimension, it will be scaled
   * to match the smaller of the two dimensions, restricted to its original
   * aspect ratio. Both the max_height_px and max_width_px properties accept an
   * integer between 1 and 4800, inclusively. If the value is not within the
   * allowed range, an INVALID_ARGUMENT error will be returned. At least one of
   * max_height_px or max_width_px needs to be specified. If neither
   * max_height_px nor max_width_px is specified, an INVALID_ARGUMENT error will
   * be returned.
   */
  maxHeightPx?: number;
  /**
   * Optional. Specifies the maximum desired width, in pixels, of the image. If
   * the image is smaller than the values specified, the original image will be
   * returned. If the image is larger in either dimension, it will be scaled to
   * match the smaller of the two dimensions, restricted to its original aspect
   * ratio. Both the max_height_px and max_width_px properties accept an integer
   * between 1 and 4800, inclusively. If the value is not within the allowed
   * range, an INVALID_ARGUMENT error will be returned. At least one of
   * max_height_px or max_width_px needs to be specified. If neither
   * max_height_px nor max_width_px is specified, an INVALID_ARGUMENT error will
   * be returned.
   */
  maxWidthPx?: number;
  /**
   * Optional. If set, skip the default HTTP redirect behavior and render a
   * text format (for example, in JSON format for HTTP use case) response. If
   * not set, an HTTP redirect will be issued to redirect the call to the image
   * media. This option is ignored for non-HTTP requests.
   */
  skipHttpRedirect?: boolean;
}