@sabstravtech/obtservices 0.0.0

package/projects/obtservices/base/src/lib/vendor/fetchers/user-ui-configs-fetcher.ts

@@ -0,0 +1,35 @@
+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 { UserUiConfigsResult } from '../types/types';
+import {
+  GetUserUiConfigsQuery,
+  GetUserUiConfigsQueryVariables
+} from '../types/graphql.types';
+
+type R = { getUserUIConfigs: { all: P } };
+type P = UserUiConfigsResult;
+type A = GetUserUiConfigsQueryVariables;
+type M = GetUserUiConfigsQuery;
+
+export type UserUiConfigsFetcherType = {
+  fetch: (a: A) => Observable<ApolloQueryResult<M>>;
+};
+
+export class BaseUserUiConfigsFetcher<
+  Q extends UserUiConfigsFetcherType
+> extends FetchableList<Q, A, R, P, M> {
+  constructor(
+    getUserUiConfigsGQL: Q,
+    helpers: BaseHelperRoutines,
+    modalService: BaseModalOpenerService
+  ) {
+    super(getUserUiConfigsGQL, helpers, modalService);
+  }
+
+  protected getDataFromResult(results: ApolloQueryResult<R>): P {
+    return results?.data?.getUserUIConfigs.all;
+  }
+}

package/projects/obtservices/base/src/lib/vendor/interfaces/Icabhire-enterprise-search.ts

@@ -0,0 +1,174 @@
+import moment from 'moment';
+import { BehaviorSubject, Subject } from 'rxjs';
+
+import {
+  AddressForm,
+  CabhireQuoteResultArray,
+  KeyValue,
+  NgbDateStruct,
+  RailAirport
+} from '../types/types';
+import {
+  BasketItem,
+  CabHireLocation,
+  LocationDetail,
+  CabHireQuote,
+  SearchCabHireQueryVariables,
+  ServiceType,
+  CabHireVehicleType
+} from '../types/graphql.types';
+
+import { BaseEnterpriseSearch } from '../classes/base-enterprise';
+import { ICheapestPrice } from './cheapest-price';
+
+export enum TaxiFormMode {
+  ADDRESS = 'location',
+  STATION = 'station'
+}
+export enum AirportSearchMode {
+  PICKUP = 'Airport Pick Up',
+  DROPOFF = 'Airport drop off'
+}
+
+export interface TransType {
+  key: CabHireVehicleType;
+  value: string;
+  id: number;
+}
+
+export enum ActionType {
+  GET = 'get',
+  SAVE = 'save',
+  DELETE = 'delete'
+}
+
+export interface TaxiAirport {
+  destination: string;
+  gateway: string;
+  terminals: string;
+  supplier_code: string;
+}
+export interface TaxiAttribute extends KeyValue<string, string> {
+  enabled: boolean;
+}
+
+export interface TaxiAddress {
+  AddressType: string;
+  House: string;
+  Town: string;
+  PostCode: string;
+  Street: string;
+  defaultUser: string;
+  id: string;
+  label: string;
+  action?: ActionType;
+  isLoading: boolean;
+  isAirportOrStation: boolean;
+  Country: string;
+  placeDescription?: string; // the raw address string - use for stations/ airports
+}
+export interface CabHireTempParams {
+  adults: number;
+  airport: TaxiAirport;
+  children: number;
+  countryCode: string;
+  departs: moment.Moment;
+  fromAddress: AddressForm;
+  fromStation: RailAirport;
+  fromLocationType: TaxiFormMode;
+  infants: number;
+  toAddress: AddressForm;
+  toStation: RailAirport;
+  toLocationType: TaxiFormMode;
+  vehicleType: CabHireVehicleType;
+  viasFrom: AddressForm;
+  viasTo: AddressForm;
+}
+export interface CabHireEnterpriseSearchInterface
+  extends BaseEnterpriseSearch<
+      CabHireTempParams,
+      CabhireQuoteResultArray,
+      CabhireQuoteResultArray
+    >,
+    CabHireTempParams {
+  type: ServiceType;
+  airportChange: Subject<TaxiAirport>;
+  readonly fromLocation: CabHireLocation;
+  readonly toLocation: CabHireLocation;
+  readonly transTypes: TransType[];
+  readonly attributes: TaxiAttribute[];
+  readonly searchTypes: string[];
+  readonly airportSearchTypes: {};
+  readonly criteria: {};
+  mode: TaxiFormMode;
+  airportSearchType: AirportSearchMode;
+  fromLocationType: TaxiFormMode;
+  toLocationType: TaxiFormMode;
+  minSelectDate: moment.Moment;
+  selectedPlaces: any;
+  getPassengers: () => string;
+  date: NgbDateStruct;
+  searchType: string;
+  searchCriteria: string;
+  outboundDateTime: moment.Moment;
+  returnDateTime: moment.Moment;
+  flightNumber: string;
+  airport: TaxiAirport;
+  terminal: string;
+  time: string;
+  departs: moment.Moment;
+  adults: number;
+  children: number;
+  infants: number;
+  countryCode: string;
+  vias: CabHireLocation[];
+  viasFrom: AddressForm;
+  viasTo: AddressForm;
+  vehicleType: CabHireVehicleType;
+  fromAddress: AddressForm;
+  fromStation: RailAirport;
+  toAddress: AddressForm;
+  toStation: RailAirport;
+  cheapestPrice: ICheapestPrice;
+  startSearch(): any;
+  getSearchQuery(): SearchCabHireQueryVariables;
+  updateOutboundAddress(location: any, placeDescription?: string): void;
+  updateInboundAddress(location: any, placeDescription?: string): void;
+  matchAddresses(): void;
+  sortBy(asc?: boolean): void;
+  getAddressFormat(
+    location: any,
+    placeDescription?: string
+  ): {
+    House: string;
+    Street: string;
+    Town: string;
+    PostCode: string;
+    Country: string;
+    placeDescription: string;
+  };
+  getAddressFromPlaceDetails(placeDetails: any, types: string[]): string;
+  getAddressFromAirportDetails(
+    airportDetails: LocationDetail,
+    airportName: string
+  ): AddressForm;
+  setLocationFromAirport(
+    airportDetails: LocationDetail,
+    airportName: string
+  ): void;
+  addToSelectedPlaces(address: any): void;
+  setOutboundFormVisibility(showForm: boolean): void;
+  setInboundFormVisibility(showForm: boolean): void;
+  getOutboundFormVisibility(): BehaviorSubject<boolean>;
+  getInboundFormVisibility(): BehaviorSubject<boolean>;
+  updateFromPreviousSearches(
+    previousItems: Record<ServiceType, BasketItem>
+  ): void;
+  getTransType(): string;
+  addCabHireToBasket(
+    cabHireQuote: CabHireQuote,
+    cabHireQuery: SearchCabHireQueryVariables
+  ): any;
+  updateLowestPrice(results: CabHireQuote[]): ICheapestPrice;
+  resetParams(): void;
+}

package/projects/obtservices/base/src/lib/vendor/interfaces/Icarhire-enterprise-search.ts

@@ -0,0 +1,143 @@
+import moment from 'moment';
+import { Observable, BehaviorSubject } from 'rxjs';
+import { CarHireFilters } from './car-hire-filters.interface';
+import { SelectFilter } from './select-filter.interface';
+import {
+  BasketItem,
+  CarHireClass,
+  CarHireDetailRequestResponse,
+  CarHireInputIdentifiers,
+  CarHireTransmission,
+  CarHireType,
+  CarHireVehicleAvailibility,
+  QuerySearchCarHireArgs,
+  ServiceType,
+  SearchCarHireQueryVariables
+} from '../types/graphql.types';
+import {
+  CarHireDepot,
+  CarHireQuoteResult,
+  CarHireQuoteResultArray,
+  LocationDetails,
+  LocationTypes,
+  NgbDateStruct,
+  OBTAirportDetails
+} from '../types/types';
+import { BaseEnterpriseSearch } from '../classes/base-enterprise';
+import { ICheapestPrice } from './cheapest-price';
+import { Traveller } from '../models/traveller.object';
+import { ICarClasses } from './car-hire-classes.interface';
+
+export interface CarHireTempParams {
+  adults: number;
+  airCon: boolean;
+  carClass: CarHireClass;
+  carType: CarHireType;
+  children: number;
+  chosenVendor: string;
+  cityDropoff: LocationDetails;
+  cityDropoffDepot: CarHireDepot;
+  cityPickup: LocationDetails;
+  cityPickupDepot: CarHireDepot;
+  dropoff_country: string;
+  dropoff_datetime: moment.Moment;
+  dropoff_location: OBTAirportDetails;
+  estimatedMileage: number;
+  locationType: LocationTypes;
+  pickup_country: string;
+  pickup_datetime: moment.Moment;
+  pickup_location: OBTAirportDetails;
+  postcodeDropoff: CarHireDepot;
+  postcodeDropoffRaw: LocationDetails;
+  postcodePickup: CarHireDepot;
+  postcodePickupRaw: LocationDetails;
+  return_to_pickup: boolean;
+  transmission: CarHireTransmission;
+}
+export interface CarhireEnterpriseSearchInterface
+  extends BaseEnterpriseSearch<
+      CarHireTempParams,
+      CarHireQuoteResultArray,
+      CarHireQuoteResultArray
+    >,
+    CarHireTempParams {
+  carhireCodes: any;
+  type: ServiceType;
+  readonly minDate: NgbDateStruct;
+  readonly minInDate: NgbDateStruct;
+  pickup_country: string;
+  dropoff_country: string;
+  pickup_location: OBTAirportDetails;
+  dropoff_location: OBTAirportDetails;
+  pickup_datetime: any;
+  dropoff_datetime: any;
+  pickup_date: NgbDateStruct;
+  pickup_time: string;
+  dropoff_date: NgbDateStruct;
+  dropoff_time: string;
+  return_to_pickup: boolean;
+  chosenVendor: string;
+  carClass: CarHireClass;
+  carType: CarHireType;
+  transmission: CarHireTransmission;
+  airCon: boolean;
+  locationType: LocationTypes;
+  cityPickup: LocationDetails;
+  cityDropoff: LocationDetails;
+  postcodePickup: CarHireDepot;
+  postcodeDropoff: CarHireDepot;
+  cityPickupDepot: CarHireDepot;
+  cityDropoffDepot: CarHireDepot;
+  ngbDropoffDate: NgbDateStruct;
+  ngbPickupDate: NgbDateStruct;
+  pickupTime: string;
+  dropoffTime: string;
+  postcodePickupRaw: LocationDetails;
+  postcodeDropoffRaw: LocationDetails;
+  cheapestPrice: ICheapestPrice;
+  readonly timeArray: {};
+  readonly carAirConditionTypes: [string, string, boolean][];
+  readonly carTransmissionCodes: [string, string, CarHireTransmission][];
+  readonly carTypeCodes: [string, string, CarHireType][];
+  readonly vendors: {};
+  readonly sortingOptions: {};
+  startSearch(): any;
+  getSearchQuery(): QuerySearchCarHireArgs;
+  getCarClasses(): Observable<ICarClasses[]>;
+  getLocationTypes(): Observable<{}>;
+  filterResults(appliedFilters: CarHireFilters, selectedSort: number): void;
+  filterByCompany(
+    companies: SelectFilter[],
+    cars: CarHireQuoteResultArray
+  ): any;
+  filterByCarType(types: SelectFilter[], cars: CarHireQuoteResultArray): any;
+  filterByTransmissionType(
+    tranmissions: SelectFilter[],
+    cars: CarHireQuoteResultArray
+  ): any;
+  filterByAirconType(
+    aircons: SelectFilter[],
+    cars: CarHireQuoteResultArray
+  ): any;
+  sortResults(selectedSort: number, results?: CarHireQuoteResultArray): any;
+  sortExpensive(results?: CarHireQuoteResultArray): any;
+  sortCheapest(results?: CarHireQuoteResultArray): any;
+  sortBySize(results?: CarHireQuoteResultArray): any;
+  sortByBrand(results?: CarHireQuoteResultArray): any;
+  getPrice(car: CarHireQuoteResult): number;
+  getMinPrice(cars: CarHireQuoteResultArray): number;
+  getMaxPrice(cars: CarHireQuoteResultArray): number;
+  updateFromPreviousSearches(
+    previousItems: Record<ServiceType, BasketItem>
+  ): void;
+  isOverNight(): boolean;
+  updateLowestPrice(results: CarHireQuoteResultArray): ICheapestPrice;
+  getCarHireAvailabilityDetail(
+    locationDetails: CarHireInputIdentifiers,
+    isLoading: BehaviorSubject<boolean>
+  ): Observable<CarHireDetailRequestResponse>;
+  addCarHireToBasket(
+    carHireQuote: CarHireVehicleAvailibility,
+    carHireQuery: SearchCarHireQueryVariables
+  ): Promise<boolean>;
+}

package/projects/obtservices/base/src/lib/vendor/interfaces/Ienterprise-basket.service.ts

@@ -0,0 +1,127 @@
+import moment from 'moment';
+import { BehaviorSubject, Observable, Observer, Subject } from 'rxjs';
+import {
+  AddItemToBasket,
+  BasketItem,
+  ManagementInfo,
+  PaymentMethod,
+  SupplementaryBookingInfo
+} from '../types/graphql.types';
+import {
+  GetUserBasketItemResult,
+  GetUserBasketResult,
+  UserBasketResult
+} from '../types/types';
+import { Traveller } from '../models/traveller.object';
+import { EnterpriseSearchServiceInterface } from './Isearch.service';
+import {
+  BasketDetails,
+  BasketItemManagementInfo,
+  BasketPrices
+} from '../services/enterprise-basket.service';
+
+export interface InternalBasketInterface {
+  subject: BehaviorSubject<any>;
+  id?: string;
+  tempid?: string;
+  title: string;
+  prices: { [key: string]: number };
+  mixedCurrency: boolean;
+  count: number;
+  miGroups: {};
+  basketInfoMiDetails: {};
+  suppInfo: {};
+  destructor(): void;
+  next(basket: UserBasketResult): void;
+}
+
+export interface EnterpriseBasketServiceInterface {
+  basketChangeEmitter: BehaviorSubject<string>;
+  highlightBasketItemsEmitter: Subject<GetUserBasketItemResult[]>;
+  baskets: BehaviorSubject<InternalBasketInterface[]>;
+  menuState: string;
+  addToBasket(
+    item: AddItemToBasket.Variables,
+    intBasket: InternalBasketInterface,
+    searchService: EnterpriseSearchServiceInterface,
+    travellers: Traveller[]
+  ): any;
+  createBasket(): Promise<InternalBasketInterface>;
+  loadBasket(id: string): void;
+  removeBasketItem(basketId: string, item: BasketItem): void;
+  getDefaultBasket(): Promise<InternalBasketInterface>;
+  toggleMenu(): void;
+  closeMenu(): void;
+  subsribeToBasket(id: string, observer: Observer<BasketDetails>): void;
+  getLatestBasketItemForTypes(basketItems: BasketItem[]): any;
+  getNumberItemsForBasket(basket: InternalBasketInterface): number;
+  removeBasket(basketid: string): any;
+  removeExpiredItems(id: string): void;
+  continueSearchAndBook(
+    basketItems: any[],
+    itiniaryUrl: string[],
+    searchService: EnterpriseSearchServiceInterface
+  ): {};
+  addTravellers(
+    basketid: string,
+    basketItem: BasketItem,
+    travellers: Traveller[],
+    index: number
+  ): void;
+  setLeadPassenger(
+    basketid: string,
+    basketItem: BasketItem,
+    travellers: Traveller,
+    index: number
+  ): void;
+  revalidate(basketid: string): void;
+  setBasketItemMiGroup(
+    basketid: string,
+    basketItemid: string,
+    group: string
+  ): void;
+  acceptNewPrice(intBasketid: string, item: BasketItem): void;
+  validateFreeValeMi(miItem: ManagementInfo, freeValue: string): any;
+  setMiFreeValue(
+    basketid: string,
+    miItem: ManagementInfo,
+    freeValue: string,
+    userId: string
+  ): void;
+  setMiSelectedValue(
+    basketid: string,
+    miItem: ManagementInfo,
+    selectedValue: string,
+    userId: string
+  ): void;
+  getMiAutoSugestions(
+    miId: string,
+    partialLabel: string,
+    isLoading: BehaviorSubject<boolean>
+  ): Observable<any>;
+  saveMiData(basketId: string, bmiArray: BasketItemManagementInfo[]): void;
+  sendBasketForApproval(basketid: string): void;
+  bookBasket(
+    basketid: string,
+    supplementaryInfo: SupplementaryBookingInfo[]
+  ): void;
+  getBasket(query: {
+    id: string;
+    withSupplemental: true;
+  }): Observable<GetUserBasketResult>;
+  reset(): void;
+  atLeastOneSearchChosen(): boolean;
+  getBasketStats(index: number): BehaviorSubject<BasketPrices>;
+  moveBasketItem(
+    originalBasketId: string,
+    basketItem: BasketItem,
+    basketIdToMoveTo: string
+  ): void;
+  updateBasketNotes(basketId: string, notes: string): void;
+  updateBasketTitle(basketId: string, title: string): void;
+  setBasketItemPaymentOption(
+    basket: BasketDetails,
+    basketItem: BasketItem,
+    paymentMethod: string
+  ): Promise<void>;
+}

package/projects/obtservices/base/src/lib/vendor/interfaces/Ieurostar-enterprise-search.ts

@@ -0,0 +1,197 @@
+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 {
+  EurostarFare,
+  EurostarItem,
+  EurostarQuoteResult,
+  EurostarQuoteResultArray,
+  EurostarResults,
+  FlightDirectionEnum,
+  NgbDateStruct,
+  OBTAirlinesDetails,
+  OBTAirportDetails
+} from '../types/types';
+import { SortTypesEurostar } from '../classes/eurostar-enterprise-search';
+import { BaseEnterpriseSearch } from '../classes/base-enterprise';
+import { ICheapestPrice } from './cheapest-price';
+import { IMultiDestination } from './flight-multi-destination.interface';
+import { EurostarSearchType } from '../classes/eurostar-search-type.enum';
+import { TimeWindow } from '../classes/flight-enterprise-search';
+import { ValueDisplay } from './value-display';
+
+export interface EurostarTempParams {
+  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: EurostarSearchType;
+  multiDestination: IMultiDestination[];
+}
+
+export interface EurostarEnterpriseSearchInterface
+  extends BaseEnterpriseSearch<
+      EurostarTempParams,
+      EurostarQuoteResult,
+      EurostarQuoteResultArray
+    >,
+    EurostarTempParams {
+  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: EurostarSearchType;
+  multiDestination: IMultiDestination[];
+  displayAddHotel: boolean;
+  searchTypes: ValueDisplay[];
+
+  startSearch(): any;
+  getSearchQuery(): SearchFlightsV2QueryVariables;
+  sortResults(sortMethodValue: SortTypesEurostar, givenResults?: EurostarResults[]): void;
+  updateFromPreviousSearches(
+    previousItems: Record<ServiceType, BasketItem>
+  ): void;
+  getTotalBaggage(result: FlightItinerary): number;
+  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[]
+  ): {};
+  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: EurostarResults[]): ICheapestPrice;
+  resetParams(): void;
+  selectGroupedEurostar(
+    selectedFlight: EurostarItem,
+    fare: EurostarFare,
+    direction: FlightDirectionEnum
+  ): void;
+  isOverNight(): boolean;
+  addEurostarJourneysToBasket(selectedFlight: FlightItinerary): void
+}