@sabstravtech/obtservices 0.0.0 → 0.0.1

package/dist/obtservices/base/lib/vendor/interfaces/Iflight-enterprise-search.d.ts

@@ -0,0 +1,123 @@
+import moment from 'moment';
+import { BehaviorSubject } from 'rxjs';
+import { FlightFilters } from './flight-filters.interface';
+import { SelectFilter } from './select-filter.interface';
+import { BasketItem, FareType, FlightCabinClass, FlightItinerary, SearchFlightsV2QueryVariables, ServiceType } from '../types/graphql.types';
+import { FlightAllQuoteResult, FlightDirectionEnum, FlightQuoteResultArray, NgbDateStruct, OBTAirlinesDetails, OBTAirportDetails } from '../types/types';
+import { SortTypes, TimeWindow } from '../classes/flight-enterprise-search';
+import { BaseEnterpriseSearch } from '../classes/base-enterprise';
+import { ICheapestPrice } from './cheapest-price';
+import { IMultiDestination } from './flight-multi-destination.interface';
+import { FlightSearchType } from '../classes/flight-search-type.enum';
+export interface FlightTempParams {
+    adults: number;
+    arriveLocation: string | OBTAirportDetails;
+    cabinClass: FlightCabinClass;
+    children: number;
+    departLocation: string | OBTAirportDetails;
+    fareType: FareType;
+    inboundDate: moment.Moment;
+    outBoundDate: moment.Moment;
+    inTimeCriteria: TimeWindow;
+    outTimeCriteria: TimeWindow;
+    preferredCarriers: OBTAirlinesDetails[];
+    returnCabinClass: FlightCabinClass;
+    maxConnections: number;
+    includeNearbyAirports: boolean;
+    chosenSearchType: FlightSearchType;
+    multiDestination: IMultiDestination[];
+}
+export interface FlightEnterpriseSearchInterface extends BaseEnterpriseSearch<FlightTempParams, FlightAllQuoteResult, FlightQuoteResultArray>, FlightTempParams {
+    type: ServiceType;
+    avaliableClasses: BehaviorSubject<{}>;
+    timeCriteriaOptions: BehaviorSubject<{}>;
+    flightOperators: BehaviorSubject<{}>;
+    minimumOutBoundDate: {
+        year: any;
+        month: any;
+        day: any;
+    };
+    minimumInBoundDate: {
+        year: any;
+        month: any;
+        day: any;
+    };
+    readonly timeArray: {};
+    operator1: OBTAirlinesDetails;
+    operator2: OBTAirlinesDetails;
+    operator3: OBTAirlinesDetails;
+    operator4: OBTAirlinesDetails;
+    readonly minDate: NgbDateStruct;
+    adults: number;
+    children: number;
+    departLocation: string | OBTAirportDetails;
+    readonly queryOriginAiport: string;
+    readonly queryDestinationAiport: string;
+    departDate: NgbDateStruct;
+    departTime: string;
+    outBoundDate: any;
+    returnDate: NgbDateStruct;
+    arriveTime: string;
+    inboundDate: any;
+    arriveLocation: string | OBTAirportDetails;
+    cabinClass: FlightCabinClass;
+    returnCabinClass: FlightCabinClass;
+    outTimeCriteria: TimeWindow;
+    inTimeCriteria: TimeWindow;
+    readonly sortDropdownValues: {};
+    readonly fareTypesValues: {};
+    fareType: FareType;
+    negotiated: boolean;
+    includeNearbyAirports: boolean;
+    cheapestPrice: ICheapestPrice;
+    maxConnections: number;
+    chosenSearchType: FlightSearchType;
+    multiDestination: IMultiDestination[];
+    showHotelForm: boolean;
+    hotelSearchRequested: boolean;
+    startSearch(): any;
+    getSearchQuery(): SearchFlightsV2QueryVariables;
+    sortResults(sortMethodValue: SortTypes, givenResults?: FlightItinerary[]): {};
+    updateFromPreviousSearches(previousItems: Record<ServiceType, BasketItem>): void;
+    getTotalBaggage(result: FlightItinerary): number;
+    filterResults(filters: FlightFilters, sortValue: SortTypes, givenResults?: FlightItinerary[]): FlightItinerary[];
+    transformMin(min: number): string;
+    filterByDuration(minDuration: number, maxDuration: number, results: FlightItinerary[], isReturn?: boolean): {};
+    filterByDepartureTime(minDep: number, maxDep: number, results: FlightItinerary[]): {};
+    filterByReturnDepartureTime(minDep: number, maxDep: number, results: FlightItinerary[]): {};
+    filterByReturnArrivalTime(minArr: number, maxArr: number, results: FlightItinerary[]): {};
+    filterByArrivalTime(minArr: number, maxArr: number, results: FlightItinerary[]): {};
+    filterByBaggage(baggageFilters: SelectFilter[], results: FlightItinerary[]): {};
+    filterByPrice(minPrice: number, maxPrice: number, results: FlightItinerary[]): {};
+    filterResultsByStops(stopFilters: SelectFilter[], fullResults: FlightItinerary[]): {};
+    filterResultsByAirline(airlineFilters: SelectFilter[], results: FlightItinerary[]): {};
+    filterResultsByClass(classFilters: SelectFilter[], results: FlightItinerary[]): {};
+    filterByDepartureAirport(departureAirports: SelectFilter[], results: FlightItinerary[]): {};
+    filterByArrivalAirport(arrivalAirports: SelectFilter[], results: FlightItinerary[]): {};
+    filterByDepartureReturnAirport(departureAirports: SelectFilter[], results: FlightItinerary[]): {};
+    filterByArrivalReturnAirport(arrivalAirports: SelectFilter[], results: FlightItinerary[]): {};
+    filterByFlightNumber(flightNumber: string, results: FlightItinerary[]): {};
+    createFilters(results: FlightItinerary[]): FlightFilters;
+    getMinDuration(results: FlightItinerary[], isReturn?: boolean): number;
+    getMaxDuration(results: FlightItinerary[], isReturn?: boolean): number;
+    getMinArrivalTime(results: FlightItinerary[]): number;
+    getMinReturnArrivalTime(results: FlightItinerary[]): number;
+    getMaxReturnArrivalTime(results: FlightItinerary[]): number;
+    getMaxArrivalTime(results: FlightItinerary[]): number;
+    getMinDepartureTime(results: FlightItinerary[]): number;
+    getMinReturnDepartureTime(results: FlightItinerary[]): number;
+    getMaxReturnDepartureTime(results: FlightItinerary[]): number;
+    getMaxDepartureTime(results: FlightItinerary[]): number;
+    getBaggage(results: FlightItinerary[]): {};
+    getMinPrice(results: FlightItinerary[]): number;
+    getMaxPrice(results: FlightItinerary[]): number;
+    getAllStops(results: FlightItinerary[]): {};
+    getAllClasses(results: FlightItinerary[]): {};
+    getAllDepartureAirports(results: FlightItinerary[], inbound?: boolean): {};
+    getAllArrivalAirports(results: FlightItinerary[], inbound?: boolean): {};
+    getAllAirlines(results: FlightItinerary[]): {};
+    updateLowestPrice(results: FlightQuoteResultArray): ICheapestPrice;
+    resetParams(): void;
+    selectGroupedFlight(selectedFlight: FlightItinerary, direction: FlightDirectionEnum): void;
+    addFlightJourneysToBasket(selectedFlight: FlightItinerary): void;
+}

package/dist/obtservices/base/lib/vendor/interfaces/Ihotel-enterprise-search.d.ts

@@ -0,0 +1,192 @@
+import { BehaviorSubject, Observable, Subject } from 'rxjs';
+import moment from 'moment';
+import { Country, HotelQuoteResult, HotelQuoteResultArray, LocationTypes, MinMax, NgbDateStruct, LocationDetails, BreatfastTypes } from '../types/types';
+import { BasketItem, ConfermaOfficeNames, HotelLocation, HotelRoom, HotelTag, SearchHotelsQueryVariables, ServiceType } from '../types/graphql.types';
+import { BaseEnterpriseSearch } from '../classes/base-enterprise';
+import { ICheapestPrice } from './cheapest-price';
+import { Traveller } from '../models/traveller.object';
+export interface HotelTempParams {
+    location_type_select: LocationTypes;
+    checkin_date: moment.Moment;
+    checkout_date: moment.Moment;
+    no_of_rooms: number;
+    no_of_occupants: number;
+    location: any;
+    distance: number;
+    prefered_hotels_only: boolean;
+    country: Country;
+    hotel_name: string;
+    hotel_chain: any;
+    currency: string;
+    postcode: LocationDetails;
+    trainsStation: LocationDetails;
+    office: ConfermaOfficeNames;
+}
+export declare type HotelDetails = HotelQuoteResult & {
+    sortedTags?: HotelTag[];
+    Details: {
+        distance_airport: number;
+        airport_details: {
+            name: string;
+        };
+        distance_metro: number;
+        metro_details: {
+            name: string;
+        };
+        distance_rail: number;
+        rail_details: {
+            name: string;
+        };
+    };
+};
+export declare type HotelDetailsArray = HotelDetails[];
+export interface DisplayFilterSettings {
+    minprice: number;
+    maxprice: number;
+    filters: {
+        breakfastType: BreatfastTypes[];
+    };
+}
+export interface ResultDetails {
+    chains: Set<string>;
+    amenities: string[];
+    maxDistance: number;
+}
+export interface AvailabilityObject {
+    hotel: string;
+    startDate: string;
+    endDate: string;
+    rooms: number;
+    occupants: number;
+    currency: string;
+}
+export declare class HotelFilters {
+    priceRange: MinMax;
+    distanceRange: MinMax;
+    chain: string[];
+    amenitytype: string[];
+    preferred: string[];
+    extra: string[];
+    hotelName: string;
+    breakfastType: string[];
+}
+export declare enum HotelView {
+    LIST = "list",
+    MAP = "map"
+}
+export interface HotelViewController {
+    showMap: boolean;
+    ratesUpdated: any;
+    filterChange: any;
+    hotelChosen: any;
+    filtered: any;
+    filterArray: {};
+    showFilterOptions: any;
+    selectedVals: [];
+    nr: any;
+    single: boolean;
+    hotelCodeChosen: any;
+    closeFilterOptions: any;
+}
+/**
+ * Sorting type can be passed to sorting-toggle component.
+ *
+ * @export
+ * @interface SortType
+ */
+export interface SortType {
+    /** Title displayed on dropdown */
+    title: string;
+    /** Reference to method used by component to sort results
+     ** Please ensure that method is binding to correct object
+     */
+    methodRef?: () => void;
+    /** Icon displayed on drop down */
+    icon?: string;
+    /** Change dir after user click second time */
+    dynamicDir?: boolean;
+    /**
+     * ! Deprecated Prod build only, should be removed in next version
+     * @deprecated Prod build only, should be removed in next version
+     * */
+    method?: string;
+    /**
+     * ! Deprecated Prod build only, should be removed in next version
+     * @deprecated Prod build only, should be removed in next version
+     * */
+    dir?: boolean;
+}
+export interface HotelEnterpriseSearchInterface extends BaseEnterpriseSearch<HotelTempParams, HotelQuoteResultArray, HotelDetailsArray> {
+    type: ServiceType;
+    location_types: BehaviorSubject<{}>;
+    offices: BehaviorSubject<{}>;
+    lastActivePage: BehaviorSubject<number>;
+    readonly galleries: {
+        [key: string]: {};
+    };
+    filterChange: Subject<any>;
+    selectItemMapView: Subject<any>;
+    display: DisplayFilterSettings;
+    min_date: {
+        year: any;
+        month: any;
+        day: any;
+    };
+    min_return_date: {
+        year: any;
+        month: any;
+        day: any;
+    };
+    currentView: HotelView;
+    filterResults: () => void;
+    readonly chains: {};
+    readonly amenities: {};
+    readonly maxDistance: number;
+    readonly maxPrice: number;
+    checkin_date_ngb: NgbDateStruct;
+    checkout_date_ngb: NgbDateStruct;
+    checkin_date: any;
+    checkout_date: any;
+    no_of_rooms: number;
+    no_of_occupants: number;
+    location: any;
+    readonly formatted_location: string;
+    distance: number;
+    prefered_hotels_only: boolean;
+    country: Country;
+    trainsStation: LocationDetails;
+    office: ConfermaOfficeNames;
+    hotel_name: string;
+    hotel_chain: string;
+    readonly max_rooms_array: {};
+    readonly max_occupant_array: {};
+    readonly distance_list: {};
+    location_type_select: LocationTypes;
+    readonly filters: HotelFilters;
+    cheapestPrice: ICheapestPrice;
+    makeLocations(location: HotelLocation[]): {
+        [key: string]: {};
+    };
+    sortTags(tags: HotelTag[]): {};
+    startSearch(): any;
+    getSearchQuery(): SearchHotelsQueryVariables;
+    buildQuery(): void;
+    makeHotelAvalilityObject(hotel: HotelQuoteResult): AvailabilityObject;
+    byMostExpensive(): void;
+    sortByPrice(min?: boolean, debug?: boolean): void;
+    sortByName(): void;
+    sortByDistance(): void;
+    byPreferred(): void;
+    getmaxPriceForCurrency(currency: string): any;
+    addFilter(filter: string, type: keyof HotelFilters): void;
+    removeFilter(filter: string, type: keyof HotelFilters): void;
+    resetFilters(): void;
+    updateFromPreviousSearches(previousItems: Record<ServiceType, BasketItem>): void;
+    filterLighteningResults(): void;
+    getImages(HolidayCode: string): Observable<{}>;
+    addPaginationPage(currentPage: number): any;
+    toggleView(): void;
+    calcDayDiff(): number;
+    updateLowestPrice(results: HotelDetails[]): ICheapestPrice;
+    addHotelRoomToBasket(hotelQuoteResult: HotelQuoteResult, hotelRoom: HotelRoom, hotelQuery: SearchHotelsQueryVariables, travellers?: Traveller[]): Promise<boolean>;
+}

package/dist/obtservices/base/lib/vendor/interfaces/Iirl-enterprise-search.d.ts

@@ -0,0 +1,45 @@
+import moment from 'moment';
+import { NgbDateStruct, IrlQuoteResultArray } from '../types/types';
+import { BasketItem, IrlClass, IrlJourneyOptions, IrlJourneyType, IrlTicketOption, SearchIrlQueryVariables, ServiceType, IrlSupplier } from '../types/graphql.types';
+import { BaseEnterpriseSearch } from '../classes/base-enterprise';
+import { ICheapestPrice } from './cheapest-price';
+export interface IrlTempParams {
+    supplier: IrlSupplier;
+    countryCode: string;
+    class: IrlClass;
+    outboundDepartureDateTime: moment.Moment;
+    departureLocationId: string;
+    arrivalLocationId: string;
+    adults: number;
+    children: number;
+    returnDepartureDateTime: moment.Moment;
+    journeyType: IrlJourneyType;
+}
+export interface IRLEnterpriseSearchInterface extends BaseEnterpriseSearch<IrlTempParams, IrlQuoteResultArray, IrlQuoteResultArray>, IrlTempParams {
+    searchTypes: {};
+    classTypes: {};
+    railCriteria: {};
+    travelCards: {};
+    type: ServiceType;
+    minOutboundDate: NgbDateStruct;
+    minInboundDate: NgbDateStruct;
+    noOfAdults: number;
+    noOfChildren: number;
+    travellingTo: any;
+    travellingFrom: any;
+    outBoundDateTime: moment.Moment;
+    outbound_date: NgbDateStruct;
+    outbound_time: string;
+    return_date: NgbDateStruct;
+    return_time: string;
+    readonly timeArray: {};
+    cheapestStandard: IrlTicketOption;
+    cheapestFirst: IrlTicketOption;
+    cheapestPrice: ICheapestPrice;
+    originalUserSearch: IrlTempParams;
+    startSearch(): any;
+    getSearchQuery(): SearchIrlQueryVariables;
+    updateFromPreviousSearches(previousItems: Record<ServiceType, BasketItem>): void;
+    updateLowestPrice(results: IrlJourneyOptions[]): ICheapestPrice;
+    findCheapestTicket(results: IrlJourneyOptions[]): number;
+}

package/dist/obtservices/base/lib/vendor/interfaces/Ilounges-enterprise-search.d.ts

@@ -0,0 +1,36 @@
+import moment from 'moment';
+import { BaseEnterpriseSearch } from '../classes/base-enterprise';
+import { BehaviorSubject } from 'rxjs';
+import { LoungeQuoteResultArray, NgbDateStruct, OBTAirportDetails } from '../types/types';
+import { BasketItem, LoungeQuote, SearchLoungesQueryVariables, ServiceType } from '../types/graphql.types';
+import { ICheapestPrice } from './cheapest-price';
+export interface LoungesTempParams {
+    adults: number;
+    children: number;
+    infants: number;
+    locationCode: string | OBTAirportDetails;
+    terminal: string;
+    arrivalDatetime: moment.Moment;
+}
+export interface LoungesEnterpriseSearchInterface extends BaseEnterpriseSearch<LoungesTempParams, LoungeQuoteResultArray, LoungeQuoteResultArray> {
+    type: ServiceType;
+    terminals: BehaviorSubject<{}>;
+    adults: number;
+    children: number;
+    readonly infants: number;
+    flightNumber: string;
+    locationCode: string | OBTAirportDetails;
+    terminal: string;
+    selectedTerminal: string;
+    date: NgbDateStruct;
+    time: string;
+    cheapestPrice: ICheapestPrice;
+    getSearchQuery(): SearchLoungesQueryVariables;
+    startSearch(): any;
+    sortByPrice(asc?: boolean, resultArray?: LoungeQuote[]): void;
+    sortResultsPrice(results: LoungeQuote[], asc?: boolean): LoungeQuote[];
+    sortByTerminal(resultArray?: LoungeQuote[]): void;
+    updateFromPreviousSearches(previousItems: Record<ServiceType, BasketItem>): void;
+    addLoungeToBasket(loungeQuote: LoungeQuote, loungeQuery: SearchLoungesQueryVariables): any;
+    updateLowestPrice(results: LoungeQuote[]): ICheapestPrice;
+}

package/dist/obtservices/base/lib/vendor/interfaces/Imybookings.service.d.ts

@@ -0,0 +1,24 @@
+import { BehaviorSubject, Observable } from 'rxjs';
+import { UserBasketResult } from '../types/types';
+import { QueryGetUserBasketsArgs } from '../types/graphql.types';
+import { BasketItem, BasketItemStatus, BasketStatus, ServiceType, User } from '../types/graphql.types';
+import { EnterpriseSearchServiceInterface } from '../interfaces/Isearch.service';
+export interface EnterpriseMyBookingsServiceInterface {
+    baskets: BehaviorSubject<UserBasketResult[]>;
+    getUserBaskets(query: QueryGetUserBasketsArgs, isLoading: BehaviorSubject<boolean>): void;
+    getSearchUserCanBookFor(search: string, isLoading: BehaviorSubject<boolean>): Observable<User[]>;
+    getServiceTypeFilters(searchService: EnterpriseSearchServiceInterface): string[];
+    getBasketStatusFilters(): string[];
+    getServiceTypeFilterVanityName(serviceType: ServiceType): string;
+    getBasketStatusIconClass(status: BasketStatus): string;
+    getServiceTypeIconClass(basketItem: BasketItem): string;
+    getTotalPriceForBasketItems(basketItems: BasketItem[]): number;
+    getTravellerNamesFromBasketItems(basketItems: BasketItem[]): string[];
+    allBasketItemsMatchStatus(basketItems: BasketItem[], basketItemStatus: BasketItemStatus): boolean;
+    getHotelAddress(hotelAddress: {
+        [key: string]: string;
+    }): string;
+    getHotelLocation(hotelAddress: {
+        [key: string]: string;
+    }): string;
+}

package/dist/obtservices/base/lib/vendor/interfaces/Iparking-enterprise-search.d.ts

@@ -0,0 +1,58 @@
+import moment from 'moment';
+import { BehaviorSubject } from 'rxjs';
+import { NgbDateStruct, OBTAirportDetails, ParkingQuoteResultArray, ParkingFiltersInterface } from '../types/types';
+import { BasketItem, ParkingQuote, SearchParkingQueryVariables, ServiceType } from '../types/graphql.types';
+import { BaseEnterpriseSearch } from '../classes/base-enterprise';
+import { ICheapestPrice } from './cheapest-price';
+export interface ParkingTempParams {
+    arrivalDatetime: moment.Moment;
+    departDatetime: moment.Moment;
+    locationCode: string | OBTAirportDetails;
+    outFlightNumber: string;
+    recommended: boolean;
+    onAirport: boolean;
+    meetAndGreet: boolean;
+    parkAndRide: boolean;
+    parkAndStroll: boolean;
+    carParkedForYou: boolean;
+    terminal: string;
+}
+export interface ParkingEnterpriseSearchInterface extends BaseEnterpriseSearch<ParkingTempParams, ParkingQuoteResultArray, ParkingQuoteResultArray> {
+    type: ServiceType;
+    terminals: BehaviorSubject<{}>;
+    listViewToggle: BehaviorSubject<ParkingQuote>;
+    parkingFiltersText: ParkingFiltersInterface;
+    min_date: {
+        year: any;
+        month: any;
+        day: any;
+    };
+    min_return_date: {
+        year: any;
+        month: any;
+        day: any;
+    };
+    outdate: NgbDateStruct;
+    outtime: string;
+    departDatetime: any;
+    indate: NgbDateStruct;
+    intime: string;
+    arrivalDatetime: any;
+    outFlightNumber: string;
+    recommended: boolean;
+    onAirport: boolean;
+    meetAndGreet: boolean;
+    parkAndRide: boolean;
+    parkAndStroll: boolean;
+    carParkedForYou: boolean;
+    terminal: string;
+    locationCode: string | OBTAirportDetails;
+    selectedTerminal: string;
+    cheapestPrice: ICheapestPrice;
+    startSearch(): any;
+    getSearchQuery(): SearchParkingQueryVariables;
+    sortByPrice(asc?: boolean): void;
+    updateFromPreviousSearches(previousItems: Record<ServiceType, BasketItem>): void;
+    addParkingToBasket(parkingQuote: ParkingQuote, parkingQuery: SearchParkingQueryVariables): any;
+    updateLowestPrice(results: ParkingQuote[]): ICheapestPrice;
+}

package/dist/obtservices/base/lib/vendor/interfaces/Irail-enterprise-search.d.ts

@@ -0,0 +1,110 @@
+import moment from 'moment';
+import { Observable, BehaviorSubject } from 'rxjs';
+import { RailTicketGroups } from './rail-ticket-groups.interface';
+import { RailTicketGroup } from './rail-ticket-group.interface';
+import { NgbDateStruct, RailQuoteResultArray, RecentSearch, RecursivePartial } from '../types/types';
+import { BasketItem, RailClass, RailJourneyOption, RailJourneyOptions, RailJourneyType, RailSegment, RailStation, RailTicketOption, ReferenceRailCardQualifier, SearchRailQueryVariables, ServiceType } from '../types/graphql.types';
+import { RailSearchCriteria } from '../classes/rail-enterprise-search';
+import { BaseEnterpriseSearch } from '../classes/base-enterprise';
+import { CodeName } from './code-name';
+import { ICheapestPrice } from './cheapest-price';
+import { IRailAirportExpressStations } from './rail-airport-express-stations.interface';
+export interface RailTempParams {
+    chosenSearchType: RailJourneyType;
+    chosenSearchClass: RailClass;
+    noOfAdults: number;
+    noOfChildren: number;
+    travellingFrom: any;
+    travellingTo: any;
+    extraTime: boolean;
+    via: boolean;
+    viaLocation: any;
+    outBoundDateTime: moment.Moment;
+    inBoundDateTime: moment.Moment;
+    outboundCriteria: RailSearchCriteria;
+    returnCriteria: RailSearchCriteria;
+    carnetTicket: boolean;
+    disableAutoDiscounts: boolean;
+    prioritiseByPrice: boolean;
+    applyRailcards: boolean;
+    airportExpressStation: string;
+    isAirportExpress: boolean;
+    openReturn: boolean;
+    railCards: ReferenceRailCardQualifier[];
+}
+export interface RailEnterpriseSearchInterface extends BaseEnterpriseSearch<RailTempParams, RailQuoteResultArray, RailQuoteResultArray>, RailTempParams {
+    searchTypes: {};
+    classTypes: {};
+    airportExpressStations: IRailAirportExpressStations[];
+    airportExpressStationsCodes: {
+        [key: string]: {
+            dep: string;
+            arr: string;
+        };
+    };
+    railCriteria: {};
+    travelCards: {};
+    type: ServiceType;
+    minOutboundDate: NgbDateStruct;
+    minInboundDate: NgbDateStruct;
+    readonly chosenTotalPrice: number;
+    readonly chosenTickets: any;
+    readonly chosenOutboundJourney: RecursivePartial<RailJourneyOption>;
+    readonly chosenInboundJourney: RecursivePartial<RailJourneyOption>;
+    openReturn: boolean;
+    chosenSearchType: RailJourneyType;
+    noOfAdults: number;
+    noOfChildren: number;
+    travellingTo: any;
+    travellingFrom: any;
+    readonly chosenRailClass: RailClass;
+    chosenSearchClass: RailClass;
+    extraTime: boolean;
+    via: boolean;
+    viaLocation: any;
+    outBoundDateTime: moment.Moment;
+    outboundCriteria: RailSearchCriteria;
+    inBoundDateTime: moment.Moment;
+    outbound_date: NgbDateStruct;
+    outbound_time: string;
+    return_date: NgbDateStruct;
+    return_time: string;
+    returnCriteria: RailSearchCriteria;
+    carnetTicket: boolean;
+    disableAutoDiscounts: boolean;
+    prioritiseByPrice: boolean;
+    applyRailcards: boolean;
+    readonly timeArray: {};
+    airportExpressStation: string;
+    isAirportExpress: boolean;
+    cheapestStandard: RailTicketOption;
+    cheapestFirst: RailTicketOption;
+    cheapestPrice: ICheapestPrice;
+    originalUserSearch: RailTempParams;
+    removePassingPointsFromResults: boolean;
+    chosenTicketGroup: RailTicketGroup;
+    getAirportExpressStations(): CodeName[];
+    setAirportExpressStationIds(stationIds: {
+        departureLocationId: string;
+        arrivalLocationId: string;
+    }): void;
+    startSearch(): any;
+    startRecentSearch(recentSearch: RecentSearch): void;
+    getSearchQuery(): SearchRailQueryVariables;
+    createTicketGroups(results: RailJourneyOptions[]): RailTicketGroups;
+    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;
+    canCombine(journeyIdentifier: string, fareIdentifier: string): boolean;
+    clearUnneededTickets(way: string, group: RailTicketGroup, timeSlotId: string): RailTicketGroup;
+    getRailStation(code: string, isLoading?: BehaviorSubject<boolean>): Observable<RailStation>;
+    getLegsFromRailJourneyOption(railJourneyOption: RailJourneyOption): any[];
+    getSelectedRailTicketOption(railJourneyOption: RailJourneyOption, railTicketGroup: RailTicketGroup, providerIndex: number): RailTicketOption;
+    addSingleJourneyToBasket(serviceId: string, railQuery: SearchRailQueryVariables, railJourneyOption: RailJourneyOption, railTicketGroup: RailTicketGroup): Promise<boolean>;
+    addReturnJourneyToBasket(serviceId: string, railQuery: SearchRailQueryVariables, outboundRailJourneyOption: RailJourneyOption, inboundRailJourneyOption: RailJourneyOption, railTicketGroup: RailTicketGroup): Promise<boolean>;
+    updateLowestPrice(results: RailJourneyOptions[]): ICheapestPrice;
+    findCheapestTicket(results: RailJourneyOptions[]): number;
+    calculateTimeDifferenceInMins(rail: RailJourneyOption | RailSegment): string;
+    ticketIsAnETicket(ticket: RailTicketOption): boolean;
+    clearChosenTickets(): void;
+}