rafay-test-ts-gm 1.22.5

package/src/models/directions-step.ts

@@ -0,0 +1,43 @@
+import * as s from "../core/validation/index.js";
+import type { Schema } from "../core/validation/schema.js";
+import { distanceSchema, type Distance } from "./distance.js";
+import { durationSchema, type Duration } from "./duration.js";
+import { endLocationSchema, type EndLocation } from "./end-location.js";
+import { maneuverSchema, type Maneuver } from "./maneuver.js";
+import { polylineSchema, type Polyline } from "./polyline.js";
+import { startLocationSchema, type StartLocation } from "./start-location.js";
+import { transitDetailsSchema, type TransitDetails } from "./transit-details.js";
+import { travelModeSchema, type TravelMode } from "./travel-mode.js";
+
+export type DirectionsStep = {
+  distance?: Distance;
+  duration: Duration;
+  endLocation: EndLocation;
+  htmlInstructions: string;
+  maneuver?: Maneuver;
+  polyline: Polyline;
+  startLocation: StartLocation;
+  transitDetails?: TransitDetails;
+  travelMode: TravelMode;
+  steps?: Record<string, unknown>;
+};
+
+export const directionsStepSchema: Schema<DirectionsStep> = s.object<DirectionsStep>({
+  distance: s.optional(s.lazy(() => distanceSchema)),
+  duration: durationSchema,
+  endLocation: endLocationSchema,
+  htmlInstructions: s.string(),
+  maneuver: s.optional(s.lazy(() => maneuverSchema)),
+  polyline: polylineSchema,
+  startLocation: startLocationSchema,
+  transitDetails: s.optional(s.lazy(() => transitDetailsSchema)),
+  travelMode: travelModeSchema,
+  steps: s.optional(s.record(s.string(), s.unknown())),
+  _keysMap: {
+    endLocation: "end_location",
+    htmlInstructions: "html_instructions",
+    startLocation: "start_location",
+    transitDetails: "transit_details",
+    travelMode: "travel_mode",
+  },
+});

package/src/models/directions-traffic-speed-entry.ts

@@ -0,0 +1,17 @@
+import * as s from "../core/validation/index.js";
+import type { Schema } from "../core/validation/schema.js";
+
+export type DirectionsTrafficSpeedEntry = {
+  speedCategory: string;
+  offsetMeters: number;
+};
+
+export const directionsTrafficSpeedEntrySchema: Schema<DirectionsTrafficSpeedEntry> =
+  s.object<DirectionsTrafficSpeedEntry>({
+    speedCategory: s.string(),
+    offsetMeters: s.number(),
+    _keysMap: {
+      speedCategory: "speed_category",
+      offsetMeters: "offset_meters",
+    },
+  });

package/src/models/directions-transit-agency.ts

@@ -0,0 +1,15 @@
+import * as s from "../core/validation/index.js";
+import type { Schema } from "../core/validation/schema.js";
+
+export type DirectionsTransitAgency = {
+  name?: string;
+  phone?: string;
+  url?: string;
+};
+
+export const directionsTransitAgencySchema: Schema<DirectionsTransitAgency> =
+  s.object<DirectionsTransitAgency>({
+    name: s.optional(s.string()),
+    phone: s.optional(s.string()),
+    url: s.optional(s.string()),
+  });

package/src/models/directions-transit-details.ts

@@ -0,0 +1,39 @@
+import * as s from "../core/validation/index.js";
+import type { Schema } from "../core/validation/schema.js";
+import { arrivalTimeSchema, type ArrivalTime } from "./arrival-time.js";
+import { departureTimeSchema, type DepartureTime } from "./departure-time.js";
+import { directionsTransitLineSchema, type DirectionsTransitLine } from "./directions-transit-line.js";
+import { directionsTransitStopSchema, type DirectionsTransitStop } from "./directions-transit-stop.js";
+
+export type DirectionsTransitDetails = {
+  arrivalStop?: DirectionsTransitStop;
+  arrivalTime?: ArrivalTime;
+  departureStop?: DirectionsTransitStop;
+  departureTime?: DepartureTime;
+  headsign?: string;
+  headway?: number;
+  line?: DirectionsTransitLine;
+  numStops?: number;
+  tripShortName?: string;
+};
+
+export const directionsTransitDetailsSchema: Schema<DirectionsTransitDetails> =
+  s.object<DirectionsTransitDetails>({
+    arrivalStop: s.optional(s.lazy(() => directionsTransitStopSchema)),
+    arrivalTime: s.optional(s.lazy(() => arrivalTimeSchema)),
+    departureStop: s.optional(s.lazy(() => directionsTransitStopSchema)),
+    departureTime: s.optional(s.lazy(() => departureTimeSchema)),
+    headsign: s.optional(s.string()),
+    headway: s.optional(s.number()),
+    line: s.optional(s.lazy(() => directionsTransitLineSchema)),
+    numStops: s.optional(s.number()),
+    tripShortName: s.optional(s.string()),
+    _keysMap: {
+      arrivalStop: "arrival_stop",
+      arrivalTime: "arrival_time",
+      departureStop: "departure_stop",
+      departureTime: "departure_time",
+      numStops: "num_stops",
+      tripShortName: "trip_short_name",
+    },
+  });

package/src/models/directions-transit-line.ts

@@ -0,0 +1,33 @@
+import * as s from "../core/validation/index.js";
+import type { Schema } from "../core/validation/schema.js";
+import { directionsTransitAgencySchema, type DirectionsTransitAgency } from "./directions-transit-agency.js";
+import {
+  directionsTransitVehicleSchema,
+  type DirectionsTransitVehicle,
+} from "./directions-transit-vehicle.js";
+
+export type DirectionsTransitLine = {
+  agencies: DirectionsTransitAgency[];
+  color?: string;
+  name: string;
+  shortName?: string;
+  textColor?: string;
+  url?: string;
+  icon?: string;
+  vehicle?: DirectionsTransitVehicle;
+};
+
+export const directionsTransitLineSchema: Schema<DirectionsTransitLine> = s.object<DirectionsTransitLine>({
+  agencies: s.array(s.lazy(() => directionsTransitAgencySchema)),
+  color: s.optional(s.string()),
+  name: s.string(),
+  shortName: s.optional(s.string()),
+  textColor: s.optional(s.string()),
+  url: s.optional(s.string()),
+  icon: s.optional(s.string()),
+  vehicle: s.optional(s.lazy(() => directionsTransitVehicleSchema)),
+  _keysMap: {
+    shortName: "short_name",
+    textColor: "text_color",
+  },
+});

package/src/models/directions-transit-stop.ts

@@ -0,0 +1,13 @@
+import * as s from "../core/validation/index.js";
+import type { Schema } from "../core/validation/schema.js";
+import { locationSchema, type Location } from "./location.js";
+
+export type DirectionsTransitStop = {
+  location: Location;
+  name: string;
+};
+
+export const directionsTransitStopSchema: Schema<DirectionsTransitStop> = s.object<DirectionsTransitStop>({
+  location: locationSchema,
+  name: s.string(),
+});

package/src/models/directions-transit-vehicle.ts

@@ -0,0 +1,22 @@
+import * as s from "../core/validation/index.js";
+import type { Schema } from "../core/validation/schema.js";
+import { vehicleTypeSchema, type VehicleType } from "./vehicle-type.js";
+
+export type DirectionsTransitVehicle = {
+  icon?: string;
+  localIcon?: string;
+  name: string;
+  vehicleType?: VehicleType;
+};
+
+export const directionsTransitVehicleSchema: Schema<DirectionsTransitVehicle> =
+  s.object<DirectionsTransitVehicle>({
+    icon: s.optional(s.string()),
+    localIcon: s.optional(s.string()),
+    name: s.string(),
+    vehicleType: s.optional(s.lazy(() => vehicleTypeSchema)),
+    _keysMap: {
+      localIcon: "local_icon",
+      vehicleType: "vehicle_type",
+    },
+  });

package/src/models/directions-via-waypoint.ts

@@ -0,0 +1,19 @@
+import * as s from "../core/validation/index.js";
+import type { Schema } from "../core/validation/schema.js";
+import { locationSchema, type Location } from "./location.js";
+
+export type DirectionsViaWaypoint = {
+  location?: Location;
+  stepIndex?: number;
+  stepInterpolation?: number;
+};
+
+export const directionsViaWaypointSchema: Schema<DirectionsViaWaypoint> = s.object<DirectionsViaWaypoint>({
+  location: s.optional(s.lazy(() => locationSchema)),
+  stepIndex: s.optional(s.number()),
+  stepInterpolation: s.optional(s.number()),
+  _keysMap: {
+    stepIndex: "step_index",
+    stepInterpolation: "step_interpolation",
+  },
+});

package/src/models/distance-matrix-element-status.ts

@@ -0,0 +1,15 @@
+import * as s from "../core/validation/index.js";
+import type { EnumSchema } from "../core/validation/schema.js";
+
+export const DistanceMatrixElementStatus = {
+  Ok: "OK",
+  NotFound: "NOT_FOUND",
+  ZeroResults: "ZERO_RESULTS",
+  MaxRouteLengthExceeded: "MAX_ROUTE_LENGTH_EXCEEDED",
+} as const;
+export type DistanceMatrixElementStatus =
+  | (typeof DistanceMatrixElementStatus)[keyof typeof DistanceMatrixElementStatus]
+  | (string & {});
+
+export const distanceMatrixElementStatusSchema: EnumSchema<DistanceMatrixElementStatus> =
+  s.enumOf<DistanceMatrixElementStatus>(DistanceMatrixElementStatus);

package/src/models/distance-matrix-element.ts

@@ -0,0 +1,29 @@
+import * as s from "../core/validation/index.js";
+import type { Schema } from "../core/validation/schema.js";
+import {
+  distanceMatrixElementStatusSchema,
+  type DistanceMatrixElementStatus,
+} from "./distance-matrix-element-status.js";
+import { distanceSchema, type Distance } from "./distance.js";
+import { durationInTrafficSchema, type DurationInTraffic } from "./duration-in-traffic.js";
+import { durationSchema, type Duration } from "./duration.js";
+import { fare1Schema, type Fare1 } from "./fare1.js";
+
+export type DistanceMatrixElement = {
+  fare?: Fare1;
+  distance?: Distance;
+  durationInTraffic?: DurationInTraffic;
+  duration?: Duration;
+  status: DistanceMatrixElementStatus;
+};
+
+export const distanceMatrixElementSchema: Schema<DistanceMatrixElement> = s.object<DistanceMatrixElement>({
+  fare: s.optional(s.lazy(() => fare1Schema)),
+  distance: s.optional(s.lazy(() => distanceSchema)),
+  durationInTraffic: s.optional(s.lazy(() => durationInTrafficSchema)),
+  duration: s.optional(s.lazy(() => durationSchema)),
+  status: distanceMatrixElementStatusSchema,
+  _keysMap: {
+    durationInTraffic: "duration_in_traffic",
+  },
+});

package/src/models/distance-matrix-response.ts

@@ -0,0 +1,25 @@
+import * as s from "../core/validation/index.js";
+import type { Schema } from "../core/validation/schema.js";
+import { distanceMatrixRowSchema, type DistanceMatrixRow } from "./distance-matrix-row.js";
+import { distanceMatrixStatusSchema, type DistanceMatrixStatus } from "./distance-matrix-status.js";
+
+export type DistanceMatrixResponse = {
+  originAddresses: string[];
+  destinationAddresses: string[];
+  rows: DistanceMatrixRow[];
+  status: DistanceMatrixStatus;
+  errorMessage?: string;
+};
+
+export const distanceMatrixResponseSchema: Schema<DistanceMatrixResponse> = s.object<DistanceMatrixResponse>({
+  originAddresses: s.array(s.string()),
+  destinationAddresses: s.array(s.string()),
+  rows: s.array(s.lazy(() => distanceMatrixRowSchema)),
+  status: distanceMatrixStatusSchema,
+  errorMessage: s.optional(s.string()),
+  _keysMap: {
+    originAddresses: "origin_addresses",
+    destinationAddresses: "destination_addresses",
+    errorMessage: "error_message",
+  },
+});

package/src/models/distance-matrix-row.ts

@@ -0,0 +1,11 @@
+import * as s from "../core/validation/index.js";
+import type { Schema } from "../core/validation/schema.js";
+import { distanceMatrixElementSchema, type DistanceMatrixElement } from "./distance-matrix-element.js";
+
+export type DistanceMatrixRow = {
+  elements: DistanceMatrixElement[];
+};
+
+export const distanceMatrixRowSchema: Schema<DistanceMatrixRow> = s.object<DistanceMatrixRow>({
+  elements: s.array(s.lazy(() => distanceMatrixElementSchema)),
+});

package/src/models/distance-matrix-status.ts

@@ -0,0 +1,19 @@
+import * as s from "../core/validation/index.js";
+import type { EnumSchema } from "../core/validation/schema.js";
+
+export const DistanceMatrixStatus = {
+  Ok: "OK",
+  InvalidRequest: "INVALID_REQUEST",
+  MaxElementsExceeded: "MAX_ELEMENTS_EXCEEDED",
+  MaxDimensionsExceeded: "MAX_DIMENSIONS_EXCEEDED",
+  OverDailyLimit: "OVER_DAILY_LIMIT",
+  OverQueryLimit: "OVER_QUERY_LIMIT",
+  RequestDenied: "REQUEST_DENIED",
+  UnknownError: "UNKNOWN_ERROR",
+} as const;
+export type DistanceMatrixStatus =
+  | (typeof DistanceMatrixStatus)[keyof typeof DistanceMatrixStatus]
+  | (string & {});
+
+export const distanceMatrixStatusSchema: EnumSchema<DistanceMatrixStatus> =
+  s.enumOf<DistanceMatrixStatus>(DistanceMatrixStatus);

package/src/models/distance.ts

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

package/src/models/duration-in-traffic.ts

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

package/src/models/duration.ts

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

package/src/models/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 EditorialSummary = {
+  overview?: string;
+  language?: string;
+};
+
+export const editorialSummarySchema: Schema<EditorialSummary> = s.object<EditorialSummary>({
+  overview: s.optional(s.string()),
+  language: s.optional(s.string()),
+});

package/src/models/elevation-response.ts

@@ -0,0 +1,19 @@
+import * as s from "../core/validation/index.js";
+import type { Schema } from "../core/validation/schema.js";
+import { elevationResultSchema, type ElevationResult } from "./elevation-result.js";
+import { elevationStatusSchema, type ElevationStatus } from "./elevation-status.js";
+
+export type ElevationResponse = {
+  errorMessage?: string;
+  status: ElevationStatus;
+  results: ElevationResult[];
+};
+
+export const elevationResponseSchema: Schema<ElevationResponse> = s.object<ElevationResponse>({
+  errorMessage: s.optional(s.string()),
+  status: elevationStatusSchema,
+  results: s.array(s.lazy(() => elevationResultSchema)),
+  _keysMap: {
+    errorMessage: "error_message",
+  },
+});

package/src/models/elevation-result.ts

@@ -0,0 +1,15 @@
+import * as s from "../core/validation/index.js";
+import type { Schema } from "../core/validation/schema.js";
+import { locationSchema, type Location } from "./location.js";
+
+export type ElevationResult = {
+  elevation: number;
+  resolution?: number;
+  location: Location;
+};
+
+export const elevationResultSchema: Schema<ElevationResult> = s.object<ElevationResult>({
+  elevation: s.number(),
+  resolution: s.optional(s.number()),
+  location: locationSchema,
+});

package/src/models/elevation-status.ts

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

package/src/models/end-location.ts

@@ -0,0 +1,12 @@
+import * as s from "../core/validation/index.js";
+import type { Schema } from "../core/validation/schema.js";
+
+export type EndLocation = {
+  lat: number;
+  lng: number;
+};
+
+export const endLocationSchema: Schema<EndLocation> = s.object<EndLocation>({
+  lat: s.number(),
+  lng: s.number(),
+});

package/src/models/error-detail.ts

@@ -0,0 +1,24 @@
+import * as s from "../core/validation/index.js";
+import type { Schema } from "../core/validation/schema.js";
+import { fieldViolationSchema, type FieldViolation } from "./field-violation.js";
+
+export type ErrorDetail = {
+  type?: string;
+  message?: string;
+  reason?: string;
+  domain?: string;
+  metadata?: Record<string, unknown>;
+  fieldViolations?: FieldViolation[];
+};
+
+export const errorDetailSchema: Schema<ErrorDetail> = s.object<ErrorDetail>({
+  type: s.optional(s.string()),
+  message: s.optional(s.string()),
+  reason: s.optional(s.string()),
+  domain: s.optional(s.string()),
+  metadata: s.optional(s.record(s.string(), s.unknown())),
+  fieldViolations: s.optional(s.array(s.lazy(() => fieldViolationSchema))),
+  _keysMap: {
+    type: "@type",
+  },
+});

package/src/models/error-object.ts

@@ -0,0 +1,19 @@
+import * as s from "../core/validation/index.js";
+import type { Schema } from "../core/validation/schema.js";
+import { errorDetailSchema, type ErrorDetail } from "./error-detail.js";
+
+export type ErrorObject = {
+  code: number;
+  message: string;
+  errors: ErrorDetail[];
+  status?: string;
+  details?: ErrorDetail[];
+};
+
+export const errorObjectSchema: Schema<ErrorObject> = s.object<ErrorObject>({
+  code: s.number(),
+  message: s.string(),
+  errors: s.array(s.lazy(() => errorDetailSchema)),
+  status: s.optional(s.string()),
+  details: s.optional(s.array(s.lazy(() => errorDetailSchema))),
+});

package/src/models/error-response.ts

@@ -0,0 +1,11 @@
+import * as s from "../core/validation/index.js";
+import type { Schema } from "../core/validation/schema.js";
+import { errorObjectSchema, type ErrorObject } from "./error-object.js";
+
+export type ErrorResponse = {
+  error: ErrorObject;
+};
+
+export const errorResponseSchema: Schema<ErrorResponse> = s.object<ErrorResponse>({
+  error: errorObjectSchema,
+});

package/src/models/fare.ts

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

package/src/models/fare1.ts

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

package/src/models/field-violation.ts

@@ -0,0 +1,12 @@
+import * as s from "../core/validation/index.js";
+import type { Schema } from "../core/validation/schema.js";
+
+export type FieldViolation = {
+  field: string;
+  description: string;
+};
+
+export const fieldViolationSchema: Schema<FieldViolation> = s.object<FieldViolation>({
+  field: s.string(),
+  description: s.string(),
+});

package/src/models/geocoder-status.ts

@@ -0,0 +1,10 @@
+import * as s from "../core/validation/index.js";
+import type { EnumSchema } from "../core/validation/schema.js";
+
+export const GeocoderStatus = {
+  Ok: "OK",
+  ZeroResults: "ZERO_RESULTS",
+} as const;
+export type GeocoderStatus = (typeof GeocoderStatus)[keyof typeof GeocoderStatus] | (string & {});
+
+export const geocoderStatusSchema: EnumSchema<GeocoderStatus> = s.enumOf<GeocoderStatus>(GeocoderStatus);

package/src/models/geocoding-geometry.ts

@@ -0,0 +1,17 @@
+import * as s from "../core/validation/index.js";
+import type { Schema } from "../core/validation/schema.js";
+import { bounds1Schema, type Bounds1 } from "./bounds1.js";
+import { locationSchema, type Location } from "./location.js";
+import { viewportSchema, type Viewport } from "./viewport.js";
+
+export type GeocodingGeometry = {
+  location: Location;
+  bounds?: Bounds1;
+  viewport: Viewport;
+};
+
+export const geocodingGeometrySchema: Schema<GeocodingGeometry> = s.object<GeocodingGeometry>({
+  location: locationSchema,
+  bounds: s.optional(s.lazy(() => bounds1Schema)),
+  viewport: viewportSchema,
+});

package/src/models/geocoding-response.ts

@@ -0,0 +1,23 @@
+import * as s from "../core/validation/index.js";
+import type { Schema } from "../core/validation/schema.js";
+import { geocodingResultSchema, type GeocodingResult } from "./geocoding-result.js";
+import { geocodingStatusSchema, type GeocodingStatus } from "./geocoding-status.js";
+import { plusCode1Schema, type PlusCode1 } from "./plus-code1.js";
+
+export type GeocodingResponse = {
+  plusCode?: PlusCode1;
+  results: GeocodingResult[];
+  status: GeocodingStatus;
+  errorMessage?: string;
+};
+
+export const geocodingResponseSchema: Schema<GeocodingResponse> = s.object<GeocodingResponse>({
+  plusCode: s.optional(s.lazy(() => plusCode1Schema)),
+  results: s.array(s.lazy(() => geocodingResultSchema)),
+  status: geocodingStatusSchema,
+  errorMessage: s.optional(s.string()),
+  _keysMap: {
+    plusCode: "plus_code",
+    errorMessage: "error_message",
+  },
+});

package/src/models/geocoding-result.ts

@@ -0,0 +1,35 @@
+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 { geometry1Schema, type Geometry1 } from "./geometry1.js";
+import { plusCode1Schema, type PlusCode1 } from "./plus-code1.js";
+
+export type GeocodingResult = {
+  addressComponents: AddressComponent[];
+  formattedAddress: string;
+  geometry: Geometry1;
+  placeId: string;
+  plusCode?: PlusCode1;
+  types: string[];
+  postcodeLocalities?: string[];
+  partialMatch?: boolean;
+};
+
+export const geocodingResultSchema: Schema<GeocodingResult> = s.object<GeocodingResult>({
+  addressComponents: s.array(s.lazy(() => addressComponentSchema)),
+  formattedAddress: s.string(),
+  geometry: geometry1Schema,
+  placeId: s.string(),
+  plusCode: s.optional(s.lazy(() => plusCode1Schema)),
+  types: s.array(s.string()),
+  postcodeLocalities: s.optional(s.array(s.string())),
+  partialMatch: s.optional(s.boolean()),
+  _keysMap: {
+    addressComponents: "address_components",
+    formattedAddress: "formatted_address",
+    placeId: "place_id",
+    plusCode: "plus_code",
+    postcodeLocalities: "postcode_localities",
+    partialMatch: "partial_match",
+  },
+});

package/src/models/geocoding-status.ts

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