@revolugo/common 6.14.4 → 6.14.5-beta.0

package/package.json

@@ -1,10 +1,16 @@
 {
   "name": "@revolugo/common",
-  "version": "6.14.4",
+  "version": "6.14.5-beta.0",
   "private": false,
   "description": "Revolugo common",
   "author": "Revolugo",
   "type": "module",
+  "engines": {
+    "node": ">=20.18.1 <25"
+  },
+  "volta": {
+    "extends": "../../package.json"
+  },
   "files": [
     "src"
   ],
@@ -17,6 +23,7 @@
     "./icons": "./src/icons/index.ts",
     "./map": "./src/map/index.ts",
     "./models": "./src/models/index.ts",
+    "./schemas": "./src/schemas/index.ts",
     "./types": "./src/types/index.ts",
     "./utils": "./src/utils/index.ts"
   },
@@ -25,13 +32,9 @@
     "dayjs": "1.11.19",
     "ky": "1.14.0",
     "slugify": "1.6.6",
-    "uuid": "13.0.0"
-  },
-  "engines": {
-    "node": ">=20.18.1 <25"
-  },
-  "volta": {
-    "extends": "../../package.json"
+    "type-fest": "5.3.0",
+    "uuid": "13.0.0",
+    "zod": "3.25.76"
   },
   "scripts": {
     "test": "vitest"

package/src/constants/hotel-room-offer.ts

@@ -0,0 +1,11 @@
+export enum HotelRoomOfferType {
+  HotelRoom = 'HOTEL_ROOM',
+  Package = 'PACKAGE',
+}
+
+export enum PackageType {
+  BestMatch = 'BEST_MATCH',
+  Cheapest = 'CHEAPEST',
+  MatchingRoomCount = 'MATCHING_ROOM_COUNT',
+  Regular = 'REGULAR',
+}

package/src/constants/index.ts

@@ -1,12 +1,13 @@
 export * from '../countries/constants.ts'
 export * from '../currencies/constants.ts'
-
 export * from './environment.ts'
 export * from './hotel.ts'
 export * from './hotel-offers.ts'
+export * from './hotel-room-offer.ts'
 export * from './locales.ts'
 export * from './measurement.ts'
 export * from './poller.ts'
+export * from './tax.ts'
 export * from './time.ts'
 export * from './stay-taxes-info.ts'
 export * from './venue.ts'

package/src/constants/locales.ts

@@ -33,11 +33,11 @@ export function langFromString(langStr: string): Lang | undefined {
 export const LANG_TO_LOCALE: Record<Lang, Locale> = {
   [Lang.EN]: Locale.en_US,
   [Lang.FR]: Locale.fr_FR,
-  [Lang.DE]: Locale.en_US,
-  [Lang.ES]: Locale.en_US,
-  [Lang.IT]: Locale.en_US,
-  [Lang.NL]: Locale.en_US,
-  [Lang.PT]: Locale.en_US,
+  [Lang.DE]: Locale.de_DE,
+  [Lang.ES]: Locale.es_ES,
+  [Lang.IT]: Locale.it_IT,
+  [Lang.NL]: Locale.nl_NL,
+  [Lang.PT]: Locale.pt_PT,
 }
 
 /* @__PURE__ */

package/src/constants/tax.ts

@@ -0,0 +1,9 @@
+export enum TaxFrequency {
+  PerNight = 'PER_NIGHT',
+  PerStay = 'PER_STAY',
+}
+
+export enum TaxMode {
+  PerAdult = 'PER_ADULT',
+  PerBooking = 'PER_BOOKING',
+}

package/src/icons/index.ts

@@ -85,7 +85,6 @@ export const ICONS_NAME = Object.freeze({
   gear: 'ph:gear',
   globe: 'ph:globe',
   golf: 'ph:golf',
-  googleColored: 'flat-color-icons:google',
   graph: 'ph:graph',
   gym: 'ph:barbell',
   hairDryer: 'ph:hair-dryer',

package/src/schemas/cancellation-policies.ts

@@ -0,0 +1,18 @@
+/* eslint-disable camelcase */
+import { z } from 'zod'
+
+export const CANCELLATION_POLICY_SCHEMA = z.object({
+  date_from: z.string().openapi({
+    description:
+      'The start date and time of the cancellation policy, given in the hotel timezone.',
+  }),
+  date_to: z.string().openapi({
+    description:
+      'The end date and time of the cancellation policy, given in the hotel timezone.',
+  }),
+  penalty_percentage: z.number().min(0).max(100).openapi({
+    description:
+      'The penalty percentage that is due in case of cancellation during the **date_from** to **date_to** period range.',
+  }),
+})
+/* eslint-enable camelcase */

package/src/schemas/currency.ts

@@ -0,0 +1,7 @@
+import { z } from 'zod'
+
+import { STRIPE_CURRENCY_CODES } from '../currencies/index.ts'
+
+export const CURRENCY_SCHEMA = z
+  .enum(STRIPE_CURRENCY_CODES)
+  .openapi({ description: 'ISO 4217 currency code.' })

package/src/schemas/hotel-offer-request.ts

@@ -0,0 +1,43 @@
+import { z } from 'zod'
+
+import { CountryIso2Code } from '../constants/index.ts'
+
+export const ADULT_COUNT_SCHEMA = z.number().int().min(1).max(200).openapi({
+  description:
+    'The total number of adults who will be staying in the property.',
+})
+
+export const CHECK_IN_DATE_SCHEMA = z
+  .string()
+  .regex(/^(19|20)\d\d[- /.](0[1-9]|1[012])[- /.](0[1-9]|[12][0-9]|3[01])$/u)
+  .openapi({ description: 'Date of check-in formatted as YYYY-MM-DD.' })
+
+export const CHECK_OUT_DATE_SCHEMA = z
+  .string()
+  .regex(/^(19|20)\d\d[- /.](0[1-9]|1[012])[- /.](0[1-9]|[12][0-9]|3[01])$/u)
+  .openapi({ description: 'Date of check-out formatted as YYYY-MM-DD.' })
+
+export const CHILDREN_SCHEMA = z
+  .string()
+  .regex(/^(([0-9]{1})|(1[0-7]){1})(,(([0-9]{1})|(1[0-7]){1}))*$|^$/u)
+  .openapi({
+    description:
+      'A comma-separated list of child ages (0 up to 17). e.g.: "3,7" represents 2 children respectively 3 and 7 years old.',
+  })
+
+export const COUNTRY_ISO2_CODE_SCHEMA = z
+  .nativeEnum(CountryIso2Code)
+  .refine(check => Object.values(CountryIso2Code).includes(check), {
+    message: 'Invalid ISO Alpha-2 country code.',
+  })
+  .openapi({
+    description: 'ISO Alpha-2 country code.',
+  })
+
+export const SOURCE_MARKET_SCHEMA = COUNTRY_ISO2_CODE_SCHEMA.openapi(
+  'sourceMarket',
+  {
+    description:
+      'For sourcing availability within certain markets, a source market option may be used to get more accurate prices. You may use any valid ISO Alpha-2 country code, e.g. JP.',
+  },
+)

package/src/schemas/hotel-offer.ts

@@ -0,0 +1,58 @@
+/* eslint-disable camelcase */
+import { z } from 'zod'
+
+import { CURRENCY_SCHEMA } from './currency.ts'
+import {
+  ADULT_COUNT_SCHEMA,
+  CHECK_IN_DATE_SCHEMA,
+  CHECK_OUT_DATE_SCHEMA,
+  CHILDREN_SCHEMA,
+} from './hotel-offer-request.ts'
+import { HOTEL_ROOM_OFFER_SCHEMA } from './hotel-room-offer.ts'
+import { HOTEL_IMAGES, HOTEL_SCHEMA, VENUES_SCHEMA } from './hotel.ts'
+import { LIST_POLLING_META_SCHEMA } from './list-polling-meta.ts'
+import { TAGS_SCHEMA } from './tag.ts'
+
+export const HOTEL_OFFER_SCHEMA = HOTEL_SCHEMA.extend({
+  hotel_images: HOTEL_IMAGES.openapi({
+    description: `⚠️ Cached images of the hotel. May be empty, use the endpoint /hotels/{id}/images to get the latest images.
+
+List of hotel images in various sizes featuring an indicator for the primary (hero) image
+`,
+  }),
+  hotel_room_offers: z.array(HOTEL_ROOM_OFFER_SCHEMA),
+  tags: TAGS_SCHEMA,
+  venues: VENUES_SCHEMA,
+})
+
+export const HOTEL_OFFERS_SCHEMA = z.array(HOTEL_OFFER_SCHEMA)
+
+export const HOTEL_OFFERS_RESPONSE_SCHEMA = z.object({
+  data: z.object({
+    adult_count: ADULT_COUNT_SCHEMA,
+    check_in_date: CHECK_IN_DATE_SCHEMA,
+    check_out_date: CHECK_OUT_DATE_SCHEMA,
+    children: CHILDREN_SCHEMA.optional().nullish(),
+    currency: CURRENCY_SCHEMA,
+    hotel_offers: HOTEL_OFFERS_SCHEMA.openapi({
+      description: 'List of Hotel Offers',
+    }),
+    price_histogram: z
+      .array(z.number())
+      .openapi({
+        description:
+          '**Hotel Offers** price histogram dataset based on the price of the cheapest **Hotel Room Offer** included on each **Hotel Offer** returned. It represents the number of available **Hotel Offers** grouped by price sorted ascendingly. Each item of the list represents a price step based on returned **price_min**, **price_max** and requested **price_histogram_step_count**',
+      })
+      .nullish(),
+    price_max: z.number().nullish().openapi({
+      description: 'Maximum price of available returned **Hotel Offers**',
+    }),
+    price_min: z.number().nullish().openapi({
+      description: 'Minimum price of available returned **Hotel Offers**',
+    }),
+  }),
+  event: z.any().optional(),
+  meta: LIST_POLLING_META_SCHEMA.extend({
+    total_count: z.number(),
+  }),
+})

package/src/schemas/hotel-room-offer.ts

@@ -0,0 +1,99 @@
+/* eslint-disable camelcase */
+import { z } from 'zod'
+
+import {
+  BreakfastOption,
+  HotelRoomOfferType,
+  PackageType,
+} from '../constants/index.ts'
+
+import { CANCELLATION_POLICY_SCHEMA } from './cancellation-policies.ts'
+import { CURRENCY_SCHEMA } from './currency.ts'
+import { SOURCE_MARKET_SCHEMA } from './hotel-offer-request.ts'
+import { HOTEL_ROOMS_SCHEMA } from './hotel-room.ts'
+import { TAGS_SCHEMA } from './tag.ts'
+import { TAXES_SCHEMA } from './taxes.ts'
+
+export const BREAKFAST_OPTION_DESCRIPTION = `This parameter describes the breakfast option for the given **Hotel Room Offer**:
+- **breakfast_option = "${BreakfastOption.Included}"**:
+  1. When **HotelRoomOffer.type = "${HotelRoomOfferType.Package}"**:
+  the returned **Hotel Room Offer** includes breakfast for the requested **guest count (adult_count + children over 3)**, you cannot choose otherwise, and the returned **price** already includes it,
+  2. When **HotelRoomOffer.type = "${HotelRoomOfferType.HotelRoom}"**:
+  the returned **Hotel Room Offer** includes breakfast for the **Hotel Room Offer** maximum occupancy, you cannot choose otherwise, and the returned **price** already includes it,
+-**breakfast_option = "${BreakfastOption.Optional}"**: the returned **Hotel Room Offer** does not include by default the breakfast and so does the returned **price**, but you'll be able to let your customers choose to add it to their booking. In that case, a **breakfast_price_per_guest_per_night** expressed in the requested **currency** will be available in the returned data, and you'll be to perform one of the two following actions: \n - Call **[Create Hotel Room Offer endpoint](/v1/documentation#operation/postV1Hotel_room_offers)** and get a fresh **Hotel Room Offer** with updated price \n - Compute and display the total price of the **Hotel Room Offer** related to the guest_count and night count requested including extra breafasts.,
+- **breakfast_option = "${BreakfastOption.NotIncluded}"**: the returned **Hotel Room Offer** does not include breakfast and you cannot choose otherwise through API. Guest may still be able to add extra breakfast option(s) at the time of check-in directly at the hotel's reception.`
+
+export const PACKAGE_TYPES_DESCRIPTION = `An **Hotel Room Offer** of type **${HotelRoomOfferType.Package}** can be of **4 types**, described by **package_type** parameter: \n\n - **${PackageType.Cheapest}** : The cheapest combination of hotel rooms that can accommodate the requested guest count. Note that it may not match the requested room count (e.g., 4 guests and 2 rooms requested may return an hotel room package including only 1 room with an occupancy of 4). \n\n -**${PackageType.MatchingRoomCount}** : the cheapest hotel room package that can accommodate the given guest count and that matches exactly the room count given. \n\n -**${PackageType.BestMatch}** : The cheapest hotel room package that matches the given room and guest count with a balanced distribution of guests across the rooms (e.g.; 8 guests and 3 rooms requested may return an **Hotel Room Offer** package including 2 rooms with an occupancy of 3 on each one and 1 room with an occupancy of 2). \n\n -**${PackageType.Regular}** : any other available package.`
+
+export const HOTEL_ROOM_OFFER_SCHEMA = z
+  .object({
+    breakfast_count: z.number().min(0).optional().nullish().openapi({
+      description:
+        'Quantity of breakfast per night included in the given **Hotel Room Offer**',
+    }),
+    breakfast_option: z.nativeEnum(BreakfastOption).openapi({
+      description: BREAKFAST_OPTION_DESCRIPTION,
+    }),
+    breakfast_price_per_guest_per_night: z
+      .number()
+      .optional()
+      .nullish()
+      .openapi({
+        description:
+          'Price of breakfast per guest per night for the given **Hotel Room Offer**, expressed in the requested **currency**, when applicable.\n\n <div style="background-color: #ffffef; padding: 20px; border: 1px solid lightgrey; border-radius: 5px;"><b style="color: red; margin-top: 10px;">🛑 DEPRECATED.</b>\n\n <b style="color: orange;">Field renamed to "breakfast_unit_price"</div>',
+      }),
+    breakfast_unit_price: z.number().optional().nullish().openapi({
+      description:
+        'Price of breakfast per guest per night for the given **Hotel Room Offer**, expressed in the requested **currency**, when applicable.',
+    }),
+    cancellation_policies: z
+      .array(CANCELLATION_POLICY_SCHEMA)
+      .openapi('cancellationPoliciesApi', {
+        description:
+          'The list of cancellation policies applied to the given **Hotel Room Offer**.',
+      }),
+    count: z
+      .number()
+      .optional()
+      .nullish()
+      .openapi({
+        description: `When **type = ${HotelRoomOfferType.HotelRoom}**: this parameters represents the available quantity for the given **Hotel Room Offer**.
+  When **type = ${HotelRoomOfferType.Package}**: count = 1 always.`,
+      }),
+    currency: CURRENCY_SCHEMA,
+    hotel_id: z
+      .string()
+      .openapi({ description: 'id of the associated Hotel.' }),
+    hotel_rooms: HOTEL_ROOMS_SCHEMA.openapi({
+      description: 'List of Hotel Rooms included in the Hotel Room Offer.',
+    }),
+    id: z.string().openapi({ description: 'Hotel Room Offer id.' }).optional(),
+    package_type: z
+      .nativeEnum(PackageType)
+      .openapi({
+        description: PACKAGE_TYPES_DESCRIPTION,
+      })
+      .nullish()
+      .optional(),
+    price: z.number().openapi({
+      description:
+        'Price with taxes NOT INCLUDED of the given **Hotel Room Offer** including breakfast(s) when applicable, expressed in the requested **currency**.',
+    }),
+    source_market: SOURCE_MARKET_SCHEMA,
+    tags: TAGS_SCHEMA,
+    tax_included_price: z.number().openapi({
+      description: `Price of the given **Hotel Room Offer** including breakfast(s) when applicable, and including all taxes from returned **taxes** list parameter expressed in the requested **currency**.\n\nThis data is not returned for a **Hotel Room Offer** of type **${HotelRoomOfferType.HotelRoom}**, you'll need to compute and display the actual tax included price of the final **Hotel Room** package corresponding to the guest count and night count requested, or make a call to the **[Create Hotel Room Offer](/v1/documentation#operation/postV1Hotel_room_offers)** endpoint in order to get a valid and bookable **Hotel Room Offer** where **type = ${HotelRoomOfferType.Package}** based on a packaged list of **Hotel Room Offers** of type **${HotelRoomOfferType.HotelRoom}**.`,
+    }),
+    taxes: TAXES_SCHEMA,
+    type: z
+      .nativeEnum(HotelRoomOfferType)
+      .openapi({
+        description: `Hotel Room Offer type.\n\n **Hotel Room Offers** with **type = "${HotelRoomOfferType.Package}"** are **Hotel Room Offers** that are already bookable and you'll be able to follow the next step of the **Booking Flow** calling **[Create Booking Policies endpoint](/v1/documentation#operation/postV1Booking_policies)**. \n\n Otherwise, you'll be able to create a new **Hotel Room Offer** with **type = "${HotelRoomOfferType.Package}"** from multiple **Hotel Room Offers** with **type = "${HotelRoomOfferType.HotelRoom}"**. See **[Create Hotel Room Offer endpoint](/v1/documentation#operation/postV1Hotel_room_offers)** for details.`,
+      })
+      .nullish()
+      .optional(),
+  })
+  .openapi('hotelRoomOfferApi', {
+    description: 'Description of the Hotel Room Offer.',
+  })
+/* eslint-enable camelcase */

package/src/schemas/hotel-room.ts

@@ -0,0 +1,106 @@
+/* eslint-disable camelcase */
+import { z } from 'zod'
+
+import { HOTEL_IMAGE } from './hotel.ts'
+
+export const BED_SCHEMA = z
+  .object({
+    count: z.number().openapi({
+      description: 'Number of beds of the given type in the room.',
+    }),
+    name: z.string().openapi({ description: 'Bed name.' }),
+    occupancy: z.number().openapi({ description: 'Bed occupancy.' }),
+  })
+  .openapi('bedApi')
+
+export const BEDS_SCHEMA = z
+  .array(z.array(BED_SCHEMA))
+  .openapi({
+    description: `Beds list.
+Each nested array of beds represents a single combination of possible beds.
+e.g.: The following object represents **1 double bed or 1 sofa bed and 1 double bed or 1 single bed**:
+\`\`\`
+[
+  [
+    { count: 1, name: 'double', occupancy: 2 },
+    { count: 1, name: 'sofa', occupancy: 1 }
+  ],
+  [
+    { count: 1, name: 'double', occupancy: 2 },
+    { count: 1, name: 'single', occupancy: 1 }
+  ]
+]
+\`\`\`
+`,
+  })
+  .openapi('bedsApi')
+
+export const HOTEL_ROOM_SCHEMA = z
+  .object({
+    amenities: z
+      .array(z.string().openapi('amenity'))
+      .openapi({
+        description:
+          'List of amenities in the room. May be subject to changes at the Hotel.',
+      })
+      .nullish(),
+    beds: BEDS_SCHEMA,
+    beds_pretty: z
+      .string()
+      .openapi({ description: 'Prettified and localized list of beds' }),
+    count: z.number().openapi({
+      description: 'Hotel Room count included in the Hotel Room Offer.',
+    }),
+    description: z.string().openapi({ description: 'Hotel Room description.' }),
+    highres_images: z
+      .boolean()
+      .openapi({ description: 'Whether high resolution images are available.' })
+      .optional()
+      .nullish(),
+    id: z
+      .string()
+      .optional()
+      .openapi({ description: 'Hotel Room id, when applicable.' }),
+    image_indexes: z.array(z.number()).optional().nullish().openapi({
+      description:
+        'List of indexes corresponding to image names for the given Hotel Room among the related hotel images.',
+    }),
+    images: z
+      .array(HOTEL_IMAGE)
+      .openapi({
+        description: 'Hotel Room images.',
+      })
+      .optional()
+      .nullish(),
+    lowres_images: z
+      .boolean()
+      .openapi({ description: 'Whether low resolution images are available.' })
+      .optional()
+      .nullish(),
+    occupancy: z
+      .number()
+      .openapi({ description: 'Total occupancy of a single hotel room.' }),
+    rich_description: z.string().optional().nullish().openapi({
+      description: 'Rich Hotel Room description. May contain HTML tags markup.',
+    }),
+    room_square_feet: z.number().optional().nullish().openapi({
+      description:
+        'Room surface in square feet. May be subject to changes at the Hotel.',
+    }),
+    room_square_meters: z.number().optional().nullish().openapi({
+      description:
+        'Room surface in square meters. May be subject to changes at the Hotel.',
+    }),
+    thumb_images: z
+      .boolean()
+      .openapi({
+        description:
+          'Whether thumb resolution images are available (in order to display them as image carousel navigation for instance).',
+      })
+      .optional()
+      .nullish(),
+  })
+  .openapi({ description: 'Hotel Room details.' })
+
+export const HOTEL_ROOMS_SCHEMA = z.array(HOTEL_ROOM_SCHEMA)
+/* eslint-enable camelcase */

package/src/schemas/hotel.ts

@@ -0,0 +1,360 @@
+/* eslint-disable camelcase */
+import { z } from 'zod'
+
+import { CountryIso2Code } from '../constants/index.ts'
+
+import { CURRENCY_SCHEMA } from './currency.ts'
+
+export const AMENITIES_SCHEMA = z.object({
+  air_conditioning: z
+    .boolean()
+    .optional()
+    .openapi({ description: 'Air conditioning.' }),
+  airport_transportation: z
+    .boolean()
+    .optional()
+    .openapi({ description: 'Airport transportation service.' }),
+  business_center: z
+    .boolean()
+    .optional()
+    .openapi({ description: 'Business center.' }),
+  car_rent_desk: z
+    .boolean()
+    .optional()
+    .openapi({ description: 'Car rental desk service.' }),
+  children_allowed: z
+    .boolean()
+    .optional()
+    .openapi({ description: 'Children welcomed.' }),
+  clothing_iron: z
+    .boolean()
+    .optional()
+    .openapi({ description: 'Clothing iron.' }),
+  coffee_tea_maker: z
+    .boolean()
+    .optional()
+    .openapi({ description: 'Coffea/tea maker.' }),
+  combination: z.boolean().optional().openapi({ description: 'Combination.' }),
+  continental_breakfast: z
+    .boolean()
+    .optional()
+    .openapi({ description: 'Continental Breakfast.' }),
+  data_ports: z
+    .boolean()
+    .optional()
+    .openapi({ description: 'Data ports in room.' }),
+  dry_cleaning: z
+    .boolean()
+    .optional()
+    .openapi({ description: 'Dry cleaning.' }),
+  electronic_room_keys: z
+    .boolean()
+    .optional()
+    .openapi({ description: 'Electornic room keys.' }),
+  exterior_room_entrance: z
+    .boolean()
+    .optional()
+    .openapi({ description: 'Exterior room entrance.' }),
+  family_rooms: z
+    .boolean()
+    .optional()
+    .openapi({ description: 'Family rooms.' }),
+  fitness_facility: z
+    .boolean()
+    .optional()
+    .openapi({ description: 'Fitness facility.' }),
+  game_room: z.boolean().optional().openapi({ description: 'Game room.' }),
+  golf_course: z.boolean().optional().openapi({ description: 'Golf course.' }),
+  hair_dryer: z.boolean().optional().openapi({ description: 'Hair dryer.' }),
+  handicap_accessible: z
+    .boolean()
+    .optional()
+    .openapi({ description: 'Handicap Accessible.' }),
+  in_house_bar: z
+    .boolean()
+    .optional()
+    .openapi({ description: 'In house bar.' }),
+  in_house_dining: z
+    .boolean()
+    .optional()
+    .openapi({ description: 'In house dining.' }),
+  in_room_movies: z
+    .boolean()
+    .optional()
+    .openapi({ description: 'In room movies.' }),
+  indoor_pool: z.boolean().optional().openapi({ description: 'Indoor pool.' }),
+  interior_room_entrance: z
+    .boolean()
+    .optional()
+    .openapi({ description: 'Interior room entrance.' }),
+  kitchen: z.boolean().optional().openapi({ description: 'Kitchen.' }),
+  map: z.boolean().optional().openapi({ description: 'Map.' }),
+  meeting_rooms: z
+    .boolean()
+    .optional()
+    .openapi({ description: 'Meeting rooms.' }),
+  mini_bar_in_room: z
+    .boolean()
+    .optional()
+    .openapi({ description: 'mini bar in room.' }),
+  non_smoking_rooms: z
+    .boolean()
+    .optional()
+    .openapi({ description: 'Non smoking rooms.' }),
+  outdoor_pool: z
+    .boolean()
+    .optional()
+    .openapi({ description: 'Outdoor pool.' }),
+  parking_garage: z
+    .boolean()
+    .optional()
+    .openapi({ description: 'Parking garage.' }),
+  pets_allowed: z
+    .boolean()
+    .optional()
+    .openapi({ description: 'Pets allowed.' }),
+  restricted_access: z
+    .boolean()
+    .optional()
+    .openapi({ description: 'Restricted access.' }),
+  room_service: z
+    .boolean()
+    .optional()
+    .openapi({ description: 'Room service.' }),
+  safe: z.boolean().optional().openapi({ description: 'Safe in room.' }),
+  sauna: z.boolean().optional().openapi({ description: 'Sauna.' }),
+  t_v_in_room: z.boolean().optional().openapi({ description: 'TV in room.' }),
+  tennis_court: z
+    .boolean()
+    .optional()
+    .openapi({ description: 'Tennis court.' }),
+  twenty_four_hour_security: z
+    .boolean()
+    .optional()
+    .openapi({ description: ' 24/7 security.' }),
+  valet_parking: z
+    .boolean()
+    .optional()
+    .openapi({ description: 'Valet parking.' }),
+  video_check_out: z
+    .boolean()
+    .optional()
+    .openapi({ description: 'Video check out.' }),
+  voice_mail: z.boolean().optional().openapi({ description: 'Voice mail.' }),
+  wake_up_service: z
+    .boolean()
+    .optional()
+    .openapi({ description: 'Wake up service.' }),
+  whirpool: z.boolean().optional().openapi({ description: 'Whirpool.' }),
+})
+
+export const HOTEL_IMAGE = z.object({
+  caption: z.string().nullish(),
+  is_hero_image: z.boolean(),
+  l: z.string(),
+  m: z.string(),
+  s: z.string(),
+  xl: z.string(),
+  xs: z.string(),
+})
+
+export const HOTEL_IMAGES = z.array(HOTEL_IMAGE).openapi({
+  description:
+    'List of hotel images in various sizes featuring an indicator for the primary (hero) image',
+})
+
+export const HOTEL_REVIEW_RATING_SCHEMA = z
+  .object({
+    category: z
+      .string()
+      .openapi({
+        description: 'Category of the collected reviews for the Hotel.',
+      })
+      .nullish()
+      .optional(),
+    rating: z.number().openapi({
+      description: 'Rating of the collected review for the Hotel.',
+    }),
+  })
+  .openapi({
+    description: 'Review rating with category collected for the Hotel.',
+  })
+
+export const HOTEL_REVIEW_RATINGS_SCHEMA = z
+  .array(HOTEL_REVIEW_RATING_SCHEMA)
+  .openapi({
+    description:
+      'List of meta reviews (category and rating) that are summary of verified reviews collected across the web on the Hotel to help choose the best option.',
+  })
+
+export const IMAGES_SCHEMA = z
+  .object({
+    count: z
+      .number()
+      .openapi({ description: 'Number of images.' })
+      .optional()
+      .nullish(),
+    highres: z
+      .boolean()
+      .openapi({ description: 'Whether images exist in highres format.' })
+      .optional()
+      .nullish(),
+
+    lowres: z
+      .boolean()
+      .openapi({ description: 'Whether images exist in lowres format.' })
+      .optional()
+      .nullish(),
+    prefix: z
+      .string()
+      .openapi({ description: 'Base URL for the images.' })
+      .optional()
+      .nullish(),
+    suffix: z
+      .string()
+      .openapi({
+        description:
+          'This parameter usually represents the extension of the image (e.g.: .jpg, .png)',
+      })
+      .optional()
+      .nullish(),
+    thumb: z
+      .boolean()
+      .openapi({
+        description:
+          'Whether images exist in thumb format (for thumbnails preview).',
+      })
+      .optional()
+      .nullish(),
+  })
+  .openapi({
+    description:
+      '🛑 DEPRECATED - Hotel images details.\n\nIn order to retrieve a specific image you need to construct the complete URL from the images parameters: **[images.prefix][highres|lowres|thumb]/[index]/[images.suffix]**. If **images.count = n**, then index is in [0...n-1] range.\n\ne.g.: https://s3.eu-west-3.amazonaws.com/revolugo/hotels/yhKY/images/highres/0.jpg',
+  })
+
+export const VENUES_SCHEMA = z
+  .array(
+    z.object({
+      description: z.string().optional().nullish(),
+      name: z.string(),
+      travel_times: z
+        .object({
+          driving: z.number().optional(),
+          transit: z.number().optional(),
+          walking: z.number().optional(),
+        })
+        .optional()
+        .nullish(),
+    }),
+  )
+  .optional()
+export const HOTEL_SCHEMA = z
+  .object({
+    address: z
+      .string()
+      .openapi({ description: 'Hotel address.' })
+      .optional()
+      .nullish(),
+    address2: z
+      .string()
+      .openapi({ description: 'Second part of hotel address.' })
+      .optional()
+      .nullish(),
+    amenities: AMENITIES_SCHEMA.nullish(),
+    check_in_time: z
+      .string()
+      .openapi({ description: 'Check in time of the hotel.' })
+      .optional()
+      .nullish(),
+    check_out_time: z
+      .string()
+      .openapi({ description: 'Check out time of the hotel.' })
+      .optional()
+      .nullish(),
+    city: z.string().openapi({ description: 'City' }).optional().nullish(),
+    country: z
+      .string()
+      .openapi({ description: 'Country' })
+      .optional()
+      .nullish(),
+    country_code: z
+      .string()
+      .refine(check =>
+        Object.values(CountryIso2Code).includes(check as CountryIso2Code),
+      )
+      .openapi({ description: 'Hotel country code in ISO2.' })
+      .optional()
+      .nullish(),
+    currency: CURRENCY_SCHEMA.openapi({ description: 'Hotel currency.' })
+      .optional()
+      .nullish(),
+    description: z
+      .string()
+      .openapi({ description: 'Hotel description.' })
+      .optional()
+      .nullish(),
+    distance: z
+      .number()
+      .optional()
+      .openapi({
+        description: 'Distance from a requested location, expressed in meters',
+      })
+      .optional()
+      .nullish(),
+    email: z
+      .string()
+      .openapi({ description: 'Hotel email.' })
+      .optional()
+      .nullish(),
+    fax: z
+      .string()
+      .openapi({ description: 'Hotel fax number.' })
+      .optional()
+      .nullish(),
+    hotel_images: HOTEL_IMAGES.nullish(),
+    hotel_review_ratings: HOTEL_REVIEW_RATINGS_SCHEMA.optional().nullish(),
+    id: z.string().openapi({ description: 'Hotel id.' }),
+    images: IMAGES_SCHEMA.nullish(),
+    latitude: z.number().openapi({ description: 'Hotel latitude.' }),
+    longitude: z.number().openapi({ description: 'Hotel longitude.' }),
+    name: z.string().openapi({ description: 'Hotel name.' }),
+    phone: z
+      .string()
+      .openapi({ description: 'Hotel phone number.' })
+      .optional()
+      .nullish(),
+    policy: z
+      .string()
+      .openapi({ description: 'Internal policy of the hotel.' })
+      .optional()
+      .nullish(),
+    postal_code: z
+      .string()
+      .openapi({ description: 'Hotel address postal code.' })
+      .optional()
+      .nullish(),
+    rating: z
+      .number()
+      .optional()
+      .nullish()
+      .openapi({ description: 'Hotel Star rating.' }),
+    state: z
+      .string()
+      .openapi({ description: 'Hotel address state.' })
+      .optional()
+      .nullish(),
+    ta_id: z
+      .string()
+      .optional()
+      .openapi({ description: 'TripAdvisor property id. When applicable.' })
+      .optional()
+      .nullish(),
+    timezone: z.string().openapi({ description: 'Hotel timezone.' }),
+    venues: VENUES_SCHEMA,
+    website: z
+      .string()
+      .openapi({ description: 'Hotel website url.' })
+      .optional()
+      .nullish(),
+  })
+  .openapi('hotelApi')

package/src/schemas/index.ts

@@ -0,0 +1,10 @@
+export * from './cancellation-policies.ts'
+export * from './currency.ts'
+export * from './hotel-offer-request.ts'
+export * from './hotel-offer.ts'
+export * from './hotel-room-offer.ts'
+export * from './hotel-room.ts'
+export * from './hotel.ts'
+export * from './list-polling-meta.ts'
+export * from './tag.ts'
+export * from './taxes.ts'

package/src/schemas/list-polling-meta.ts

@@ -0,0 +1,43 @@
+/* eslint-disable camelcase */
+import { z } from 'zod'
+
+import { PollerStatus } from '@revolugo/common/constants'
+
+export const ENDING_BEFORE_SCHEMA = z.string().optional().nullable().openapi({
+  description:
+    'A cursor to use in pagination. `ending_before` is an object ID that defines your place in the list. For instance, if you make a list request and receive 100 objects, starting with `obj_bar`, your subsequent call can include `ending_before=obj_bar` in order to fetch the previous page of the list.',
+})
+
+export const STARTING_AFTER_SCHEMA = z.string().optional().nullable().openapi({
+  description:
+    'A cursor to use in pagination. `starting_after` is an object ID that defines your place in the list. For instance, if you make a list request and receive 100 objects, ending with `obj_foo`, your subsequent call can include `starting_after=obj_foo` in order to fetch the next page of the list.',
+})
+
+export const STATUS_SCHEMA = z
+  .nativeEnum(PollerStatus)
+  .openapi({ description: 'Status of the response data.' })
+  .openapi('pollerStatus')
+
+export const LIMIT_SCHEMA = z
+  .number()
+  .optional()
+  .openapi({ description: 'A limit on the number of object to be returned.' })
+  .openapi('limit')
+
+export const LIST_META_SCHEMA = z
+  .object({
+    ending_before: ENDING_BEFORE_SCHEMA,
+    limit: LIMIT_SCHEMA,
+    starting_after: STARTING_AFTER_SCHEMA,
+    total_count: z.number().nullish(),
+  })
+  .openapi('metaApiResponse')
+  .openapi({
+    description:
+      'Meta information about the response list, such as pagination cursors or status.',
+  })
+
+export const LIST_POLLING_META_SCHEMA = LIST_META_SCHEMA.extend({
+  status: STATUS_SCHEMA,
+}).openapi('metaApiPollingResponse')
+/* eslint-enable camelcase */

package/src/schemas/tag.ts

@@ -0,0 +1,13 @@
+/* eslint-disable camelcase */
+import { z } from 'zod'
+
+export const TAG_SCHEMA = z.object({
+  bg: z.string().optional().nullish(),
+  color: z.string().optional().nullish(),
+  description: z.string().optional().nullish(),
+  fa_icon: z.string().optional().nullish(),
+  name: z.string(),
+})
+
+export const TAGS_SCHEMA = z.array(TAG_SCHEMA).optional().default([])
+/* eslint-enable camelcase */

package/src/schemas/taxes.ts

@@ -0,0 +1,34 @@
+/* eslint-disable camelcase */
+import { z } from 'zod'
+
+import { TaxFrequency, TaxMode } from '../constants/index.ts'
+
+export const TAX_SCHEMA = z
+  .object({
+    amount: z.number().optional().nullish().openapi({
+      description: 'Tax amount expressed in the requested currency.',
+    }),
+    code: z.string().optional().openapi({ description: 'Tax code.' }),
+    description: z
+      .string()
+      .optional()
+      .nullish()
+      .openapi({ description: 'Tax description.' }),
+    percentage: z
+      .number()
+      .optional()
+      .nullish()
+      .openapi({ description: 'Tax percentage on the total amount.' }),
+    tax_frequency: z.nativeEnum(TaxFrequency).openapi({
+      description:
+        'Tax frequency. Specifies if the tax applies per stay or per night',
+    }),
+    tax_mode: z.nativeEnum(TaxMode).openapi({
+      description:
+        'Tax mode. Specifies if the tax applies per occupant, per booking or per room',
+    }),
+  })
+  .openapi('taxApi')
+
+export const TAXES_SCHEMA = z.array(TAX_SCHEMA).optional()
+/* eslint-enable camelcase */

package/src/types/elements/hotel.ts

@@ -151,6 +151,8 @@ export interface Hotel {
    */
   // oxlint-disable-next-line no-explicit-any
   rating?: any | null
+
+  reviewCount?: number | null
   /**
    * Hotel address state.
    * @type {string}

package/src/types/severities.ts

@@ -7,5 +7,6 @@ export enum Severity {
   Secondary = 'secondary',
   Tertiary = 'tertiary',
   Danger = 'danger',
+  Error = 'error',
   Contrast = 'contrast',
 }

package/src/utils/case-transformers.ts

@@ -7,7 +7,7 @@ import {
 } from 'change-case'
 import slugify from 'slugify'
 
-function slugCase(input: string) {
+function slugCase(input: string): string {
   return slugify(kebabCase(input), {
     lower: true,
     strict: true,
@@ -23,7 +23,7 @@ export enum CaseTransformer {
   Snake = 'snakeCase',
 }
 
-const CASE_TRANSORMERS_MAPPING = {
+export const CASE_TRANSFORMERS_MAPPING = {
   [CaseTransformer.Camel]: camelCase,
   [CaseTransformer.Capital]: capitalCase,
   [CaseTransformer.Param]: kebabCase,
@@ -38,11 +38,11 @@ export function changeCase<T extends string | string[]>(
 ): T extends string ? string : string[] {
   if (Array.isArray(input)) {
     return input.map(item =>
-      CASE_TRANSORMERS_MAPPING[toCase](item),
+      CASE_TRANSFORMERS_MAPPING[toCase](item),
     ) as T extends string ? string : string[]
   }
 
-  return CASE_TRANSORMERS_MAPPING[toCase](input) as T extends string
+  return CASE_TRANSFORMERS_MAPPING[toCase](input) as T extends string
     ? string
     : string[]
 }
@@ -85,7 +85,7 @@ export function keysChangeCase<T>(
       const transformedKey =
         options?.exclude && matches(options.exclude, key)
           ? key
-          : CASE_TRANSORMERS_MAPPING[toCase](key)
+          : CASE_TRANSFORMERS_MAPPING[toCase](key)
 
       result[transformedKey] = options.deep
         ? keysChangeCase(obj[key], toCase, options)

package/src/utils/get-sanitized-room-count.ts

@@ -0,0 +1,29 @@
+const MAX_ADULTS_PER_ROOM = 2
+
+export function getSanitizedRoomCount({
+  adultCount,
+  maxAdultsPerRoom = MAX_ADULTS_PER_ROOM,
+  roomCount,
+}: {
+  adultCount: number
+  roomCount: number
+  maxAdultsPerRoom?: number
+}): number {
+  // Ensure at least enough rooms for each adult and at most MAX_ADULTS_PER_ROOM per room
+  if (!Number.isFinite(roomCount) || roomCount < 1) {
+    return adultCount
+  }
+
+  const minRooms = Math.ceil(adultCount / maxAdultsPerRoom)
+  const maxRooms = adultCount
+
+  if (roomCount <= minRooms) {
+    return minRooms
+  }
+
+  if (roomCount >= maxRooms) {
+    return maxRooms
+  }
+
+  return roomCount
+}

package/src/utils/index.ts

@@ -1,6 +1,7 @@
 export * from './add-classes.ts'
 export * from './amount-from-percentage.ts'
 export * from './case-transformers.ts'
+export * from './keys-case-transformer.ts'
 export * from './chunk.ts'
 export * from './colors.ts'
 export * from './compact-object.ts'
@@ -20,11 +21,13 @@ export * from './get-guest-count.ts'
 export * from './get-random-element-from-array.ts'
 export * from './get-random-hex-color.ts'
 export * from './get-random-int.ts'
+export * from './get-sanitized-room-count.ts'
 export * from './group-by.ts'
 export * from './images.ts'
 export * from './is-empty.ts'
 export * from './is-equal.ts'
 export * from './is-nil.ts'
+export * from './is-object.ts'
 export * from './key-by.ts'
 export * from './lang-default-fallbacks.ts'
 export * from './map-keys.ts'
@@ -45,6 +48,7 @@ export * from './sort-by.ts'
 export * from './sum-by.ts'
 export * from './sum.ts'
 export * from './to-boolean.ts'
+export * from './transform-schema-keys.ts'
 export * from './uniq.ts'
 export * from './uniq-by.ts'
 export * from './uniq-with.ts'

package/src/utils/is-object.ts

@@ -0,0 +1,2 @@
+export const isObject = (value: unknown): value is object =>
+  !!value && value.constructor === Object

package/src/utils/keys-case-transformer.ts

@@ -0,0 +1,118 @@
+import { type CaseTransformer, changeCase } from './case-transformers.ts'
+import { isObject } from './is-object.ts'
+import { mapKeys } from './map-keys.ts'
+
+import type {
+  CamelCasedProperties,
+  CamelCasedPropertiesDeep,
+  KebabCasedProperties,
+  KebabCasedPropertiesDeep,
+  PascalCasedProperties,
+  PascalCasedPropertiesDeep,
+  SnakeCasedProperties,
+  SnakeCasedPropertiesDeep,
+} from 'type-fest'
+
+/**
+ * Maps CaseTransformer enum to the corresponding type-fest property transformation (shallow).
+ * Capital and Slug cases don't have type-fest equivalents, so they preserve the original type.
+ */
+type TransformProperties<
+  T,
+  C extends CaseTransformer,
+> = C extends CaseTransformer.Camel
+  ? CamelCasedProperties<T>
+  : C extends CaseTransformer.Snake
+    ? SnakeCasedProperties<T>
+    : C extends CaseTransformer.Pascal
+      ? PascalCasedProperties<T>
+      : C extends CaseTransformer.Param
+        ? KebabCasedProperties<T>
+        : T
+
+/**
+ * Maps CaseTransformer enum to the corresponding type-fest deep property transformation.
+ * Capital and Slug cases don't have type-fest equivalents, so they preserve the original type.
+ */
+type TransformPropertiesDeep<
+  T,
+  C extends CaseTransformer,
+> = C extends CaseTransformer.Camel
+  ? CamelCasedPropertiesDeep<T>
+  : C extends CaseTransformer.Snake
+    ? SnakeCasedPropertiesDeep<T>
+    : C extends CaseTransformer.Pascal
+      ? PascalCasedPropertiesDeep<T>
+      : C extends CaseTransformer.Param
+        ? KebabCasedPropertiesDeep<T>
+        : T
+
+/**
+ * Transforms object keys based on the specified case transformer.
+ * - Arrays: recursively applies transformation to each element
+ * - Objects: applies property transformation (shallow by default, deep if Deep=true)
+ * - Primitives: returns as-is
+ */
+export type KeysCaseTransformed<
+  T,
+  C extends CaseTransformer,
+  Deep extends boolean = false,
+> = Deep extends true
+  ? T extends readonly (infer U)[]
+    ? KeysCaseTransformed<U, C, true>[]
+    : T extends object
+      ? TransformPropertiesDeep<T, C>
+      : T
+  : T extends readonly (infer U)[]
+    ? KeysCaseTransformed<U, C>[]
+    : T extends object
+      ? TransformProperties<T, C>
+      : T
+
+export interface KeysCaseTransformerOptions {
+  deep?: boolean
+}
+
+// Overload: deep transformation
+export function keysCaseTransformer<T, C extends CaseTransformer>(
+  obj: T,
+  toCase: C,
+  options: { deep: true },
+): KeysCaseTransformed<T, C, true>
+
+// Overload: shallow transformation (default)
+export function keysCaseTransformer<T, C extends CaseTransformer>(
+  obj: T,
+  toCase: C,
+  options?: { deep?: false },
+): KeysCaseTransformed<T, C>
+
+// Implementation
+export function keysCaseTransformer<T, C extends CaseTransformer>(
+  obj: T,
+  toCase: C,
+  options?: KeysCaseTransformerOptions,
+): KeysCaseTransformed<T, C, boolean> {
+  if (Array.isArray(obj)) {
+    return obj.map(item =>
+      keysCaseTransformer(item, toCase, options as { deep: true }),
+    ) as KeysCaseTransformed<T, C, boolean>
+  }
+
+  if (isObject(obj)) {
+    const transformed = mapKeys(obj, key => changeCase(key, toCase))
+    if (options?.deep) {
+      // Recursively transform nested values
+      return Object.fromEntries(
+        Object.entries(transformed).map(([k, v]) => [
+          k,
+          keysCaseTransformer(v, toCase, options as { deep: true }),
+        ]),
+      ) as KeysCaseTransformed<T, C, boolean>
+    }
+
+    return transformed as KeysCaseTransformed<T, C, boolean>
+  }
+
+  return obj as KeysCaseTransformed<T, C, boolean>
+}

package/src/utils/transform-schema-keys.ts

@@ -0,0 +1,143 @@
+import { type ZodTypeAny, z } from 'zod'
+
+import {
+  CASE_TRANSFORMERS_MAPPING,
+  type CaseTransformer,
+} from './case-transformers.ts'
+
+/* eslint-disable no-underscore-dangle, max-statements */
+
+function transformSchemaKeysWithTransformer(
+  schema: ZodTypeAny,
+  transformer: (str: string) => string,
+): ZodTypeAny {
+  let result: ZodTypeAny = schema
+
+  // Handle ZodObject
+  if (schema instanceof z.ZodObject) {
+    const shape = schema._def.shape()
+    const transformedShape: Record<string, ZodTypeAny> = {}
+
+    for (const key in shape) {
+      if (Object.hasOwn(shape, key)) {
+        const transformedKey = transformer(key)
+        transformedShape[transformedKey] = transformSchemaKeysWithTransformer(
+          shape[key],
+          transformer,
+        )
+      }
+    }
+
+    result = z.object(transformedShape) as ZodTypeAny
+  }
+
+  // Handle ZodArray
+  else if (schema instanceof z.ZodArray) {
+    const { type: elementSchema } = schema._def
+    result = z.array(
+      transformSchemaKeysWithTransformer(elementSchema, transformer),
+    )
+  }
+
+  // Handle ZodOptional
+  else if (schema instanceof z.ZodOptional) {
+    const { innerType: innerSchema } = schema._def
+    result = transformSchemaKeysWithTransformer(
+      innerSchema,
+      transformer,
+    ).optional()
+  }
+
+  // Handle ZodNullable
+  else if (schema instanceof z.ZodNullable) {
+    const { innerType: innerSchema } = schema._def
+    result = transformSchemaKeysWithTransformer(
+      innerSchema,
+      transformer,
+    ).nullable()
+  }
+
+  // Handle ZodDefault
+  else if (schema instanceof z.ZodDefault) {
+    const { defaultValue, innerType: innerSchema } = schema._def
+    result = transformSchemaKeysWithTransformer(
+      innerSchema,
+      transformer,
+    ).default(defaultValue())
+  }
+
+  // Handle ZodEffects (includes .refine(), .transform(), etc.)
+  else if (schema instanceof z.ZodEffects) {
+    const { schema: innerSchema } = schema._def
+    const transformedInner = transformSchemaKeysWithTransformer(
+      innerSchema,
+      transformer,
+    )
+
+    // We need to reconstruct the effects
+    // This is a simplified version - effects are not transformed, just passed through
+    result = transformedInner
+  }
+
+  // Handle ZodUnion
+  else if (schema instanceof z.ZodUnion) {
+    const { options } = schema._def
+    const transformedOptions = options.map((option: ZodTypeAny) =>
+      transformSchemaKeysWithTransformer(option, transformer),
+    )
+    result = z.union(
+      transformedOptions as [ZodTypeAny, ZodTypeAny, ...ZodTypeAny[]],
+    )
+  }
+
+  // Handle ZodIntersection
+  else if (schema instanceof z.ZodIntersection) {
+    const { left, right } = schema._def
+    result = z.intersection(
+      transformSchemaKeysWithTransformer(left, transformer),
+      transformSchemaKeysWithTransformer(right, transformer),
+    )
+  }
+
+  // Propagate openapi metadata
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const { openapi } = schema._def as any
+  if (openapi && result !== schema) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    ;(result._def as any).openapi = openapi
+  }
+
+  return result
+}
+
+/**
+ * Transforms all keys in a Zod schema from one case to another (e.g., snake_case to camelCase).
+ * This function recursively transforms all nested schemas as well.
+ *
+ * @param schema - The Zod schema to transform
+ * @param toCase - The target case (e.g., CaseTransformer.Camel)
+ * @returns A new Zod schema with transformed keys
+ *
+ * @example
+ * ```ts
+ * const snakeSchema = z.object({
+ *   first_name: z.string(),
+ *   last_name: z.string(),
+ * })
+ *
+ * const camelSchema = transformSchemaKeys(snakeSchema, CaseTransformer.Camel)
+ * // Results in: { firstName: z.string(), lastName: z.string() }
+ * ```
+ */
+export function transformSchemaKeys<T extends ZodTypeAny>(
+  schema: T,
+  toCase: CaseTransformer,
+): T {
+  const transformer = CASE_TRANSFORMERS_MAPPING[toCase]
+
+  if (!transformer) {
+    throw new Error(`Unsupported case transformer: ${toCase}`)
+  }
+
+  return transformSchemaKeysWithTransformer(schema, transformer) as T
+}