@sabstravtech/obtservices 0.2.2605201100 → 0.2.2606091200

package/base/lib/vendor/interfaces/chatbot.types.d.ts

@@ -0,0 +1,438 @@
+export type ChatConversationState = 'GREETING' | 'COLLECTING_PARAMS' | 'PARAMS_COMPLETE' | 'SEARCHING' | 'RESULTS_READY' | 'HANDED_OFF' | 'SELECTING_RESULT' | 'BLOCKED';
+/** A curated FAQ shown in the chat widget's browse-and-select view (no AI). */
+export interface BotFaq {
+    id: number;
+    question: string;
+    answer: string;
+}
+export interface CondensedResult {
+    index: number;
+    airline?: string;
+    operator?: string;
+    depart: string;
+    arrive: string;
+    stops: number;
+    duration: string;
+    price: number;
+    cabin?: string;
+    class?: string;
+    co2?: number;
+    policyStatus?: 'IN_POLICY' | 'ALLOW_WITH_REASON' | 'UNAVAILABLE';
+    policyMessages?: string[];
+    from?: string;
+    to?: string;
+    flightNumbers?: string;
+    fares?: {
+        cabin: string;
+        price: number;
+        bags: number;
+    }[];
+    inbound?: {
+        depart: string;
+        arrive: string;
+        stops: number;
+        duration: string;
+        flightNumbers?: string;
+    };
+    returnOptions?: {
+        index: number;
+        depart: string;
+        arrive: string;
+        stops: number;
+        duration: string;
+        price: number;
+        operator?: string;
+        co2?: number;
+        policyStatus?: 'IN_POLICY' | 'ALLOW_WITH_REASON' | 'UNAVAILABLE';
+    }[];
+    singleOrReturn?: string;
+    name?: string;
+    address?: string;
+    rating?: number;
+    distance?: number;
+    distanceUnit?: string;
+    pricePerNight?: number;
+}
+/** One leg of a multi-city flight itinerary, as supplied to chatbot flight search. */
+export interface ChatFlightSearchLeg {
+    departure: string;
+    arrival: string;
+    departureCode?: string;
+    arrivalCode?: string;
+    /** Travel date for this leg in YYYY-MM-DD format. */
+    date: string;
+    /** Optional preferred time in HH:mm. */
+    time?: string;
+    /** Optional Depart/Arrive criterion for this leg. */
+    timeCriteria?: 'Depart' | 'Arrive';
+}
+export interface ChatSearchParameters {
+    travelType: 'flight' | 'rail' | 'hotel' | 'eurostar' | 'taxi';
+    departure: string;
+    arrival: string;
+    departureCode?: string;
+    arrivalCode?: string;
+    departureDate: string;
+    departureTime?: string;
+    returnDate?: string;
+    returnTime?: string;
+    passengers: number;
+    /**
+     * Flight multi-city legs. When set with 2+ entries the search runs as
+     * multi-city (the top-level departure/arrival/date describe the first leg
+     * for back-compat). Each entry is one segment of the itinerary.
+     */
+    legs?: ChatFlightSearchLeg[];
+    /** Optional explicit journey type — usually inferred from legs/returnDate. */
+    journeyType?: 'single' | 'return' | 'multiCity';
+    rooms?: number;
+    hotelName?: string;
+    hotelChain?: string;
+    distance?: number;
+    preferredOnly?: boolean;
+    locationType?: 'address' | 'office' | 'shortlist' | 'airport' | 'trainstation';
+    crownRatesOnly?: boolean;
+    propertyNumber?: string;
+    country?: string;
+    cabinClass?: string;
+    maxConnections?: number;
+    outboundTimeCriteria?: 'Depart' | 'Arrive';
+    returnTimeCriteria?: 'Depart' | 'Arrive';
+    railClass?: 'Standard' | 'First' | 'All';
+    viaStation?: string;
+    viaCode?: string;
+    isAirportExpress?: boolean;
+    airportExpressRoute?: string;
+    children?: number;
+    /** Railcard codes to apply to this search (e.g. "YNG", "SRN", "FAM"). */
+    railcards?: string[];
+    airline?: string;
+    airlineCode?: string;
+    /** Sort field — values vary by travel type (flight: cheapest/fastest/shortest; hotel: cheapest/distance/preferred/name). */
+    sortType?: 'cheapest' | 'fastest' | 'shortest' | 'distance' | 'preferred' | 'name';
+    adults?: number;
+    infants?: number;
+    includeNearbyAirports?: boolean;
+    timeFlexibility?: number;
+    refundableOnly?: boolean;
+    via?: string;
+    vehicleType?: string;
+    pickupTerminal?: string;
+    pickupFlightNumber?: string;
+    dropoffTerminal?: string;
+    dropoffFlightNumber?: string;
+}
+export interface ChatRailFareTicket {
+    type: string;
+    classOfService?: string;
+    price: number;
+    currency: string;
+    /** Identifier needed to open the View Conditions dialog */
+    fareHash?: string;
+    /** Section the fare came from (e.g. singleJourneyFares) — needed to find the raw fare */
+    section?: string;
+    /** True if this ticket belongs to the inbound/return leg */
+    isReturnLeg?: boolean;
+    /** Index of the journey within rawResults / railReturnJourneys */
+    journeyIndex?: number;
+}
+export interface ChatRailFareSummary {
+    /** Cheapest single/one-way fare for this leg */
+    singlePrice?: number;
+    /** Cheapest return fare available (outbound only; absent for inbound cards) */
+    returnPrice?: number;
+    currency: string;
+    /** Full ticket list shown when a fare section is clicked, sorted cheapest first */
+    singleTickets?: ChatRailFareTicket[];
+    returnTickets?: ChatRailFareTicket[];
+}
+export interface ChatRailResultCard {
+    index: number;
+    departDate: string;
+    departTime: string;
+    arriveTime: string;
+    from: string;
+    to: string;
+    route: string;
+    duration: string;
+    changes: number;
+    fromPrice: number;
+    currency: string;
+    operator: string;
+    policyStatus?: 'IN_POLICY' | 'ALLOW_WITH_REASON' | 'UNAVAILABLE';
+    /** Fare breakdown shown when the card is expanded */
+    fares?: ChatRailFareSummary;
+}
+export interface ChatRailResults {
+    outbound: ChatRailResultCard[];
+    inbound?: ChatRailResultCard[];
+    isReturn: boolean;
+    parameters: ChatSearchParameters;
+}
+export interface ChatFlightLeg {
+    /** Departure airport code (e.g. "LHR") */
+    fromCode: string;
+    /** Departure airport display name */
+    fromName?: string;
+    /** Arrival airport code (e.g. "AMS") */
+    toCode: string;
+    /** Arrival airport display name */
+    toName?: string;
+    /** Date label e.g. "Wed 10 Jun 2026" */
+    departDate: string;
+    /** Time label e.g. "09:15" */
+    departTime: string;
+    /** Time label e.g. "11:42" */
+    arriveTime: string;
+    /** Duration label e.g. "2h 27m" */
+    duration: string;
+    /** 0 = direct, 1, 2+ */
+    stops: number;
+    /** Flight numbers joined e.g. "BA123/BA456" */
+    flightNumbers: string;
+}
+export interface ChatFlightFareTicket {
+    /** Display label, e.g. "Economy Saver", "Business Flex" */
+    type: string;
+    /** Cabin class group (Economy / PremiumEconomy / Business / First) */
+    cabin?: string;
+    /** Fare-brand name when present */
+    brand?: string;
+    price: number;
+    currency: string;
+    /** Index back into the underlying journeys array for select / navigate use */
+    journeyIndex?: number;
+}
+/** Flight fare breakdown for the expandable panel on a chat flight card. */
+export interface ChatFlightFareBreakdown {
+    /** All bookable fares for the same outbound (+ inbound) flights, sorted cheapest first. */
+    tickets: ChatFlightFareTicket[];
+    currency: string;
+}
+export interface ChatFlightResultCard {
+    index: number;
+    /** Airline display name (cheapest fare's marketing carrier) */
+    airline: string;
+    /** Airline IATA code, used to derive a logo url */
+    airlineCode?: string;
+    /** Outbound leg (always present for single/return; first leg for multi-city) */
+    outbound: ChatFlightLeg;
+    /** Inbound leg (present for return itineraries) */
+    inbound?: ChatFlightLeg;
+    /**
+     * Full list of legs for multi-city itineraries. When set the card should
+     * render these stacked instead of outbound/inbound. `outbound` still mirrors
+     * `legs[0]` for back-compat with consumers that only read outbound.
+     */
+    legs?: ChatFlightLeg[];
+    /** Cheapest fare price for the whole itinerary */
+    fromPrice: number;
+    currency: string;
+    /** Cabin class label e.g. "Economy" */
+    cabin: string;
+    policyStatus?: 'IN_POLICY' | 'ALLOW_WITH_REASON' | 'UNAVAILABLE';
+    /** Expandable fare-options panel data (cabin/brand variants for the same flights). */
+    fares?: ChatFlightFareBreakdown;
+}
+export interface ChatFlightResults {
+    outbound: ChatFlightResultCard[];
+    /**
+     * Separate inbound cards when the backend returned dual-singles (i.e. the
+     * outbound and inbound legs are priced + selectable independently). For
+     * combined-return itineraries the inbound info lives inside each outbound
+     * card's `.inbound` and this array is left empty.
+     */
+    inbound?: ChatFlightResultCard[];
+    isReturn: boolean;
+    /** True when the search was a multi-city (3+ leg) itinerary. */
+    isMultiCity?: boolean;
+    parameters: ChatSearchParameters;
+    /** How the results were sorted, used in the summary text */
+    sort?: 'cheapest' | 'fastest' | 'shortest';
+}
+export interface ChatHotelRoom {
+    roomId: string;
+    description: string;
+    total: number;
+    prpn: number;
+    currencyCode: string;
+    unavailable: boolean;
+    policyStatus?: 'IN_POLICY' | 'ALLOW_WITH_REASON' | 'UNAVAILABLE';
+}
+export interface ChatHotelResultCard {
+    index: number;
+    name: string;
+    address: string;
+    rating: number;
+    distance: number;
+    distanceUnit: string;
+    price: number;
+    pricePerNight: number;
+    dateRange: string;
+    policyStatus?: 'IN_POLICY' | 'ALLOW_WITH_REASON' | 'UNAVAILABLE';
+    policyMessages?: string[];
+    co2?: number;
+    currencyCode?: string;
+    rooms?: ChatHotelRoom[];
+}
+export interface ChatHotelResults {
+    cards: ChatHotelResultCard[];
+    searchHeader: string;
+    parameters: ChatSearchParameters;
+}
+export interface ChatEurostarFare {
+    class: string;
+    price: number;
+    currency: string;
+    policyStatus: CondensedResult['policyStatus'];
+    policyMessages: string[];
+    unavailable: boolean;
+}
+export interface ChatEurostarResultCard {
+    index: number;
+    timeDeparture: string;
+    timeArrival: string;
+    duration: string;
+    fares: ChatEurostarFare[];
+    co2PerPassenger: number;
+}
+export interface ChatEurostarResults {
+    outbound: ChatEurostarResultCard[];
+    inbound?: ChatEurostarResultCard[];
+    isReturn: boolean;
+    parameters: ChatSearchParameters;
+}
+export interface ChatSuggestion {
+    type: 'search_action' | 'select_action';
+    label: string;
+    action: 'FILL_FORM' | 'FILL_AND_SEARCH' | 'SELECT_RESULT';
+}
+export interface ChatRequest {
+    message: string;
+    sessionId?: string;
+    searchResults?: CondensedResult[];
+}
+export interface ChatResponse {
+    sessionId: string;
+    text: string;
+    intent: string | null;
+    parameters: ChatSearchParameters | null;
+    policyHints: string[];
+    suggestions: ChatSuggestion[];
+    state: ChatConversationState;
+    selectedIndex?: number;
+    returnSelectedIndex?: number;
+    alternativeIndex?: number;
+    action?: 'search' | 'select' | 'navigate';
+    riskFlag?: IRiskFlag | null;
+}
+export interface IRiskFlag {
+    level: string;
+    countryCode: string;
+    breaking: boolean;
+}
+export type ChatMessageRole = 'user' | 'assistant';
+export interface ChatMessage {
+    id: string;
+    role: ChatMessageRole;
+    text: string;
+    timestamp: Date;
+    parameters?: ChatSearchParameters | null;
+    policyHints?: string[];
+    suggestions?: ChatSuggestion[];
+    state?: ChatConversationState;
+    selectedIndex?: number;
+    returnSelectedIndex?: number;
+    alternativeIndex?: number;
+    action?: 'search' | 'select' | 'navigate';
+    riskFlag?: IRiskFlag | null;
+    railResults?: ChatRailResults;
+    flightResults?: ChatFlightResults;
+    hotelResults?: ChatHotelResults;
+    eurostarResults?: ChatEurostarResults;
+    searchResults?: CondensedResult[];
+    searchHeader?: string;
+}
+export interface UserCapabilities {
+    isCrown: boolean;
+    isAgent: boolean;
+    uiConfigs: {
+        hideHotelSearchOptions: boolean;
+    };
+}
+/**
+ * Travel-type-specific chatbot search handler. Implement one of these per
+ * travel type (rail, flight, hotel, eurostar, …) and register the service in
+ * `ChatbotSearchDispatcherService`'s constructor.
+ *
+ * The handler is responsible for:
+ *  1. Populating the corresponding `EnterpriseSearchService.searches[ServiceType.*]`
+ *     state from the chatbot parameters (the same fields the search form would
+ *     populate via two-way binding).
+ *  2. If `autoSearch` is true, kicking off the search and capturing results so
+ *     the chatbot can render its in-chat cards.
+ *
+ * Handlers run independently of any component being mounted so the chatbot
+ * works from any page in the consuming app.
+ */
+export interface ChatbotTravelHandler {
+    /** Travel type this handler accepts (matches `ChatSearchParameters.travelType`). */
+    readonly travelType: ChatSearchParameters['travelType'];
+    /** Populate search state and (if requested) run the search. */
+    handle(parameters: ChatSearchParameters, autoSearch: boolean): Promise<void>;
+}
+/**
+ * Source of the feedback signal — matches the values accepted by the
+ * request-handler chat:feedback gateway.
+ */
+export type ChatFeedbackSource = 'OBT' | 'App' | 'Portal' | 'Mobile' | 'Other';
+/**
+ * Reason chips offered after a positive (thumbs-up) rating. Shared between
+ * the web (lu-frontend) and mobile (new-ent-mobile-app) chat widgets so the
+ * recorded `chat_feedback.reason` strings stay consistent across surfaces.
+ */
+export declare const POSITIVE_FEEDBACK_REASONS: readonly string[];
+/** Reason chips offered after a negative (thumbs-down) rating. */
+export declare const NEGATIVE_FEEDBACK_REASONS: readonly string[];
+/** Convenience helper: returns the reason set for a given rating. */
+export declare function feedbackReasonsForRating(rating: 'up' | 'down' | undefined): readonly string[];
+/** Incremental LLM token chunk emitted while an assistant message is being generated. */
+export interface ChatTokenEvent {
+    sessionId: string;
+    token: string;
+    agent?: string;
+}
+/** Tool execution lifecycle event emitted during a turn. */
+export interface ChatToolEvent {
+    sessionId: string;
+    toolEvent: string;
+    name: string;
+}
+/** Single transcript entry attached to a `chat:feedback` emit. */
+export interface ChatFeedbackTranscriptEntry {
+    id?: string;
+    role: 'user' | 'assistant';
+    text: string;
+    timestamp?: string;
+}
+/**
+ * Optional context attached to `submitFeedback()` — comment, reason chip and
+ * the surrounding transcript snapshot so the analytics team has enough to
+ * action a thumbs-down without replaying the whole session.
+ */
+export interface ChatFeedbackExtras {
+    comment?: string;
+    reason?: string;
+    source?: ChatFeedbackSource;
+    userQuestion?: string;
+    assistantResponse?: string;
+    transcript?: ChatFeedbackTranscriptEntry[];
+}
+/** Server ack for a previously emitted `chat:feedback`. */
+export interface ChatFeedbackAck {
+    sessionId: string;
+    messageId?: string;
+    rating?: 'up' | 'down';
+    success: boolean;
+    error?: string;
+}

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

@@ -0,0 +1,145 @@
+import { Socket } from 'socket.io-client';
+import { BotFaq, ChatConversationState, ChatFeedbackAck, ChatFeedbackExtras, ChatFeedbackSource, ChatMessage, ChatResponse, ChatSearchParameters, ChatTokenEvent, ChatToolEvent, CondensedResult, IRiskFlag, UserCapabilities } from '../interfaces/chatbot.types';
+export interface ChatWsResponse {
+    sessionId: string;
+    message: string;
+    timestamp?: string;
+    parameters?: ChatSearchParameters | null;
+    results?: CondensedResult[];
+    suggestions?: ChatResponse['suggestions'];
+    actions?: ChatResponse['suggestions'];
+    policyHints?: string[];
+    state?: string;
+    selectedIndex?: number;
+    returnSelectedIndex?: number;
+    alternativeIndex?: number;
+    action?: ChatResponse['action'];
+    metadata?: {
+        confidence?: number;
+        vectorContext?: unknown;
+        interrupted?: boolean;
+        interruptData?: unknown;
+    };
+    riskFlag?: IRiskFlag;
+}
+/**
+ * Platform-agnostic chat-over-websocket service.
+ *
+ * Owns the socket.io connection, session/message/loading state, response
+ * mapping, and HITL approval resume flow. Subclasses adapt it to a host
+ * framework by implementing the platform hooks below.
+ *
+ * Used by:
+ *  - Angular `ChatbotService` (obtservices/angular) — pushes updates via RxJS
+ *    subjects and delegates result-selection to `ResultAwareService`.
+ *  - React Native `ChatbotService` (new-ent-mobile-app) — pushes updates via
+ *    callback arrays and handles selection through chatbot-navigation.service.
+ */
+export declare abstract class BaseChatbotService {
+    protected socket: Socket | null;
+    protected sessionId: string | null;
+    protected lastAssistantState: ChatConversationState | undefined;
+    protected messages: ChatMessage[];
+    protected loading: boolean;
+    private myBookingsBaseParams;
+    getMyBookingsBaseParams(): any;
+    setMyBookingsBaseParams(newParams: any): void;
+    /** Base URL of the request-handler (the GraphQL `requestURL` from env). */
+    protected abstract getRequestUrl(): string | null;
+    /** JWT to use for socket.io auth. Return null to abort connect. */
+    protected abstract getAuthToken(): string | null;
+    /** Push the latest messages array to the UI. */
+    protected abstract notifyMessages(messages: ChatMessage[]): void;
+    /** Push the loading flag to the UI. */
+    protected abstract notifyLoading(loading: boolean): void;
+    /** Push parsed search parameters to the host's search form. */
+    protected abstract notifyFillForm(parameters: ChatSearchParameters, autoSearch: boolean): void;
+    /** Notify the host that a risk flag was received. */
+    protected abstract notifyRiskFlag(flag: IRiskFlag): void;
+    /**
+     * Push the TMC's curated FAQ list (browse-and-select view) to the UI.
+     * Default no-op so platforms that don't surface the FAQ view (e.g. mobile)
+     * need not override it; the Angular host overrides to feed `faqs$`.
+     */
+    protected notifyFaqs(_faqs: BotFaq[]): void;
+    /**
+     * ENT-16247 — incoming token chunk for the in-flight assistant message.
+     * Default no-op; hosts that render token-by-token (web, mobile) override
+     * to fan out to their UI layer.
+     */
+    protected notifyToken(_event: ChatTokenEvent): void;
+    /** ENT-16247 — tool execution lifecycle event. Default no-op. */
+    protected notifyTool(_event: ChatToolEvent): void;
+    /** ENT-16247 — server ack for a previously emitted `chat:feedback`. Default no-op. */
+    protected notifyFeedbackAck(_ack: ChatFeedbackAck): void;
+    /** True when search results are in scope for selection. */
+    protected abstract hasResults(): boolean;
+    /** Returns the current search results (only called when hasResults()). */
+    protected abstract getCondensedResults(): CondensedResult[];
+    /**
+     * Selection requested by the assistant (action === 'select').
+     * Angular delegates to ResultAwareService; mobile is a no-op
+     * (chatbot-navigation handles selection on its own).
+     */
+    protected abstract executeSelection(selectedIndex: number, returnSelectedIndex?: number): Promise<void>;
+    /** Source tag included in the chat:message payload (e.g. 'web' | 'mobile'). */
+    protected abstract getSource(): string;
+    /**
+     * Optional user capabilities forwarded to the backend so the assistant can
+     * tailor responses (e.g. hide hotel-search options for restricted users).
+     * Subclasses may return undefined when capabilities aren't applicable.
+     */
+    protected getUserCapabilities(): UserCapabilities | undefined;
+    /**
+     * Source tag included in chat:feedback emits. Derived from getSource()
+     * (web → 'OBT', mobile → 'Mobile'); subclasses may override to send
+     * 'Portal', 'App', etc.
+     */
+    protected getFeedbackSource(): ChatFeedbackSource;
+    connect(): void;
+    disconnect(): void;
+    sendMessage(text: string): Promise<void>;
+    resume(approved: boolean): void;
+    /**
+     * ENT-16247 — submit thumbs up/down feedback for an assistant message.
+     * Reuses the already-authenticated /chat socket and the cached sessionId
+     * (refreshed on every chat:token / chat:response) so callers only need
+     * to pass the messageId + rating. Returns false if the socket isn't
+     * connected or there's no session yet (no-op rather than throw, to keep
+     * UI fire-and-forget friendly). The server replies on `chat:feedback-ack`,
+     * surfaced through `notifyFeedbackAck` to host-specific subjects/listeners.
+     */
+    submitFeedback(messageId: string, rating: 'up' | 'down', extras?: ChatFeedbackExtras): boolean;
+    /**
+     * Request the TMC's curated FAQ list for the browse-and-select view. Connects
+     * if needed; the list arrives via the `chat:faqs-response` handler → notifyFaqs.
+     */
+    requestFaqs(): void;
+    fillForm(parameters: ChatSearchParameters): void;
+    fillAndSearch(parameters: ChatSearchParameters): void;
+    clearSession(): void;
+    protected handleResponse(env: ChatWsResponse): void;
+    protected mapState(state: string | undefined): ChatConversationState | undefined;
+    protected shouldAttachSearchResults(): boolean;
+    protected addMessage(message: ChatMessage): void;
+    protected addAssistantMessage(text: string): void;
+    /** Patch the most recent assistant message in-place (e.g. to attach rail results after search). */
+    protected patchLastAssistantMessage(patch: Partial<ChatMessage>): void;
+    protected setLoading(value: boolean): void;
+    protected tearDownSocket(): void;
+    protected generateId(): string;
+    /**
+     * Derives socket.io connection config from the GraphQL `requestURL`.
+     * The request-handler base = requestURL with `/graphql` (or `/req`) stripped.
+     *
+     * Examples:
+     *   "/graphql"                                  → { url: "/chat",                          path: "/socket.io/" }
+     *   "/rqh/graphql"                              → { url: "/chat",                          path: "/rqh/socket.io/" }
+     *   "http://localhost:1234/rqh/graphql"         → { url: "http://localhost:1234/chat",     path: "/rqh/socket.io/" }
+     *   "https://api.example.com/req/"              → { url: "https://api.example.com/chat",   path: "/socket.io/" }
+     */
+    protected buildSocketConfig(requestURL: string): {
+        url: string;
+        path: string;
+    };
+}

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

@@ -3921,6 +3921,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';
@@ -5839,6 +5840,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>>;
@@ -12588,6 +12590,7 @@ export type EditUserMutation = {
         canSeeBookingsOfOthers: boolean;
         becomeUser: boolean;
         canOverrideApproval: boolean;
+        aiTravelAssistantEnabled?: boolean | null;
         dob?: any | null;
         admin?: boolean | null;
         companyAdmin?: boolean | null;
@@ -18984,6 +18987,12 @@ export type GetProcessTermsPriceQuery = {
         __typename?: 'ProcessTermsPriceResult';
         amount: string;
         currency: string;
+        taxItemsWithoutCode: Array<{
+            __typename?: 'ProcessTermsTaxItem';
+            name: string;
+            amount: string;
+            currency: string;
+        }>;
     };
 };
 export type GetRailLiveDeparturesQueryVariables = Exact<{
@@ -35881,6 +35890,7 @@ export type UserFieldsFragment = {
     canSeeBookingsOfOthers: boolean;
     becomeUser: boolean;
     canOverrideApproval: boolean;
+    aiTravelAssistantEnabled?: boolean | null;
     dob?: any | null;
     admin?: boolean | null;
     companyAdmin?: boolean | null;
@@ -36158,6 +36168,7 @@ export type GetUserQuery = {
         canSeeBookingsOfOthers: boolean;
         becomeUser: boolean;
         canOverrideApproval: boolean;
+        aiTravelAssistantEnabled?: boolean | null;
         dob?: any | null;
         admin?: boolean | null;
         companyAdmin?: boolean | null;
@@ -37421,6 +37432,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/base/services.d.ts

@@ -13,3 +13,4 @@ export * from './lib/vendor/services/routehappy.service';
 export * from './lib/vendor/services/requires-reason.service';
 export * from './lib/vendor/services/http-cancel.service';
 export * from './lib/vendor/services/messages.service';
+export * from './lib/vendor/services/chatbot.service';