@sabstravtech/obtservices 0.0.0 → 0.0.1

package/dist/obtservices/esm2015/angular/lib/vendor/services/search.service.js

@@ -0,0 +1,142 @@
+import { Injectable } from '@angular/core';
+import { UserService } from './user.service';
+import { Router } from '@angular/router';
+import { GetRailStationFetcher } from '../fetchers/get-rail-station.fetcher';
+import { GetRiskAlertsFetcher } from '../fetchers/get-risk-alerts.fetcher';
+import { CarHireAvailabilityDetailFetcher } from '../fetchers/carhire-availability-detail.fetcher';
+import { SearchAirportsFetcher } from '../fetchers/search-airports-fetcher';
+import { SearchAirlinesFetcher } from '../fetchers/search-airlines-fetcher';
+import { StorageService } from './storage.service';
+import { ParkingQuoteFetcher } from '../fetchers/parking-quote-fetcher';
+import { CarhireQuoteFetcher } from '../fetchers/carhire-quote-fetcher';
+import { FlightQuoteFetcher } from '../fetchers/flight-quote.fetcher';
+import { RailQuoteFetcher } from '../fetchers/rail-quote-fetcher';
+import { HotelQuoteFetcher } from '../fetchers/hotel-quote-fetcher';
+import { CabhireQuoteFetcher } from '../fetchers/cabhire-quote-fetcher';
+import { HotelAvalibilityService } from './hotel-avallibility.service';
+import { HttpCallService } from './../services/http-call.service';
+import { SearchPostcodeFetcher } from '../fetchers/search-postcodes.fetcher';
+import { SearchCityFetcher } from '../fetchers/search-cities.fetcher';
+import { SearchConfermaCityFetcher } from '../fetchers/search-conferma-cities.fetcher';
+import { SearchRailStationsFetcher } from '../fetchers/search-rail-stations.fetcher';
+import { EnterpriseBasketService } from './enterprise-basket.service';
+import { BaseEnterpriseSearchService } from 'obtservices/base';
+import { LoungeQuoteFetcher } from '../fetchers/lounge-quote.fetcher';
+import { HelperRoutines } from '../classes/helpers';
+import { Environment } from '../classes/environment';
+import { UserAddressesFetcher } from '../fetchers/user-addresses.fetcher';
+import { GetUserCompanyOfficesFetcher } from '../fetchers/get-user-company-offices.fetcher';
+import { SearchHotelChainsFetcher } from '../fetchers/search-hotel-chains.fetcher';
+import { IsPostcodeValidValueTester } from '../testers/postcode-validate.tester';
+import { ConfermaOfficeNamesFetcher } from '../fetchers/conferma-office-names.fetcher';
+import { GetRailCardsFetcher } from '../fetchers/get-rail-cards.fetcher';
+import { EurostarQuoteFetcher } from '../fetchers/eurostar-quote.fetcher';
+import { DeleteUserAddressUpdater } from '../updaters/remove-user-address.updater';
+import { DeleteRecentSearchUpdater } from '../updaters/remove-recent-search.updater';
+import { SaveRecentSearchUpdater } from '../updaters/save-recent-search.updater';
+import { SaveUserAddressUpdater } from '../updaters/save-user-address.updater';
+import { SearchDepotFetcher } from '../fetchers/search-depots.fetcher';
+import { GetUserCurrentCarbonAllowanceFetcher } from '../fetchers/get-user-current-carbon-allowance.fetcher';
+import { WebTokenService } from './webtoken.service';
+import { IrlQuoteFetcher } from '../fetchers/irl-quote-fetcher';
+import { ConfermaQuicklistFetcherType } from '../fetchers/conferma-quicklist.fetcher';
+import { GetUserRecentSearchesFetcher } from '../fetchers/get-user-recent-searches.fetcher';
+import { SearchUsersCanBookForFetcher } from '../fetchers/search-users-can-book-for-fetcher';
+import * as i0 from "@angular/core";
+import * as i1 from "../fetchers/search-airports-fetcher";
+import * as i2 from "../fetchers/search-airlines-fetcher";
+import * as i3 from "./storage.service";
+import * as i4 from "./user.service";
+import * as i5 from "@angular/router";
+import * as i6 from "../classes/helpers";
+import * as i7 from "./hotel-avallibility.service";
+import * as i8 from "../fetchers/search-cities.fetcher";
+import * as i9 from "../fetchers/search-conferma-cities.fetcher";
+import * as i10 from "../fetchers/search-postcodes.fetcher";
+import * as i11 from "../fetchers/search-rail-stations.fetcher";
+import * as i12 from "../updaters/save-user-address.updater";
+import * as i13 from "../fetchers/user-addresses.fetcher";
+import * as i14 from "./enterprise-basket.service";
+import * as i15 from "../fetchers/get-user-company-offices.fetcher";
+import * as i16 from "../fetchers/search-hotel-chains.fetcher";
+import * as i17 from "../testers/postcode-validate.tester";
+import * as i18 from "../fetchers/conferma-office-names.fetcher";
+import * as i19 from "../updaters/remove-user-address.updater";
+import * as i20 from "../updaters/remove-recent-search.updater";
+import * as i21 from "../updaters/save-recent-search.updater";
+import * as i22 from "../fetchers/get-user-current-carbon-allowance.fetcher";
+import * as i23 from "../classes/environment";
+import * as i24 from "../fetchers/lounge-quote.fetcher";
+import * as i25 from "../fetchers/parking-quote-fetcher";
+import * as i26 from "./http-call.service";
+import * as i27 from "../fetchers/flight-quote.fetcher";
+import * as i28 from "../fetchers/hotel-quote-fetcher";
+import * as i29 from "../fetchers/carhire-quote-fetcher";
+import * as i30 from "../fetchers/carhire-availability-detail.fetcher";
+import * as i31 from "../fetchers/cabhire-quote-fetcher";
+import * as i32 from "../fetchers/rail-quote-fetcher";
+import * as i33 from "../fetchers/irl-quote-fetcher";
+import * as i34 from "../fetchers/search-depots.fetcher";
+import * as i35 from "../fetchers/get-rail-station.fetcher";
+import * as i36 from "./webtoken.service";
+import * as i37 from "../fetchers/get-risk-alerts.fetcher";
+import * as i38 from "../fetchers/conferma-quicklist.fetcher";
+import * as i39 from "../fetchers/get-user-recent-searches.fetcher";
+import * as i40 from "../fetchers/get-rail-cards.fetcher";
+import * as i41 from "../fetchers/eurostar-quote.fetcher";
+import * as i42 from "../fetchers/search-users-can-book-for-fetcher";
+export class EnterpriseSearchService extends BaseEnterpriseSearchService {
+    constructor(searchAirportsFetcher, searchAirlinesFetcher, storageService, userService, router, helpers, hotelAvalibilityService, citiesFetcher, confermaCitiesFetcher, postcodeFetcher, railStationFetcher, saveUserAddressUpdater, userAddressesFetcher, basketService, getUserCompanyOfficesFetcher, searchHotelChainsFetcher, isPostcodeValidValueTester, confermaOfficeNamesFetcher, deleteUserAddressUpdater, deleteRecentSearchUpdater, saveRecentSearchUpdater, getUserCurrentCarbonAllowanceFetcher, environment, loungeFetcher, parkingFetcher, httpCallService, flightFetcher, hotelFetcher, carhireFetcher, carHireAvailabilityDetailFetcher, cabhireFetcher, railFetcher, irlFetcher, depotFetcher, getRailStationFetcher, webTokenService, riskAlertsFetcher, quicklistFetcher, getUserRecentSearchesFetcher, getRailCardsFetcher, eurostarFetcher, searchUsersCanBookForFetcher) {
+        super(searchAirportsFetcher, searchAirlinesFetcher, storageService, userService, router, helpers, hotelAvalibilityService, citiesFetcher, confermaCitiesFetcher, postcodeFetcher, railStationFetcher, saveUserAddressUpdater, userAddressesFetcher, basketService, getUserCompanyOfficesFetcher, searchHotelChainsFetcher, isPostcodeValidValueTester, depotFetcher, confermaOfficeNamesFetcher, deleteUserAddressUpdater, deleteRecentSearchUpdater, saveRecentSearchUpdater, getUserCurrentCarbonAllowanceFetcher, environment, loungeFetcher, parkingFetcher, httpCallService, flightFetcher, hotelFetcher, carhireFetcher, carHireAvailabilityDetailFetcher, cabhireFetcher, railFetcher, irlFetcher, getRailStationFetcher, webTokenService, riskAlertsFetcher, quicklistFetcher, getUserRecentSearchesFetcher, getRailCardsFetcher, eurostarFetcher, searchUsersCanBookForFetcher);
+    }
+}
+/** @nocollapse */ EnterpriseSearchService.ɵprov = i0.ɵɵdefineInjectable({ factory: function EnterpriseSearchService_Factory() { return new EnterpriseSearchService(i0.ɵɵinject(i1.SearchAirportsFetcher), i0.ɵɵinject(i2.SearchAirlinesFetcher), i0.ɵɵinject(i3.StorageService), i0.ɵɵinject(i4.UserService), i0.ɵɵinject(i5.Router), i0.ɵɵinject(i6.HelperRoutines), i0.ɵɵinject(i7.HotelAvalibilityService), i0.ɵɵinject(i8.SearchCityFetcher), i0.ɵɵinject(i9.SearchConfermaCityFetcher), i0.ɵɵinject(i10.SearchPostcodeFetcher), i0.ɵɵinject(i11.SearchRailStationsFetcher), i0.ɵɵinject(i12.SaveUserAddressUpdater), i0.ɵɵinject(i13.UserAddressesFetcher), i0.ɵɵinject(i14.EnterpriseBasketService), i0.ɵɵinject(i15.GetUserCompanyOfficesFetcher), i0.ɵɵinject(i16.SearchHotelChainsFetcher), i0.ɵɵinject(i17.IsPostcodeValidValueTester), i0.ɵɵinject(i18.ConfermaOfficeNamesFetcher), i0.ɵɵinject(i19.DeleteUserAddressUpdater), i0.ɵɵinject(i20.DeleteRecentSearchUpdater), i0.ɵɵinject(i21.SaveRecentSearchUpdater), i0.ɵɵinject(i22.GetUserCurrentCarbonAllowanceFetcher), i0.ɵɵinject(i23.Environment), i0.ɵɵinject(i24.LoungeQuoteFetcher), i0.ɵɵinject(i25.ParkingQuoteFetcher), i0.ɵɵinject(i26.HttpCallService), i0.ɵɵinject(i27.FlightQuoteFetcher), i0.ɵɵinject(i28.HotelQuoteFetcher), i0.ɵɵinject(i29.CarhireQuoteFetcher), i0.ɵɵinject(i30.CarHireAvailabilityDetailFetcher), i0.ɵɵinject(i31.CabhireQuoteFetcher), i0.ɵɵinject(i32.RailQuoteFetcher), i0.ɵɵinject(i33.IrlQuoteFetcher), i0.ɵɵinject(i34.SearchDepotFetcher), i0.ɵɵinject(i35.GetRailStationFetcher), i0.ɵɵinject(i36.WebTokenService), i0.ɵɵinject(i37.GetRiskAlertsFetcher), i0.ɵɵinject(i38.ConfermaQuicklistFetcherType), i0.ɵɵinject(i39.GetUserRecentSearchesFetcher), i0.ɵɵinject(i40.GetRailCardsFetcher), i0.ɵɵinject(i41.EurostarQuoteFetcher), i0.ɵɵinject(i42.SearchUsersCanBookForFetcher)); }, token: EnterpriseSearchService, providedIn: "root" });
+EnterpriseSearchService.decorators = [
+    { type: Injectable, args: [{ providedIn: 'root' },] }
+];
+/** @nocollapse */
+EnterpriseSearchService.ctorParameters = () => [
+    { type: SearchAirportsFetcher },
+    { type: SearchAirlinesFetcher },
+    { type: StorageService },
+    { type: UserService },
+    { type: Router },
+    { type: HelperRoutines },
+    { type: HotelAvalibilityService },
+    { type: SearchCityFetcher },
+    { type: SearchConfermaCityFetcher },
+    { type: SearchPostcodeFetcher },
+    { type: SearchRailStationsFetcher },
+    { type: SaveUserAddressUpdater },
+    { type: UserAddressesFetcher },
+    { type: EnterpriseBasketService },
+    { type: GetUserCompanyOfficesFetcher },
+    { type: SearchHotelChainsFetcher },
+    { type: IsPostcodeValidValueTester },
+    { type: ConfermaOfficeNamesFetcher },
+    { type: DeleteUserAddressUpdater },
+    { type: DeleteRecentSearchUpdater },
+    { type: SaveRecentSearchUpdater },
+    { type: GetUserCurrentCarbonAllowanceFetcher },
+    { type: Environment },
+    { type: LoungeQuoteFetcher },
+    { type: ParkingQuoteFetcher },
+    { type: HttpCallService },
+    { type: FlightQuoteFetcher },
+    { type: HotelQuoteFetcher },
+    { type: CarhireQuoteFetcher },
+    { type: CarHireAvailabilityDetailFetcher },
+    { type: CabhireQuoteFetcher },
+    { type: RailQuoteFetcher },
+    { type: IrlQuoteFetcher },
+    { type: SearchDepotFetcher },
+    { type: GetRailStationFetcher },
+    { type: WebTokenService },
+    { type: GetRiskAlertsFetcher },
+    { type: ConfermaQuicklistFetcherType },
+    { type: GetUserRecentSearchesFetcher },
+    { type: GetRailCardsFetcher },
+    { type: EurostarQuoteFetcher },
+    { type: SearchUsersCanBookForFetcher }
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"search.service.js","sourceRoot":"","sources":["../../../../../../../projects/obtservices/angular/src/lib/vendor/services/search.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAC7C,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAEzC,OAAO,EAAE,qBAAqB,EAAE,MAAM,sCAAsC,CAAC;AAC7E,OAAO,EAAE,oBAAoB,EAAE,MAAM,qCAAqC,CAAC;AAC3E,OAAO,EAAE,gCAAgC,EAAE,MAAM,iDAAiD,CAAC;AACnG,OAAO,EAAE,qBAAqB,EAAE,MAAM,qCAAqC,CAAC;AAC5E,OAAO,EAAE,qBAAqB,EAAE,MAAM,qCAAqC,CAAC;AAC5E,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACnD,OAAO,EAAE,mBAAmB,EAAE,MAAM,mCAAmC,CAAC;AACxE,OAAO,EAAE,mBAAmB,EAAE,MAAM,mCAAmC,CAAC;AACxE,OAAO,EAAE,kBAAkB,EAAE,MAAM,kCAAkC,CAAC;AACtE,OAAO,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAC;AAClE,OAAO,EAAE,iBAAiB,EAAE,MAAM,iCAAiC,CAAC;AACpE,OAAO,EAAE,mBAAmB,EAAE,MAAM,mCAAmC,CAAC;AACxE,OAAO,EAAE,uBAAuB,EAAE,MAAM,8BAA8B,CAAC;AACvE,OAAO,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAC;AAClE,OAAO,EAAE,qBAAqB,EAAE,MAAM,sCAAsC,CAAC;AAC7E,OAAO,EAAE,iBAAiB,EAAE,MAAM,mCAAmC,CAAC;AACtE,OAAO,EAAE,yBAAyB,EAAE,MAAM,4CAA4C,CAAC;AACvF,OAAO,EAAE,yBAAyB,EAAE,MAAM,0CAA0C,CAAC;AACrF,OAAO,EAAE,uBAAuB,EAAE,MAAM,6BAA6B,CAAC;AACtE,OAAO,EAAE,2BAA2B,EAAE,MAAM,kBAAkB,CAAC;AAC/D,OAAO,EAAE,kBAAkB,EAAE,MAAM,kCAAkC,CAAC;AACtE,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACpD,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAErD,OAAO,EAAE,oBAAoB,EAAE,MAAM,oCAAoC,CAAC;AAC1E,OAAO,EAAE,4BAA4B,EAAE,MAAM,8CAA8C,CAAC;AAC5F,OAAO,EAAE,wBAAwB,EAAE,MAAM,yCAAyC,CAAC;AACnF,OAAO,EAAE,0BAA0B,EAAE,MAAM,qCAAqC,CAAC;AAEjF,OAAO,EAAE,0BAA0B,EAAE,MAAM,2CAA2C,CAAC;AACvF,OAAO,EAAE,mBAAmB,EAAE,MAAM,oCAAoC,CAAC;AACzE,OAAO,EAAE,oBAAoB,EAAE,MAAM,oCAAoC,CAAC;AAE1E,OAAO,EAAE,wBAAwB,EAAE,MAAM,yCAAyC,CAAC;AACnF,OAAO,EAAE,yBAAyB,EAAE,MAAM,0CAA0C,CAAC;AACrF,OAAO,EAAE,uBAAuB,EAAE,MAAM,wCAAwC,CAAC;AAsCjF,OAAO,EAAE,sBAAsB,EAAE,MAAM,uCAAuC,CAAC;AAC/E,OAAO,EAAE,kBAAkB,EAAE,MAAM,mCAAmC,CAAC;AACvE,OAAO,EAAE,oCAAoC,EAAE,MAAM,uDAAuD,CAAC;AAC7G,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AACrD,OAAO,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAC;AAChE,OAAO,EAAE,4BAA4B,EAAE,MAAM,wCAAwC,CAAC;AACtF,OAAO,EAAE,4BAA4B,EAAE,MAAM,8CAA8C,CAAC;AAC5F,OAAO,EAAE,4BAA4B,EAAE,MAAM,+CAA+C,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAG7F,MAAM,OAAO,uBAAwB,SAAQ,2BAmC5C;IACC,YACE,qBAA4C,EAC5C,qBAA4C,EAC5C,cAA8B,EAC9B,WAAwB,EACxB,MAAc,EACd,OAAuB,EACvB,uBAAgD,EAChD,aAAgC,EAChC,qBAAgD,EAChD,eAAsC,EACtC,kBAA6C,EAC7C,sBAA8C,EAC9C,oBAA0C,EAC1C,aAAsC,EACtC,4BAA0D,EAC1D,wBAAkD,EAClD,0BAAsD,EACtD,0BAAsD,EACtD,wBAAkD,EAClD,yBAAoD,EACpD,uBAAgD,EAChD,oCAA0E,EAC1E,WAAwB,EACxB,aAAiC,EACjC,cAAmC,EACnC,eAAgC,EAChC,aAAiC,EACjC,YAA+B,EAC/B,cAAmC,EACnC,gCAAkE,EAClE,cAAmC,EACnC,WAA6B,EAC7B,UAA2B,EAC3B,YAAgC,EAChC,qBAA4C,EAC5C,eAAgC,EAChC,iBAAuC,EACvC,gBAA8C,EAC9C,4BAA0D,EAC1D,mBAAwC,EACxC,eAAqC,EACrC,4BAA0D;QAE1D,KAAK,CACH,qBAAqB,EACrB,qBAAqB,EACrB,cAAc,EACd,WAAW,EACX,MAAM,EACN,OAAO,EACP,uBAAuB,EACvB,aAAa,EACb,qBAAqB,EACrB,eAAe,EACf,kBAAkB,EAClB,sBAAsB,EACtB,oBAAoB,EACpB,aAAa,EACb,4BAA4B,EAC5B,wBAAwB,EACxB,0BAA0B,EAC1B,YAAY,EACZ,0BAA0B,EAC1B,wBAAwB,EACxB,yBAAyB,EACzB,uBAAuB,EACvB,oCAAoC,EACpC,WAAW,EACX,aAAa,EACb,cAAc,EACd,eAAe,EACf,aAAa,EACb,YAAY,EACZ,cAAc,EACd,gCAAgC,EAChC,cAAc,EACd,WAAW,EACX,UAAU,EACV,qBAAqB,EACrB,eAAe,EACf,iBAAiB,EACjB,gBAAgB,EAChB,4BAA4B,EAC5B,mBAAmB,EACnB,eAAe,EACf,4BAA4B,CAC7B,CAAC;IACJ,CAAC;;;;YA7HF,UAAU,SAAC,EAAE,UAAU,EAAE,MAAM,EAAE;;;;YA/EzB,qBAAqB;YACrB,qBAAqB;YACrB,cAAc;YARd,WAAW;YACX,MAAM;YAuBN,cAAc;YATd,uBAAuB;YAGvB,iBAAiB;YACjB,yBAAyB;YAFzB,qBAAqB;YAGrB,yBAAyB;YAwDzB,sBAAsB;YAjDtB,oBAAoB;YANpB,uBAAuB;YAOvB,4BAA4B;YAC5B,wBAAwB;YACxB,0BAA0B;YAE1B,0BAA0B;YAI1B,wBAAwB;YACxB,yBAAyB;YACzB,uBAAuB;YAwCvB,oCAAoC;YArDpC,WAAW;YAFX,kBAAkB;YAdlB,mBAAmB;YAOnB,eAAe;YALf,kBAAkB;YAElB,iBAAiB;YAHjB,mBAAmB;YALnB,gCAAgC;YAShC,mBAAmB;YAFnB,gBAAgB;YAoEhB,eAAe;YAHf,kBAAkB;YA1ElB,qBAAqB;YA4ErB,eAAe;YA3Ef,oBAAoB;YA6EpB,4BAA4B;YAC5B,4BAA4B;YAjD5B,mBAAmB;YACnB,oBAAoB;YAiDpB,4BAA4B","sourcesContent":["import { Injectable } from '@angular/core';\r\nimport { UserService } from './user.service';\r\nimport { Router } from '@angular/router';\r\n\r\nimport { GetRailStationFetcher } from '../fetchers/get-rail-station.fetcher';\r\nimport { GetRiskAlertsFetcher } from '../fetchers/get-risk-alerts.fetcher';\r\nimport { CarHireAvailabilityDetailFetcher } from '../fetchers/carhire-availability-detail.fetcher';\r\nimport { SearchAirportsFetcher } from '../fetchers/search-airports-fetcher';\r\nimport { SearchAirlinesFetcher } from '../fetchers/search-airlines-fetcher';\r\nimport { StorageService } from './storage.service';\r\nimport { ParkingQuoteFetcher } from '../fetchers/parking-quote-fetcher';\r\nimport { CarhireQuoteFetcher } from '../fetchers/carhire-quote-fetcher';\r\nimport { FlightQuoteFetcher } from '../fetchers/flight-quote.fetcher';\r\nimport { RailQuoteFetcher } from '../fetchers/rail-quote-fetcher';\r\nimport { HotelQuoteFetcher } from '../fetchers/hotel-quote-fetcher';\r\nimport { CabhireQuoteFetcher } from '../fetchers/cabhire-quote-fetcher';\r\nimport { HotelAvalibilityService } from './hotel-avallibility.service';\r\nimport { HttpCallService } from './../services/http-call.service';\r\nimport { SearchPostcodeFetcher } from '../fetchers/search-postcodes.fetcher';\r\nimport { SearchCityFetcher } from '../fetchers/search-cities.fetcher';\r\nimport { SearchConfermaCityFetcher } from '../fetchers/search-conferma-cities.fetcher';\r\nimport { SearchRailStationsFetcher } from '../fetchers/search-rail-stations.fetcher';\r\nimport { EnterpriseBasketService } from './enterprise-basket.service';\r\nimport { BaseEnterpriseSearchService } from 'obtservices/base';\r\nimport { LoungeQuoteFetcher } from '../fetchers/lounge-quote.fetcher';\r\nimport { HelperRoutines } from '../classes/helpers';\r\nimport { Environment } from '../classes/environment';\r\n\r\nimport { UserAddressesFetcher } from '../fetchers/user-addresses.fetcher';\r\nimport { GetUserCompanyOfficesFetcher } from '../fetchers/get-user-company-offices.fetcher';\r\nimport { SearchHotelChainsFetcher } from '../fetchers/search-hotel-chains.fetcher';\r\nimport { IsPostcodeValidValueTester } from '../testers/postcode-validate.tester';\r\n\r\nimport { ConfermaOfficeNamesFetcher } from '../fetchers/conferma-office-names.fetcher';\r\nimport { GetRailCardsFetcher } from '../fetchers/get-rail-cards.fetcher';\r\nimport { EurostarQuoteFetcher } from '../fetchers/eurostar-quote.fetcher';\r\n\r\nimport { DeleteUserAddressUpdater } from '../updaters/remove-user-address.updater';\r\nimport { DeleteRecentSearchUpdater } from '../updaters/remove-recent-search.updater';\r\nimport { SaveRecentSearchUpdater } from '../updaters/save-recent-search.updater';\r\nimport {\r\n  GetCarHireDepotsGQL,\r\n  GetMultipleHotelsAvailabilityGQL,\r\n  GetUserCompanyOfficesGQL,\r\n  GetRailStationGQL,\r\n  IsPostcodeValidGQL,\r\n  SaveUserAddressGQL,\r\n  SearchAirlinesGQL,\r\n  SearchAirportsGQL,\r\n  SearchCabHireGQL,\r\n  SearchCarHireGQL,\r\n  SearchCitiesGQL,\r\n  SearchConfermaCitiesGQL,\r\n  SearchFlightsV2GQL,\r\n  SearchHotelChainsGQL,\r\n  SearchHotelsGQL,\r\n  SearchLoungesGQL,\r\n  SearchParkingGQL,\r\n  SearchPostcodesGQL,\r\n  SearchRailGQL,\r\n  SearchRailStationsGQL,\r\n  SearchUserAddressGQL,\r\n  GetConfermaOfficeNamesGQL,\r\n  DeleteUserAddressGQL,\r\n  DeleteRecentSearchGQL,\r\n  SaveRecentSearchGQL,\r\n  GetUserCurrentCarbonAllowanceGQL,\r\n  GetRiskAlertsGQL,\r\n  CarHireAvailabilityDetailRequestGQL,\r\n  SearchIrlGQL,\r\n  GetConfermaQuicklistGQL,\r\n  GetUserRecentSearchesGQL,\r\n  GetRailcards,\r\n  GetRailcardsGQL,\r\n  SearchEurostarGQL,\r\n  SearchUserCanBookForGQL\r\n} from '../types/graphql.angular.types';\r\nimport { SaveUserAddressUpdater } from '../updaters/save-user-address.updater';\r\nimport { SearchDepotFetcher } from '../fetchers/search-depots.fetcher';\r\nimport { GetUserCurrentCarbonAllowanceFetcher } from '../fetchers/get-user-current-carbon-allowance.fetcher';\r\nimport { WebTokenService } from './webtoken.service';\r\nimport { IrlQuoteFetcher } from '../fetchers/irl-quote-fetcher';\r\nimport { ConfermaQuicklistFetcherType } from '../fetchers/conferma-quicklist.fetcher';\r\nimport { GetUserRecentSearchesFetcher } from '../fetchers/get-user-recent-searches.fetcher';\r\nimport { SearchUsersCanBookForFetcher } from '../fetchers/search-users-can-book-for-fetcher';\r\n\r\n@Injectable({ providedIn: 'root' })\r\nexport class EnterpriseSearchService extends BaseEnterpriseSearchService<\r\n  SearchPostcodesGQL,\r\n  SearchRailStationsGQL,\r\n  SearchLoungesGQL,\r\n  SearchParkingGQL,\r\n  SearchFlightsV2GQL,\r\n  SearchHotelsGQL,\r\n  SearchCarHireGQL,\r\n  CarHireAvailabilityDetailRequestGQL,\r\n  SearchCabHireGQL,\r\n  SearchAirportsGQL,\r\n  SearchAirlinesGQL,\r\n  GetMultipleHotelsAvailabilityGQL,\r\n  SearchCitiesGQL,\r\n  SearchConfermaCitiesGQL,\r\n  SearchRailGQL,\r\n  SearchIrlGQL,\r\n  SaveUserAddressGQL,\r\n  SearchUserAddressGQL,\r\n  GetUserCompanyOfficesGQL,\r\n  SearchHotelChainsGQL,\r\n  IsPostcodeValidGQL,\r\n  GetCarHireDepotsGQL,\r\n  GetRailStationGQL,\r\n  GetConfermaOfficeNamesGQL,\r\n  DeleteUserAddressGQL,\r\n  DeleteRecentSearchGQL,\r\n  SaveRecentSearchGQL,\r\n  GetUserCurrentCarbonAllowanceGQL,\r\n  GetRiskAlertsGQL,\r\n  GetConfermaQuicklistGQL,\r\n  GetUserRecentSearchesGQL,\r\n  GetRailcardsGQL,\r\n  SearchEurostarGQL,\r\n  SearchUserCanBookForGQL\r\n> {\r\n  constructor(\r\n    searchAirportsFetcher: SearchAirportsFetcher,\r\n    searchAirlinesFetcher: SearchAirlinesFetcher,\r\n    storageService: StorageService,\r\n    userService: UserService,\r\n    router: Router,\r\n    helpers: HelperRoutines,\r\n    hotelAvalibilityService: HotelAvalibilityService,\r\n    citiesFetcher: SearchCityFetcher,\r\n    confermaCitiesFetcher: SearchConfermaCityFetcher,\r\n    postcodeFetcher: SearchPostcodeFetcher,\r\n    railStationFetcher: SearchRailStationsFetcher,\r\n    saveUserAddressUpdater: SaveUserAddressUpdater,\r\n    userAddressesFetcher: UserAddressesFetcher,\r\n    basketService: EnterpriseBasketService,\r\n    getUserCompanyOfficesFetcher: GetUserCompanyOfficesFetcher,\r\n    searchHotelChainsFetcher: SearchHotelChainsFetcher,\r\n    isPostcodeValidValueTester: IsPostcodeValidValueTester,\r\n    confermaOfficeNamesFetcher: ConfermaOfficeNamesFetcher,\r\n    deleteUserAddressUpdater: DeleteUserAddressUpdater,\r\n    deleteRecentSearchUpdater: DeleteRecentSearchUpdater,\r\n    saveRecentSearchUpdater: SaveRecentSearchUpdater,\r\n    getUserCurrentCarbonAllowanceFetcher: GetUserCurrentCarbonAllowanceFetcher,\r\n    environment: Environment,\r\n    loungeFetcher: LoungeQuoteFetcher,\r\n    parkingFetcher: ParkingQuoteFetcher,\r\n    httpCallService: HttpCallService,\r\n    flightFetcher: FlightQuoteFetcher,\r\n    hotelFetcher: HotelQuoteFetcher,\r\n    carhireFetcher: CarhireQuoteFetcher,\r\n    carHireAvailabilityDetailFetcher: CarHireAvailabilityDetailFetcher,\r\n    cabhireFetcher: CabhireQuoteFetcher,\r\n    railFetcher: RailQuoteFetcher,\r\n    irlFetcher: IrlQuoteFetcher,\r\n    depotFetcher: SearchDepotFetcher,\r\n    getRailStationFetcher: GetRailStationFetcher,\r\n    webTokenService: WebTokenService,\r\n    riskAlertsFetcher: GetRiskAlertsFetcher,\r\n    quicklistFetcher: ConfermaQuicklistFetcherType,\r\n    getUserRecentSearchesFetcher: GetUserRecentSearchesFetcher,\r\n    getRailCardsFetcher: GetRailCardsFetcher,\r\n    eurostarFetcher: EurostarQuoteFetcher,\r\n    searchUsersCanBookForFetcher: SearchUsersCanBookForFetcher\r\n  ) {\r\n    super(\r\n      searchAirportsFetcher,\r\n      searchAirlinesFetcher,\r\n      storageService,\r\n      userService,\r\n      router,\r\n      helpers,\r\n      hotelAvalibilityService,\r\n      citiesFetcher,\r\n      confermaCitiesFetcher,\r\n      postcodeFetcher,\r\n      railStationFetcher,\r\n      saveUserAddressUpdater,\r\n      userAddressesFetcher,\r\n      basketService,\r\n      getUserCompanyOfficesFetcher,\r\n      searchHotelChainsFetcher,\r\n      isPostcodeValidValueTester,\r\n      depotFetcher,\r\n      confermaOfficeNamesFetcher,\r\n      deleteUserAddressUpdater,\r\n      deleteRecentSearchUpdater,\r\n      saveRecentSearchUpdater,\r\n      getUserCurrentCarbonAllowanceFetcher,\r\n      environment,\r\n      loungeFetcher,\r\n      parkingFetcher,\r\n      httpCallService,\r\n      flightFetcher,\r\n      hotelFetcher,\r\n      carhireFetcher,\r\n      carHireAvailabilityDetailFetcher,\r\n      cabhireFetcher,\r\n      railFetcher,\r\n      irlFetcher,\r\n      getRailStationFetcher,\r\n      webTokenService,\r\n      riskAlertsFetcher,\r\n      quicklistFetcher,\r\n      getUserRecentSearchesFetcher,\r\n      getRailCardsFetcher,\r\n      eurostarFetcher,\r\n      searchUsersCanBookForFetcher\r\n    );\r\n  }\r\n}\r\n"]}

package/dist/obtservices/esm2015/angular/lib/vendor/services/storage.service.js

@@ -0,0 +1,79 @@
+import { Injectable } from '@angular/core';
+import { BaseStorageService } from 'obtservices/base';
+import * as i0 from "@angular/core";
+export class StorageService extends BaseStorageService {
+    constructor() {
+        super();
+        this._session = {};
+    }
+    getSessionItem(key) {
+        this._session[key] = this._session.hasOwnProperty(key)
+            ? this._session[key]
+            : this.getItem(key, sessionStorage);
+        return this._session[key];
+    }
+    getSessionItemAsList(key) {
+        this._session[key] = this._session.hasOwnProperty(key)
+            ? this._session[key] || null
+            : this.getItem(key, sessionStorage) || [];
+        return this._session[key];
+    }
+    getLocalItem(key) {
+        return this.getItem(key, localStorage);
+    }
+    setSessionItem(key, data) {
+        this._session[key] = data;
+        this.setItem(key, data, sessionStorage);
+    }
+    setLocalItem(key, data) {
+        this.setItem(key, data, localStorage);
+    }
+    removeSessionItem(key) {
+        this.removeItem(key, sessionStorage);
+    }
+    clearSessionData() {
+        this._session = {};
+        const version = sessionStorage.getItem('version');
+        sessionStorage.clear();
+        sessionStorage.setItem('version', version);
+    }
+    /**
+     * @param options.split boolean - will split your data to mulikeys in storage (helps with saving big data bundles);
+     */
+    setItem(key, data, storage) {
+        try {
+            storage.setItem(key, JSON.stringify(data));
+            return true;
+        }
+        catch (e) {
+            console.warn('Session storage overloaded, only 5Mb of data can be saved. Trying to compress data...');
+        }
+    }
+    getItem(key, storage) {
+        try {
+            const item = storage.getItem(key) || '';
+            return JSON.parse(item);
+        }
+        catch (e) {
+            return undefined;
+        }
+    }
+    removeItem(key, storage) {
+        try {
+            delete this._session[key];
+            storage.removeItem(key);
+            return true;
+        }
+        catch (e) {
+            console.warn(`Can not remove item from this ${typeof storage}!`);
+            return false;
+        }
+    }
+}
+/** @nocollapse */ StorageService.ɵprov = i0.ɵɵdefineInjectable({ factory: function StorageService_Factory() { return new StorageService(); }, token: StorageService, providedIn: "root" });
+StorageService.decorators = [
+    { type: Injectable, args: [{ providedIn: 'root' },] }
+];
+/** @nocollapse */
+StorageService.ctorParameters = () => [];
+//# sourceMappingURL=data:application/json;base64,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

package/dist/obtservices/esm2015/angular/lib/vendor/services/user.service.js

@@ -0,0 +1,31 @@
+import { Injectable } from '@angular/core';
+import { UserMessagesFetcher } from '../fetchers/user-message.fetcher';
+import { UserProductsFetcher } from '../fetchers/user-products-fetcher';
+import { UserUiConfigsFetcher } from '../fetchers/user-ui-configs-fetcher';
+import { StorageService } from './storage.service';
+import { BaseUserService } from 'obtservices/base';
+import { HelperRoutines } from '../classes/helpers';
+import * as i0 from "@angular/core";
+import * as i1 from "../fetchers/user-ui-configs-fetcher";
+import * as i2 from "../fetchers/user-products-fetcher";
+import * as i3 from "../fetchers/user-message.fetcher";
+import * as i4 from "./storage.service";
+import * as i5 from "../classes/helpers";
+export class UserService extends BaseUserService {
+    constructor(userUiConfigsFetcher, userProductsFetcher, userMessagesFetcher, storageService, helpers) {
+        super(userUiConfigsFetcher, userProductsFetcher, userMessagesFetcher, storageService, helpers);
+    }
+}
+/** @nocollapse */ UserService.ɵprov = i0.ɵɵdefineInjectable({ factory: function UserService_Factory() { return new UserService(i0.ɵɵinject(i1.UserUiConfigsFetcher), i0.ɵɵinject(i2.UserProductsFetcher), i0.ɵɵinject(i3.UserMessagesFetcher), i0.ɵɵinject(i4.StorageService), i0.ɵɵinject(i5.HelperRoutines)); }, token: UserService, providedIn: "root" });
+UserService.decorators = [
+    { type: Injectable, args: [{ providedIn: 'root' },] }
+];
+/** @nocollapse */
+UserService.ctorParameters = () => [
+    { type: UserUiConfigsFetcher },
+    { type: UserProductsFetcher },
+    { type: UserMessagesFetcher },
+    { type: StorageService },
+    { type: HelperRoutines }
+];
+//# sourceMappingURL=data:application/json;base64,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

package/dist/obtservices/esm2015/angular/lib/vendor/services/webtoken.service.js

@@ -0,0 +1,59 @@
+import { HttpHeaders } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+import { BaseWebTokenService } from 'obtservices/base';
+import { Environment } from '../classes/environment';
+import { ModalOpenerService } from './modal-opener.service';
+import * as moment from 'moment';
+import * as i0 from "@angular/core";
+import * as i1 from "./modal-opener.service";
+import * as i2 from "../classes/environment";
+export class WebTokenService extends BaseWebTokenService {
+    // tslint:disable-next-line: variable-name
+    constructor(modalOpenerService, environment) {
+        super(modalOpenerService, environment);
+        let hidden;
+        let visibilityChange;
+        if (typeof document.hidden !== 'undefined') {
+            // Opera 12.10 and Firefox 18 and later support
+            hidden = 'hidden';
+            visibilityChange = 'visibilitychange';
+        }
+        else if (typeof document.msHidden !== 'undefined') {
+            hidden = 'msHidden';
+            visibilityChange = 'msvisibilitychange';
+        }
+        else if (typeof document.webkitHidden !== 'undefined') {
+            hidden = 'webkitHidden';
+            visibilityChange = 'webkitvisibilitychange';
+        }
+        const handleVisibilityChange = () => {
+            if (!document[hidden]) {
+                this.checkToLogout();
+            }
+        };
+        // Warn if the browser doesn't support addEventListener or the Page Visibility API
+        if (typeof document.addEventListener === 'undefined' ||
+            hidden === undefined) {
+            console.log('This demo requires a browser, such as Google Chrome or Firefox, that supports the Page Visibility API.');
+        }
+        else {
+            // Handle page visibility change
+            document.addEventListener(visibilityChange, handleVisibilityChange, false);
+        }
+    }
+    getHeaders() {
+        this._updateTimer();
+        this.lastUpdated = moment();
+        return new HttpHeaders().set('Authorization', `Bearer ${this._jwtToken || null}`);
+    }
+}
+/** @nocollapse */ WebTokenService.ɵprov = i0.ɵɵdefineInjectable({ factory: function WebTokenService_Factory() { return new WebTokenService(i0.ɵɵinject(i1.ModalOpenerService), i0.ɵɵinject(i2.Environment)); }, token: WebTokenService, providedIn: "root" });
+WebTokenService.decorators = [
+    { type: Injectable, args: [{ providedIn: 'root' },] }
+];
+/** @nocollapse */
+WebTokenService.ctorParameters = () => [
+    { type: ModalOpenerService },
+    { type: Environment }
+];
+//# sourceMappingURL=data:application/json;base64,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

package/dist/obtservices/esm2015/angular/lib/vendor/testers/postcode-validate.tester.js

@@ -0,0 +1,22 @@
+import { Injectable, Inject } from '@angular/core';
+import { ModalOpenerService } from '../services/modal-opener.service';
+import { BaseValidateIsPostcodeValidTester } from 'obtservices/base';
+import { IsPostcodeValidGQL } from '../types/graphql.angular.types';
+import * as i0 from "@angular/core";
+import * as i1 from "../types/graphql.angular.types";
+import * as i2 from "../services/modal-opener.service";
+export class IsPostcodeValidValueTester extends BaseValidateIsPostcodeValidTester {
+    constructor(isPostcodeValidValueGQL, modalService) {
+        super(isPostcodeValidValueGQL, modalService);
+    }
+}
+/** @nocollapse */ IsPostcodeValidValueTester.ɵprov = i0.ɵɵdefineInjectable({ factory: function IsPostcodeValidValueTester_Factory() { return new IsPostcodeValidValueTester(i0.ɵɵinject(i1.IsPostcodeValidGQL), i0.ɵɵinject(i2.ModalOpenerService)); }, token: IsPostcodeValidValueTester, providedIn: "root" });
+IsPostcodeValidValueTester.decorators = [
+    { type: Injectable, args: [{ providedIn: 'root' },] }
+];
+/** @nocollapse */
+IsPostcodeValidValueTester.ctorParameters = () => [
+    { type: IsPostcodeValidGQL, decorators: [{ type: Inject, args: [IsPostcodeValidGQL,] }] },
+    { type: ModalOpenerService }
+];
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicG9zdGNvZGUtdmFsaWRhdGUudGVzdGVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvb2J0c2VydmljZXMvYW5ndWxhci9zcmMvbGliL3ZlbmRvci90ZXN0ZXJzL3Bvc3Rjb2RlLXZhbGlkYXRlLnRlc3Rlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUNuRCxPQUFPLEVBQUUsa0JBQWtCLEVBQUUsTUFBTSxrQ0FBa0MsQ0FBQztBQUN0RSxPQUFPLEVBQUUsaUNBQWlDLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQztBQUNyRSxPQUFPLEVBQUUsa0JBQWtCLEVBQUUsTUFBTSxnQ0FBZ0MsQ0FBQzs7OztBQUVwRSxNQUFNLE9BQU8sMEJBQTJCLFNBQVEsaUNBQXFEO0lBQ25HLFlBRUUsdUJBQTJDLEVBQzNDLFlBQWdDO1FBRWhDLEtBQUssQ0FBQyx1QkFBdUIsRUFBRSxZQUFZLENBQUMsQ0FBQztJQUMvQyxDQUFDOzs7O1lBUkYsVUFBVSxTQUFDLEVBQUUsVUFBVSxFQUFFLE1BQU0sRUFBRTs7OztZQUR6QixrQkFBa0IsdUJBSXRCLE1BQU0sU0FBQyxrQkFBa0I7WUFOckIsa0JBQWtCIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0YWJsZSwgSW5qZWN0IH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XHJcbmltcG9ydCB7IE1vZGFsT3BlbmVyU2VydmljZSB9IGZyb20gJy4uL3NlcnZpY2VzL21vZGFsLW9wZW5lci5zZXJ2aWNlJztcclxuaW1wb3J0IHsgQmFzZVZhbGlkYXRlSXNQb3N0Y29kZVZhbGlkVGVzdGVyIH0gZnJvbSAnb2J0c2VydmljZXMvYmFzZSc7XHJcbmltcG9ydCB7IElzUG9zdGNvZGVWYWxpZEdRTCB9IGZyb20gJy4uL3R5cGVzL2dyYXBocWwuYW5ndWxhci50eXBlcyc7XHJcbkBJbmplY3RhYmxlKHsgcHJvdmlkZWRJbjogJ3Jvb3QnIH0pXHJcbmV4cG9ydCBjbGFzcyBJc1Bvc3Rjb2RlVmFsaWRWYWx1ZVRlc3RlciBleHRlbmRzIEJhc2VWYWxpZGF0ZUlzUG9zdGNvZGVWYWxpZFRlc3RlcjxJc1Bvc3Rjb2RlVmFsaWRHUUw+IHtcclxuICBjb25zdHJ1Y3RvcihcclxuICAgIEBJbmplY3QoSXNQb3N0Y29kZVZhbGlkR1FMKVxyXG4gICAgaXNQb3N0Y29kZVZhbGlkVmFsdWVHUUw6IElzUG9zdGNvZGVWYWxpZEdRTCxcclxuICAgIG1vZGFsU2VydmljZTogTW9kYWxPcGVuZXJTZXJ2aWNlXHJcbiAgKSB7XHJcbiAgICBzdXBlcihpc1Bvc3Rjb2RlVmFsaWRWYWx1ZUdRTCwgbW9kYWxTZXJ2aWNlKTtcclxuICB9XHJcbn1cclxuIl19

package/dist/obtservices/esm2015/angular/lib/vendor/testers/validate-mi-free-value.tester.js

@@ -0,0 +1,22 @@
+import { Injectable, Inject } from '@angular/core';
+import { ModalOpenerService } from '../services/modal-opener.service';
+import { BaseValidateMiFreeValueTester } from 'obtservices/base';
+import { ValidateUserMiFreeValueGQL } from '../types/graphql.angular.types';
+import * as i0 from "@angular/core";
+import * as i1 from "../types/graphql.angular.types";
+import * as i2 from "../services/modal-opener.service";
+export class ValidateMiFreeValueTester extends BaseValidateMiFreeValueTester {
+    constructor(validateMiFreeValueGQL, modalService) {
+        super(validateMiFreeValueGQL, modalService);
+    }
+}
+/** @nocollapse */ ValidateMiFreeValueTester.ɵprov = i0.ɵɵdefineInjectable({ factory: function ValidateMiFreeValueTester_Factory() { return new ValidateMiFreeValueTester(i0.ɵɵinject(i1.ValidateUserMiFreeValueGQL), i0.ɵɵinject(i2.ModalOpenerService)); }, token: ValidateMiFreeValueTester, providedIn: "root" });
+ValidateMiFreeValueTester.decorators = [
+    { type: Injectable, args: [{ providedIn: 'root' },] }
+];
+/** @nocollapse */
+ValidateMiFreeValueTester.ctorParameters = () => [
+    { type: ValidateUserMiFreeValueGQL, decorators: [{ type: Inject, args: [ValidateUserMiFreeValueGQL,] }] },
+    { type: ModalOpenerService }
+];
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmFsaWRhdGUtbWktZnJlZS12YWx1ZS50ZXN0ZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9vYnRzZXJ2aWNlcy9hbmd1bGFyL3NyYy9saWIvdmVuZG9yL3Rlc3RlcnMvdmFsaWRhdGUtbWktZnJlZS12YWx1ZS50ZXN0ZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDbkQsT0FBTyxFQUFFLGtCQUFrQixFQUFFLE1BQU0sa0NBQWtDLENBQUM7QUFDdEUsT0FBTyxFQUFFLDZCQUE2QixFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFDakUsT0FBTyxFQUFFLDBCQUEwQixFQUFFLE1BQU0sZ0NBQWdDLENBQUM7Ozs7QUFFNUUsTUFBTSxPQUFPLHlCQUEwQixTQUFRLDZCQUF5RDtJQUN0RyxZQUVFLHNCQUFrRCxFQUNsRCxZQUFnQztRQUVoQyxLQUFLLENBQUMsc0JBQXNCLEVBQUUsWUFBWSxDQUFDLENBQUM7SUFDOUMsQ0FBQzs7OztZQVJGLFVBQVUsU0FBQyxFQUFFLFVBQVUsRUFBRSxNQUFNLEVBQUU7Ozs7WUFEekIsMEJBQTBCLHVCQUk5QixNQUFNLFNBQUMsMEJBQTBCO1lBTjdCLGtCQUFrQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGFibGUsIEluamVjdCB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xyXG5pbXBvcnQgeyBNb2RhbE9wZW5lclNlcnZpY2UgfSBmcm9tICcuLi9zZXJ2aWNlcy9tb2RhbC1vcGVuZXIuc2VydmljZSc7XHJcbmltcG9ydCB7IEJhc2VWYWxpZGF0ZU1pRnJlZVZhbHVlVGVzdGVyIH0gZnJvbSAnb2J0c2VydmljZXMvYmFzZSc7XHJcbmltcG9ydCB7IFZhbGlkYXRlVXNlck1pRnJlZVZhbHVlR1FMIH0gZnJvbSAnLi4vdHlwZXMvZ3JhcGhxbC5hbmd1bGFyLnR5cGVzJztcclxuQEluamVjdGFibGUoeyBwcm92aWRlZEluOiAncm9vdCcgfSlcclxuZXhwb3J0IGNsYXNzIFZhbGlkYXRlTWlGcmVlVmFsdWVUZXN0ZXIgZXh0ZW5kcyBCYXNlVmFsaWRhdGVNaUZyZWVWYWx1ZVRlc3RlcjxWYWxpZGF0ZVVzZXJNaUZyZWVWYWx1ZUdRTD4ge1xyXG4gIGNvbnN0cnVjdG9yKFxyXG4gICAgQEluamVjdChWYWxpZGF0ZVVzZXJNaUZyZWVWYWx1ZUdRTClcclxuICAgIHZhbGlkYXRlTWlGcmVlVmFsdWVHUUw6IFZhbGlkYXRlVXNlck1pRnJlZVZhbHVlR1FMLFxyXG4gICAgbW9kYWxTZXJ2aWNlOiBNb2RhbE9wZW5lclNlcnZpY2VcclxuICApIHtcclxuICAgIHN1cGVyKHZhbGlkYXRlTWlGcmVlVmFsdWVHUUwsIG1vZGFsU2VydmljZSk7XHJcbiAgfVxyXG59XHJcbiJdfQ==