@sabstravtech/obtservices 0.0.0 → 0.0.2

package/dist/obtservices/base/lib/vendor/classes/helpers.d.ts

@@ -0,0 +1,173 @@
+import moment from 'moment';
+import _ from 'lodash';
+import { Traveller } from '../models/traveller.object';
+import { BasketDetails } from '../services/enterprise-basket.service';
+import { ManagementInfoAndIsValid } from './management-info-and-valid';
+import { UserServices } from '../interfaces/Iuser.service';
+import { FlightDirectionEnum, MinMax, NgbDateStruct, Schema } from '../types/types';
+import { Airport, BasketItem, FareConditions, FlightItinerary, FlightJourney, Service, ServiceType, UserPassengerTypeInput } from '../types/graphql.types';
+import { SupplementaryBookingInfoInterface } from '../interfaces/Isupplementary-booking-info-impl';
+export declare class BaseHelperRoutines {
+    static READ_DATE_FORMAT: string;
+    static READ_TIME_FORMAT: string;
+    static DATE_FORMAT: string;
+    static ISO_DATA_FORMAT: string;
+    static ISO_DATA_FORMAT_TIME: string;
+    static ISO_DATA_FORMAT_NO_HYPHANS: string;
+    static TIME_FORMAT: string;
+    static TIME_FORMAT_COLON: string;
+    static MMDDYY_DATE: string;
+    minToHour(dur: number): string;
+    makeColonTime(time: string): string;
+    nonNullMin(key: string, ...args: any[]): any;
+    joinByComma(...attributes: any[]): string;
+    mutuallyInclude(a: string, b: string): boolean;
+    findByKey(array: any[], key: string, value: string): any;
+    dateToNgDate(date: Date): NgbDateStruct;
+    convertToYYMMDD(date: string): string;
+    formatDateToMMDDYYY(date: Date): string;
+    formatDate(date: moment.Moment): string;
+    formatTime(date: moment.Moment): string;
+    formatTimeColon(date: moment.Moment): string;
+    formatIsoDate(date: moment.Moment): string;
+    formatIsoDateTime(date: moment.Moment): string;
+    formatIsoDateNoHyphans(date: moment.Moment): string;
+    generateTimesList(from?: number, to?: number, step?: number): string[];
+    momentToNgDate(date: moment.Moment): NgbDateStruct;
+    ngDateToDate(date: NgbDateStruct): Date;
+    ngDateToMoment(date: NgbDateStruct, time?: string): moment.Moment;
+    todayToNgbDateStruct(): NgbDateStruct;
+    objectToArray(object: Record<string, any>): Array<any>;
+    yyyymmddToDate(value: string): Date;
+    yyyymmddToMoment(value: string): moment.Moment;
+    yymmddToMoment(value: string): moment.Moment;
+    yymmddToNgbDate(value: string): NgbDateStruct;
+    yymmdd_hhmmToMoment(date: string, time: string): moment.Moment;
+    yyyymmdd_hhmmToMoment(date: string, time: string): moment.Moment;
+    yyyymmddToNgDate(value: string): NgbDateStruct;
+    yyyymmddTimeToNgDate(date: string, time: string): NgbDateStruct;
+    yyyymmddTimeToMoment(date: string): moment.Moment;
+    hhmmToTime(value: string): string;
+    dateStringToyyyymmdd(d: string): string | null;
+    timeStringTohh_mm(t: string): string | null;
+    stringToBool(s: string): boolean;
+    clone<T = any>(toClone: T): T;
+    replaceKeysInText(text: string, replacements: Record<string, string>): string;
+    getNextMinuets(date?: moment.Moment, minutesToRound?: number): string;
+    /********************************************************************************************
+     * Below are functions needed for generating the hashed number once token, taken as required	*
+     * Don't Mess with these																		*
+     ********************************************************************************************/
+    getNumberOnceValue(token: string): string;
+    guid(): any;
+    s4(): any;
+    capitaliseFirstLetter(word: string): string;
+    fromObject(...args: any[]): any;
+    momentRoundMinutes(time: moment.Moment, round: number): moment.Moment;
+    round(date: any, duration: any): moment.Moment;
+    icsFold(body: string): string;
+    splitAddressLine(line: string, len: number): {
+        line: string;
+        residue: string;
+    };
+    daysBetween(start: moment.Moment, end: moment.Moment): number;
+    mapPromise<T = any, R = any>(a: T[], f: (val: T, index: number) => R | Promise<R>, max?: number): Promise<R[]>;
+    mapSeriesPromise<T = any, R = any>(a: T[], f: (val: T, index: number) => R | Promise<R>): Promise<R[]>;
+    obj2queryString(obj: any): string;
+    stripPunctuation(s: string): string;
+    replaceAll(haystack: string, needle: string, replacement: string): string;
+    dateTime(sabsDate: string, sabsTime: string): any;
+    alternateJSONStringify(jsonObject: any): string;
+    ConvertObjectToArray(object: object): any[];
+    addDay(dateStruct: NgbDateStruct): any;
+    hashCode(toCode: string): string;
+    MMddyyToNgb(date: string): NgbDateStruct;
+    selectedChildrenTravellers(selectedTravellers: Traveller[], type: ServiceType): Traveller[];
+    selectedTravellers(travellers: Traveller[], type: ServiceType): {
+        adults: Traveller[];
+        children: Traveller[];
+        infants: Traveller[];
+    };
+    selectedAdultTravellers(selectedTravellers: Traveller[], type: ServiceType): Traveller[];
+    private _isChild;
+    isChildFlight(traveller: Traveller): boolean;
+    isChildRail(traveller: Traveller): boolean;
+    isChildEurostar(traveller: Traveller): boolean;
+    uniqBy(array: any[], value: string): any[];
+    isChild(traveller: Traveller | Date, travelType: ServiceType): boolean;
+    isInfant(traveller: Traveller | Date, travelType: ServiceType): boolean;
+    getAgeType(traveller: Traveller, travelType: ServiceType): any;
+    getMaxChildAge(type: ServiceType): string;
+    getDefaultAdultAge(type: ServiceType): string;
+    transform(array: any[], callback: _.MemoVoidArrayIterator<any, any[]>, acc: any): any[];
+    arrayToObject<T extends {
+        [key: string]: any;
+    }>(array: T[], field: string): {
+        [key: string]: T;
+    };
+    arrayToObjectArray<T extends {
+        [key: string]: any;
+    }>(array: T[], field: string): {
+        [key: string]: T[];
+    };
+    getTerminals(airport: Airport): string[];
+    fieldFromObject(obj: object, field: string): string;
+    mapFieldFromObject<K extends string | number | symbol, T>(field: K): (obj: Record<K, any>) => T;
+    removeNulls<T>(query: T): T;
+    getTravellersId(travellers: Traveller[]): string[];
+    /**
+     * loop over the query object param and convert any moment date objects to date-time strings
+     * @param query
+     * @param debug
+     */
+    sanitizeMomentDates(query: any, debug?: boolean): any;
+    toStrings<T>(toFormat: T, schema: Schema): T;
+    private _formatValue;
+    makeTimeWindow(dateTime: moment.Moment, start: number, end: number): string;
+    inRange(tocheck: number, range: MinMax): boolean;
+    makeUsers(travellers: Traveller[]): UserPassengerTypeInput[];
+    makeMomentDayTime(addDay?: number, hh?: number, m?: number): moment.Moment;
+    sanatizeReturns<T>(defaults: T, suppliedData: Partial<T>, momentFields?: (keyof T)[]): T;
+    miIsValid(toCheck: ManagementInfoAndIsValid[]): boolean;
+    isMiValid(miPerItem: ManagementInfoAndIsValid[], miPerUser: {
+        [key: string]: {
+            managementInfo: ManagementInfoAndIsValid[];
+        };
+    }): boolean;
+    needsMi(basket: BasketDetails, needsToViewMi: boolean): boolean;
+    findService(services: UserServices, id: string): Service;
+    allTrue(suppInfo: SupplementaryBookingInfoInterface[], filter: (suppInfo: SupplementaryBookingInfoInterface) => boolean): boolean;
+    joinFromAttribute<T>(joinCharacter: string, attribute: keyof T, array: T[]): string;
+    /**
+     * @description - split up an array into equal parts
+     * @param array - the array to split up
+     * @param size - the size of the constituant parts
+     * @param includeRemainder - wether or not to include any remaing results - default true
+     */
+    splitUpArray(array: any[], size: number, includeRemainder?: boolean): any[];
+    getTimeDifference(depDateTime: string, arrDateTime: string): number;
+    dayDifference(dept: string, arr: string): string;
+    makeFareRules(flight: FlightItinerary, direction: FlightDirectionEnum): {
+        rules: FareConditions;
+        flights: FlightJourney[];
+    };
+    /**
+     * @desc - generates ics file content
+     */
+    generateIcsFileContents(basketItems: BasketItem[]): string;
+    /**
+     * @desc - generates ics file body content based on the provided basketItems param
+     */
+    generateIcsFileBodyContent(basketItems: BasketItem[]): string;
+    /**
+     * @desc - creates an element in memory and triggers click event to download ics file
+     */
+    downloadIcs(filename: string, text: string): void;
+    /**
+     * @description - split a string on capitals
+     * @param rawString - the string we want to split
+     * @param join - whether or not to joing the split into one string, seperated by a space
+     * @returns string/string[]
+     */
+    splitStringOnCapitals(rawString: string, join?: boolean): string | string[];
+}

package/dist/obtservices/base/lib/vendor/classes/hotel-enterprise-search.d.ts

@@ -0,0 +1,176 @@
+import moment from 'moment';
+import { BaseEnterpriseSearch } from './base-enterprise';
+import { BaseStorageService } from '../services/storage.service';
+import { BaseHelperRoutines } from './helpers';
+import { BehaviorSubject, Observable, Subject } from 'rxjs';
+import { BaseEnvironment } from './enviroment';
+import { BaseHotelAvalibilityService } from '../services/hotel-avallibility.service';
+import { Country, HotelQuoteResult, HotelQuoteResultArray, LocationTypes, NgbDateStruct, LocationDetails, RecentSearch } from '../types/types';
+import { BasketItem, ConfermaOfficeNames, HotelLocation, HotelRoom, HotelTag, SaveRecentSearchMutationVariables, SearchHotelsQueryVariables, ServiceType } from '../types/graphql.types';
+import { BaseHotelQuoteFetcher, HotelQuoteFetcherType } from '../fetchers/hotel-quote-fetcher';
+import { UserServiceInterface } from '../interfaces/Iuser.service';
+import { EnterpriseSearchServiceInterface } from '../interfaces/Isearch.service';
+import { AbstractHttpCallService } from '../services/http-call.service';
+import { HotelAvalinilityFetcherType } from '../fetchers/hotel-avaliability-fetcher';
+import { EnterpriseBasketServiceInterface } from '../interfaces/Ienterprise-basket.service';
+import { AvailabilityObject, DisplayFilterSettings, HotelDetails, HotelDetailsArray, HotelEnterpriseSearchInterface, HotelFilters, HotelTempParams, HotelView } from '../interfaces/Ihotel-enterprise-search';
+import { ICheapestPrice } from '../interfaces/cheapest-price';
+import { Traveller } from '../models/traveller.object';
+import { BaseSearchConfermaQuicklistFetcher, ConfermaQuicklistFetcherType } from '../fetchers/conferma-quicklist.fetcher';
+import { BaseGetRailStationFetcher, GetRailStationFetcherType } from '../fetchers/get-rail-station.fetcher';
+export declare enum SortTypesHotel {
+    distance = "distance",
+    name = "name",
+    price = "price"
+}
+export declare class HotelEnterpriseSearch<HQ_Q extends HotelQuoteFetcherType, HA_Q extends HotelAvalinilityFetcherType, QL_Q extends ConfermaQuicklistFetcherType, GRS_Q extends GetRailStationFetcherType> extends BaseEnterpriseSearch<HotelTempParams, HotelQuoteResultArray, HotelDetailsArray> implements HotelEnterpriseSearchInterface {
+    private hotelFetcher;
+    private helpers;
+    private userService;
+    private environment;
+    private avaliabilityService;
+    private basketService;
+    private searchService;
+    private httpCallService;
+    private quickListFetcher;
+    private getRailStationFetcher;
+    static readonly MAX_HOTEL_ROOMS = 4;
+    static readonly STORAGE_SESSION_PARAMS = "search_hotel";
+    static readonly STORAGE_SESSION_RESULTS = "results_hotel";
+    type: ServiceType;
+    private travellers;
+    location_types: BehaviorSubject<LocationTypes[]>;
+    offices: BehaviorSubject<LocationTypes[]>;
+    lastActivePage: BehaviorSubject<number>;
+    readonly galleries: {
+        [key: string]: string[];
+    };
+    private occupied;
+    private results_details;
+    private _checkin_date_ngb;
+    private _checkout_date_ngb;
+    get chains(): string[];
+    get amenities(): string[];
+    get maxDistance(): number;
+    get maxPrice(): number;
+    get currency(): string;
+    set currency(value: string);
+    filterChange: Subject<any>;
+    selectItemMapView: Subject<any>;
+    display: DisplayFilterSettings;
+    min_date: {
+        year: number;
+        month: number;
+        day: number;
+    };
+    min_return_date: {
+        year: number;
+        month: number;
+        day: number;
+    };
+    private localFilters;
+    currentView: HotelView;
+    private _max_no_of_rooms;
+    private _max_rooms_array;
+    private _max_no_of_occupants;
+    private _max_occupant_array;
+    private _distance_list;
+    private _default_currency;
+    get checkin_date_ngb(): NgbDateStruct;
+    set checkin_date_ngb(value: NgbDateStruct);
+    get checkout_date_ngb(): NgbDateStruct;
+    set checkout_date_ngb(value: NgbDateStruct);
+    get checkin_date(): moment.Moment;
+    set checkin_date(newDate: moment.Moment);
+    get checkout_date(): moment.Moment;
+    set checkout_date(newDate: moment.Moment);
+    get no_of_rooms(): number;
+    set no_of_rooms(newRooms: number);
+    get no_of_occupants(): number;
+    set no_of_occupants(newOcc: number);
+    get default_currency(): string;
+    set default_currency(currency: string);
+    get location(): any;
+    set location(newLoc: any);
+    get formatted_location(): string;
+    get distance(): number;
+    set distance(newDist: number);
+    get prefered_hotels_only(): boolean;
+    set prefered_hotels_only(newPref: boolean);
+    get country(): Country;
+    set country(newCont: Country);
+    get postcode(): LocationDetails;
+    set postcode(postcode: LocationDetails);
+    get trainsStation(): LocationDetails;
+    set trainsStation(station: LocationDetails);
+    get office(): ConfermaOfficeNames;
+    set office(office: ConfermaOfficeNames);
+    get hotel_name(): string;
+    set hotel_name(newName: string);
+    get hotel_chain(): any;
+    set hotel_chain(newChain: any);
+    get max_rooms_array(): number[];
+    get max_occupant_array(): number[];
+    get distance_list(): number[];
+    get location_type_select(): LocationTypes;
+    set location_type_select(value: LocationTypes);
+    get filters(): HotelFilters;
+    constructor(hotelFetcher: BaseHotelQuoteFetcher<HQ_Q>, helpers: BaseHelperRoutines, userService: UserServiceInterface, environment: BaseEnvironment, avaliabilityService: BaseHotelAvalibilityService<HA_Q>, basketService: EnterpriseBasketServiceInterface, storageService: BaseStorageService, searchService: EnterpriseSearchServiceInterface, httpCallService: AbstractHttpCallService, quickListFetcher: BaseSearchConfermaQuicklistFetcher<QL_Q>, getRailStationFetcher: BaseGetRailStationFetcher<GRS_Q>);
+    protected resultsSessionName: string;
+    private query;
+    makeLocations(location: HotelLocation[]): {
+        [key: string]: HotelLocation[];
+    };
+    sortTags(tags: HotelTag[]): any[];
+    protected resetQuery(): void;
+    private _isValid;
+    startSearch(): Promise<boolean>;
+    getRecentSearchQuery(query: SearchHotelsQueryVariables): SaveRecentSearchMutationVariables;
+    startRecentSearch(recentSearch: RecentSearch): void;
+    private getRailStationByCode;
+    getSearchQuery(): SearchHotelsQueryVariables;
+    buildQuery(): void;
+    makeHotelAvalilityObject(hotel: HotelQuoteResult): AvailabilityObject;
+    filterResults: () => void;
+    filterLighteningResults: () => void;
+    private inPriceRange;
+    private inDistanceRange;
+    private containsHotelname;
+    private inLighteningPriceRange;
+    private hasChain;
+    private breakfastTypeFilter;
+    byMostExpensive(): void;
+    /**
+     * @param {boolean} min
+     * @param {boolean} debug set this to true to output console logs
+     * @description sorts results by price according to the 'min' paramater. min = true (lowest price first), min = false (highest price first)
+     * In summary, this method creates a sorted array of hotels with prices and an array of hotels WITHOUT prices,
+     * then finally joins these 2 temporary arrays together before triggering the next observable.
+     */
+    sortByPrice(min?: boolean, debug?: boolean): void;
+    sortByName(): void;
+    sortByDistance(): void;
+    byPreferred(): void;
+    private preferredToInt;
+    private intToPreferred;
+    addFilter(filter: string, type: keyof HotelFilters): void;
+    removeFilter(filter: string, type: keyof HotelFilters): void;
+    resetFilters(): void;
+    updateFromPreviousSearches(previousItems: Record<ServiceType, BasketItem>): void;
+    private hasPreferred;
+    getmaxPriceForCurrency(currency: string): any;
+    private getExtraFilter;
+    private getAmenitiesFilter;
+    private convertToOneString;
+    getImages(HolidayCode: string): Observable<string[]>;
+    addPaginationPage(currentPage: number): any;
+    toggleView(): void;
+    calcDayDiff(): number;
+    updateLowestPrice(results: HotelDetails[]): ICheapestPrice;
+    getRoomNumber(): void;
+    /**
+     *	@desc - return the occupancy for a room - need to calculate based on no of rooms, no of travellers and currently occupied rooms;
+     **/
+    calcRoomOccupancy(no_of_rooms: number, travellers: number): number;
+    addHotelRoomToBasket(hotel: HotelQuoteResult, hotelRoom: HotelRoom, hotelQuery: SearchHotelsQueryVariables, travellers?: Traveller[]): Promise<boolean>;
+}

package/dist/obtservices/base/lib/vendor/classes/irl-enterprise-search.d.ts

@@ -0,0 +1,139 @@
+import moment, { Moment } from 'moment';
+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 } from '../interfaces/rail-ticket-group.interface';
+import { ValueDisplay } from '../interfaces/value-display';
+import { NgbDateStruct, IrlQuoteResultArray, RecentSearch } from '../types/types';
+import { BasketItem, IrlClass, IrlJourneyOption, IrlJourneyOptions, IrlTicketOption, SearchIrlQueryVariables, ServiceType, IrlJourneyType, IrlSupplier } from '../types/graphql.types';
+import { BaseIrlQuoteFetcher, IrlQuoteFetcherType } from '../fetchers/irl-quote-fetcher';
+import { EnterpriseBasketServiceInterface } from '../interfaces/Ienterprise-basket.service';
+import { EnterpriseSearchServiceInterface } from '../interfaces/Isearch.service';
+import { IRLEnterpriseSearchInterface, IrlTempParams } from '../interfaces/Iirl-enterprise-search';
+import { ICheapestPrice } from '../interfaces/cheapest-price';
+export declare enum IrlSearchCriteria {
+    Depart = "Depart After",
+    Arrive = "Arrive Before"
+}
+export declare class IRLEnterpriseSearch<Q extends IrlQuoteFetcherType> extends BaseEnterpriseSearch<IrlTempParams, IrlQuoteResultArray, IrlQuoteResultArray> implements IRLEnterpriseSearchInterface {
+    private Irlfetcher;
+    private helpers;
+    private basketService;
+    private searchService;
+    static readonly STORAGE_SESSION_PARAMS = "search_irl";
+    static readonly STORAGE_SESSION_RESULTS = "irl_results";
+    static readonly PASSING_POINT = "Passing";
+    private travellers;
+    protected resultsSessionName: string;
+    searchTypes: {
+        display: string;
+        value: IrlJourneyType;
+    }[];
+    classTypes: {
+        display: string;
+        value: IrlClass;
+    }[];
+    ageRanges: {
+        key: string;
+        value: string;
+    }[];
+    railCriteria: IrlSearchCriteria[];
+    travelCards: {
+        display: string;
+        value: string;
+    }[];
+    type: ServiceType;
+    minOutboundDate: NgbDateStruct;
+    minInboundDate: NgbDateStruct;
+    private _timeArray;
+    private _canCombine;
+    private _viaLocation;
+    private _travellingFrom;
+    private _travellingTo;
+    protected _originalUserSearch: IrlTempParams;
+    get noOfAdults(): number;
+    set noOfAdults(adults: number);
+    get noOfChildren(): number;
+    set noOfChildren(children: number);
+    get travellingTo(): any;
+    set travellingTo(tt: any);
+    get travellingFrom(): any;
+    set travellingFrom(tt: any);
+    private _supplier;
+    get supplier(): IrlSupplier;
+    set supplier(data: IrlSupplier);
+    private _countryCode;
+    get countryCode(): string;
+    set countryCode(data: string);
+    private _class;
+    get class(): IrlClass;
+    set class(data: IrlClass);
+    private _outboundDepartureDateTime;
+    get outboundDepartureDateTime(): Moment;
+    set outboundDepartureDateTime(data: Moment);
+    private _departureLocationId;
+    get departureLocationId(): string;
+    set departureLocationId(data: string);
+    private _arrivalLocationId;
+    get arrivalLocationId(): string;
+    set arrivalLocationId(data: string);
+    private _adults;
+    get adults(): number;
+    set adults(data: number);
+    private _children;
+    get children(): number;
+    set children(data: number);
+    private _returnDepartureDateTime;
+    get returnDepartureDateTime(): Moment;
+    set returnDepartureDateTime(data: Moment);
+    private _ageRange;
+    get ageRange(): string;
+    set ageRange(data: string);
+    get chosenSearchClass(): IrlClass;
+    set chosenSearchClass(classR: IrlClass);
+    get outBoundDateTime(): moment.Moment;
+    set outBoundDateTime(newDateTime: moment.Moment);
+    private _outbound_date;
+    get outbound_date(): NgbDateStruct;
+    set outbound_date(value: NgbDateStruct);
+    private _outbound_time;
+    get outbound_time(): string;
+    set outbound_time(value: string);
+    private _return_date;
+    get return_date(): NgbDateStruct;
+    set return_date(value: NgbDateStruct);
+    private _return_time;
+    get return_time(): string;
+    set return_time(value: string);
+    get timeArray(): ValueDisplay[];
+    private _cheapestStandard;
+    get cheapestStandard(): IrlTicketOption;
+    private _cheapestFirst;
+    get cheapestFirst(): IrlTicketOption;
+    private _irlClass;
+    get irlClass(): IrlClass;
+    set irlClass(data: IrlClass);
+    private _journeytype;
+    get journeyType(): IrlJourneyType;
+    set journeyType(data: IrlJourneyType);
+    constructor(Irlfetcher: BaseIrlQuoteFetcher<Q>, helpers: BaseHelperRoutines, basketService: EnterpriseBasketServiceInterface, storageService: BaseStorageService, searchService: EnterpriseSearchServiceInterface);
+    protected resetQuery(): void;
+    private _isValid;
+    startSearch(): Promise<boolean>;
+    startRecentSearch(recentSearch: RecentSearch): void;
+    private _updateOutboundDateTime;
+    private _updateReturnDateTime;
+    getSearchQuery(): SearchIrlQueryVariables;
+    combineChildTickets(tickets: RailTicketGroups): RailTicketGroups;
+    setTicketsGroups(results: IrlJourneyOption[]): any;
+    updateFromPreviousSearches(previousItems: Record<ServiceType, BasketItem>): void;
+    updateCanCombine(tkt: IrlTicketOption): void;
+    /**
+     * @description - determine if a fare can be combined with what we currently have selected
+     */
+    clearUnneededTickets(way: string, group: RailTicketGroup, timeSlotId: string): RailTicketGroup;
+    getLegsFromRailJourneyOption(railJourneyOption: IrlJourneyOption): any[];
+    updateLowestPrice(results: IrlJourneyOptions[]): ICheapestPrice;
+    findCheapestTicket(results: IrlJourneyOptions[]): number;
+}

package/dist/obtservices/base/lib/vendor/classes/limited-cache.class.d.ts

@@ -0,0 +1,21 @@
+declare class Node<T> {
+    key: string;
+    value: T;
+    next: Node<T>;
+    pre: Node<T>;
+    constructor(key: string, value: T);
+}
+export declare class LimitedCache<T> {
+    private size;
+    private cache;
+    private count;
+    private head;
+    constructor(size?: number);
+    get(key: string): T;
+    set(key: string, value: T): void;
+    hasKey(key: string): boolean;
+    deleteItem(node: Node<T>): void;
+    addToHead(item: Node<T>): void;
+}
+export declare function Memorise(): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
+export {};

package/dist/obtservices/base/lib/vendor/classes/lounges-enterprise-search.d.ts

@@ -0,0 +1,68 @@
+import { BaseEnterpriseSearch } from './base-enterprise';
+import { BehaviorSubject } from 'rxjs';
+import moment from 'moment';
+import { BaseStorageService } from '../services/storage.service';
+import { BaseHelperRoutines } from './helpers';
+import { LoungeQuoteResultArray, NgbDateStruct, OBTAirportDetails, RecentSearch, TerminalsType } from '../types/types';
+import { BasketItem, LoungeQuote, SaveRecentSearchMutationVariables, SearchLoungesQueryVariables, ServiceType } from '../types/graphql.types';
+import { BaseLoungeQuoteFetcher, LoungeQuoteFetcherType } from '../fetchers/lounge-quote.fetcher';
+import { EnterpriseBasketServiceInterface } from '../interfaces/Ienterprise-basket.service';
+import { EnterpriseSearchServiceInterface } from '../interfaces/Isearch.service';
+import { LoungesEnterpriseSearchInterface, LoungesTempParams } from '../interfaces/Ilounges-enterprise-search';
+import { ICheapestPrice } from '../interfaces/cheapest-price';
+export declare class LoungesEnterpriseSearch<LQ_Q extends LoungeQuoteFetcherType> extends BaseEnterpriseSearch<LoungesTempParams, LoungeQuoteResultArray, LoungeQuoteResultArray> implements LoungesEnterpriseSearchInterface {
+    private loungefetcher;
+    private helpers;
+    private basketService;
+    private searchService;
+    static readonly STORAGE_SESSION_PARAMS = "search_lounge";
+    static readonly STORAGE_SESSION_RESULTS = "results_lounge";
+    type: ServiceType;
+    terminals: BehaviorSubject<TerminalsType[]>;
+    private travellers;
+    private _locationCode;
+    get adults(): number;
+    set adults(value: number);
+    get children(): number;
+    set children(value: number);
+    get infants(): number;
+    set infants(value: number);
+    private _flightNumber;
+    get flightNumber(): string;
+    set flightNumber(value: string);
+    get locationCode(): string | OBTAirportDetails;
+    set locationCode(value: string | OBTAirportDetails);
+    get terminal(): string;
+    set terminal(input: string);
+    private _selectedTerminal;
+    set selectedTerminal(value: string);
+    get selectedTerminal(): string;
+    min_date: {
+        year: number;
+        month: number;
+        day: number;
+    };
+    private _date;
+    get date(): NgbDateStruct;
+    set date(value: NgbDateStruct);
+    private _time;
+    get time(): string;
+    set time(value: string);
+    get arrivalDatetime(): moment.Moment;
+    set arrivalDatetime(value: moment.Moment);
+    protected resultsSessionName: string;
+    constructor(loungefetcher: BaseLoungeQuoteFetcher<LQ_Q>, helpers: BaseHelperRoutines, basketService: EnterpriseBasketServiceInterface, storageService: BaseStorageService, searchService: EnterpriseSearchServiceInterface);
+    protected resetQuery(): void;
+    getSearchQuery(): SearchLoungesQueryVariables;
+    private _isValid;
+    private _updateDateTime;
+    startSearch(): Promise<boolean>;
+    getRecentSearchQuery(query: SearchLoungesQueryVariables): SaveRecentSearchMutationVariables;
+    startRecentSearch(recentSearch: RecentSearch): void;
+    sortByPrice(asc?: boolean, resultArray?: LoungeQuote[]): void;
+    sortResultsPrice(resultArray: LoungeQuote[], asc?: boolean): LoungeQuote[];
+    sortByTerminal(resultArray?: LoungeQuote[]): void;
+    updateFromPreviousSearches(previousItems: Record<ServiceType, BasketItem>): void;
+    addLoungeToBasket(loungeQuote: LoungeQuote, loungeQuery: SearchLoungesQueryVariables): Promise<boolean>;
+    updateLowestPrice(results: LoungeQuote[]): ICheapestPrice;
+}

package/dist/obtservices/base/lib/vendor/classes/management-info-and-valid.d.ts

@@ -0,0 +1,41 @@
+import { BehaviorSubject, Observable } from 'rxjs';
+import { ValidatorChecker } from '../classes/validator.checker';
+import { EnterpriseBasketServiceInterface } from '../interfaces/Ienterprise-basket.service';
+import { FieldWrapper, ManagementInfo, ManagementInfoValue, Maybe, Scalars, SelectedManagementInfoValue, Service, UiPresentation } from '../types/graphql.types';
+import { GetMiAutoSugestionArray, ValidationErrors } from '../types/types';
+export declare abstract class ManagementInfoAndIsValid extends ValidatorChecker implements ManagementInfo {
+    agentOnly: FieldWrapper<Scalars['Boolean']>;
+    createdAt: FieldWrapper<Scalars['DateTime']>;
+    dbId: FieldWrapper<Scalars['Int']>;
+    defaultValue?: Maybe<FieldWrapper<ManagementInfoValue>>;
+    description?: Maybe<FieldWrapper<Scalars['String']>>;
+    fixed: FieldWrapper<Scalars['Boolean']>;
+    fixedValue?: Maybe<FieldWrapper<ManagementInfoValue>>;
+    group?: Maybe<Array<Maybe<FieldWrapper<Scalars['String']>>>>;
+    handoff: FieldWrapper<Scalars['String']>;
+    id: FieldWrapper<Scalars['ID']>;
+    mandatory: FieldWrapper<Scalars['Boolean']>;
+    name: FieldWrapper<Scalars['String']>;
+    perBooking: FieldWrapper<Scalars['Boolean']>;
+    perPassenger: FieldWrapper<Scalars['Boolean']>;
+    _selectedValues: Array<Maybe<FieldWrapper<SelectedManagementInfoValue>>>;
+    service: FieldWrapper<Service>;
+    uiPresentation: FieldWrapper<UiPresentation>;
+    updatedAt: FieldWrapper<Scalars['DateTime']>;
+    valueMask?: Maybe<FieldWrapper<Scalars['String']>>;
+    values: Array<Maybe<FieldWrapper<ManagementInfoValue>>>;
+    isLoading: BehaviorSubject<boolean>;
+    avaliableItems: GetMiAutoSugestionArray;
+    get selectedValues(): Array<Maybe<FieldWrapper<SelectedManagementInfoValue>>>;
+    set selectedValues(values: SelectedManagementInfoValue[]);
+    get value(): string;
+    set value(val: string);
+    protected constructor(managementInfo: ManagementInfo);
+    isValid(): boolean;
+    hasErrors(value: string): Promise<ValidationErrors>;
+    abstract getValue(): string;
+    abstract setValue(val: string): void;
+    search: (terms: Observable<string>) => Observable<GetMiAutoSugestionArray>;
+    abstract save(basketid: string, userId?: string): void;
+}
+export declare const makeManagamentInfo: (managementInfo: ManagementInfo, basketService: EnterpriseBasketServiceInterface) => ManagementInfoAndIsValid;

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

@@ -0,0 +1,12 @@
+export declare class ModalTypes {
+    value: string;
+    static readonly ModalErrorComponent: ModalTypes;
+    static readonly ModalNetWorkErrorComponent: ModalTypes;
+    static readonly BaseModalComponent: ModalTypes;
+    static readonly AutoLogout: ModalTypes;
+    static readonly RiskAlertDetail: ModalTypes;
+    private _component;
+    get component(): any;
+    set component(value: any);
+    protected constructor(value: string);
+}