@sabstravtech/obtservices 0.0.19020100 → 0.0.22041208

package/base/lib/vendor/classes/modal-types.enum.d.ts

@@ -5,6 +5,10 @@ export declare class ModalTypes {
     static readonly BaseModalComponent: ModalTypes;
     static readonly AutoLogout: ModalTypes;
     static readonly RiskAlertDetail: ModalTypes;
+    static readonly AlternativeRailModalComponent: ModalTypes;
+    static readonly WarningRemoveModalComponent: ModalTypes;
+    static readonly RailTicketsDialogComponent: ModalTypes;
+    static readonly ModalFlightFareComponent: ModalTypes;
     private _component;
     get component(): any;
     set component(value: any);

package/base/lib/vendor/classes/parking-enterprise-search.d.ts

@@ -1,9 +1,9 @@
-import { BehaviorSubject } from 'rxjs';
+import { BehaviorSubject, Observable } from 'rxjs';
 import moment from 'moment';
 import { BaseEnterpriseSearch } from './base-enterprise';
 import { BaseStorageService } from '../services/storage.service';
 import { BaseHelperRoutines } from './helpers';
-import { NgbDateStruct, OBTAirportDetails, ParkingQuoteResultArray, TerminalsType, ParkingFiltersInterface, RecentSearch } from '../types/types';
+import { NgbDateStruct, OBTAirportDetails, ParkingQuoteResultArray, TerminalsType, ParkingFiltersInterface, RecentSearch, SaveFavouriteSearchResult } from '../types/types';
 import { BasketItem, ParkingQuote, SaveRecentSearchMutationVariables, SearchParkingQueryVariables, ServiceType } from '../types/graphql.types';
 import { BaseParkingQuoteFetcher, ParkingQuoteFetcherType } from '../fetchers/parking-quote-fetcher';
 import { EnterpriseBasketServiceInterface } from '../interfaces/Ienterprise-basket.service';
@@ -18,7 +18,6 @@ export declare const defaultValidations: {
 };
 export declare class ParkingEnterpriseSearch<Q extends ParkingQuoteFetcherType> extends BaseEnterpriseSearch<ParkingTempParams, ParkingQuoteResultArray, ParkingQuoteResultArray> implements ParkingEnterpriseSearchInterface {
     private parkingfetcher;
-    private helpers;
     private basketService;
     private searchService;
     static readonly STORAGE_SESSION_PARAMS = "search_parking";
@@ -100,5 +99,10 @@ export declare class ParkingEnterpriseSearch<Q extends ParkingQuoteFetcherType>
     sortByPrice(asc?: boolean): void;
     updateFromPreviousSearches(previousItems: Record<ServiceType, BasketItem>): void;
     addParkingToBasket(parkingQuote: ParkingQuote, parkingQuery: SearchParkingQueryVariables): Promise<boolean>;
+    getTermsAndCond(parkingQuote: ParkingQuote): {
+        name: string;
+        value: any;
+    }[];
     updateLowestPrice(results: ParkingQuote[]): ICheapestPrice;
+    saveSearch(): Observable<SaveFavouriteSearchResult>;
 }

package/base/lib/vendor/classes/rail-direction.enum.d.ts

@@ -1,4 +1,4 @@
 export declare enum RailDirection {
-    Outbound = "out",
-    Inbound = "in"
+    Outbound = "outbound",
+    Inbound = "inbound"
 }

package/base/lib/vendor/classes/rail-enterprise-search.d.ts

@@ -3,33 +3,55 @@ import { Observable, BehaviorSubject } from 'rxjs';
 import { BaseEnterpriseSearch } from './base-enterprise';
 import { BaseStorageService } from '../services/storage.service';
 import { BaseHelperRoutines } from './helpers';
-import { RailTicketGroups } from '../interfaces/rail-ticket-groups.interface';
-import { RailTicketGroup, TicketGroups } from '../interfaces/rail-ticket-group.interface';
 import { ValueDisplay } from '../interfaces/value-display';
-import { NgbDateStruct, RailQuoteResultArray, RecentSearch, RecursivePartial } from '../types/types';
-import { BasketItem, RailClass, RailJourneyOption, RailJourneyOptions, RailJourneyType, RailSegment, RailStation, RailTicketOption, ReferenceRailCardQualifier, SaveRecentSearchMutationVariables, SearchRailQueryVariables, ServiceType, RailTicketExtra } from '../types/graphql.types';
+import { CheapestRailClassPrices, CheapestRailPrices, NgbDateStruct, OBTRailFareTypes, OBTRailJourneyFare, OBTRailJourneyOption, OBTRailQuoteResultArray, RecentSearch, SaveFavouriteSearchResult } from '../types/types';
+import { BasketItem, RailClass, RailJourneyOption, ReferenceRailCardQualifier, SaveRecentSearchMutationVariables, SearchRailQueryVariables, ServiceType, RailTicketExtra, RailSearchJourneyType, RailJourneyFare, RailStation, RailJourneyLeg } from '../types/graphql.types';
 import { BaseRailQuoteFetcher, RailQuoteFetcherType } from '../fetchers/rail-quote-fetcher';
 import { BaseGetRailStationFetcher, GetRailStationFetcherType } from '../fetchers/get-rail-station.fetcher';
 import { EnterpriseBasketServiceInterface } from '../interfaces/Ienterprise-basket.service';
 import { EnterpriseSearchServiceInterface } from '../interfaces/Isearch.service';
+import { UserServiceInterface } from '../interfaces/Iuser.service';
 import { RailEnterpriseSearchInterface, RailTempParams } from '../interfaces/Irail-enterprise-search';
 import { ICheapestPrice } from '../interfaces/cheapest-price';
 import { IRailAirportExpressStations } from '../interfaces/rail-airport-express-stations.interface';
 import { TicketExtras } from '../interfaces/rail-basket-item.interface';
+import { RailQuoteResultArray } from '../types/types';
+import { RailSummary } from '../interfaces/summary-interface';
+import { BaseModalOpenerService } from '../services/modal-opener.service';
+import { IRailSelectedTicket } from '../interfaces/rail-selected-ticket.interface';
+import { RailDirection } from './rail-direction.enum';
 export declare enum RailSearchCriteria {
     Depart = "Depart After",
     Arrive = "Arrive Before"
 }
-export declare enum RailTicketOptionType {
+export declare enum RailJourneyFareType {
     Return = "Return",
     Single = "Single"
 }
-export declare class RailEnterpriseSearch<Q extends RailQuoteFetcherType, GRS_Q extends GetRailStationFetcherType> extends BaseEnterpriseSearch<RailTempParams, RailQuoteResultArray, RailQuoteResultArray> implements RailEnterpriseSearchInterface {
+export declare class RailEnterpriseSearch<Q extends RailQuoteFetcherType, GRS_Q extends GetRailStationFetcherType> extends BaseEnterpriseSearch<RailTempParams, RailQuoteResultArray, OBTRailQuoteResultArray> implements RailEnterpriseSearchInterface {
     private Railfetcher;
     private getRailStationFetcher;
-    private helpers;
     private basketService;
     private searchService;
+    private userService;
+    private modalService;
+    private _selectedTicket;
+    private _selectedInboundTicket;
+    private _selectedSummary;
+    private _selectedInboundSummary;
+    private _selectedSection;
+    private alternativeWellbeing;
+    get selectedSection(): OBTRailFareTypes;
+    get selectedTicket(): {
+        journey: OBTRailJourneyOption;
+        fare: OBTRailJourneyFare;
+    };
+    set selectedTicket(selectedTicket: {
+        journey: OBTRailJourneyOption;
+        fare: OBTRailJourneyFare;
+    });
+    get selectedInboundTicket(): IRailSelectedTicket;
+    set selectedInboundTicket(selectedTicket: IRailSelectedTicket);
     static readonly STORAGE_SESSION_PARAMS = "search_rail";
     static readonly STORAGE_SESSION_RESULTS = "rail_results";
     static readonly PASSING_POINT = "Passing";
@@ -38,7 +60,7 @@ export declare class RailEnterpriseSearch<Q extends RailQuoteFetcherType, GRS_Q
     protected multiResultsSessionName: string;
     searchTypes: {
         display: string;
-        value: RailJourneyType;
+        value: RailSearchJourneyType;
     }[];
     classTypes: {
         display: string;
@@ -58,29 +80,27 @@ export declare class RailEnterpriseSearch<Q extends RailQuoteFetcherType, GRS_Q
     }[];
     removePassingPointsFromResults: boolean;
     type: ServiceType;
+    private _bookRailFromLive;
+    cheapest: BehaviorSubject<{
+        outboundCheapest: CheapestRailPrices;
+        inboundCheapest: CheapestRailPrices;
+        cheapestClassTicket: CheapestRailClassPrices;
+    }>;
+    get bookRailFromLive(): boolean;
+    set bookRailFromLive(value: boolean);
     minOutboundDate: NgbDateStruct;
     minInboundDate: NgbDateStruct;
     maxDate: NgbDateStruct;
     private _timeArray;
-    private _canCombine;
-    private _chosenOutboundTicket;
-    private _chosenInboundTicket;
-    private _chosenOutboundJourney;
-    private _chosenInboundJourney;
-    private _chosenTicketGroup;
     private _viaLocation;
     private _travellingFrom;
     private _travellingTo;
     protected _originalUserSearch: RailTempParams;
-    get chosenTicketGroup(): RailTicketGroup;
-    get chosenTotalPrice(): number;
-    get chosenTickets(): any;
-    get chosenOutboundJourney(): RecursivePartial<RailJourneyOption>;
-    get chosenInboundJourney(): RecursivePartial<RailJourneyOption>;
+    summary: RailSummary;
     get openReturn(): boolean;
     set openReturn(newVal: boolean);
-    get chosenSearchType(): RailJourneyType;
-    set chosenSearchType(newType: RailJourneyType);
+    get chosenSearchType(): RailSearchJourneyType;
+    set chosenSearchType(newType: RailSearchJourneyType);
     get noOfAdults(): number;
     set noOfAdults(adults: number);
     get noOfChildren(): number;
@@ -142,53 +162,62 @@ export declare class RailEnterpriseSearch<Q extends RailQuoteFetcherType, GRS_Q
         departureLocationId: string;
         arrivalLocationId: string;
     }): void;
-    private _cheapestStandard;
-    get cheapestStandard(): RailTicketOption;
-    private _cheapestFirst;
-    get cheapestFirst(): RailTicketOption;
-    constructor(Railfetcher: BaseRailQuoteFetcher<Q>, getRailStationFetcher: BaseGetRailStationFetcher<GRS_Q>, helpers: BaseHelperRoutines, basketService: EnterpriseBasketServiceInterface, storageService: BaseStorageService, searchService: EnterpriseSearchServiceInterface);
+    private _findSummary;
+    updateLowestPrice(results: OBTRailQuoteResultArray): ICheapestPrice;
+    constructor(Railfetcher: BaseRailQuoteFetcher<Q>, getRailStationFetcher: BaseGetRailStationFetcher<GRS_Q>, helpers: BaseHelperRoutines, basketService: EnterpriseBasketServiceInterface, storageService: BaseStorageService, searchService: EnterpriseSearchServiceInterface, userService: UserServiceInterface, modalService: BaseModalOpenerService);
+    protected processResults(rawResults: RailQuoteResultArray): OBTRailQuoteResultArray;
+    private makeFareNames;
+    private _makeFareNames;
+    private updatePrices;
+    selectTicket(direction: RailDirection, journey: OBTRailJourneyOption, railFare: OBTRailJourneyFare, sourceId: string, section: OBTRailFareTypes, wellbeing?: boolean): Promise<void>;
+    checkAlternativeHours(hourDifference: number, dayDifference: number): Promise<boolean>;
+    performAlternativeRailAndHotelSearch(): void;
+    selectTicketNoAdd(direction: RailDirection, journey: OBTRailJourneyOption, railFare: OBTRailJourneyFare, sourceId: string, section: OBTRailFareTypes): Promise<void>;
+    /**
+     * @description - add to basket for go2/scion
+     * @param sourceId
+     * @param searchQuery
+     * @param journey
+     * @param railFare
+     * @param inboundRailFare
+     * @param inboundJourney
+     * @returns
+     */
+    addToBasket(sourceId: string, searchQuery: RailTempParams, journey: OBTRailJourneyOption, railFare: OBTRailJourneyFare, inboundRailFare?: OBTRailJourneyFare, inboundJourney?: OBTRailJourneyOption): Promise<boolean>;
+    addOpenReturnToBasket(sourceId: string, searchQuery: RailTempParams, journey: OBTRailJourneyOption, railFare: OBTRailJourneyFare): Promise<void>;
+    addDualSingleToBasket(serviceId: string, searchQuery: RailTempParams, outbound: OBTRailJourneyOption, inbound: OBTRailJourneyOption, outboundFare: OBTRailJourneyFare, inboundFare: OBTRailJourneyFare): Promise<void>;
+    findCheapestTicket(): number;
     protected resetQuery(): void;
     private _setAirportExpressStations;
     private _isValid;
     startSearch(): Promise<boolean>;
     getRecentSearchQuery(query: SearchRailQueryVariables): SaveRecentSearchMutationVariables;
+    private updateSerchQuery;
     startRecentSearch(recentSearch: RecentSearch): void;
-    private _removeCallingPoints;
     private _updateOutboundDateTime;
     private _updateReturnDateTime;
-    getSearchQuery(): SearchRailQueryVariables;
-    private getRailStationById;
-    private getCriteria;
-    createTicketGroups(results: RailJourneyOptions[]): RailTicketGroups;
-    combineChildTickets(tickets: RailTicketGroups): RailTicketGroups;
-    setTicketsGroups(results: RailJourneyOption[]): TicketGroups;
+    getSearchQuery(tempParams: RailTempParams): SearchRailQueryVariables;
+    getCriteria(departureDateTime: string, arrivalDateTime: string): RailSearchCriteria;
     updateFromPreviousSearches(previousItems: Record<ServiceType, BasketItem>): void;
-    updateCanCombine(tkt: RailTicketOption): void;
-    toggleTicketSelect(ticket: RailTicketGroup, way: 'departs' | 'returns', timeSlotId: string, ticketId: string, fareIdentifier: string, ticketsGroups: RailTicketGroups): RailTicketGroups;
-    /**
-     * @description - determine if a fare can be combined with what we currently have selected
-     */
-    canCombine(journeyIdentifier: string, fareIdentifier: string): boolean;
-    clearUnneededTickets(way: string, group: RailTicketGroup, timeSlotId: string): RailTicketGroup;
     getRailStation(code: string, isLoading?: BehaviorSubject<boolean>): Observable<RailStation>;
-    getSelectedRailTicketOption(railJourneyOption: RailJourneyOption, railTicketGroup: RailTicketGroup, providerIndex: number): RailTicketOption;
-    getLegsFromRailJourneyOption(railJourneyOption: RailJourneyOption): any[];
-    addSingleJourneyToBasket(serviceId: string, railQuery: SearchRailQueryVariables, railJourneyOption: RailJourneyOption, railTicketGroup: RailTicketGroup): Promise<boolean>;
-    addReturnJourneyToBasket(serviceId: string, railQuery: SearchRailQueryVariables, outbound: RailJourneyOption, inbound: RailJourneyOption, railTicketGroup: RailTicketGroup): Promise<boolean>;
+    getSelectedRailJourneyFare(): RailJourneyFare;
+    getLegsFromRailJourneyOption(railJourneyOption: OBTRailJourneyOption): any[];
+    addSingleJourneyToBasket(serviceId: string, tempParams: RailTempParams, railJourneyOption: OBTRailJourneyOption, railFare: RailJourneyFare): Promise<void>;
+    addReturnJourneyToBasket(serviceId: string, tempParams: RailTempParams, outbound: OBTRailJourneyOption, inbound: OBTRailJourneyOption, outboundFare: RailJourneyFare, inboundFare: RailJourneyFare): Promise<boolean>;
+    removedScheduledPlatformFromCallingPoints(railLegs: RailJourneyLeg[]): RailJourneyLeg[];
     createTicketExtrasObject(railTicketExtra: RailTicketExtra): TicketExtras[];
-    sortTicketPrices(tickets: TicketGroups): TicketGroups;
-    sortTicketChildrenPrices(tickets: RailTicketGroups): RailTicketGroups;
-    updateLowestPrice(results: RailJourneyOptions[]): ICheapestPrice;
-    findCheapestTicket(results: RailJourneyOptions[]): number;
-    calculateTimeDifferenceInMins(railJourney: RailJourneyOption | RailSegment): string;
+    calculateTimeDifferenceInMins(railJourney: RailJourneyOption): string;
     /**
      * @description - determine if a ticket is an eTicket
      * @param ticket - the ticket we want to to check
      * @returns - boolean
      */
-    ticketIsAnETicket(ticket: RailTicketOption): boolean;
-    /**
-     * @description - clear all of our chosen tickets/other rail stuff, call this when kicking off a new search
-     */
-    clearChosenTickets(): void;
+    ticketIsAnETicket(): boolean;
+    applyFilter(): void;
+    protected _applyFilter(): void;
+    getTermsAndCond(outboundFare: RailJourneyFare, outbound: OBTRailJourneyOption, inbound?: OBTRailJourneyOption): {
+        name: string;
+        value: string;
+    }[];
+    saveSearch(): Observable<SaveFavouriteSearchResult>;
 }

package/base/lib/vendor/classes/rail-index-to-ticket.d.ts

@@ -0,0 +1,9 @@
+import { OBTRailJourneyFare } from '../types/types';
+export declare class RailIndexToTicket {
+    private data;
+    private current;
+    nextJourney(): void;
+    addFares(ticketName: string, ticketType: string, fares: OBTRailJourneyFare[]): void;
+    getTicketTypes(): Record<string, number>;
+    workoutIndexes(ticketName: string): string[][];
+}

package/base/lib/vendor/classes/supplementary-booking-info-impl.d.ts

@@ -55,6 +55,7 @@ export declare class SupplementaryBookingInfoImpl<Q extends SearchGetUserFetcher
     constructor(basketItem: BasketItem, helpers: BaseHelperRoutines, getUserFetcher: BaseGetUserFetcher<Q>);
     processSchema(schema: Schema): Schema;
     schemaWidgetToFormat(widget: string): SchemaFormat;
+    addRailFormat(key: string): SchemaFormat;
     schemaTypeToFormat(type: SchemaType): SchemaFormat;
     createSupplemtalBookingInformation(values: {
         [key: string]: any;

package/base/lib/vendor/classes/user-favourite.enum.d.ts

@@ -2,6 +2,9 @@ export declare class UserFavorurite {
     value: string;
     static MaxFlightClass: UserFavorurite;
     static SSO_no_password: UserFavorurite;
+    static HideFlightCabinClasses: UserFavorurite;
+    static AlternativeRailItineraryEnabled: UserFavorurite;
+    static riskMinimumLevel: UserFavorurite;
     constructor(value: string);
 }
 export declare class Suppliers {

package/base/lib/vendor/fetchers/apply-JIT-hotel-rules.fetcher.d.ts

@@ -0,0 +1,23 @@
+import { ApolloQueryResult, FetchResult } from '@apollo/client/core';
+import { BaseHelperRoutines } from '../classes/helpers';
+import { FetchableList } from './list-fetchable-enterprise';
+import { BaseModalOpenerService } from '../services/modal-opener.service';
+import { Observable } from 'rxjs';
+import { ApplyJitHotelRulesQuery, QueryApplyJitHotelRulesArgs } from '../types/graphql.types';
+declare type R = {
+    applyJITHotelRules: {
+        result: P;
+    };
+};
+declare type P = Object;
+declare type A = QueryApplyJitHotelRulesArgs;
+declare type M = ApplyJitHotelRulesQuery;
+export declare type ApplyHotelRulesFetcherType = {
+    fetch: (a: A) => Observable<ApolloQueryResult<M>>;
+};
+export declare class BaseHotelRulesFetcher<Q extends ApplyHotelRulesFetcherType> extends FetchableList<Q, A, R, P, M> {
+    constructor(gql: Q, helpers: BaseHelperRoutines, modalService: BaseModalOpenerService);
+    protected getDataFromResult(results: ApolloQueryResult<R>): P;
+    processCall(stream: Observable<FetchResult<{}, Record<string, any>, Record<string, any>>>): Observable<P>;
+}
+export {};

package/base/lib/vendor/fetchers/apply-jit-flight-rules.d.ts

@@ -0,0 +1,21 @@
+import { ApolloQueryResult } from '@apollo/client/core';
+import { BaseModalOpenerService } from '../services/modal-opener.service';
+import { Observable } from 'rxjs';
+import { ApplyJitFlightRulesQuery, ApplyJitFlightRulesQueryVariables } from '../types/graphql.types';
+import { FetchableObject } from './object-fetchable-enterprise';
+import { RuleActionSummaryInterface } from '../types/types';
+import { BaseHelperRoutines } from '../classes/helpers';
+declare type R = {
+    applyJITFlightRules: P;
+};
+declare type P = RuleActionSummaryInterface;
+declare type A = ApplyJitFlightRulesQueryVariables;
+declare type M = ApplyJitFlightRulesQuery;
+export declare type ApplyJitFlightRulesType = {
+    fetch: (a: A) => Observable<ApolloQueryResult<M>>;
+};
+export declare class BaseApplyJitFlightRulesFetcher<Q extends ApplyJitFlightRulesType> extends FetchableObject<Q, A, R, P, M> {
+    constructor(gql: Q, modalService: BaseModalOpenerService, helpers: BaseHelperRoutines);
+    protected getDataFromResult(results: ApolloQueryResult<R>): P;
+}
+export {};

package/base/lib/vendor/fetchers/basket-fetcher.d.ts

@@ -1,5 +1,6 @@
 import { ApolloQueryResult } from '@apollo/client/core';
 import { Observable } from 'rxjs';
+import { BaseHelperRoutines } from '../classes/helpers';
 import { BaseModalOpenerService } from '../services/modal-opener.service';
 import { GetUserBasketQuery, GetUserBasketQueryVariables } from '../types/graphql.types';
 import { GetUserBasketResult } from '../types/types';
@@ -14,7 +15,7 @@ export declare type GetBasketFetcherType = {
     fetch: (a: A) => Observable<ApolloQueryResult<M>>;
 };
 export declare class BaseGetBasketFetcher<Q extends GetBasketFetcherType> extends FetchableObject<Q, A, R, P, M> {
-    constructor(getBasketGQL: Q, modalService: BaseModalOpenerService);
+    constructor(getBasketGQL: Q, modalService: BaseModalOpenerService, helpers: BaseHelperRoutines);
     protected getDataFromResult(results: ApolloQueryResult<R>): P;
 }
 export {};

package/base/lib/vendor/fetchers/conferma-office.fetcher.d.ts

@@ -1,4 +1,5 @@
 import { ApolloQueryResult } from '@apollo/client/core';
+import { BaseHelperRoutines } from '../classes/helpers';
 import { BaseModalOpenerService } from '../services/modal-opener.service';
 import { Observable } from 'rxjs';
 import { ConfermaOfficeResult } from '../types/types';
@@ -14,7 +15,7 @@ export declare type ConfermaOfficeFetcherType = {
     fetch: (a: A) => Observable<ApolloQueryResult<M>>;
 };
 export declare class BaseConfermaOfficeFetcher<Q extends ConfermaOfficeFetcherType> extends FetchableObject<Q, A, R, P, M> {
-    constructor(getUserAddressGQL: Q, modalService: BaseModalOpenerService);
+    constructor(getUserAddressGQL: Q, modalService: BaseModalOpenerService, helpers: BaseHelperRoutines);
     protected getDataFromResult(results: ApolloQueryResult<R>): P;
 }
 export {};

package/base/lib/vendor/fetchers/flight-fare-rules.fetcher.d.ts

@@ -0,0 +1,21 @@
+import { ApolloQueryResult } from '@apollo/client/core';
+import { Observable } from 'rxjs';
+import { BaseHelperRoutines } from '../classes/helpers';
+import { BaseModalOpenerService } from '../services/modal-opener.service';
+import { GetFlightFareRulesQuery, GetFlightFareRulesQueryVariables } from '../types/graphql.types';
+import { GetFlightFareRulesResult } from '../types/types';
+import { FetchableList } from './list-fetchable-enterprise';
+declare type R = {
+    getFlightFareRules: P;
+};
+declare type P = GetFlightFareRulesResult;
+declare type A = GetFlightFareRulesQueryVariables;
+declare type M = GetFlightFareRulesQuery;
+export declare type GetFlightFareRulesType = {
+    fetch: (a: A) => Observable<ApolloQueryResult<M>>;
+};
+export declare class BaseGetFlightFareRulesFetcher<Q extends GetFlightFareRulesType> extends FetchableList<Q, A, R, P, M> {
+    constructor(getBasketGQL: Q, helpers: BaseHelperRoutines, modalService: BaseModalOpenerService);
+    protected getDataFromResult(results: ApolloQueryResult<R>): P;
+}
+export {};

package/base/lib/vendor/fetchers/flight-quote.fetcher.d.ts

@@ -3,11 +3,13 @@ import { BaseModalOpenerService } from '../services/modal-opener.service';
 import { BaseHelperRoutines } from '../classes/helpers';
 import { FetchableList } from './list-fetchable-enterprise';
 import { Observable } from 'rxjs';
-import { FlightAllQuoteResult } from '../types/types';
+import { FlightAllQuoteResult, RuleActionSummaryInterface } from '../types/types';
 import { SearchFlightsV2Query, SearchFlightsV2QueryVariables } from '../types/graphql.types';
+import { BaseEnvironment } from '../classes/enviroment';
 declare type R = {
     searchFlightsV2: {
         results: P;
+        ruleActionSummary: RuleActionSummaryInterface;
     };
 };
 declare type P = FlightAllQuoteResult;
@@ -17,7 +19,9 @@ export declare type FlightQuoteFetcherType = {
     fetch: (a: A) => Observable<ApolloQueryResult<M>>;
 };
 export declare class BaseFlightQuoteFetcher<Q extends FlightQuoteFetcherType> extends FetchableList<Q, A, R, P, M> {
-    constructor(gql: Q, helpers: BaseHelperRoutines, modalService: BaseModalOpenerService);
+    private environment;
+    constructor(gql: Q, helpers: BaseHelperRoutines, modalService: BaseModalOpenerService, environment: BaseEnvironment);
+    fetchList(queryArgs?: A): Observable<P>;
     protected getDataFromResult(results: ApolloQueryResult<R>): P;
 }
 export {};

package/base/lib/vendor/fetchers/get-conferma-room-images.fetcher.d.ts

@@ -0,0 +1,21 @@
+import { ApolloQueryResult } from '@apollo/client/core';
+import { BaseHelperRoutines } from '../classes/helpers';
+import { FetchableList } from './list-fetchable-enterprise';
+import { BaseModalOpenerService } from '../services/modal-opener.service';
+import { Observable } from 'rxjs';
+import { GetConfermaRoomImagesResultArray } from '../types/types';
+import { GetConfermaRoomImagesQuery, GetConfermaRoomImagesQueryVariables } from '../types/graphql.types';
+declare type R = {
+    getConfermaRoomImages: P;
+};
+declare type P = GetConfermaRoomImagesResultArray;
+declare type A = GetConfermaRoomImagesQueryVariables;
+declare type M = GetConfermaRoomImagesQuery;
+export declare type GetConfermaRoomImagesQuoteFetcherType = {
+    fetch: (a: A) => Observable<ApolloQueryResult<M>>;
+};
+export declare class BaseGetConfermaRoomImagesFetcher<Q extends GetConfermaRoomImagesQuoteFetcherType> extends FetchableList<Q, A, R, P, M> {
+    constructor(queryGQL: Q, helpers: BaseHelperRoutines, modalService: BaseModalOpenerService);
+    protected getDataFromResult(results: ApolloQueryResult<R>): P;
+}
+export {};

package/base/lib/vendor/fetchers/get-covid-microsite-token.fetcher.d.ts

@@ -0,0 +1,21 @@
+import { ApolloQueryResult } from '@apollo/client/core';
+import { BaseHelperRoutines } from '../classes/helpers';
+import { FetchableList } from './list-fetchable-enterprise';
+import { BaseModalOpenerService } from '../services/modal-opener.service';
+import { Observable } from 'rxjs';
+import { CovidMicrositeTokenResult } from '../types/types';
+import { GetCovidMicrositeTokenQuery, GetCovidMicrositeTokenQueryVariables } from '../types/graphql.types';
+declare type R = {
+    getCOVIDMicrositeToken: P;
+};
+declare type P = CovidMicrositeTokenResult;
+declare type A = GetCovidMicrositeTokenQueryVariables;
+declare type M = GetCovidMicrositeTokenQuery;
+export declare type GetCovidMicrositeTokenFetcherType = {
+    fetch: (a: A) => Observable<ApolloQueryResult<M>>;
+};
+export declare class BaseGetCovidMicrositeTokenFetcher<Q extends GetCovidMicrositeTokenFetcherType> extends FetchableList<Q, A, R, P, M> {
+    constructor(getCovidMicrositeTokenGQL: Q, helpers: BaseHelperRoutines, modalService: BaseModalOpenerService);
+    protected getDataFromResult(results: ApolloQueryResult<R>): P;
+}
+export {};

package/base/lib/vendor/fetchers/get-flight-seat-map-fetcher.d.ts

@@ -0,0 +1,21 @@
+import { ApolloQueryResult } from '@apollo/client/core';
+import { Observable } from 'rxjs';
+import { BaseHelperRoutines } from '../classes/helpers';
+import { BaseModalOpenerService } from '../services/modal-opener.service';
+import { GetFlightSeatMapQuery, GetFlightSeatMapQueryVariables } from '../types/graphql.types';
+import { GetFlightSeatMapResultArray } from '../types/types';
+import { FetchableList } from './list-fetchable-enterprise';
+declare type R = {
+    getFlightSeatMap: P;
+};
+declare type P = GetFlightSeatMapResultArray;
+declare type A = GetFlightSeatMapQueryVariables;
+declare type M = GetFlightSeatMapQuery;
+export declare type GetFlightSeatMapType = {
+    fetch: (a: A) => Observable<ApolloQueryResult<M>>;
+};
+export declare class BaseGetFlightSeatMapFetcher<Q extends GetFlightSeatMapType> extends FetchableList<Q, A, R, P, M> {
+    constructor(getBasketGQL: Q, helpers: BaseHelperRoutines, modalService: BaseModalOpenerService);
+    protected getDataFromResult(results: ApolloQueryResult<R>): P;
+}
+export {};

package/base/lib/vendor/fetchers/get-rail-live-departures.fetcher.d.ts

@@ -0,0 +1,21 @@
+import { ApolloQueryResult } from '@apollo/client/core';
+import { BaseHelperRoutines } from '../classes/helpers';
+import { FetchableList } from './list-fetchable-enterprise';
+import { BaseModalOpenerService } from '../services/modal-opener.service';
+import { Observable } from 'rxjs';
+import { SearchRailLiveDeparturesResult } from '../types/types';
+import { GetRailLiveDeparturesQuery, GetRailLiveDeparturesQueryVariables } from '../types/graphql.types';
+declare type R = {
+    getRailLiveDepartures: P;
+};
+declare type P = SearchRailLiveDeparturesResult;
+declare type A = GetRailLiveDeparturesQueryVariables;
+declare type M = GetRailLiveDeparturesQuery;
+export declare type GetRailLiveDeparturesFetcherType = {
+    fetch: (a: A) => Observable<ApolloQueryResult<M>>;
+};
+export declare class BaseGetRailLiveDeparturesFetcher<Q extends GetRailLiveDeparturesFetcherType> extends FetchableList<Q, A, R, P, M> {
+    constructor(gql: Q, helpers: BaseHelperRoutines, modalService: BaseModalOpenerService);
+    protected getDataFromResult(results: ApolloQueryResult<R>): P;
+}
+export {};

package/base/lib/vendor/fetchers/get-user-favourite-searches.fetcher.d.ts

@@ -0,0 +1,21 @@
+import { ApolloQueryResult } from '@apollo/client/core';
+import { Observable } from 'rxjs';
+import { BaseHelperRoutines } from '../classes/helpers';
+import { BaseModalOpenerService } from '../services/modal-opener.service';
+import { GetUserFavouriteSearchesQuery, GetUserFavouriteSearchesQueryVariables } from '../types/graphql.types';
+import { GetUserFavouriteSearchesResultArray } from '../types/types';
+import { FetchableList } from './list-fetchable-enterprise';
+declare type R = {
+    getUserFavouriteSearches: P;
+};
+declare type P = GetUserFavouriteSearchesResultArray;
+declare type A = GetUserFavouriteSearchesQueryVariables;
+declare type M = GetUserFavouriteSearchesQuery;
+export declare type GetUserFavouriteSearchesFetcherType = {
+    fetch: (a: A) => Observable<ApolloQueryResult<M>>;
+};
+export declare class BaseGetUserFavouriteSearchesFetcher<Q extends GetUserFavouriteSearchesFetcherType> extends FetchableList<Q, A, R, P, M> {
+    constructor(getUserFavouriteSearchesGQL: Q, helpers: BaseHelperRoutines, modalService: BaseModalOpenerService);
+    protected getDataFromResult(results: ApolloQueryResult<R>): P;
+}
+export {};

package/base/lib/vendor/fetchers/irl-discount-card-fetcher.d.ts

@@ -0,0 +1,21 @@
+import { ApolloQueryResult } from '@apollo/client/core';
+import { BaseHelperRoutines } from '../classes/helpers';
+import { FetchableList } from './list-fetchable-enterprise';
+import { BaseModalOpenerService } from '../services/modal-opener.service';
+import { Observable } from 'rxjs';
+import { IrlDiscountCardArray } from '../types/types';
+import { GetIrlDiscountCardsQuery, GetIrlDiscountCardsQueryVariables } from '../types/graphql.types';
+declare type R = {
+    getIRLDiscountCards: P;
+};
+declare type P = IrlDiscountCardArray;
+declare type A = GetIrlDiscountCardsQueryVariables;
+declare type M = GetIrlDiscountCardsQuery;
+export declare type IrlDiscountCardFetcherType = {
+    fetch: (a: A) => Observable<ApolloQueryResult<M>>;
+};
+export declare class BaseIrlDiscountCardFetcher<Q extends IrlDiscountCardFetcherType> extends FetchableList<Q, A, R, P, M> {
+    constructor(gql: Q, helpers: BaseHelperRoutines, modalService: BaseModalOpenerService);
+    protected getDataFromResult(results: ApolloQueryResult<R>): P;
+}
+export {};

package/base/lib/vendor/fetchers/list-fetchable-enterprise.d.ts

@@ -14,7 +14,7 @@ export declare abstract class FetchableList<Q extends {
     fetchKeyedObject(fieldToIndexOn: string, queryArgs?: A): Observable<{
         [key: string]: Unpacked<P>;
     }>;
-    fetchKeyedObjectArray(fieldToIndexOn: string, queryArgs?: A): Observable<{
+    fetchKeyedObjectArray(fieldToIndexOn: keyof Unpacked<P>, queryArgs?: A): Observable<{
         [key: string]: Unpacked<P>[];
     }>;
 }

package/base/lib/vendor/fetchers/object-fetchable-enterprise.d.ts

@@ -2,10 +2,12 @@ import { Observable } from 'rxjs';
 import { BaseModalOpenerService } from '../services/modal-opener.service';
 import { BaseNetworkCall } from '../classes/base-network-call';
 import { ApolloQueryResult } from '@apollo/client/core';
+import { BaseHelperRoutines } from '../classes/helpers';
 export declare abstract class FetchableObject<Q extends {
     fetch: (a: A) => Observable<ApolloQueryResult<M>>;
 }, A, R, P, M> extends BaseNetworkCall<Q, A, R, P> {
     private query;
-    constructor(query: Q, modalService: BaseModalOpenerService);
+    private helpers;
+    constructor(query: Q, modalService: BaseModalOpenerService, helpers: BaseHelperRoutines);
     fetchOne(queryArgs?: A): Observable<P>;
 }

package/base/lib/vendor/fetchers/search-airlines.fetcher.d.ts

@@ -4,6 +4,7 @@ import { BaseModalOpenerService } from '../services/modal-opener.service';
 import { Observable } from 'rxjs';
 import { AirlinesSearchResultArray } from '../types/types';
 import { SearchAirlinesQuery, SearchAirlinesQueryVariables } from '../types/graphql.types';
+import { BaseHelperRoutines } from '../classes/helpers';
 declare type R = {
     searchAirlines: P;
 };
@@ -14,7 +15,7 @@ export declare type SearchAirlinesQuoteFetcherType = {
     fetch: (a: A) => Observable<ApolloQueryResult<M>>;
 };
 export declare class BaseSearchAirlinesFetcher<Q extends SearchAirlinesQuoteFetcherType> extends FetchableObject<Q, A, R, P, M> {
-    constructor(query: Q, modalService: BaseModalOpenerService);
+    constructor(query: Q, modalService: BaseModalOpenerService, helpers: BaseHelperRoutines);
     protected getDataFromResult(results: ApolloQueryResult<R>): P;
 }
 export {};

package/base/lib/vendor/fetchers/search-airports-fetcher.d.ts

@@ -4,6 +4,7 @@ import { BaseModalOpenerService } from '../services/modal-opener.service';
 import { Observable } from 'rxjs';
 import { AirportSearchResultsArray } from '../types/types';
 import { SearchAirportsQuery, SearchAirportsQueryVariables } from '../types/graphql.types';
+import { BaseHelperRoutines } from '../classes/helpers';
 declare type R = {
     searchAirports: P;
 };
@@ -14,7 +15,7 @@ export declare type SearchAirportsQuoteFetcherType = {
     fetch: (a: A) => Observable<ApolloQueryResult<M>>;
 };
 export declare class BaseSearchAirportsFetcher<Q extends SearchAirportsQuoteFetcherType> extends FetchableObject<Q, A, R, P, M> {
-    constructor(query: Q, modalService: BaseModalOpenerService);
+    constructor(query: Q, modalService: BaseModalOpenerService, helpers: BaseHelperRoutines);
     protected getDataFromResult(results: ApolloQueryResult<R>): P;
 }
 export {};

package/base/lib/vendor/fetchers/search-conferma-cities.fetcher.d.ts

@@ -4,6 +4,7 @@ import { BaseModalOpenerService } from '../services/modal-opener.service';
 import { Observable } from 'rxjs';
 import { SearchConfermaCitiesResultArray } from '../types/types';
 import { SearchConfermaCitiesQuery, SearchConfermaCitiesQueryVariables } from '../types/graphql.types';
+import { BaseHelperRoutines } from '../classes/helpers';
 declare type R = {
     searchConfermaCities: P;
 };
@@ -14,7 +15,7 @@ export declare type SearchConfermaCitiesQuoteFetcherType = {
     fetch: (a: A) => Observable<ApolloQueryResult<M>>;
 };
 export declare class BaseSearchConfermaCityFetcher<Q extends SearchConfermaCitiesQuoteFetcherType> extends FetchableObject<Q, A, R, P, M> {
-    constructor(queryGQL: Q, modalService: BaseModalOpenerService);
+    constructor(queryGQL: Q, modalService: BaseModalOpenerService, helpers: BaseHelperRoutines);
     protected getDataFromResult(results: ApolloQueryResult<R>): P;
 }
 export {};