@sabstravtech/obtservices 0.2.2606091300 → 0.2.2606301620

package/fesm2022/sabstravtech-obtservices-angular.mjs

@@ -1,6 +1,6 @@
 import * as i0 from '@angular/core';
 import { Injectable, Component, Inject, NgModule, Pipe } from '@angular/core';
-import { BaseEnvironment, BaseEventMessenager, BaseHelperRoutines, PaymentMethodType, SchemaFormat, ServiceProvider, BaseModalOpenerService, BaseAcceptNewPriceUpdater, BaseAddItemToBasketUpdater, BaseAddUserToBasketItemUpdater, BaseCreateBasketUpdater, BaseGetBasketFetcher, BaseBookBasketUpdater, BaseDeleteBasketUpdater, BaseRemoveItemFromBasketUpdater, BaseRevalidateBasketUpdater, BaseGetUserFetcher, BaseGetUserBasketsFetcher, BaseSetBasketItemLeadPassengerUpdater, BaseMoveBasketItemToBasket, BaseUpdateBasketNoteUpdater, BaseUpdateBasketTitleUpdater, BaseUserUiConfigsFetcher, BaseUserProductsFetcher, BaseUserMessagesFetcher, BaseGetCompaniesFetcher, BaseGetCompanyFetcher, BaseConfirmMessagesUpdater, BaseSetUserLanguageUpdater, BaseEditUserUpdater, BaseCreateGuestUpdater, BaseGetUserGuestsFetcher, BaseGetOfficeFetcher, BaseRedirectApproverFetcher, BaseAddRedirectApproverUpdater, BaseRemoveRedirectApproverUpdater, BaseStorageService, BaseWebTokenService, BaseSearchCompanyApproversFetcher, BaseAddFavouriteUserUpdater, BaseGetUserFavouriteUsersFetcher, BaseRemoveFavouriteUserUpdater, BaseApexxCreateCardUpdater, BaseApexxDeleteCardUpdater, BaseApexxUpdateCardUpdater, BaseGetApexxListCardsFetcher, BaseSetBasketItemApexxTokenUpdater, BaseGetUserMiFetcher, BaseGetUserDocumentLoyaltyFetcher, BaseGetUserEmergencyContactFetcher, BaseDeleteGuestUpdater, BaseSearchUserWithEmailFetcher, BaseGetOfficeUsersFetcher, BaseRemovePreferredTransportHubUpdater, BaseSetPreferredTransportHubUpdater, BaseGetUserPreferredTransportHubsFetcher, BaseGetUserMiDefaultValuesFetcher, BaseGetUserMiStackFetcher, BaseSetUserMIDefaultValueUpdater, BaseGetEmptyUserMiDefaultValuesFetcher, BaseSetEmptyUserMIDefaultValueUpdater, BaseSearchCompanyUsersFetcher, BaseTrainlineTenantIsFrenchFetcher, BaseUserService, BaseSetPaymentOptionUpdater, BaseGetCancellationInfoFetcher, BaseAddGuestToBasketItemUpdater, BaseAddUpdatedItemToBasketUpdater, BaseCreateBasketNoteUpdater, BaseGetBasketNotesFetcher, BaseGetBasketApprovalTimestampsFetcher, BaseAddBasketItemMarkupUpdater, BaseAddBasketItemCustomRemarkUpdater, BaseGetBasketItemCustomRemarksFetcher, BaseChangeBasketOwnershipUpdater, BaseGetBasketQuoteFetcher, BaseGetProcessTermsPriceFetcher, BaseAcceptProcessTermsUpdater, BaseResendApproverEmailFetcher, BaseCheckIfBasketRequiresApprovalFetcher, BaseGetOfficeApproversFetcher, BaseSelectBasketApproverUpdater, BaseGetDraftBasketsFetcher, BaseCreateBasketFromDraftUpdater, BaseSelectBasketNotifyApproverUpdater, BaseCanAmendBookingFetcher, BaseGetUserApproversFetcher, BaseGetMIApproversFetcher, BaseGetBasketApprovalInfoFetcher, BaseShareBasketUpdater, BaseGetUserSharedBasketsFetcher, BaseGetTrainSeatMapFetcher, BaseBeforeAmendCabSearchFetcher, BaseBeforeAmendCarHireSearchFetcher, BaseSendBackToQueueUpdater, BaseGetBasketCo2InfoFetcher, BaseSelectBasketMultiLevelApproversUpdater, BaseValidateBasketMiFetcher, BaseValidateBasketItemMiFetcher, BaseSetMIValuesUpdater, BaseSearchMIAutoSuggestValuesFetcher, BaseGetTrainSeatmapEvolviFetcher, BaseReserveRailSeatsUpdater, BaseGetEvolviSeatmapsAreEnabledFetcher, BasegetRequestedBookingUpdateFetcher, BaseUpdateExchangeBasketUpdater, BaseDownloadETicketFetcher, BaseEnterpriseBasketService, BaseHotelAvalibilityQuoteFetcher, BaseHotelAvalibilityService, AbstractHttpCallService, BaseSearchAirportsFetcher, BaseSearchAirlinesFetcher, BaseSearchCityFetcher, BaseSearchPostcodeFetcher, BaseSearchRailStationsFetcher, BaseSaveUserAddressUpdater, BaseEditUserAddressUpdater, BaseUserAddressesFetcher, BaseGetUserCompanyOfficesFetcher, BaseSearchHotelChainsFetcher, BaseGetConfermaRoomImagesFetcher, BaseValidateIsPostcodeValidTester, BaseDeleteUserAddressUpdater, BaseDeleteRecentSearchUpdater, BaseSaveRecentSearchUpdater, BaseGetUserCarbonAllowanceFetcher, BaseSaveFavouriteSearchUpdater, BaseGetHotelChainsFetcher, BaseGetRailProvidersFetcher, BaseGetAllAirlinesFetcher, BaseGetCarHireProvidersFetcher, BaseLoungeQuoteFetcher, BaseParkingQuoteFetcher, BaseFlightQuoteFetcher, BaseHotelQuoteFetcher, BaseCarhireQuoteFetcher, BaseCarHireAvailabilityDetailFetcher, BaseCabhireQuoteFetcher, BaseRailQuoteFetcher, BaseIrlQuoteFetcher, BaseSearchDepotFetcher, BaseGetRailStationInfoFetcher, BaseGetRailStationFetcher, BaseGetIrlSupplierStationFetcher, BaseGetRiskAlertsFetcher, BaseSearchConfermaQuicklistFetcher, BaseGetUserRecentSearchesFetcher, BaseGetRailcardsFetcher, BaseGetCovidMicrositeTokenFetcher, BaseEurostarQuoteFetcher, BaseSearchUsersCanBookForFetcher, BaseSearchIrlStationsFetcher, BaseIrlDiscountCardFetcher, BaseGetFlightFareRulesFetcher, BaseGetFlightSeatMapFetcher, BaseGetRailLiveDeparturesFetcher, BaseHotelRulesFetcher, BaseApplyJitFlightRulesFetcher, BaseGetUserFavouriteSearchesFetcher, BaseDeleteFavouriteSearchUpdater, BaseEmailBasketFetcher, BaseFastTrackQuoteFetcher, BaseSendOfflineNotificationFetcher, BaseGenerateBasketPdfFetcher, BaseEmailFerryBookingFetcher, BaseGetFlightExtrasOptionsFetcher, BaseConvertCurrencyFetcher, BaseGetCurrencyConversionRatesFetcher, BaseGetHotelDetailsFetcher, BaseGetServiceFetcher, BaseGetFlightBrandedFaresFetcher, BaseGetTrainlineSearchConfigFetcher, BaseSearchRailInwardFetcher, BaseRailSearchExchangeFetcher, BaseCreateItineraryExchangeUpdater, BaseGetAirAvailabilityFetcher, BaseGetFlightAtNewClassFetcher, BaseGetFlightUpsellOffersFetcher, BaseGetOfficesFetcher, BaseFlightSearchExchangeFetcher, BaseFlightExchangeDetailsFetcher, BaseEmailApartmentBookingFetcher, BaseEmailSeasonTicketBookingFetcher, BaseSuggestPlacesFetcher, BaseGetLatLonFromHereIdFetcher, BaseGetGmtItineraryOptionsFetcher, BaseGetGutCitySuggestionsFetcher, BaseGetGutLocationSuggestionsFetcher, BaseGetRouteHappyFetcher, BaseGetMultipleHotelRatingFetcher, BaseEmailMeetingRoomBookingFetcher, BaseEmailAmbulanceBookingFetcher, BaseGetEntLocationByPostcode, BaseGetEntLocationByCity, BaseGetUserRecentBoltSearchesFetcher, BaseSaveRecentBoltSearchUpdater, BaseGetFerryPortsFetcher, BaseGetBannerFetcher, BaseUpdateDOBUpdater, BaseUpdateFlightSeatMapUpdater, BaseDeleteAllRecentSearchesUpdater, BaseGetOfficeDivisionsFetcher, BaseSearchGeoLocationFetcher, BaseSearchDiscoverLocationFetcher, BaseGetJyrneyUrlFetcher, BaseGetPriceHiddenSabreExchangeFetcher, BaseEnterpriseSearchService, BaseGetLatestVersionsFetcher, BaseLogonService, BaseCancelBookingUpdater, BaseAmendBookingUpdater, BaseCheckForDuplicateBookingsFetcher, BaseEnterpriseMyBookingsService, BaseRouteHappyService, BaseHttpCancelService, BaseMessagesService, RailFareNameKeywords, RailSplitType, isGroupTicket, RailFareTypes, SingleOrReturn, FlightSearchType, FlightDirectionEnum, BaseChatbotService, UserFavorurite, RailSearchCriteria, TimeWindow, LocationTypes, EurostarSearchType, ModalTypes, BaseGetMiRequiringMandatoryDefaultValueFetcher, BaseHttpCancelInterceptor } from '@sabstravtech/obtservices/base';
+import { BaseEnvironment, BaseEventMessenager, BaseHelperRoutines, PaymentMethodType, SchemaFormat, ServiceProvider, BaseModalOpenerService, BaseAcceptNewPriceUpdater, BaseAddItemToBasketUpdater, BaseAddUserToBasketItemUpdater, BaseCreateBasketUpdater, BaseGetBasketFetcher, BaseBookBasketUpdater, BaseDeleteBasketUpdater, BaseRemoveItemFromBasketUpdater, BaseRevalidateBasketUpdater, BaseGetUserFetcher, BaseGetUserBasketsFetcher, BaseSetBasketItemLeadPassengerUpdater, BaseMoveBasketItemToBasket, BaseUpdateBasketNoteUpdater, BaseUpdateBasketTitleUpdater, BaseUserUiConfigsFetcher, BaseUserProductsFetcher, BaseUserMessagesFetcher, BaseGetCompaniesFetcher, BaseGetCompanyFetcher, BaseConfirmMessagesUpdater, BaseSetUserLanguageUpdater, BaseEditUserUpdater, BaseCreateGuestUpdater, BaseGetUserGuestsFetcher, BaseGetOfficeFetcher, BaseRedirectApproverFetcher, BaseAddRedirectApproverUpdater, BaseRemoveRedirectApproverUpdater, BaseStorageService, BaseWebTokenService, BaseSearchCompanyApproversFetcher, BaseAddFavouriteUserUpdater, BaseGetUserFavouriteUsersFetcher, BaseRemoveFavouriteUserUpdater, BaseApexxCreateCardUpdater, BaseApexxDeleteCardUpdater, BaseApexxUpdateCardUpdater, BaseGetApexxListCardsFetcher, BaseSetBasketItemApexxTokenUpdater, BaseGetUserMiFetcher, BaseGetUserDocumentLoyaltyFetcher, BaseGetUserEmergencyContactFetcher, BaseDeleteGuestUpdater, BaseSearchUserWithEmailFetcher, BaseGetOfficeUsersFetcher, BaseRemovePreferredTransportHubUpdater, BaseSetPreferredTransportHubUpdater, BaseGetUserPreferredTransportHubsFetcher, BaseGetUserMiDefaultValuesFetcher, BaseGetUserMiStackFetcher, BaseSetUserMIDefaultValueUpdater, BaseGetEmptyUserMiDefaultValuesFetcher, BaseSetEmptyUserMIDefaultValueUpdater, BaseSearchCompanyUsersFetcher, BaseTrainlineTenantIsFrenchFetcher, BaseUserService, BaseSetPaymentOptionUpdater, BaseGetCancellationInfoFetcher, BaseAddGuestToBasketItemUpdater, BaseAddUpdatedItemToBasketUpdater, BaseCreateBasketNoteUpdater, BaseGetBasketNotesFetcher, BaseGetBasketApprovalTimestampsFetcher, BaseAddBasketItemMarkupUpdater, BaseAddBasketItemCustomRemarkUpdater, BaseGetBasketItemCustomRemarksFetcher, BaseChangeBasketOwnershipUpdater, BaseGetBasketQuoteFetcher, BaseGetProcessTermsPriceFetcher, BaseAcceptProcessTermsUpdater, BaseResendApproverEmailFetcher, BaseCheckIfBasketRequiresApprovalFetcher, BaseGetOfficeApproversFetcher, BaseSelectBasketApproverUpdater, BaseGetDraftBasketsFetcher, BaseCreateBasketFromDraftUpdater, BaseSelectBasketNotifyApproverUpdater, BaseCanAmendBookingFetcher, BaseGetUserApproversFetcher, BaseGetMIApproversFetcher, BaseGetBasketApprovalInfoFetcher, BaseShareBasketUpdater, BaseGetUserSharedBasketsFetcher, BaseGetTrainSeatMapFetcher, BaseBeforeAmendCabSearchFetcher, BaseBeforeAmendCarHireSearchFetcher, BaseSendBackToQueueUpdater, BaseGetBasketCo2InfoFetcher, BaseSelectBasketMultiLevelApproversUpdater, BaseValidateBasketMiFetcher, BaseValidateBasketItemMiFetcher, BaseSetMIValuesUpdater, BaseSearchMIAutoSuggestValuesFetcher, BaseGetTrainSeatmapEvolviFetcher, BaseReserveRailSeatsUpdater, BaseGetEvolviSeatmapsAreEnabledFetcher, BasegetRequestedBookingUpdateFetcher, BaseUpdateExchangeBasketUpdater, BaseDownloadETicketFetcher, BaseEnterpriseBasketService, BaseHotelAvalibilityQuoteFetcher, BaseHotelAvalibilityService, AbstractHttpCallService, BaseSearchAirportsFetcher, BaseSearchAirlinesFetcher, BaseSearchCityFetcher, BaseSearchPostcodeFetcher, BaseSearchRailStationsFetcher, BaseSaveUserAddressUpdater, BaseEditUserAddressUpdater, BaseUserAddressesFetcher, BaseGetUserCompanyOfficesFetcher, BaseSearchHotelChainsFetcher, BaseGetConfermaRoomImagesFetcher, BaseValidateIsPostcodeValidTester, BaseDeleteUserAddressUpdater, BaseDeleteRecentSearchUpdater, BaseSaveRecentSearchUpdater, BaseGetUserCarbonAllowanceFetcher, BaseSaveFavouriteSearchUpdater, BaseGetHotelChainsFetcher, BaseGetRailProvidersFetcher, BaseGetAllAirlinesFetcher, BaseGetCarHireProvidersFetcher, BaseLoungeQuoteFetcher, BaseParkingQuoteFetcher, BaseFlightQuoteFetcher, BaseHotelQuoteFetcher, BaseCarhireQuoteFetcher, BaseCarHireAvailabilityDetailFetcher, BaseCabhireQuoteFetcher, BaseRailQuoteFetcher, BaseIrlQuoteFetcher, BaseSearchDepotFetcher, BaseGetRailStationInfoFetcher, BaseGetRailStationFetcher, BaseGetIrlSupplierStationFetcher, BaseGetRiskAlertsFetcher, BaseSearchConfermaQuicklistFetcher, BaseGetUserRecentSearchesFetcher, BaseGetRailcardsFetcher, BaseGetCovidMicrositeTokenFetcher, BaseEurostarQuoteFetcher, BaseSearchUsersCanBookForFetcher, BaseSearchIrlStationsFetcher, BaseIrlDiscountCardFetcher, BaseGetFlightFareRulesFetcher, BaseGetFlightSeatMapFetcher, BaseGetRailLiveDeparturesFetcher, BaseHotelRulesFetcher, BaseApplyJitFlightRulesFetcher, BaseGetUserFavouriteSearchesFetcher, BaseDeleteFavouriteSearchUpdater, BaseEmailBasketFetcher, BaseFastTrackQuoteFetcher, BaseSendOfflineNotificationFetcher, BaseGenerateBasketPdfFetcher, BaseEmailFerryBookingFetcher, BaseGetFlightExtrasOptionsFetcher, BaseConvertCurrencyFetcher, BaseGetCurrencyConversionRatesFetcher, BaseGetHotelDetailsFetcher, BaseGetServiceFetcher, BaseGetFlightBrandedFaresFetcher, BaseGetTrainlineSearchConfigFetcher, BaseSearchRailInwardFetcher, BaseRailSearchExchangeFetcher, BaseCreateItineraryExchangeUpdater, BaseGetAirAvailabilityFetcher, BaseGetFlightAtNewClassFetcher, BaseGetFlightUpsellOffersFetcher, BaseGetOfficesFetcher, BaseFlightSearchExchangeFetcher, BaseFlightExchangeDetailsFetcher, BaseEmailApartmentBookingFetcher, BaseEmailSeasonTicketBookingFetcher, BaseSuggestPlacesFetcher, BaseGetLatLonFromHereIdFetcher, BaseGetGmtItineraryOptionsFetcher, BaseGetGutCitySuggestionsFetcher, BaseGetGutLocationSuggestionsFetcher, BaseGetRouteHappyFetcher, BaseGetMultipleHotelRatingFetcher, BaseEmailMeetingRoomBookingFetcher, BaseEmailAmbulanceBookingFetcher, BaseGetEntLocationByPostcode, BaseGetEntLocationByCity, BaseGetUserRecentBoltSearchesFetcher, BaseSaveRecentBoltSearchUpdater, BaseGetFerryPortsFetcher, BaseGetBannerFetcher, BaseUpdateDOBUpdater, BaseUpdateFlightSeatMapUpdater, BaseDeleteAllRecentSearchesUpdater, BaseGetOfficeDivisionsFetcher, BaseSearchGeoLocationFetcher, BaseSearchDiscoverLocationFetcher, BaseGetJyrneyUrlFetcher, BaseGetPriceHiddenSabreExchangeFetcher, BaseEnterpriseSearchService, BaseGetLatestVersionsFetcher, BaseLogonService, BaseCancelBookingUpdater, BaseAmendBookingUpdater, BaseCheckForDuplicateBookingsFetcher, BaseEnterpriseMyBookingsService, BaseRouteHappyService, BaseHttpCancelService, BaseMessagesService, RailFareNameKeywords, RailSplitType, isGroupTicket, RailFareTypes, SingleOrReturn, makeFareRules, FlightDirectionEnum, FlightSearchType, BaseChatbotService, UserFavorurite, RailSearchCriteria, TimeWindow, LocationTypes, EurostarSearchType, ModalTypes, BaseGetMiRequiringMandatoryDefaultValueFetcher, BaseHttpCancelInterceptor } from '@sabstravtech/obtservices/base';
 import { FormGroup, FormControl, Validators } from '@angular/forms';
 import * as i1 from 'apollo-angular';
 import { gql } from 'apollo-angular';
@@ -8340,11 +8340,6 @@ const GetProcessTermsPriceDocument = gql `
   ) {
     amount
     currency
-    taxItemsWithoutCode {
-      name
-      amount
-      currency
-    }
   }
 }
     `;
@@ -17529,6 +17524,12 @@ class ResultAwareService {
     currentServiceType = null;
     railSourceId = null;
     railReturnJourneys = [];
+    /** Raw flight itineraries per leg, kept so the chat cards' "Fare Rules" links
+     *  can resolve a fare back to its underlying journey. Outbound holds the
+     *  outbound + combined-return journeys; inbound holds dual-single return
+     *  journeys (priced separately). */
+    flightOutboundRaw = [];
+    flightInboundRaw = [];
     resultsAvailableSubject = new BehaviorSubject(false);
     resultsAvailable$ = this.resultsAvailableSubject.asObservable();
     constructor(searchService, basketService, router) {
@@ -17570,6 +17571,24 @@ class ResultAwareService {
         this.condensedResults = this.condenseHotelResults(results);
         this.resultsAvailableSubject.next(this.condensedResults.length > 0);
     }
+    captureCarHireResults(results) {
+        this.currentServiceType = ServiceType.Car;
+        this.rawResults = results;
+        this.resultsAvailableSubject.next(results.length > 0);
+    }
+    async selectCarHire(cardIndex) {
+        const result = this.rawResults[cardIndex];
+        if (!result) {
+            return;
+        }
+        // const searchParams = this.searchService.searches[ServiceType.Car] as any;
+        // await searchParams.addCarHireToBasket(result, searchParams.getSearchQuery());
+        // this.basketService.toggleMenu();
+        const basket = (await this.basketService.getDefaultBasket())?.subject.value;
+        if (basket?.id) {
+            this.router.navigate(['/itinerary', basket.id]);
+        }
+    }
     isHotelSearch() {
         return this.currentServiceType === ServiceType.Hotel;
     }
@@ -17640,6 +17659,39 @@ class ResultAwareService {
             return;
         await searchParams.openRailTicketDetailsDialog(journey, foundFare, foundFare.terms, foundFare.identifiers, this.railSourceId || '');
     }
+    /** Store the raw flight journeys for each leg so the chat cards can open fare
+     *  rules. Called by the chat flight-search service after a search/re-rank. */
+    setFlightRawLegs(outbound, inbound) {
+        this.flightOutboundRaw = outbound || [];
+        this.flightInboundRaw = inbound || [];
+    }
+    /**
+     * Open the existing OBT flight "Fare Rules" dialog for a fare displayed in the
+     * chat — mirrors the results page's fares-table behaviour (makeFareRules +
+     * openFlightFareRules) so the user sees the same conditions modal.
+     */
+    async openFlightFareDetails(ticket) {
+        if (!ticket || ticket.journeyIndex == null)
+            return;
+        const journeys = ticket.isReturnLeg ? this.flightInboundRaw : this.flightOutboundRaw;
+        const journey = journeys?.[ticket.journeyIndex];
+        if (!journey)
+            return;
+        const searchParams = this.searchService.searches[ServiceType.Flight];
+        if (typeof searchParams?.openFlightFareRules !== 'function')
+            return;
+        const { rules, flights } = makeFareRules(journey, FlightDirectionEnum.Outbound);
+        const isReturn = (journey.inboundFlights?.length ?? 0) > 0;
+        let inboundRules = null;
+        let inboundFlights = null;
+        if (isReturn) {
+            const inbound = makeFareRules(journey, FlightDirectionEnum.Inbound);
+            inboundRules = inbound.rules;
+            inboundFlights = inbound.flights;
+        }
+        const flightDetail = isReturn ? journey : null;
+        searchParams.openFlightFareRules(rules, flights, journey.sourceId, { centered: true, size: 'xl' }, null, flightDetail, inboundRules, inboundFlights);
+    }
     collectFareTickets(journey, sections, journeyIndex, isReturnLeg) {
         const tickets = [];
         for (const section of sections) {
@@ -17959,6 +18011,10 @@ class ResultAwareService {
         let condensedReturns = [];
         for (let i = 0; i < returnJourneys.length; i++) {
             const rj = returnJourneys[i];
+            // Cancelled services have no selectable fares; omit them from the results.
+            if (rj.cancelled) {
+                continue;
+            }
             const cheapestFare = this.getCheapestRailFare(rj);
             const expensiveFare = this.getMostExpensiveRailFare(rj);
             const cheapestValid = cheapestFare &&
@@ -17970,6 +18026,8 @@ class ResultAwareService {
                     index: i,
                     depart: this.formatTime(rj.departDateTime),
                     arrive: this.formatTime(rj.arriveDateTime),
+                    departDateTime: rj.departDateTime,
+                    arriveDateTime: rj.arriveDateTime,
                     stops: parseInt(rj.changes || '0', 10),
                     duration: this.computeRailDuration(rj),
                     price: cheapestValid ? cheapestFare.price : 0,
@@ -17986,6 +18044,8 @@ class ResultAwareService {
                     index: i,
                     depart: this.formatTime(rj.departDateTime),
                     arrive: this.formatTime(rj.arriveDateTime),
+                    departDateTime: rj.departDateTime,
+                    arriveDateTime: rj.arriveDateTime,
                     stops: parseInt(rj.changes || '0', 10),
                     duration: this.computeRailDuration(rj),
                     price: expensiveValid ? expensiveFare.price : 0,
@@ -18001,6 +18061,10 @@ class ResultAwareService {
         const parsdJourneys = [];
         for (let i = 0; i < journeys.length; i++) {
             const journey = journeys[i];
+            // Cancelled services have no selectable fares; omit them from the results.
+            if (journey.cancelled) {
+                continue;
+            }
             const cheapestFare = this.getCheapestRailFare(journey);
             const hasValidFare = cheapestFare && cheapestFare.price > 0;
             const result = {
@@ -18008,6 +18072,8 @@ class ResultAwareService {
                 operator: journey.journeyLegs?.[0]?.operatorName || '',
                 depart: this.formatTime(journey.departDateTime),
                 arrive: this.formatTime(journey.arriveDateTime),
+                departDateTime: journey.departDateTime,
+                arriveDateTime: journey.arriveDateTime,
                 stops: parseInt(journey.changes || '0', 10),
                 duration: this.computeRailDuration(journey),
                 price: hasValidFare ? cheapestFare.price : 0,
@@ -18015,7 +18081,7 @@ class ResultAwareService {
                 co2: journey.co2PerPassenger || 0,
                 policyStatus: hasValidFare ? this.derivePolicyStatus(cheapestFare) : 'UNAVAILABLE',
                 policyMessages: hasValidFare ? this.derivePolicyMessages(cheapestFare) : [],
-                singleOrReturn: cheapestFare.singleOrReturn
+                singleOrReturn: cheapestFare?.singleOrReturn
             };
             // Attach return options so the LLM can select both legs
             if (condensedReturns.length > 0) {
@@ -18030,6 +18096,8 @@ class ResultAwareService {
                 operator: journey.journeyLegs?.[0]?.operatorName || '',
                 depart: this.formatTime(journey.departDateTime),
                 arrive: this.formatTime(journey.arriveDateTime),
+                departDateTime: journey.departDateTime,
+                arriveDateTime: journey.arriveDateTime,
                 stops: parseInt(journey.changes || '0', 10),
                 duration: this.computeRailDuration(journey),
                 price: expensiveValid ? expensiveFare.price : 0,
@@ -18037,7 +18105,7 @@ class ResultAwareService {
                 co2: journey.co2PerPassenger || 0,
                 policyStatus: expensiveValid ? this.derivePolicyStatus(expensiveFare) : 'UNAVAILABLE',
                 policyMessages: expensiveValid ? this.derivePolicyMessages(expensiveFare) : [],
-                singleOrReturn: expensiveFare.singleOrReturn
+                singleOrReturn: expensiveFare?.singleOrReturn
             };
             // console.log(`[ResultAwareService] - Condensed Returns: ${condensedReturns.length}`);
             // Attach return options so the LLM can select both legs
@@ -18085,18 +18153,28 @@ class ResultAwareService {
                 ret.price = 0;
             });
         }
-        // remove any returns which time conflict with this journey
-        const arrivalTimeSplit = result.arrive.split(':');
-        const arrivalDate = moment$1();
-        arrivalDate.hour(arrivalTimeSplit[0]);
-        arrivalDate.minutes(arrivalTimeSplit[1]);
+        // Remove any returns which depart before this outbound arrives. Prefer the
+        // full ISO datetimes so a return on a later calendar day isn't dropped just
+        // because its time-of-day is earlier than the outbound arrival (e.g. arrive
+        // 17:44 day 1, return departs 16:14 day 2). Fall back to a time-of-day
+        // comparison when a datetime is missing (same-day / open returns).
+        const timeOfDay = (time) => {
+            const [hour, minute] = time.split(':');
+            return moment$1().hour(Number(hour)).minute(Number(minute)).second(0).millisecond(0);
+        };
+        const departsAfterArrival = (ret) => {
+            if (result.arriveDateTime != null && ret.departDateTime != null) {
+                const arrival = moment$1(result.arriveDateTime);
+                const depart = moment$1(ret.departDateTime);
+                if (arrival.isValid() && depart.isValid()) {
+                    return depart.isAfter(arrival);
+                }
+            }
+            return timeOfDay(ret.depart).isAfter(timeOfDay(result.arrive));
+        };
         condensedReturns = condensedReturns.filter((ret) => {
             try {
-                const departTimeSplit = ret.depart.split(':');
-                const retDepartTime = moment$1();
-                retDepartTime.hour(departTimeSplit[0]);
-                retDepartTime.minute(departTimeSplit[1]);
-                return retDepartTime.isAfter(arrivalDate);
+                return departsAfterArrival(ret);
             }
             catch (error) {
                 return false;
@@ -18203,6 +18281,11 @@ class ChatbotService extends BaseChatbotService {
     /** Back-compat boolean stream for callers that only care whether a search is in flight. */
     searching$ = this.searchingSubject.pipe(map((s) => s.searching));
     fillSearchForm$ = new Subject();
+    /** Fires after the car hire chatbot handler has finished populating city/depot params,
+     *  so the component can call updateLocation() to populate the depot dropdown options. */
+    carHireParamsReady$ = new Subject();
+    /** Re-rank already-cached results (no new search) — routed to the handler's resort(). */
+    resortResults$ = new Subject();
     riskFlagSubject = new BehaviorSubject(null);
     riskFlag$ = this.riskFlagSubject.asObservable();
     faqsSubject = new BehaviorSubject([]);
@@ -18266,6 +18349,9 @@ class ChatbotService extends BaseChatbotService {
     notifyFillForm(parameters, autoSearch) {
         this.fillSearchForm$.next({ parameters, autoSearch });
     }
+    notifyResort(parameters) {
+        this.resortResults$.next({ parameters });
+    }
     notifyRiskFlag(flag) {
         this.riskFlagSubject.next(flag);
     }
@@ -18294,20 +18380,58 @@ class ChatbotService extends BaseChatbotService {
         return 'web';
     }
     getUserCapabilities() {
+        const flightDefaults = this.userService.getUserFavoriteObject(UserFavorurite.FlightSearchDefaults) || {};
         return {
             isCrown: this.userService.crownIsSet(),
             isAgent: this.userService.userIsAgent(),
             uiConfigs: {
-                hideHotelSearchOptions: this.userService.isUserFavoriteSet(new UserFavorurite('hideHotelSearchOptions'))
+                hideHotelSearchOptions: this.userService.isUserFavoriteSet(new UserFavorurite('hideHotelSearchOptions')),
+                allowedFlightCabins: this.resolveAllowedFlightCabins(flightDefaults.classSelection),
+                flightAnyCabinAllowed: flightDefaults.classSelection
+                    ? flightDefaults.classSelection.any !== true
+                    : true,
+                flightMultiCityEnabled: flightDefaults.enableMultiCityForFlight === true,
+                flightMultiCityMaxLegs: flightDefaults.multiCityMaxSelectors
+                    ? Number(flightDefaults.multiCityMaxSelectors)
+                    : undefined,
+                hideFlightVia: this.userService.isUserFavoriteSet(new UserFavorurite('HideFlightVia')),
+                flightMinTimeFlexibilityHours: flightDefaults.setMinimumTimeWindow
+                    ? Number(flightDefaults.setMinimumTimeWindow)
+                    : undefined
             }
         };
     }
+    /**
+     * Translate the flight search form's `classSelection` config (where a `true`
+     * value HIDES a cabin) into the list of cabin classes the user is allowed to
+     * search/book, in the cabin enum the chatbot/AI uses. Returns undefined when
+     * no class is hidden (i.e. no restriction).
+     */
+    resolveAllowedFlightCabins(classSelection) {
+        if (!classSelection) {
+            return undefined;
+        }
+        const map = [
+            ['economy', 'Economy'],
+            ['premium', 'PremiumEconomy'],
+            ['business', 'Business'],
+            ['first', 'First']
+        ];
+        const allowed = map.filter(([key]) => classSelection[key] !== true).map(([, label]) => label);
+        return allowed.length < map.length ? allowed : undefined;
+    }
+    getUserFirstName() {
+        return this.userService.fullUserDetails.allDetails.value?.forename ?? undefined;
+    }
     // ── Public override ──────────────────────────────────────────────────────
+    /** Set by ChatbotCarHireSearchService when the user is choosing from a depot list. */
+    depotSelectionHandler = null;
     connect() {
-        const user = this.userService.fullUserDetails.allDetails.value;
-        if (!user?.aiTravelAssistantEnabled) {
-            return;
-        }
+        // TODO: restore guard → check aiTravelAssistantEnabled
+        // const user = this.userService.fullUserDetails.allDetails.value;
+        // if (!(user as any)?.aiTravelAssistantEnabled) {
+        //   return;
+        // }
         super.connect();
     }
     clearSession() {
@@ -18317,14 +18441,39 @@ class ChatbotService extends BaseChatbotService {
     injectMessage(message) {
         this.addMessage(message);
     }
+    /** Remove the last assistant message from the UI (e.g. when it's been superseded). */
+    retractLastAssistantMessage() {
+        this.removeLastAssistantMessage();
+    }
+    async beforeEmit(text) {
+        if (this.depotSelectionHandler) {
+            const handled = await this.depotSelectionHandler(text);
+            if (handled)
+                return true;
+        }
+        return false;
+    }
     handleResponse(env) {
         super.handleResponse(env);
+        const tt = env.parameters?.travelType;
+        // Re-rank the already-cached results (cheapest/fastest/nearest-time) without
+        // a new backend search. The handler reads the session's cached itineraries
+        // and re-renders the cards.
+        if (env.action === 'sort_results' && tt === 'flight') {
+            this.notifyResort(env.parameters);
+            return;
+        }
         // Auto-trigger a search as soon as the bot signals parameters are complete.
         // The dispatcher routes to the travel-type handler, which owns the search +
         // result-capture flow.
-        const tt = env.parameters?.travelType;
         if (env.state === 'PARAMS_COMPLETE' &&
-            (tt === 'rail' || tt === 'flight' || tt === 'hotel' || tt === 'eurostar')) {
+            (tt === 'rail' ||
+                tt === 'flight' ||
+                tt === 'hotel' ||
+                tt === 'car-hire' ||
+                tt === 'eurostar' ||
+                tt === 'lounge' ||
+                tt === 'taxi')) {
             this.notifyFillForm(env.parameters, true);
         }
     }
@@ -18440,8 +18589,9 @@ class ChatbotRailSearchService {
             return;
         }
         const railResults = railSearch.results.value;
-        if (railResults?.[0]) {
-            this.resultAwareService.captureRailResults(railResults[0]);
+        const resultIndex = parameters.isEuRail ? (railResults?.[1] ? 1 : 0) : 0;
+        if (railResults?.[resultIndex]) {
+            this.resultAwareService.captureRailResults(railResults[resultIndex]);
         }
         else {
             console.warn('[ChatbotRailSearchService] no rail results to capture (startSearch returned', ok, ')');
@@ -18575,6 +18725,7 @@ class ChatbotRailSearchService {
     // ── Param population ─────────────────────────────────────────────────────
     async populateRailParams(parameters, departNgbDate) {
         const railParams = this.searchService.searches[ServiceType.Rail];
+        railParams.changeLocation(parameters.isEuRail ? 'EU' : 'UK');
         railParams.outbound_date = departNgbDate;
         if (parameters.departureTime) {
             railParams.outbound_time = this.normalizeTime(parameters.departureTime);
@@ -18793,6 +18944,39 @@ function extractJourneys(results) {
 }
 const FLIGHT_RESULTS_WAIT_MS = 90_000;
 const MAX_FLIGHT_CARDS = 3;
+/**
+ * Order raw itineraries by the SAME "Preferred" ranking the normal results
+ * page applies by default (FlightEnterpriseSearch._sortItinaryRoutines
+ * [FlightSortTypes.Preferred]): highest `preferenceLevel` first, then the
+ * `preferred` flag, otherwise stable. Replicated here (not imported) so the
+ * chatbot's default cards are the top of the same list the user would see on
+ * the results page — a headless chatbot search never mounts the FlightSortBy
+ * component that would otherwise set this default, so `results.value` arrives
+ * in raw supplier order and must be ordered explicitly.
+ */
+function sortByPreferred(list) {
+    return [...list].sort((a, b) => {
+        const aLevel = a?.preferenceLevel ?? 0;
+        const bLevel = b?.preferenceLevel ?? 0;
+        if (aLevel && bLevel) {
+            if (aLevel > bLevel)
+                return -1;
+            if (aLevel < bLevel)
+                return 1;
+        }
+        else if (aLevel && !bLevel) {
+            return -1;
+        }
+        else if (!aLevel && bLevel) {
+            return 1;
+        }
+        if (a?.preferred && !b?.preferred)
+            return -1;
+        if (!a?.preferred && b?.preferred)
+            return 1;
+        return 0;
+    });
+}
 /**
  * Handles chatbot-driven flight searches. Registered with
  * `ChatbotSearchDispatcherService`; not used directly.
@@ -18809,7 +18993,20 @@ class ChatbotFlightSearchService {
     resultAwareService;
     userService;
     travelType = 'flight';
+    /** The flight form exposes four preferred-carrier slots. */
+    static MAX_PREFERRED_CARRIERS = 4;
+    /** Terms that mean "no airline preference" and should be ignored. */
+    static NO_CARRIER_PREFERENCE = new Set(['', 'any', 'all']);
+    /** Regional/subsidiary markers, so "KLM" doesn't resolve to "KLM Cityhopper". */
+    static CARRIER_SUBSIDIARY = /\b(cityhopper|cityline|cityjet|express|regional|connect|shuttle|airlink|link|commuter)\b/i;
     resultsSubscription = null;
+    /**
+     * The most recent full search parameters (origin, destination, dates,
+     * cabin, etc.). Cached so a {@link resort} call — whose own parameters carry
+     * only the new ranking intent (sortType / time target) — can still render
+     * card headers and dates for the trip that produced the cached results.
+     */
+    lastSearchParameters = null;
     constructor(chatbotService, searchService, resultAwareService, userService) {
         this.chatbotService = chatbotService;
         this.searchService = searchService;
@@ -18817,6 +19014,7 @@ class ChatbotFlightSearchService {
         this.userService = userService;
     }
     async handle(parameters, autoSearch) {
+        this.lastSearchParameters = parameters;
         this.searchService.resetSearchChosenObjects();
         this.searchService.resetSearchPriorities();
         this.searchService.search_objects[ServiceType.Flight].chosen = true;
@@ -18936,127 +19134,342 @@ class ChatbotFlightSearchService {
             return EMPTY;
         }))
             .subscribe(() => {
-            const rawResults = flightSearch.results?.value ?? [];
-            const { outbound, inbound, multi } = extractJourneys(rawResults);
-            const isMultiCity = (parameters.legs?.length ?? 0) >= 2;
-            // Feed ResultAwareService with outbound so its condensed-cards API is
-            // populated for downstream card click → filter navigation.
+            this.buildAndPatchResultsFromCache(parameters);
+            this.chatbotService.setSearching(false);
+        });
+    }
+    /**
+     * Re-render the chat flight cards from whatever the flight-search session
+     * currently holds — the same cached results that "View Full Results" shows.
+     * Used both by the post-search subscription and by {@link resort} (which
+     * re-ranks without a new backend search). Reads `results.value` (falling
+     * back to the unfiltered `fullResults`), re-extracts the journeys, and builds
+     * cards using `parameters` (sort/time/airline/stops) so the same data can be
+     * re-ordered for a new preference.
+     */
+    buildAndPatchResultsFromCache(parameters) {
+        const flightSearch = this.searchService.searches[ServiceType.Flight];
+        // `results.value` is the *filtered* bundle. For dual-single return
+        // searches applyFilters() can collapse multi[].results to [] when
+        // client-side filters (e.g. the `via` gateway) don't match the
+        // supplier's itineraries. Fall back to the unfiltered `fullResults` so
+        // the chat still surfaces the options.
+        const filtered = flightSearch.results?.value ?? [];
+        let extracted = extractJourneys(filtered);
+        if (!extracted.outbound.length &&
+            Array.isArray(flightSearch.fullResults) &&
+            flightSearch.fullResults.length) {
+            extracted = extractJourneys(flightSearch.fullResults);
+        }
+        const { outbound: rawOutboundOrder, inbound: rawInboundOrder } = extracted;
+        // Baseline order = the normal results page's default "Preferred" ranking, so
+        // the chatbot's default top-N cards are the same flights the user would see
+        // at the top of a normal search. Explicit re-ranks (cheapest/fastest/time)
+        // are re-sorted downstream in `buildFlightResults`, so this is a safe base.
+        const outbound = sortByPreferred(rawOutboundOrder);
+        const inbound = sortByPreferred(rawInboundOrder);
+        const isMultiCity = (parameters.legs?.length ?? 0) >= 2;
+        // Feed ResultAwareService with outbound so its condensed-cards API is
+        // populated for downstream card click → filter navigation.
+        this.resultAwareService.captureFlightResults(outbound);
+        // Keep both raw leg arrays so the chat cards' "Fare Rules" links can resolve
+        // a fare's underlying journey (outbound/combined-return vs dual-single inbound).
+        this.resultAwareService.setFlightRawLegs(outbound, inbound);
+        const outboundCondensed = this.resultAwareService.getCondensedResults();
+        let inboundCondensed = [];
+        if (inbound.length) {
+            // Build inbound condensed by re-running the condensation. The
+            // ResultAwareService keeps state for outbound, so we condense the
+            // raw inbound array via a temporary capture/restore.
+            this.resultAwareService.captureFlightResults(inbound);
+            inboundCondensed = this.resultAwareService.getCondensedResults();
+            // Restore outbound as the "current" capture for click-through filters.
             this.resultAwareService.captureFlightResults(outbound);
-            const outboundCondensed = this.resultAwareService.getCondensedResults();
-            let inboundCondensed = [];
-            if (inbound.length) {
-                // Build inbound condensed by re-running the condensation. The
-                // ResultAwareService keeps state for outbound, so we condense the
-                // raw inbound array via a temporary capture/restore.
-                this.resultAwareService.captureFlightResults(inbound);
-                inboundCondensed = this.resultAwareService.getCondensedResults();
-                // Restore outbound as the "current" capture for click-through filters.
-                this.resultAwareService.captureFlightResults(outbound);
-            }
-            const flightResults = isMultiCity
-                ? this.buildMultiCityFlightResults(parameters, outbound)
-                : this.buildFlightResults(outboundCondensed, inboundCondensed, parameters, outbound, inbound);
+        }
+        const flightResults = isMultiCity
+            ? this.buildMultiCityFlightResults(parameters, outbound)
+            : this.buildFlightResults(outboundCondensed, inboundCondensed, parameters, outbound, inbound);
+        this.chatbotService.patchAssistantMessage({
+            flightResults,
+            state: 'RESULTS_READY'
+        });
+    }
+    /**
+     * Re-rank the results already in the flight-search session for a new user
+     * preference (cheapest / fastest / shortest / nearest-to-time) WITHOUT
+     * running a new backend search. The cached itineraries are the same set the
+     * results page shows; we just re-order them via `buildFlightResults` and
+     * patch fresh cards onto the latest assistant message.
+     */
+    async resort(parameters) {
+        const flightSearch = this.searchService.searches[ServiceType.Flight];
+        const hasCache = !!flightSearch.results?.value?.length ||
+            (Array.isArray(flightSearch.fullResults) && flightSearch.fullResults.length > 0);
+        if (!hasCache) {
+            // Nothing cached to re-rank (e.g. the page was reloaded since the last
+            // search). sort_results only carries ranking fields, not a full set of
+            // search params, so we can't silently re-run the search — ask the user
+            // to search again rather than showing an empty card stack.
             this.chatbotService.patchAssistantMessage({
-                flightResults,
+                text: `I don't have those flight results to hand any more — could you run the search again and I'll re-rank them for you?`,
                 state: 'RESULTS_READY'
             });
-            this.chatbotService.setSearching(false);
-        });
+            return;
+        }
+        // The re-rank parameters carry only the new ranking intent (sortType /
+        // time target). Merge them over the last full search so the cards keep the
+        // trip's origin/destination/dates (used for headers + date labels) while
+        // applying the requested ordering.
+        const merged = {
+            ...(this.lastSearchParameters ?? {}),
+            ...parameters
+        };
+        this.buildAndPatchResultsFromCache(merged);
     }
     buildFlightResults(outbound, inbound, parameters, rawOutbound = [], rawInbound = []) {
         const isReturn = !!parameters.returnDate;
-        // sortType is widened on ChatSearchParameters to cover hotel + flight values;
-        // narrow back to the flight-only subset accepted by ChatFlightResults.sort.
-        const sort = parameters.sortType === 'fastest' || parameters.sortType === 'shortest'
-            ? parameters.sortType
-            : 'cheapest';
-        // Optional airline filter: if the user asked for a specific carrier
-        // ("Give me BA flights…"), keep only matching itineraries. Honour it
-        // strictly — better to show "no matches" than mislead the user.
-        const airlineFilter = (parameters.airlineCode || parameters.airline || '').trim().toLowerCase();
+        // Flight sort options the chatbot can re-rank by. Mirrors the normal results
+        // page's sort dropdown (FlightSortTypes) so "cheapest/fastest/most direct/
+        // lowest emissions/preferred/earliest|latest departure|arrival" all show the
+        // same top flights the page would. `preferred` is the default order, so it's
+        // treated as "no re-rank" (the list already arrives in Preferred order).
+        const FLIGHT_SORTS = new Set([
+            'cheapest',
+            'fastest',
+            'shortest',
+            'most_direct',
+            'lowest_emissions',
+            'earliest_departure',
+            'latest_departure',
+            'earliest_arrival',
+            'latest_arrival'
+        ]);
+        const requestedSort = parameters.sortType;
+        // The AI sends `sortType` when the user explicitly asks to rank. When present
+        // (and not the default `preferred`) it overrides time-proximity ordering;
+        // when absent we fall back to a target-time ranking if one exists.
+        const hasExplicitSort = !!requestedSort && FLIGHT_SORTS.has(requestedSort);
+        // Narrowed label kept for the ChatFlightResults.sort metadata field (price/
+        // duration family only); has no effect on the ordering applied below.
+        const sort = requestedSort === 'fastest' || requestedSort === 'shortest' ? requestedSort : 'cheapest';
+        // Time target for proximity ordering: "arrive by 5pm" ranks cards nearest
+        // 17:00 first, "depart at 9am" nearest 09:00. `field` records whether the
+        // user anchored on arrival or departure.
+        const targetTimeToMinutes = (time) => {
+            if (!time)
+                return null;
+            const match = /^(\d{2})(\d{2})$/.exec(this.normalizeTime(time));
+            return match ? +match[1] * 60 + +match[2] : null;
+        };
+        const cardTimeToMinutes = (time) => {
+            if (!time)
+                return null;
+            const match = /^(\d{1,2}):(\d{2})/.exec(time);
+            return match ? +match[1] * 60 + +match[2] : null;
+        };
+        // Build a proximity target from the trip params. `sort_results` re-ranks
+        // carry the time in `departureTime` with an explicit `outboundTimeCriteria`
+        // flag ("arrive by 11" → departureTime '11:00' + criteria 'Arrive'); the
+        // search path may instead set `arrivalTime` directly. Honour the criteria
+        // flag first so an arrival target ranks by arrival, not departure.
+        const resolveTarget = (primary, arrivalAlt, criteria) => {
+            if (criteria === 'Arrive') {
+                const value = primary ?? arrivalAlt;
+                return value ? { mins: targetTimeToMinutes(value), field: 'arrive' } : null;
+            }
+            if (criteria === 'Depart') {
+                const value = primary ?? arrivalAlt;
+                return value ? { mins: targetTimeToMinutes(value), field: 'depart' } : null;
+            }
+            if (primary)
+                return { mins: targetTimeToMinutes(primary), field: 'depart' };
+            if (arrivalAlt)
+                return { mins: targetTimeToMinutes(arrivalAlt), field: 'arrive' };
+            return null;
+        };
+        const outboundTarget = resolveTarget(parameters.departureTime, parameters.arrivalTime, parameters.outboundTimeCriteria);
+        const inboundTarget = resolveTarget(parameters.returnTime, parameters.returnArrivalTime, parameters.returnTimeCriteria);
+        // How each leg's time target should shape the cards: `around` → proximity
+        // rank; `before`/`after` → bound filter + Preferred order; undefined (initial
+        // search) → pure constraint, cards keep Preferred order to mirror the page.
+        const outboundTimeMode = parameters.outboundTimeMode;
+        const inboundTimeMode = parameters.returnTimeMode;
+        // Optional airline filter: when the user asked for specific carrier(s)
+        // ("Give me BA flights", "BA or Virgin"), keep only matching itineraries
+        // strictly — better to show "no matches" than mislead the user. Matches if
+        // the result matches ANY of the requested airlines.
+        const airlineFilters = this.collectCarrierTerms(parameters).map((t) => t.toLowerCase());
         const applyAirline = (list) => {
-            if (!airlineFilter)
+            if (!airlineFilters.length)
                 return list;
-            return list.filter((r) => {
-                const code = (r.flightNumbers?.match(/^[A-Z]{2,3}/i)?.[0] || '').toLowerCase();
-                const name = (r.airline || '').toLowerCase();
-                return code === airlineFilter || name.includes(airlineFilter);
+            return list.filter((result) => {
+                const carrierCode = (result.flightNumbers?.match(/^[A-Z]{2,3}/i)?.[0] || '').toLowerCase();
+                const airlineName = (result.airline || '').toLowerCase();
+                return airlineFilters.some((f) => carrierCode === f || airlineName.includes(f));
             });
         };
-        // Honour "direct only" / maxConnections=0 strictly. The form-level
-        // maxConnections setting goes to the supplier, but some suppliers ignore
-        // it — re-filter client-side so the user gets what they asked for.
+        // Honour "direct only" / maxConnections strictly. The form-level setting
+        // goes to the supplier, but some suppliers ignore it — re-filter
+        // client-side so the user gets what they asked for.
         const applyStops = (list) => {
             if (parameters.maxConnections == null)
                 return list;
             const max = parameters.maxConnections;
-            return list.filter((r) => (r.stops ?? 0) <= max);
+            return list.filter((result) => (result.stops ?? 0) <= max);
+        };
+        // Drop next-day arrivals when the user anchored on a same-day arrival
+        // ("arrive before 17:00 tomorrow"). Some suppliers honour the arrival
+        // *time-of-day* window but still return overnight itineraries that land the
+        // following day (e.g. depart 20:50 → arrive 15:35 +1, 17h45m, 1 stop). Their
+        // clock-time arrival sits inside the window, so without this they'd pass the
+        // supplier filter, fool the time-proximity sort, and render as nonsensical
+        // same-day flights. Only applied when an arrival target exists so plain
+        // departure-time or unconstrained searches keep legitimate red-eyes.
+        const applyArrivalWindow = (list, target) => {
+            if (!target || target.field !== 'arrive')
+                return list;
+            return list.filter((result) => this.arrivalDayOffset(result) <= 0);
+        };
+        // Honour an explicit "before"/"after" time bound ("arrive by 11", "depart
+        // after 9") strictly. Unlike a proximity target this doesn't re-order — it
+        // just drops cards that fall outside the bound so the kept ones still show
+        // in Preferred order (matching the normal results page). Only applied for an
+        // explicit bound mode; an initial search leaves the cards untouched.
+        const applyTimeBound = (list, target, mode) => {
+            if (!target || target.mins == null || (mode !== 'before' && mode !== 'after')) {
+                return list;
+            }
+            const boundMins = target.mins;
+            return list.filter((result) => {
+                const label = target.field === 'arrive' ? result.arrive : result.depart;
+                const mins = cardTimeToMinutes(label);
+                if (mins == null)
+                    return true;
+                return mode === 'before' ? mins <= boundMins : mins >= boundMins;
+            });
         };
-        const outFiltered = applyStops(applyAirline(outbound));
-        const inFiltered = applyStops(applyAirline(inbound));
-        // Dedupe by physical-flight signature, keep the cheapest fare per flight,
-        // then sort. Without dedup we'd often render two or three "cards" that
-        // are the same KL1034 with different fare brands (Restricted/Flex/Plus)
-        // — the user wants one card per flight with the cheapest price shown,
-        // and the existing fare-options expand panel (built via
-        // indexFaresByFlights) surfaces the other bookable fares.
+        const outFiltered = applyTimeBound(applyArrivalWindow(applyStops(applyAirline(outbound)), outboundTarget), outboundTarget, outboundTimeMode);
+        const inFiltered = applyTimeBound(applyArrivalWindow(applyStops(applyAirline(inbound)), inboundTarget), inboundTarget, inboundTimeMode);
+        // Dedupe by physical-flight signature, keeping the cheapest fare per flight,
+        // then sort. Without this we'd render the same flight several times with
+        // different fare brands (Restricted/Flex/Plus); the fare-options expand
+        // panel (built via indexFaresByFlights) surfaces the other bookable fares.
         //
-        // Key includes outbound flight numbers + inbound flight numbers AND each
-        // leg's depart time, so two operationally-distinct flights that happen
-        // to share marketing flight numbers (codeshares on different equipment
-        // or schedules) don't collapse into one card.
-        const parseDurationToMins = (d) => {
-            if (!d)
+        // The key includes both legs' flight numbers AND depart times so two
+        // operationally-distinct flights sharing marketing numbers (codeshares on
+        // different equipment/schedules) don't collapse into one card.
+        const parseDurationToMins = (duration) => {
+            if (!duration)
                 return Number.POSITIVE_INFINITY;
-            const h = /(\d+)\s*h/i.exec(d);
-            const m = /(\d+)\s*m/i.exec(d);
-            const total = (h ? +h[1] : 0) * 60 + (m ? +m[1] : 0);
+            const hours = /(\d+)\s*h/i.exec(duration);
+            const minutes = /(\d+)\s*m/i.exec(duration);
+            const total = (hours ? +hours[1] : 0) * 60 + (minutes ? +minutes[1] : 0);
             return total > 0 ? total : Number.POSITIVE_INFINITY;
         };
-        const totalDurationMins = (r) => parseDurationToMins(r.duration) + (r.inbound ? parseDurationToMins(r.inbound.duration) : 0);
+        const totalDurationMins = (result) => parseDurationToMins(result.duration) +
+            (result.inbound ? parseDurationToMins(result.inbound.duration) : 0);
         const dedupeCheapestByFlight = (list) => {
-            const seen = new Map();
-            for (const r of list) {
-                const out = r.flightNumbers || '';
-                const inb = r.inbound?.flightNumbers || '';
-                if (!out && !inb) {
+            const cheapestByKey = new Map();
+            for (const result of list) {
+                const outboundNumbers = result.flightNumbers || '';
+                const inboundNumbers = result.inbound?.flightNumbers || '';
+                if (!outboundNumbers && !inboundNumbers) {
                     // No flight numbers to key on (shouldn't happen for real results);
                     // fall back to per-index so we don't collapse unrelated cards.
-                    seen.set(`__idx${r.index}`, r);
+                    cheapestByKey.set(`__idx${result.index}`, result);
                     continue;
                 }
-                const key = `${out}|${inb}|${r.depart}|${r.inbound?.depart ?? ''}`;
-                const existing = seen.get(key);
-                if (!existing || (r.price ?? Infinity) < (existing.price ?? Infinity)) {
-                    seen.set(key, r);
+                const key = `${outboundNumbers}|${inboundNumbers}|${result.depart}|${result.inbound?.depart ?? ''}`;
+                const existing = cheapestByKey.get(key);
+                if (!existing || (result.price ?? Infinity) < (existing.price ?? Infinity)) {
+                    cheapestByKey.set(key, result);
                 }
             }
-            const arr = Array.from(seen.values());
-            if (sort === 'fastest' || sort === 'shortest') {
-                arr.sort((a, b) => totalDurationMins(a) - totalDurationMins(b));
+            return Array.from(cheapestByKey.values());
+        };
+        // Time-of-day in minutes for a card, preferring the raw ISO datetime (so
+        // next-day arrivals sort after same-day ones) and falling back to the HH:MM
+        // label. Used by the earliest/latest departure & arrival sorts.
+        const cardClockMins = (result, field) => {
+            const iso = field === 'arrive' ? result.arriveDateTime : result.departDateTime;
+            if (iso) {
+                const parsed = Date.parse(iso);
+                if (!Number.isNaN(parsed))
+                    return parsed;
             }
-            else {
-                arr.sort((a, b) => (a.price ?? Infinity) - (b.price ?? Infinity));
+            const label = field === 'arrive' ? result.arrive : result.depart;
+            const mins = cardTimeToMinutes(label);
+            return mins == null ? Number.POSITIVE_INFINITY : mins;
+        };
+        // Comparators for each explicit flight sort — mirrors the normal results
+        // page's sort dropdown so the chatbot's top cards match what the user would
+        // see there. Keyed by the AI's sortType. `preferred` is intentionally
+        // absent: it's the default order, handled by the fall-through below.
+        const sortComparators = {
+            cheapest: (a, b) => (a.price ?? Infinity) - (b.price ?? Infinity),
+            fastest: (a, b) => totalDurationMins(a) - totalDurationMins(b),
+            shortest: (a, b) => totalDurationMins(a) - totalDurationMins(b),
+            most_direct: (a, b) => (a.stops ?? Infinity) - (b.stops ?? Infinity) ||
+                totalDurationMins(a) - totalDurationMins(b),
+            lowest_emissions: (a, b) => (a.co2 ?? Number.POSITIVE_INFINITY) - (b.co2 ?? Number.POSITIVE_INFINITY),
+            earliest_departure: (a, b) => cardClockMins(a, 'depart') - cardClockMins(b, 'depart'),
+            latest_departure: (a, b) => cardClockMins(b, 'depart') - cardClockMins(a, 'depart'),
+            earliest_arrival: (a, b) => cardClockMins(a, 'arrive') - cardClockMins(b, 'arrive'),
+            latest_arrival: (a, b) => cardClockMins(b, 'arrive') - cardClockMins(a, 'arrive')
+        };
+        // Order a deduped leg for display:
+        //   1. proximity mode ("around/closest to/at" a time) + no explicit sort ->
+        //      nearest to that time first
+        //   2. an explicit sortType -> the matching comparator (price/duration/
+        //      stops/co2/departure/arrival)
+        //   3. otherwise (incl. `preferred`, and "by/before/after" bounds which are
+        //      filtered above) -> preserve the incoming "Preferred" order (the normal
+        //      results page default), so the chatbot's default cards match the top of
+        //      the user's normal search.
+        const orderLeg = (legResults, target, mode) => {
+            if (mode === 'around' && !hasExplicitSort && target && target.mins != null) {
+                const targetMins = target.mins;
+                return [...legResults].sort((a, b) => {
+                    const aMinutes = cardTimeToMinutes(target.field === 'arrive' ? a.arrive : a.depart);
+                    const bMinutes = cardTimeToMinutes(target.field === 'arrive' ? b.arrive : b.depart);
+                    const aDistance = aMinutes == null ? Number.POSITIVE_INFINITY : Math.abs(aMinutes - targetMins);
+                    const bDistance = bMinutes == null ? Number.POSITIVE_INFINITY : Math.abs(bMinutes - targetMins);
+                    if (aDistance !== bDistance)
+                        return aDistance - bDistance;
+                    // Tie-break on price so equally-close flights show cheapest first.
+                    return (a.price ?? Infinity) - (b.price ?? Infinity);
+                });
             }
-            return arr;
+            const comparator = requestedSort ? sortComparators[requestedSort] : undefined;
+            if (comparator) {
+                return [...legResults].sort(comparator);
+            }
+            // Default (incl. `preferred`): keep the Preferred order the list carries.
+            return legResults;
         };
-        const outDeduped = dedupeCheapestByFlight(outFiltered);
-        const inDeduped = dedupeCheapestByFlight(inFiltered);
-        // Pre-compute fare-options groupings for the expand panel: group the raw
-        // itineraries by their outbound (+ inbound) flight-numbers signature so a
-        // card can show all bookable cabins/brands for the same physical flights.
-        // For one-way searches the lookup key on the card side is just the
-        // outbound flight numbers (no trailing "|"); use the same shape here so
-        // the maps actually match. For returns, include the inbound legs.
-        const outFareIndex = this.indexFaresByFlights(rawOutbound, isReturn);
-        const inFareIndex = this.indexFaresByFlights(rawInbound, false);
+        const outDeduped = orderLeg(dedupeCheapestByFlight(outFiltered), outboundTarget, outboundTimeMode);
+        const inDeduped = orderLeg(dedupeCheapestByFlight(inFiltered), inboundTarget, inboundTimeMode);
+        // Group raw itineraries by their flight-number signature so each card can
+        // show all bookable cabins/brands for the same physical flights. One-way
+        // keys use just the outbound numbers; returns include the inbound legs.
+        const outFareIndex = this.indexFaresByFlights(rawOutbound, isReturn, false);
+        const inFareIndex = this.indexFaresByFlights(rawInbound, false, true);
+        // Display only the top N for the chosen ordering. Follow-up questions
+        // ("which is cheapest?", "any BA?") are answered by the AI over the
+        // condensed results, so the chat UI doesn't carry the full set or re-sort.
         const outboundCards = outDeduped
             .slice(0, MAX_FLIGHT_CARDS)
-            .map((r) => this.toFlightCard(r, parameters, 'outbound', outFareIndex));
+            .map((result) => this.toFlightCard(result, parameters, 'outbound', outFareIndex));
         const inboundCards = inDeduped
             .slice(0, MAX_FLIGHT_CARDS)
-            .map((r) => this.toFlightCard(r, parameters, 'inbound', inFareIndex));
-        return { outbound: outboundCards, inbound: inboundCards, isReturn, parameters, sort };
+            .map((result) => this.toFlightCard(result, parameters, 'inbound', inFareIndex));
+        return {
+            outbound: outboundCards,
+            inbound: inboundCards,
+            isReturn,
+            parameters,
+            sort
+        };
     }
     /**
      * Builds a map keyed by an itinerary's flight-number signature to all
@@ -19064,7 +19477,7 @@ class ChatbotFlightSearchService {
      * For combined-return journeys the key includes both outbound + inbound
      * flight numbers; for dual-single legs it's just that leg's numbers.
      */
-    indexFaresByFlights(raw, includeInbound) {
+    indexFaresByFlights(raw, includeInbound, isReturnLeg = false) {
         const map = new Map();
         if (!raw?.length)
             return map;
@@ -19072,10 +19485,17 @@ class ChatbotFlightSearchService {
             const key = this.flightSignature(it, includeInbound);
             if (!key)
                 return;
-            const fare = this.toFareTicket(it, idx);
+            const fare = this.toFareTicket(it, idx, isReturnLeg);
             if (!fare)
                 return;
             const arr = map.get(key) ?? [];
+            // Mirror the full-results grouping (FlightTicketsComponent): suppliers
+            // often return the identical fare for the same physical flight more than
+            // once. The results page drops a fare when one with the same price is
+            // already in the group; do the same so the chat fare panel doesn't render
+            // duplicate ticket rows.
+            if (arr.some((existing) => existing.price === fare.price))
+                return;
             arr.push(fare);
             map.set(key, arr);
         });
@@ -19098,7 +19518,7 @@ class ChatbotFlightSearchService {
             .join('/');
         return `${out}|${inn}`;
     }
-    toFareTicket(it, idx) {
+    toFareTicket(it, idx, isReturnLeg = false) {
         const price = it?.total?.price;
         if (!(price > 0))
             return null;
@@ -19120,7 +19540,8 @@ class ChatbotFlightSearchService {
             brand: brand || undefined,
             price,
             currency: it?.total?.currency || 'GBP',
-            journeyIndex: idx
+            journeyIndex: idx,
+            isReturnLeg: isReturnLeg || undefined
         };
     }
     /**
@@ -19147,7 +19568,10 @@ class ChatbotFlightSearchService {
         if (!journeys.length || !legs.length) {
             return baseResults;
         }
-        // Dedupe by full-itinerary flight signature and sort cheapest first.
+        // Dedupe by full-itinerary flight signature, keeping the cheapest fare per
+        // physical itinerary. The Map preserves first-occurrence order, so the list
+        // stays in the incoming "Preferred" order (the normal page default) — we
+        // don't re-rank by price here, matching the single/return default.
         const bySig = new Map();
         for (const j of journeys) {
             const sig = (j?.outboundFlights ?? [])
@@ -19158,7 +19582,8 @@ class ChatbotFlightSearchService {
                 bySig.set(sig, j);
             }
         }
-        const sorted = [...bySig.values()].sort((a, b) => (a?.total?.price ?? Infinity) - (b?.total?.price ?? Infinity));
+        const sorted = [...bySig.values()];
+        const fareIndex = this.indexFaresByFlights(journeys, false, false);
         const cards = [];
         for (let i = 0; i < Math.min(MAX_FLIGHT_CARDS, sorted.length); i++) {
             const journey = sorted[i];
@@ -19168,7 +19593,15 @@ class ChatbotFlightSearchService {
             const airline = journey?.outboundFlights?.[0]?.marketingCarrierName ||
                 journey?.outboundFlights?.[0]?.airline ||
                 '';
-            const cabin = journey?.fareConditions?.outboundFareConditions?.cabinClass || '';
+            const cabin = journey?.outboundFlights?.[0]?.cabinClass ||
+                journey?.fareConditions?.outboundFareConditions?.cabinClass ||
+                '';
+            let fares;
+            const fareKey = this.flightSignature(journey, false);
+            const tickets = fareKey ? fareIndex.get(fareKey) : undefined;
+            if (tickets && tickets.length) {
+                fares = { tickets, currency: tickets[0].currency };
+            }
             cards.push({
                 index: i,
                 airline,
@@ -19178,7 +19611,8 @@ class ChatbotFlightSearchService {
                 fromPrice: journey?.total?.price ?? 0,
                 currency: journey?.total?.currency || 'GBP',
                 cabin: this.formatCabinLabel(cabin),
-                policyStatus: journey?.preferenceLevel === 'IN_POLICY' ? 'IN_POLICY' : undefined
+                policyStatus: journey?.preferenceLevel === 'IN_POLICY' ? 'IN_POLICY' : undefined,
+                fares
             });
         }
         return { ...baseResults, outbound: cards };
@@ -19193,7 +19627,7 @@ class ChatbotFlightSearchService {
         const buckets = legs.map(() => []);
         let currentLeg = 0;
         for (const f of flights) {
-            const fDate = (f?.departureDateTime || '').slice(0, 10);
+            const fDate = (f?.dateTimeDeparting || '').slice(0, 10);
             // Advance currentLeg while the leg's date is strictly before this
             // flight's date — preserves ordering even when a leg connects overnight.
             while (currentLeg + 1 < legs.length && legs[currentLeg + 1].date <= fDate) {
@@ -19212,24 +19646,46 @@ class ChatbotFlightSearchService {
             .filter(Boolean)
             .join('/');
         let duration = '';
-        if (first.departureDateTime && last.arrivalDateTime) {
-            const mins = Math.round((new Date(last.arrivalDateTime).getTime() - new Date(first.departureDateTime).getTime()) /
+        if (first.dateTimeDeparting && last.dateTimeArriving) {
+            const mins = Math.round((new Date(last.dateTimeArriving).getTime() - new Date(first.dateTimeDeparting).getTime()) /
                 60000);
             duration = this.formatDuration(mins);
         }
         return {
-            fromCode: first.departureAirport || leg.departureCode || leg.departure,
+            fromCode: first.originAirport || leg.departureCode || leg.departure,
             fromName: leg.departure,
-            toCode: last.arrivalAirport || leg.arrivalCode || leg.arrival,
+            toCode: last.destinationAirport || leg.arrivalCode || leg.arrival,
             toName: leg.arrival,
             departDate: this.formatDate(leg.date),
-            departTime: this.formatHHmm(first.departureDateTime),
-            arriveTime: this.formatHHmm(last.arrivalDateTime),
+            departTime: this.formatHHmm(first.dateTimeDeparting),
+            arriveTime: this.formatHHmm(last.dateTimeArriving),
             duration,
             stops: Math.max(0, flights.length - 1),
+            arrivalDayOffset: this.arrivalDayOffset({
+                departDateTime: first.dateTimeDeparting,
+                arriveDateTime: last.dateTimeArriving
+            }),
             flightNumbers
         };
     }
+    /**
+     * Calendar days the arrival falls after departure (0 = same day, 1 = next
+     * day). Compares date components rather than elapsed time so a 23:30 → 00:40
+     * hop still counts as +1. Returns 0 when datetimes are missing/invalid so a
+     * lack of data never hides an otherwise-valid result. Accepts either a full
+     * `CondensedResult` (outbound) or its `inbound` sub-leg.
+     */
+    arrivalDayOffset(leg) {
+        if (!leg.departDateTime || !leg.arriveDateTime)
+            return 0;
+        const dep = new Date(leg.departDateTime);
+        const arr = new Date(leg.arriveDateTime);
+        if (Number.isNaN(dep.getTime()) || Number.isNaN(arr.getTime()))
+            return 0;
+        const depDay = Date.UTC(dep.getFullYear(), dep.getMonth(), dep.getDate());
+        const arrDay = Date.UTC(arr.getFullYear(), arr.getMonth(), arr.getDate());
+        return Math.round((arrDay - depDay) / 86_400_000);
+    }
     formatHHmm(iso) {
         if (!iso)
             return '';
@@ -19269,6 +19725,7 @@ class ChatbotFlightSearchService {
             arriveTime: r.arrive,
             duration: r.duration,
             stops: r.stops,
+            arrivalDayOffset: this.arrivalDayOffset(r),
             flightNumbers: r.flightNumbers ?? ''
         };
         // For combined-return itineraries (journeys), each result already has
@@ -19284,6 +19741,7 @@ class ChatbotFlightSearchService {
                 arriveTime: r.inbound.arrive,
                 duration: r.inbound.duration,
                 stops: r.inbound.stops,
+                arrivalDayOffset: this.arrivalDayOffset(r.inbound),
                 flightNumbers: r.inbound.flightNumbers ?? ''
             }
             : undefined;
@@ -19459,6 +19917,9 @@ class ChatbotFlightSearchService {
             else if ('cabinClass' in flightParams && FlightCabinClass.Any) {
                 flightParams.cabinClass = FlightCabinClass.Any;
             }
+            if ('returnCabinClass' in flightParams) {
+                flightParams.returnCabinClass = flightParams.cabinClass;
+            }
         }
         if (parameters.adults != null) {
             flightParams.adults = parameters.adults;
@@ -19543,15 +20004,27 @@ class ChatbotFlightSearchService {
                 // keep the previously-stated cabin for the same journey.
                 try {
                     flightParams.cabinClass = FlightCabinClass.Economy;
+                    if ('returnCabinClass' in flightParams) {
+                        flightParams.returnCabinClass = FlightCabinClass.Economy;
+                    }
                 }
                 catch (err) {
                     console.warn('[ChatbotFlight] failed to reset cabinClass', err);
                 }
             }
         }
+        // OBT keeps a single time-of-day per leg; the criteria (set further down)
+        // decides whether it means "depart at" or "arrive by". So an arrival time
+        // ("arriving before 5pm") and a departure time share the same field — we
+        // accept either and remember which the user gave so we can default the
+        // criteria accordingly.
+        const outboundLegTime = parameters.departureTime || parameters.arrivalTime;
+        const outboundArrivalGiven = !parameters.departureTime && !!parameters.arrivalTime;
+        const returnLegTime = parameters.returnTime || parameters.returnArrivalTime;
+        const returnArrivalGiven = !parameters.returnTime && !!parameters.returnArrivalTime;
         flightParams.departDate = departNgbDate;
-        if (parameters.departureTime) {
-            flightParams.departTime = this.normalizeTime(parameters.departureTime);
+        if (outboundLegTime) {
+            flightParams.departTime = this.normalizeTime(outboundLegTime);
         }
         if (parameters.returnDate) {
             const returnDate = moment$1(parameters.returnDate);
@@ -19561,8 +20034,8 @@ class ChatbotFlightSearchService {
                 day: returnDate.date()
             };
             flightParams.chosenSearchType = FlightSearchType.return;
-            if (parameters.returnTime) {
-                flightParams.arriveTime = this.normalizeTime(parameters.returnTime);
+            if (returnLegTime) {
+                flightParams.arriveTime = this.normalizeTime(returnLegTime);
             }
         }
         else {
@@ -19581,6 +20054,27 @@ class ChatbotFlightSearchService {
             else if ('cabinClass' in flightParams && FlightCabinClass.Any) {
                 flightParams.cabinClass = FlightCabinClass.Any;
             }
+            // OBT tracks outbound and return cabin separately. When the user wants a
+            // DIFFERENT cabin on the return (e.g. business out, economy back) the AI
+            // sends `returnCabinClass`; honour it. Otherwise mirror the outbound cabin
+            // — without this a "First class return" search would ask for First out /
+            // Economy back (returnCabinClass would stay at its Economy default).
+            if ('returnCabinClass' in flightParams) {
+                const rcc = String(parameters.returnCabinClass ?? '')
+                    .trim()
+                    .toLowerCase();
+                if (parameters.returnCabinClass && rcc && rcc !== 'any' && rcc !== 'all') {
+                    flightParams.returnCabinClass = this.mapCabinClass(parameters.returnCabinClass);
+                }
+                else if (parameters.returnCabinClass &&
+                    (rcc === 'any' || rcc === 'all') &&
+                    FlightCabinClass.Any) {
+                    flightParams.returnCabinClass = FlightCabinClass.Any;
+                }
+                else {
+                    flightParams.returnCabinClass = flightParams.cabinClass;
+                }
+            }
         }
         // Passenger breakdown — if the AI passed adults/children/infants, prefer
         // those; otherwise fall back to total `passengers` as adults.
@@ -19600,11 +20094,13 @@ class ChatbotFlightSearchService {
         // so that if the user later navigates to the flight search form (whose
         // ngOnInit re-derives maxConnections from this flag) the "Direct only"
         // checkbox stays ticked instead of being silently reset.
-        if (parameters.maxConnections != null) {
-            flightParams.maxConnections = parameters.maxConnections;
-            if ('directDefaultValue' in flightParams) {
-                flightParams.directDefaultValue = parameters.maxConnections === 0;
-            }
+        // Always set maxConnections so a previous "direct only" search doesn't
+        // persist when the user removes that constraint on a same-journey turn
+        // (the AI omits the field). `null` = no connection limit.
+        flightParams.maxConnections =
+            parameters.maxConnections != null ? parameters.maxConnections : null;
+        if ('directDefaultValue' in flightParams) {
+            flightParams.directDefaultValue = parameters.maxConnections === 0;
         }
         if (parameters.includeNearbyAirports != null && 'includeNearbyAirports' in flightParams) {
             flightParams.includeNearbyAirports = parameters.includeNearbyAirports;
@@ -19622,15 +20118,35 @@ class ChatbotFlightSearchService {
                 return TimeWindow.Anytime;
             return null;
         };
-        if (parameters.outboundTimeCriteria) {
-            const mapped = toTimeWindow(parameters.outboundTimeCriteria);
-            if (mapped)
-                flightParams.outTimeCriteria = mapped;
+        // OBT uses a single time-of-day per leg (departTime / arriveTime, set above
+        // from departureTime / returnTime) and the criteria reinterprets it:
+        //   Depart  -> a ±flexibility window centred on the time
+        //   Arrive  -> a fixed 2h window ending at the time (makeArrivalTimeWindow)
+        //   Anytime -> no window at all (every flight for the date)
+        // So the rule is simply: if the user gave a time for a leg, honour their
+        // criteria (defaulting to "Depart" / depart-after); if they gave no time,
+        // search Anytime. The latter is essential — without it the engine windows
+        // around the leg's *default* time-of-day and returns the wrong flights
+        // (e.g. a 0730-0930 arrival window when the user only said "arriving before
+        // 5pm" but no parseable time reached us, or a stray departure window that
+        // wipes out the return leg of a long-haul return such as SYD→LHR).
+        if (outboundLegTime) {
+            flightParams.outTimeCriteria =
+                (parameters.outboundTimeCriteria && toTimeWindow(parameters.outboundTimeCriteria)) ||
+                    (outboundArrivalGiven ? TimeWindow.Arrive : TimeWindow.Depart);
         }
-        if (parameters.returnTimeCriteria) {
-            const mapped = toTimeWindow(parameters.returnTimeCriteria);
-            if (mapped)
-                flightParams.inTimeCriteria = mapped;
+        else {
+            flightParams.outTimeCriteria = TimeWindow.Anytime;
+        }
+        if (parameters.returnDate) {
+            if (returnLegTime) {
+                flightParams.inTimeCriteria =
+                    (parameters.returnTimeCriteria && toTimeWindow(parameters.returnTimeCriteria)) ||
+                        (returnArrivalGiven ? TimeWindow.Arrive : TimeWindow.Depart);
+            }
+            else {
+                flightParams.inTimeCriteria = TimeWindow.Anytime;
+            }
         }
         if (parameters.timeFlexibility != null) {
             flightParams.outTimeFlexibility = parameters.timeFlexibility;
@@ -19647,23 +20163,18 @@ class ChatbotFlightSearchService {
                     flightParams.showVia = true;
             }
         }
-        // Preferred airline → operator1 (which is preferredCarriers[0]).
-        // The form's airline field is a typeahead backed by the searchAirlines
-        // GraphQL query, so we MUST write a real {code, name} object resolved
-        // from that source (an ad-hoc object with the wrong code wouldn't match
-        // anything server-side). Use either the IATA code or the name as the
-        // search term, prefer an exact IATA match, then an exact name match,
-        // then a substring match.
+        // Preferred airline(s) → preferredCarriers[0..3]. The form exposes four
+        // carrier slots; the chatbot may pass a single airline (airline/airlineCode)
+        // or up to four in `airlines`. The form's airline field is a typeahead
+        // backed by the searchAirlines GraphQL query, so we MUST write real
+        // {code, name} objects resolved from that source (an ad-hoc object with the
+        // wrong code wouldn't match anything server-side).
         //
-        // Skip entirely when the AI passes a "no preference" sentinel — null,
-        // empty string, or the literal word "any"/"all". preferredCarriers was
-        // already reset to all-nulls at the top of this method, so no carrier
-        // filter will be applied to the search in that case.
-        const rawAirlineTerm = (parameters.airlineCode || parameters.airline || '').toString().trim();
-        const isAnyAirline = !rawAirlineTerm ||
-            rawAirlineTerm.toLowerCase() === 'any' ||
-            rawAirlineTerm.toLowerCase() === 'all';
-        if (!isAnyAirline) {
+        // Skip entirely when there's no real preference (null, empty, or "any"/
+        // "all"). preferredCarriers was already reset to all-nulls at the top of
+        // this method, so no carrier filter will be applied to the search.
+        const carrierTerms = this.collectCarrierTerms(parameters);
+        if (carrierTerms.length) {
             if (!Array.isArray(flightParams.preferredCarriers)) {
                 try {
                     flightParams.preferredCarriers = [];
@@ -19673,39 +20184,12 @@ class ChatbotFlightSearchService {
                 }
             }
             if (Array.isArray(flightParams.preferredCarriers)) {
-                const term = (parameters.airlineCode || parameters.airline || '').trim();
-                if (term.length >= 2) {
-                    try {
-                        const matches = await firstValueFrom(this.searchService.getAirlinesList(term));
-                        const list = matches || [];
-                        const upper = term.toUpperCase();
-                        const lower = term.toLowerCase();
-                        // Avoid silently selecting a regional/subsidiary carrier when the
-                        // user named the parent airline. E.g. "KLM" → should match
-                        // "KLM Royal Dutch Airlines" not "KLM Cityhopper" (which would
-                        // also match a naive substring/startsWith check first).
-                        const isSubsidiary = (name) => /\b(cityhopper|cityline|cityjet|express|regional|connect|shuttle|airlink|link|commuter)\b/i.test(name);
-                        const startsWith = list.filter((a) => (a.name || '').toLowerCase().startsWith(lower));
-                        const startsWithNonSub = startsWith.filter((a) => !isSubsidiary(a.name || ''));
-                        const containsNonSub = list.filter((a) => !isSubsidiary(a.name || '') && (a.name || '').toLowerCase().includes(lower));
-                        const resolved = list.find((a) => (a.code || '').toUpperCase() === upper) ||
-                            list.find((a) => (a.name || '').toLowerCase() === lower) ||
-                            startsWithNonSub[0] ||
-                            startsWith[0] ||
-                            containsNonSub[0] ||
-                            list.find((a) => (a.name || '').toLowerCase().includes(lower)) ||
-                            list[0];
-                        if (resolved) {
-                            flightParams.preferredCarriers[0] = {
-                                code: resolved.code,
-                                name: resolved.name
-                            };
-                        }
-                    }
-                    catch (err) {
-                        console.warn('[ChatbotFlightSearchService] airline lookup failed', err);
+                const resolvedCarriers = await Promise.all(carrierTerms.map((term) => this.resolveCarrier(term)));
+                resolvedCarriers.forEach((carrier, idx) => {
+                    if (carrier) {
+                        flightParams.preferredCarriers[idx] = { code: carrier.code, name: carrier.name };
                     }
-                }
+                });
             }
         }
         // Apply the airports we already resolved at the top of this method.
@@ -19758,6 +20242,75 @@ class ChatbotFlightSearchService {
         }
         return null;
     }
+    /**
+     * Build the de-duplicated list of carrier search terms from the chat
+     * parameters. Prefers the `airlines` array (up to {@link MAX_PREFERRED_CARRIERS})
+     * when present, else falls back to the singular airline/airlineCode. Drops
+     * "no preference" sentinels ("any"/"all"/empty) and terms shorter than 2 chars.
+     */
+    collectCarrierTerms(parameters) {
+        const candidates = parameters.airlines?.length
+            ? parameters.airlines.map((a) => a?.code || a?.name || '')
+            : [parameters.airlineCode || parameters.airline || ''];
+        const terms = [];
+        const seen = new Set();
+        for (const candidate of candidates) {
+            const term = String(candidate).trim();
+            const key = term.toLowerCase();
+            if (term.length < 2 ||
+                ChatbotFlightSearchService.NO_CARRIER_PREFERENCE.has(key) ||
+                seen.has(key)) {
+                continue;
+            }
+            seen.add(key);
+            terms.push(term);
+            if (terms.length >= ChatbotFlightSearchService.MAX_PREFERRED_CARRIERS) {
+                break;
+            }
+        }
+        return terms;
+    }
+    /**
+     * Resolve a single airline search term to a real {code, name} from the
+     * searchAirlines GraphQL source, trying the highest-confidence match first:
+     * exact IATA code, exact name, then non-subsidiary startsWith/contains — so
+     * "KLM" resolves to "KLM Royal Dutch Airlines" rather than "KLM Cityhopper".
+     */
+    async resolveCarrier(term) {
+        const trimmed = (term || '').trim();
+        if (trimmed.length < 2) {
+            return null;
+        }
+        let list;
+        try {
+            list = (await firstValueFrom(this.searchService.getAirlinesList(trimmed))) || [];
+        }
+        catch (err) {
+            console.warn('[ChatbotFlightSearchService] airline lookup failed', err);
+            return null;
+        }
+        const upper = trimmed.toUpperCase();
+        const lower = trimmed.toLowerCase();
+        const name = (a) => (a.name || '').toLowerCase();
+        const isSubsidiary = (a) => ChatbotFlightSearchService.CARRIER_SUBSIDIARY.test(a.name || '');
+        const strategies = [
+            (a) => (a.code || '').toUpperCase() === upper,
+            (a) => name(a) === lower,
+            (a) => name(a).startsWith(lower) && !isSubsidiary(a),
+            (a) => name(a).startsWith(lower),
+            (a) => name(a).includes(lower) && !isSubsidiary(a),
+            (a) => name(a).includes(lower)
+        ];
+        let resolved;
+        for (const matches of strategies) {
+            resolved = list.find(matches);
+            if (resolved) {
+                break;
+            }
+        }
+        resolved = resolved || list[0];
+        return resolved ? { code: resolved.code, name: resolved.name } : null;
+    }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.20", ngImport: i0, type: ChatbotFlightSearchService, deps: [{ token: ChatbotService }, { token: EnterpriseSearchService }, { token: ResultAwareService }, { token: UserService }], target: i0.ɵɵFactoryTarget.Injectable });
     static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.20", ngImport: i0, type: ChatbotFlightSearchService, providedIn: 'root' });
 }
@@ -19788,15 +20341,35 @@ class ChatbotHotelSearchService {
     searchService;
     hotelAvalibilityService;
     resultAwareService;
+    userService;
     travelType = 'hotel';
     availabilitySubscription = null;
-    constructor(chatbotService, searchService, hotelAvalibilityService, resultAwareService) {
+    lastParameters = null;
+    markAsLoading() {
+        const hotelSearch = this.searchService.searches[ServiceType.Hotel];
+        hotelSearch?.isLoading?.next(true);
+    }
+    get hasHotelResults() {
+        const hotelSearch = this.searchService.searches[ServiceType.Hotel];
+        return (hotelSearch?.results?.value?.length ?? 0) > 0;
+    }
+    constructor(chatbotService, searchService, hotelAvalibilityService, resultAwareService, userService) {
         this.chatbotService = chatbotService;
         this.searchService = searchService;
         this.hotelAvalibilityService = hotelAvalibilityService;
         this.resultAwareService = resultAwareService;
+        this.userService = userService;
     }
     async handle(parameters, autoSearch) {
+        this.lastParameters = parameters;
+        if ((parameters.resultOffset ?? 0) > 0) {
+            await this.runSearchFromOffset(parameters);
+            return;
+        }
+        const hotelSearch = this.searchService.searches[ServiceType.Hotel];
+        if (hotelSearch?.filters?.hotelName) {
+            hotelSearch.filters.hotelName = '';
+        }
         this.searchService.resetSearchChosenObjects();
         this.searchService.resetSearchPriorities();
         this.searchService.search_objects[ServiceType.Hotel].chosen = true;
@@ -19815,8 +20388,18 @@ class ChatbotHotelSearchService {
         await this.runSearch(parameters);
     }
     // ── Search + availability ─────────────────────────────────────────────────
+    ensureSelfTraveller() {
+        if (this.searchService.travellerInformation.value.length > 0) {
+            return;
+        }
+        const traveller = this.userService.bobo ?? this.userService.createSelfTraveller();
+        if (traveller) {
+            this.searchService.addTraveller(traveller);
+        }
+    }
     async runSearch(parameters) {
         const hotelSearch = this.searchService.searches[ServiceType.Hotel];
+        this.ensureSelfTraveller();
         this.resultAwareService.clearResults();
         let hasResults = false;
         this.chatbotService.setSearching(true, 'hotel');
@@ -19853,9 +20436,15 @@ class ChatbotHotelSearchService {
                 }
             });
             this.sortHotels(candidates, parameters.sortType);
-            const hotelsWithPrices = candidates
-                .filter((hotel) => (hotel.availableRates?.rooms ?? []).some((r) => r?.total > 0))
-                .slice(0, MAX_HOTEL_CARDS);
+            let hotelsWithPrices = candidates.filter((hotel) => (hotel.availableRates?.rooms ?? []).some((r) => r?.total > 0));
+            if (parameters.hotelName) {
+                const nameTerm = parameters.hotelName.toLowerCase();
+                const nameFiltered = hotelsWithPrices.filter((hotel) => (hotel.name || '').toLowerCase().includes(nameTerm));
+                if (nameFiltered.length > 0) {
+                    hotelsWithPrices = nameFiltered;
+                }
+            }
+            hotelsWithPrices = hotelsWithPrices.slice(0, MAX_HOTEL_CARDS);
             this.resultAwareService.captureHotelResults(hotelsWithPrices);
             const condensed = this.resultAwareService.getCondensedResults();
             if (!condensed.length) {
@@ -19879,6 +20468,73 @@ class ChatbotHotelSearchService {
         });
     }
     // ── Card building ─────────────────────────────────────────────────────────
+    async runSearchFromOffset(parameters) {
+        const hotelSearch = this.searchService.searches[ServiceType.Hotel];
+        const offset = parameters.resultOffset ?? 0;
+        const allResults = hotelSearch.results?.value ?? [];
+        if (!allResults.length) {
+            this.injectNoResultsMessage();
+            return;
+        }
+        const candidates = allResults.slice(offset, offset + AVAILABILITY_CANDIDATE_COUNT);
+        if (!candidates.length) {
+            this.chatbotService.injectMessage({
+                id: `hotel-no-more-${Date.now()}`,
+                role: 'assistant',
+                text: 'There are no more hotel results to show.',
+                timestamp: new Date()
+            });
+            return;
+        }
+        this.chatbotService.setSearching(true, 'hotel');
+        const availabilitySubjects = candidates.map((hotel) => this.hotelAvalibilityService.getAvailabilityForId(hotelSearch.makeHotelAvalilityObject(hotel), hotel));
+        const allRoomsReady$ = combineLatest(availabilitySubjects).pipe(filter((results) => results.every((r) => r?.rooms !== undefined)), take(1));
+        const fetchingDone$ = this.hotelAvalibilityService.fetching.pipe(skipWhile((fetching) => !fetching), filter((fetching) => !fetching), take(1));
+        this.availabilitySubscription?.unsubscribe();
+        this.availabilitySubscription = race(allRoomsReady$, fetchingDone$, timer(HOTEL_AVAILABILITY_WAIT_MS))
+            .pipe(take(1), catchError$1((err) => {
+            console.warn('[ChatbotHotelSearchService] offset availability polling error', err);
+            this.chatbotService.setSearching(false);
+            return EMPTY;
+        }))
+            .subscribe(() => {
+            candidates.forEach((hotel, i) => {
+                const availability = availabilitySubjects[i].value;
+                if (availability?.rooms !== undefined) {
+                    hotel.availableRates = { ...availability, rooms: availability.rooms ?? [] };
+                }
+            });
+            this.sortHotels(candidates, parameters.sortType);
+            let hotelsWithPrices = candidates.filter((hotel) => (hotel.availableRates?.rooms ?? []).some((r) => r?.total > 0));
+            hotelsWithPrices = hotelsWithPrices.slice(0, MAX_HOTEL_CARDS);
+            if (!hotelsWithPrices.length) {
+                this.injectNoResultsMessage();
+                this.chatbotService.setSearching(false);
+                return;
+            }
+            this.resultAwareService.captureHotelResults(hotelsWithPrices);
+            const condensed = this.resultAwareService.getCondensedResults();
+            const cards = this.buildHotelCards(condensed, hotelsWithPrices);
+            const checkin = hotelSearch?.checkin_date
+                ? moment$1(hotelSearch.checkin_date).format('D MMM')
+                : '';
+            const checkout = hotelSearch?.checkout_date
+                ? moment$1(hotelSearch.checkout_date).format('D MMM')
+                : '';
+            const dateRange = checkin && checkout ? `${checkin} - ${checkout}` : '';
+            const searchHeader = [parameters.arrival, dateRange].filter(Boolean).join(' · ');
+            const hotelResults = { cards, searchHeader, parameters };
+            this.chatbotService.injectMessage({
+                id: `hotel-more-${Date.now()}`,
+                role: 'assistant',
+                text: '',
+                timestamp: new Date(),
+                hotelResults,
+                state: 'RESULTS_READY'
+            });
+            this.chatbotService.setSearching(false);
+        });
+    }
     buildHotelCards(condensed, rawHotels) {
         return condensed.slice(0, MAX_HOTEL_CARDS).map((r, i) => {
             const raw = rawHotels[i];
@@ -19886,14 +20542,20 @@ class ChatbotHotelSearchService {
                 .filter((room) => room && !room.unavailable && room.total > 0)
                 .map((room) => ({
                 roomId: room.roomId,
-                description: room.roomDescription || room.roomType || 'Standard Room',
+                description: room.roomType || room.roomDescription || 'Standard Room',
                 total: room.total,
                 prpn: room.prpn,
                 currencyCode: room.currencyCode ?? 'GBP',
                 unavailable: !!room.unavailable,
                 policyStatus: room.requiresReasonKeys?.length
                     ? 'ALLOW_WITH_REASON'
-                    : 'IN_POLICY'
+                    : 'IN_POLICY',
+                rateSource: room.rateSource ?? null,
+                rateCode: room.rateCode ?? null,
+                rateDescription: room.rateDescription ?? null,
+                roomDescription: room.roomDescription ?? null,
+                policies: room.policies ?? null,
+                additional: room.additional ?? null
             }));
             return {
                 index: r.index,
@@ -19909,6 +20571,7 @@ class ChatbotHotelSearchService {
                 policyMessages: r.policyMessages,
                 co2: r.co2,
                 currencyCode: rooms[0]?.currencyCode ?? 'GBP',
+                source: raw?.availableRates?.source ?? null,
                 rooms
             };
         });
@@ -19940,12 +20603,21 @@ class ChatbotHotelSearchService {
                 break;
             case 'cheapest':
             default:
+                hotels.sort((a, b) => this.cheapestRoomTotal(a) - this.cheapestRoomTotal(b));
                 break;
         }
     }
+    cheapestRoomTotal(hotel) {
+        const totals = (hotel.availableRates?.rooms ?? [])
+            .map((room) => room?.total)
+            .filter((total) => typeof total === 'number' && total > 0);
+        return totals.length ? Math.min(...totals) : Number.POSITIVE_INFINITY;
+    }
     // ── Param population ──────────────────────────────────────────────────────
     async populateHotelParams(parameters, departDate, departNgbDate) {
         const hotelParams = this.searchService.searches[ServiceType.Hotel];
+        hotelParams.hotel_name = '';
+        hotelParams.hotel_chain = null;
         hotelParams.checkin_date = departDate;
         hotelParams.checkin_date_ngb = departNgbDate;
         if (parameters.returnDate) {
@@ -20009,11 +20681,10 @@ class ChatbotHotelSearchService {
             const resolvedLocationType = locationTypeMap[locationType] ?? LocationTypes.Address;
             hotelParams.location_type_select = resolvedLocationType;
             if (resolvedLocationType === LocationTypes.Office) {
-                const offices = await firstValueFrom(this.searchService.getOfficeLocationsNoUserAddresses(''));
+                const searchTerm = parameters.arrival?.toLowerCase() ?? '';
+                const offices = await firstValueFrom(this.searchService.getOfficeLocationsNoUserAddresses(searchTerm));
                 if (offices?.length > 0) {
-                    const searchTerm = parameters.arrival?.toLowerCase() ?? '';
-                    const match = offices.find((o) => o.name.toLowerCase().includes(searchTerm)) ?? offices[0];
-                    hotelParams.office = match;
+                    hotelParams.office = offices[0];
                 }
             }
             else if (resolvedLocationType === LocationTypes.Address) {
@@ -20047,60 +20718,67 @@ class ChatbotHotelSearchService {
             }
         }
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.20", ngImport: i0, type: ChatbotHotelSearchService, deps: [{ token: ChatbotService }, { token: EnterpriseSearchService }, { token: HotelAvalibilityService }, { token: ResultAwareService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.20", ngImport: i0, type: ChatbotHotelSearchService, deps: [{ token: ChatbotService }, { token: EnterpriseSearchService }, { token: HotelAvalibilityService }, { token: ResultAwareService }, { token: UserService }], target: i0.ɵɵFactoryTarget.Injectable });
     static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.20", ngImport: i0, type: ChatbotHotelSearchService, providedIn: 'root' });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.20", ngImport: i0, type: ChatbotHotelSearchService, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
-        }], ctorParameters: () => [{ type: ChatbotService }, { type: EnterpriseSearchService }, { type: HotelAvalibilityService }, { type: ResultAwareService }] });
+        }], ctorParameters: () => [{ type: ChatbotService }, { type: EnterpriseSearchService }, { type: HotelAvalibilityService }, { type: ResultAwareService }, { type: UserService }] });
 
-/** Safety timeout (ms) waiting for eurostar results. */
-const EUROSTAR_RESULTS_WAIT_MS = 60_000;
-/** Maximum number of outbound/inbound cards to surface in the chat widget. */
-const MAX_EUROSTAR_CARDS = 3;
+/** Maximum number of car hire cards to show in the chat widget. */
+const MAX_CAR_HIRE_CARDS = 3;
+/** Default driver age used for delivery/collection searches when the user
+ *  hasn't supplied one (matches the form's minimum selectable age). */
+const DEFAULT_DRIVER_AGE = 25;
+/** Radius (miles) to retry a depot lookup at before giving up, when nothing
+ *  is found within the requested distance. */
+const WIDE_SEARCH_RADIUS_MILES = 20;
 /**
- * Handles chatbot-driven Eurostar searches. Registered with
+ * Handles chatbot-driven car hire searches. Registered with
  * `ChatbotSearchDispatcherService`; not used directly.
  *
- * Populates the Eurostar search state from the chatbot's parameters and, when
- * `autoSearch` is true, runs the search headlessly so it works from any page.
- * Once results arrive, builds `ChatEurostarResults` and patches them onto the
- * last assistant message via {@link ChatbotService.patchAssistantMessage}.
+ * Populates the car hire search state from the chatbot's parameters, runs the
+ * search headlessly, then injects a `ChatCarHireResults` message so the chat
+ * widget can render car hire cards.
  */
-class ChatbotEurostarSearchService {
+class ChatbotCarHireSearchService {
     chatbotService;
     searchService;
+    resultAwareService;
     userService;
-    travelType = 'eurostar';
-    resultsSubscription = null;
-    constructor(chatbotService, searchService, userService) {
+    travelType = 'car-hire';
+    pendingDepotChoice = null;
+    constructor(chatbotService, searchService, resultAwareService, userService) {
         this.chatbotService = chatbotService;
         this.searchService = searchService;
+        this.resultAwareService = resultAwareService;
         this.userService = userService;
     }
+    ensureSelfTraveller() {
+        if (this.searchService.travellerInformation.value.length > 0) {
+            return;
+        }
+        const traveller = this.userService.bobo ?? this.userService.createSelfTraveller();
+        if (traveller) {
+            this.searchService.addTraveller(traveller);
+        }
+    }
     async handle(parameters, autoSearch) {
+        // Clear any pending depot choice from a previous interaction.
+        this.pendingDepotChoice = null;
+        this.chatbotService.depotSelectionHandler = null;
         this.searchService.resetSearchChosenObjects();
         this.searchService.resetSearchPriorities();
-        this.searchService.search_objects[ServiceType.Eurostar].chosen = true;
-        this.searchService.search_objects[ServiceType.Eurostar].originalChosen = true;
+        this.searchService.search_objects[ServiceType.Car].chosen = true;
+        this.searchService.search_objects[ServiceType.Car].originalChosen = true;
         this.searchService.determineHighestSearchPriority();
-        // Auto-add the signed-in user as the traveller when none is selected so
-        // the search isn't blocked by the "add a traveller" validation rule.
-        // Matches the rail handler pattern.
-        if (this.searchService.travellerInformation.value.length === 0) {
-            const selfTraveller = this.userService.createSelfTraveller();
-            if (selfTraveller) {
-                this.searchService.addTraveller(selfTraveller);
-            }
+        const result = await this.populateCarHireParams(parameters);
+        if (result.status !== 'ok') {
+            this.injectLocationHelpMessage(result, parameters, autoSearch);
+            return;
         }
-        const departDate = moment$1(parameters.departureDate);
-        const departNgbDate = {
-            year: departDate.year(),
-            month: departDate.month() + 1,
-            day: departDate.date()
-        };
-        await this.populateEurostarParams(parameters, departNgbDate);
+        this.chatbotService.carHireParamsReady$.next();
         if (!autoSearch) {
             return;
         }
@@ -20108,7 +20786,970 @@ class ChatbotEurostarSearchService {
     }
     // ── Search ────────────────────────────────────────────────────────────────
     async runSearch(parameters) {
-        const eurostarSearch = this.searchService.searches[ServiceType.Eurostar];
+        const carHireSearch = this.searchService.searches[ServiceType.Car];
+        this.ensureSelfTraveller();
+        this.resultAwareService.clearResults();
+        this.chatbotService.setSearching(true);
+        const hasResults = await carHireSearch.startSearch();
+        if (!hasResults) {
+            this.injectNoResultsMessage();
+            this.chatbotService.setSearching(false);
+            return;
+        }
+        const results$ = carHireSearch.results;
+        results$
+            .pipe(filter((results) => results?.length > 0), take(1), catchError$1((err) => {
+            console.warn('[ChatbotCarHireSearchService] results polling error', err);
+            this.chatbotService.setSearching(false);
+            return EMPTY;
+        }))
+            .subscribe((results) => {
+            const topResults = results.slice(0, MAX_CAR_HIRE_CARDS);
+            const cards = this.buildCarHireCards(topResults, parameters);
+            this.resultAwareService.captureCarHireResults(topResults);
+            const pickupName = parameters.departure || '';
+            const pickupDate = parameters.departureDate
+                ? moment$1(parameters.departureDate).format('ddd D MMM')
+                : '';
+            const dropoffDate = parameters.returnDate
+                ? moment$1(parameters.returnDate).format('ddd D MMM')
+                : '';
+            const dateRange = pickupDate && dropoffDate ? `${pickupDate} – ${dropoffDate}` : pickupDate;
+            const searchHeader = [pickupName, dateRange].filter(Boolean).join(' · ');
+            const carHireResults = { cards, searchHeader, parameters };
+            this.chatbotService.patchAssistantMessage({ carHireResults, state: 'RESULTS_READY' });
+            this.chatbotService.setSearching(false);
+        });
+    }
+    // ── Card building ─────────────────────────────────────────────────────────
+    buildCarHireCards(results, parameters) {
+        return results.map((r, i) => {
+            const display = r.displayRecord;
+            const identifiers = r.identifiers;
+            const vehicleDescription = display?.vehicle?.description || identifiers?.makeModel || '';
+            const vendorName = display?.vendor?.name || identifiers?.vendor || '';
+            const vendorCode = identifiers?.vendor || undefined;
+            const vendorLogoUrl = vendorCode
+                ? `https://images.sabscorp.com/images/carhire/${vendorCode}.gif`
+                : undefined;
+            const price = display?.price ?? 0;
+            const pickupDt = identifiers?.pickUpDateTime || parameters.departureDate || '';
+            const dropoffDt = identifiers?.dropOffDateTime || parameters.returnDate || '';
+            const durationDays = this.calculateDays(pickupDt, dropoffDt);
+            const pricePerDay = durationDays > 0 ? price / durationDays : undefined;
+            const pickupLocation = identifiers?.pickUpLocationName ||
+                display?.pickupLocation?.name ||
+                parameters.departure ||
+                '';
+            const dropoffLocation = identifiers?.dropOffLocationName ||
+                display?.returnLocation?.name ||
+                parameters.arrival ||
+                pickupLocation;
+            let policyStatus;
+            if (r.unavailable) {
+                policyStatus = 'UNAVAILABLE';
+            }
+            else if (r.requiresReasonKeys?.length || r.requiresApprovalKeys?.length) {
+                policyStatus = 'ALLOW_WITH_REASON';
+            }
+            else {
+                policyStatus = 'IN_POLICY';
+            }
+            const currencyCode = display?.charges?.[0]?.currencyCode || 'GBP';
+            return {
+                index: i + 1,
+                vehicleDescription,
+                vendorName,
+                vendorCode,
+                vendorLogoUrl,
+                carClass: display?.vehicle?.class || undefined,
+                carType: display?.vehicle?.type || undefined,
+                transmission: display?.vehicle?.transmission || undefined,
+                airCon: display?.vehicle?.aircon ?? undefined,
+                doorsCount: identifiers?.doorCount || undefined,
+                price,
+                pricePerDay,
+                currencyCode,
+                pickupLocation,
+                dropoffLocation,
+                pickupDateTime: pickupDt,
+                dropoffDateTime: dropoffDt,
+                policyStatus,
+                policyMessages: r.requiresReasonMessages ?? undefined,
+                co2: r.co2PerItem || undefined
+            };
+        });
+    }
+    calculateDays(pickupDt, dropoffDt) {
+        if (!pickupDt || !dropoffDt) {
+            return 0;
+        }
+        const pickup = moment$1(pickupDt);
+        const dropoff = moment$1(dropoffDt);
+        return Math.max(1, dropoff.diff(pickup, 'days'));
+    }
+    injectNoResultsMessage() {
+        this.chatbotService.injectMessage({
+            id: `car-hire-no-results-${Date.now()}`,
+            role: 'assistant',
+            text: 'No car hire results found for your search. Try adjusting your dates or location.',
+            timestamp: new Date(),
+            state: 'SELECTING_RESULT'
+        });
+    }
+    injectLocationHelpMessage(result, parameters, autoSearch) {
+        let text;
+        let depotChoices;
+        if (result.status === 'location-not-found') {
+            text = `I couldn't find a pickup location matching "${result.term}". Could you give a nearby town, city, airport, or postcode?`;
+        }
+        else if (result.status === 'depot-not-found') {
+            text = `I couldn't find any car hire locations near ${result.location}, even within ${WIDE_SEARCH_RADIUS_MILES} miles. Could you try a nearby town, city, or airport?`;
+        }
+        else {
+            const MAX_SHOWN = 5;
+            const shown = result.depots.slice(0, MAX_SHOWN);
+            depotChoices = shown.map((d, i) => ({
+                index: i,
+                label: `${d.vendor} — ${d.addressLines?.[0] ?? ''}`
+            }));
+            const more = result.depots.length > MAX_SHOWN
+                ? ` Showing ${MAX_SHOWN} of ${result.depots.length} — type "show all" to see the full list.`
+                : '';
+            text = `I found several car hire locations near ${result.location}. Which would you prefer?${more}`;
+            this.pendingDepotChoice = {
+                depots: shown,
+                allDepots: result.depots,
+                pickup: result.pickup,
+                parameters,
+                autoSearch,
+                deliveryCollection: result.deliveryCollection
+            };
+            this.chatbotService.depotSelectionHandler = (reply) => this.handleDepotSelectionReply(reply);
+        }
+        // The agent already responded ("I've set up the search...") before handle()
+        // ran. Remove that message so our more accurate reply replaces it.
+        this.chatbotService.retractLastAssistantMessage();
+        this.chatbotService.injectMessage({
+            id: `car-hire-location-help-${Date.now()}`,
+            role: 'assistant',
+            text,
+            timestamp: new Date(),
+            state: 'COLLECTING_PARAMS',
+            depotChoices
+        });
+    }
+    async handleDepotSelectionReply(reply) {
+        const pending = this.pendingDepotChoice;
+        if (!pending) {
+            return false;
+        }
+        const normalised = reply.trim().toLowerCase();
+        if (normalised === 'show all') {
+            const allChoices = pending.allDepots.map((d, i) => ({
+                index: i,
+                label: `${d.vendor} — ${d.addressLines?.[0] ?? ''}`
+            }));
+            // Update shown list to the full set so subsequent number picks work
+            this.pendingDepotChoice = { ...pending, depots: pending.allDepots };
+            this.chatbotService.injectMessage({
+                id: `car-hire-depot-all-${Date.now()}`,
+                role: 'assistant',
+                text: `Here are all ${pending.allDepots.length} locations:`,
+                timestamp: new Date(),
+                state: 'COLLECTING_PARAMS',
+                depotChoices: allChoices
+            });
+            return true;
+        }
+        // Parse a number from the reply (handles "5", "the 5th", "number 5", etc.)
+        const match = normalised.match(/\b(\d+)\b/);
+        if (!match) {
+            return false;
+        }
+        const index = parseInt(match[1], 10) - 1;
+        const activeList = pending.depots;
+        if (index < 0 || index >= activeList.length) {
+            this.chatbotService.injectMessage({
+                id: `car-hire-depot-invalid-${Date.now()}`,
+                role: 'assistant',
+                text: `Please choose a number between 1 and ${activeList.length}.`,
+                timestamp: new Date(),
+                state: 'COLLECTING_PARAMS'
+            });
+            return true;
+        }
+        const chosen = activeList[index];
+        // Clear pending state and handler before continuing
+        this.pendingDepotChoice = null;
+        this.chatbotService.depotSelectionHandler = null;
+        const carHireSearch = this.searchService.searches[ServiceType.Car];
+        const isPostcode = !!pending.parameters.pickupPostcode;
+        if (isPostcode) {
+            carHireSearch.postcodePickupRaw = pending.pickup;
+            carHireSearch.postcodePickup = chosen;
+            carHireSearch.locationType = LocationTypes.Postcode;
+            // Mirror pickup to dropoff — postcode searches always return to same point
+            // unless a distinct dropoff postcode was provided (rare; not in depot-choice flow).
+            carHireSearch.postcodeDropoffRaw = pending.pickup;
+            carHireSearch.postcodeDropoff = chosen;
+        }
+        else {
+            carHireSearch.cityPickup = this.toCityLocation(pending.pickup);
+            carHireSearch.cityPickupDepot = chosen;
+            carHireSearch.locationType = LocationTypes.City;
+            await this.applyCityDropoff(carHireSearch, pending.parameters, pending.deliveryCollection);
+            // If there's no distinct dropoff location, force it to match the chosen
+            // pickup depot exactly.
+            const hasDistinctDropoff = !!pending.parameters.arrival &&
+                pending.parameters.arrival !== pending.parameters.departure;
+            if (!hasDistinctDropoff) {
+                carHireSearch.cityDropoff = carHireSearch.cityPickup;
+                carHireSearch.cityDropoffDepot = carHireSearch.cityPickupDepot;
+            }
+        }
+        this.chatbotService.carHireParamsReady$.next();
+        if (pending.autoSearch) {
+            // Inject a confirmation before running the search so results appear
+            // below this message rather than above the user's selection reply.
+            const depotLabel = chosen.addressLines?.[0]
+                ? `${chosen.addressLines[0]}, ${chosen.cityName}`
+                : chosen.cityName;
+            this.chatbotService.injectMessage({
+                id: `car-hire-depot-confirm-${Date.now()}`,
+                role: 'assistant',
+                text: `Searching for cars at ${depotLabel}…`,
+                timestamp: new Date(),
+                state: 'COLLECTING_PARAMS'
+            });
+            await this.runSearch(pending.parameters);
+        }
+        return true;
+    }
+    // ── Param population ──────────────────────────────────────────────────────
+    async populateCarHireParams(parameters) {
+        const carHireSearch = this.searchService.searches[ServiceType.Car];
+        // Pickup datetime
+        const pickupDate = moment$1(parameters.departureDate);
+        carHireSearch.pickup_datetime = parameters.departureTime
+            ? moment$1(`${parameters.departureDate} ${parameters.departureTime}`, 'YYYY-MM-DD HH:mm')
+            : pickupDate.clone().hour(10).minute(0).second(0);
+        carHireSearch.pickup_time = parameters.departureTime || '10:00';
+        // Dropoff datetime
+        if (parameters.returnDate) {
+            carHireSearch.dropoff_datetime = parameters.returnTime
+                ? moment$1(`${parameters.returnDate} ${parameters.returnTime}`, 'YYYY-MM-DD HH:mm')
+                : moment$1(parameters.returnDate).hour(10).minute(0).second(0);
+            carHireSearch.dropoff_time = parameters.returnTime || '10:00';
+        }
+        carHireSearch.return_to_pickup =
+            parameters.returnToPickup ??
+                (!parameters.arrival || parameters.arrival === parameters.departure);
+        carHireSearch.adults = parameters.passengers || 1;
+        // Delivery/collection is an Enterprise-only service applied on top of a
+        // postcode/city search. It forces the Enterprise depot lookup, hides the
+        // vendor (Any), and requires a driver age.
+        const deliveryCollection = !!parameters.delivery || !!parameters.collection;
+        carHireSearch.delivery = !!parameters.delivery;
+        carHireSearch.collection = !!parameters.collection;
+        carHireSearch.driverAge =
+            parameters.driverAge || (deliveryCollection ? DEFAULT_DRIVER_AGE : 0);
+        // Clear optional vehicle preferences left over from a previous search — the
+        // dispatcher's reset only clears the chosen flags, not these tempParams, so
+        // a prior vendor/class/transmission would otherwise persist into this search.
+        carHireSearch.chosenVendor = '-';
+        carHireSearch.carClass = '';
+        carHireSearch.carType = '';
+        carHireSearch.transmission = '';
+        carHireSearch.airCon = null;
+        if (parameters.carClass) {
+            carHireSearch.carClass = parameters.carClass;
+        }
+        if (parameters.carType) {
+            // AI agents returns the enum key name (e.g. 'Suv') but the enum value may differ (e.g. 'SUV').
+            // Look up by key name first; fall back to treating the value as-is.
+            carHireSearch.carType = (CarHireType[parameters.carType] ?? parameters.carType);
+        }
+        if (parameters.carTransmission) {
+            carHireSearch.transmission = parameters.carTransmission;
+        }
+        if (parameters.airCon !== undefined) {
+            carHireSearch.airCon = parameters.airCon;
+        }
+        // Delivery/collection forces Enterprise (Any vendor), so only honour a
+        // requested vendor for standard searches.
+        if (parameters.carVendor && !deliveryCollection) {
+            const vendorCode = this.resolveVendorCode(carHireSearch, parameters.carVendor);
+            if (vendorCode) {
+                carHireSearch.chosenVendor = vendorCode;
+            }
+        }
+        // Location: postcode pickups run in postcode mode (locationType = Postcode);
+        // otherwise resolve pickup/dropoff through the shared discover-locations
+        // service (consistent with the hotel chatbot). This returns typed candidates
+        // (Airport / City) with coordinates, so it works across all car hire
+        // providers and is not limited to Enterprise or to GB.
+        if (parameters.pickupPostcode) {
+            return this.applyPostcodePickupAndDropoff(carHireSearch, parameters, deliveryCollection);
+        }
+        const pickup = await this.resolveLocation(parameters.departure || parameters.departureCode || '', this.prefersAirport(parameters.departure, parameters.departureCode), parameters.departureCode);
+        if (!pickup) {
+            return {
+                status: 'location-not-found',
+                term: parameters.departure || parameters.departureCode || ''
+            };
+        }
+        if (pickup.type === LocationTypes.Airport) {
+            // Delivery/collection is not available for airport pickups — the form
+            // forces both off in that case, so mirror that here.
+            carHireSearch.delivery = false;
+            carHireSearch.collection = false;
+            carHireSearch.locationType = LocationTypes.Airport;
+            const pickupAirport = await this.enrichAirportDetails(pickup);
+            carHireSearch.pickup_location = pickupAirport;
+            carHireSearch.pickup_country = pickupAirport.countryCode || '';
+            await this.applyAirportDropoff(carHireSearch, parameters);
+            return { status: 'ok' };
+        }
+        const depots = await this.applyCityPickup(carHireSearch, pickup, deliveryCollection);
+        if (!depots.length) {
+            return {
+                status: 'depot-not-found',
+                location: pickup.name || parameters.departure || ''
+            };
+        }
+        if (depots.length > 1) {
+            return {
+                status: 'depot-choice',
+                location: pickup.name || parameters.departure || '',
+                depots,
+                pickup,
+                deliveryCollection
+            };
+        }
+        carHireSearch.locationType = LocationTypes.City;
+        await this.applyCityDropoff(carHireSearch, parameters, deliveryCollection);
+        return { status: 'ok' };
+    }
+    prefersAirport(name, code) {
+        return !!code || /\bairport\b/i.test(name ?? '');
+    }
+    // Maps a vendor name from the chatbot (e.g. "Avis", "Enterprise") to the
+    // vendor code the search form expects (e.g. "ZI", "ET"). The vendor dropdown
+    // is keyed by code, so assigning a raw name never matches an option.
+    resolveVendorCode(carHireSearch, vendorName) {
+        const query = vendorName.trim().toLowerCase();
+        if (!query) {
+            return undefined;
+        }
+        const vendors = (carHireSearch.vendors ?? []);
+        const match = vendors.find((v) => v.name.toLowerCase() === query) ??
+            vendors.find((v) => v.name.toLowerCase().startsWith(query)) ??
+            vendors.find((v) => v.name.toLowerCase().includes(query));
+        return match?.code;
+    }
+    // ── Location resolution ─────────────────────────────────────────────────────
+    async resolveLocation(term, preferAirport, iataHint) {
+        const query = term.replace(/,\s*/g, ' ').trim();
+        if (query.length < 3) {
+            return undefined;
+        }
+        // Airport pickups resolve through the airport-specific search (getAirportsList),
+        // which is ranked and lets us match the exact IATA. This avoids the ambiguity
+        // of the generic discover-locations search, which can return a like-named
+        // airport in the wrong country first (e.g. "Barcelona" → Venezuela, not Spain).
+        if (preferAirport) {
+            const airport = await this.resolveAirportLocation(query, iataHint);
+            if (airport) {
+                return airport;
+            }
+        }
+        try {
+            const locations = await firstValueFrom(this.searchService.getDiscoverLocations(query));
+            if (!locations?.length) {
+                return undefined;
+            }
+            return this.pickBestLocation(locations, preferAirport, query, iataHint);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    async resolveAirportLocation(query, iataHint) {
+        const validIata = !!iataHint && /^[A-Z]{3}$/i.test(iataHint.trim());
+        const term = validIata ? iataHint.trim() : query.replace(/\bairport\b/i, '').trim();
+        if (term.length < 3) {
+            return undefined;
+        }
+        try {
+            const airports = await firstValueFrom(this.searchService.getAirportsList(term, undefined, undefined));
+            if (!airports?.length) {
+                return undefined;
+            }
+            const chosen = validIata
+                ? airports.find((a) => a.gateway?.toUpperCase() === iataHint.trim().toUpperCase()) ??
+                    airports[0]
+                : airports[0];
+            return this.airportToLocation(chosen);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    airportToLocation(a) {
+        return {
+            name: a.destination ?? '',
+            type: LocationTypes.Airport,
+            iata: a.gateway,
+            gateway: a.gateway,
+            country: a.country,
+            countryCode: a.countryCode,
+            latitude: a.latitude,
+            longitude: a.longitude
+        };
+    }
+    pickBestLocation(locations, preferAirport, query, iataHint) {
+        const airports = locations.filter((l) => l.type === LocationTypes.Airport);
+        const cities = locations.filter((l) => l.type === LocationTypes.City);
+        const validIata = iataHint && /^[A-Z]{3}$/i.test(iataHint.trim());
+        if (validIata) {
+            const exact = airports.find((l) => l.iata?.toUpperCase() === iataHint.toUpperCase());
+            if (exact) {
+                return exact;
+            }
+        }
+        const firstWord = query
+            .toLowerCase()
+            .replace(/\b(airport|station|hub|central station)\b/g, '')
+            .trim()
+            .split(' ')[0];
+        const nameMatches = (pool) => firstWord ? pool.find((l) => l.name.toLowerCase().includes(firstWord)) : undefined;
+        if (preferAirport && airports.length) {
+            return nameMatches(airports) ?? airports[0];
+        }
+        // When not preferring an airport, only return city results — never silently
+        // fall back to an airport for a city query (e.g. "Manchester" → MAN).
+        return nameMatches(cities) ?? cities[0];
+    }
+    toAirportDetails(loc) {
+        return {
+            destination: loc.name,
+            gateway: loc.iata || loc.gateway || '',
+            country: loc.country,
+            countryCode: loc.countryCode,
+            postcode: loc.postcode,
+            latitude: loc.latitude,
+            longitude: loc.longitude
+        };
+    }
+    // Enriches a discover-location airport result with full OBTAirportDetails
+    // (including countryCode) by looking up via IATA — mirrors what the normal
+    // car hire UI does via getParamsForCarbyAirport → getAirportByCode.
+    async enrichAirportDetails(loc) {
+        const iata = loc.iata || loc.gateway;
+        if (iata) {
+            try {
+                const airports = await firstValueFrom(this.searchService.getAirportsList(iata, undefined, undefined));
+                if (airports?.length) {
+                    return airports[0];
+                }
+            }
+            catch {
+                // fall through to basic mapping
+            }
+        }
+        return this.toAirportDetails(loc);
+    }
+    async applyAirportDropoff(carHireSearch, parameters) {
+        if (carHireSearch.return_to_pickup) {
+            carHireSearch.dropoff_location = carHireSearch.pickup_location;
+            return;
+        }
+        const dropoff = await this.resolveLocation(parameters.arrival || parameters.arrivalCode || '', this.prefersAirport(parameters.arrival, parameters.arrivalCode), parameters.arrivalCode);
+        const dropoffAirport = dropoff && dropoff.type === LocationTypes.Airport
+            ? await this.enrichAirportDetails(dropoff)
+            : carHireSearch.pickup_location;
+        carHireSearch.dropoff_location = dropoffAirport;
+        carHireSearch.dropoff_country = dropoffAirport.countryCode || carHireSearch.pickup_country || '';
+    }
+    async applyCityPickup(carHireSearch, loc, deliveryCollection) {
+        if (deliveryCollection) {
+            const depots = await this.fetchEnterpriseDepots(loc, 'city');
+            if (!depots.length) {
+                return [];
+            }
+            if (depots.length === 1) {
+                carHireSearch.cityPickup = this.toCityLocation(loc);
+                carHireSearch.cityPickupDepot = depots[0];
+            }
+            return depots;
+        }
+        const depots = await this.resolveCityDepots(loc, carHireSearch);
+        if (!depots.length) {
+            return [];
+        }
+        if (depots.length === 1) {
+            carHireSearch.cityPickup = this.toCityLocation(loc);
+            carHireSearch.cityPickupDepot = depots[0];
+        }
+        return depots;
+    }
+    async applyCityDropoff(carHireSearch, parameters, deliveryCollection) {
+        if (!carHireSearch.return_to_pickup) {
+            const dropoff = await this.resolveLocation(parameters.arrival || parameters.arrivalCode || '', this.prefersAirport(parameters.arrival, parameters.arrivalCode), parameters.arrivalCode);
+            const dropoffDepot = dropoff
+                ? await this.resolveDepot(dropoff, '5', deliveryCollection, 'city')
+                : undefined;
+            if (dropoff && dropoffDepot) {
+                carHireSearch.cityDropoff = this.toCityLocation(dropoff);
+                carHireSearch.cityDropoffDepot = dropoffDepot;
+                return;
+            }
+        }
+        // Return-to-pickup, or unresolved dropoff — mirror the pickup so the search
+        // stays valid (getSearchQuery reads both pickup and dropoff depots).
+        carHireSearch.cityDropoff = carHireSearch.cityPickup;
+        carHireSearch.cityDropoffDepot = carHireSearch.cityPickupDepot;
+    }
+    toCityLocation(loc) {
+        // discover-locations returns name as "Manchester(GB)" — strip the country
+        // code suffix so the city name matches what the depot filter expects.
+        const plainName = loc.city || loc.name.replace(/\s*\([^)]*\)\s*$/, '').trim();
+        return {
+            id: loc.id ?? '',
+            name: plainName,
+            type: LocationTypes.City,
+            country: loc.country,
+            countryCode: loc.countryCode,
+            city: loc.city,
+            latitude: loc.latitude,
+            longitude: loc.longitude
+        };
+    }
+    async resolveCityDepots(loc, carHireSearch, isPostCode = false) {
+        if (loc.latitude == null || loc.longitude == null) {
+            return [];
+        }
+        const cityName = loc.city || loc.name.replace(/\s*\([^)]*\)\s*$/, '').trim();
+        // Mirror updateDepot: enterprise-only users use getEntCarhireLocationsCity,
+        // everyone else uses the lat/lng getCarHireDepots path.
+        if (!carHireSearch.hasNonEnterpriseCarAccess) {
+            if (!cityName || !loc.countryCode) {
+                return [];
+            }
+            try {
+                const raw = await firstValueFrom(carHireSearch.getEntCarhireLocationsCity(loc.countryCode, cityName, carHireSearch.chosenVendor));
+                return (raw ?? []).map((l) => this.toEnterpriseDepot(l));
+            }
+            catch {
+                return [];
+            }
+        }
+        const raw = await this.fetchDepotsWithinRadius(loc, '5');
+        const filtered = carHireSearch.filterCarHireDepots(raw, cityName, isPostCode);
+        if (filtered.length) {
+            carHireSearch.chosenDistance = '5';
+            return carHireSearch.sortCarHireDepots(filtered);
+        }
+        // Nothing within 5 miles — widen before giving up.
+        const rawWide = await this.fetchDepotsWithinRadius(loc, String(WIDE_SEARCH_RADIUS_MILES));
+        const filteredWide = carHireSearch.filterCarHireDepots(rawWide, cityName, isPostCode);
+        if (filteredWide.length) {
+            carHireSearch.chosenDistance = String(WIDE_SEARCH_RADIUS_MILES);
+        }
+        return carHireSearch.sortCarHireDepots(filteredWide);
+    }
+    async fetchDepotsWithinRadius(loc, distance) {
+        try {
+            const depots = await firstValueFrom(this.searchService.getCarHireDepots(loc.latitude, loc.longitude, distance));
+            return depots ?? [];
+        }
+        catch {
+            return [];
+        }
+    }
+    // Resolves a single depot for a location — used for dropoff and postcode paths.
+    // Delivery/collection uses the Enterprise lookup; standard searches use lat/lng.
+    async resolveDepot(loc, distance, deliveryCollection, by, carHireSearch) {
+        if (deliveryCollection) {
+            return this.resolveEnterpriseDepot(loc, by);
+        }
+        const search = carHireSearch ?? this.searchService.searches[ServiceType.Car];
+        const depots = await this.resolveCityDepots(loc, search, by === 'postcode');
+        return depots[0];
+    }
+    async resolveEnterpriseDepot(loc, by) {
+        const depots = await this.fetchEnterpriseDepots(loc, by);
+        return depots[0];
+    }
+    async fetchEnterpriseDepots(loc, by) {
+        const country = loc.countryCode;
+        const term = loc.name;
+        if (!country || !term) {
+            return [];
+        }
+        try {
+            const obs = by === 'postcode'
+                ? this.searchService.getEntLocationsPostcode(country, term, '-')
+                : this.searchService.getEntLocationsCity(country, term, '-');
+            const locations = await firstValueFrom(obs);
+            return (locations ?? []).map((l) => this.toEnterpriseDepot(l));
+        }
+        catch {
+            return [];
+        }
+    }
+    toEnterpriseDepot(loc) {
+        return {
+            addressLines: loc.address || null,
+            cityName: loc.city || null,
+            countryCode: loc.country || null,
+            extendedLocationCode: loc.code || null,
+            latitude: null,
+            locationCode: loc.postcode || null,
+            locationType: null,
+            longitude: null,
+            vendor: loc.vendor,
+            vendorCode: loc.vendor
+        };
+    }
+    // ── Postcode resolution ─────────────────────────────────────────────────────
+    async applyPostcodePickupAndDropoff(carHireSearch, parameters, deliveryCollection) {
+        const country = parameters.country || 'GB';
+        const distance = String(parameters.distance ?? 5);
+        carHireSearch.chosenDistance = distance;
+        const pickup = await this.resolvePostcode(parameters.pickupPostcode, country);
+        if (!pickup) {
+            return { status: 'location-not-found', term: parameters.pickupPostcode };
+        }
+        // Delivery/collection uses Enterprise-only depot lookup (mirrors the form's
+        // behaviour when delivery/collection checkboxes are checked).
+        if (deliveryCollection) {
+            const allDepots = await this.fetchEnterpriseDepots(pickup, 'postcode');
+            if (!allDepots.length) {
+                return { status: 'depot-not-found', location: parameters.pickupPostcode };
+            }
+            if (allDepots.length > 1) {
+                return {
+                    status: 'depot-choice',
+                    location: parameters.pickupPostcode,
+                    depots: allDepots,
+                    pickup,
+                    deliveryCollection
+                };
+            }
+            carHireSearch.postcodePickupRaw = pickup;
+            carHireSearch.postcodePickup = allDepots[0];
+            carHireSearch.postcodeDropoffRaw = pickup;
+            carHireSearch.postcodeDropoff = allDepots[0];
+            return { status: 'ok' };
+        }
+        const allDepots = await this.resolveCityDepots(pickup, carHireSearch, true);
+        if (!allDepots.length) {
+            return { status: 'depot-not-found', location: parameters.pickupPostcode };
+        }
+        if (allDepots.length > 1) {
+            return {
+                status: 'depot-choice',
+                location: parameters.pickupPostcode,
+                depots: allDepots,
+                pickup,
+                deliveryCollection
+            };
+        }
+        const pickupDepot = allDepots[0];
+        carHireSearch.postcodePickupRaw = pickup;
+        carHireSearch.postcodePickup = pickupDepot;
+        if (carHireSearch.return_to_pickup || !parameters.dropoffPostcode) {
+            carHireSearch.postcodeDropoffRaw = pickup;
+            carHireSearch.postcodeDropoff = pickupDepot;
+            return { status: 'ok' };
+        }
+        const dropoff = await this.resolvePostcode(parameters.dropoffPostcode, country);
+        const dropoffDepots = dropoff
+            ? await this.resolveCityDepots(dropoff, carHireSearch, true)
+            : [];
+        if (dropoff && dropoffDepots.length) {
+            carHireSearch.postcodeDropoffRaw = dropoff;
+            carHireSearch.postcodeDropoff = dropoffDepots[0];
+            return { status: 'ok' };
+        }
+        // Unresolved dropoff — mirror the pickup so the search stays valid.
+        carHireSearch.postcodeDropoffRaw = pickup;
+        carHireSearch.postcodeDropoff = pickupDepot;
+        return { status: 'ok' };
+    }
+    async resolvePostcode(term, country) {
+        const query = term.trim();
+        if (query.length < 2) {
+            return undefined;
+        }
+        try {
+            const results = await firstValueFrom(this.searchService.getPostcodeList(query, country));
+            return results?.[0];
+        }
+        catch {
+            return undefined;
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.20", ngImport: i0, type: ChatbotCarHireSearchService, deps: [{ token: ChatbotService }, { token: EnterpriseSearchService }, { token: ResultAwareService }, { token: UserService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.20", ngImport: i0, type: ChatbotCarHireSearchService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.20", ngImport: i0, type: ChatbotCarHireSearchService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: ChatbotService }, { type: EnterpriseSearchService }, { type: ResultAwareService }, { type: UserService }] });
+
+const MAX_TAXI_CARDS = 3;
+class ChatbotTaxiSearchService {
+    chatbotService;
+    searchService;
+    resultAwareService;
+    travelType = 'taxi';
+    constructor(chatbotService, searchService, resultAwareService) {
+        this.chatbotService = chatbotService;
+        this.searchService = searchService;
+        this.resultAwareService = resultAwareService;
+    }
+    async handle(parameters, autoSearch) {
+        this.searchService.resetSearchChosenObjects();
+        this.searchService.resetSearchPriorities();
+        this.searchService.search_objects[ServiceType.Cab].chosen = true;
+        this.searchService.search_objects[ServiceType.Cab].originalChosen = true;
+        this.searchService.determineHighestSearchPriority();
+        if (autoSearch) {
+            this.chatbotService.setSearching(true, 'taxi');
+        }
+        await this.populateTaxiParams(parameters);
+        if (!autoSearch) {
+            return;
+        }
+        await this.runSearch(parameters);
+    }
+    async runSearch(parameters) {
+        const taxiSearch = this.searchService.searches[ServiceType.Cab];
+        this.resultAwareService.clearResults();
+        const hasResults = await taxiSearch.startSearch();
+        if (!hasResults) {
+            this.injectNoResultsMessage();
+            this.chatbotService.setSearching(false);
+            return;
+        }
+        const results$ = taxiSearch.results;
+        results$
+            .pipe(filter((results) => results?.length > 0), take(1), catchError$1((err) => {
+            console.warn('[ChatbotTaxiSearchService] results polling error', err);
+            this.chatbotService.setSearching(false);
+            return EMPTY;
+        }))
+            .subscribe((results) => {
+            const topResults = results.slice(0, MAX_TAXI_CARDS);
+            const cards = this.buildTaxiCards(topResults, parameters);
+            const fromName = parameters.departure || '';
+            const toName = parameters.arrival || '';
+            const dateStr = parameters.departureDate
+                ? moment$1(parameters.departureDate).format('D MMM')
+                : '';
+            const searchHeader = [fromName, toName, dateStr].filter(Boolean).join(' · ');
+            const taxiResults = { cards, searchHeader, parameters };
+            this.chatbotService.patchAssistantMessage({ taxiResults, state: 'RESULTS_READY' });
+            this.chatbotService.setSearching(false);
+        });
+    }
+    buildTaxiCards(results, parameters) {
+        return results.map((r, i) => {
+            const fromLoc = r.fromLocation?.airportStationName ||
+                r.fromLocation?.streetAndNumber ||
+                parameters.departure ||
+                '';
+            const toLoc = r.toLocation?.airportStationName ||
+                r.toLocation?.streetAndNumber ||
+                parameters.arrival ||
+                '';
+            let policyStatus;
+            if (r.unavailable) {
+                policyStatus = 'UNAVAILABLE';
+            }
+            else if (r.requiresReasonKeys?.length || r.requiresApprovalKeys?.length) {
+                policyStatus = 'ALLOW_WITH_REASON';
+            }
+            else {
+                policyStatus = 'IN_POLICY';
+            }
+            return {
+                index: i + 1,
+                supplierName: r.supplierName || '',
+                vehicleType: r.vehicleType || '',
+                price: r.price ?? 0,
+                currencyCode: r.currency || 'GBP',
+                departs: r.departs || '',
+                fromLocation: fromLoc,
+                toLocation: toLoc,
+                tripDistanceMetres: r.tripDistanceMetres ?? undefined,
+                tripDurationSeconds: r.tripDurationSeconds ?? undefined,
+                policyStatus,
+                policyMessages: r.requiresReasonMessages ?? undefined,
+                co2: r.co2PerItem || undefined,
+            };
+        });
+    }
+    injectNoResultsMessage() {
+        this.chatbotService.injectMessage({
+            id: `taxi-no-results-${Date.now()}`,
+            role: 'assistant',
+            text: 'No taxi results found for your search. Try adjusting your pickup, dropoff or time.',
+            timestamp: new Date(),
+            state: 'SELECTING_RESULT',
+        });
+    }
+    async populateTaxiParams(parameters) {
+        const taxiSearch = this.searchService.searches[ServiceType.Cab];
+        const departDate = moment$1(parameters.departureDate);
+        taxiSearch.date = {
+            year: departDate.year(),
+            month: departDate.month() + 1,
+            day: departDate.date(),
+        };
+        if (parameters.departureTime) {
+            const parsed = moment$1(parameters.departureTime, ['HH:mm', 'H:mm', 'ha', 'h:mma']);
+            taxiSearch.time = parsed.isValid() ? parsed.format('HH:mm') : parameters.departureTime;
+        }
+        taxiSearch.adults = parameters.passengers || 1;
+        if (parameters.vehicleType) {
+            taxiSearch.vehicleType = parameters.vehicleType;
+        }
+        const [fromResolved, toResolved, viaResolved] = await Promise.all([
+            this.resolveGeoLocation(parameters.departure, taxiSearch),
+            this.resolveGeoLocation(parameters.arrival, taxiSearch),
+            parameters.via ? this.resolveGeoLocation(parameters.via, taxiSearch) : Promise.resolve(null),
+        ]);
+        if (fromResolved) {
+            const { result, address } = fromResolved;
+            if (result.terminals?.length) {
+                taxiSearch.fromTerminals = result.terminals;
+            }
+            address.Terminal = parameters.pickupTerminal
+                ? this.matchTerminal(parameters.pickupTerminal, result.terminals || [])
+                : null;
+            if (parameters.pickupFlightNumber) {
+                address.FlightNumber = parameters.pickupFlightNumber;
+            }
+            taxiSearch.fromAddress = address;
+        }
+        if (toResolved) {
+            const { result, address } = toResolved;
+            if (result.terminals?.length) {
+                taxiSearch.toTerminals = result.terminals;
+            }
+            address.Terminal = parameters.dropoffTerminal
+                ? this.matchTerminal(parameters.dropoffTerminal, result.terminals || [])
+                : null;
+            if (parameters.dropoffFlightNumber) {
+                address.FlightNumber = parameters.dropoffFlightNumber;
+            }
+            taxiSearch.toAddress = address;
+        }
+        if (viaResolved) {
+            taxiSearch.viasTo = viaResolved.address;
+        }
+    }
+    async resolveGeoLocation(searchTerm, taxiSearch) {
+        if (!searchTerm)
+            return null;
+        try {
+            const results = await firstValueFrom(this.searchService.getGeoLocations(searchTerm));
+            if (results?.length) {
+                const term = searchTerm.toLowerCase();
+                let location = results[0];
+                if (term.includes('airport')) {
+                    location = results.find((r) => r.type === 'Airport') ?? results[0];
+                }
+                else if (term.includes('station') || term.includes('rail')) {
+                    location = results.find((r) => r.type === 'Train Station') ?? results[0];
+                }
+                const address = taxiSearch.getAddress(location);
+                if (location.type === 'Airport' && !address?.Town) {
+                    address.Town = location.name;
+                }
+                return { result: location, address };
+            }
+        }
+        catch {
+        }
+        return null;
+    }
+    matchTerminal(aiTerminal, terminals) {
+        const t = aiTerminal.toLowerCase().trim();
+        if (!t || t.includes('any') || t.includes('main'))
+            return null;
+        const byValue = terminals.find((x) => x.value.toLowerCase() === t);
+        if (byValue)
+            return byValue.key;
+        const byKey = terminals.find((x) => x.key.toLowerCase().includes(t) || t.includes(x.value.toLowerCase()));
+        return byKey ? byKey.key : null;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.20", ngImport: i0, type: ChatbotTaxiSearchService, deps: [{ token: ChatbotService }, { token: EnterpriseSearchService }, { token: ResultAwareService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.20", ngImport: i0, type: ChatbotTaxiSearchService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.20", ngImport: i0, type: ChatbotTaxiSearchService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: ChatbotService }, { type: EnterpriseSearchService }, { type: ResultAwareService }] });
+
+/** Safety timeout (ms) waiting for eurostar results. */
+const EUROSTAR_RESULTS_WAIT_MS = 60_000;
+/** Maximum number of outbound/inbound cards to surface in the chat widget. */
+const MAX_EUROSTAR_CARDS = 3;
+/**
+ * Handles chatbot-driven Eurostar searches. Registered with
+ * `ChatbotSearchDispatcherService`; not used directly.
+ *
+ * Populates the Eurostar search state from the chatbot's parameters and, when
+ * `autoSearch` is true, runs the search headlessly so it works from any page.
+ * Once results arrive, builds `ChatEurostarResults` and patches them onto the
+ * last assistant message via {@link ChatbotService.patchAssistantMessage}.
+ */
+class ChatbotEurostarSearchService {
+    chatbotService;
+    searchService;
+    userService;
+    travelType = 'eurostar';
+    resultsSubscription = null;
+    constructor(chatbotService, searchService, userService) {
+        this.chatbotService = chatbotService;
+        this.searchService = searchService;
+        this.userService = userService;
+    }
+    async handle(parameters, autoSearch) {
+        this.searchService.resetSearchChosenObjects();
+        this.searchService.resetSearchPriorities();
+        this.searchService.search_objects[ServiceType.Eurostar].chosen = true;
+        this.searchService.search_objects[ServiceType.Eurostar].originalChosen = true;
+        this.searchService.determineHighestSearchPriority();
+        // Auto-add the signed-in user as the traveller when none is selected so
+        // the search isn't blocked by the "add a traveller" validation rule.
+        // Matches the rail handler pattern.
+        if (this.searchService.travellerInformation.value.length === 0) {
+            const selfTraveller = this.userService.createSelfTraveller();
+            if (selfTraveller) {
+                this.searchService.addTraveller(selfTraveller);
+            }
+        }
+        const departDate = moment$1(parameters.departureDate);
+        const departNgbDate = {
+            year: departDate.year(),
+            month: departDate.month() + 1,
+            day: departDate.date()
+        };
+        await this.populateEurostarParams(parameters, departNgbDate);
+        if (!autoSearch) {
+            return;
+        }
+        await this.runSearch(parameters);
+    }
+    // ── Search ────────────────────────────────────────────────────────────────
+    async runSearch(parameters) {
+        const eurostarSearch = this.searchService.searches[ServiceType.Eurostar];
         // Surface OBT's existing validation (past dates, missing stations,
         // same origin/destination, return-before-depart, incompatible cabins)
         // before triggering the search — matches the rail handler pattern.
@@ -20281,11 +21922,15 @@ class ChatbotEurostarSearchService {
         // used by the Eurostar search class internals. Always set both outbound
         // and return cabin classes — `updateSerchQuery` calls
         // `turnCabinTypeToName(returnCabinClass)` on return trips and crashes if
-        // it's undefined. Keeping them in sync also satisfies the cabin-match
-        // validation rule (`checkCabinMatchisValid`).
+        // it's undefined. The return leg uses its own class when the user asked for
+        // a different one (e.g. business out, standard return); otherwise it
+        // mirrors the outbound class, satisfying the cabin-match validation rule
+        // (`checkCabinMatchisValid`).
         const mappedCabin = this.mapCabinClass(parameters.cabinClass);
         eurostarParams.cabinClass = mappedCabin;
-        eurostarParams.returnCabinClass = mappedCabin;
+        eurostarParams.returnCabinClass = parameters.returnCabinClass
+            ? this.mapCabinClass(parameters.returnCabinClass)
+            : mappedCabin;
         // Always set maxConnections so a previous "direct only" search doesn't
         // persist when the user removes that constraint. `null` = no limit.
         eurostarParams.maxConnections =
@@ -20352,6 +21997,216 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.20", ngImpo
             args: [{ providedIn: 'root' }]
         }], ctorParameters: () => [{ type: ChatbotService }, { type: EnterpriseSearchService }, { type: UserService }] });
 
+/** How long (ms) to wait for lounge results before giving up. */
+const LOUNGE_RESULTS_WAIT_MS = 60_000;
+/** Maximum number of lounge cards to show in chat. */
+const MAX_LOUNGE_CARDS = 3;
+/**
+ * Handles chatbot-driven lounge searches. Registered with
+ * `ChatbotSearchDispatcherService`; not used directly.
+ *
+ * Populates the lounge search state from the chatbot's parameters and runs
+ * `startSearch()` headlessly so chatbot lounge searches work from any page.
+ * Once results arrive, builds `ChatLoungeResultCard`s and patches them onto
+ * the last assistant message via {@link ChatbotService.patchAssistantMessage}.
+ */
+class ChatbotLoungeSearchService {
+    chatbotService;
+    searchService;
+    resultAwareService;
+    userService;
+    travelType = 'lounge';
+    resultsSubscription = null;
+    constructor(chatbotService, searchService, resultAwareService, userService) {
+        this.chatbotService = chatbotService;
+        this.searchService = searchService;
+        this.resultAwareService = resultAwareService;
+        this.userService = userService;
+    }
+    async handle(parameters, autoSearch) {
+        this.searchService.resetSearchChosenObjects();
+        this.searchService.resetSearchPriorities();
+        this.searchService.search_objects[ServiceType.Lounge].chosen = true;
+        this.searchService.search_objects[ServiceType.Lounge].originalChosen = true;
+        this.searchService.determineHighestSearchPriority();
+        if (this.searchService.travellerInformation.value.length === 0) {
+            const selfTraveller = this.userService.createSelfTraveller();
+            if (selfTraveller) {
+                this.searchService.addTraveller(selfTraveller);
+            }
+        }
+        if (autoSearch) {
+            this.subscribeToLoungeResults(parameters);
+        }
+        await this.populateLoungeParams(parameters);
+        if (!autoSearch) {
+            return;
+        }
+        const loungeSearch = this.searchService.searches[ServiceType.Lounge];
+        const validationMessages = Array.isArray(loungeSearch.validationMessages)
+            ? loungeSearch.validationMessages.filter(Boolean)
+            : [];
+        if (validationMessages.length) {
+            this.resultsSubscription?.unsubscribe();
+            this.resultsSubscription = null;
+            this.chatbotService.patchAssistantMessage({
+                text: this.formatValidationMessages(validationMessages),
+                state: 'RESULTS_READY'
+            });
+            this.chatbotService.setSearching(false);
+            return;
+        }
+        const ok = await loungeSearch.startSearch();
+        if (!ok) {
+            this.resultsSubscription?.unsubscribe();
+            this.resultsSubscription = null;
+            const messages = Array.isArray(loungeSearch.validationMessages)
+                ? loungeSearch.validationMessages.filter(Boolean)
+                : [];
+            this.chatbotService.patchAssistantMessage({
+                text: messages.length
+                    ? this.formatValidationMessages(messages)
+                    : `I couldn't find any lounges — please check the airport and date and try again.`,
+                state: 'RESULTS_READY'
+            });
+            this.chatbotService.setSearching(false);
+        }
+    }
+    // ── Result capture + card building ────────────────────────────────────────
+    subscribeToLoungeResults(parameters) {
+        this.resultsSubscription?.unsubscribe();
+        this.resultAwareService.clearResults();
+        this.chatbotService.setSearching(true, 'lounge');
+        const loungeSearch = this.searchService.searches[ServiceType.Lounge];
+        this.resultsSubscription = loungeSearch.results
+            .pipe(filter((results) => Array.isArray(results) && results.length > 0), take(1), timeout$1(LOUNGE_RESULTS_WAIT_MS), catchError$1((err) => {
+            console.warn('[ChatbotLoungeSearchService] lounge results timed out or errored', err);
+            this.chatbotService.patchAssistantMessage({
+                text: `I couldn't find any lounges for that airport. It may not have lounge access available.`,
+                state: 'RESULTS_READY'
+            });
+            this.chatbotService.setSearching(false);
+            return EMPTY;
+        }))
+            .subscribe((results) => {
+            const cards = this.buildLoungeCards(results, parameters);
+            const airport = typeof loungeSearch.locationCode === 'object'
+                ? loungeSearch.locationCode.destination ?? parameters.departure
+                : parameters.departure;
+            const dateLabel = parameters.departureDate
+                ? moment$1(parameters.departureDate).format('D MMM YYYY')
+                : '';
+            const searchHeader = [airport, dateLabel].filter(Boolean).join(' · ');
+            const loungeResults = { cards, searchHeader, parameters };
+            this.chatbotService.patchAssistantMessage({ loungeResults, state: 'RESULTS_READY' });
+            this.chatbotService.setSearching(false);
+        });
+    }
+    buildLoungeCards(results, parameters) {
+        return results.slice(0, MAX_LOUNGE_CARDS).map((r, i) => {
+            const policyStatus = r.unavailable
+                ? 'UNAVAILABLE'
+                : r.requiresReasonKeys?.length
+                    ? 'ALLOW_WITH_REASON'
+                    : 'IN_POLICY';
+            const isPreferred = !!(r.tmcPreferred || r.companyPreferred || r.officePreferred);
+            return {
+                index: i,
+                date: parameters.departureDate
+                    ? moment$1(parameters.departureDate).format('ddd, D MMM YYYY')
+                    : '',
+                name: r.name ?? '',
+                airport: r.lounge?.airport ?? parameters.departure,
+                terminal: r.lounge?.terminal != null ? String(r.lounge.terminal) : undefined,
+                price: r.price ?? 0,
+                currency: r.currency ?? 'GBP',
+                policyStatus,
+                policyMessages: r.requiresReasonMessages ?? [],
+                isPreferred,
+                unavailable: !!r.unavailable,
+                unavailableMessage: r.unavailableMessage ?? undefined,
+                openTime: r.lounge?.openTime ?? undefined,
+                closeTime: r.lounge?.closeTime ?? undefined
+            };
+        });
+    }
+    formatValidationMessages(messages) {
+        if (messages.length === 1) {
+            return `I couldn't run that search — ${messages[0]}. Please adjust and try again.`;
+        }
+        const bullets = messages.map((m) => `• ${m}`).join('\n');
+        return `I couldn't run that search — please fix the following and try again:\n${bullets}`;
+    }
+    // ── Param population ──────────────────────────────────────────────────────
+    async populateLoungeParams(parameters) {
+        const loungeSearch = this.searchService.searches[ServiceType.Lounge];
+        // Resolve airport
+        const airport = await this.resolveAirport(parameters.locationCode, parameters.departure);
+        if (airport) {
+            loungeSearch.locationCode = airport;
+            if (airport.countryCode) {
+                loungeSearch.countryCode = airport.countryCode;
+            }
+        }
+        // Set arrival datetime from date + time
+        const departDate = moment$1(parameters.departureDate);
+        if (parameters.departureTime) {
+            const timeParsed = moment$1(parameters.departureTime, ['H:mm', 'HH:mm', 'ha', 'h:mma', 'h a', 'h:mm a']);
+            if (timeParsed.isValid()) {
+                departDate.hours(timeParsed.hours()).minutes(timeParsed.minutes()).seconds(0);
+            }
+        }
+        loungeSearch.arrivalDatetime = departDate;
+        // Terminal
+        if (parameters.terminal) {
+            loungeSearch.terminal = parameters.terminal;
+        }
+        // Flight number
+        if (parameters.flight) {
+            loungeSearch.flightNumber = parameters.flight;
+        }
+        // Passengers
+        if (parameters.passengers != null) {
+            loungeSearch.adults = parameters.passengers;
+        }
+        if (parameters.children != null) {
+            loungeSearch.children = parameters.children;
+        }
+    }
+    async resolveAirport(code, name) {
+        const searchTerm = code ?? name;
+        if (!searchTerm)
+            return null;
+        try {
+            const airports = await firstValueFrom(this.searchService.getAirportsList(searchTerm, null, null, true));
+            if (!airports?.length) {
+                // Fall back to name if code search returned nothing
+                if (code && name) {
+                    const byName = await firstValueFrom(this.searchService.getAirportsList(name, null, null, true));
+                    return byName?.[0] ?? null;
+                }
+                return null;
+            }
+            // Prefer exact IATA code match
+            if (code) {
+                const exact = airports.find((a) => a?.gateway?.toUpperCase() === code.toUpperCase());
+                if (exact)
+                    return exact;
+            }
+            return airports[0];
+        }
+        catch {
+            return null;
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.20", ngImport: i0, type: ChatbotLoungeSearchService, deps: [{ token: ChatbotService }, { token: EnterpriseSearchService }, { token: ResultAwareService }, { token: UserService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.20", ngImport: i0, type: ChatbotLoungeSearchService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.20", ngImport: i0, type: ChatbotLoungeSearchService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: ChatbotService }, { type: EnterpriseSearchService }, { type: ResultAwareService }, { type: UserService }] });
+
 /**
  * Routes `ChatbotService.fillSearchForm$` events to per-travel-type handlers.
  *
@@ -20368,9 +22223,9 @@ class ChatbotSearchDispatcherService {
     chatbotService;
     initialised = false;
     handlers;
-    constructor(chatbotService, rail, flight, hotel, eurostar) {
+    constructor(chatbotService, rail, flight, hotel, carHire, eurostar, lounge, taxi) {
         this.chatbotService = chatbotService;
-        this.handlers = [rail, flight, hotel, eurostar];
+        this.handlers = [rail, flight, hotel, carHire, eurostar, lounge, taxi];
     }
     /** Call once at app start. Idempotent. */
     init() {
@@ -20389,6 +22244,22 @@ class ChatbotSearchDispatcherService {
                 console.error(`[ChatbotSearchDispatcherService] handler '${parameters.travelType}' failed:`, err);
             });
         });
+        this.chatbotService.resortResults$.subscribe(({ parameters }) => {
+            const handler = this.findHandler(parameters?.travelType);
+            if (!handler?.resort) {
+                // Handler doesn't support cache re-ranking — fall back to a fresh
+                // search so the user still gets re-ordered cards.
+                if (handler) {
+                    handler.handle(parameters, true).catch((err) => {
+                        console.error(`[ChatbotSearchDispatcherService] resort fallback '${parameters.travelType}' failed:`, err);
+                    });
+                }
+                return;
+            }
+            handler.resort(parameters).catch((err) => {
+                console.error(`[ChatbotSearchDispatcherService] resort '${parameters.travelType}' failed:`, err);
+            });
+        });
     }
     /**
      * Whether a global handler is registered for the given travel type. Used by
@@ -20404,13 +22275,13 @@ class ChatbotSearchDispatcherService {
         }
         return this.handlers.find((h) => h.travelType === travelType);
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.20", ngImport: i0, type: ChatbotSearchDispatcherService, deps: [{ token: ChatbotService }, { token: ChatbotRailSearchService }, { token: ChatbotFlightSearchService }, { token: ChatbotHotelSearchService }, { token: ChatbotEurostarSearchService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.20", ngImport: i0, type: ChatbotSearchDispatcherService, deps: [{ token: ChatbotService }, { token: ChatbotRailSearchService }, { token: ChatbotFlightSearchService }, { token: ChatbotHotelSearchService }, { token: ChatbotCarHireSearchService }, { token: ChatbotEurostarSearchService }, { token: ChatbotLoungeSearchService }, { token: ChatbotTaxiSearchService }], target: i0.ɵɵFactoryTarget.Injectable });
     static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.20", ngImport: i0, type: ChatbotSearchDispatcherService, providedIn: 'root' });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.20", ngImport: i0, type: ChatbotSearchDispatcherService, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
-        }], ctorParameters: () => [{ type: ChatbotService }, { type: ChatbotRailSearchService }, { type: ChatbotFlightSearchService }, { type: ChatbotHotelSearchService }, { type: ChatbotEurostarSearchService }] });
+        }], ctorParameters: () => [{ type: ChatbotService }, { type: ChatbotRailSearchService }, { type: ChatbotFlightSearchService }, { type: ChatbotHotelSearchService }, { type: ChatbotCarHireSearchService }, { type: ChatbotEurostarSearchService }, { type: ChatbotLoungeSearchService }, { type: ChatbotTaxiSearchService }] });
 
 class BasketPanelComponent extends WithSubscriptionComponent {
     basketService;
@@ -20700,5 +22571,5 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.20", ngImpo
  * Generated bundle index. Do not edit.
  */
 
-export { AcceptNewPriceDocument, AcceptNewPriceGQL, AcceptNewPriceUpdater, AcceptProcessTermsDocument, AcceptProcessTermsGQL, AccessibilityInfoFragmentDoc, AddBasketItemCustomRemarkDocument, AddBasketItemCustomRemarkGQL, AddBasketItemCustomRemarkUpdater, AddBasketItemMarkupDocument, AddBasketItemMarkupGQL, AddBasketItemMarkupUpdater, AddFavouriteUserDocument, AddFavouriteUserGQL, AddFavouriteUserUpdater, AddGuestToBasketItemUpdater, AddGuestsToBasketItemDocument, AddGuestsToBasketItemGQL, AddItemToBasketDocument, AddItemToBasketGQL, AddItemToBasketUpdater, AddRedirectApproverDocument, AddRedirectApproverGQL, AddRedirectApproverUpdater, AddToBasketFieldsFragmentDoc, AddUpdatedItemToBasketDocument, AddUpdatedItemToBasketGQL, AddUpdatedItemToBasketUpdater, AddUserToBasketItemUpdater, AddUsersToBasketItemDocument, AddUsersToBasketItemGQL, AddressType, AmendBookingDocument, AmendBookingGQL, AmendBookingUpdater, ApexxCardStatus, ApexxCreateCardDocument, ApexxCreateCardGQL, ApexxDeleteCardDocument, ApexxDeleteCardGQL, ApexxDeleteCardUpdater, ApexxListCardsDocument, ApexxListCardsGQL, ApexxUpdateCardDocument, ApexxUpdateCardGQL, ApexxUpdateCardUpdater, ApplyJitFlightRulesDocument, ApplyJitFlightRulesGQL, ApplyJitHotelRulesDocument, ApplyJitHotelRulesGQL, ApprovalEventType, ApproverUserFieldsFragmentDoc, AuthHttpService, BaggageType, BannerDisplayTarget, BasketFieldsFragmentDoc, BasketItemStatus, BasketMinimalFieldsFragmentDoc, BasketPanelComponent, BasketStatus, BeforeAmendCabSearchDocument, BeforeAmendCabSearchFetcher, BeforeAmendCabSearchGQL, BeforeAmendCarHireSearchDocument, BeforeAmendCarHireSearchFetcher, BeforeAmendCarHireSearchGQL, BookBasketDocument, BookBasketFieldsFragmentDoc, BookBasketGQL, BookBasketUpdater, BookerType, CabHireVehicleType, CabhireQuoteFetcher, CanAmendBookingDocument, CanAmendBookingFetcher, CanAmendBookingGQL, CancelBookingDocument, CancelBookingGQL, CancelBookingUpdater, CarHireAvailabilityDetailFetcher, CarHireAvailabilityDetailRequestDocument, CarHireAvailabilityDetailRequestGQL, CarHireClass, CarHireTransmission, CarHireType, CarbonPolicyDuration, CarbonPolicySource, CarhireQuoteFetcher, ChangeBasketOwnershipDocument, ChangeBasketOwnershipGQL, ChangeBasketOwnershipUpdater, ChangeMode, ChatbotEurostarSearchService, ChatbotFlightSearchService, ChatbotHotelSearchService, ChatbotRailSearchService, ChatbotSearchDispatcherService, ChatbotService, CheckForDuplicateBookingsDocument, CheckForDuplicateBookingsFetcher, CheckForDuplicateBookingsGQL, CheckIfBasketRequiresApprovalDocument, CheckIfBasketRequiresApprovalFetcher, CheckIfBasketRequiresApprovalGQL, CompanyType, ConfirmMessagesDocument, ConfirmMessagesGQL, ConvertCurrencyDocument, ConvertCurrencyFetcher, ConvertCurrencyGQL, CreateBasketDocument, CreateBasketFieldsFragmentDoc, CreateBasketFromDraftDocument, CreateBasketFromDraftGQL, CreateBasketFromDraftUpdater, CreateBasketGQL, CreateBasketNoteDocument, CreateBasketNoteGQL, CreateBasketNoteUpdater, CreateBasketUpdater, CreateGuestDocument, CreateGuestGQL, CreateGuestUpdater, CreateItineraryExchangeDocument, CreateItineraryExchangeGQL, CurrencyCode, CycleInfoFragmentDoc, DeleteAllRecentSearchesDocument, DeleteAllRecentSearchesGQL, DeleteAllRecentSearchesUpdater, DeleteBasketDocument, DeleteBasketGQL, DeleteBasketUpdater, DeleteFavouriteSearchDocument, DeleteFavouriteSearchGQL, DeleteFavouriteSearchUpdater, DeleteGuestDocument, DeleteGuestGQL, DeleteGuestUpdater, DeleteRecentSearchDocument, DeleteRecentSearchGQL, DeleteUserAddressDocument, DeleteUserAddressGQL, DiscountType, DistanceTypes, DivisionFieldsFragmentDoc, DocGender, DocType, DownloadETicketDocument, DownloadETicketFetcher, DownloadETicketGQL, DraftBasketType, EditUserAddressDocument, EditUserAddressGQL, EditUserAddressUpdater, EditUserDocument, EditUserGQL, EmailAmbulanceBookingFetcher, EmailAmbulanceBookingReqDocument, EmailAmbulanceBookingReqGQL, EmailApartmentBookingFetcher, EmailApartmentBookingReqDocument, EmailApartmentBookingReqGQL, EmailBasketDocument, EmailBasketFetcher, EmailBasketGQL, EmailFerryBookingFetcher, EmailFerryBookingReqDocument, EmailFerryBookingReqGQL, EmailMeetingRoomBookingFetcher, EmailMeetingRoomBookingReqDocument, EmailMeetingRoomBookingReqGQL, EmailSeasonTicketBookingFetcher, EmailSeasonTicketBookingReqDocument, EmailSeasonTicketBookingReqGQL, EntLocationsByCityDocument, EntLocationsByCityGQL, EntLocationsByPostcodeDocument, EntLocationsByPostcodeGQL, EnterpriseBasketService, EnterpriseMyBookingsService, EnterpriseSearchService, Environment, ErrorsFragmentDoc, EurostarQuoteFetcher, EventMessenager, EvolviSeatmapsAreEnabledDocument, EvolviSeatmapsAreEnabledGQL, ExchangeType, ExternalHttpService, FailedEmail, FareRuleType, FareType, FerryOrEurotunnel, FlightCabinClass, FlightItineraryFieldsFragmentDoc, FlightPassengerType, FlightQuoteFetcher, GenerateBasketPdfDocument, GenerateBasketPdfFetcher, GenerateBasketPdfGQL, GetAirAvailabilityDocument, GetAirAvailabilityFetcher, GetAirAvailabilityGQL, GetAllAirlinesDocument, GetAllAirlinesFetcher, GetAllAirlinesGQL, GetApexxListCardsFetcher, GetBannerDocument, GetBannerFetcher, GetBannerGQL, GetBasketApprovalInfoDocument, GetBasketApprovalInfoFetcher, GetBasketApprovalInfoGQL, GetBasketApprovalTimestampsDocument, GetBasketApprovalTimestampsGQL, GetBasketCo2InfoFetcher, GetBasketFetcher, GetBasketItemCustomRemarksDocument, GetBasketItemCustomRemarksFetcher, GetBasketItemCustomRemarksGQL, GetBasketNotesDocument, GetBasketNotesFetcher, GetBasketNotesGQL, GetBasketQuoteDocument, GetBasketQuoteFetcher, GetBasketQuoteGQL, GetBrandedFaresDocument, GetBrandedFaresGQL, GetCancellationInfoDocument, GetCancellationInfoFetcher, GetCancellationInfoGQL, GetCarHireDepotsDocument, GetCarHireDepotsGQL, GetCarHireProvidersDocument, GetCarHireProvidersFetcher, GetCarHireProvidersGQL, GetCompaniesDocument, GetCompaniesFetcher, GetCompaniesGQL, GetCompanyDocument, GetCompanyFetcher, GetCompanyGQL, GetConfermaQuicklistDocument, GetConfermaQuicklistGQL, GetConfermaRoomImagesDocument, GetConfermaRoomImagesGQL, GetCovidMicrositeTokenDocument, GetCovidMicrositeTokenFetcher, GetCovidMicrositeTokenGQL, GetCurrencyConversionRatesDocument, GetCurrencyConversionRatesFetcher, GetCurrencyConversionRatesGQL, GetDivisionDocument, GetDivisionGQL, GetDraftBasketsDocument, GetDraftBasketsFetcher, GetDraftBasketsGQL, GetEmptyUserMiDefaultValuesDocument, GetEmptyUserMiDefaultValuesFetcher, GetEmptyUserMiDefaultValuesGQL, GetEntLocationByPostcode, GetEvolviSeatmapsAreEnabledFetcher, GetFerryPortsDocument, GetFerryPortsFetcher, GetFerryPortsGQL, GetFlightAtNewClassDocument, GetFlightAtNewClassFetcher, GetFlightAtNewClassGQL, GetFlightBrandedFaresFetcher, GetFlightExchangeDetailsDocument, GetFlightExchangeDetailsFetcher, GetFlightExchangeDetailsGQL, GetFlightExtrasOptionsDocument, GetFlightExtrasOptionsFetcher, GetFlightExtrasOptionsGQL, GetFlightFareRulesDocument, GetFlightFareRulesFetcher, GetFlightFareRulesGQL, GetFlightSearchExchangeDocument, GetFlightSearchExchangeFetcher, GetFlightSearchExchangeGQL, GetFlightSeatMapDocument, GetFlightSeatMapFetcher, GetFlightSeatMapGQL, GetFlightUpsellOffersDocument, GetFlightUpsellOffersFetcher, GetFlightUpsellOffersGQL, GetGmtItineraryOptionsDocument, GetGmtItineraryOptionsFetcher, GetGmtItineraryOptionsGQL, GetGutCitySuggestionsDocument, GetGutCitySuggestionsFetcher, GetGutCitySuggestionsGQL, GetGutLocationSuggestionsDocument, GetGutLocationSuggestionsFetcher, GetGutLocationSuggestionsGQL, GetHotelChainsDocument, GetHotelChainsFetcher, GetHotelChainsGQL, GetHotelDetailsDocument, GetHotelDetailsFetcher, GetHotelDetailsGQL, GetIrlDiscountCardsDocument, GetIrlDiscountCardsGQL, GetIrlSupplierStationDocument, GetIrlSupplierStationFetcher, GetIrlSupplierStationGQL, GetJyrneyUrlDocument, GetJyrneyUrlFetcher, GetJyrneyUrlGQL, GetLatLonFromHereIdDocument, GetLatLonFromHereIdFetcher, GetLatLonFromHereIdGQL, GetLatestVersionsDocument, GetLatestVersionsFetcher, GetLatestVersionsGQL, GetMIApproversFetcher, GetMiApproversDocument, GetMiApproversGQL, GetMiRequiringMandatoryDefaultValueDocument, GetMiRequiringMandatoryDefaultValueFetcher, GetMiRequiringMandatoryDefaultValueGQL, GetMultipleHotelRatingDocument, GetMultipleHotelRatingFetcher, GetMultipleHotelRatingGQL, GetMultipleHotelsAvailabilityDocument, GetMultipleHotelsAvailabilityGQL, GetOfficeApproversDocument, GetOfficeApproversFetcher, GetOfficeApproversGQL, GetOfficeDivisionsDocument, GetOfficeDivisionsFetcher, GetOfficeDivisionsGQL, GetOfficeDocument, GetOfficeFetcher, GetOfficeGQL, GetOfficeUsersDocument, GetOfficeUsersFetcher, GetOfficeUsersGQL, GetOfficesDocument, GetOfficesFetcher, GetOfficesGQL, GetPriceHiddenSabreExchangeDocument, GetPriceHiddenSabreExchangeFetcher, GetPriceHiddenSabreExchangeGQL, GetProcessTermsPriceDocument, GetProcessTermsPriceGQL, GetRailcardsFetcher as GetRailCardsFetcher, GetRailLiveDeparturesDocument, GetRailLiveDeparturesFetcher, GetRailLiveDeparturesGQL, GetRailProvidersDocument, GetRailProvidersFetcher, GetRailProvidersGQL, GetRailSearchExchangeDocument, GetRailSearchExchangeGQL, GetRailStationDocument, GetRailStationFetcher, GetRailStationGQL, GetRailStationInfoDocument, GetRailStationInfoFetcher, GetRailStationInfoGQL, GetRailcardsDocument, GetRailcardsFetcher, GetRailcardsGQL, GetRedirectApproverDocument, RedirectApproverFetcher as GetRedirectApproverFetcher, GetRedirectApproverGQL, GetRequestedBookingUpdateDocument, GetRequestedBookingUpdateFetcher, GetRequestedBookingUpdateGQL, GetRiskAlertsDocument, GetRiskAlertsFetcher, GetRiskAlertsGQL, GetRouteHappyDocument, GetRouteHappyFetcher, GetRouteHappyGQL, SearchCompanyApproversFetcher as GetSearchCompanyApproversFetcher, GetServiceDocument, GetServiceFetcher, GetServiceGQL, GetTrainSeatMapDocument, GetTrainSeatMapEvolviDocument, GetTrainSeatMapEvolviGQL, GetTrainSeatMapGQL, GetTrainSeatmapEvolviFetcher, GetTrainSeatmapFetcher, GetTrainlineSearchConfigDocument, GetTrainlineSearchConfigFetcher, GetTrainlineSearchConfigGQL, GetUserAddressesDocument, GetUserAddressesGQL, GetUserApproversDocument, GetUserApproversFetcher, GetUserApproversGQL, GetUserBasketCo2InfoDocument, GetUserBasketCo2InfoGQL, GetUserBasketDocument, GetUserBasketGQL, GetUserBasketsDocument, GetUserBasketsFetcher, GetUserBasketsGQL, GetUserCarbonAllowanceDocument, GetUserCarbonAllowanceFetcher, GetUserCarbonAllowanceGQL, GetUserCompanyOfficesDocument, GetUserCompanyOfficesFetcher, GetUserCompanyOfficesGQL, GetUserCarbonAllowanceFetcher as GetUserCurrentCarbonAllowanceFetcher, GetUserDocument, GetUserDocumentLoyaltyDocument, GetUserDocumentLoyaltyFetcher, GetUserDocumentLoyaltyGQL, GetUserEmergencyContactDocument, GetUserEmergencyContactFetcher, GetUserEmergencyContactGQL, GetUserFavouriteSearchesDocument, GetUserFavouriteSearchesFetcher, GetUserFavouriteSearchesGQL, GetUserFavouriteUsersDocument, GetUserFavouriteUsersFetcher, GetUserFavouriteUsersGQL, GetUserFetcher, GetUserGQL, GetUserGuestsDocument, GetUserGuestsFetcher, GetUserGuestsGQL, GetUserMessagesDocument, GetUserMessagesGQL, GetUserMiDefaultValuesDocument, GetUserMiDefaultValuesFetcher, GetUserMiDefaultValuesGQL, GetUserMiDocument, GetUserMiFetcher, GetUserMiGQL, GetUserMiStackDocument, GetUserMiStackFetcher, GetUserMiStackGQL, GetUserPhoneDocument, GetUserPhoneGQL, GetUserPhoneNumbersDocument, GetUserPhoneNumbersGQL, GetUserPreferredTransportHubsDocument, GetUserPreferredTransportHubsFetcher, GetUserPreferredTransportHubsGQL, GetUserRecentBoltSearchesDocument, GetUserRecentBoltSearchesGQL, GetUserRecentSearchesDocument, GetUserRecentSearchesFetcher, GetUserRecentSearchesGQL, GetUserServicesDocument, GetUserServicesGQL, GetUserSharedBasketsDocument, GetUserSharedBasketsFetcher, GetUserSharedBasketsGQL, GetUserUiConfigsDocument, GetUserUiConfigsGQL, GmtItineraryAirportOptionFragmentFragmentDoc, GmtItineraryEurostarOptionFragmentFragmentDoc, GmtItineraryRailStationOptioFragmentFragmentDoc, GroupedFieldsFragmentDoc, HelpInfoFragmentDoc, HelperRoutines, HotelAvalibilityQuoteFetcher, HotelAvalibilityService, HotelQuoteFetcher, HotelStaticTagDisplay, HttpCallService, HttpCancelInterceptor, HttpCancelService, InvokedUserFieldsFragmentDoc, IrlClass, IrlJourneyType, IrlSupplier, IrlTravellerStatus, IsPostcodeValidDocument, IsPostcodeValidGQL, ItineraryEmailTo, LeadPassengerType, LocationType, Location_DetailFragmentDoc, LogLevelType, LogonService, LoungeQuoteFetcher, LoungesInfoFragmentDoc, ManagementInfoDefaultValuePrepopulation, ManagementInfoFieldFragmentDoc, ManagementInfoScope, ManagementInfoSpecialValueSource, ManagementInfoUiPresentation, ManagementInfoValueFieldFragmentDoc, ManagementInfoValueHandling, MarkupFareType, MarkupFlightCabinClass, MarkupFlightSpecialFares, MeetingRoomCatering, MeetingRoomDuration, MeetingRoomEquipment, MeetingRoomLayout, MemoizePipe, MessageTarget, MessageType, MessagesService, ModalOpenerService, MoveItemToADifferentBasketDocument, MoveItemToADifferentBasketGQL, OBTServicesModule, OBTproviders, OfficeFieldsFragmentDoc, OwnerFieldsFragmentDoc, OysterCardsInfoFragmentDoc, ParkingQuoteFetcher, ParkingStationFragmentDoc, PassengerInputType, PassengerType, PaymentMethodFieldsFragmentDoc, PaymentMethodWithCardFieldsFragmentDoc, PhoneType, PlaceCategory, PreferenceKey, ProfileConfigOption, PromptUpdateService, RailAccountsListFragmentDoc, RailCallingPointsFragmentDoc, RailClass, RailFareProcessingService, RailJourneyFareFragmentDoc, RailJourneyOptionFragmentDoc, RailQuoteFetcher, RailResultsStateService, RailSearchComposition, RailSearchJourneyType, RailSeatInfoFragmentDoc, RailSeatPreferenceTypeFragmentDoc, RailSegmentFieldsFragmentDoc, RailStationClassification, RailStoppingPattern, RailTicketFieldsFragmentDoc, RailTicketOptionFieldsFragmentDoc, RailTicketQueueListFragmentDoc, RedirectApproverFetcher, RemoveFavouriteUserDocument, RemoveFavouriteUserGQL, RemoveFavouriteUserUpdater, RemoveItemFromBasketDocument, RemoveItemFromBasketGQL, RemoveItemFromBasketUpdater, RemovePreferredTransportHubDocument, RemovePreferredTransportHubGQL, RemovePreferredTransportHubUpdater, RemoveRedirectApproverDocument, RemoveRedirectApproverGQL, RemoveRedirectApproverUpdater, ResendApproverEmailDocument, ResendApproverEmailFetcher, ResendApproverEmailGQL, ReserveRailSeatsDocument, ReserveRailSeatsGQL, ReserveRailSeatsUpdater, ResultAwareService, RevalidateBasketDocument, RevalidateBasketGQL, RevalidateBasketUpdater, RiskLevel, RoomAvaliabilityFragmentDoc, RouteHappyService, SaveFavouriteSearchDocument, SaveFavouriteSearchGQL, SaveFavouriteSearchUpdater, SaveRecentBoltSearchDocument, SaveRecentBoltSearchGQL, SaveRecentBoltSearchUpdater, SaveRecentSearchDocument, SaveRecentSearchGQL, SaveRecentSearchUpdater, SaveUserAddressDocument, SaveUserAddressGQL, SaveUserAddressUpdater, SearchAirlinesDocument, SearchAirlinesFetcher, SearchAirlinesGQL, SearchAirportsDocument, SearchAirportsFetcher, SearchAirportsGQL, SearchCabHireDocument, SearchCabHireGQL, SearchCarHireDocument, SearchCarHireGQL, SearchCitiesDocument, SearchCitiesGQL, SearchCityFetcher, SearchCompanyApproversDocument, SearchCompanyApproversFetcher, SearchCompanyApproversGQL, SearchCompanyUsersDocument, SearchCompanyUsersFetcher, SearchCompanyUsersGQL, SearchDepotFetcher, SearchDiscoverLocationDocument, SearchDiscoverLocationFetcher, SearchDiscoverLocationGQL, SearchDocumentValidationService, SearchEurostarDocument, SearchEurostarGQL, SearchFastTrackDocument, SearchFastTrackGQL, SearchFlightsV2Document, SearchFlightsV2GQL, SearchGeoLocationDocument, SearchGeoLocationFetcher, SearchGeoLocationGQL, SearchHotelChainsDocument, SearchHotelChainsFetcher, SearchHotelChainsGQL, SearchHotelsDocument, SearchHotelsGQL, SearchIrlDocument, SearchIrlGQL, SearchIrlStationsFetcher, SearchIrlSupplierStationsDocument, SearchIrlSupplierStationsGQL, SearchLoungesDocument, SearchLoungesGQL, SearchMIAutoSuggestValuesFetcher, SearchMiAutoSuggestValuesDocument, SearchMiAutoSuggestValuesGQL, SearchParkingDocument, SearchParkingGQL, SearchPaymentValidationService, SearchPostcodeFetcher, SearchPostcodesDocument, SearchPostcodesGQL, SearchRailDocument, SearchRailGQL, SearchRailInwardDocument, SearchRailInwardFetcher, SearchRailInwardGQL, SearchRailStationsDocument, SearchRailStationsFetcher, SearchRailStationsGQL, SearchUserAddressDocument, SearchUserAddressGQL, SearchUserCanBookForDocument, SearchUserCanBookForGQL, SearchUserWithEmailDocument, SearchUserWithEmailFetcher, SearchUserWithEmailGQL, SearchUsersCanBookForFetcher, SeasonTicketCardType, SeasonTicketClassType, SeasonTicketDeliveryType, SeasonTicketLondonUnderground, SeasonTicketType, SelectBasketApproverDocument, SelectBasketApproverGQL, SelectBasketApproverUpdater, SelectBasketMultiLevelApproversDocument, SelectBasketMultiLevelApproversGQL, SelectBasketMultiLevelApproversUpdater, SelectBasketNotifyApproverDocument, SelectBasketNotifyApproverGQL, SelectBasketNotifyApproverUpdater, SendBackToQueueDocument, SendBackToQueueGQL, SendBackToQueueUpdater, SendOfflineNotificationDocument, SendOfflineNotificationFetcher, SendOfflineNotificationGQL, ServiceMinimalFieldsFragmentDoc, ServiceType, SetBasketItemApexxTokenDocument, SetBasketItemApexxTokenGQL, SetBasketItemApexxTokenUpdater, SetBasketItemLeadPassengerDocument, SetBasketItemLeadPassengerGQL, SetBasketItemPaymentMethodDocument, SetBasketItemPaymentMethodGQL, SetEmptyUserMIDefaultValueUpdater, SetEmptyUserMiDefaultValueDocument, SetEmptyUserMiDefaultValueGQL, SetMIValuesUpdater, SetMiValuesDocument, SetMiValuesGQL, SetPaymentOptionUpdater, SetPreferredTransportHubDocument, SetPreferredTransportHubGQL, SetPreferredTransportHubUpdater, SetUserLanguageDocument, SetUserLanguageGQL, SetUserMIDefaultValueUpdater, SetUserMiDefaultValueDocument, SetUserMiDefaultValueGQL, ShareBasketDocument, ShareBasketGQL, ShareBasketUpdater, ShoppingInfoFragmentDoc, SmartCardsInfoFragmentDoc, SplitRailJourneyFareFragmentDoc, StorageService, SuggestPlacesDocument, SuggestPlacesFetcher, SuggestPlacesGQL, TicketOfficeInfoFragmentDoc, TicketQueueService, TicketType, TimeType, ToiletsBabyInfoFragmentDoc, TrainlineTenantIsFrenchDocument, TrainlineTenantIsFrenchFetcher, TrainlineTenantIsFrenchGQL, TransportType, TravellerGuestsFieldsFragmentDoc, TravellerUserFieldsFragmentDoc, UiConfigTarget, UpdateBasketNotesDocument, UpdateBasketNotesGQL, UpdateBasketTitleDocument, UpdateBasketTitleGQL, UpdateDOBUpdater, UpdateDobDocument, UpdateDobGQL, UpdateExchangeBasketDocument, UpdateExchangeBasketGQL, UpdateExchangeBasketUpdater, UpdateFlightSeatMapDocument, UpdateFlightSeatMapGQL, UpdateFlightSeatMapUpdater, UserApproversFieldsFragmentDoc, UserFieldsFragmentDoc, UserMessagesFetcher, UserMiFragmentDoc, UserMinimalFieldsFragmentDoc, UserProductsFetcher, UserService, UserSummaryFieldsFragmentDoc, UserUiConfigsFetcher, UsersFragmentDoc, ValidateBasketItemMiDocument, ValidateBasketItemMiFetcher, ValidateBasketItemMiGQL, ValidateBasketMiDocument, ValidateBasketMiFetcher, ValidateBasketMiGQL, VehicleType, WebTokenService, WifiInfoFragmentDoc, WithSubscriptionComponent };
+export { AcceptNewPriceDocument, AcceptNewPriceGQL, AcceptNewPriceUpdater, AcceptProcessTermsDocument, AcceptProcessTermsGQL, AccessibilityInfoFragmentDoc, AddBasketItemCustomRemarkDocument, AddBasketItemCustomRemarkGQL, AddBasketItemCustomRemarkUpdater, AddBasketItemMarkupDocument, AddBasketItemMarkupGQL, AddBasketItemMarkupUpdater, AddFavouriteUserDocument, AddFavouriteUserGQL, AddFavouriteUserUpdater, AddGuestToBasketItemUpdater, AddGuestsToBasketItemDocument, AddGuestsToBasketItemGQL, AddItemToBasketDocument, AddItemToBasketGQL, AddItemToBasketUpdater, AddRedirectApproverDocument, AddRedirectApproverGQL, AddRedirectApproverUpdater, AddToBasketFieldsFragmentDoc, AddUpdatedItemToBasketDocument, AddUpdatedItemToBasketGQL, AddUpdatedItemToBasketUpdater, AddUserToBasketItemUpdater, AddUsersToBasketItemDocument, AddUsersToBasketItemGQL, AddressType, AmendBookingDocument, AmendBookingGQL, AmendBookingUpdater, ApexxCardStatus, ApexxCreateCardDocument, ApexxCreateCardGQL, ApexxDeleteCardDocument, ApexxDeleteCardGQL, ApexxDeleteCardUpdater, ApexxListCardsDocument, ApexxListCardsGQL, ApexxUpdateCardDocument, ApexxUpdateCardGQL, ApexxUpdateCardUpdater, ApplyJitFlightRulesDocument, ApplyJitFlightRulesGQL, ApplyJitHotelRulesDocument, ApplyJitHotelRulesGQL, ApprovalEventType, ApproverUserFieldsFragmentDoc, AuthHttpService, BaggageType, BannerDisplayTarget, BasketFieldsFragmentDoc, BasketItemStatus, BasketMinimalFieldsFragmentDoc, BasketPanelComponent, BasketStatus, BeforeAmendCabSearchDocument, BeforeAmendCabSearchFetcher, BeforeAmendCabSearchGQL, BeforeAmendCarHireSearchDocument, BeforeAmendCarHireSearchFetcher, BeforeAmendCarHireSearchGQL, BookBasketDocument, BookBasketFieldsFragmentDoc, BookBasketGQL, BookBasketUpdater, BookerType, CabHireVehicleType, CabhireQuoteFetcher, CanAmendBookingDocument, CanAmendBookingFetcher, CanAmendBookingGQL, CancelBookingDocument, CancelBookingGQL, CancelBookingUpdater, CarHireAvailabilityDetailFetcher, CarHireAvailabilityDetailRequestDocument, CarHireAvailabilityDetailRequestGQL, CarHireClass, CarHireTransmission, CarHireType, CarbonPolicyDuration, CarbonPolicySource, CarhireQuoteFetcher, ChangeBasketOwnershipDocument, ChangeBasketOwnershipGQL, ChangeBasketOwnershipUpdater, ChangeMode, ChatbotCarHireSearchService, ChatbotEurostarSearchService, ChatbotFlightSearchService, ChatbotHotelSearchService, ChatbotRailSearchService, ChatbotSearchDispatcherService, ChatbotService, ChatbotTaxiSearchService, CheckForDuplicateBookingsDocument, CheckForDuplicateBookingsFetcher, CheckForDuplicateBookingsGQL, CheckIfBasketRequiresApprovalDocument, CheckIfBasketRequiresApprovalFetcher, CheckIfBasketRequiresApprovalGQL, CompanyType, ConfirmMessagesDocument, ConfirmMessagesGQL, ConvertCurrencyDocument, ConvertCurrencyFetcher, ConvertCurrencyGQL, CreateBasketDocument, CreateBasketFieldsFragmentDoc, CreateBasketFromDraftDocument, CreateBasketFromDraftGQL, CreateBasketFromDraftUpdater, CreateBasketGQL, CreateBasketNoteDocument, CreateBasketNoteGQL, CreateBasketNoteUpdater, CreateBasketUpdater, CreateGuestDocument, CreateGuestGQL, CreateGuestUpdater, CreateItineraryExchangeDocument, CreateItineraryExchangeGQL, CurrencyCode, CycleInfoFragmentDoc, DeleteAllRecentSearchesDocument, DeleteAllRecentSearchesGQL, DeleteAllRecentSearchesUpdater, DeleteBasketDocument, DeleteBasketGQL, DeleteBasketUpdater, DeleteFavouriteSearchDocument, DeleteFavouriteSearchGQL, DeleteFavouriteSearchUpdater, DeleteGuestDocument, DeleteGuestGQL, DeleteGuestUpdater, DeleteRecentSearchDocument, DeleteRecentSearchGQL, DeleteUserAddressDocument, DeleteUserAddressGQL, DiscountType, DistanceTypes, DivisionFieldsFragmentDoc, DocGender, DocType, DownloadETicketDocument, DownloadETicketFetcher, DownloadETicketGQL, DraftBasketType, EditUserAddressDocument, EditUserAddressGQL, EditUserAddressUpdater, EditUserDocument, EditUserGQL, EmailAmbulanceBookingFetcher, EmailAmbulanceBookingReqDocument, EmailAmbulanceBookingReqGQL, EmailApartmentBookingFetcher, EmailApartmentBookingReqDocument, EmailApartmentBookingReqGQL, EmailBasketDocument, EmailBasketFetcher, EmailBasketGQL, EmailFerryBookingFetcher, EmailFerryBookingReqDocument, EmailFerryBookingReqGQL, EmailMeetingRoomBookingFetcher, EmailMeetingRoomBookingReqDocument, EmailMeetingRoomBookingReqGQL, EmailSeasonTicketBookingFetcher, EmailSeasonTicketBookingReqDocument, EmailSeasonTicketBookingReqGQL, EntLocationsByCityDocument, EntLocationsByCityGQL, EntLocationsByPostcodeDocument, EntLocationsByPostcodeGQL, EnterpriseBasketService, EnterpriseMyBookingsService, EnterpriseSearchService, Environment, ErrorsFragmentDoc, EurostarQuoteFetcher, EventMessenager, EvolviSeatmapsAreEnabledDocument, EvolviSeatmapsAreEnabledGQL, ExchangeType, ExternalHttpService, FailedEmail, FareRuleType, FareType, FerryOrEurotunnel, FlightCabinClass, FlightItineraryFieldsFragmentDoc, FlightPassengerType, FlightQuoteFetcher, GenerateBasketPdfDocument, GenerateBasketPdfFetcher, GenerateBasketPdfGQL, GetAirAvailabilityDocument, GetAirAvailabilityFetcher, GetAirAvailabilityGQL, GetAllAirlinesDocument, GetAllAirlinesFetcher, GetAllAirlinesGQL, GetApexxListCardsFetcher, GetBannerDocument, GetBannerFetcher, GetBannerGQL, GetBasketApprovalInfoDocument, GetBasketApprovalInfoFetcher, GetBasketApprovalInfoGQL, GetBasketApprovalTimestampsDocument, GetBasketApprovalTimestampsGQL, GetBasketCo2InfoFetcher, GetBasketFetcher, GetBasketItemCustomRemarksDocument, GetBasketItemCustomRemarksFetcher, GetBasketItemCustomRemarksGQL, GetBasketNotesDocument, GetBasketNotesFetcher, GetBasketNotesGQL, GetBasketQuoteDocument, GetBasketQuoteFetcher, GetBasketQuoteGQL, GetBrandedFaresDocument, GetBrandedFaresGQL, GetCancellationInfoDocument, GetCancellationInfoFetcher, GetCancellationInfoGQL, GetCarHireDepotsDocument, GetCarHireDepotsGQL, GetCarHireProvidersDocument, GetCarHireProvidersFetcher, GetCarHireProvidersGQL, GetCompaniesDocument, GetCompaniesFetcher, GetCompaniesGQL, GetCompanyDocument, GetCompanyFetcher, GetCompanyGQL, GetConfermaQuicklistDocument, GetConfermaQuicklistGQL, GetConfermaRoomImagesDocument, GetConfermaRoomImagesGQL, GetCovidMicrositeTokenDocument, GetCovidMicrositeTokenFetcher, GetCovidMicrositeTokenGQL, GetCurrencyConversionRatesDocument, GetCurrencyConversionRatesFetcher, GetCurrencyConversionRatesGQL, GetDivisionDocument, GetDivisionGQL, GetDraftBasketsDocument, GetDraftBasketsFetcher, GetDraftBasketsGQL, GetEmptyUserMiDefaultValuesDocument, GetEmptyUserMiDefaultValuesFetcher, GetEmptyUserMiDefaultValuesGQL, GetEntLocationByPostcode, GetEvolviSeatmapsAreEnabledFetcher, GetFerryPortsDocument, GetFerryPortsFetcher, GetFerryPortsGQL, GetFlightAtNewClassDocument, GetFlightAtNewClassFetcher, GetFlightAtNewClassGQL, GetFlightBrandedFaresFetcher, GetFlightExchangeDetailsDocument, GetFlightExchangeDetailsFetcher, GetFlightExchangeDetailsGQL, GetFlightExtrasOptionsDocument, GetFlightExtrasOptionsFetcher, GetFlightExtrasOptionsGQL, GetFlightFareRulesDocument, GetFlightFareRulesFetcher, GetFlightFareRulesGQL, GetFlightSearchExchangeDocument, GetFlightSearchExchangeFetcher, GetFlightSearchExchangeGQL, GetFlightSeatMapDocument, GetFlightSeatMapFetcher, GetFlightSeatMapGQL, GetFlightUpsellOffersDocument, GetFlightUpsellOffersFetcher, GetFlightUpsellOffersGQL, GetGmtItineraryOptionsDocument, GetGmtItineraryOptionsFetcher, GetGmtItineraryOptionsGQL, GetGutCitySuggestionsDocument, GetGutCitySuggestionsFetcher, GetGutCitySuggestionsGQL, GetGutLocationSuggestionsDocument, GetGutLocationSuggestionsFetcher, GetGutLocationSuggestionsGQL, GetHotelChainsDocument, GetHotelChainsFetcher, GetHotelChainsGQL, GetHotelDetailsDocument, GetHotelDetailsFetcher, GetHotelDetailsGQL, GetIrlDiscountCardsDocument, GetIrlDiscountCardsGQL, GetIrlSupplierStationDocument, GetIrlSupplierStationFetcher, GetIrlSupplierStationGQL, GetJyrneyUrlDocument, GetJyrneyUrlFetcher, GetJyrneyUrlGQL, GetLatLonFromHereIdDocument, GetLatLonFromHereIdFetcher, GetLatLonFromHereIdGQL, GetLatestVersionsDocument, GetLatestVersionsFetcher, GetLatestVersionsGQL, GetMIApproversFetcher, GetMiApproversDocument, GetMiApproversGQL, GetMiRequiringMandatoryDefaultValueDocument, GetMiRequiringMandatoryDefaultValueFetcher, GetMiRequiringMandatoryDefaultValueGQL, GetMultipleHotelRatingDocument, GetMultipleHotelRatingFetcher, GetMultipleHotelRatingGQL, GetMultipleHotelsAvailabilityDocument, GetMultipleHotelsAvailabilityGQL, GetOfficeApproversDocument, GetOfficeApproversFetcher, GetOfficeApproversGQL, GetOfficeDivisionsDocument, GetOfficeDivisionsFetcher, GetOfficeDivisionsGQL, GetOfficeDocument, GetOfficeFetcher, GetOfficeGQL, GetOfficeUsersDocument, GetOfficeUsersFetcher, GetOfficeUsersGQL, GetOfficesDocument, GetOfficesFetcher, GetOfficesGQL, GetPriceHiddenSabreExchangeDocument, GetPriceHiddenSabreExchangeFetcher, GetPriceHiddenSabreExchangeGQL, GetProcessTermsPriceDocument, GetProcessTermsPriceGQL, GetRailcardsFetcher as GetRailCardsFetcher, GetRailLiveDeparturesDocument, GetRailLiveDeparturesFetcher, GetRailLiveDeparturesGQL, GetRailProvidersDocument, GetRailProvidersFetcher, GetRailProvidersGQL, GetRailSearchExchangeDocument, GetRailSearchExchangeGQL, GetRailStationDocument, GetRailStationFetcher, GetRailStationGQL, GetRailStationInfoDocument, GetRailStationInfoFetcher, GetRailStationInfoGQL, GetRailcardsDocument, GetRailcardsFetcher, GetRailcardsGQL, GetRedirectApproverDocument, RedirectApproverFetcher as GetRedirectApproverFetcher, GetRedirectApproverGQL, GetRequestedBookingUpdateDocument, GetRequestedBookingUpdateFetcher, GetRequestedBookingUpdateGQL, GetRiskAlertsDocument, GetRiskAlertsFetcher, GetRiskAlertsGQL, GetRouteHappyDocument, GetRouteHappyFetcher, GetRouteHappyGQL, SearchCompanyApproversFetcher as GetSearchCompanyApproversFetcher, GetServiceDocument, GetServiceFetcher, GetServiceGQL, GetTrainSeatMapDocument, GetTrainSeatMapEvolviDocument, GetTrainSeatMapEvolviGQL, GetTrainSeatMapGQL, GetTrainSeatmapEvolviFetcher, GetTrainSeatmapFetcher, GetTrainlineSearchConfigDocument, GetTrainlineSearchConfigFetcher, GetTrainlineSearchConfigGQL, GetUserAddressesDocument, GetUserAddressesGQL, GetUserApproversDocument, GetUserApproversFetcher, GetUserApproversGQL, GetUserBasketCo2InfoDocument, GetUserBasketCo2InfoGQL, GetUserBasketDocument, GetUserBasketGQL, GetUserBasketsDocument, GetUserBasketsFetcher, GetUserBasketsGQL, GetUserCarbonAllowanceDocument, GetUserCarbonAllowanceFetcher, GetUserCarbonAllowanceGQL, GetUserCompanyOfficesDocument, GetUserCompanyOfficesFetcher, GetUserCompanyOfficesGQL, GetUserCarbonAllowanceFetcher as GetUserCurrentCarbonAllowanceFetcher, GetUserDocument, GetUserDocumentLoyaltyDocument, GetUserDocumentLoyaltyFetcher, GetUserDocumentLoyaltyGQL, GetUserEmergencyContactDocument, GetUserEmergencyContactFetcher, GetUserEmergencyContactGQL, GetUserFavouriteSearchesDocument, GetUserFavouriteSearchesFetcher, GetUserFavouriteSearchesGQL, GetUserFavouriteUsersDocument, GetUserFavouriteUsersFetcher, GetUserFavouriteUsersGQL, GetUserFetcher, GetUserGQL, GetUserGuestsDocument, GetUserGuestsFetcher, GetUserGuestsGQL, GetUserMessagesDocument, GetUserMessagesGQL, GetUserMiDefaultValuesDocument, GetUserMiDefaultValuesFetcher, GetUserMiDefaultValuesGQL, GetUserMiDocument, GetUserMiFetcher, GetUserMiGQL, GetUserMiStackDocument, GetUserMiStackFetcher, GetUserMiStackGQL, GetUserPhoneDocument, GetUserPhoneGQL, GetUserPhoneNumbersDocument, GetUserPhoneNumbersGQL, GetUserPreferredTransportHubsDocument, GetUserPreferredTransportHubsFetcher, GetUserPreferredTransportHubsGQL, GetUserRecentBoltSearchesDocument, GetUserRecentBoltSearchesGQL, GetUserRecentSearchesDocument, GetUserRecentSearchesFetcher, GetUserRecentSearchesGQL, GetUserServicesDocument, GetUserServicesGQL, GetUserSharedBasketsDocument, GetUserSharedBasketsFetcher, GetUserSharedBasketsGQL, GetUserUiConfigsDocument, GetUserUiConfigsGQL, GmtItineraryAirportOptionFragmentFragmentDoc, GmtItineraryEurostarOptionFragmentFragmentDoc, GmtItineraryRailStationOptioFragmentFragmentDoc, GroupedFieldsFragmentDoc, HelpInfoFragmentDoc, HelperRoutines, HotelAvalibilityQuoteFetcher, HotelAvalibilityService, HotelQuoteFetcher, HotelStaticTagDisplay, HttpCallService, HttpCancelInterceptor, HttpCancelService, InvokedUserFieldsFragmentDoc, IrlClass, IrlJourneyType, IrlSupplier, IrlTravellerStatus, IsPostcodeValidDocument, IsPostcodeValidGQL, ItineraryEmailTo, LeadPassengerType, LocationType, Location_DetailFragmentDoc, LogLevelType, LogonService, LoungeQuoteFetcher, LoungesInfoFragmentDoc, ManagementInfoDefaultValuePrepopulation, ManagementInfoFieldFragmentDoc, ManagementInfoScope, ManagementInfoSpecialValueSource, ManagementInfoUiPresentation, ManagementInfoValueFieldFragmentDoc, ManagementInfoValueHandling, MarkupFareType, MarkupFlightCabinClass, MarkupFlightSpecialFares, MeetingRoomCatering, MeetingRoomDuration, MeetingRoomEquipment, MeetingRoomLayout, MemoizePipe, MessageTarget, MessageType, MessagesService, ModalOpenerService, MoveItemToADifferentBasketDocument, MoveItemToADifferentBasketGQL, OBTServicesModule, OBTproviders, OfficeFieldsFragmentDoc, OwnerFieldsFragmentDoc, OysterCardsInfoFragmentDoc, ParkingQuoteFetcher, ParkingStationFragmentDoc, PassengerInputType, PassengerType, PaymentMethodFieldsFragmentDoc, PaymentMethodWithCardFieldsFragmentDoc, PhoneType, PlaceCategory, PreferenceKey, ProfileConfigOption, PromptUpdateService, RailAccountsListFragmentDoc, RailCallingPointsFragmentDoc, RailClass, RailFareProcessingService, RailJourneyFareFragmentDoc, RailJourneyOptionFragmentDoc, RailQuoteFetcher, RailResultsStateService, RailSearchComposition, RailSearchJourneyType, RailSeatInfoFragmentDoc, RailSeatPreferenceTypeFragmentDoc, RailSegmentFieldsFragmentDoc, RailStationClassification, RailStoppingPattern, RailTicketFieldsFragmentDoc, RailTicketOptionFieldsFragmentDoc, RailTicketQueueListFragmentDoc, RedirectApproverFetcher, RemoveFavouriteUserDocument, RemoveFavouriteUserGQL, RemoveFavouriteUserUpdater, RemoveItemFromBasketDocument, RemoveItemFromBasketGQL, RemoveItemFromBasketUpdater, RemovePreferredTransportHubDocument, RemovePreferredTransportHubGQL, RemovePreferredTransportHubUpdater, RemoveRedirectApproverDocument, RemoveRedirectApproverGQL, RemoveRedirectApproverUpdater, ResendApproverEmailDocument, ResendApproverEmailFetcher, ResendApproverEmailGQL, ReserveRailSeatsDocument, ReserveRailSeatsGQL, ReserveRailSeatsUpdater, ResultAwareService, RevalidateBasketDocument, RevalidateBasketGQL, RevalidateBasketUpdater, RiskLevel, RoomAvaliabilityFragmentDoc, RouteHappyService, SaveFavouriteSearchDocument, SaveFavouriteSearchGQL, SaveFavouriteSearchUpdater, SaveRecentBoltSearchDocument, SaveRecentBoltSearchGQL, SaveRecentBoltSearchUpdater, SaveRecentSearchDocument, SaveRecentSearchGQL, SaveRecentSearchUpdater, SaveUserAddressDocument, SaveUserAddressGQL, SaveUserAddressUpdater, SearchAirlinesDocument, SearchAirlinesFetcher, SearchAirlinesGQL, SearchAirportsDocument, SearchAirportsFetcher, SearchAirportsGQL, SearchCabHireDocument, SearchCabHireGQL, SearchCarHireDocument, SearchCarHireGQL, SearchCitiesDocument, SearchCitiesGQL, SearchCityFetcher, SearchCompanyApproversDocument, SearchCompanyApproversFetcher, SearchCompanyApproversGQL, SearchCompanyUsersDocument, SearchCompanyUsersFetcher, SearchCompanyUsersGQL, SearchDepotFetcher, SearchDiscoverLocationDocument, SearchDiscoverLocationFetcher, SearchDiscoverLocationGQL, SearchDocumentValidationService, SearchEurostarDocument, SearchEurostarGQL, SearchFastTrackDocument, SearchFastTrackGQL, SearchFlightsV2Document, SearchFlightsV2GQL, SearchGeoLocationDocument, SearchGeoLocationFetcher, SearchGeoLocationGQL, SearchHotelChainsDocument, SearchHotelChainsFetcher, SearchHotelChainsGQL, SearchHotelsDocument, SearchHotelsGQL, SearchIrlDocument, SearchIrlGQL, SearchIrlStationsFetcher, SearchIrlSupplierStationsDocument, SearchIrlSupplierStationsGQL, SearchLoungesDocument, SearchLoungesGQL, SearchMIAutoSuggestValuesFetcher, SearchMiAutoSuggestValuesDocument, SearchMiAutoSuggestValuesGQL, SearchParkingDocument, SearchParkingGQL, SearchPaymentValidationService, SearchPostcodeFetcher, SearchPostcodesDocument, SearchPostcodesGQL, SearchRailDocument, SearchRailGQL, SearchRailInwardDocument, SearchRailInwardFetcher, SearchRailInwardGQL, SearchRailStationsDocument, SearchRailStationsFetcher, SearchRailStationsGQL, SearchUserAddressDocument, SearchUserAddressGQL, SearchUserCanBookForDocument, SearchUserCanBookForGQL, SearchUserWithEmailDocument, SearchUserWithEmailFetcher, SearchUserWithEmailGQL, SearchUsersCanBookForFetcher, SeasonTicketCardType, SeasonTicketClassType, SeasonTicketDeliveryType, SeasonTicketLondonUnderground, SeasonTicketType, SelectBasketApproverDocument, SelectBasketApproverGQL, SelectBasketApproverUpdater, SelectBasketMultiLevelApproversDocument, SelectBasketMultiLevelApproversGQL, SelectBasketMultiLevelApproversUpdater, SelectBasketNotifyApproverDocument, SelectBasketNotifyApproverGQL, SelectBasketNotifyApproverUpdater, SendBackToQueueDocument, SendBackToQueueGQL, SendBackToQueueUpdater, SendOfflineNotificationDocument, SendOfflineNotificationFetcher, SendOfflineNotificationGQL, ServiceMinimalFieldsFragmentDoc, ServiceType, SetBasketItemApexxTokenDocument, SetBasketItemApexxTokenGQL, SetBasketItemApexxTokenUpdater, SetBasketItemLeadPassengerDocument, SetBasketItemLeadPassengerGQL, SetBasketItemPaymentMethodDocument, SetBasketItemPaymentMethodGQL, SetEmptyUserMIDefaultValueUpdater, SetEmptyUserMiDefaultValueDocument, SetEmptyUserMiDefaultValueGQL, SetMIValuesUpdater, SetMiValuesDocument, SetMiValuesGQL, SetPaymentOptionUpdater, SetPreferredTransportHubDocument, SetPreferredTransportHubGQL, SetPreferredTransportHubUpdater, SetUserLanguageDocument, SetUserLanguageGQL, SetUserMIDefaultValueUpdater, SetUserMiDefaultValueDocument, SetUserMiDefaultValueGQL, ShareBasketDocument, ShareBasketGQL, ShareBasketUpdater, ShoppingInfoFragmentDoc, SmartCardsInfoFragmentDoc, SplitRailJourneyFareFragmentDoc, StorageService, SuggestPlacesDocument, SuggestPlacesFetcher, SuggestPlacesGQL, TicketOfficeInfoFragmentDoc, TicketQueueService, TicketType, TimeType, ToiletsBabyInfoFragmentDoc, TrainlineTenantIsFrenchDocument, TrainlineTenantIsFrenchFetcher, TrainlineTenantIsFrenchGQL, TransportType, TravellerGuestsFieldsFragmentDoc, TravellerUserFieldsFragmentDoc, UiConfigTarget, UpdateBasketNotesDocument, UpdateBasketNotesGQL, UpdateBasketTitleDocument, UpdateBasketTitleGQL, UpdateDOBUpdater, UpdateDobDocument, UpdateDobGQL, UpdateExchangeBasketDocument, UpdateExchangeBasketGQL, UpdateExchangeBasketUpdater, UpdateFlightSeatMapDocument, UpdateFlightSeatMapGQL, UpdateFlightSeatMapUpdater, UserApproversFieldsFragmentDoc, UserFieldsFragmentDoc, UserMessagesFetcher, UserMiFragmentDoc, UserMinimalFieldsFragmentDoc, UserProductsFetcher, UserService, UserSummaryFieldsFragmentDoc, UserUiConfigsFetcher, UsersFragmentDoc, ValidateBasketItemMiDocument, ValidateBasketItemMiFetcher, ValidateBasketItemMiGQL, ValidateBasketMiDocument, ValidateBasketMiFetcher, ValidateBasketMiGQL, VehicleType, WebTokenService, WifiInfoFragmentDoc, WithSubscriptionComponent };
 //# sourceMappingURL=sabstravtech-obtservices-angular.mjs.map