rafay-test-ts-gm 1.22.5

package/src/models/geolocation-request.ts

@@ -0,0 +1,24 @@
+import * as s from "../core/validation/index.js";
+import type { Schema } from "../core/validation/schema.js";
+import { cellTowerSchema, type CellTower } from "./cell-tower.js";
+import { wiFiAccessPointSchema, type WiFiAccessPoint } from "./wi-fi-access-point.js";
+
+export type GeolocationRequest = {
+  homeMobileCountryCode?: number;
+  homeMobileNetworkCode?: number;
+  radioType?: string;
+  carrier?: string;
+  considerIp?: string;
+  cellTowers?: CellTower[];
+  wifiAccessPoints?: WiFiAccessPoint[];
+};
+
+export const geolocationRequestSchema: Schema<GeolocationRequest> = s.object<GeolocationRequest>({
+  homeMobileCountryCode: s.optional(s.number()),
+  homeMobileNetworkCode: s.optional(s.number()),
+  radioType: s.optional(s.string()),
+  carrier: s.optional(s.string()),
+  considerIp: s.optional(s.string()),
+  cellTowers: s.optional(s.array(s.lazy(() => cellTowerSchema))),
+  wifiAccessPoints: s.optional(s.array(s.lazy(() => wiFiAccessPointSchema))),
+});

package/src/models/geolocation-response.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 GeolocationResponse = {
+  location: Location;
+  accuracy: number;
+};
+
+export const geolocationResponseSchema: Schema<GeolocationResponse> = s.object<GeolocationResponse>({
+  location: locationSchema,
+  accuracy: s.number(),
+});

package/src/models/geolocation-v1-geolocate-request.ts

@@ -0,0 +1,25 @@
+import * as s from "../core/validation/index.js";
+import type { Schema } from "../core/validation/schema.js";
+import { cellTowerSchema, type CellTower } from "./cell-tower.js";
+import { wiFiAccessPointSchema, type WiFiAccessPoint } from "./wi-fi-access-point.js";
+
+export type GeolocationV1GeolocateRequest = {
+  homeMobileCountryCode?: number;
+  homeMobileNetworkCode?: number;
+  radioType?: string;
+  carrier?: string;
+  considerIp?: string;
+  cellTowers?: CellTower[];
+  wifiAccessPoints?: WiFiAccessPoint[];
+};
+
+export const geolocationV1GeolocateRequestSchema: Schema<GeolocationV1GeolocateRequest> =
+  s.object<GeolocationV1GeolocateRequest>({
+    homeMobileCountryCode: s.optional(s.number()),
+    homeMobileNetworkCode: s.optional(s.number()),
+    radioType: s.optional(s.string()),
+    carrier: s.optional(s.string()),
+    considerIp: s.optional(s.string()),
+    cellTowers: s.optional(s.array(s.lazy(() => cellTowerSchema))),
+    wifiAccessPoints: s.optional(s.array(s.lazy(() => wiFiAccessPointSchema))),
+  });

package/src/models/geolocation-v1-geolocate-response.ts

@@ -0,0 +1,14 @@
+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 GeolocationV1GeolocateResponse = {
+  location: Location;
+  accuracy: number;
+};
+
+export const geolocationV1GeolocateResponseSchema: Schema<GeolocationV1GeolocateResponse> =
+  s.object<GeolocationV1GeolocateResponse>({
+    location: locationSchema,
+    accuracy: s.number(),
+  });

package/src/models/geolocation-v1-geolocate400-error.ts

@@ -0,0 +1,12 @@
+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 GeolocationV1Geolocate400Error = {
+  error: ErrorObject;
+};
+
+export const geolocationV1Geolocate400ErrorSchema: Schema<GeolocationV1Geolocate400Error> =
+  s.object<GeolocationV1Geolocate400Error>({
+    error: errorObjectSchema,
+  });

package/src/models/geolocation-v1-geolocate400-error1.ts

@@ -0,0 +1,12 @@
+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 GeolocationV1Geolocate400Error1 = {
+  error: ErrorObject;
+};
+
+export const geolocationV1Geolocate400Error1Schema: Schema<GeolocationV1Geolocate400Error1> =
+  s.object<GeolocationV1Geolocate400Error1>({
+    error: errorObjectSchema,
+  });

package/src/models/geolocation-v1-geolocate404-error.ts

@@ -0,0 +1,12 @@
+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 GeolocationV1Geolocate404Error = {
+  error: ErrorObject;
+};
+
+export const geolocationV1Geolocate404ErrorSchema: Schema<GeolocationV1Geolocate404Error> =
+  s.object<GeolocationV1Geolocate404Error>({
+    error: errorObjectSchema,
+  });

package/src/models/geolocation-v1-geolocate404-error1.ts

@@ -0,0 +1,12 @@
+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 GeolocationV1Geolocate404Error1 = {
+  error: ErrorObject;
+};
+
+export const geolocationV1Geolocate404Error1Schema: Schema<GeolocationV1Geolocate404Error1> =
+  s.object<GeolocationV1Geolocate404Error1>({
+    error: errorObjectSchema,
+  });

package/src/models/geometry.ts

@@ -0,0 +1,14 @@
+import * as s from "../core/validation/index.js";
+import type { Schema } from "../core/validation/schema.js";
+import { locationSchema, type Location } from "./location.js";
+import { viewportSchema, type Viewport } from "./viewport.js";
+
+export type Geometry = {
+  location: Location;
+  viewport: Viewport;
+};
+
+export const geometrySchema: Schema<Geometry> = s.object<Geometry>({
+  location: locationSchema,
+  viewport: viewportSchema,
+});

package/src/models/geometry1.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 Geometry1 = {
+  location: Location;
+  bounds?: Bounds1;
+  viewport: Viewport;
+};
+
+export const geometry1Schema: Schema<Geometry1> = s.object<Geometry1>({
+  location: locationSchema,
+  bounds: s.optional(s.lazy(() => bounds1Schema)),
+  viewport: viewportSchema,
+});

package/src/models/geometry2.ts

@@ -0,0 +1,14 @@
+import * as s from "../core/validation/index.js";
+import type { Schema } from "../core/validation/schema.js";
+import { locationSchema, type Location } from "./location.js";
+import { viewportSchema, type Viewport } from "./viewport.js";
+
+export type Geometry2 = {
+  location: Location;
+  viewport: Viewport;
+};
+
+export const geometry2Schema: Schema<Geometry2> = s.object<Geometry2>({
+  location: locationSchema,
+  viewport: viewportSchema,
+});

package/src/models/inputtype.ts

@@ -0,0 +1,10 @@
+import * as s from "../core/validation/index.js";
+import type { EnumSchema } from "../core/validation/schema.js";
+
+export const Inputtype = {
+  Textquery: "textquery",
+  Phonenumber: "phonenumber",
+} as const;
+export type Inputtype = (typeof Inputtype)[keyof typeof Inputtype] | (string & {});
+
+export const inputtypeSchema: EnumSchema<Inputtype> = s.enumOf<Inputtype>(Inputtype);

package/src/models/inputtype1.ts

@@ -0,0 +1,10 @@
+import * as s from "../core/validation/index.js";
+import type { EnumSchema } from "../core/validation/schema.js";
+
+export const Inputtype1 = {
+  Textquery: "textquery",
+  Phonenumber: "phonenumber",
+} as const;
+export type Inputtype1 = (typeof Inputtype1)[keyof typeof Inputtype1] | (string & {});
+
+export const inputtype1Schema: EnumSchema<Inputtype1> = s.enumOf<Inputtype1>(Inputtype1);

package/src/models/language.ts

@@ -0,0 +1,61 @@
+import * as s from "../core/validation/index.js";
+import type { EnumSchema } from "../core/validation/schema.js";
+
+export const Language = {
+  Ar: "ar",
+  Bg: "bg",
+  Bn: "bn",
+  Ca: "ca",
+  Cs: "cs",
+  Da: "da",
+  De: "de",
+  El: "el",
+  En: "en",
+  EnAu: "en-AU",
+  EnGb: "en-GB",
+  Es: "es",
+  Eu: "eu",
+  Fa: "fa",
+  Fi: "fi",
+  Fil: "fil",
+  Fr: "fr",
+  Gl: "gl",
+  Gu: "gu",
+  Hi: "hi",
+  Hr: "hr",
+  Hu: "hu",
+  Id: "id",
+  It: "it",
+  Iw: "iw",
+  Ja: "ja",
+  Kn: "kn",
+  Ko: "ko",
+  Lt: "lt",
+  Lv: "lv",
+  Ml: "ml",
+  Mr: "mr",
+  Nl: "nl",
+  No: "no",
+  Pl: "pl",
+  Pt: "pt",
+  PtBr: "pt-BR",
+  PtPt: "pt-PT",
+  Ro: "ro",
+  Ru: "ru",
+  Sk: "sk",
+  Sl: "sl",
+  Sr: "sr",
+  Sv: "sv",
+  Ta: "ta",
+  Te: "te",
+  Th: "th",
+  Tl: "tl",
+  Tr: "tr",
+  Uk: "uk",
+  Vi: "vi",
+  ZhCn: "zh-CN",
+  ZhTw: "zh-TW",
+} as const;
+export type Language = (typeof Language)[keyof typeof Language] | (string & {});
+
+export const languageSchema: EnumSchema<Language> = s.enumOf<Language>(Language);

package/src/models/language1.ts

@@ -0,0 +1,61 @@
+import * as s from "../core/validation/index.js";
+import type { EnumSchema } from "../core/validation/schema.js";
+
+export const Language1 = {
+  Ar: "ar",
+  Bg: "bg",
+  Bn: "bn",
+  Ca: "ca",
+  Cs: "cs",
+  Da: "da",
+  De: "de",
+  El: "el",
+  En: "en",
+  EnAu: "en-AU",
+  EnGb: "en-GB",
+  Es: "es",
+  Eu: "eu",
+  Fa: "fa",
+  Fi: "fi",
+  Fil: "fil",
+  Fr: "fr",
+  Gl: "gl",
+  Gu: "gu",
+  Hi: "hi",
+  Hr: "hr",
+  Hu: "hu",
+  Id: "id",
+  It: "it",
+  Iw: "iw",
+  Ja: "ja",
+  Kn: "kn",
+  Ko: "ko",
+  Lt: "lt",
+  Lv: "lv",
+  Ml: "ml",
+  Mr: "mr",
+  Nl: "nl",
+  No: "no",
+  Pl: "pl",
+  Pt: "pt",
+  PtBr: "pt-BR",
+  PtPt: "pt-PT",
+  Ro: "ro",
+  Ru: "ru",
+  Sk: "sk",
+  Sl: "sl",
+  Sr: "sr",
+  Sv: "sv",
+  Ta: "ta",
+  Te: "te",
+  Th: "th",
+  Tl: "tl",
+  Tr: "tr",
+  Uk: "uk",
+  Vi: "vi",
+  ZhCn: "zh-CN",
+  ZhTw: "zh-TW",
+} as const;
+export type Language1 = (typeof Language1)[keyof typeof Language1] | (string & {});
+
+export const language1Schema: EnumSchema<Language1> = s.enumOf<Language1>(Language1);

package/src/models/lat-lng-literal.ts

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

package/src/models/latitude-longitude-literal.ts

@@ -0,0 +1,13 @@
+import * as s from "../core/validation/index.js";
+import type { Schema } from "../core/validation/schema.js";
+
+export type LatitudeLongitudeLiteral = {
+  latitude: number;
+  longitude: number;
+};
+
+export const latitudeLongitudeLiteralSchema: Schema<LatitudeLongitudeLiteral> =
+  s.object<LatitudeLongitudeLiteral>({
+    latitude: s.number(),
+    longitude: s.number(),
+  });

package/src/models/location-type.ts

@@ -0,0 +1,12 @@
+import * as s from "../core/validation/index.js";
+import type { EnumSchema } from "../core/validation/schema.js";
+
+export const LocationType = {
+  Approximate: "APPROXIMATE",
+  GeometricCenter: "GEOMETRIC_CENTER",
+  RangeInterpolated: "RANGE_INTERPOLATED",
+  Rooftop: "ROOFTOP",
+} as const;
+export type LocationType = (typeof LocationType)[keyof typeof LocationType] | (string & {});
+
+export const locationTypeSchema: EnumSchema<LocationType> = s.enumOf<LocationType>(LocationType);

package/src/models/location.ts

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

package/src/models/location6.ts

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

package/src/models/maneuver.ts

@@ -0,0 +1,28 @@
+import * as s from "../core/validation/index.js";
+import type { EnumSchema } from "../core/validation/schema.js";
+
+export const Maneuver = {
+  TurnSlightLeft: "turn-slight-left",
+  TurnSharpLeft: "turn-sharp-left",
+  TurnLeft: "turn-left",
+  TurnSlightRight: "turn-slight-right",
+  TurnSharpRight: "turn-sharp-right",
+  KeepRight: "keep-right",
+  KeepLeft: "keep-left",
+  UturnLeft: "uturn-left",
+  UturnRight: "uturn-right",
+  TurnRight: "turn-right",
+  Straight: "straight",
+  RampLeft: "ramp-left",
+  RampRight: "ramp-right",
+  Merge: "merge",
+  ForkLeft: "fork-left",
+  ForkRight: "fork-right",
+  Ferry: "ferry",
+  FerryTrain: "ferry-train",
+  RoundaboutLeft: "roundabout-left",
+  RoundaboutRight: "roundabout-right",
+} as const;
+export type Maneuver = (typeof Maneuver)[keyof typeof Maneuver] | (string & {});
+
+export const maneuverSchema: EnumSchema<Maneuver> = s.enumOf<Maneuver>(Maneuver);

package/src/models/maps-api-elevation-json-response.ts

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

package/src/models/maxprice.ts

@@ -0,0 +1,13 @@
+import * as s from "../core/validation/index.js";
+import type { EnumSchema } from "../core/validation/schema.js";
+
+export const Maxprice = {
+  _0: "0",
+  _1: "1",
+  _2: "2",
+  _3: "3",
+  _4: "4",
+} as const;
+export type Maxprice = (typeof Maxprice)[keyof typeof Maxprice] | (string & {});
+
+export const maxpriceSchema: EnumSchema<Maxprice> = s.enumOf<Maxprice>(Maxprice);

package/src/models/maxprice1.ts

@@ -0,0 +1,13 @@
+import * as s from "../core/validation/index.js";
+import type { EnumSchema } from "../core/validation/schema.js";
+
+export const Maxprice1 = {
+  _0: "0",
+  _1: "1",
+  _2: "2",
+  _3: "3",
+  _4: "4",
+} as const;
+export type Maxprice1 = (typeof Maxprice1)[keyof typeof Maxprice1] | (string & {});
+
+export const maxprice1Schema: EnumSchema<Maxprice1> = s.enumOf<Maxprice1>(Maxprice1);

package/src/models/minprice.ts

@@ -0,0 +1,13 @@
+import * as s from "../core/validation/index.js";
+import type { EnumSchema } from "../core/validation/schema.js";
+
+export const Minprice = {
+  _0: "0",
+  _1: "1",
+  _2: "2",
+  _3: "3",
+  _4: "4",
+} as const;
+export type Minprice = (typeof Minprice)[keyof typeof Minprice] | (string & {});
+
+export const minpriceSchema: EnumSchema<Minprice> = s.enumOf<Minprice>(Minprice);

package/src/models/minprice1.ts

@@ -0,0 +1,13 @@
+import * as s from "../core/validation/index.js";
+import type { EnumSchema } from "../core/validation/schema.js";
+
+export const Minprice1 = {
+  _0: "0",
+  _1: "1",
+  _2: "2",
+  _3: "3",
+  _4: "4",
+} as const;
+export type Minprice1 = (typeof Minprice1)[keyof typeof Minprice1] | (string & {});
+
+export const minprice1Schema: EnumSchema<Minprice1> = s.enumOf<Minprice1>(Minprice1);

package/src/models/mode.ts

@@ -0,0 +1,12 @@
+import * as s from "../core/validation/index.js";
+import type { EnumSchema } from "../core/validation/schema.js";
+
+export const Mode = {
+  Driving: "driving",
+  Bicycling: "bicycling",
+  Transit: "transit",
+  Walking: "walking",
+} as const;
+export type Mode = (typeof Mode)[keyof typeof Mode] | (string & {});
+
+export const modeSchema: EnumSchema<Mode> = s.enumOf<Mode>(Mode);

package/src/models/mode1.ts

@@ -0,0 +1,12 @@
+import * as s from "../core/validation/index.js";
+import type { EnumSchema } from "../core/validation/schema.js";
+
+export const Mode1 = {
+  Driving: "driving",
+  Bicycling: "bicycling",
+  Transit: "transit",
+  Walking: "walking",
+} as const;
+export type Mode1 = (typeof Mode1)[keyof typeof Mode1] | (string & {});
+
+export const mode1Schema: EnumSchema<Mode1> = s.enumOf<Mode1>(Mode1);

package/src/models/nearest-roads-error-response.ts

@@ -0,0 +1,12 @@
+import * as s from "../core/validation/index.js";
+import type { Schema } from "../core/validation/schema.js";
+import { nearestRoadsErrorSchema, type NearestRoadsError } from "./nearest-roads-error.js";
+
+export type NearestRoadsErrorResponse = {
+  error?: NearestRoadsError;
+};
+
+export const nearestRoadsErrorResponseSchema: Schema<NearestRoadsErrorResponse> =
+  s.object<NearestRoadsErrorResponse>({
+    error: s.optional(s.lazy(() => nearestRoadsErrorSchema)),
+  });

package/src/models/nearest-roads-error.ts

@@ -0,0 +1,14 @@
+import * as s from "../core/validation/index.js";
+import type { Schema } from "../core/validation/schema.js";
+
+export type NearestRoadsError = {
+  code: number;
+  message: string;
+  status: string;
+};
+
+export const nearestRoadsErrorSchema: Schema<NearestRoadsError> = s.object<NearestRoadsError>({
+  code: s.number(),
+  message: s.string(),
+  status: s.string(),
+});

package/src/models/nearest-roads-response.ts

@@ -0,0 +1,11 @@
+import * as s from "../core/validation/index.js";
+import type { Schema } from "../core/validation/schema.js";
+import { snappedPointSchema, type SnappedPoint } from "./snapped-point.js";
+
+export type NearestRoadsResponse = {
+  snappedPoints?: SnappedPoint[];
+};
+
+export const nearestRoadsResponseSchema: Schema<NearestRoadsResponse> = s.object<NearestRoadsResponse>({
+  snappedPoints: s.optional(s.array(s.lazy(() => snappedPointSchema))),
+});

package/src/models/northeast.ts

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

package/src/models/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 OpeningHours = {
+  openNow?: boolean;
+  periods?: PlaceOpeningHoursPeriod[];
+  specialDays?: PlaceSpecialDay[];
+  type?: string;
+  weekdayText?: string[];
+};
+
+export const openingHoursSchema: Schema<OpeningHours> = s.object<OpeningHours>({
+  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/overview-polyline.ts

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

package/src/models/place-autocomplete-matched-substring.ts

@@ -0,0 +1,13 @@
+import * as s from "../core/validation/index.js";
+import type { Schema } from "../core/validation/schema.js";
+
+export type PlaceAutocompleteMatchedSubstring = {
+  length: number;
+  offset: number;
+};
+
+export const placeAutocompleteMatchedSubstringSchema: Schema<PlaceAutocompleteMatchedSubstring> =
+  s.object<PlaceAutocompleteMatchedSubstring>({
+    length: s.number(),
+    offset: s.number(),
+  });