@sabstravtech/obtservices 0.2.2605201100 → 0.2.2606091200

package/angular/lib/vendor/services/chatbot-eurostar-search.service.d.ts

@@ -0,0 +1,38 @@
+import { ChatSearchParameters, ChatbotTravelHandler } from '@sabstravtech/obtservices/base';
+import { ChatbotService } from './chatbot.service';
+import { EnterpriseSearchService } from './search.service';
+import { UserService } from './user.service';
+import * as i0 from "@angular/core";
+/**
+ * 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}.
+ */
+export declare class ChatbotEurostarSearchService implements ChatbotTravelHandler {
+    private chatbotService;
+    private searchService;
+    private userService;
+    readonly travelType: "eurostar";
+    private resultsSubscription;
+    constructor(chatbotService: ChatbotService, searchService: EnterpriseSearchService, userService: UserService);
+    handle(parameters: ChatSearchParameters, autoSearch: boolean): Promise<void>;
+    private runSearch;
+    /**
+     * Render OBT's validationMessages array as a chatbot reply. Single message →
+     * inline sentence; multiple → bullet list so each issue reads clearly.
+     */
+    private formatValidationMessages;
+    private subscribeToResults;
+    private extractItems;
+    private buildCard;
+    private populateEurostarParams;
+    private mapCabinClass;
+    private resolveStation;
+    private normalizeTime;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ChatbotEurostarSearchService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ChatbotEurostarSearchService>;
+}

package/angular/lib/vendor/services/chatbot-flight-search.service.d.ts

@@ -0,0 +1,100 @@
+import { ChatSearchParameters, ChatbotTravelHandler } from '@sabstravtech/obtservices/base';
+import { ChatbotService } from './chatbot.service';
+import { EnterpriseSearchService } from './search.service';
+import { ResultAwareService } from './result-aware.service';
+import { UserService } from './user.service';
+import * as i0 from "@angular/core";
+/**
+ * Handles chatbot-driven flight searches. Registered with
+ * `ChatbotSearchDispatcherService`; not used directly.
+ *
+ * Populates the flight search state from the chatbot's parameters (same state
+ * the search form binds to via ngModel) and runs `startSearch()` headlessly
+ * so chatbot flight searches work from any page. Once results arrive, builds
+ * `ChatFlightResultCard`s and patches them onto the last assistant message
+ * via {@link ChatbotService.patchAssistantMessage}.
+ */
+export declare class ChatbotFlightSearchService implements ChatbotTravelHandler {
+    private chatbotService;
+    private searchService;
+    private resultAwareService;
+    private userService;
+    readonly travelType: "flight";
+    private resultsSubscription;
+    constructor(chatbotService: ChatbotService, searchService: EnterpriseSearchService, resultAwareService: ResultAwareService, userService: UserService);
+    handle(parameters: ChatSearchParameters, autoSearch: boolean): Promise<void>;
+    private subscribeToFlightResults;
+    private buildFlightResults;
+    /**
+     * Builds a map keyed by an itinerary's flight-number signature to all
+     * bookable fare variants (cabin/brand/price) for the same physical flights.
+     * For combined-return journeys the key includes both outbound + inbound
+     * flight numbers; for dual-single legs it's just that leg's numbers.
+     */
+    private indexFaresByFlights;
+    private flightSignature;
+    private toFareTicket;
+    /**
+     * Builds chat cards for a multi-city itinerary. OBT returns one bundle per
+     * search with per-leg result arrays; we surface the top N itineraries by
+     * pairing the i-th cheapest option from every leg into a single "stacked"
+     * card. This is naive (it doesn't try every combinatorial combination) but
+     * gives the user a useful headline view; View Full Results owns the proper
+     * fare-combination picker.
+     *
+     * OBT returns multi-city itineraries as a single `bundle.journeys[]` where
+     * each entry has all legs concatenated in `outboundFlights[]`. We split each
+     * itinerary by leg-date to produce N `ChatFlightLeg`s per card.
+     */
+    private buildMultiCityFlightResults;
+    /**
+     * Split a concatenated multi-city flight list into per-leg buckets. Primary
+     * key is the flight's depart date matching a leg date; falls back to the
+     * latest leg whose date is on or before the flight (covers overnight
+     * connections that depart the day before the next leg's planned date).
+     */
+    private splitFlightsByLeg;
+    /** Build a `ChatFlightLeg` from the flights assigned to a single leg. */
+    private flightsToChatLeg;
+    private formatHHmm;
+    private formatDuration;
+    private toFlightCard;
+    private formatDate;
+    private formatCabinLabel;
+    /**
+     * Render OBT's validationMessages array as a chatbot reply. Single message →
+     * inline sentence; multiple → bullet list so each issue reads clearly.
+     */
+    private formatValidationMessages;
+    /**
+     * Tracks the last chatbot flight search's resolved airports so we can decide
+     * whether a follow-up turn is a "refinement of the same journey" (e.g. swap
+     * MAN → AMS for LPL → AMS — same metro, user is just nudging a parameter)
+     * or a "fresh search" (e.g. MAN → AMS to BER → ATH — clearly unrelated, so
+     * any sticky options like "direct only" should be cleared).
+     */
+    private lastSearch;
+    private static readonly NEARBY_AIRPORT_KM;
+    private static distanceKm;
+    private airportCoords;
+    /**
+     * Multi-city counterpart to `populateFlightParams`. Resolves each leg's
+     * origin/destination airports, builds the `IMultiDestination[]` shape the
+     * flight search expects, and switches `chosenSearchType` to multiCity.
+     * Same-journey detection is skipped (the user is describing a fundamentally
+     * new itinerary), so we always do a full reset.
+     */
+    private populateMultiCityFlightParams;
+    /**
+     * Apply the subset of `populateFlightParams` that is leg-agnostic (cabin
+     * class, passenger breakdown, sort, refundable flag). Shared between
+     * single/return and multi-city paths.
+     */
+    private applySharedFlightParams;
+    private populateFlightParams;
+    private mapCabinClass;
+    private normalizeTime;
+    private resolveAirport;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ChatbotFlightSearchService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ChatbotFlightSearchService>;
+}

package/angular/lib/vendor/services/chatbot-hotel-search.service.d.ts

@@ -0,0 +1,32 @@
+import { ChatSearchParameters, ChatbotTravelHandler } from '@sabstravtech/obtservices/base';
+import { ChatbotService } from './chatbot.service';
+import { EnterpriseSearchService } from './search.service';
+import { HotelAvalibilityService } from './hotel-avallibility.service';
+import { ResultAwareService } from './result-aware.service';
+import * as i0 from "@angular/core";
+/**
+ * Handles chatbot-driven hotel searches. Registered with
+ * `ChatbotSearchDispatcherService`; not used directly.
+ *
+ * Populates the hotel search state from the chatbot's parameters, runs the
+ * search headlessly, polls availability for the top candidates, then injects
+ * a `ChatHotelResults` message so the chat widget can render hotel cards.
+ * Works from any page — no search form component needs to be mounted.
+ */
+export declare class ChatbotHotelSearchService implements ChatbotTravelHandler {
+    private chatbotService;
+    private searchService;
+    private hotelAvalibilityService;
+    private resultAwareService;
+    readonly travelType: "hotel";
+    private availabilitySubscription;
+    constructor(chatbotService: ChatbotService, searchService: EnterpriseSearchService, hotelAvalibilityService: HotelAvalibilityService, resultAwareService: ResultAwareService);
+    handle(parameters: ChatSearchParameters, autoSearch: boolean): Promise<void>;
+    private runSearch;
+    private buildHotelCards;
+    private injectNoResultsMessage;
+    private sortHotels;
+    private populateHotelParams;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ChatbotHotelSearchService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ChatbotHotelSearchService>;
+}

package/angular/lib/vendor/services/chatbot-rail-search.service.d.ts

@@ -0,0 +1,53 @@
+import { ChatSearchParameters, ChatbotTravelHandler } from '@sabstravtech/obtservices/base';
+import { ChatbotService } from './chatbot.service';
+import { EnterpriseSearchService } from './search.service';
+import { ResultAwareService } from './result-aware.service';
+import { UserService } from './user.service';
+import * as i0 from "@angular/core";
+/**
+ * Handles chatbot-driven rail searches. Registered with
+ * `ChatbotSearchDispatcherService`; not used directly.
+ *
+ * Populates the rail search state from the chatbot's parameters (same state
+ * the search form binds to via ngModel) and runs `startSearch()` headlessly
+ * so chatbot rail searches work from any page. Once results arrive, builds
+ * `ChatRailResultCard`s and patches them onto the last assistant message
+ * via {@link ChatbotService.patchAssistantMessage}.
+ */
+export declare class ChatbotRailSearchService implements ChatbotTravelHandler {
+    private chatbotService;
+    private searchService;
+    private resultAwareService;
+    private userService;
+    readonly travelType: "rail";
+    private resultsSubscription;
+    constructor(chatbotService: ChatbotService, searchService: EnterpriseSearchService, resultAwareService: ResultAwareService, userService: UserService);
+    handle(parameters: ChatSearchParameters, autoSearch: boolean): Promise<void>;
+    /**
+     * Render OBT's validationMessages array as a chatbot reply. Single message →
+     * inline sentence; multiple → bullet list so each issue reads clearly.
+     */
+    private formatValidationMessages;
+    /**
+     * Subscribe to ResultAwareService for the next rail result emission, build
+     * the top-N cards per leg, then patch the last assistant message so the
+     * chat widget can render them.
+     */
+    private subscribeToRailResults;
+    private buildRailResults;
+    private buildInboundCards;
+    private toRailCard;
+    private formatDate;
+    private populateRailParams;
+    private normalizeTime;
+    private preferRailStation;
+    private resolveRailStation;
+    private lookupRailStations;
+    /**
+     * Generate progressively-cleaner name variants for rail station lookup.
+     * e.g. "Manchester (all stations)" → ["Manchester (all stations)", "Manchester", "Manchester all stations"]
+     */
+    private buildRailStationNameCandidates;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ChatbotRailSearchService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ChatbotRailSearchService>;
+}

package/angular/lib/vendor/services/chatbot-search-dispatcher.service.d.ts

@@ -0,0 +1,36 @@
+import { ChatSearchParameters } from '@sabstravtech/obtservices/base';
+import { ChatbotEurostarSearchService } from './chatbot-eurostar-search.service';
+import { ChatbotFlightSearchService } from './chatbot-flight-search.service';
+import { ChatbotRailSearchService } from './chatbot-rail-search.service';
+import { ChatbotHotelSearchService } from './chatbot-hotel-search.service';
+import { ChatbotService } from './chatbot.service';
+import * as i0 from "@angular/core";
+/**
+ * Routes `ChatbotService.fillSearchForm$` events to per-travel-type handlers.
+ *
+ * **To add a new travel type (hotel / eurostar / taxi / …):**
+ *  1. Create a new service implementing `ChatbotTravelHandler` (use
+ *     `ChatbotRailSearchService` or `ChatbotFlightSearchService` as a
+ *     reference implementation).
+ *  2. Inject it into this dispatcher and add it to {@link handlers}.
+ *  3. Nothing else needs to change — the consuming app calls {@link init}
+ *     once (typically from its root component's `ngOnInit`), and search
+ *     forms can ask {@link handles} which travel types to skip.
+ */
+export declare class ChatbotSearchDispatcherService {
+    private chatbotService;
+    private initialised;
+    private readonly handlers;
+    constructor(chatbotService: ChatbotService, rail: ChatbotRailSearchService, flight: ChatbotFlightSearchService, hotel: ChatbotHotelSearchService, eurostar: ChatbotEurostarSearchService);
+    /** Call once at app start. Idempotent. */
+    init(): void;
+    /**
+     * Whether a global handler is registered for the given travel type. Used by
+     * search forms to know which travel types they should skip (avoiding
+     * double-handling).
+     */
+    handles(travelType: ChatSearchParameters['travelType'] | undefined): boolean;
+    private findHandler;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ChatbotSearchDispatcherService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ChatbotSearchDispatcherService>;
+}

package/angular/lib/vendor/services/chatbot.service.d.ts

@@ -0,0 +1,72 @@
+import { OnDestroy } from '@angular/core';
+import { Subject } from 'rxjs';
+import { WebTokenService } from '../services/webtoken.service';
+import { Environment } from '../classes/environment';
+import { BaseChatbotService, BotFaq, ChatFeedbackAck, ChatMessage, ChatSearchParameters, ChatTokenEvent, ChatToolEvent, ChatWsResponse, CondensedResult, UserCapabilities, IRiskFlag } from '@sabstravtech/obtservices/base';
+import { ResultAwareService } from './result-aware.service';
+import { UserService } from './user.service';
+import * as i0 from "@angular/core";
+export declare class ChatbotService extends BaseChatbotService implements OnDestroy {
+    private webTokenService;
+    private resultAwareService;
+    private environment;
+    private userService;
+    private messagesSubject;
+    messages$: import("rxjs").Observable<ChatMessage[]>;
+    private loadingSubject;
+    loading$: import("rxjs").Observable<boolean>;
+    private searchingSubject;
+    searchingState$: import("rxjs").Observable<{
+        searching: boolean;
+        travelType?: string;
+    }>;
+    /** Back-compat boolean stream for callers that only care whether a search is in flight. */
+    searching$: import("rxjs").Observable<boolean>;
+    fillSearchForm$: Subject<{
+        parameters: ChatSearchParameters;
+        autoSearch: boolean;
+    }>;
+    private riskFlagSubject;
+    riskFlag$: import("rxjs").Observable<IRiskFlag>;
+    private faqsSubject;
+    faqs$: import("rxjs").Observable<BotFaq[]>;
+    private tokenEventsSubject;
+    tokenEvents$: import("rxjs").Observable<ChatTokenEvent>;
+    private toolEventsSubject;
+    toolEvents$: import("rxjs").Observable<ChatToolEvent>;
+    private feedbackAckSubject;
+    feedbackAck$: import("rxjs").Observable<ChatFeedbackAck>;
+    /** Tracks the user ID that owns the current chat session, to detect user switches. */
+    private sessionOwnerId;
+    private userChangeSubscription;
+    constructor(webTokenService: WebTokenService, resultAwareService: ResultAwareService, environment: Environment, userService: UserService);
+    ngOnDestroy(): void;
+    protected getRequestUrl(): string | null;
+    protected getAuthToken(): string | null;
+    protected notifyMessages(messages: ChatMessage[]): void;
+    protected notifyLoading(loading: boolean): void;
+    protected notifyFillForm(parameters: ChatSearchParameters, autoSearch: boolean): void;
+    protected notifyRiskFlag(flag: IRiskFlag): void;
+    protected notifyFaqs(faqs: BotFaq[]): void;
+    protected notifyToken(event: ChatTokenEvent): void;
+    protected notifyTool(event: ChatToolEvent): void;
+    protected notifyFeedbackAck(ack: ChatFeedbackAck): void;
+    protected hasResults(): boolean;
+    protected getCondensedResults(): CondensedResult[];
+    protected executeSelection(selectedIndex: number, returnSelectedIndex?: number): Promise<void>;
+    protected getSource(): string;
+    protected getUserCapabilities(): UserCapabilities;
+    connect(): void;
+    clearSession(): void;
+    injectMessage(message: ChatMessage): void;
+    protected handleResponse(env: ChatWsResponse): void;
+    /**
+     * Toggle the chatbot's "searching" indicator from a travel-type handler.
+     * @param travelType optional - lets the UI render a travel-aware label
+     *   (e.g. "Searching for flights…" vs "Searching for trains…").
+     */
+    setSearching(searching: boolean, travelType?: string): void;
+    patchAssistantMessage(patch: Partial<ChatMessage>): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ChatbotService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ChatbotService>;
+}

package/angular/lib/vendor/services/result-aware.service.d.ts

@@ -0,0 +1,68 @@
+import { Router } from '@angular/router';
+import { EnterpriseSearchService } from './search.service';
+import { EnterpriseBasketService } from './enterprise-basket.service';
+import { CondensedResult, ChatRailFareTicket } from '@sabstravtech/obtservices/base';
+import * as i0 from "@angular/core";
+export declare class ResultAwareService {
+    private searchService;
+    private basketService;
+    private router;
+    private condensedResults;
+    private rawResults;
+    private currentServiceType;
+    private railSourceId;
+    private railReturnJourneys;
+    private resultsAvailableSubject;
+    resultsAvailable$: import("rxjs").Observable<boolean>;
+    constructor(searchService: EnterpriseSearchService, basketService: EnterpriseBasketService, router: Router);
+    captureFlightResults(results: any[]): void;
+    captureRailResults(quoteResult: any): void;
+    captureHotelResults(results: any[]): void;
+    isHotelSearch(): boolean;
+    getCondensedResults(): CondensedResult[];
+    /**
+     * Returns the cheapest single and return fare prices for a raw outbound rail journey.
+     * Used by the chatbot fare panel to show per-category prices on card expand.
+     */
+    getRailJourneyFares(journeyIndex: number): {
+        singlePrice?: number;
+        returnPrice?: number;
+        singleTickets?: ChatRailFareTicket[];
+        returnTickets?: ChatRailFareTicket[];
+    };
+    /**
+     * Returns the cheapest single fare price and full ticket list for a raw inbound/return rail journey.
+     * Falls back to the other return-leg fare sections if no pure singles are available.
+     */
+    getRailReturnJourneyFares(journeyIndex: number): {
+        singlePrice?: number;
+        singleTickets?: ChatRailFareTicket[];
+    };
+    /**
+     * Open the existing OBT rail "View Conditions" dialog for a fare displayed in the chat.
+     */
+    openRailFareDetails(ticket: ChatRailFareTicket): Promise<void>;
+    private collectFareTickets;
+    hasResults(): boolean;
+    clearResults(): void;
+    executeSelection(selectedIndex: number, returnIndex?: number): Promise<void>;
+    private executeFlightSelection;
+    private condenseFlightResults;
+    private formatTime;
+    private formatDuration;
+    private computeRailDuration;
+    private executeRailSelection;
+    private findCheapestRailJourney;
+    private getCheapestRailFare;
+    private getMostExpensiveRailFare;
+    private condenseRailResults;
+    private derivePolicyStatus;
+    private derivePolicyMessages;
+    private getFirstCabinClassName;
+    private filterDownCompressedReturnRailOptions;
+    selectHotelRoom(hotelIndex: number, roomId: string): Promise<void>;
+    private executeHotelSelection;
+    private condenseHotelResults;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ResultAwareService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ResultAwareService>;
+}

package/angular/lib/vendor/types/graphql.angular.types.d.ts

@@ -3923,6 +3923,7 @@ export type ProcessTermsPriceResult = {
     __typename?: 'ProcessTermsPriceResult';
     amount: FieldWrapper<Scalars['String']['output']>;
     currency: FieldWrapper<Scalars['String']['output']>;
+    taxItemsWithoutCode: Array<FieldWrapper<ProcessTermsTaxItem>>;
 };
 export type ProcessTermsTaxItem = {
     __typename?: 'ProcessTermsTaxItem';
@@ -5841,6 +5842,7 @@ export type User = {
     admin?: Maybe<FieldWrapper<Scalars['Boolean']['output']>>;
     agentBooker: FieldWrapper<Scalars['Boolean']['output']>;
     agentId?: Maybe<FieldWrapper<Scalars['String']['output']>>;
+    aiTravelAssistantEnabled?: Maybe<FieldWrapper<Scalars['Boolean']['output']>>;
     approver: FieldWrapper<Scalars['Boolean']['output']>;
     authMethods: Array<FieldWrapper<Scalars['String']['output']>>;
     availableLanguages: Array<FieldWrapper<Language>>;
@@ -12590,6 +12592,7 @@ export type EditUserMutation = {
         canSeeBookingsOfOthers: boolean;
         becomeUser: boolean;
         canOverrideApproval: boolean;
+        aiTravelAssistantEnabled?: boolean | null;
         dob?: any | null;
         admin?: boolean | null;
         companyAdmin?: boolean | null;
@@ -18986,6 +18989,12 @@ export type GetProcessTermsPriceQuery = {
         __typename?: 'ProcessTermsPriceResult';
         amount: string;
         currency: string;
+        taxItemsWithoutCode: Array<{
+            __typename?: 'ProcessTermsTaxItem';
+            name: string;
+            amount: string;
+            currency: string;
+        }>;
     };
 };
 export type GetRailLiveDeparturesQueryVariables = Exact<{
@@ -35883,6 +35892,7 @@ export type UserFieldsFragment = {
     canSeeBookingsOfOthers: boolean;
     becomeUser: boolean;
     canOverrideApproval: boolean;
+    aiTravelAssistantEnabled?: boolean | null;
     dob?: any | null;
     admin?: boolean | null;
     companyAdmin?: boolean | null;
@@ -36160,6 +36170,7 @@ export type GetUserQuery = {
         canSeeBookingsOfOthers: boolean;
         becomeUser: boolean;
         canOverrideApproval: boolean;
+        aiTravelAssistantEnabled?: boolean | null;
         dob?: any | null;
         admin?: boolean | null;
         companyAdmin?: boolean | null;
@@ -37423,6 +37434,7 @@ export declare namespace GetProcessTermsPrice {
     type Variables = GetProcessTermsPriceQueryVariables;
     type Query = GetProcessTermsPriceQuery;
     type GetProcessTermsPrice = GetProcessTermsPriceQuery['getProcessTermsPrice'];
+    type TaxItemsWithoutCode = GetProcessTermsPriceQuery['getProcessTermsPrice']['taxItemsWithoutCode'][number];
 }
 export declare namespace GetRailLiveDepartures {
     type Variables = GetRailLiveDeparturesQueryVariables;

package/angular/services.d.ts

@@ -17,3 +17,10 @@ export * from './lib/vendor/services/rail-fare-processing.service';
 export * from './lib/vendor/services/rail-results-state.service';
 export * from './lib/vendor/services/search-document-validation.service';
 export * from './lib/vendor/services/search-payment-validation.service';
+export * from './lib/vendor/services/chatbot.service';
+export * from './lib/vendor/services/chatbot-rail-search.service';
+export * from './lib/vendor/services/chatbot-flight-search.service';
+export * from './lib/vendor/services/chatbot-hotel-search.service';
+export * from './lib/vendor/services/chatbot-eurostar-search.service';
+export * from './lib/vendor/services/chatbot-search-dispatcher.service';
+export * from './lib/vendor/services/result-aware.service';

package/base/interfaces.d.ts

@@ -28,6 +28,7 @@ export * from './lib/vendor/interfaces/terms-and-conditions.interface';
 export * from './lib/vendor/interfaces/rail-basket-item.interface';
 export * from './lib/vendor/interfaces/enable-fresh-chat-interface';
 export * from './lib/vendor/interfaces/Ifast-track-enterprise-search';
+export * from './lib/vendor/interfaces/chatbot.types';
 export * from './lib/vendor/interfaces/fast-track-filters.interface';
 export * from './lib/vendor/interfaces/Iferry-enterprise-search';
 export * from './lib/vendor/interfaces/Iapartment-enterprise-search';
@@ -38,3 +39,4 @@ export * from './lib/vendor/interfaces/Iseason-tickets-enterprise-search';
 export * from './lib/vendor/interfaces/hotel-stars-to-hide.interface';
 export * from './lib/vendor/interfaces/cheapest-price';
 export * from './lib/vendor/interfaces/cheapest-price-object';
+export * from './lib/vendor/interfaces/chatbot.types';