@sabstravtech/obtservices 0.0.0 → 0.0.1

package/dist/obtservices/base/lib/vendor/services/enterprise-basket.service.d.ts

@@ -0,0 +1,177 @@
+import { BehaviorSubject, Observable, Observer, Subject } from 'rxjs';
+import { AddItemToBasket, BasketItem, ManagementInfo, ServiceType, SupplementaryBookingInfo } from '../types/graphql.types';
+import { GetMiAutoSugestionArray, GetUserBasketItemResult, GetUserBasketResult, MenuSlideEnum, UserBasketResult } from '../types/types';
+import { ManagementInfoAndIsValid } from '../classes/management-info-and-valid';
+import { BasketInfoMiDetailsImpl } from '../classes/basket-info-mi-details.impl';
+import { BaseHelperRoutines } from '../classes/helpers';
+import { BaseModalOpenerService } from './modal-opener.service';
+import { BaseGetUserFetcher, SearchGetUserFetcherType } from '../fetchers/user-fetcher';
+import { AcceptNewPriceFetcherType, BaseAcceptNewPriceUpdater } from '../updaters/accept-new-price.updater';
+import { BaseGetBasketFetcher, GetBasketFetcherType } from '../fetchers/basket-fetcher';
+import { BaseGetUserBasketsFetcher, GetUserBasketsFetcherType } from '../fetchers/get-users-baskets-fetcher';
+import { BaseGetMiAutoSugestionFetcher, MiAutoSuggestFetcherType } from '../fetchers/getMiAutoSugestions.fetcher';
+import { AddItemToBasketFetcherType, BaseAddItemToBasketUpdater } from '../updaters/add-item-to-basket.updater';
+import { AddUserBasketFetcherType, BaseAddUserToBasketItemUpdater } from '../updaters/addUserToBasketItem';
+import { SetBasketItemLeadPassengerFetcherType, BaseSetBasketItemLeadPassengerUpdater } from '../updaters/set-basket-item-lead-passenger.updater';
+import { BaseBookBasketUpdater, BookBasketFetcherType } from '../updaters/book-basket-updater';
+import { BaseCreateBasketUpdater, CreateBasketFetcherType } from '../updaters/create-basket-updater';
+import { BaseDeleteBasketUpdater, DeleteBasketFetcherType } from '../updaters/remove-basket-updater';
+import { BaseRemoveItemFromBasketUpdater, DeleteBasketItemFetcherType } from '../updaters/remove-item-from-basket.updater';
+import { BaseRevalidateBasketUpdater, RevalidateBasketFetcherType } from '../updaters/revalidate-basket-updater';
+import { BaseSendBasketForApprovalUpdater, SendBasketApprovalFetcherType } from '../updaters/send-basket-for-approval.updater';
+import { BaseSetBasketItemMiGroupUpdater, SetBasketItMiGroupFetcherType } from '../updaters/set-basket-item-mi-group';
+import { Traveller } from '../models/traveller.object';
+import { BaseSetBasketItemMiValueUpdater, SetBasketItMiFetcherType } from '../updaters/set-basket-item-mi-value-updater';
+import { BaseValidateMiFreeValueTester, ValidateMiFetcherType } from '../testers/validate-mi-free-value.tester';
+import { EnterpriseSearchServiceInterface } from '../interfaces/Isearch.service';
+import { UserServiceInterface } from '../interfaces/Iuser.service';
+import { EnterpriseBasketServiceInterface, InternalBasketInterface } from '../interfaces/Ienterprise-basket.service';
+import { SupplementaryBookingInfoInterface } from '../interfaces/Isupplementary-booking-info-impl';
+import { BasemoveBasketItemToBasket, MoveItemToADifferentBasketType } from '../updaters/move-basket-item-to-basket';
+import { BaseUpdateBasketNotesType, BaseUpdateBasketNoteUpdater } from '../updaters/update-basket-notes-updater';
+import { BaseUpdateBasketTitleType, BaseUpdateBasketTitleUpdater } from '../updaters/update-basket-title-updater';
+import { BaseSetPaymentOptionUpdater, SetBasketItemPaymentMethodType } from '../updaters/set-basket-item-paymenr-option.updater';
+export interface BasketAndItem {
+    basketId: string;
+    item: BasketItem;
+}
+export interface MiGroupDetail {
+    type: ServiceType;
+    options: string[];
+    basketItem: BasketItem;
+    value: string;
+}
+export interface BasketItemManagementInfo {
+    miPerItem: ManagementInfoAndIsValid[];
+    miPerUser: {
+        [key: string]: {
+            managementInfo: ManagementInfoAndIsValid[];
+            supplementaryBookingInfo?: SupplementaryBookingInfoInterface;
+        };
+    };
+    users: string[];
+    basketItem: BasketItem;
+}
+export interface BasketInformation {
+    prices: {
+        [key: string]: number;
+    };
+    mixedCurrency: boolean;
+    count: number;
+    miGroups: MiGroupDetail[];
+    basketInfoMiDetails: BasketInfoMiDetailsImpl[];
+    suppInfo: SupplementaryBookingInfoInterface[];
+}
+export interface BasketPricesList {
+    type: ServiceType;
+    price: number;
+    currency?: string;
+    text: string;
+}
+export interface BasketPrices {
+    total: number;
+    currency?: string;
+    list: BasketPricesList[];
+}
+export declare type BasketDetails = UserBasketResult & BasketInformation;
+export declare class InternalBasket<Q extends SearchGetUserFetcherType> implements BasketInformation, InternalBasketInterface {
+    private helpers;
+    private basketService;
+    private getUserFetcher;
+    subject: BehaviorSubject<BasketDetails>;
+    id?: string;
+    tempid?: string;
+    title: string;
+    prices: {
+        [key: string]: number;
+    };
+    mixedCurrency: boolean;
+    count: number;
+    miGroups: MiGroupDetail[];
+    basketInfoMiDetails: BasketInfoMiDetailsImpl[];
+    suppInfo: SupplementaryBookingInfoInterface[];
+    grandTotal: {
+        [key: string]: number;
+    };
+    constructor(basket: UserBasketResult, helpers: BaseHelperRoutines, basketService: EnterpriseBasketServiceInterface, getUserFetcher: BaseGetUserFetcher<Q>);
+    destructor(): void;
+    next(basket: UserBasketResult): void;
+}
+export declare abstract class BaseEnterpriseBasketService<ANPU_Q extends AcceptNewPriceFetcherType, AITB_Q extends AddItemToBasketFetcherType, AUTB_Q extends AddUserBasketFetcherType, CB_Q extends CreateBasketFetcherType, GB_Q extends GetBasketFetcherType, BB_Q extends BookBasketFetcherType, DB_Q extends DeleteBasketFetcherType, GAS_Q extends MiAutoSuggestFetcherType, RIB_Q extends DeleteBasketItemFetcherType, RVB_Q extends RevalidateBasketFetcherType, SBMI_Q extends SetBasketItMiGroupFetcherType, SVMI_Q extends SetBasketItMiFetcherType, VMI_Q extends ValidateMiFetcherType, SBA_Q extends SendBasketApprovalFetcherType, GU_Q extends SearchGetUserFetcherType, GUB_Q extends GetUserBasketsFetcherType, SBLP_Q extends SetBasketItemLeadPassengerFetcherType, MITDB_Q extends MoveItemToADifferentBasketType, UBN_Q extends BaseUpdateBasketNotesType, UBT_Q extends BaseUpdateBasketTitleType, SBM_Q extends SetBasketItemPaymentMethodType> implements EnterpriseBasketServiceInterface {
+    private acceptNewPriceUpdater;
+    private addItemToBasketUpdater;
+    private addUserToBasketItem;
+    private basketCreator;
+    basketFetcher: BaseGetBasketFetcher<GB_Q>;
+    private bookBasketUpdater;
+    private deleteBasketUpdater;
+    private getMiAutoSugestionFetcher;
+    private helpers;
+    private removeItemFromBasketUpdater;
+    private revalidateBasketUpdater;
+    private setBasketItemMiGroupUpdater;
+    private setBasketItemMiValueUpdater;
+    private validateMiFreeValue;
+    private sendBasketForApprovalUpdater;
+    private getUserFetcher;
+    private getUserBasketsFetcher;
+    private SetBasketItemLeadPassenger;
+    private moveItemToADifferentBasket;
+    private updateBasketNotesUpdater;
+    private updateBasketTitleUpdater;
+    private setPaymentMethodUpdater;
+    private userService;
+    private modalService;
+    private currentBaskets;
+    highlightBasketItemsEmitter: Subject<GetUserBasketItemResult[]>;
+    basketChangeEmitter: BehaviorSubject<string>;
+    private get currentBasketID();
+    private set currentBasketID(value);
+    baskets: BehaviorSubject<InternalBasket<GU_Q>[]>;
+    basketList: BasketPricesList[];
+    basketPrices: BehaviorSubject<BasketPrices>;
+    menuState: MenuSlideEnum;
+    constructor(acceptNewPriceUpdater: BaseAcceptNewPriceUpdater<ANPU_Q>, addItemToBasketUpdater: BaseAddItemToBasketUpdater<AITB_Q>, addUserToBasketItem: BaseAddUserToBasketItemUpdater<AUTB_Q>, basketCreator: BaseCreateBasketUpdater<CB_Q>, basketFetcher: BaseGetBasketFetcher<GB_Q>, bookBasketUpdater: BaseBookBasketUpdater<BB_Q>, deleteBasketUpdater: BaseDeleteBasketUpdater<DB_Q>, getMiAutoSugestionFetcher: BaseGetMiAutoSugestionFetcher<GAS_Q>, helpers: BaseHelperRoutines, removeItemFromBasketUpdater: BaseRemoveItemFromBasketUpdater<RIB_Q>, revalidateBasketUpdater: BaseRevalidateBasketUpdater<RVB_Q>, setBasketItemMiGroupUpdater: BaseSetBasketItemMiGroupUpdater<SBMI_Q>, setBasketItemMiValueUpdater: BaseSetBasketItemMiValueUpdater<SVMI_Q>, validateMiFreeValue: BaseValidateMiFreeValueTester<VMI_Q>, sendBasketForApprovalUpdater: BaseSendBasketForApprovalUpdater<SBA_Q>, getUserFetcher: BaseGetUserFetcher<GU_Q>, getUserBasketsFetcher: BaseGetUserBasketsFetcher<GUB_Q>, SetBasketItemLeadPassenger: BaseSetBasketItemLeadPassengerUpdater<SBLP_Q>, moveItemToADifferentBasket: BasemoveBasketItemToBasket<MITDB_Q>, updateBasketNotesUpdater: BaseUpdateBasketNoteUpdater<UBN_Q>, updateBasketTitleUpdater: BaseUpdateBasketTitleUpdater<UBT_Q>, setPaymentMethodUpdater: BaseSetPaymentOptionUpdater<SBM_Q>, userService: UserServiceInterface, modalService: BaseModalOpenerService);
+    reset(): void;
+    getAllOpenBaskets(user_id: string): Promise<UserBasketResult[]>;
+    addToBasket(item: AddItemToBasket.Variables, intBasket: InternalBasket<GU_Q>, searchService: EnterpriseSearchServiceInterface, travellers?: Traveller[]): Promise<boolean>;
+    loadBasket(id: string): void;
+    subsribeToBasket(id: string, observer: Observer<BasketDetails>): void;
+    removeExpiredItems(id: string): void;
+    removeBasketItem(basketId: string, item: BasketItem): void;
+    getDefaultBasket(getBookedBasket?: boolean): Promise<InternalBasket<GU_Q>>;
+    private findBasket;
+    private findOrCreateBasket;
+    createBasket(): Promise<InternalBasket<GU_Q>>;
+    private createBasketOnDB;
+    toggleMenu(): void;
+    closeMenu(): void;
+    getLatestBasketItemForTypes(basketItems: BasketItem[]): Record<ServiceType, BasketItem>;
+    private checkDetails;
+    getNumberItemsForBasket(basket?: InternalBasket<GU_Q>): number;
+    removeBasket(basketid: string): Promise<void>;
+    continueSearchAndBook(basketItems: any[], itiniaryUrl: string[], searchService: EnterpriseSearchServiceInterface): string[];
+    addTravellers(basketid: string, basketItem: BasketItem, travellers: Traveller[], index?: number): void;
+    setLeadPassenger(basketid: string, basketItem: BasketItem, travellers: Traveller, index?: number): void;
+    updateBasket(basketid: string, obs: Observable<BasketDetails>): Promise<void>;
+    revalidate(basketid: string): void;
+    setBasketItemMiGroup(basketid: string, basketItemid: string, group: string): void;
+    acceptNewPrice(basketid: string, item: BasketItem): void;
+    validateFreeValeMi(miItem: ManagementInfo, freeValue: string): Promise<boolean>;
+    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<GetMiAutoSugestionArray>;
+    saveMiData(basketId: string, bmiArray: BasketItemManagementInfo[]): void;
+    sendBasketForApproval(basketid: string): void;
+    setBasketItemPaymentOption(basket: BasketDetails, basketItem: BasketItem, paymentMethod: string): Promise<void>;
+    bookBasket(basketid: string, supplementaryInfo: SupplementaryBookingInfo[]): void;
+    moveBasketItem(originalBasketId: string, basketItem: BasketItem, basketIdToMoveTo: string): void;
+    updateBasketNotes(basketId: string, notes: string): void;
+    updateBasketTitle(basketId: string, title: string): void;
+    getBasket(query: {
+        id: string;
+        withSupplemental: true;
+    }): Observable<GetUserBasketResult>;
+    atLeastOneSearchChosen(): boolean;
+    getBasketStats(index: number): BehaviorSubject<BasketPrices>;
+}

package/dist/obtservices/base/lib/vendor/services/hotel-avallibility.service.d.ts

@@ -0,0 +1,31 @@
+import { BehaviorSubject } from 'rxjs';
+import { BaseEnvironment } from '../classes/enviroment';
+import { BaseHelperRoutines } from '../classes/helpers';
+import { BaseHotelAvalibilityQuoteFetcher, HotelAvalinilityFetcherType } from '../fetchers/hotel-avaliability-fetcher';
+import { HotelDetails } from '../interfaces/Ihotel-enterprise-search';
+import { CurrencyDetails, HotelAvalibilityQuery, HotelAvalibilityQuoteResult } from '../types/types';
+import { BaseStorageService } from './storage.service';
+export declare class BaseHotelAvalibilityService<Q extends HotelAvalinilityFetcherType> {
+    private avalibilityFethcer;
+    private sessionStorage;
+    private helpers;
+    private environment;
+    private data;
+    private behaviours;
+    private timeout;
+    private toFetch;
+    fetching: BehaviorSubject<boolean>;
+    currencies: CurrencyDetails;
+    constructor(avalibilityFethcer: BaseHotelAvalibilityQuoteFetcher<Q>, sessionStorage: BaseStorageService, helpers: BaseHelperRoutines, environment: BaseEnvironment);
+    private readFromSession;
+    reset(): void;
+    getAvailabilityForId(hotel: HotelAvalibilityQuery): BehaviorSubject<HotelAvalibilityQuoteResult>;
+    getAvailabilityValue(hotel: HotelDetails): HotelAvalibilityQuoteResult;
+    private _getAvailabilityForId;
+    private fetchAvalilbility;
+    maxPriceForCurrency(currency: string): number;
+    /**
+     * @description - return the number of hotels that have a price (prpn value)
+     */
+    numberOfHotelsWithPrice(): number;
+}

package/dist/obtservices/base/lib/vendor/services/http-call.service.d.ts

@@ -0,0 +1,17 @@
+import { Observable } from 'rxjs';
+import { URLS } from './url.service';
+export declare abstract class AbstractHttpCallService {
+    abstract formEncodedPost(url: URLS, body?: any, responseType?: 'json' | 'text'): Observable<any>;
+    abstract timeoutFormEncodedPost(url: URLS, body?: any, reTimeout?: number): Observable<any>;
+    abstract formEncodedPostNoErrorHandling(url: URLS, body?: any): Observable<any>;
+    abstract post(url: URLS, data?: any): Observable<any>;
+    abstract get(url: URLS, params?: any): Observable<any>;
+    abstract handleResponse(data: any): any;
+    abstract resetLogout(): void;
+    abstract handleError(errorVal: any, skipTimeoutMessage?: boolean): any;
+    serialize(obj: {
+        [key: string]: string;
+    }): string;
+    abstract getHeaders(): any;
+    abstract makeUrl(url: URLS): string;
+}

package/dist/obtservices/base/lib/vendor/services/logon.service.d.ts

@@ -0,0 +1,39 @@
+import { BaseModalOpenerService } from './modal-opener.service';
+import { BaseStorageService } from './storage.service';
+import { Observable } from 'rxjs';
+import { BaseEventMessenager } from '../classes/event-messenager';
+import { BaseEnvironment } from '../classes/enviroment';
+import { UserData } from '../interfaces/user.data';
+import { AuthInfo, LoginResponse, PasswordChangeResponse } from '../models/login.model';
+import { UserServiceInterface } from '../interfaces/Iuser.service';
+import { AbstractHttpCallService } from './http-call.service';
+import { Router } from '../types/types';
+export declare class BaseLogonService {
+    private userService;
+    private modalService;
+    private http;
+    private router;
+    private eventMessenager;
+    private storageService;
+    private environment;
+    loading: boolean;
+    isLoggedIn: boolean;
+    redirectUrl: string;
+    authInfo: AuthInfo;
+    loginResponse: LoginResponse;
+    timeoutSubscription: number;
+    refreshPromise: Promise<boolean>;
+    constructor(userService: UserServiceInterface, modalService: BaseModalOpenerService, http: AbstractHttpCallService, router: Router, eventMessenager: BaseEventMessenager, storageService: BaseStorageService, environment: BaseEnvironment);
+    checkLogin(): Promise<boolean>;
+    refreshToken(): Promise<boolean>;
+    private clearRefresh;
+    private setRefresh;
+    login(username: string, password: string, again?: boolean): Observable<UserData>;
+    handleResponse(data: any): any;
+    cookieLogin(username: string): Observable<UserData>;
+    logout(): void;
+    changePassword(authInfo: AuthInfo): Observable<PasswordChangeResponse>;
+    resetPassword(passwordResetToken: string, newPassword: string): Observable<PasswordChangeResponse>;
+    recoverPassword(username: string): Observable<any>;
+    handleError(error: string): void;
+}

package/dist/obtservices/base/lib/vendor/services/modal-opener.service.d.ts

@@ -0,0 +1,13 @@
+import { ModalTypes } from '../classes/modal-types.enum';
+export interface ModalEvent {
+    type: ModalTypes;
+    data: any;
+    options: object;
+    results: (data: any) => void;
+}
+export declare class BaseModalOpenerService {
+    private openModalEvent;
+    constructor();
+    open(type: ModalTypes, options?: any, data?: any): Promise<any>;
+    subscribe(next: (data: any) => void): import("rxjs").Subscription;
+}

package/dist/obtservices/base/lib/vendor/services/my-bookings.service.d.ts

@@ -0,0 +1,31 @@
+import { BehaviorSubject, Observable } from 'rxjs';
+import { EnterpriseMyBookingsServiceInterface } from '../interfaces/Imybookings.service';
+import { BaseSearchUsersCanBookForFetcher, SearchUserCanBookForFetcherType } from '../fetchers/search-users-can-book-for-fetcher';
+import { BaseGetUserBasketsFetcher, GetUserBasketsFetcherType } from '../fetchers/get-users-baskets-fetcher';
+import { UserBasketResult } from '../types/types';
+import { BasketItem, BasketItemStatus, BasketStatus, QueryGetUserBasketsArgs, ServiceType, User } from '../types/graphql.types';
+import { EnterpriseSearchServiceInterface } from '../interfaces/Isearch.service';
+export declare class BaseEnterpriseMyBookingsService<GUB_Q extends GetUserBasketsFetcherType, SUCBF_Q extends SearchUserCanBookForFetcherType> implements EnterpriseMyBookingsServiceInterface {
+    private getUserBasketsFetcher;
+    private searchUserCanBookFor;
+    baskets: BehaviorSubject<UserBasketResult[]>;
+    private _basketStatusIconClasses;
+    private _serviceTypeIconClasses;
+    constructor(getUserBasketsFetcher: BaseGetUserBasketsFetcher<GUB_Q>, searchUserCanBookFor: BaseSearchUsersCanBookForFetcher<SUCBF_Q>);
+    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/services/routehappy.service.d.ts

@@ -0,0 +1,47 @@
+import { BehaviorSubject } from 'rxjs';
+import { BaseHelperRoutines } from '../classes/helpers';
+import { Amenities } from '../classes/routehappy-request';
+import { AbstractHttpCallService } from './http-call.service';
+export interface RouteHappyBandsUpas {
+    brands: Brand[];
+    upas: Upas[];
+}
+export interface RouteHappyAmenities {
+    seat: Amenities.Seat;
+    wifi: Amenities.Wifi;
+    power: Amenities.Power;
+    entertainment: Amenities.Entertainment;
+    fresh_food: Amenities.FreshFood;
+    beverage: Amenities.Beverage;
+    layout: Amenities.Layout;
+    aircraft: Amenities.Aircraft;
+}
+interface Brand {
+    brand_name: string;
+    brand_codes: string[];
+}
+interface Upa {
+    headline: string;
+    description: string;
+    small_icon_url: string;
+    large_icon_url: string;
+    cta_text: string;
+    cta_url: string;
+    categories: string[];
+    fees: any[];
+}
+interface Upas {
+    [key: string]: Upa;
+}
+export declare class BaseRouteHappyService {
+    private httpService;
+    private helpers;
+    constructor(httpService: AbstractHttpCallService, helpers: BaseHelperRoutines);
+    getAmenitiesForFlight(flight: any): BehaviorSubject<RouteHappyAmenities[]>;
+    parseAmenities(response: Amenities.AmenitiesResponse): RouteHappyAmenities[];
+    convertClassString(seatClass: string): string;
+    getUpasForFlight(flight: any): BehaviorSubject<RouteHappyBandsUpas[]>;
+    convertClass(seatClass: string): number;
+    private parseResponse;
+}
+export {};

package/dist/obtservices/base/lib/vendor/services/search.service.d.ts

@@ -0,0 +1,236 @@
+import { BehaviorSubject } from 'rxjs';
+import { Observable } from 'rxjs';
+import { SearchObject, SearchObjects } from '../interfaces/search-objects.interface';
+import { Address, Airport, BasketItem, ServiceType, SaveUserAddressMutationVariables, ConfermaOfficeNames, CarbonAllowance, RiskAlert, RiskLevel, RailStation, ReferenceRailCardQualifier, SaveRecentSearchMutationVariables } from '../types/graphql.types';
+import { Traveller } from '../models/traveller.object';
+import { BaseStorageService } from './storage.service';
+import { BaseHelperRoutines } from '../classes/helpers';
+import { BaseHotelAvalibilityService } from './hotel-avallibility.service';
+import { BaseEnvironment } from '../classes/enviroment';
+import { BaseSearchPostcodeFetcher, SearchPostcodesQuoteFetcherType } from '../fetchers/search-postcodes.fetcher';
+import { AddressForm, AirportSearchResults, CarHireDepotResultArray, CountryCode, LocationDetails, OBTAirportDetails, RailAirport, Router, TerminalsType, OBTAirlinesDetails, RecentSearch } from '../types/types';
+import { BaseSearchRailStationsFetcher, SearchRailStationsFetcherType } from '../fetchers/search-rail-stations.fetcher';
+import { BaseLoungeQuoteFetcher, LoungeQuoteFetcherType } from '../fetchers/lounge-quote.fetcher';
+import { BaseParkingQuoteFetcher, ParkingQuoteFetcherType } from '../fetchers/parking-quote-fetcher';
+import { BaseFlightQuoteFetcher, FlightQuoteFetcherType } from '../fetchers/flight-quote.fetcher';
+import { BaseHotelQuoteFetcher, HotelQuoteFetcherType } from '../fetchers/hotel-quote-fetcher';
+import { BaseCarhireQuoteFetcher, CarHireFetcherType } from '../fetchers/carhire-quote-fetcher';
+import { BaseCarHireAvailabilityDetailFetcher, CarHireAvailabilityDetailFetcherType } from '../fetchers/carhire-availability-detail.fetcher';
+import { BaseCabhireQuoteFetcher, CabhireQuoteFetcherType } from '../fetchers/cabhire-quote-fetcher';
+import { BaseRailQuoteFetcher, RailQuoteFetcherType } from '../fetchers/rail-quote-fetcher';
+import { BaseIrlQuoteFetcher, IrlQuoteFetcherType } from '../fetchers/irl-quote-fetcher';
+import { EnterpriseSearchServiceInterface, SearchParams } from '../interfaces/Isearch.service';
+import { BaseSearchAirportsFetcher, SearchAirportsQuoteFetcherType } from '../fetchers/search-airports-fetcher';
+import { BaseSearchAirlinesFetcher, SearchAirlinesQuoteFetcherType } from '../fetchers/search-airlines.fetcher';
+import { UserServiceInterface } from '../interfaces/Iuser.service';
+import { BaseSearchCityFetcher, SearchCitiesQuoteFetcherType } from '../fetchers/search-cities.fetcher';
+import { BaseSearchConfermaCityFetcher, SearchConfermaCitiesQuoteFetcherType } from '../fetchers/search-conferma-cities.fetcher';
+import { AbstractHttpCallService } from './http-call.service';
+import { EnterpriseBasketServiceInterface } from '../interfaces/Ienterprise-basket.service';
+import { HotelAvalinilityFetcherType } from '../fetchers/hotel-avaliability-fetcher';
+import { BaseSaveUserAddressUpdater, SaveUserAddressUpdaterType } from '../updaters/save-user-address.updater';
+import { BaseUserAddressesFetcher, UserAddressFetcherType } from '../fetchers/user-addresses.fetcher';
+import { BaseConfermaOfficeNamesFetcher, ConfermaOfficeNameFetcherType } from '../fetchers/conferma-office-names.fetcher';
+import { BaseGetUserCompanyOfficesFetcher, GetUserCompanyOfficesQuoteFetcherType } from '../fetchers/get-user-company-offices.fetcher';
+import { BaseSearchHotelChainsFetcher, SearchHotelChainsQuoteFetcherType } from '../fetchers/search-hotel-chains.fetcher';
+import { BaseValidateIsPostcodeValidTester, ValidateIsPostcodeValidType } from '../testers/postcode-validate.tester';
+import { BaseSearchDepotFetcher, SearchDepotQuoteFetcherType } from '../fetchers/search-depots.fetcher';
+import { BaseGetRailStationFetcher, GetRailStationFetcherType } from '../fetchers/get-rail-station.fetcher';
+import { BaseSearchConfermaQuicklistFetcher, ConfermaQuicklistFetcherType } from '../fetchers/conferma-quicklist.fetcher';
+import { BaseDeleteUserAddressUpdater, DeleteUserAddressFetcherType } from '../updaters/remove-user-address-updater';
+import { BaseDeleteRecentSearchUpdater, DeleteRecentSearchFetcherType } from '../updaters/remove-recent-search-updater';
+import { BaseSaveRecentSearchUpdater, SaveRecentSearchFetcherType } from '../updaters/save-recent-search-updater';
+import { HotelTempParams } from '../interfaces/Ihotel-enterprise-search';
+import { RailTempParams } from '../interfaces/Irail-enterprise-search';
+import { FlightTempParams } from '../interfaces/Iflight-enterprise-search';
+import { LoungesTempParams } from '../interfaces/Ilounges-enterprise-search';
+import { ParkingTempParams } from '../interfaces/Iparking-enterprise-search';
+import { CabHireTempParams } from '../interfaces/Icabhire-enterprise-search';
+import { CarHireTempParams } from '../interfaces/Icarhire-enterprise-search';
+import { BaseGetUserCurrentCarbonAllowanceFetcher, GetUserCurrentCarbonAllowanceType } from '../fetchers/get-user-current-carbon-allowance.fetcher';
+import { BaseWebTokenService } from './webtoken.service';
+import { BaseGetRiskAlertsFetcher, GetRiskAlertsFetcherType } from '../fetchers/get-risk-alerts.fetcher';
+import { IrlTempParams } from '../interfaces/Iirl-enterprise-search';
+import { BaseGetUserRecentSearchesFetcher, GetUserRecentSearchesFetcherType } from '../fetchers/get-user-recent-searches.fetcher';
+import { BaseGetRailcardsFetcher, GetRailCardsFetcherType } from '../fetchers/get-rail-cards.fetcher';
+import { BaseEurostarQuoteFetcher, EurostarQuoteFetcherType } from '../fetchers/eurostar-quote.fetcher';
+import { EurostarTempParams } from '../interfaces/Ieurostar-enterprise-search';
+import { BaseSearchUsersCanBookForFetcher, SearchUserCanBookForFetcherType } from '../fetchers/search-users-can-book-for-fetcher';
+export declare const MAX_TRAVELLERS = 8;
+export declare enum TravellerSearchTypes {
+    email = "email",
+    name = "name",
+    employeeNumber = "employeeNumber"
+}
+export declare class BaseEnterpriseSearchService<SP_Q extends SearchPostcodesQuoteFetcherType, SR_Q extends SearchRailStationsFetcherType, SL_Q extends LoungeQuoteFetcherType, SPA_Q extends ParkingQuoteFetcherType, SFL_Q extends FlightQuoteFetcherType, SHO_Q extends HotelQuoteFetcherType, SCH_Q extends CarHireFetcherType, CHAD_Q extends CarHireAvailabilityDetailFetcherType, STH_Q extends CabhireQuoteFetcherType, SA_Q extends SearchAirportsQuoteFetcherType, SAL_Q extends SearchAirlinesQuoteFetcherType, HA_Q extends HotelAvalinilityFetcherType, SC_Q extends SearchCitiesQuoteFetcherType, SCC_Q extends SearchConfermaCitiesQuoteFetcherType, SRA_Q extends RailQuoteFetcherType, SI_Q extends IrlQuoteFetcherType, SUA_Q extends SaveUserAddressUpdaterType, SU_Q extends UserAddressFetcherType, GUCO_Q extends GetUserCompanyOfficesQuoteFetcherType, SHC_Q extends SearchHotelChainsQuoteFetcherType, IPV_Q extends ValidateIsPostcodeValidType, SD_Q extends SearchDepotQuoteFetcherType, GRS_Q extends GetRailStationFetcherType, GON_Q extends ConfermaOfficeNameFetcherType, DUA_Q extends DeleteUserAddressFetcherType, DRS_Q extends DeleteRecentSearchFetcherType, SRS_Q extends SaveRecentSearchFetcherType, UCA_Q extends GetUserCurrentCarbonAllowanceType, GRA_Q extends GetRiskAlertsFetcherType, QL_Q extends ConfermaQuicklistFetcherType, GURSF_Q extends GetUserRecentSearchesFetcherType, GRCF_Q extends GetRailCardsFetcherType, SE_Q extends EurostarQuoteFetcherType, SUCBF extends SearchUserCanBookForFetcherType> implements EnterpriseSearchServiceInterface {
+    protected searchAirportsFetcher: BaseSearchAirportsFetcher<SA_Q>;
+    protected searchAirlinesFetcher: BaseSearchAirlinesFetcher<SAL_Q>;
+    protected storageService: BaseStorageService;
+    protected userService: UserServiceInterface;
+    protected router: Router;
+    protected helpers: BaseHelperRoutines;
+    protected hotelAvalibilityService: BaseHotelAvalibilityService<HA_Q>;
+    private citiesFetcher;
+    private confermaCitiesFetcher;
+    private postcodeFetcher;
+    private railStationFetcher;
+    private saveUserAddressUpdater;
+    private userAddressesFetcher;
+    private basketService;
+    private getUserCompanyOfficesFetcher;
+    private searchHotelChainsFetcher;
+    private baseValidateIsPostcodeValidTester;
+    private depotFetcher;
+    private confermaOfficeNamesFetcher;
+    private baseDeleteUserAddressUpdater;
+    private baseDeleteRecentSearchUpdater;
+    private baseSaveRecentSearchUpdater;
+    private getUserCurrentCarbonAllowanceFetcher;
+    protected getRailStationFetcher: BaseGetRailStationFetcher<GRS_Q>;
+    private riskAlertsFetcher;
+    private quicklistFetcher;
+    private getUserRecentSearchesFetcher;
+    protected getRailCardsFetcher: BaseGetRailcardsFetcher<GRCF_Q>;
+    searchUsersCanBookForFetcher: BaseSearchUsersCanBookForFetcher<SUCBF>;
+    static SESSION_TRAVELLER: string;
+    searches: SearchParams;
+    traveller_error: boolean;
+    travellerInformation: BehaviorSubject<Traveller[]>;
+    errors: BehaviorSubject<string[]>;
+    searchLoadingDone: BehaviorSubject<boolean>;
+    searchTimedOut: BehaviorSubject<boolean>;
+    newSearchStarted: BehaviorSubject<boolean>;
+    firstLoad: boolean;
+    search_objects: SearchObjects;
+    highest_search_priority: number;
+    show_errors: boolean;
+    travellerValidationMessages: string[];
+    search_loading: boolean;
+    search_airport_loading: boolean;
+    private selectedTravellers;
+    selectedPlaces: any;
+    countries: {
+        cName: string;
+        dCode: string;
+        cCode: string;
+    }[];
+    eurostations: {
+        gateway: string;
+        destination: string;
+    }[];
+    constructor(searchAirportsFetcher: BaseSearchAirportsFetcher<SA_Q>, searchAirlinesFetcher: BaseSearchAirlinesFetcher<SAL_Q>, storageService: BaseStorageService, userService: UserServiceInterface, router: Router, helpers: BaseHelperRoutines, hotelAvalibilityService: BaseHotelAvalibilityService<HA_Q>, citiesFetcher: BaseSearchCityFetcher<SC_Q>, confermaCitiesFetcher: BaseSearchConfermaCityFetcher<SCC_Q>, postcodeFetcher: BaseSearchPostcodeFetcher<SP_Q>, railStationFetcher: BaseSearchRailStationsFetcher<SR_Q>, saveUserAddressUpdater: BaseSaveUserAddressUpdater<SUA_Q>, userAddressesFetcher: BaseUserAddressesFetcher<SU_Q>, basketService: EnterpriseBasketServiceInterface, getUserCompanyOfficesFetcher: BaseGetUserCompanyOfficesFetcher<GUCO_Q>, searchHotelChainsFetcher: BaseSearchHotelChainsFetcher<SHC_Q>, baseValidateIsPostcodeValidTester: BaseValidateIsPostcodeValidTester<IPV_Q>, depotFetcher: BaseSearchDepotFetcher<SD_Q>, confermaOfficeNamesFetcher: BaseConfermaOfficeNamesFetcher<GON_Q>, baseDeleteUserAddressUpdater: BaseDeleteUserAddressUpdater<DUA_Q>, baseDeleteRecentSearchUpdater: BaseDeleteRecentSearchUpdater<DRS_Q>, baseSaveRecentSearchUpdater: BaseSaveRecentSearchUpdater<SRS_Q>, getUserCurrentCarbonAllowanceFetcher: BaseGetUserCurrentCarbonAllowanceFetcher<UCA_Q>, environment: BaseEnvironment, loungeFetcher: BaseLoungeQuoteFetcher<SL_Q>, parkingFetcher: BaseParkingQuoteFetcher<SPA_Q>, httpCallService: AbstractHttpCallService, flightFetcher: BaseFlightQuoteFetcher<SFL_Q>, hotelFetcher: BaseHotelQuoteFetcher<SHO_Q>, carhireFetcher: BaseCarhireQuoteFetcher<SCH_Q>, carHireAvailabilityDetailFetcher: BaseCarHireAvailabilityDetailFetcher<CHAD_Q>, cabhireFetcher: BaseCabhireQuoteFetcher<STH_Q>, railFetcher: BaseRailQuoteFetcher<SRA_Q>, irlFetcher: BaseIrlQuoteFetcher<SI_Q>, getRailStationFetcher: BaseGetRailStationFetcher<GRS_Q>, baseWebTokenService: BaseWebTokenService, riskAlertsFetcher: BaseGetRiskAlertsFetcher<GRA_Q>, quicklistFetcher: BaseSearchConfermaQuicklistFetcher<QL_Q>, getUserRecentSearchesFetcher: BaseGetUserRecentSearchesFetcher<GURSF_Q>, getRailCardsFetcher: BaseGetRailcardsFetcher<GRCF_Q>, eurostarFetcher: BaseEurostarQuoteFetcher<SE_Q>, searchUsersCanBookForFetcher: BaseSearchUsersCanBookForFetcher<SUCBF>);
+    reset(): void;
+    getUserCurrentCarbonAllowance(user?: string, isLoading?: BehaviorSubject<boolean>): Observable<CarbonAllowance>;
+    getRiskAlerts(minLevel: RiskLevel, maxLevel: RiskLevel, countryIsoCode: string, isLoading?: BehaviorSubject<boolean>, airport?: Airport, railStation?: RailStation, airportIata?: string): Observable<RiskAlert[]>;
+    getAirportsList(term: string, countryCode?: CountryCode, isLoading?: BehaviorSubject<boolean>, hasLounge?: boolean, hasParking?: boolean, hasFastTrack?: boolean): Observable<OBTAirportDetails[]>;
+    getAirlinesList(term: string, isLoading?: BehaviorSubject<boolean>): Observable<OBTAirlinesDetails[]>;
+    getAirportLocations(term: string, countryCode: CountryCode, isLoading?: BehaviorSubject<boolean>, hasLounge?: boolean, hasParking?: boolean, hasFastTrack?: boolean): Observable<LocationDetails[]>;
+    getCityLocations(term: string, countryCode?: CountryCode, isLoading?: BehaviorSubject<boolean>, isConfirma?: boolean): Observable<LocationDetails[]>;
+    _getCityLocations(term: string, countryCode?: CountryCode, isLoading?: BehaviorSubject<boolean>): Observable<LocationDetails[]>;
+    private getConfermaCityLocations;
+    /**
+     * @description - get car hire depots based on city cords
+     */
+    getCarHireDepots(latitude: number, longitude: number, isLoading?: BehaviorSubject<boolean>): Observable<CarHireDepotResultArray>;
+    /**
+     * @description - get postcode locations, these will use partial postcode,
+     *  full and then grabbing them will let us fill in the address form
+     * @todo - fill this out for the other location types, may need to mergeMap them or some other rxjs magic
+     * @param term - the term to search by e.g. 'wa14' should bring back, our office, 'm33' shoiuld bring back my addrs
+     */
+    getPostcodeList(term: string): Observable<LocationDetails[]>;
+    addToSelectedPlaces(address: Address): void;
+    getSelectedPlaceById(placeId: string): Address;
+    getOfficeLocations(term: string): Observable<LocationDetails[]>;
+    getStationLocations(term: string, isLoading?: BehaviorSubject<boolean>): Observable<LocationDetails[]>;
+    /**
+     * @description - get hotel locations, these should be city, office, airport, railstation
+     * @todo - fill this out for the other location types, may need to mergeMap them or some other rxjs magic
+     * @param term - the term to search by e.g. 'Man' should bring back, manchester, manchester airport, manchester picadilly, etc
+     */
+    getHotelLocationsList(term: string, countryCode: CountryCode, isLoading?: BehaviorSubject<boolean>): Observable<LocationDetails[]>;
+    getStationsAndAirportsList(term: string, countryCode: CountryCode, isLoading?: BehaviorSubject<boolean>): Observable<LocationDetails[]>;
+    removeTraveller(traveller: Traveller): void;
+    _removeTraveller(traveller: Traveller): void;
+    removeAllTravellers(): void;
+    addTraveller(traveller: Traveller): void;
+    currentNoOfTravellersGreaterOrEqualToMax(): boolean;
+    maxTravellers(): number;
+    travellerAlreadyAdded(traveller: Traveller): boolean;
+    canUseTravellerProfile(): boolean;
+    getCurrentNoOfTravellers(): number;
+    updateTravellerInformation(): void;
+    determineHighestSearchPriority(): number;
+    getHighestSearchPriorityObject(basketItems: Record<ServiceType, BasketItem>): SearchObject;
+    private _getHighestSearchPriorityObject;
+    getSelectedOptions(): ServiceType[];
+    /**
+     * Checks if selected travellers contains any guests without all of details
+     */
+    hasSimpleGuests(): boolean;
+    /**
+     * @description - set the search objects to the get me there objects - called before starting the get me there searches
+     */
+    setGetMeThereSearchObjects(): void;
+    resetSearchParams(): void;
+    canSearch(type: ServiceType | string): boolean;
+    hasHighestSearchPriority(priorityVal: number): boolean;
+    getAllErrorMessages(): string[];
+    protected travellersContainUser(): boolean;
+    validateTravellers(): boolean;
+    findPaxInTravellers(username: string): Traveller;
+    validateForms(): boolean;
+    private _findSearchObtect;
+    startSearches(): void;
+    getTaxiStationLocations(term: string, isLoading?: BehaviorSubject<boolean>): Observable<RailAirport[]>;
+    getAddresses(isLoading: BehaviorSubject<boolean>): Observable<AddressForm[]>;
+    getUserAddresses(isLoading?: BehaviorSubject<boolean>): Observable<AddressForm[]>;
+    deleteUserAddressByID(id: string): Observable<any>;
+    getHotelChain(term: string, isLoading?: BehaviorSubject<boolean>): Observable<any[]>;
+    getOfficeNames(isLoading?: BehaviorSubject<boolean>): Observable<ConfermaOfficeNames[]>;
+    getRailCards(): Observable<ReferenceRailCardQualifier[]>;
+    getAirportByCode(code: string): Observable<AirportSearchResults>;
+    protected init_search_objects(): SearchObjects;
+    /********************************************************
+     * SEARCH OBJECTS FOR GET ME THERE DOOR 2 DOOR          *
+     * Difference(s):                                       *
+     * All objects have a priority of 1 so that they are    *
+     * searched at the same time                            *
+     * Urls changed to getmethere                           *
+     *******************************************************/
+    protected getMeThereSearchObjects(): SearchObjects;
+    getSelectedtravellers(): Traveller[];
+    resetSearchObjects(): void;
+    processTerminals(terminals: string[]): TerminalsType[];
+    saveUserAddress(address: SaveUserAddressMutationVariables): Promise<void>;
+    canBook(service: ServiceType): boolean;
+    isPostcodeVaild(postcode: string): Observable<boolean>;
+    makeCabHireQuery(...args: any): CabHireTempParams;
+    makeCarHireQuery(...args: any): CarHireTempParams;
+    makeFlightQuery(...args: any): FlightTempParams;
+    makeHotelQuery(...args: any): HotelTempParams;
+    makeLoungesQuery(...args: any): LoungesTempParams;
+    makeParkingQuery(...args: any): ParkingTempParams;
+    makeRailQuery(...args: any): RailTempParams;
+    makeIrlQuery(...args: any): IrlTempParams;
+    makeEurostarQuery(...args: any): EurostarTempParams;
+    shouldAddTravellerSubscription(): boolean;
+    getAutoLogoutConfig(): {};
+    /**
+     * Overwrite if the OBT displays a list of offices instead of searching on them
+     */
+    shouldFetchAllOffices(): boolean;
+    isFlightsGrouped(): boolean;
+    getCountryFullNameFromCountryCode(code: string): string;
+    getUserRecentSearches(serviceType?: ServiceType, isLoading?: BehaviorSubject<boolean>): Observable<RecentSearch[]>;
+    deleteRecentSearchByID(id: string): Observable<any>;
+    saveRecentSearch(query: SaveRecentSearchMutationVariables): void;
+    /**
+     * @description - get the list of eurostar station locations based on search term given
+     * @todo - fill this out so that it actually performs a http call
+     * @param term - the term we want to search by
+     * @returns
+     */
+    lookupEurostarStations(term: string): Observable<any[]>;
+    searchTravellers(input: string, searchTravellersBy: TravellerSearchTypes): Observable<Traveller[]>;
+}

package/dist/obtservices/base/lib/vendor/services/storage.service.d.ts

@@ -0,0 +1,9 @@
+export declare abstract class BaseStorageService {
+    abstract getSessionItem<T>(key: string): T;
+    abstract getSessionItemAsList<T extends Array<any>>(key: string): T;
+    abstract getLocalItem<T>(key: string): T;
+    abstract setSessionItem(key: string, data: {}): void;
+    abstract setLocalItem(key: string, data: {}): void;
+    abstract removeSessionItem(key: string): void;
+    abstract clearSessionData(): void;
+}

package/dist/obtservices/base/lib/vendor/services/url.service.d.ts

@@ -0,0 +1,10 @@
+export declare enum URLS {
+    AccessToken = "accessToken",
+    LOGOUT_URL = "logout",
+    Refresh = "refreshToken",
+    CONFERMA_THUMBNAIL_URL = "https://ssl.conferma.com/Images/PropertyThumbnails/",
+    CONFIRMA_PHOTO_URL = "/confermainfo/Info.aspx?mode=media&key=MICROSSABS&id=",
+    CONFIRMA_INFO_URL = "/confermainfo/Info.aspx?mode=hotel&key=MICROSSABS&id=",
+    RECOVER_PASSWORD_URL = "password/getResetToken",
+    RESET_PASSWORD = "password/resetByToken"
+}