@sabstravtech/obtservices 0.0.0 → 0.0.1

package/dist/obtservices/base/lib/vendor/fetchers/search-rail-stations.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 { SearchRailStationsResultArray } from '../types/types';
+import { SearchRailStationsQuery, SearchRailStationsQueryVariables } from '../types/graphql.types';
+declare type R = {
+    searchRailStations: P;
+};
+declare type P = SearchRailStationsResultArray;
+declare type A = SearchRailStationsQueryVariables;
+declare type M = SearchRailStationsQuery;
+export declare type SearchRailStationsFetcherType = {
+    fetch: (a: A) => Observable<ApolloQueryResult<M>>;
+};
+export declare class BaseSearchRailStationsFetcher<Q extends SearchRailStationsFetcherType> extends FetchableList<Q, A, R, P, M> {
+    constructor(queryGQL: Q, helpers: BaseHelperRoutines, modalService: BaseModalOpenerService);
+    protected getDataFromResult(results: ApolloQueryResult<R>): P;
+}
+export {};

package/dist/obtservices/base/lib/vendor/fetchers/search-users-can-book-for-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 { SearchUserCanBookForResult } from '../types/types';
+import { SearchUserCanBookForQuery, SearchUserCanBookForQueryVariables } from '../types/graphql.types';
+declare type R = {
+    searchUserCanBookFor: P;
+};
+declare type P = SearchUserCanBookForResult;
+declare type A = SearchUserCanBookForQueryVariables;
+declare type M = SearchUserCanBookForQuery;
+export declare type SearchUserCanBookForFetcherType = {
+    fetch: (a: A) => Observable<ApolloQueryResult<M>>;
+};
+export declare class BaseSearchUsersCanBookForFetcher<Q extends SearchUserCanBookForFetcherType> extends FetchableList<Q, A, R, P, M> {
+    constructor(queryGQL: Q, helpers: BaseHelperRoutines, modalService: BaseModalOpenerService);
+    protected getDataFromResult(results: ApolloQueryResult<R>): P;
+}
+export {};

package/dist/obtservices/base/lib/vendor/fetchers/user-addresses.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 { UserAddressesResult } from '../types/types';
+import { GetUserAddressesQuery, GetUserAddressesQueryVariables } from '../types/graphql.types';
+declare type R = {
+    getUserAddresses: P;
+};
+declare type P = UserAddressesResult;
+declare type A = GetUserAddressesQueryVariables;
+declare type M = GetUserAddressesQuery;
+export declare type UserAddressFetcherType = {
+    fetch: (a: A) => Observable<ApolloQueryResult<M>>;
+};
+export declare class BaseUserAddressesFetcher<Q extends UserAddressFetcherType> extends FetchableList<Q, A, R, P, M> {
+    constructor(getUserAddressGQL: Q, helpers: BaseHelperRoutines, modalService: BaseModalOpenerService);
+    protected getDataFromResult(results: ApolloQueryResult<R>): P;
+}
+export {};

package/dist/obtservices/base/lib/vendor/fetchers/user-fetcher.d.ts

@@ -0,0 +1,20 @@
+import { FetchableObject } from './object-fetchable-enterprise';
+import { BaseModalOpenerService } from '../services/modal-opener.service';
+import { Observable } from 'rxjs';
+import { ApolloQueryResult } from '@apollo/client/core';
+import { GetUserQuery, GetUserQueryVariables } from '../types/graphql.types';
+import { GetUserResult } from '../types/types';
+declare type A = GetUserQueryVariables;
+declare type R = {
+    getUser: P;
+};
+declare type P = GetUserResult;
+declare type M = GetUserQuery;
+export declare type SearchGetUserFetcherType = {
+    fetch: (a: A) => Observable<ApolloQueryResult<M>>;
+};
+export declare class BaseGetUserFetcher<Q extends SearchGetUserFetcherType> extends FetchableObject<Q, A, R, P, M> {
+    constructor(getUserGQL: Q, modalService: BaseModalOpenerService);
+    protected getDataFromResult(results: ApolloQueryResult<R>): P;
+}
+export {};

package/dist/obtservices/base/lib/vendor/fetchers/user-message.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 { UserMessagesResult } from '../types/types';
+import { GetUserMessagesQuery, GetUserMessagesQueryVariables } from '../types/graphql.types';
+declare type R = {
+    getUserMessages: P;
+};
+declare type P = UserMessagesResult;
+declare type A = GetUserMessagesQueryVariables;
+declare type M = GetUserMessagesQuery;
+export declare type UserMessageFetcherType = {
+    fetch: (a: A) => Observable<ApolloQueryResult<M>>;
+};
+export declare class BaseUserMessagesFetcher<Q extends UserMessageFetcherType> extends FetchableList<Q, A, R, P, M> {
+    constructor(getUserMessagesGQL: Q, helpers: BaseHelperRoutines, modalService: BaseModalOpenerService);
+    protected getDataFromResult(results: ApolloQueryResult<R>): P;
+}
+export {};

package/dist/obtservices/base/lib/vendor/fetchers/user-products-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 { UserProductsResult } from '../types/types';
+import { GetUserServicesQuery, GetUserServicesQueryVariables } from '../types/graphql.types';
+declare type R = {
+    getUserServices: P;
+};
+declare type P = UserProductsResult;
+declare type A = GetUserServicesQueryVariables;
+declare type M = GetUserServicesQuery;
+export declare type UserProductsFetcherType = {
+    fetch: (a: A) => Observable<ApolloQueryResult<M>>;
+};
+export declare class BaseUserProductsFetcher<Q extends UserProductsFetcherType> extends FetchableList<Q, A, R, P, M> {
+    constructor(getUserServicesGQL: Q, helpers: BaseHelperRoutines, modalService: BaseModalOpenerService);
+    protected getDataFromResult(results: ApolloQueryResult<R>): P;
+}
+export {};

package/dist/obtservices/base/lib/vendor/fetchers/user-ui-configs-fetcher.d.ts

@@ -0,0 +1,23 @@
+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';
+declare type R = {
+    getUserUIConfigs: {
+        all: P;
+    };
+};
+declare type P = UserUiConfigsResult;
+declare type A = GetUserUiConfigsQueryVariables;
+declare type M = GetUserUiConfigsQuery;
+export declare type UserUiConfigsFetcherType = {
+    fetch: (a: A) => Observable<ApolloQueryResult<M>>;
+};
+export declare class BaseUserUiConfigsFetcher<Q extends UserUiConfigsFetcherType> extends FetchableList<Q, A, R, P, M> {
+    constructor(getUserUiConfigsGQL: Q, helpers: BaseHelperRoutines, modalService: BaseModalOpenerService);
+    protected getDataFromResult(results: ApolloQueryResult<R>): P;
+}
+export {};

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

@@ -0,0 +1,133 @@
+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 declare enum TaxiFormMode {
+    ADDRESS = "location",
+    STATION = "station"
+}
+export declare enum AirportSearchMode {
+    PICKUP = "Airport Pick Up",
+    DROPOFF = "Airport drop off"
+}
+export interface TransType {
+    key: CabHireVehicleType;
+    value: string;
+    id: number;
+}
+export declare 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;
+}
+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/dist/obtservices/base/lib/vendor/interfaces/Icarhire-enterprise-search.d.ts

@@ -0,0 +1,99 @@
+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 { 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/dist/obtservices/base/lib/vendor/interfaces/Ienterprise-basket.service.d.ts

@@ -0,0 +1,64 @@
+import { BehaviorSubject, Observable, Observer, Subject } from 'rxjs';
+import { AddItemToBasket, BasketItem, ManagementInfo, 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/dist/obtservices/base/lib/vendor/interfaces/Ieurostar-enterprise-search.d.ts

@@ -0,0 +1,124 @@
+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;
+}