rafay-test-ts-gm 1.22.5

package/src/models/place-autocomplete-prediction.ts

@@ -0,0 +1,40 @@
+import * as s from "../core/validation/index.js";
+import type { Schema } from "../core/validation/schema.js";
+import {
+  placeAutocompleteMatchedSubstringSchema,
+  type PlaceAutocompleteMatchedSubstring,
+} from "./place-autocomplete-matched-substring.js";
+import {
+  placeAutocompleteStructuredFormatSchema,
+  type PlaceAutocompleteStructuredFormat,
+} from "./place-autocomplete-structured-format.js";
+import { placeAutocompleteTermSchema, type PlaceAutocompleteTerm } from "./place-autocomplete-term.js";
+
+export type PlaceAutocompletePrediction = {
+  description: string;
+  matchedSubstrings: PlaceAutocompleteMatchedSubstring[];
+  placeId?: string;
+  reference?: string;
+  structuredFormatting: PlaceAutocompleteStructuredFormat;
+  terms: PlaceAutocompleteTerm[];
+  types?: string[];
+  distanceMeters?: number;
+};
+
+export const placeAutocompletePredictionSchema: Schema<PlaceAutocompletePrediction> =
+  s.object<PlaceAutocompletePrediction>({
+    description: s.string(),
+    matchedSubstrings: s.array(s.lazy(() => placeAutocompleteMatchedSubstringSchema)),
+    placeId: s.optional(s.string()),
+    reference: s.optional(s.string()),
+    structuredFormatting: placeAutocompleteStructuredFormatSchema,
+    terms: s.array(s.lazy(() => placeAutocompleteTermSchema)),
+    types: s.optional(s.array(s.string())),
+    distanceMeters: s.optional(s.number()),
+    _keysMap: {
+      matchedSubstrings: "matched_substrings",
+      placeId: "place_id",
+      structuredFormatting: "structured_formatting",
+      distanceMeters: "distance_meters",
+    },
+  });

package/src/models/place-autocomplete-structured-format.ts

@@ -0,0 +1,29 @@
+import * as s from "../core/validation/index.js";
+import type { Schema } from "../core/validation/schema.js";
+import {
+  placeAutocompleteMatchedSubstringSchema,
+  type PlaceAutocompleteMatchedSubstring,
+} from "./place-autocomplete-matched-substring.js";
+
+export type PlaceAutocompleteStructuredFormat = {
+  mainText: string;
+  mainTextMatchedSubstrings: PlaceAutocompleteMatchedSubstring[];
+  secondaryText?: string;
+  secondaryTextMatchedSubstrings?: PlaceAutocompleteMatchedSubstring[];
+};
+
+export const placeAutocompleteStructuredFormatSchema: Schema<PlaceAutocompleteStructuredFormat> =
+  s.object<PlaceAutocompleteStructuredFormat>({
+    mainText: s.string(),
+    mainTextMatchedSubstrings: s.array(s.lazy(() => placeAutocompleteMatchedSubstringSchema)),
+    secondaryText: s.optional(s.string()),
+    secondaryTextMatchedSubstrings: s.optional(
+      s.array(s.lazy(() => placeAutocompleteMatchedSubstringSchema)),
+    ),
+    _keysMap: {
+      mainText: "main_text",
+      mainTextMatchedSubstrings: "main_text_matched_substrings",
+      secondaryText: "secondary_text",
+      secondaryTextMatchedSubstrings: "secondary_text_matched_substrings",
+    },
+  });

package/src/models/place-autocomplete-term.ts

@@ -0,0 +1,12 @@
+import * as s from "../core/validation/index.js";
+import type { Schema } from "../core/validation/schema.js";
+
+export type PlaceAutocompleteTerm = {
+  value: string;
+  offset: number;
+};
+
+export const placeAutocompleteTermSchema: Schema<PlaceAutocompleteTerm> = s.object<PlaceAutocompleteTerm>({
+  value: s.string(),
+  offset: s.number(),
+});

package/src/models/place-editorial-summary.ts

@@ -0,0 +1,12 @@
+import * as s from "../core/validation/index.js";
+import type { Schema } from "../core/validation/schema.js";
+
+export type PlaceEditorialSummary = {
+  overview?: string;
+  language?: string;
+};
+
+export const placeEditorialSummarySchema: Schema<PlaceEditorialSummary> = s.object<PlaceEditorialSummary>({
+  overview: s.optional(s.string()),
+  language: s.optional(s.string()),
+});

package/src/models/place-opening-hours-period-detail.ts

@@ -0,0 +1,17 @@
+import * as s from "../core/validation/index.js";
+import type { Schema } from "../core/validation/schema.js";
+
+export type PlaceOpeningHoursPeriodDetail = {
+  date?: string;
+  day: number;
+  time: string;
+  truncated?: boolean;
+};
+
+export const placeOpeningHoursPeriodDetailSchema: Schema<PlaceOpeningHoursPeriodDetail> =
+  s.object<PlaceOpeningHoursPeriodDetail>({
+    date: s.optional(s.string()),
+    day: s.number(),
+    time: s.string(),
+    truncated: s.optional(s.boolean()),
+  });

package/src/models/place-opening-hours-period.ts

@@ -0,0 +1,17 @@
+import * as s from "../core/validation/index.js";
+import type { Schema } from "../core/validation/schema.js";
+import {
+  placeOpeningHoursPeriodDetailSchema,
+  type PlaceOpeningHoursPeriodDetail,
+} from "./place-opening-hours-period-detail.js";
+
+export type PlaceOpeningHoursPeriod = {
+  open: PlaceOpeningHoursPeriodDetail;
+  close?: PlaceOpeningHoursPeriodDetail;
+};
+
+export const placeOpeningHoursPeriodSchema: Schema<PlaceOpeningHoursPeriod> =
+  s.object<PlaceOpeningHoursPeriod>({
+    open: placeOpeningHoursPeriodDetailSchema,
+    close: s.optional(s.lazy(() => placeOpeningHoursPeriodDetailSchema)),
+  });

package/src/models/place-opening-hours.ts

@@ -0,0 +1,25 @@
+import * as s from "../core/validation/index.js";
+import type { Schema } from "../core/validation/schema.js";
+import { placeOpeningHoursPeriodSchema, type PlaceOpeningHoursPeriod } from "./place-opening-hours-period.js";
+import { placeSpecialDaySchema, type PlaceSpecialDay } from "./place-special-day.js";
+
+export type PlaceOpeningHours = {
+  openNow?: boolean;
+  periods?: PlaceOpeningHoursPeriod[];
+  specialDays?: PlaceSpecialDay[];
+  type?: string;
+  weekdayText?: string[];
+};
+
+export const placeOpeningHoursSchema: Schema<PlaceOpeningHours> = s.object<PlaceOpeningHours>({
+  openNow: s.optional(s.boolean()),
+  periods: s.optional(s.array(s.lazy(() => placeOpeningHoursPeriodSchema))),
+  specialDays: s.optional(s.array(s.lazy(() => placeSpecialDaySchema))),
+  type: s.optional(s.string()),
+  weekdayText: s.optional(s.array(s.string())),
+  _keysMap: {
+    openNow: "open_now",
+    specialDays: "special_days",
+    weekdayText: "weekday_text",
+  },
+});

package/src/models/place-photo.ts

@@ -0,0 +1,20 @@
+import * as s from "../core/validation/index.js";
+import type { Schema } from "../core/validation/schema.js";
+
+export type PlacePhoto = {
+  height: number;
+  width: number;
+  htmlAttributions: string[];
+  photoReference: string;
+};
+
+export const placePhotoSchema: Schema<PlacePhoto> = s.object<PlacePhoto>({
+  height: s.number(),
+  width: s.number(),
+  htmlAttributions: s.array(s.string()),
+  photoReference: s.string(),
+  _keysMap: {
+    htmlAttributions: "html_attributions",
+    photoReference: "photo_reference",
+  },
+});

package/src/models/place-review.ts

@@ -0,0 +1,35 @@
+import * as s from "../core/validation/index.js";
+import type { Schema } from "../core/validation/schema.js";
+
+export type PlaceReview = {
+  authorName: string;
+  authorUrl?: string;
+  profilePhotoUrl?: string;
+  language?: string;
+  originalLanguage?: string;
+  rating: number;
+  relativeTimeDescription: string;
+  text?: string;
+  time: number;
+  translated?: boolean;
+};
+
+export const placeReviewSchema: Schema<PlaceReview> = s.object<PlaceReview>({
+  authorName: s.string(),
+  authorUrl: s.optional(s.string()),
+  profilePhotoUrl: s.optional(s.string()),
+  language: s.optional(s.string()),
+  originalLanguage: s.optional(s.string()),
+  rating: s.number(),
+  relativeTimeDescription: s.string(),
+  text: s.optional(s.string()),
+  time: s.number(),
+  translated: s.optional(s.boolean()),
+  _keysMap: {
+    authorName: "author_name",
+    authorUrl: "author_url",
+    profilePhotoUrl: "profile_photo_url",
+    originalLanguage: "original_language",
+    relativeTimeDescription: "relative_time_description",
+  },
+});

package/src/models/place-special-day.ts

@@ -0,0 +1,15 @@
+import * as s from "../core/validation/index.js";
+import type { Schema } from "../core/validation/schema.js";
+
+export type PlaceSpecialDay = {
+  date?: string;
+  exceptionalHours?: boolean;
+};
+
+export const placeSpecialDaySchema: Schema<PlaceSpecialDay> = s.object<PlaceSpecialDay>({
+  date: s.optional(s.string()),
+  exceptionalHours: s.optional(s.boolean()),
+  _keysMap: {
+    exceptionalHours: "exceptional_hours",
+  },
+});

package/src/models/place.ts

@@ -0,0 +1,134 @@
+import * as s from "../core/validation/index.js";
+import type { Schema } from "../core/validation/schema.js";
+import { addressComponentSchema, type AddressComponent } from "./address-component.js";
+import { businessStatusSchema, type BusinessStatus } from "./business-status.js";
+import { currentOpeningHoursSchema, type CurrentOpeningHours } from "./current-opening-hours.js";
+import { editorialSummarySchema, type EditorialSummary } from "./editorial-summary.js";
+import { geometry2Schema, type Geometry2 } from "./geometry2.js";
+import { openingHoursSchema, type OpeningHours } from "./opening-hours.js";
+import { placeOpeningHoursSchema, type PlaceOpeningHours } from "./place-opening-hours.js";
+import { placePhotoSchema, type PlacePhoto } from "./place-photo.js";
+import { placeReviewSchema, type PlaceReview } from "./place-review.js";
+import { plusCode1Schema, type PlusCode1 } from "./plus-code1.js";
+
+export type Place = {
+  addressComponents?: AddressComponent[];
+  adrAddress?: string;
+  businessStatus?: BusinessStatus;
+  curbsidePickup?: boolean;
+  currentOpeningHours?: CurrentOpeningHours;
+  delivery?: boolean;
+  dineIn?: boolean;
+  editorialSummary?: EditorialSummary;
+  formattedAddress?: string;
+  formattedPhoneNumber?: string;
+  geometry?: Geometry2;
+  icon?: string;
+  iconBackgroundColor?: string;
+  iconMaskBaseUri?: string;
+  internationalPhoneNumber?: string;
+  name?: string;
+  openingHours?: OpeningHours;
+  permanentlyClosed?: boolean;
+  photos?: PlacePhoto[];
+  placeId?: string;
+  plusCode?: PlusCode1;
+  priceLevel?: number;
+  rating?: number;
+  reference?: string;
+  reservable?: boolean;
+  reviews?: PlaceReview[];
+  servesBeer?: boolean;
+  servesBreakfast?: boolean;
+  servesBrunch?: boolean;
+  servesDinner?: boolean;
+  servesLunch?: boolean;
+  servesVegetarianFood?: boolean;
+  servesWine?: boolean;
+  scope?: string;
+  secondaryOpeningHours?: PlaceOpeningHours[];
+  takeout?: boolean;
+  types?: string[];
+  url?: string;
+  userRatingsTotal?: number;
+  utcOffset?: number;
+  vicinity?: string;
+  website?: string;
+  wheelchairAccessibleEntrance?: boolean;
+};
+
+export const placeSchema: Schema<Place> = s.object<Place>({
+  addressComponents: s.optional(s.array(s.lazy(() => addressComponentSchema))),
+  adrAddress: s.optional(s.string()),
+  businessStatus: s.optional(s.lazy(() => businessStatusSchema)),
+  curbsidePickup: s.optional(s.boolean()),
+  currentOpeningHours: s.optional(s.lazy(() => currentOpeningHoursSchema)),
+  delivery: s.optional(s.boolean()),
+  dineIn: s.optional(s.boolean()),
+  editorialSummary: s.optional(s.lazy(() => editorialSummarySchema)),
+  formattedAddress: s.optional(s.string()),
+  formattedPhoneNumber: s.optional(s.string()),
+  geometry: s.optional(s.lazy(() => geometry2Schema)),
+  icon: s.optional(s.string()),
+  iconBackgroundColor: s.optional(s.string()),
+  iconMaskBaseUri: s.optional(s.string()),
+  internationalPhoneNumber: s.optional(s.string()),
+  name: s.optional(s.string()),
+  openingHours: s.optional(s.lazy(() => openingHoursSchema)),
+  permanentlyClosed: s.optional(s.boolean()),
+  photos: s.optional(s.array(s.lazy(() => placePhotoSchema))),
+  placeId: s.optional(s.string()),
+  plusCode: s.optional(s.lazy(() => plusCode1Schema)),
+  priceLevel: s.optional(s.number()),
+  rating: s.optional(s.number()),
+  reference: s.optional(s.string()),
+  reservable: s.optional(s.boolean()),
+  reviews: s.optional(s.array(s.lazy(() => placeReviewSchema))),
+  servesBeer: s.optional(s.boolean()),
+  servesBreakfast: s.optional(s.boolean()),
+  servesBrunch: s.optional(s.boolean()),
+  servesDinner: s.optional(s.boolean()),
+  servesLunch: s.optional(s.boolean()),
+  servesVegetarianFood: s.optional(s.boolean()),
+  servesWine: s.optional(s.boolean()),
+  scope: s.optional(s.string()),
+  secondaryOpeningHours: s.optional(s.array(s.lazy(() => placeOpeningHoursSchema))),
+  takeout: s.optional(s.boolean()),
+  types: s.optional(s.array(s.string())),
+  url: s.optional(s.string()),
+  userRatingsTotal: s.optional(s.number()),
+  utcOffset: s.optional(s.number()),
+  vicinity: s.optional(s.string()),
+  website: s.optional(s.string()),
+  wheelchairAccessibleEntrance: s.optional(s.boolean()),
+  _keysMap: {
+    addressComponents: "address_components",
+    adrAddress: "adr_address",
+    businessStatus: "business_status",
+    curbsidePickup: "curbside_pickup",
+    currentOpeningHours: "current_opening_hours",
+    dineIn: "dine_in",
+    editorialSummary: "editorial_summary",
+    formattedAddress: "formatted_address",
+    formattedPhoneNumber: "formatted_phone_number",
+    iconBackgroundColor: "icon_background_color",
+    iconMaskBaseUri: "icon_mask_base_uri",
+    internationalPhoneNumber: "international_phone_number",
+    openingHours: "opening_hours",
+    permanentlyClosed: "permanently_closed",
+    placeId: "place_id",
+    plusCode: "plus_code",
+    priceLevel: "price_level",
+    servesBeer: "serves_beer",
+    servesBreakfast: "serves_breakfast",
+    servesBrunch: "serves_brunch",
+    servesDinner: "serves_dinner",
+    servesLunch: "serves_lunch",
+    servesVegetarianFood: "serves_vegetarian_food",
+    servesWine: "serves_wine",
+    secondaryOpeningHours: "secondary_opening_hours",
+    userRatingsTotal: "user_ratings_total",
+    utcOffset: "utc_offset",
+    wheelchairAccessibleEntrance: "wheelchair_accessible_entrance",
+  },
+});

package/src/models/places-autocomplete-response.ts

@@ -0,0 +1,29 @@
+import * as s from "../core/validation/index.js";
+import type { Schema } from "../core/validation/schema.js";
+import {
+  placeAutocompletePredictionSchema,
+  type PlaceAutocompletePrediction,
+} from "./place-autocomplete-prediction.js";
+import {
+  placesAutocompleteStatusSchema,
+  type PlacesAutocompleteStatus,
+} from "./places-autocomplete-status.js";
+
+export type PlacesAutocompleteResponse = {
+  predictions: PlaceAutocompletePrediction[];
+  status: PlacesAutocompleteStatus;
+  errorMessage?: string;
+  infoMessages?: string[];
+};
+
+export const placesAutocompleteResponseSchema: Schema<PlacesAutocompleteResponse> =
+  s.object<PlacesAutocompleteResponse>({
+    predictions: s.array(s.lazy(() => placeAutocompletePredictionSchema)),
+    status: placesAutocompleteStatusSchema,
+    errorMessage: s.optional(s.string()),
+    infoMessages: s.optional(s.array(s.string())),
+    _keysMap: {
+      errorMessage: "error_message",
+      infoMessages: "info_messages",
+    },
+  });

package/src/models/places-autocomplete-status.ts

@@ -0,0 +1,17 @@
+import * as s from "../core/validation/index.js";
+import type { EnumSchema } from "../core/validation/schema.js";
+
+export const PlacesAutocompleteStatus = {
+  Ok: "OK",
+  ZeroResults: "ZERO_RESULTS",
+  InvalidRequest: "INVALID_REQUEST",
+  OverQueryLimit: "OVER_QUERY_LIMIT",
+  RequestDenied: "REQUEST_DENIED",
+  UnknownError: "UNKNOWN_ERROR",
+} as const;
+export type PlacesAutocompleteStatus =
+  | (typeof PlacesAutocompleteStatus)[keyof typeof PlacesAutocompleteStatus]
+  | (string & {});
+
+export const placesAutocompleteStatusSchema: EnumSchema<PlacesAutocompleteStatus> =
+  s.enumOf<PlacesAutocompleteStatus>(PlacesAutocompleteStatus);

package/src/models/places-details-response.ts

@@ -0,0 +1,22 @@
+import * as s from "../core/validation/index.js";
+import type { Schema } from "../core/validation/schema.js";
+import { placesDetailsStatusSchema, type PlacesDetailsStatus } from "./places-details-status.js";
+import { result2Schema, type Result2 } from "./result2.js";
+
+export type PlacesDetailsResponse = {
+  htmlAttributions: string[];
+  result: Result2;
+  status: PlacesDetailsStatus;
+  infoMessages?: string[];
+};
+
+export const placesDetailsResponseSchema: Schema<PlacesDetailsResponse> = s.object<PlacesDetailsResponse>({
+  htmlAttributions: s.array(s.string()),
+  result: result2Schema,
+  status: placesDetailsStatusSchema,
+  infoMessages: s.optional(s.array(s.string())),
+  _keysMap: {
+    htmlAttributions: "html_attributions",
+    infoMessages: "info_messages",
+  },
+});

package/src/models/places-details-status.ts

@@ -0,0 +1,18 @@
+import * as s from "../core/validation/index.js";
+import type { EnumSchema } from "../core/validation/schema.js";
+
+export const PlacesDetailsStatus = {
+  Ok: "OK",
+  ZeroResults: "ZERO_RESULTS",
+  InvalidRequest: "INVALID_REQUEST",
+  NotFound: "NOT_FOUND",
+  OverQueryLimit: "OVER_QUERY_LIMIT",
+  RequestDenied: "REQUEST_DENIED",
+  UnknownError: "UNKNOWN_ERROR",
+} as const;
+export type PlacesDetailsStatus =
+  | (typeof PlacesDetailsStatus)[keyof typeof PlacesDetailsStatus]
+  | (string & {});
+
+export const placesDetailsStatusSchema: EnumSchema<PlacesDetailsStatus> =
+  s.enumOf<PlacesDetailsStatus>(PlacesDetailsStatus);

package/src/models/places-find-place-from-text-response.ts

@@ -0,0 +1,23 @@
+import * as s from "../core/validation/index.js";
+import type { Schema } from "../core/validation/schema.js";
+import { placeSchema, type Place } from "./place.js";
+import { placesSearchStatusSchema, type PlacesSearchStatus } from "./places-search-status.js";
+
+export type PlacesFindPlaceFromTextResponse = {
+  candidates: Place[];
+  status: PlacesSearchStatus;
+  errorMessage?: string;
+  infoMessages?: string[];
+};
+
+export const placesFindPlaceFromTextResponseSchema: Schema<PlacesFindPlaceFromTextResponse> =
+  s.object<PlacesFindPlaceFromTextResponse>({
+    candidates: s.array(s.lazy(() => placeSchema)),
+    status: placesSearchStatusSchema,
+    errorMessage: s.optional(s.string()),
+    infoMessages: s.optional(s.array(s.string())),
+    _keysMap: {
+      errorMessage: "error_message",
+      infoMessages: "info_messages",
+    },
+  });

package/src/models/places-nearby-search-response.ts

@@ -0,0 +1,29 @@
+import * as s from "../core/validation/index.js";
+import type { Schema } from "../core/validation/schema.js";
+import { placeSchema, type Place } from "./place.js";
+import { placesSearchStatusSchema, type PlacesSearchStatus } from "./places-search-status.js";
+
+export type PlacesNearbySearchResponse = {
+  htmlAttributions: string[];
+  results: Place[];
+  status: PlacesSearchStatus;
+  errorMessage?: string;
+  infoMessages?: string[];
+  nextPageToken?: string;
+};
+
+export const placesNearbySearchResponseSchema: Schema<PlacesNearbySearchResponse> =
+  s.object<PlacesNearbySearchResponse>({
+    htmlAttributions: s.array(s.string()),
+    results: s.array(s.lazy(() => placeSchema)),
+    status: placesSearchStatusSchema,
+    errorMessage: s.optional(s.string()),
+    infoMessages: s.optional(s.array(s.string())),
+    nextPageToken: s.optional(s.string()),
+    _keysMap: {
+      htmlAttributions: "html_attributions",
+      errorMessage: "error_message",
+      infoMessages: "info_messages",
+      nextPageToken: "next_page_token",
+    },
+  });

package/src/models/places-query-autocomplete-response.ts

@@ -0,0 +1,29 @@
+import * as s from "../core/validation/index.js";
+import type { Schema } from "../core/validation/schema.js";
+import {
+  placeAutocompletePredictionSchema,
+  type PlaceAutocompletePrediction,
+} from "./place-autocomplete-prediction.js";
+import {
+  placesAutocompleteStatusSchema,
+  type PlacesAutocompleteStatus,
+} from "./places-autocomplete-status.js";
+
+export type PlacesQueryAutocompleteResponse = {
+  predictions: PlaceAutocompletePrediction[];
+  status: PlacesAutocompleteStatus;
+  errorMessage?: string;
+  infoMessages?: string[];
+};
+
+export const placesQueryAutocompleteResponseSchema: Schema<PlacesQueryAutocompleteResponse> =
+  s.object<PlacesQueryAutocompleteResponse>({
+    predictions: s.array(s.lazy(() => placeAutocompletePredictionSchema)),
+    status: placesAutocompleteStatusSchema,
+    errorMessage: s.optional(s.string()),
+    infoMessages: s.optional(s.array(s.string())),
+    _keysMap: {
+      errorMessage: "error_message",
+      infoMessages: "info_messages",
+    },
+  });

package/src/models/places-search-status.ts

@@ -0,0 +1,15 @@
+import * as s from "../core/validation/index.js";
+import type { EnumSchema } from "../core/validation/schema.js";
+
+export const PlacesSearchStatus = {
+  Ok: "OK",
+  ZeroResults: "ZERO_RESULTS",
+  InvalidRequest: "INVALID_REQUEST",
+  OverQueryLimit: "OVER_QUERY_LIMIT",
+  RequestDenied: "REQUEST_DENIED",
+  UnknownError: "UNKNOWN_ERROR",
+} as const;
+export type PlacesSearchStatus = (typeof PlacesSearchStatus)[keyof typeof PlacesSearchStatus] | (string & {});
+
+export const placesSearchStatusSchema: EnumSchema<PlacesSearchStatus> =
+  s.enumOf<PlacesSearchStatus>(PlacesSearchStatus);

package/src/models/places-text-search-response.ts

@@ -0,0 +1,29 @@
+import * as s from "../core/validation/index.js";
+import type { Schema } from "../core/validation/schema.js";
+import { placeSchema, type Place } from "./place.js";
+import { placesSearchStatusSchema, type PlacesSearchStatus } from "./places-search-status.js";
+
+export type PlacesTextSearchResponse = {
+  htmlAttributions: string[];
+  results: Place[];
+  status: PlacesSearchStatus;
+  errorMessage?: string;
+  infoMessages?: string[];
+  nextPageToken?: string;
+};
+
+export const placesTextSearchResponseSchema: Schema<PlacesTextSearchResponse> =
+  s.object<PlacesTextSearchResponse>({
+    htmlAttributions: s.array(s.string()),
+    results: s.array(s.lazy(() => placeSchema)),
+    status: placesSearchStatusSchema,
+    errorMessage: s.optional(s.string()),
+    infoMessages: s.optional(s.array(s.string())),
+    nextPageToken: s.optional(s.string()),
+    _keysMap: {
+      htmlAttributions: "html_attributions",
+      errorMessage: "error_message",
+      infoMessages: "info_messages",
+      nextPageToken: "next_page_token",
+    },
+  });

package/src/models/plus-code.ts

@@ -0,0 +1,16 @@
+import * as s from "../core/validation/index.js";
+import type { Schema } from "../core/validation/schema.js";
+
+export type PlusCode = {
+  compoundCode?: string;
+  globalCode: string;
+};
+
+export const plusCodeSchema: Schema<PlusCode> = s.object<PlusCode>({
+  compoundCode: s.optional(s.string()),
+  globalCode: s.string(),
+  _keysMap: {
+    compoundCode: "compound_code",
+    globalCode: "global_code",
+  },
+});

package/src/models/plus-code1.ts

@@ -0,0 +1,16 @@
+import * as s from "../core/validation/index.js";
+import type { Schema } from "../core/validation/schema.js";
+
+export type PlusCode1 = {
+  compoundCode?: string;
+  globalCode: string;
+};
+
+export const plusCode1Schema: Schema<PlusCode1> = s.object<PlusCode1>({
+  compoundCode: s.optional(s.string()),
+  globalCode: s.string(),
+  _keysMap: {
+    compoundCode: "compound_code",
+    globalCode: "global_code",
+  },
+});

package/src/models/polyline.ts

@@ -0,0 +1,10 @@
+import * as s from "../core/validation/index.js";
+import type { Schema } from "../core/validation/schema.js";
+
+export type Polyline = {
+  points: string;
+};
+
+export const polylineSchema: Schema<Polyline> = s.object<Polyline>({
+  points: s.string(),
+});

package/src/models/rankby.ts

@@ -0,0 +1,10 @@
+import * as s from "../core/validation/index.js";
+import type { EnumSchema } from "../core/validation/schema.js";
+
+export const Rankby = {
+  Prominence: "prominence",
+  Distance: "distance",
+} as const;
+export type Rankby = (typeof Rankby)[keyof typeof Rankby] | (string & {});
+
+export const rankbySchema: EnumSchema<Rankby> = s.enumOf<Rankby>(Rankby);

package/src/models/rankby1.ts

@@ -0,0 +1,10 @@
+import * as s from "../core/validation/index.js";
+import type { EnumSchema } from "../core/validation/schema.js";
+
+export const Rankby1 = {
+  Prominence: "prominence",
+  Distance: "distance",
+} as const;
+export type Rankby1 = (typeof Rankby1)[keyof typeof Rankby1] | (string & {});
+
+export const rankby1Schema: EnumSchema<Rankby1> = s.enumOf<Rankby1>(Rankby1);